diff --git a/AGENTS.md b/AGENTS.md
index c64363b35..6166ac3c0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -207,7 +207,6 @@ Each domain has exactly **one** write-owning module (or one tightly-scoped famil
 | Hosted backup binding (`backup/hosted/binding.json`) | `solstone/think/backup/hosted.py` |
 | Convey config (`config/convey.json`) | `solstone/convey/config.py` + `solstone/think/facets.py` |
 | Chat config (`config/chat.json`) | `solstone/apps/chat/config.py` |
-| Vertex credentials (`.config/vertex-credentials.json`) | `solstone/apps/thinking/vertex_credentials.py` |
 | Speaker labels (`chronicle/**/talents/speaker_labels.json`) | `solstone/apps/speakers/attribution.py` |
 | Speaker corrections (`chronicle/**/talents/speaker_corrections.json`) | `solstone/apps/speakers/attribution.py` |
 | Stream identity (`chronicle/**/<seg>/stream.json` marker + `streams/<name>.json` state) | `solstone/think/streams.py` |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 55ecd5659..a39916ebe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@ Format adapted from [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), al
 
 ## [Unreleased]
 
+### Changed
+
+- thinking now has one active brain for every task: bundled local by default, a personal OpenAI, Anthropic, or Google AI Studio key, or an owner-supplied OpenAI-compatible endpoint. legacy split lanes, tier and talent routing, Vertex support, and duplicate cloud-provider adapters have been removed.
+
 ## [0.8.7] - 2026-07-15
 
 ### Added
diff --git a/docs/CORTEX.md b/docs/CORTEX.md
index e0bbd4e97..954da31b3 100644
--- a/docs/CORTEX.md
+++ b/docs/CORTEX.md
@@ -280,25 +280,18 @@ The JSON frontmatter for an agent can include:
 
 ### Model Resolution
 
-Models are resolved automatically by interface:
-1. `providers.generate.provider/model` or `providers.cogitate.provider/model`
-   pins the active brain when present.
-2. If no provider is pinned, managed cloud-key presence is honored in the
-   grandfathered `google` -> `anthropic` -> `openai` order.
-3. If no cloud key is configured and the local runtime is ready, `local` is used.
-4. If no brain is available, the request fails closed.
-
-`providers.contexts` no longer selects provider/model. Its `disabled` and
-`extract` fields remain live talent metadata.
+Generate and cogitate use the single explicit `providers.active` provider/model
+selected in the Thinking app. If it is missing or invalid, the request fails
+closed. Key presence, tiers, backup maps, and talent frontmatter never select a
+different provider or model. Talent `disabled` and `extract` metadata lives in
+the top-level `talent_overrides` map.
 
 ## Agent Providers
 
 The system supports multiple provider identities through
 `solstone/think/providers/__init__.py`:
 
-- **OpenAI** (`solstone/think/providers/openhands.py`): GPT cogitate via OpenHands; generate redispatched to `solstone/think/providers/openai.py`
-- **Google** (`solstone/think/providers/openhands.py`): Gemini cogitate via OpenHands; generate redispatched to `solstone/think/providers/google.py`
-- **Anthropic** (`solstone/think/providers/openhands.py`): Claude cogitate via OpenHands; generate redispatched to `solstone/think/providers/anthropic.py`
+- **OpenAI, Google AI Studio, and Anthropic** (`solstone/think/providers/openhands.py`): one OpenHands/LiteLLM transport for generate and cogitate
 - **Local** (`solstone/think/providers/local.py`): bundled llama-server, BYO OpenAI-compatible endpoint, or confidential local endpoint
 
 Effective providers:
diff --git a/docs/PROVIDERS.md b/docs/PROVIDERS.md
index 6ade0054e..d8b51d423 100644
--- a/docs/PROVIDERS.md
+++ b/docs/PROVIDERS.md
@@ -1,233 +1,168 @@
-# Provider Architecture
-
-This guide describes the provider behavior that ships today. The core code paths
-are `solstone/think/models.py`, `solstone/think/talents.py`,
-`solstone/think/providers/__init__.py`, `solstone/think/providers/openhands.py`,
-and `solstone/think/providers/local.py`.
+# Thinking Provider Architecture
 
-For the broader think pipeline, see `docs/THINK.md`.
-
-## Active Brain Resolution
-
-Solstone runs one active provider/model pair per interface:
-
-- `generate` for single-shot model calls and generators.
-- `cogitate` for tool-using OpenHands runs.
-
-`solstone/think/models.py` owns active-brain resolution. `resolve_provider()`
-checks `providers.<interface>.provider` first, then managed cloud-key presence in
-the grandfathered `google` -> `anthropic` -> `openai` order, then local runtime
-readiness, then the no-brain state. `providers.<interface>.model` can pin the
-model for that interface. Without a model pin, each provider has one default
-model in `DEFAULT_MODEL_BY_PROVIDER`.
-
-`resolve_provider()` intentionally ignores retired routing keys: `tier`,
-`backup`, and `providers.models`. `providers.contexts` no longer steers
-provider/model routing either. Its `disabled` and `extract` fields are still live
-talent metadata because `solstone/think/talent.py` merges exactly those fields
-from `providers.contexts.<context>`.
-
-## Provider Registry
-
-`solstone/think/providers/__init__.py` is the registry. Cloud provider names
-`google`, `openai`, and `anthropic` all resolve to the OpenHands facade module,
-`solstone.think.providers.openhands`; `local` resolves to
-`solstone.think.providers.local`.
-
-The effective provider modules expose the interface that `models.py` and
-`talents.py` call:
-
-- `run_generate()` returns a `GenerateResult`.
-- `run_agenerate()` returns a `GenerateResult` from async callers.
-- `run_cogitate()` runs a tool-using conversation and emits events.
-
-The cloud vendor leaf modules `solstone/think/providers/google.py`,
-`solstone/think/providers/openai.py`, and
-`solstone/think/providers/anthropic.py` implement generate/agenerate only. They
-are not cogitate providers. The OpenHands facade owns cloud cogitate.
-
-## Generate Dispatch
-
-`solstone/think/models.py` resolves the active generate brain, prepares the
-provider-facing schema, calls `provider_mod.run_generate()` or
-`provider_mod.run_agenerate()`, and logs usage centrally.
-
-For cloud generate, `provider_mod` is the OpenHands facade. The facade keeps
-`run_generate()` and `run_agenerate()` as redispatchers: at call time it imports
-the vendor leaf from `_GENERATE_MODULES` in
-`solstone/think/providers/openhands.py` and calls the matching leaf function.
-This keeps vendor-specific transport behavior in the leaf modules while leaving
-the registry stable.
-
-The native cloud leaves remain intentionally thin transport adapters. Solstone
-keeps them because the OpenAI-compatible surfaces do not provide full parity for
-the behavior the generate path needs, including strict/constrained schema support
-and native-provider response details. Anthropic, OpenAI, and Google each keep
-their provider-specific generate implementation in their own module.
-
-For local generate, `solstone/think/providers/local.py` owns both bundled-local
-and configured endpoint traffic. Bundled local posts to the supervisor-owned
-loopback llama-server. A configured local endpoint posts to the owner-supplied
-OpenAI-compatible URL resolved by `solstone/think/providers/local_endpoint.py`.
-
-## Cogitate Dispatch
-
-`solstone/think/talents.py` runs cogitate talents through
-`_execute_with_tools()`. It resolves the provider module through
-`solstone/think/providers/__init__.py` and calls `run_cogitate()`.
-
-For cloud cogitate, `solstone/think/providers/openhands.py` builds and runs the
-OpenHands conversation. For local cogitate,
-`solstone/think/providers/local.py` performs local readiness/admission work and
-then delegates to `openhands.run_cogitate()` with a local OpenAI-compatible
-configuration. This is why local cogitate failures are classified in
-`local.py`, not by a separate local tool-calling engine.
-
-## Local Lanes
-
-The owner-facing provider key is `local`. It has three runtime lanes:
-
-- Bundled local: `solstone/think/providers/local_server.py` manages the
-  loopback llama-server process and `solstone/think/providers/local.py` sends
-  OpenAI-compatible requests to it.
-- BYO local endpoint: `solstone/think/providers/local_endpoint.py` activates the
-  endpoint only when both `providers.local.endpoint_url` and
-  `providers.local.served_model_id` are present. Optional
-  `providers.local.credential` supplies the bearer token. Optional
-  `providers.local.parallel_slots` governs non-confidential BYO admission.
-- Confidential endpoint: `solstone/think/services/spp_transport.py` gates
-  confidential egress and `solstone/think/providers/local.py` uses that transport
-  before provider dispatch.
-
-Bundled local, BYO URL, and confidential local traffic all use an
-OpenAI-compatible request shape. The difference is where the request is sent and
-which readiness, admission, and attestation gates run first.
-
-## Local Admission and Capacity
-
-The `local` provider has one shared admission boundary for governed local lanes:
-the supervisor-owned Qwen server and non-confidential OpenAI-compatible endpoint
-overrides. The confidential-processing lane (`services.confidential` present)
-and every cloud provider bypass this boundary. Bundled-local inference telemetry
-remains bundled-only.
-
-Capacity remains explicit and intentionally small:
-
-| Runtime profile | Serving capacity | Evidence |
-|---|---:|---|
-| Linux floor | 1 | supervisor `ServerTier`; live `/props.total_slots` wins |
-| Linux capable (at least 16 GiB tiering VRAM) | 2 | supervisor `ServerTier`; live `/props.total_slots` wins |
-| Apple mlx-vlm local backend | 1 | conservative explicit default; mlx-vlm on darwin exposes neither `/props` nor `ServerTier` (`solstone/think/providers/local_server.py:185`) |
-| Non-confidential BYO endpoint | configured | journal config `providers.local.parallel_slots`; resolved by `_configured_byo_parallel_slots()` (`solstone/think/providers/local_endpoint.py:68`) after `resolve_local_endpoint()` selects BYO (`solstone/think/providers/local_endpoint.py:84`) |
-
-For bundled local, the provider memoizes capacity once per process. It first
-reads live `/props.total_slots`, then the persisted `health/local.ctx` launch
-profile, then uses one slot when neither source is available. The supervisor
-remains the configuration owner:
-changing a Linux profile's `parallel_slots` changes both
-`llama-server --parallel` and provider admission after journal processes restart.
-Apple stays at one until that runtime exposes a stable capacity contract and a
-separate measurement justifies raising it.
-
-Admission uses one `flock` file per slot under
-`health/local-inference-admission/`. This coordinates independent journal
-processes without a scheduler service or in-memory queue. Waiting async calls
-are cancellation-safe; exceptions and cancellation release acquired locks;
-process exit releases kernel locks. Queue time consumes the caller's existing
-provider deadline, so waiting cannot silently extend a request beyond its
-configured timeout. Cogitate holds one parent permit across model turns, but
-temporarily yields that permit while the OpenHands `sol` tool runs a nested
-`sol` child process. The parent reacquires through the same FIFO admission pool
-before any further model request; failure to reacquire is a terminal
-`local_queue_timeout`.
-
-Every bundled-local attempt appends a content-free JSON record to
-`health/local-inference/YYYYMMDD.jsonl`. These files follow the configured
-`retention.journal_logs.days` policy. Records contain request id, timestamp,
-kind, provider, logical model, runtime profile, serving capacity, evidence
-source, admission slot, client queue wait, timing, token counts, retry index,
-finish reason, outcome, timeout/cancellation flags, and a safe reason code on
-failure. Records never contain prompt text, generated text, messages, schemas,
-images, endpoint URLs, or credentials.
-
-## Honest Failure Semantics
-
-Provider failure is not a routing signal. Solstone does not silently switch to
-another provider when the active brain fails.
-
-- Quota failures are recorded by
-  `solstone/think/providers/state.py::record_quota_failure()` in
-  `health/talents.json` under the active journal root with provider, model, interface,
-  `provider_quota_exceeded`, and `reset_at_ms`.
-- Local endpoint reachability and contract failures are classified by
-  `solstone/think/providers/local_endpoint.py` and
-  `solstone/think/providers/local.py`.
-- Local retry is deliberately narrow in `solstone/think/talents.py`: generate
-  retries once only for `incomplete_json_length` or
-  `local_capacity_exhausted`, and it retries the same local provider.
-- Segment deferral is represented in health JSONL, not by provider switching.
-  `solstone/think/pipeline_health.py` folds segment progress, and
-  `solstone/think/thinking.py` selects sensed-but-not-fully-thought segments for
-  repair.
-
-If the local runtime, model files, RAM gate, loopback server, BYO endpoint, or
-confidential attestation is not ready, Solstone surfaces that recovery reason
-instead of falling back to a cloud provider.
-
-## Live Configuration Keys
-
-Provider configuration lives in `config/journal.json` under the active journal
-root; the canonical reader/writer is `solstone/think/journal_config.py`.
-
-Live routing keys:
-
-- `providers.generate.provider`
-- `providers.generate.model`
-- `providers.cogitate.provider`
-- `providers.cogitate.model`
-
-Live local endpoint keys:
+Solstone is local-first software for personal use. It supports one active
+provider/model profile, configured in Thinking, and never silently switches
+providers. The implementation deliberately has no special Vertex AI, Azure
+OpenAI, Bedrock, or other enterprise-cloud integration.
 
-- `providers.local.endpoint_url`
-- `providers.local.served_model_id`
-- `providers.local.credential`
-- `providers.local.parallel_slots`
+For the broader pipeline, see `docs/THINK.md`.
 
-Live Google backend keys:
+## One Active Brain
 
-- `providers.google_backend`, read by Google provider code for Gemini Developer
-  API versus Vertex behavior.
-- Vertex/ADC credential settings used by `solstone/apps/thinking/routes.py` and
-  `solstone/apps/thinking/vertex_credentials.py`.
+`config/journal.json` stores the selected profile at:
 
-Live managed key storage:
+```json
+{
+  "providers": {
+    "active": {
+      "provider": "local",
+      "model": "local/qwen3.5-4b"
+    }
+  }
+}
+```
+
+`solstone/think/models.py::resolve_provider()` is the only runtime resolver.
+The `generate` and `cogitate` arguments identify the interface being invoked,
+but both resolve the same `providers.active` profile. A missing profile is an
+explicit no-brain state. Key presence and local readiness never choose a
+provider implicitly.
+
+Provider and model overrides are rejected in talent frontmatter, cortex
+requests, batch requests, and direct generate calls. Thinking is the sole
+configuration surface for the active brain. Talent `disabled` and `extract`
+controls are separate metadata under `talent_overrides`; they do not route
+models.
+
+## Supported Owner Choices
+
+The Thinking app exposes five setup choices:
+
+- Bundled local, using Solstone's installed llama-server or mlx-vlm runtime.
+- An owner-supplied OpenAI-compatible URL, model id, and optional bearer key.
+- OpenAI with an owner-supplied API key and model id.
+- Anthropic with an owner-supplied API key and model id.
+- Google AI Studio with an owner-supplied API key and Gemini model id.
+
+The direct cloud options are convenience presets. The arbitrary endpoint is a
+plain compatibility contract: Solstone sends OpenAI-compatible requests, but
+does not add vendor-specific support for whatever sits behind that URL.
+
+Managed personal cloud keys remain journal-local:
 
-- `env.GOOGLE_API_KEY`
-- `env.ANTHROPIC_API_KEY`
 - `env.OPENAI_API_KEY`
+- `env.ANTHROPIC_API_KEY`
+- `env.GOOGLE_API_KEY`
 
-Retired for provider/model routing:
+## Dispatch
 
-- `tier`
-- `backup`
-- `providers.models`
-- `providers.contexts.<context>.provider`
-- `providers.contexts.<context>.model`
+`solstone/think/providers/__init__.py` has a deliberately small registry:
 
-`providers.contexts.<context>.disabled` and
-`providers.contexts.<context>.extract` remain live talent metadata. Do not remove
-those fields as if the whole `providers.contexts` block were inert.
+- `google`, `openai`, and `anthropic` all map to
+  `solstone/think/providers/openhands.py`.
+- `local` maps to `solstone/think/providers/local.py`.
 
-## Adding or Changing Providers
+The effective modules implement:
 
-Provider changes should start from the current registry and active-brain model,
-not from the retired tier/backup system:
+- `run_generate()` for synchronous single-shot generation.
+- `run_agenerate()` for asynchronous single-shot generation.
+- `run_cogitate()` for tool-using OpenHands conversations.
 
-1. Update `solstone/think/providers/__init__.py` for provider identity and
-   metadata.
-2. Implement the effective module surface that the registry points to.
-3. If the provider is cloud generate-only, keep cogitate on the OpenHands facade
-   and add a vendor leaf only for generate/agenerate.
-4. Add one default model in `solstone/think/models.py`.
-5. Add focused provider tests and lane-honesty tests under `tests/`.
-6. Update `docs/THINK.md`, `docs/CORTEX.md`, and this file.
+### Personal cloud
+
+`openhands.py` is the single cloud transport. It builds an OpenHands `LLM` and
+lets LiteLLM translate the request to OpenAI, Anthropic, or Google AI Studio.
+It also normalizes text, usage, finish reasons, and thinking blocks back into
+Solstone's `GenerateResult`.
+
+Generate calls explicitly neutralize OpenHands' agent-oriented defaults and
+then apply only Solstone's requested behavior. The transport preserves:
+
+- sync and async calls;
+- multimodal message content;
+- JSON object and JSON Schema response formats;
+- OpenAI reasoning-effort suffixes;
+- Anthropic and Gemini thinking budgets;
+- normalized usage, resolved model, and finish reason.
+
+Direct OpenAI generation uses the Responses API. Anthropic and Google use chat
+completion through LiteLLM's provider translation. Key/model validation sends
+a tiny request through this same runtime path, so validation can incur a small
+provider charge.
+
+OpenHands/LiteLLM may internally contain code for many providers. That does not
+make them Solstone-supported providers: Solstone exposes no registry entry,
+config, UI, credential flow, or validation path for enterprise integrations.
+
+### Local and arbitrary endpoints
+
+`local.py` remains a thin product-policy wrapper rather than a second general
+cloud adapter. It owns guarantees that OpenHands alone does not provide:
+
+- bundled runtime installation and readiness;
+- context-budget fitting and local schema preparation;
+- Qwen sampling and chat-template controls;
+- cross-process local admission and bounded retry;
+- content-free local inference telemetry;
+- confidential egress/attestation gates;
+- stable local error classification.
+
+Bundled local posts to the supervisor-owned loopback server. A configured
+endpoint uses:
+
+- `providers.local.endpoint_url`
+- `providers.local.served_model_id`
+- `providers.local.credential` (optional)
+- `providers.local.parallel_slots` (optional)
+
+Both generate and cogitate use the endpoint's OpenAI-compatible contract. The
+configured logical provider remains `local`, so the same readiness and safety
+boundary applies without maintaining vendor-specific adapters.
+
+## Local Admission
+
+Bundled local and non-confidential arbitrary endpoints share the governed local
+admission boundary. Cloud and confidential processing bypass it. Capacity is
+kept intentionally small: one slot on the Linux floor and Apple mlx-vlm, two on
+the capable Linux tier, or the explicit `parallel_slots` value for an arbitrary
+endpoint.
+
+Admission uses per-slot `flock` files under
+`health/local-inference-admission/`, coordinating independent journal
+processes. Queue time consumes the caller's existing timeout. Cogitate yields
+its permit while a nested `sol` command runs and reacquires it before the next
+model turn.
+
+Bundled attempts append content-free telemetry to
+`health/local-inference/YYYYMMDD.jsonl`. Records include timing, capacity,
+token counts, retry index, finish reason, and safe failure codes—never prompts,
+responses, schemas, images, URLs, or credentials.
+
+## Failure Semantics
+
+Provider failure is not a routing signal. Solstone surfaces the failure and
+recovery action for the active profile.
+
+- Quota failures are recorded in `health/talents.json`.
+- Endpoint reachability and contract errors are classified by the local
+  endpoint wrapper.
+- Local generate retries once only for narrow capacity/truncation cases, using
+  the same provider.
+- Missing local runtime, model files, RAM, endpoint readiness, or confidential
+  attestation fails closed rather than falling back to cloud.
+
+## Migration Boundary
+
+The Thinking maintenance task collapses legacy `providers.generate` and
+`providers.cogitate` into `providers.active`. If they differ, cogitate wins
+because its model already satisfies the tool-capable interface. A key-only
+legacy install is materialized once in Google, Anthropic, OpenAI order. The task
+selects bundled local when no prior profile or personal cloud key exists. It
+also:
+
+- removes tier, backup, model-map, Google-backend, and Vertex fields;
+- deletes the canonical legacy Vertex credential file;
+- moves `providers.contexts` enable/extract controls to `talent_overrides`;
+- moves Rev.ai/Plaud validation state to `service_key_validation`.
+
+There are no runtime compatibility shims for the retired shapes.
diff --git a/docs/SOLCLI.md b/docs/SOLCLI.md
index e6480a9c4..71fe3ace9 100644
--- a/docs/SOLCLI.md
+++ b/docs/SOLCLI.md
@@ -430,7 +430,7 @@ solstone/
 | `transcripts` | `solstone/apps/transcripts/call.py` | list, read, segments |
 | `support` | `solstone/apps/support/call.py` | register, search, article, create, list, show, reply, attach, feedback, announcements, diagnose |
 | `sol` | `solstone/apps/sol/call.py` | set-name, reset, set-owner, sol-init |
-| `settings` | `solstone/apps/settings/call.py` | keys (show/set/delete), providers show, provider selection, vertex service-account. Provider install moved to `journal install-provider local`. |
+| `settings` | `solstone/apps/settings/call.py` | personal service keys (show/set/delete). Thinking provider selection lives in the Thinking app; local provider install lives at `journal install-provider local`. |
 | `awareness` | `solstone/apps/awareness/call.py` | status, imports, log, log-read |
 | `journal` | `solstone/think/tools/call.py` | search, events, facets, facet (show/create/update/rename/mute/unmute/delete/merge), news, agents, read, imports, import, retention purge, storage-summary |
 
diff --git a/docs/THINK.md b/docs/THINK.md
index 31d638ad2..fb59525fd 100644
--- a/docs/THINK.md
+++ b/docs/THINK.md
@@ -179,13 +179,11 @@ The `journal providers check` command is an ad-hoc provider check CLI. Cortex do
 journal providers check [TASK_FILE] [--provider PROVIDER] [--model MODEL] [--max-tokens N] [-o OUT_FILE]
 ```
 
-Provider resolution lives in `solstone/think/models.py`. Each interface has one
-active brain: explicit `providers.generate` / `providers.cogitate` provider and
-model pins win first, then managed cloud-key presence in `google` -> `anthropic`
--> `openai` order, then local runtime readiness, then the no-thinking-engine
-state. Retired tier, backup, and context provider/model routing keys are ignored
-by provider resolution. Configure managed cloud API keys in the `env` section of
-`journal/config/journal.json`. The `local` provider requires no API key.
+Provider resolution lives in `solstone/think/models.py`. Generate and cogitate
+share the single explicit `providers.active` provider/model selected in the
+Thinking app. There is no key-presence fallback, tier override, backup route, or
+talent-specific provider route. Configure cloud API keys in the `env` section of
+`journal/config/journal.json`; the bundled local provider requires no API key.
 
 ### Provider modules
 
@@ -198,7 +196,7 @@ to `solstone/think/providers/openhands.py` and maps `local` to
 - `run_cogitate()` - Tool-calling execution via `sol call` commands and event streaming
 
 For direct LLM calls, use `think.models.generate()` or `think.models.agenerate()`;
-they route through the active generate brain.
+they route through the active brain.
 
 ## Generator map keys
 
diff --git a/docs/deletion-sites-inventory.md b/docs/deletion-sites-inventory.md
index 43e42be04..98e752e34 100644
--- a/docs/deletion-sites-inventory.md
+++ b/docs/deletion-sites-inventory.md
@@ -113,13 +113,6 @@ Out of scope for this sweep; keep visible because it is a destructive journal-do
 | `solstone/apps/import/call.py:401,437,452` | staged entity review file | merge/create/skip entity review resolution | `staged_path` must exist under `state_dir/entities/staged` | yes (`solstone/apps/import/call.py:402-463`) | no | `⚠️` | review-state cleanup after explicit operator resolution |
 | `solstone/apps/import/call.py:507,583,605` | staged facet review file | skip/apply facet review resolution | `staged_path` must exist under `state_dir/facets/staged` | yes (`solstone/apps/import/call.py:508-615`) | no | `⚠️` | review-state cleanup after explicit operator resolution |
 
-## solstone/apps/settings
-
-| file:line | target | trigger | path validation | audit log | dry-run | class | why |
-| --- | --- | --- | --- | --- | --- | --- | --- |
-| `solstone/apps/settings/routes.py:878` | canonical `journal/.config/vertex-credentials.json` | provider update clears Vertex credentials | stored path must resolve to the canonical credential path before unlink | yes (`solstone/apps/settings/routes.py:892-899`) | no | `⚠️` | config artifact cleanup with a canonical-path guard |
-| `solstone/apps/settings/call.py:511` | canonical `journal/.config/vertex-credentials.json` | `sol call settings vertex clear` | stored path must resolve to the canonical credential path before unlink | no | no | `⚠️` | CLI config cleanup outside the journal-domain sweep |
-
 ## solstone/apps/support
 
 | file:line | target | trigger | path validation | audit log | dry-run | class | why |
diff --git a/pyproject.toml b/pyproject.toml
index b76ddaba6..4ae2f35ba 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -127,7 +127,6 @@ journal-host = [
     "opentelemetry-instrumentation==0.60b1",
     "opentelemetry-instrumentation-threading==0.60b1",
     "opentelemetry-semantic-conventions==0.60b1",
-    "anthropic",
     # 0.6.2 = validated continuous-batching-fix baseline; <0.7 pins it
     # so on-device builds don't float past the soak-validated server-wedge fix.
     "mlx-vlm>=0.6.2,<0.7; sys_platform == 'darwin' and platform_machine == 'arm64'",
diff --git a/scripts/check_journal_io_access.py b/scripts/check_journal_io_access.py
index 7c5c03b06..fb1715b58 100644
--- a/scripts/check_journal_io_access.py
+++ b/scripts/check_journal_io_access.py
@@ -96,7 +96,6 @@ OWNER_FILES: frozenset[str] = frozenset(
         "solstone/apps/speakers/discovery.py",
         "solstone/apps/speakers/owner.py",
         "solstone/apps/speakers/routes.py",
-        "solstone/apps/thinking/vertex_credentials.py",
         "solstone/apps/timeline/maintenance.py",
         "solstone/apps/timeline/talent/segment_summary.py",
         "solstone/apps/import/ingest.py",
diff --git a/solstone/apps/settings/call.py b/solstone/apps/settings/call.py
index c6285f448..f421fe81c 100644
--- a/solstone/apps/settings/call.py
+++ b/solstone/apps/settings/call.py
@@ -23,28 +23,17 @@ _API_KEY_ENV_VARS = [
     "REVAI_ACCESS_TOKEN",
     "PLAUD_ACCESS_TOKEN",
 ]
-_AI_KEY_ENV_VARS = {
-    "GOOGLE_API_KEY",
-    "ANTHROPIC_API_KEY",
-    "OPENAI_API_KEY",
-}
 _SERVICE_KEY_VALIDATION_NAME = {
     "REVAI_ACCESS_TOKEN": "revai",
     "PLAUD_ACCESS_TOKEN": "plaud",
 }
 
 app = typer.Typer(
-    help="Journal settings — keys, providers, transcription, identity, and observer."
+    help="Journal settings — service keys, transcription, identity, and observer."
 )
 
 keys_app = typer.Typer(help="API key management.")
 app.add_typer(keys_app, name="keys")
-providers_app = typer.Typer(help="AI provider configuration.")
-app.add_typer(providers_app, name="providers")
-google_backend_app = typer.Typer(help="Google backend selection.")
-app.add_typer(google_backend_app, name="google-backend")
-vertex_app = typer.Typer(help="Vertex AI service account credentials.")
-app.add_typer(vertex_app, name="vertex-credentials")
 transcribe_app = typer.Typer(help="Transcription backend configuration.")
 app.add_typer(transcribe_app, name="transcribe")
 identity_app = typer.Typer(help="Journal owner identity.")
@@ -97,23 +86,12 @@ def _exit_with(message: str) -> None:
 
 
 def _validate_env_var_or_exit(env_var: str) -> None:
-    if env_var in _AI_KEY_ENV_VARS:
-        typer.echo(
-            "Moved to `sol call thinking keys …` — run that instead.",
-            err=True,
-        )
-        raise typer.Exit(2)
     if env_var not in _API_KEY_ENV_VARS:
         _exit_with(
             f"Invalid env var: {env_var}. Must be one of: {', '.join(_API_KEY_ENV_VARS)}"
         )
 
 
-def _moved_stub(command: str) -> None:
-    typer.echo(f"Moved to `sol call thinking {command}` — run that instead.", err=True)
-    raise typer.Exit(2)
-
-
 @processing_app.command("show")
 @convey_cli
 def processing_show() -> None:
@@ -285,7 +263,7 @@ def keys_clear(
 @convey_cli
 def keys_validate(
     cache_result: bool = typer.Option(
-        False, "--cache-result", help="Persist results to providers.key_validation."
+        False, "--cache-result", help="Persist service-token validation results."
     ),
 ) -> None:
     """Validate all configured API keys without persisting by default."""
@@ -295,106 +273,6 @@ def keys_validate(
     _echo_json({"key_validation": response.get("key_validation", {})})
 
 
-@providers_app.command("show")
-def providers_show(
-    human: bool = typer.Option(False, "--human", help="Print one-line statuses."),
-) -> None:
-    """Moved to ``sol call thinking providers show``."""
-
-    _moved_stub("providers show")
-
-
-@providers_app.command("install")
-def providers_install(
-    name: str = typer.Argument(None, help="Provider name."),
-) -> None:
-    """Moved to `journal install-provider`."""
-    typer.echo("Moved to `journal install-provider` — run that instead.", err=True)
-    raise typer.Exit(2)
-
-
-@providers_app.command("set-local-endpoint")
-def providers_set_local_endpoint(
-    url: str = typer.Option(..., "--url", help="OpenAI-compatible endpoint URL."),
-    model: str = typer.Option(..., "--model", help="Served model id."),
-    credential: str | None = typer.Option(
-        None,
-        "--credential",
-        help="Optional bearer credential for the endpoint.",
-    ),
-) -> None:
-    """Moved to ``sol call thinking set-local-endpoint``."""
-
-    _moved_stub("set-local-endpoint")
-
-
-@providers_app.command("clear-local-endpoint")
-def providers_clear_local_endpoint() -> None:
-    """Moved to ``sol call thinking clear-local-endpoint``."""
-
-    _moved_stub("clear-local-endpoint")
-
-
-@providers_app.command("set-generate")
-def providers_set_generate(
-    provider: str | None = typer.Option(None, "--provider", help="Primary provider."),
-) -> None:
-    """Moved to ``sol call thinking providers set-generate``."""
-
-    _moved_stub("providers set-generate")
-
-
-@providers_app.command("set-cogitate")
-def providers_set_cogitate(
-    provider: str | None = typer.Option(None, "--provider", help="Primary provider."),
-) -> None:
-    """Moved to ``sol call thinking providers set-cogitate``."""
-
-    _moved_stub("providers set-cogitate")
-
-
-@google_backend_app.command("show")
-def google_backend_show() -> None:
-    """Moved to ``sol call thinking google-backend show``."""
-
-    _moved_stub("google-backend show")
-
-
-@google_backend_app.command("set")
-def google_backend_set(
-    backend: str = typer.Argument(..., help="Google backend to use."),
-) -> None:
-    """Moved to ``sol call thinking google-backend set``."""
-
-    _moved_stub("google-backend set")
-
-
-@vertex_app.command("show")
-def vertex_credentials_show() -> None:
-    """Moved to ``sol call thinking vertex-credentials show``."""
-
-    _moved_stub("vertex-credentials show")
-
-
-@vertex_app.command("import")
-def vertex_credentials_import(
-    file_path: str = typer.Argument(..., help="Path to service account JSON."),
-    skip_validation: bool = typer.Option(
-        False, "--skip-validation", help="Skip API validation of credentials."
-    ),
-) -> None:
-    """Moved to ``sol call thinking vertex-credentials import``."""
-
-    _moved_stub("vertex-credentials import")
-
-
-@vertex_app.command("clear")
-def vertex_credentials_clear() -> None:
-    """Moved to ``sol call thinking vertex-credentials clear``."""
-
-    _moved_stub("vertex-credentials clear")
-
-
 @transcribe_app.command("show")
 @convey_cli
 def transcribe_show() -> None:
diff --git a/solstone/apps/settings/routes.py b/solstone/apps/settings/routes.py
index e8c11b671..9b09b30f1 100644
--- a/solstone/apps/settings/routes.py
+++ b/solstone/apps/settings/routes.py
@@ -152,12 +152,7 @@ def _compute_runtime_label() -> str:
 
 
 def _service_key_validation(config: dict[str, Any]) -> dict[str, Any]:
-    providers_config = config.get("providers", {})
-    key_validation = (
-        providers_config.get("key_validation", {})
-        if isinstance(providers_config, dict)
-        else {}
-    )
+    key_validation = config.get("service_key_validation", {})
     if not isinstance(key_validation, dict):
         key_validation = {}
     return {
@@ -211,6 +206,7 @@ def _project_public_config(config: dict[str, Any]) -> dict[str, Any]:
     service_validation = _service_key_validation(config)
     if service_validation:
         projected["key_validation"] = service_validation
+    projected.pop("service_key_validation", None)
     if "env" in projected:
         projected["env"] = {k: bool(v) for k, v in projected["env"].items()}
     projected.pop("providers", None)
@@ -442,10 +438,7 @@ def update_config() -> Any:
                                 config[section][backend_key][nested_key] = new_value
 
             if section == "env" and changed_fields:
-                if "providers" not in config:
-                    config["providers"] = {}
-                if "key_validation" not in config["providers"]:
-                    config["providers"]["key_validation"] = {}
+                key_validation = config.setdefault("service_key_validation", {})
 
                 # Validate service tokens (Rev.ai, Plaud) — not AI providers,
                 # so they use their own validators instead of think.providers.
@@ -469,9 +462,9 @@ def update_config() -> Any:
                             mod = importlib.import_module(module_path)
                             result = mod.validate_token(new_val)
                             result["timestamp"] = datetime.now(timezone.utc).isoformat()
-                            config["providers"]["key_validation"][val_key] = result
+                            key_validation[val_key] = result
                         else:
-                            config["providers"]["key_validation"].pop(val_key, None)
+                            key_validation.pop(val_key, None)
 
             write_journal_config(config)
 
@@ -856,8 +849,7 @@ def validate_all_keys() -> Any:
         with hold_config_lock():
             config = get_journal_config()
             key_validation = _compute_key_validation(config)
-            providers_config = config.setdefault("providers", {})
-            existing = providers_config.setdefault("key_validation", {})
+            existing = config.setdefault("service_key_validation", {})
             for key in ("revai", "plaud"):
                 existing.pop(key, None)
             existing.update(key_validation)
diff --git a/solstone/apps/settings/tests/conftest.py b/solstone/apps/settings/tests/conftest.py
index c8243de05..603a1aa49 100644
--- a/solstone/apps/settings/tests/conftest.py
+++ b/solstone/apps/settings/tests/conftest.py
@@ -45,20 +45,10 @@ def settings_env(tmp_path, monkeypatch):
                     "OPENAI_API_KEY": "test-openai-key",
                 },
                 "providers": {
-                    "generate": {
+                    "active": {
                         "provider": "google",
                         "model": "gemini-flash-latest",
                     },
-                    "cogitate": {
-                        "provider": "openai",
-                        "model": "gpt-5.4-mini",
-                    },
-                    "auth": {
-                        "google": "api_key",
-                        "openai": "api_key",
-                        "anthropic": "platform",
-                    },
-                    "google_backend": "auto",
                     "key_validation": {},
                 },
                 "transcribe": {
diff --git a/solstone/apps/settings/tests/test_call.py b/solstone/apps/settings/tests/test_call.py
deleted file mode 100644
index f99def2aa..000000000
--- a/solstone/apps/settings/tests/test_call.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-"""Static settings CLI command tests not covered by HTTP parity."""
-
-from __future__ import annotations
-
-import pytest
-from typer.testing import CliRunner
-
-from solstone.think.call import call_app
-
-runner = CliRunner()
-
-
-class TestProvidersInstall:
-    @pytest.mark.parametrize("args", [[], ["local"], ["anthropic"]])
-    def test_install_redirects_to_journal_install_provider(self, settings_env, args):
-        settings_env()
-
-        result = runner.invoke(call_app, ["settings", "providers", "install", *args])
-
-        assert result.exit_code != 0
-        combined = result.output + result.stderr
-        assert "journal install-provider" in combined
-
-    @pytest.mark.parametrize("verb", ["uninstall", "disable", "enable", "validate-key"])
-    @pytest.mark.parametrize("name", ["anthropic", "openai", "openhands"])
-    def test_retired_verbs_return_no_such_command(self, settings_env, verb, name):
-        settings_env()
-
-        result = runner.invoke(call_app, ["settings", "providers", verb, name])
-
-        assert result.exit_code != 0
-        assert "No such command" in (result.output + result.stderr)
diff --git a/solstone/apps/settings/workspace.html b/solstone/apps/settings/workspace.html
index ab4b3ad43..beb21cf7e 100644
--- a/solstone/apps/settings/workspace.html
+++ b/solstone/apps/settings/workspace.html
@@ -1109,140 +1109,6 @@ input:checked + .slider:before {
   text-decoration: underline;
 }
 
-.provider-card {
-  border: 1px solid var(--facet-border, #e5e0db);
-  border-radius: 8px;
-  padding: 0.85em;
-  background: #fff;
-}
-
-.provider-card__header {
-  display: flex;
-  align-items: flex-start;
-  justify-content: space-between;
-  gap: 0.75em;
-  margin-bottom: 0.65em;
-}
-
-.provider-card__title {
-  font-weight: 600;
-  color: #333;
-}
-
-.provider-card__pills {
-  display: flex;
-  gap: 0.4em;
-  flex-wrap: wrap;
-  justify-content: flex-end;
-}
-
-.provider-card__badge,
-.provider-card__key-pill {
-  border-radius: 999px;
-  padding: 0.2em 0.55em;
-  font-size: 0.75em;
-  font-weight: 600;
-  white-space: nowrap;
-}
-
-.provider-card__badge[data-tone="ok"],
-.provider-card__key-pill[data-tone="ok"] {
-  background: #dcfce7;
-  color: #166534;
-}
-
-.provider-card__badge[data-tone="progress"],
-.provider-card__badge[data-tone="warn"],
-.provider-card__key-pill[data-tone="progress"],
-.provider-card__key-pill[data-tone="warn"] {
-  background: #fef3c7;
-  color: #92400e;
-}
-
-.provider-card__badge[data-tone="error"],
-.provider-card__key-pill[data-tone="error"] {
-  background: #fee2e2;
-  color: #991b1b;
-}
-
-.provider-card__badge[data-tone="muted"],
-.provider-card__key-pill[data-tone="muted"] {
-  background: #f3f4f6;
-  color: #374151;
-}
-
-.provider-card__meta {
-  display: grid;
-  gap: 0.25em;
-  color: #666;
-  font-size: 0.85em;
-  margin-bottom: 0.75em;
-}
-
-.provider-card__bytes,
-.provider-card__issue {
-  color: #666;
-  font-size: 0.85em;
-  margin-bottom: 0.75em;
-}
-
-.provider-card__issue {
-  color: #856404;
-}
-
-.provider-card__actions {
-  display: flex;
-  align-items: center;
-  gap: 0.5em;
-  flex-wrap: wrap;
-}
-
-.provider-card__actions button,
-.provider-card__menu button {
-  border: 1px solid #d1d5db;
-  background: white;
-  color: #374151;
-  border-radius: 6px;
-  padding: 0.4em 0.75em;
-  font-size: 0.85em;
-  cursor: pointer;
-}
-
-.provider-card__actions button:disabled {
-  color: #999;
-  cursor: default;
-}
-
-.provider-card__menu {
-  position: relative;
-}
-
-.provider-card__menu summary {
-  cursor: pointer;
-  color: #555;
-  font-size: 0.9em;
-}
-
-.provider-card__menu-body {
-  display: grid;
-  gap: 0.35em;
-  position: absolute;
-  right: 0;
-  top: 1.5em;
-  min-width: 8em;
-  padding: 0.45em;
-  border: 1px solid var(--facet-border, #e5e0db);
-  border-radius: 8px;
-  background: #fff;
-  z-index: 3;
-  box-shadow: 0 6px 18px rgba(0,0,0,0.12);
-}
-
-.provider-model-row {
-  align-items: flex-start;
-  margin-top: -0.25em;
-}
-
 /* Backend settings fieldsets */
 .backend-settings {
   border: none;
@@ -2590,7 +2456,7 @@ button:focus:not(:focus-visible) {
         <p class="settings-field-note">
           Gemini combines transcription and enrichment in a single API call, providing
           speaker diarization, emotion detection, and topic extraction automatically.
-          Model selection is handled by the provider settings.
+          Model selection is handled in Thinking.
         </p>
       </fieldset>
 
@@ -3403,7 +3269,7 @@ let solVoiceCategories = [];
 // Reusable per-tab attention indicator. Any tab can opt in by calling
 // setTabAttention('<section>', true) when its content has a problem the
 // user should notice (incompatible backend on the transcription tab,
-// missing API key referenced from the providers tab, etc.) and
+// missing service token referenced by a backend, etc.) and
 // setTabAttention('<section>', false) once the issue clears. Implemented
 // by toggling data-attention on the <button id="tab-{section}"> in the
 // nav; the CSS rule on .settings-nav-item[data-attention="true"]::after
@@ -3922,9 +3788,9 @@ function updateEnvStatus(fieldId, isJournalConfigured, isSystemConfigured) {
       label.appendChild(status);
     }
 
-    // Add validation status for provider keys
+    // Add validation status for transcription/import service tokens.
     const providerName = fieldId.replace('field-env-', '');
-    if (['google', 'openai', 'anthropic', 'revai', 'plaud'].includes(providerName)) {
+    if (['revai', 'plaud'].includes(providerName)) {
       const validation = keyValidationData[providerName];
       const oldValidation = label.querySelector('.key-validation-status');
       if (oldValidation) oldValidation.remove();
@@ -3934,11 +3800,7 @@ function updateEnvStatus(fieldId, isJournalConfigured, isSystemConfigured) {
         validationSpan.className = 'key-validation-status';
         if (validation.valid) {
           validationSpan.className += ' key-status-valid';
-          let validText = ' ✓ Valid';
-          if (providerName === 'google' && validation.backend) {
-            validText += validation.backend === 'vertex' ? ' (Vertex AI)' : ' (AI Studio)';
-          }
-          validationSpan.textContent = validText;
+          validationSpan.textContent = ' ✓ Valid';
         } else {
           validationSpan.className += ' key-status-invalid';
           const errMsg = validation.error || 'Invalid';
diff --git a/solstone/apps/thinking/call.py b/solstone/apps/thinking/call.py
index bec9a1f6b..d8de9f14f 100644
--- a/solstone/apps/thinking/call.py
+++ b/solstone/apps/thinking/call.py
@@ -12,11 +12,8 @@ from typing import Any
 import typer
 
 from solstone.convey.reasons import (
-    FILE_NOT_FOUND,
     INVALID_CONFIG_VALUE,
-    INVALID_JSON_REQUEST,
     INVALID_OPERATION_FOR_STATE,
-    MISSING_REQUIRED_FIELD,
 )
 from solstone.think.convey_client import ConveyClientError, convey_cli, get_client
 
@@ -34,7 +31,6 @@ _AI_ENV_TO_PROVIDER = {
 }
 _PROVIDERS = ("anthropic", "google", "openai", "local")
 _CLOUD_PROVIDERS = ("anthropic", "google", "openai")
-_GOOGLE_BACKENDS = ("auto", "aistudio", "vertex")
 
 # Mirrors solstone.apps.thinking.copy; reconstructed here so this call.py
 # remains a pure Convey HTTP client.
@@ -77,10 +73,6 @@ keys_app = typer.Typer(help="AI key management.")
 app.add_typer(keys_app, name="keys")
 providers_app = typer.Typer(help="AI provider configuration.")
 app.add_typer(providers_app, name="providers")
-google_backend_app = typer.Typer(help="Google backend selection.")
-app.add_typer(google_backend_app, name="google-backend")
-vertex_app = typer.Typer(help="Vertex credentials.")
-app.add_typer(vertex_app, name="vertex-credentials")
 local_app = typer.Typer(help="Local model readiness and setup.")
 app.add_typer(local_app, name="local")
 scout_app = typer.Typer(
@@ -370,7 +362,7 @@ def keys_validate(
         False, "--cache-result", help="Persist results to providers.key_validation."
     ),
 ) -> None:
-    """Validate configured AI keys and Vertex credentials."""
+    """Validate configured AI keys."""
 
     method = "POST" if cache_result else "GET"
     response = _request(method, "/app/thinking/api/validate-keys")
@@ -387,7 +379,7 @@ def providers_show(
     response = _get_providers()
     if human:
         active = response.get("active_lane", {})
-        typer.echo(f"active lane: {active.get('lane', 'advanced')}")
+        typer.echo(f"active lane: {active.get('lane', 'none')}")
         for name, status in sorted(response.get("provider_status", {}).items()):
             issues = status.get("issues", [])
             if issues:
@@ -403,8 +395,7 @@ def providers_show(
             "providers": response.get("providers", []),
             "provider_status": response.get("provider_status", {}),
             "active_lane": response.get("active_lane", {}),
-            "generate": response.get("generate", {}),
-            "cogitate": response.get("cogitate", {}),
+            "active": response.get("active", {}),
             "local_override": response.get("local_override", {}),
             "api_keys": response.get("api_keys", {}),
             "key_validation": response.get("key_validation", {}),
@@ -412,54 +403,45 @@ def providers_show(
     )
 
 
-def _set_provider_type(
-    agent_type: str,
-    provider: str | None,
+def _set_active_provider(
+    provider: str,
     model: str | None,
 ) -> dict[str, Any]:
-    if provider is not None:
-        _validate_provider_or_exit(provider)
-    payload = {
-        key: value
-        for key, value in {
-            "provider": provider,
-            "model": model,
-        }.items()
-        if value is not None
+    _validate_provider_or_exit(provider)
+    if provider == "local":
+        if model is not None:
+            _exit_with("--model is only valid for cloud providers.")
+        local_override = _get_providers().get("local_override", {})
+        lane = "byo" if local_override.get("enabled") else "local"
+    else:
+        lane = "byo"
+    payload: dict[str, object | None] = {
+        "lane": lane,
+        "provider": provider,
+        "model": model,
     }
     try:
         response = _request(
             "POST",
             "/app/thinking/api/providers",
-            json_body={agent_type: payload},
+            json_body=payload,
         )
     except ConveyClientError as err:
         if err.reason_code == INVALID_CONFIG_VALUE.code and err.detail:
             _exit_with(err.detail)
         raise
-    return response.get(agent_type, {})
-
-
-@providers_app.command("set-generate")
-@convey_cli
-def providers_set_generate(
-    provider: str | None = typer.Option(None, "--provider", help="Primary provider."),
-    model: str | None = typer.Option(None, "--model", help="Model override."),
-) -> None:
-    """Set generate provider defaults."""
-
-    _echo_json(_set_provider_type("generate", provider, model))
+    return response.get("active", {})
 
 
-@providers_app.command("set-cogitate")
+@providers_app.command("set-active")
 @convey_cli
-def providers_set_cogitate(
-    provider: str | None = typer.Option(None, "--provider", help="Primary provider."),
+def providers_set_active(
+    provider: str = typer.Option(..., "--provider", help="Active provider."),
     model: str | None = typer.Option(None, "--model", help="Model override."),
 ) -> None:
-    """Set cogitate provider defaults."""
+    """Set the provider and model used for all thinking."""
 
-    _echo_json(_set_provider_type("cogitate", provider, model))
+    _echo_json(_set_active_provider(provider, model))
 
 
 @app.command("set-local-endpoint")
@@ -498,100 +480,6 @@ def clear_local_endpoint() -> None:
     _echo_json(response.get("local_endpoint", response))
 
 
-@google_backend_app.command("show")
-@convey_cli
-def google_backend_show() -> None:
-    """Show Google backend status."""
-
-    providers = _get_providers()
-    _echo_json(
-        {
-            "google_backend": providers.get("google_backend", "auto"),
-            "vertex_credentials_configured": providers.get(
-                "vertex_credentials_configured",
-                False,
-            ),
-            "vertex_credentials_email": providers.get("vertex_credentials_email", ""),
-        }
-    )
-
-
-@google_backend_app.command("set")
-@convey_cli
-def google_backend_set(
-    backend: str = typer.Argument(..., help="Google backend to use."),
-) -> None:
-    """Set the Google provider backend."""
-
-    if backend not in _GOOGLE_BACKENDS:
-        _exit_with(
-            f"Invalid google_backend: {backend}. Must be one of: {', '.join(_GOOGLE_BACKENDS)}"
-        )
-    _request(
-        "POST",
-        "/app/thinking/api/providers",
-        json_body={"google_backend": backend},
-    )
-    _echo_json({"google_backend": backend})
-
-
-@vertex_app.command("show")
-@convey_cli
-def vertex_credentials_show() -> None:
-    """Show Vertex credential status without secrets."""
-
-    providers = _get_providers()
-    validation = providers.get("key_validation", {}).get("google_vertex", {})
-    _echo_json(
-        {
-            "configured": providers.get("vertex_credentials_configured", False),
-            "email": providers.get("vertex_credentials_email", ""),
-            "validation": validation,
-        }
-    )
-
-
-@vertex_app.command("import")
-@convey_cli
-def vertex_credentials_import(
-    file_path: str = typer.Argument(..., help="Path to credentials JSON."),
-    skip_validation: bool = typer.Option(
-        False, "--skip-validation", help="Skip API validation of credentials."
-    ),
-) -> None:
-    """Import Vertex credentials into the journal config."""
-
-    try:
-        response = _request(
-            "POST",
-            "/app/thinking/api/vertex-credentials/import",
-            json_body={"path": file_path, "skip_validation": skip_validation},
-        )
-    except ConveyClientError as err:
-        if err.reason_code == FILE_NOT_FOUND.code:
-            _exit_with(f"Credential file not found: {err.detail}")
-        if err.reason_code == INVALID_JSON_REQUEST.code:
-            _exit_with(f"Invalid JSON in credential file: {err.detail}")
-        if err.reason_code == MISSING_REQUIRED_FIELD.code:
-            _exit_with(f"Missing required fields: {err.detail}")
-        typer.echo(err.error, err=True)
-        raise typer.Exit(1)
-    _echo_json(response)
-
-
-@vertex_app.command("clear")
-@convey_cli
-def vertex_credentials_clear() -> None:
-    """Clear stored Vertex credentials."""
-
-    _request(
-        "POST",
-        "/app/thinking/api/providers",
-        json_body={"vertex_credentials": ""},
-    )
-    _echo_json({"configured": False})
-
-
 @local_app.command("readiness")
 @convey_cli
 def local_readiness() -> None:
diff --git a/solstone/apps/thinking/copy.py b/solstone/apps/thinking/copy.py
index 1316a1c07..1b38bba1a 100644
--- a/solstone/apps/thinking/copy.py
+++ b/solstone/apps/thinking/copy.py
@@ -105,7 +105,6 @@ ACTIVE_LANE_LABELS = {
     "local": "local",
     "confidential": "confidential processing",
     "byo": "your own AI engine",
-    "advanced": "advanced split",
 }
 PROVIDER_LABELS = {
     "anthropic": "Claude",
@@ -122,7 +121,6 @@ STATE_LABELS = {
     "active": "active",
     "available": "available",
     "unavailable": "not ready",
-    "advanced": "split",
     "loading": "loading...",
     "saved": "saved",
     "validating": "validating...",
diff --git a/solstone/apps/thinking/maint/000_unify_provider_config.py b/solstone/apps/thinking/maint/000_unify_provider_config.py
new file mode 100644
index 000000000..0dcb1cc1c
--- /dev/null
+++ b/solstone/apps/thinking/maint/000_unify_provider_config.py
@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+"""Collapse legacy thinking provider routing into one active brain profile."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from solstone.think.journal_config import (
+    hold_config_lock,
+    read_journal_config,
+    write_journal_config,
+)
+from solstone.think.models import DEFAULT_MODEL_BY_PROVIDER
+from solstone.think.utils import get_journal
+
+SUPPORTED_PROVIDERS = frozenset(DEFAULT_MODEL_BY_PROVIDER)
+CLOUD_KEY_ORDER = (
+    ("GOOGLE_API_KEY", "google"),
+    ("ANTHROPIC_API_KEY", "anthropic"),
+    ("OPENAI_API_KEY", "openai"),
+)
+RETIRED_PROVIDER_FIELDS = (
+    "generate",
+    "cogitate",
+    "tier",
+    "backup",
+    "models",
+    "google_backend",
+    "vertex_credentials",
+)
+
+
+def _profile(value: Any) -> dict[str, str] | None:
+    if not isinstance(value, dict):
+        return None
+    provider = value.get("provider")
+    if not isinstance(provider, str) or provider not in SUPPORTED_PROVIDERS:
+        return None
+    model = value.get("model")
+    if not isinstance(model, str) or not model.strip():
+        model = DEFAULT_MODEL_BY_PROVIDER[provider]
+    return {"provider": provider, "model": model.strip()}
+
+
+def _choose_active(
+    config: dict[str, Any], providers: dict[str, Any]
+) -> dict[str, str] | None:
+    for field in ("active", "cogitate", "generate"):
+        profile = _profile(providers.get(field))
+        if profile is not None:
+            return profile
+
+    env = config.get("env", {})
+    if not isinstance(env, dict):
+        env = {}
+    for env_var, provider in CLOUD_KEY_ORDER:
+        if env.get(env_var):
+            return {
+                "provider": provider,
+                "model": DEFAULT_MODEL_BY_PROVIDER[provider],
+            }
+    return {
+        "provider": "local",
+        "model": DEFAULT_MODEL_BY_PROVIDER["local"],
+    }
+
+
+def migrate(config: dict[str, Any], journal: Path) -> bool:
+    changed = False
+    providers = config.get("providers")
+    if not isinstance(providers, dict):
+        providers = {}
+        config["providers"] = providers
+        changed = True
+
+    active = _choose_active(config, providers)
+    if providers.get("active") != active:
+        if active is None:
+            providers.pop("active", None)
+        else:
+            providers["active"] = active
+        changed = True
+
+    legacy_contexts = providers.get("contexts")
+    if isinstance(legacy_contexts, dict) and legacy_contexts:
+        overrides = config.get("talent_overrides")
+        if not isinstance(overrides, dict):
+            overrides = {}
+        for context, value in legacy_contexts.items():
+            if not isinstance(value, dict):
+                continue
+            supported = {
+                key: value[key] for key in ("disabled", "extract") if key in value
+            }
+            if supported and overrides.get(context) != supported:
+                overrides[context] = supported
+                changed = True
+        if overrides and config.get("talent_overrides") != overrides:
+            config["talent_overrides"] = overrides
+            changed = True
+    if "contexts" in providers:
+        providers.pop("contexts")
+        changed = True
+
+    services = config.get("services")
+    confidential = services.get("confidential") if isinstance(services, dict) else None
+    if isinstance(confidential, dict):
+        if "prior_active" not in confidential:
+            prior_provider = confidential.get(
+                "prior_cogitate_provider"
+            ) or confidential.get("prior_generate_provider")
+            confidential["prior_active"] = (
+                {
+                    "provider": prior_provider,
+                    "model": DEFAULT_MODEL_BY_PROVIDER[prior_provider],
+                }
+                if prior_provider in SUPPORTED_PROVIDERS
+                else None
+            )
+            changed = True
+        for field in ("prior_generate_provider", "prior_cogitate_provider"):
+            if field in confidential:
+                confidential.pop(field)
+                changed = True
+
+    for field in RETIRED_PROVIDER_FIELDS:
+        if field in providers:
+            providers.pop(field)
+            changed = True
+
+    validation = providers.get("key_validation")
+    if isinstance(validation, dict):
+        services = config.get("service_key_validation")
+        if not isinstance(services, dict):
+            services = {}
+        for key in ("revai", "plaud"):
+            if key in validation:
+                if services.get(key) != validation[key]:
+                    services[key] = validation[key]
+                validation.pop(key)
+                changed = True
+        if services:
+            if config.get("service_key_validation") != services:
+                config["service_key_validation"] = services
+                changed = True
+        if "google_vertex" in validation:
+            validation.pop("google_vertex")
+            changed = True
+        if not validation:
+            providers.pop("key_validation")
+            changed = True
+
+    vertex_credentials = journal / ".config" / "vertex-credentials.json"
+    if vertex_credentials.exists() or vertex_credentials.is_symlink():
+        vertex_credentials.unlink()
+        changed = True
+
+    return changed
+
+
+def main() -> None:
+    journal = Path(get_journal())
+    with hold_config_lock(journal):
+        config = read_journal_config(journal)
+        if not migrate(config, journal):
+            print("Thinking provider config already unified.")
+            return
+        write_journal_config(config, journal)
+    print("Unified thinking provider config and removed retired provider settings.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/solstone/apps/thinking/maint/__init__.py b/solstone/apps/thinking/maint/__init__.py
new file mode 100644
index 000000000..2728ad55d
--- /dev/null
+++ b/solstone/apps/thinking/maint/__init__.py
@@ -0,0 +1 @@
+"""Thinking app maintenance tasks."""
diff --git a/solstone/apps/thinking/routes.py b/solstone/apps/thinking/routes.py
index 851a48b10..4781fd6c9 100644
--- a/solstone/apps/thinking/routes.py
+++ b/solstone/apps/thinking/routes.py
@@ -6,12 +6,10 @@
 from __future__ import annotations
 
 import copy
-import json
 import logging
 import os
 from collections.abc import Callable
 from datetime import datetime, timezone
-from pathlib import Path
 from typing import Any
 from urllib.parse import urlsplit
 
@@ -21,18 +19,10 @@ from solstone.apps.thinking import copy as thinking_copy
 from solstone.apps.thinking import local_bootstrap, scout_lane
 from solstone.apps.thinking.copy import thinking_copy_payload
 from solstone.apps.thinking.model_tiers import MODEL_TIERS
-from solstone.apps.thinking.vertex_credentials import (
-    delete_vertex_credentials,
-    save_vertex_credentials,
-)
 from solstone.apps.utils import log_app_action
-from solstone.convey import state
 from solstone.convey.readiness_snapshot import build_readiness_snapshot
 from solstone.convey.reasons import (
-    FILE_NOT_FOUND,
-    FILE_READ_FAILED,
     INVALID_CONFIG_VALUE,
-    INVALID_JSON_REQUEST,
     INVALID_OPERATION_FOR_STATE,
     INVALID_REQUEST_VALUE,
     MISSING_REQUEST_BODY,
@@ -48,6 +38,7 @@ from solstone.think.journal_config import (
     write_journal_config,
 )
 from solstone.think.models import (
+    DEFAULT_MODEL_BY_PROVIDER,
     LOCAL_MODEL,
     NO_BRAIN_PROVIDER,
     resolve_provider,
@@ -59,7 +50,6 @@ from solstone.think.providers import (
     validate_key,
     validate_model,
 )
-from solstone.think.providers.google import validate_vertex_credentials
 from solstone.think.providers.local_endpoint import (
     normalize_local_endpoint_url,
     resolve_local_endpoint,
@@ -74,7 +64,7 @@ from solstone.think.services import (
 )
 from solstone.think.services.constants import SERVICE_SPP
 from solstone.think.services.spp_attest.cadence import AttestationSession
-from solstone.think.utils import CorruptConfigError, get_journal
+from solstone.think.utils import CorruptConfigError
 from solstone.think.utils import get_config as get_journal_config
 
 logger = logging.getLogger(__name__)
@@ -337,18 +327,15 @@ def _validate_local_endpoint_url(endpoint_url: str) -> str | Any:
     return normalized
 
 
-def _type_settings(providers_config: dict[str, Any]) -> dict[str, dict[str, Any]]:
-    settings: dict[str, dict[str, Any]] = {}
-    for agent_type in ("generate", "cogitate"):
-        type_config = providers_config.get(agent_type, {})
-        if not isinstance(type_config, dict):
-            type_config = {}
-        provider, model = resolve_provider(agent_type)
-        settings[agent_type] = {
-            "provider": provider,
-            "model": type_config.get("model") or model,
-        }
-    return settings
+def _active_settings(providers_config: dict[str, Any]) -> dict[str, Any]:
+    active_config = providers_config.get("active", {})
+    if not isinstance(active_config, dict):
+        active_config = {}
+    provider, model = resolve_provider("generate")
+    return {
+        "provider": provider,
+        "model": active_config.get("model") or model,
+    }
 
 
 def _lane_for_provider(
@@ -367,27 +354,19 @@ def _lane_for_provider(
 
 
 def _active_lane_payload(
-    type_settings: dict[str, dict[str, Any]],
+    active_settings: dict[str, Any],
     transcribe_config: dict[str, Any],
 ) -> dict[str, Any]:
     endpoint = resolve_local_endpoint()
     local_endpoint_configured = not endpoint.is_bundled
     confidential_provenance_present = spp.confidential_provenance() is not None
-    per_type = {
-        agent_type: _lane_for_provider(
-            str(settings.get("provider") or ""),
-            local_endpoint_configured=local_endpoint_configured,
-            confidential_provenance_present=confidential_provenance_present,
-        )
-        for agent_type, settings in type_settings.items()
-    }
-    lanes = set(per_type.values())
-    active = next(iter(lanes)) if len(lanes) == 1 else "advanced"
+    active = _lane_for_provider(
+        str(active_settings.get("provider") or ""),
+        local_endpoint_configured=local_endpoint_configured,
+        confidential_provenance_present=confidential_provenance_present,
+    )
     return {
         "lane": active,
-        "generate": per_type.get("generate"),
-        "cogitate": per_type.get("cogitate"),
-        "split": active == "advanced",
         "scout_enabled": scout.is_scout_enabled(),
         "scout_provenance_configured": scout.scout_provenance() is not None,
         "confidential_enabled": spp.is_confidential_enabled(),
@@ -426,7 +405,7 @@ def _filtered_ai_key_validation(config: dict[str, Any]) -> dict[str, Any]:
     return {
         key: value
         for key, value in key_validation.items()
-        if key in {"google", "openai", "anthropic", "google_vertex"}
+        if key in {"google", "openai", "anthropic"}
     }
 
 
@@ -440,7 +419,7 @@ def _keys_payload(config: dict[str, Any]) -> dict[str, Any]:
 
 
 def _validation_payload(result: dict[str, Any], **identity: str) -> dict[str, Any]:
-    """Map an adapter validation result to a browser-safe payload.
+    """Map a transport validation result to a browser-safe payload.
 
     The browser `api()` wrapper throws on any top-level `error`, so failures
     carry `message` instead.
@@ -457,6 +436,8 @@ def _compute_ai_key_validation(config: dict[str, Any]) -> dict[str, Any]:
     """Validate configured AI provider keys without mutating config."""
 
     env_config = config.get("env", {})
+    if not isinstance(env_config, dict):
+        env_config = {}
     key_validation: dict[str, Any] = {}
 
     for env_var, provider in AI_ENV_TO_PROVIDER.items():
@@ -466,16 +447,6 @@ def _compute_ai_key_validation(config: dict[str, Any]) -> dict[str, Any]:
             result["timestamp"] = datetime.now(timezone.utc).isoformat()
             key_validation[provider] = result
 
-    providers_config = config.get("providers", {})
-    if providers_config.get("google_backend") == "vertex" and providers_config.get(
-        "vertex_credentials"
-    ):
-        result = validate_vertex_credentials(
-            providers_config["vertex_credentials"],
-        )
-        result["timestamp"] = datetime.now(timezone.utc).isoformat()
-        key_validation["google_vertex"] = result
-
     return key_validation
 
 
@@ -516,20 +487,9 @@ def _provider_payload(config: dict[str, Any], local_model_id: str) -> dict[str,
     if not isinstance(providers_config, dict):
         providers_config = {}
 
-    type_settings = _type_settings(providers_config)
+    active_settings = _active_settings(providers_config)
 
     providers_list = get_provider_list()
-    vertex_creds_path = providers_config.get("vertex_credentials")
-    vertex_creds_configured = False
-    vertex_creds_email = ""
-    if vertex_creds_path and Path(vertex_creds_path).exists():
-        vertex_creds_configured = True
-        try:
-            creds_data = json.loads(Path(vertex_creds_path).read_text())
-            vertex_creds_email = creds_data.get("client_email", "")
-        except Exception:
-            pass
-
     local_status = local_bootstrap.get_state(local_model_id)
     ai_readiness = build_readiness_snapshot(
         local_model_id=local_model_id,
@@ -538,19 +498,15 @@ def _provider_payload(config: dict[str, Any], local_model_id: str) -> dict[str,
 
     return {
         "providers": providers_list,
-        "provider_status": build_provider_status(
-            providers_list,
-            vertex_creds_configured,
-        ),
+        "provider_status": build_provider_status(providers_list),
         "ai_readiness": ai_readiness,
         "active_lane": _active_lane_payload(
-            type_settings,
+            active_settings,
             config.get("transcribe", {})
             if isinstance(config.get("transcribe", {}), dict)
             else {},
         ),
-        "generate": type_settings["generate"],
-        "cogitate": type_settings["cogitate"],
+        "active": active_settings,
         "model_tiers": MODEL_TIERS,
         "byo_models": providers_config.get("byo_models", {}),
         "api_keys": _api_key_status(config),
@@ -558,9 +514,6 @@ def _provider_payload(config: dict[str, Any], local_model_id: str) -> dict[str,
         "local": local_status,
         "local_override": _local_override_payload(config),
         "local_backend": "mlx" if local_bootstrap._is_mlx_backend() else "local",
-        "google_backend": providers_config.get("google_backend", "auto"),
-        "vertex_credentials_configured": vertex_creds_configured,
-        "vertex_credentials_email": vertex_creds_email,
         "scout_enabled": scout.is_scout_enabled(),
     }
 
@@ -822,19 +775,30 @@ def keys() -> Any:
             )
         provider = AI_ENV_TO_PROVIDER[env_var]
 
+        new_value = str(value or "").strip()
         validation = None
+        if new_value:
+            validation = validate_key(provider, new_value)
+            validation["timestamp"] = datetime.now(timezone.utc).isoformat()
         with hold_config_lock():
             config = read_journal_config()
-            env = config.setdefault("env", {})
-            providers_config = config.setdefault("providers", {})
-            key_validation = providers_config.setdefault("key_validation", {})
+            env = config.get("env")
+            if not isinstance(env, dict):
+                env = {}
+                config["env"] = env
+            providers_config = config.get("providers")
+            if not isinstance(providers_config, dict):
+                providers_config = {}
+                config["providers"] = providers_config
+            key_validation = providers_config.get("key_validation")
+            if not isinstance(key_validation, dict):
+                key_validation = {}
+                providers_config["key_validation"] = key_validation
             old_value = env.get(env_var)
-            new_value = str(value or "").strip()
             if new_value:
                 env[env_var] = new_value
                 os.environ[env_var] = new_value
-                validation = validate_key(provider, new_value)
-                validation["timestamp"] = datetime.now(timezone.utc).isoformat()
+                assert validation is not None
                 key_validation[provider] = validation
             else:
                 env.pop(env_var, None)
@@ -871,21 +835,50 @@ def keys() -> Any:
 
 @thinking_bp.route("/api/validate-keys", methods=["GET", "POST"])
 def validate_all_keys() -> Any:
-    """Re-validate configured AI keys and Vertex credentials."""
+    """Re-validate configured AI keys."""
 
     try:
         config = get_journal_config()
+        snapshot_env = config.get("env", {})
+        if not isinstance(snapshot_env, dict):
+            snapshot_env = {}
+        validated_values = {
+            provider: str(snapshot_env.get(env_var) or "").strip()
+            for env_var, provider in AI_ENV_TO_PROVIDER.items()
+        }
         key_validation = _compute_ai_key_validation(config)
         if request.method == "GET":
             return jsonify({"key_validation": key_validation})
 
-        providers_config = config.setdefault("providers", {})
-        existing = providers_config.setdefault("key_validation", {})
-        for key in ("google", "openai", "anthropic", "google_vertex"):
-            existing.pop(key, None)
-        existing.update(key_validation)
-        write_journal_config(config)
-        return jsonify({"success": True, "key_validation": key_validation})
+        with hold_config_lock():
+            config = read_journal_config()
+            providers_config = config.get("providers")
+            if not isinstance(providers_config, dict):
+                providers_config = {}
+                config["providers"] = providers_config
+            existing = providers_config.get("key_validation")
+            if not isinstance(existing, dict):
+                existing = {}
+                providers_config["key_validation"] = existing
+            current_env = config.get("env", {})
+            if not isinstance(current_env, dict):
+                current_env = {}
+            for env_var, provider in AI_ENV_TO_PROVIDER.items():
+                current_value = str(current_env.get(env_var) or "").strip()
+                if current_value != validated_values[provider]:
+                    continue
+                result = key_validation.get(provider)
+                if result is None:
+                    existing.pop(provider, None)
+                else:
+                    existing[provider] = result
+            write_journal_config(config)
+            persisted = {
+                provider: existing[provider]
+                for provider in AI_ENV_TO_PROVIDER.values()
+                if provider in existing
+            }
+        return jsonify({"success": True, "key_validation": persisted})
     except Exception:
         logger.exception("error validating thinking keys")
         return _thinking_operation_failed()
@@ -1113,7 +1106,7 @@ def get_local_provider_status() -> Any:
         local_provider = next(
             provider for provider in providers_list if provider["name"] == "local"
         )
-        provider_status = build_provider_status([local_provider], False)
+        provider_status = build_provider_status([local_provider])
         return jsonify(provider_status["local"])
     except Exception:
         logger.exception("error loading local provider status")
@@ -1139,8 +1132,14 @@ def _remember_byo_model(
     provider: str,
     model: str,
 ) -> None:
-    byo_models = config["providers"].setdefault("byo_models", {})
-    old_model = old_providers.get("byo_models", {}).get(provider)
+    byo_models = config["providers"].get("byo_models")
+    if not isinstance(byo_models, dict):
+        byo_models = {}
+        config["providers"]["byo_models"] = byo_models
+    old_byo_models = old_providers.get("byo_models")
+    if not isinstance(old_byo_models, dict):
+        old_byo_models = {}
+    old_model = old_byo_models.get(provider)
     if old_model != model:
         changed_fields[f"byo_models.{provider}"] = {
             "old": old_model,
@@ -1149,88 +1148,40 @@ def _remember_byo_model(
     byo_models[provider] = model
 
 
-def _fill_remembered_byo_model(
+def _set_active_provider(
     config: dict[str, Any],
     old_providers: dict[str, Any],
     changed_fields: dict[str, Any],
-    agent_type: str,
+    provider: str,
+    model: str | None,
 ) -> None:
-    type_config = config["providers"].get(agent_type, {})
-    if not isinstance(type_config, dict) or "model" in type_config:
-        return
-    provider = type_config.get("provider")
-    if provider not in CLOUD_BYO_PROVIDERS:
-        return
-    model = config["providers"].get("byo_models", {}).get(provider)
-    if not isinstance(model, str) or not model.strip():
-        return
-    model = model.strip()
-    old_type = old_providers.get(agent_type, {})
-    if old_type.get("model") != model:
-        changed_fields[f"{agent_type}.model"] = {
-            "old": old_type.get("model"),
-            "new": model,
-        }
-    type_config["model"] = model
-
-
-def _apply_type_update(
-    config: dict[str, Any],
-    old_providers: dict[str, Any],
-    changed_fields: dict[str, Any],
-    agent_type: str,
-    type_data: dict[str, Any],
-) -> Any | None:
-    if agent_type not in config["providers"]:
-        config["providers"][agent_type] = {}
-    old_type = old_providers.get(agent_type, {})
-
-    if "provider" in type_data:
-        provider = _validate_provider(type_data["provider"])
-        if not isinstance(provider, str):
-            return provider
-        if old_type.get("provider") != provider:
-            changed_fields[f"{agent_type}.provider"] = {
-                "old": old_type.get("provider"),
-                "new": provider,
-            }
-        config["providers"][agent_type]["provider"] = provider
-        if old_type.get("provider") != provider and "model" not in type_data:
-            old_model = config["providers"][agent_type].pop("model", None)
-            if old_model is not None:
-                changed_fields[f"{agent_type}.model"] = {
-                    "old": old_model,
-                    "new": None,
-                }
-
-    if "tier" in type_data:
-        return error_response(
-            INVALID_CONFIG_VALUE,
-            detail=f"{agent_type}.tier is retired; set provider/model instead.",
-        )
+    old_active = old_providers.get("active", {})
+    if not isinstance(old_active, dict):
+        old_active = {}
 
-    if "backup" in type_data:
-        return error_response(
-            INVALID_CONFIG_VALUE,
-            detail=f"{agent_type}.backup is retired; automatic provider switching is disabled.",
-        )
-
-    if "model" in type_data:
-        model = type_data["model"]
-        if not isinstance(model, str) or not model.strip():
-            return error_response(
-                INVALID_CONFIG_VALUE,
-                detail=f"{agent_type}.model must be a non-empty string.",
-            )
-        model = model.strip()
-        if old_type.get("model") != model:
-            changed_fields[f"{agent_type}.model"] = {
-                "old": old_type.get("model"),
-                "new": model,
+    if model is None:
+        if old_active.get("provider") == provider:
+            old_model = old_active.get("model")
+            if isinstance(old_model, str) and old_model.strip():
+                model = old_model.strip()
+        if model is None and provider in CLOUD_BYO_PROVIDERS:
+            remembered_models = config["providers"].get("byo_models")
+            if not isinstance(remembered_models, dict):
+                remembered_models = {}
+            remembered = remembered_models.get(provider)
+            if isinstance(remembered, str) and remembered.strip():
+                model = remembered.strip()
+        if model is None:
+            model = DEFAULT_MODEL_BY_PROVIDER[provider]
+
+    new_active = {"provider": provider, "model": model}
+    for field, value in new_active.items():
+        if old_active.get(field) != value:
+            changed_fields[f"active.{field}"] = {
+                "old": old_active.get(field),
+                "new": value,
             }
-        config["providers"][agent_type]["model"] = model
-
-    return None
+    config["providers"]["active"] = new_active
 
 
 def _lane_provider(request_data: dict[str, Any]) -> str | Any:
@@ -1278,62 +1229,44 @@ def _lane_provider(request_data: dict[str, Any]) -> str | Any:
 @thinking_bp.route("/api/providers", methods=["PUT", "POST"])
 def update_providers() -> Any:
     try:
-        request_data = request.get_json()
-        if not request_data:
+        request_data = request.get_json(silent=True)
+        if not isinstance(request_data, dict) or not request_data:
             return error_response(MISSING_REQUEST_BODY, detail="No data provided")
+        unknown = set(request_data) - {"lane", "provider", "model"}
+        if unknown:
+            return error_response(
+                INVALID_CONFIG_VALUE,
+                detail=f"Unknown provider fields: {', '.join(sorted(unknown))}",
+            )
+        if "lane" not in request_data:
+            return error_response(MISSING_REQUIRED_FIELD, detail="lane")
 
-        config = get_journal_config()
-        old_providers = copy.deepcopy(config.get("providers", {}))
-        config.setdefault("providers", {})
-        changed_fields: dict[str, Any] = {}
+        provider = _lane_provider(request_data)
+        if not isinstance(provider, str):
+            return provider
 
-        for legacy_key in ("tier", "backup", "models"):
-            if legacy_key in request_data:
+        model: str | None = None
+        if "model" in request_data:
+            if request_data["lane"] != "byo" or provider not in CLOUD_BYO_PROVIDERS:
                 return error_response(
                     INVALID_CONFIG_VALUE,
                     detail=(
-                        f"{legacy_key} is retired; configure generate/cogitate "
-                        "provider/model instead."
+                        "model is only valid with cloud BYO providers: "
+                        "anthropic, google, openai."
                     ),
                 )
-        if "contexts" in request_data:
-            return error_response(
-                INVALID_CONFIG_VALUE,
-                detail=(
-                    "providers.contexts routing is retired; use /api/generators "
-                    "for disabled/extract toggles."
-                ),
-            )
-        if "model" in request_data and "lane" not in request_data:
-            return error_response(
-                INVALID_CONFIG_VALUE,
-                detail="model is only valid with lane=byo.",
-            )
-
-        if "lane" in request_data:
-            provider = _lane_provider(request_data)
-            if not isinstance(provider, str):
-                return provider
-            lane_update = {"provider": provider}
-            has_top_level_model = "model" in request_data
-            if has_top_level_model:
-                if request_data["lane"] != "byo":
-                    return error_response(
-                        INVALID_CONFIG_VALUE,
-                        detail="model is only valid with lane=byo for cloud providers.",
-                    )
-                if provider not in CLOUD_BYO_PROVIDERS:
-                    return error_response(
-                        INVALID_CONFIG_VALUE,
-                        detail=(
-                            "model is only valid with cloud BYO providers: "
-                            "anthropic, google, openai."
-                        ),
-                    )
-                model = _validate_top_level_model(request_data["model"])
-                if not isinstance(model, str):
-                    return model
-                lane_update["model"] = model
+            model = _validate_top_level_model(request_data["model"])
+            if not isinstance(model, str):
+                return model
+        with hold_config_lock():
+            config = read_journal_config()
+            providers_config = config.get("providers")
+            if not isinstance(providers_config, dict):
+                providers_config = {}
+                config["providers"] = providers_config
+            old_providers = copy.deepcopy(providers_config)
+            changed_fields: dict[str, Any] = {}
+            if model is not None:
                 _remember_byo_model(
                     config,
                     old_providers,
@@ -1341,116 +1274,14 @@ def update_providers() -> Any:
                     provider,
                     model,
                 )
-            for agent_type in ("generate", "cogitate"):
-                error = _apply_type_update(
-                    config,
-                    old_providers,
-                    changed_fields,
-                    agent_type,
-                    lane_update,
-                )
-                if error is not None:
-                    return error
-                if not has_top_level_model:
-                    _fill_remembered_byo_model(
-                        config,
-                        old_providers,
-                        changed_fields,
-                        agent_type,
-                    )
-
-        for agent_type in ("generate", "cogitate"):
-            if agent_type not in request_data:
-                continue
-            type_data = request_data[agent_type]
-            if not isinstance(type_data, dict):
-                return error_response(INVALID_REQUEST_VALUE, detail=agent_type)
-            error = _apply_type_update(
+            _set_active_provider(
                 config,
                 old_providers,
                 changed_fields,
-                agent_type,
-                type_data,
+                provider,
+                model,
             )
-            if error is not None:
-                return error
-
-        if "google_backend" in request_data:
-            backend = request_data["google_backend"]
-            if backend not in ("auto", "aistudio", "vertex"):
-                return error_response(
-                    INVALID_CONFIG_VALUE,
-                    detail=(
-                        f"Invalid google_backend: {backend}. "
-                        "Must be 'auto', 'aistudio', or 'vertex'."
-                    ),
-                )
-            old_val = old_providers.get("google_backend", "auto")
-            if old_val != backend:
-                changed_fields["google_backend"] = {"old": old_val, "new": backend}
-            config["providers"]["google_backend"] = backend
-
-        if "vertex_credentials" in request_data:
-            vertex_creds_value = request_data["vertex_credentials"]
-            if vertex_creds_value:
-                try:
-                    creds_data = (
-                        json.loads(vertex_creds_value)
-                        if isinstance(vertex_creds_value, str)
-                        else vertex_creds_value
-                    )
-                except json.JSONDecodeError:
-                    return error_response(
-                        INVALID_JSON_REQUEST,
-                        detail="Invalid JSON in vertex_credentials",
-                    )
-                required_fields = (
-                    "type",
-                    "project_id",
-                    "client_email",
-                    "private_key",
-                )
-                missing = [
-                    field for field in required_fields if field not in creds_data
-                ]
-                if missing:
-                    return error_response(
-                        MISSING_REQUIRED_FIELD,
-                        detail=f"Missing required fields: {', '.join(missing)}",
-                    )
-                creds_file = save_vertex_credentials(
-                    creds_data,
-                    Path(state.journal_root),
-                )
-                old_val = old_providers.get("vertex_credentials", "")
-                creds_path_str = str(creds_file)
-                if old_val != creds_path_str:
-                    changed_fields["vertex_credentials"] = {
-                        "old": old_val,
-                        "new": creds_path_str,
-                    }
-                config["providers"]["vertex_credentials"] = creds_path_str
-                validation = validate_vertex_credentials(creds_path_str)
-                config["providers"].setdefault("key_validation", {})
-                config["providers"]["key_validation"]["google_vertex"] = {
-                    **validation,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                }
-            else:
-                old_path = config["providers"].get("vertex_credentials")
-                if old_path:
-                    changed_fields["vertex_credentials"] = {
-                        "old": old_path,
-                        "new": None,
-                    }
-                    delete_vertex_credentials(old_path, Path(state.journal_root))
-                    config["providers"].pop("vertex_credentials", None)
-                    config["providers"].get("key_validation", {}).pop(
-                        "google_vertex",
-                        None,
-                    )
-
-        write_journal_config(config)
+            write_journal_config(config)
         if changed_fields:
             log_app_action(
                 app="thinking",
@@ -1464,65 +1295,6 @@ def update_providers() -> Any:
         return _thinking_operation_failed()
 
 
-@thinking_bp.route("/api/vertex-credentials/import", methods=["POST"])
-def import_vertex_credentials() -> Any:
-    """Import Vertex credentials from a server-side path."""
-
-    try:
-        request_data = request.get_json()
-        if not isinstance(request_data, dict):
-            return error_response(MISSING_REQUEST_BODY, detail="No data provided")
-
-        raw_path = request_data.get("path")
-        if not isinstance(raw_path, str) or not raw_path.strip():
-            return error_response(MISSING_REQUIRED_FIELD, detail="path")
-
-        source = Path(raw_path)
-        if not source.exists():
-            return error_response(FILE_NOT_FOUND, detail=raw_path)
-
-        try:
-            creds_data = json.loads(source.read_text(encoding="utf-8"))
-        except json.JSONDecodeError:
-            return error_response(INVALID_JSON_REQUEST, detail=raw_path)
-        except OSError:
-            return error_response(FILE_READ_FAILED, detail=raw_path)
-
-        required_fields = ("type", "project_id", "client_email", "private_key")
-        missing = [field for field in required_fields if field not in creds_data]
-        if missing:
-            return error_response(
-                MISSING_REQUIRED_FIELD,
-                detail=", ".join(missing),
-            )
-
-        creds_file = save_vertex_credentials(creds_data, Path(get_journal()))
-        config = get_journal_config()
-        config.setdefault("providers", {})
-        config["providers"]["vertex_credentials"] = str(creds_file)
-
-        validation = None
-        if not bool(request_data.get("skip_validation", False)):
-            validation = validate_vertex_credentials(str(creds_file))
-            validation["timestamp"] = datetime.now(timezone.utc).isoformat()
-            config["providers"].setdefault("key_validation", {})
-            config["providers"]["key_validation"]["google_vertex"] = validation
-
-        write_journal_config(config)
-
-        return jsonify(
-            {
-                "configured": True,
-                "email": creds_data.get("client_email", ""),
-                "path": str(creds_file),
-                "validation": validation,
-            }
-        )
-    except Exception:
-        logger.exception("error importing vertex credentials")
-        return _thinking_operation_failed()
-
-
 def _build_generator_info(key: str, info: dict[str, Any]) -> dict[str, Any]:
     return {
         "key": key,
@@ -1562,44 +1334,46 @@ def update_generators() -> Any:
         if not request_data:
             return error_response(MISSING_REQUEST_BODY, detail="No data provided")
 
-        config = get_journal_config()
-        old_providers = copy.deepcopy(config.get("providers", {}))
-        config.setdefault("providers", {})
-        config["providers"].setdefault("contexts", {})
-        old_contexts = old_providers.get("contexts", {})
-        changed_fields: dict[str, Any] = {}
-
         from solstone.think.talent import key_to_context
 
-        for key, updates in request_data.items():
-            if not isinstance(updates, dict):
-                continue
-            context_key = key_to_context(key)
-            ctx_config = config["providers"]["contexts"].get(context_key, {})
-            old_ctx = old_contexts.get(context_key, {})
-            if "disabled" in updates:
-                if not isinstance(updates["disabled"], bool):
-                    return error_response(
-                        INVALID_CONFIG_VALUE,
-                        detail=f"disabled must be boolean for {key}",
-                    )
-                ctx_config["disabled"] = updates["disabled"]
-            if "extract" in updates:
-                if not isinstance(updates["extract"], bool):
-                    return error_response(
-                        INVALID_CONFIG_VALUE,
-                        detail=f"extract must be boolean for {key}",
-                    )
-                ctx_config["extract"] = updates["extract"]
-            if ctx_config:
-                if old_ctx != ctx_config:
-                    changed_fields[f"contexts.{context_key}"] = {
-                        "old": old_ctx if old_ctx else None,
-                        "new": ctx_config,
-                    }
-                config["providers"]["contexts"][context_key] = ctx_config
-
-        write_journal_config(config)
+        with hold_config_lock():
+            config = read_journal_config()
+            contexts = config.get("talent_overrides")
+            if not isinstance(contexts, dict):
+                contexts = {}
+                config["talent_overrides"] = contexts
+            old_contexts = copy.deepcopy(contexts)
+            changed_fields: dict[str, Any] = {}
+
+            for key, updates in request_data.items():
+                if not isinstance(updates, dict):
+                    continue
+                context_key = key_to_context(key)
+                ctx_config = contexts.get(context_key, {})
+                old_ctx = old_contexts.get(context_key, {})
+                if "disabled" in updates:
+                    if not isinstance(updates["disabled"], bool):
+                        return error_response(
+                            INVALID_CONFIG_VALUE,
+                            detail=f"disabled must be boolean for {key}",
+                        )
+                    ctx_config["disabled"] = updates["disabled"]
+                if "extract" in updates:
+                    if not isinstance(updates["extract"], bool):
+                        return error_response(
+                            INVALID_CONFIG_VALUE,
+                            detail=f"extract must be boolean for {key}",
+                        )
+                    ctx_config["extract"] = updates["extract"]
+                if ctx_config:
+                    if old_ctx != ctx_config:
+                        changed_fields[f"contexts.{context_key}"] = {
+                            "old": old_ctx if old_ctx else None,
+                            "new": ctx_config,
+                        }
+                    contexts[context_key] = ctx_config
+
+            write_journal_config(config)
         if changed_fields:
             log_app_action(
                 app="thinking",
diff --git a/solstone/apps/thinking/static/thinking.js b/solstone/apps/thinking/static/thinking.js
index 6179dc111..46fe0a792 100644
--- a/solstone/apps/thinking/static/thinking.js
+++ b/solstone/apps/thinking/static/thinking.js
@@ -434,9 +434,9 @@
   function preselectByoModel(provider, providersPayload) {
     const remembered = String(providersPayload?.byo_models?.[provider] || '').trim();
     if (remembered) return remembered;
-    const generate = providersPayload?.generate || {};
-    const generatedModel = String(generate.model || '').trim();
-    if (generate.provider === provider && generatedModel) return generatedModel;
+    const active = providersPayload?.active || {};
+    const activeModel = String(active.model || '').trim();
+    if (active.provider === provider && activeModel) return activeModel;
     const lite = byoTierList(provider, providersPayload).find((tier) => tier?.tier === 'lite');
     return String(lite?.model || '').trim();
   }
@@ -778,11 +778,9 @@
   }
 
   function defaultByoProvider() {
-    const generateProvider = state.providers.generate?.provider || '';
-    const cogitateProvider = state.providers.cogitate?.provider || '';
-    if (localEndpointConfigured() && (generateProvider === 'local' || cogitateProvider === 'local')) return 'local';
-    if (providerEnv[generateProvider]) return generateProvider;
-    if (providerEnv[cogitateProvider]) return cogitateProvider;
+    const activeProvider = state.providers.active?.provider || '';
+    if (localEndpointConfigured() && activeProvider === 'local') return 'local';
+    if (providerEnv[activeProvider]) return activeProvider;
     if (localEndpointConfigured() && configuredProviders().length === 0) return 'local';
     if (state.providers.scout_enabled) return 'google';
     return configuredProviders()[0] || 'anthropic';
@@ -841,19 +839,16 @@
   }
 
   function activeBrain() {
-    const lane = state.providers.active_lane?.lane || 'advanced';
-    const generateProvider = state.providers.generate?.provider || '';
-    const cogitateProvider = state.providers.cogitate?.provider || '';
-    const byoProvider = generateProvider !== 'local' ? generateProvider : cogitateProvider || generateProvider;
+    const lane = state.providers.active_lane?.lane || 'none';
+    const provider = state.providers.active?.provider || '';
     const byoUsable = byoIsUsable();
-    const advancedUsable = lane === 'advanced' && !!generateProvider && !!cogitateProvider;
 
     if (lane === 'byo' && byoUsable) {
       return {
         kind: 'byo',
-        byoKind: byoKindForProvider(byoProvider),
-        provider: byoProvider,
-        providerLabel: providerLabel(byoProvider),
+        byoKind: byoKindForProvider(provider),
+        provider,
+        providerLabel: providerLabel(provider),
       };
     }
     if (lane === 'local' && localIsReady()) {
@@ -862,14 +857,6 @@
     if (lane === 'confidential' && confidentialProvenancePresent()) {
       return {kind: 'confidential', providerLabel: 'Confidential processing'};
     }
-    if (advancedUsable) {
-      return {
-        kind: 'advanced',
-        generateProvider,
-        cogitateProvider,
-        providerLabel: 'Advanced split',
-      };
-    }
     return {kind: 'none', providerLabel: ''};
   }
 
@@ -911,7 +898,7 @@
       const key = `byo_${brain.byoKind || 'key'}`;
       const row = glanceCopy[key] || {};
       const model = brain.byoKind === 'key'
-        ? byoModelLabel(brain.provider, state.providers.generate?.model || '', state.providers)
+        ? byoModelLabel(brain.provider, state.providers.active?.model || '', state.providers)
         : '';
       setText('thinkingActiveLane', glanceCopy.lane_label || 'sol is thinking with');
       setText('thinkingActiveValue', formatCopy(row.value, {provider: brain.providerLabel, model}));
@@ -928,13 +915,6 @@
       setText('thinkingActiveLane', row.label || '');
       setText('thinkingActiveValue', row.value || '');
       setText('thinkingActiveDetail', row.detail || '');
-    } else if (brain.kind === 'advanced') {
-      setText('thinkingActiveLane', 'sol is thinking with');
-      setText('thinkingActiveValue', 'an advanced split');
-      setText(
-        'thinkingActiveDetail',
-        `generate uses ${providerLabel(brain.generateProvider)}; cogitate uses ${providerLabel(brain.cogitateProvider)}`,
-      );
     } else {
       const row = glanceCopy.none || {};
       setText('thinkingActiveValue', row.value || activeLaneLabel('none'));
@@ -1349,26 +1329,6 @@
     }
   }
 
-  function populateProviderSelect(select, selected) {
-    if (!select) return;
-    select.innerHTML = '';
-    for (const provider of state.providers.providers || []) {
-      const option = document.createElement('option');
-      option.value = provider.name;
-      option.textContent = providerLabels[provider.name] || provider.label || provider.name;
-      select.appendChild(option);
-    }
-    select.value = selected || '';
-  }
-
-  function renderAdvanced() {
-    populateProviderSelect($('field-generate-provider'), state.providers.generate?.provider);
-    populateProviderSelect($('field-cogitate-provider'), state.providers.cogitate?.provider);
-    if ($('field-google-backend')) {
-      $('field-google-backend').value = state.providers.google_backend || 'auto';
-    }
-  }
-
   function setSelectedByoProvider(provider) {
     state.selectedByoProvider = provider || defaultByoProvider();
     const select = $('byoProvider');
@@ -1407,7 +1367,7 @@
     const providerName = providerLabel(provider);
     const checked = relativeTime(validation?.timestamp) || relativeTime(new Date().toISOString());
     const selected = state.byoSelectedModel || (state.byoCustomOpen ? '' : preselectByoModel(provider, state.providers));
-    const activeModel = state.providers.generate?.provider === provider ? state.providers.generate?.model || '' : '';
+    const activeModel = state.providers.active?.provider === provider ? state.providers.active?.model || '' : '';
     const rows = byoTierRows(provider, state.providers, activeModel, byoText);
     const catalogModels = new Set(rows.map((row) => row.model).filter(Boolean));
     const selectedIsCustom = !!selected && !catalogModels.has(selected);
@@ -1848,7 +1808,6 @@
   function renderAll() {
     renderGlance();
     renderMainLanes();
-    renderAdvanced();
     renderByo();
     renderLocalEndpoint();
     renderScout();
@@ -2282,45 +2241,6 @@
     }
   }
 
-  async function saveAdvanced(agentType, field, value) {
-    const payload = {[agentType]: {[field]: value}};
-    state.providers = await api('api/providers', {
-      method: 'PUT',
-      body: JSON.stringify(payload),
-    });
-    setMessage('advancedStatus', 'saved', 'ok');
-    renderAll();
-  }
-
-  async function saveGoogleBackend() {
-    state.providers = await api('api/providers', {
-      method: 'PUT',
-      body: JSON.stringify({google_backend: $('field-google-backend')?.value || 'auto'}),
-    });
-    setMessage('vertexStatus', 'backend saved', 'ok');
-    renderAll();
-  }
-
-  async function saveVertexCredentials() {
-    const value = $('vertexCredsInput')?.value || '';
-    state.providers = await api('api/providers', {
-      method: 'PUT',
-      body: JSON.stringify({vertex_credentials: value}),
-    });
-    if ($('vertexCredsInput')) $('vertexCredsInput').value = '';
-    setMessage('vertexStatus', 'credentials saved', 'ok');
-    renderAll();
-  }
-
-  async function clearVertexCredentials() {
-    state.providers = await api('api/providers', {
-      method: 'PUT',
-      body: JSON.stringify({vertex_credentials: ''}),
-    });
-    setMessage('vertexStatus', 'credentials cleared', 'ok');
-    renderAll();
-  }
-
   async function saveLocalEndpoint() {
     const payload = {
       endpoint_url: $('localEndpointUrl')?.value || '',
@@ -2508,11 +2428,6 @@
         refreshInstallStatus({autoResume: true}),
       ]).catch((err) => setMessage('localSetupMessage', err.message, 'error'));
     });
-    $('field-generate-provider')?.addEventListener('change', (event) => saveAdvanced('generate', 'provider', event.target.value).catch((err) => setMessage('advancedStatus', err.message, 'error')));
-    $('field-cogitate-provider')?.addEventListener('change', (event) => saveAdvanced('cogitate', 'provider', event.target.value).catch((err) => setMessage('advancedStatus', err.message, 'error')));
-    $('field-google-backend')?.addEventListener('change', () => saveGoogleBackend().catch((err) => setMessage('vertexStatus', err.message, 'error')));
-    $('vertexSave')?.addEventListener('click', () => saveVertexCredentials().catch((err) => setMessage('vertexStatus', err.message, 'error')));
-    $('vertexClear')?.addEventListener('click', () => clearVertexCredentials().catch((err) => setMessage('vertexStatus', err.message, 'error')));
     $('localEndpointSave')?.addEventListener('click', () => saveLocalEndpoint().catch((err) => setMessage('localEndpointStatus', err.message, 'error')));
     $('localEndpointClear')?.addEventListener('click', () => clearLocalEndpoint().catch((err) => setMessage('localEndpointStatus', err.message, 'error')));
     $('localEndpointClearFromLocal')?.addEventListener('click', () => clearLocalEndpoint().catch((err) => setMessage('localEndpointStatus', err.message, 'error')));
diff --git a/solstone/apps/thinking/tests/conftest.py b/solstone/apps/thinking/tests/conftest.py
index 256bec205..0c48b3822 100644
--- a/solstone/apps/thinking/tests/conftest.py
+++ b/solstone/apps/thinking/tests/conftest.py
@@ -91,20 +91,10 @@ def settings_env(tmp_path, monkeypatch):
                     "OPENAI_API_KEY": "test-openai-key",
                 },
                 "providers": {
-                    "generate": {
+                    "active": {
                         "provider": "google",
                         "model": "gemini-flash-latest",
                     },
-                    "cogitate": {
-                        "provider": "openai",
-                        "model": "gpt-5.4-mini",
-                    },
-                    "auth": {
-                        "google": "api_key",
-                        "openai": "api_key",
-                        "anthropic": "platform",
-                    },
-                    "google_backend": "auto",
                     "key_validation": {},
                 },
                 "transcribe": {
diff --git a/solstone/apps/thinking/tests/test_confidential_routes.py b/solstone/apps/thinking/tests/test_confidential_routes.py
index a189e3eab..f5ec9bc8f 100644
--- a/solstone/apps/thinking/tests/test_confidential_routes.py
+++ b/solstone/apps/thinking/tests/test_confidential_routes.py
@@ -240,8 +240,10 @@ def test_disable_confidential_restores_synchronously(
     assert data["service"] == "spp"
     assert data["result"] == {"was_enabled": True, "credential_preserved": False}
     config = _read_config(journal_copy)
-    assert config["providers"]["generate"]["provider"] == "google"
-    assert config["providers"]["cogitate"]["provider"] == "openai"
+    assert config["providers"]["active"] == {
+        "provider": "google",
+        "model": "gemini-flash-latest",
+    }
     assert config["providers"]["local"] == {}
     assert "confidential" not in config["services"]
     state = spp.get_attestation_state()
diff --git a/solstone/apps/thinking/tests/test_keys_check_route.py b/solstone/apps/thinking/tests/test_keys_check_route.py
index 479770996..41235f61b 100644
--- a/solstone/apps/thinking/tests/test_keys_check_route.py
+++ b/solstone/apps/thinking/tests/test_keys_check_route.py
@@ -128,11 +128,7 @@ def test_keys_check_invalid_candidate_does_not_change_active_lane(
     client, journal_path = settings_client_with_journal
     config = _read_config(journal_path)
     config["env"]["ANTHROPIC_API_KEY"] = "working-key-a"
-    config["providers"]["generate"] = {
-        "provider": "anthropic",
-        "model": "claude-opus-4-8",
-    }
-    config["providers"]["cogitate"] = {
+    config["providers"]["active"] = {
         "provider": "anthropic",
         "model": "claude-opus-4-8",
     }
diff --git a/solstone/apps/thinking/tests/test_local_bootstrap_routes.py b/solstone/apps/thinking/tests/test_local_bootstrap_routes.py
index 28bbfc4b5..6480887aa 100644
--- a/solstone/apps/thinking/tests/test_local_bootstrap_routes.py
+++ b/solstone/apps/thinking/tests/test_local_bootstrap_routes.py
@@ -38,8 +38,7 @@ def _settings_config() -> dict:
     return {
         "setup": {"completed_at": 1700000000000},
         "providers": {
-            "generate": {"provider": "google", "model": "gemini-flash-latest"},
-            "cogitate": {"provider": "openai", "model": "gpt-5.4-mini"},
+            "active": {"provider": "google", "model": "gemini-flash-latest"},
             "auth": {"google": "api_key", "openai": "api_key"},
         },
     }
diff --git a/solstone/apps/thinking/tests/test_provider_config_migration.py b/solstone/apps/thinking/tests/test_provider_config_migration.py
new file mode 100644
index 000000000..391ab59ef
--- /dev/null
+++ b/solstone/apps/thinking/tests/test_provider_config_migration.py
@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+from __future__ import annotations
+
+import importlib
+
+from solstone.think.models import CLAUDE_SONNET_4, LOCAL_MODEL
+
+migration = importlib.import_module(
+    "solstone.apps.thinking.maint.000_unify_provider_config"
+)
+
+
+def test_migration_prefers_cogitate_and_removes_legacy_provider_state(tmp_path):
+    secret = tmp_path / ".config" / "vertex-credentials.json"
+    secret.parent.mkdir()
+    secret.write_text("secret", encoding="utf-8")
+    config = {
+        "providers": {
+            "generate": {"provider": "google", "model": "gemini-custom"},
+            "cogitate": {"provider": "anthropic", "model": "claude-custom"},
+            "tier": 2,
+            "backup": "openai",
+            "models": {"google": {"2": "old"}},
+            "contexts": {
+                "talent.timeline.segment_summary": {
+                    "provider": "openai",
+                    "tier": 3,
+                    "disabled": True,
+                    "extract": False,
+                }
+            },
+            "google_backend": "vertex",
+            "vertex_credentials": str(secret),
+            "key_validation": {
+                "google": {"valid": True},
+                "google_vertex": {"valid": True},
+                "revai": {"valid": True},
+            },
+        }
+    }
+
+    assert migration.migrate(config, tmp_path) is True
+
+    assert config["providers"] == {
+        "active": {"provider": "anthropic", "model": "claude-custom"},
+        "key_validation": {"google": {"valid": True}},
+    }
+    assert config["talent_overrides"] == {
+        "talent.timeline.segment_summary": {
+            "disabled": True,
+            "extract": False,
+        }
+    }
+    assert config["service_key_validation"] == {"revai": {"valid": True}}
+    assert not secret.exists()
+    assert migration.migrate(config, tmp_path) is False
+
+
+def test_migration_materializes_key_only_personal_cloud_config(tmp_path):
+    config = {"env": {"ANTHROPIC_API_KEY": "key"}, "providers": {}}
+
+    assert migration.migrate(config, tmp_path) is True
+    assert config["providers"]["active"] == {
+        "provider": "anthropic",
+        "model": CLAUDE_SONNET_4,
+    }
+
+
+def test_migration_materializes_local_default_and_removes_broken_vertex_link(tmp_path):
+    secret = tmp_path / ".config" / "vertex-credentials.json"
+    secret.parent.mkdir()
+    secret.symlink_to(tmp_path / "missing-secret")
+    config = {}
+
+    assert migration.migrate(config, tmp_path) is True
+    assert config["providers"]["active"] == {
+        "provider": "local",
+        "model": LOCAL_MODEL,
+    }
+    assert not secret.is_symlink()
+    assert migration.migrate(config, tmp_path) is False
+
+
+def test_migration_recovers_malformed_legacy_env_and_profile(tmp_path):
+    config = {
+        "env": ["not", "a", "mapping"],
+        "providers": {"generate": {"provider": ["not", "hashable"]}},
+    }
+
+    assert migration.migrate(config, tmp_path) is True
+    assert config["providers"] == {
+        "active": {"provider": "local", "model": LOCAL_MODEL}
+    }
+
+
+def test_migration_preserves_confidential_restore_profile(tmp_path):
+    config = {
+        "providers": {
+            "generate": {"provider": "local"},
+            "cogitate": {"provider": "local"},
+        },
+        "services": {
+            "confidential": {
+                "prior_generate_provider": "google",
+                "prior_cogitate_provider": "anthropic",
+            }
+        },
+    }
+
+    assert migration.migrate(config, tmp_path) is True
+    assert config["providers"]["active"] == {
+        "provider": "local",
+        "model": LOCAL_MODEL,
+    }
+    assert config["services"]["confidential"] == {
+        "prior_active": {
+            "provider": "anthropic",
+            "model": CLAUDE_SONNET_4,
+        }
+    }
diff --git a/solstone/apps/thinking/tests/test_providers_payload_extended.py b/solstone/apps/thinking/tests/test_providers_payload_extended.py
index dd4dc35ec..9ab891234 100644
--- a/solstone/apps/thinking/tests/test_providers_payload_extended.py
+++ b/solstone/apps/thinking/tests/test_providers_payload_extended.py
@@ -138,7 +138,7 @@ def test_get_providers_includes_local_install_state(settings_client):
     _assert_install_status(payload["local"])
 
 
-def test_get_providers_reports_byo_when_split_cloud_providers_share_lane(
+def test_get_providers_reports_active_personal_cloud_lane(
     settings_client,
 ):
     response = settings_client.get("/app/thinking/api/providers")
@@ -146,7 +146,10 @@ def test_get_providers_reports_byo_when_split_cloud_providers_share_lane(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "byo"
-    assert payload["active_lane"]["split"] is False
+    assert payload["active"] == {
+        "provider": "google",
+        "model": "gemini-flash-latest",
+    }
 
 
 def test_get_providers_reports_none_lane_when_no_engine_selected(
@@ -173,25 +176,27 @@ def test_get_providers_reports_none_lane_when_no_engine_selected(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == NO_BRAIN_PROVIDER
-    assert payload["active_lane"]["split"] is False
+    assert payload["active"]["provider"] == NO_BRAIN_PROVIDER
 
 
-def test_get_providers_reports_advanced_when_generate_and_cogitate_lanes_split(
+def test_get_providers_reports_one_profile_for_both_interfaces(
     settings_client_with_journal,
 ):
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"]["provider"] = "local"
-    config["providers"]["cogitate"]["provider"] = "openai"
+    config["providers"]["active"] = {
+        "provider": "openai",
+        "model": "gpt-5.4-mini",
+    }
     _write_config(journal_path, config)
 
     response = client.get("/app/thinking/api/providers")
 
     assert response.status_code == 200
     payload = response.get_json()
-    assert payload["active_lane"]["lane"] == "advanced"
-    assert payload["active_lane"]["split"] is True
+    assert payload["active_lane"]["lane"] == "byo"
+    assert payload["active"] == config["providers"]["active"]
 
 
 def test_provider_update_rejects_context_payload(settings_client_with_journal):
@@ -205,68 +210,7 @@ def test_provider_update_rejects_context_payload(settings_client_with_journal):
     assert response.status_code != 200
     payload = response.get_json()
     assert payload["reason_code"] == "invalid_config_value"
-    assert "providers.contexts routing is retired" in payload["detail"]
-
-
-@pytest.mark.parametrize(
-    "payload",
-    [
-        {"tier": 2},
-        {"backup": "anthropic"},
-        {"models": {"google": {"3": "gemini-flash-lite-latest"}}},
-        {"generate": {"tier": 2}},
-        {"cogitate": {"backup": "anthropic"}},
-    ],
-)
-def test_provider_update_rejects_retired_routing_keys(
-    settings_client_with_journal,
-    payload,
-):
-    client, journal_path = settings_client_with_journal
-    config_path = journal_path / "config" / "journal.json"
-    before = config_path.read_bytes()
-
-    response = client.put("/app/thinking/api/providers", json=payload)
-
-    assert response.status_code == 400
-    body = response.get_json()
-    assert body["reason_code"] == "invalid_config_value"
-    assert "retired" in body["detail"]
-    assert config_path.read_bytes() == before
-
-
-def test_provider_update_preserves_legacy_models_on_success(
-    settings_client_with_journal,
-):
-    client, journal_path = settings_client_with_journal
-    config_path = journal_path / "config" / "journal.json"
-    config = json.loads(config_path.read_text(encoding="utf-8"))
-    legacy_models = {
-        "google": {
-            "2": "legacy-flash",
-            "3": "legacy-lite",
-        },
-    }
-    config["providers"]["models"] = legacy_models.copy()
-    _write_config(journal_path, config)
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={
-            "generate": {
-                "provider": "anthropic",
-                "model": "claude-sonnet-4-6",
-            }
-        },
-    )
-
-    assert response.status_code == 200
-    stored = json.loads(config_path.read_text(encoding="utf-8"))
-    assert stored["providers"]["models"] == legacy_models
-    assert stored["providers"]["generate"] == {
-        "provider": "anthropic",
-        "model": "claude-sonnet-4-6",
-    }
+    assert payload["detail"] == "Unknown provider fields: contexts"
 
 
 def test_scout_enabled_google_provider_derives_byo_with_provenance(
@@ -280,8 +224,10 @@ def test_scout_enabled_google_provider_derives_byo_with_provenance(
         "enabled_at": "2026-05-23T00:00:00Z",
         "key_fingerprint_sha256": "fingerprint",
     }
-    config["providers"]["generate"]["provider"] = "google"
-    config["providers"]["cogitate"]["provider"] = "google"
+    config["providers"]["active"] = {
+        "provider": "google",
+        "model": "gemini-flash-latest",
+    }
     _write_config(journal_path, config)
 
     response = client.get("/app/thinking/api/providers")
@@ -289,8 +235,6 @@ def test_scout_enabled_google_provider_derives_byo_with_provenance(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "byo"
-    assert payload["active_lane"]["generate"] == "byo"
-    assert payload["active_lane"]["cogitate"] == "byo"
     assert payload["active_lane"]["scout_enabled"] is True
     assert payload["active_lane"]["scout_provenance_configured"] is True
 
@@ -369,6 +313,41 @@ def test_key_save_preserves_remembered_byo_model(
     assert stored["providers"]["byo_models"] == {"openai": "gpt-5.5"}
 
 
+def test_validate_all_does_not_cache_result_for_a_concurrently_replaced_key(
+    settings_client_with_journal,
+    monkeypatch,
+):
+    client, journal_path = settings_client_with_journal
+    config_path = journal_path / "config" / "journal.json"
+    current = json.loads(config_path.read_text())
+    current["env"]["GOOGLE_API_KEY"] = "new-key"
+    current["providers"]["key_validation"]["google"] = {
+        "valid": True,
+        "timestamp": "new-key-result",
+    }
+    _write_config(journal_path, current)
+    stale = json.loads(json.dumps(current))
+    stale["env"]["GOOGLE_API_KEY"] = "old-key"
+    monkeypatch.setattr(
+        "solstone.apps.thinking.routes.get_journal_config",
+        lambda: stale,
+    )
+    monkeypatch.setattr(
+        "solstone.apps.thinking.routes.validate_key",
+        lambda _provider, _api_key: {"valid": False, "error": "old key"},
+    )
+
+    response = client.post("/app/thinking/api/validate-keys")
+
+    assert response.status_code == 200
+    stored = json.loads(config_path.read_text())
+    assert stored["providers"]["key_validation"]["google"] == {
+        "valid": True,
+        "timestamp": "new-key-result",
+    }
+    assert response.get_json()["key_validation"]["google"]["valid"] is True
+
+
 def test_thinking_status_payloads_are_secret_free_with_scout_provenance(
     settings_client_with_journal, monkeypatch
 ):
@@ -409,15 +388,16 @@ def test_thinking_status_payloads_are_secret_free_with_scout_provenance(
         "served_model_id": "confidential-model",
         "credential_created_at": "2026-05-24T00:00:00Z",
         "credential_fingerprint_sha256": "confidential-fingerprint-secret",
-        "prior_generate_provider": "google",
-        "prior_cogitate_provider": "openai",
+        "prior_active": {"provider": "google", "model": "gemini-flash-latest"},
         "prior_local_endpoint": None,
     }
     config.setdefault("providers", {}).setdefault("local", {})["credential"] = (
         "confidential-credential-secret"
     )
-    config["providers"]["generate"]["provider"] = "google"
-    config["providers"]["cogitate"]["provider"] = "google"
+    config["providers"]["active"] = {
+        "provider": "google",
+        "model": "gemini-flash-latest",
+    }
     _write_config(journal_path, config)
 
     monkeypatch.setattr(
@@ -452,9 +432,6 @@ def test_thinking_status_payloads_are_secret_free_with_scout_provenance(
     providers_payload = responses[0].get_json()
     assert providers_payload["active_lane"] == {
         "lane": "byo",
-        "generate": "byo",
-        "cogitate": "byo",
-        "split": False,
         "scout_enabled": True,
         "scout_provenance_configured": True,
         "confidential_enabled": True,
@@ -563,8 +540,7 @@ def test_local_endpoint_override_derives_byo_and_bundled_derives_local(
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"]["provider"] = "local"
-    config["providers"]["cogitate"]["provider"] = "local"
+    config["providers"]["active"] = {"provider": "local", "model": LOCAL_MODEL}
     _write_config(journal_path, config)
 
     response = client.get("/app/thinking/api/providers")
@@ -587,8 +563,6 @@ def test_local_endpoint_override_derives_byo_and_bundled_derives_local(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "byo"
-    assert payload["active_lane"]["generate"] == "byo"
-    assert payload["active_lane"]["cogitate"] == "byo"
 
 
 def test_local_endpoint_override_derives_confidential_only_with_provenance(
@@ -598,8 +572,7 @@ def test_local_endpoint_override_derives_confidential_only_with_provenance(
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"]["provider"] = "local"
-    config["providers"]["cogitate"]["provider"] = "local"
+    config["providers"]["active"] = {"provider": "local", "model": LOCAL_MODEL}
     config["providers"]["local"] = {
         "endpoint_url": "http://host.test:8080/v1",
         "served_model_id": "served-model",
@@ -616,8 +589,6 @@ def test_local_endpoint_override_derives_confidential_only_with_provenance(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "byo"
-    assert payload["active_lane"]["generate"] == "byo"
-    assert payload["active_lane"]["cogitate"] == "byo"
     assert payload["active_lane"]["confidential_provenance_configured"] is False
 
     config.setdefault("services", {})["confidential"] = {
@@ -627,8 +598,7 @@ def test_local_endpoint_override_derives_confidential_only_with_provenance(
         "served_model_id": "served-model",
         "credential_created_at": "2026-05-24T00:00:00Z",
         "credential_fingerprint_sha256": "fingerprint",
-        "prior_generate_provider": "google",
-        "prior_cogitate_provider": "openai",
+        "prior_active": {"provider": "google", "model": "gemini-flash-latest"},
         "prior_local_endpoint": None,
     }
     _write_config(journal_path, config)
@@ -638,8 +608,6 @@ def test_local_endpoint_override_derives_confidential_only_with_provenance(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "confidential"
-    assert payload["active_lane"]["generate"] == "confidential"
-    assert payload["active_lane"]["cogitate"] == "confidential"
     assert payload["active_lane"]["confidential_enabled"] is True
     assert payload["active_lane"]["confidential_provenance_configured"] is True
 
@@ -714,8 +682,7 @@ def test_byo_local_with_override_succeeds_and_rederives_byo(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "byo"
-    assert payload["generate"]["provider"] == "local"
-    assert payload["cogitate"]["provider"] == "local"
+    assert payload["active"]["provider"] == "local"
 
 
 def test_byo_endpoint_switch_never_remembers_local_model(
@@ -745,7 +712,7 @@ def test_byo_endpoint_switch_never_remembers_local_model(
     assert "local" not in stored["providers"].get("byo_models", {})
 
 
-def test_byo_lane_with_top_level_model_writes_types_and_memory(
+def test_byo_lane_with_top_level_model_writes_active_profile_and_memory(
     settings_client_with_journal,
 ):
     client, journal_path = settings_client_with_journal
@@ -762,22 +729,14 @@ def test_byo_lane_with_top_level_model_writes_types_and_memory(
 
     assert response.status_code == 200
     payload = response.get_json()
-    assert payload["generate"] == {
-        "provider": "anthropic",
-        "model": "claude-opus-4-8",
-    }
-    assert payload["cogitate"] == {
+    assert payload["active"] == {
         "provider": "anthropic",
         "model": "claude-opus-4-8",
     }
     assert payload["byo_models"]["anthropic"] == "claude-opus-4-8"
 
     stored = json.loads(config_path.read_text())
-    assert stored["providers"]["generate"] == {
-        "provider": "anthropic",
-        "model": "claude-opus-4-8",
-    }
-    assert stored["providers"]["cogitate"] == {
+    assert stored["providers"]["active"] == {
         "provider": "anthropic",
         "model": "claude-opus-4-8",
     }
@@ -787,13 +746,9 @@ def test_byo_lane_with_top_level_model_writes_types_and_memory(
 @pytest.mark.parametrize(
     ("payload", "detail"),
     [
-        (
-            {"model": "gemini-pro-latest"},
-            "model is only valid with lane=byo.",
-        ),
         (
             {"lane": "local", "model": "gemini-pro-latest"},
-            "model is only valid with lane=byo for cloud providers.",
+            "model is only valid with cloud BYO providers: anthropic, google, openai.",
         ),
         (
             {"lane": "byo", "provider": "google", "model": ""},
@@ -861,11 +816,7 @@ def test_byo_lane_fills_remembered_model_after_hygiene_pop(
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"] = {
-        "provider": "google",
-        "model": "gemini-pro-latest",
-    }
-    config["providers"]["cogitate"] = {
+    config["providers"]["active"] = {
         "provider": "google",
         "model": "gemini-pro-latest",
     }
@@ -879,11 +830,7 @@ def test_byo_lane_fills_remembered_model_after_hygiene_pop(
 
     assert response.status_code == 200
     stored = json.loads(config_path.read_text())
-    assert stored["providers"]["generate"] == {
-        "provider": "anthropic",
-        "model": "claude-opus-4-8",
-    }
-    assert stored["providers"]["cogitate"] == {
+    assert stored["providers"]["active"] == {
         "provider": "anthropic",
         "model": "claude-opus-4-8",
     }
@@ -895,11 +842,7 @@ def test_byo_lane_remembered_model_does_not_overwrite_present_model(
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"] = {
-        "provider": "anthropic",
-        "model": "claude-sonnet-4-6",
-    }
-    config["providers"]["cogitate"] = {
+    config["providers"]["active"] = {
         "provider": "anthropic",
         "model": "claude-sonnet-4-6",
     }
@@ -913,8 +856,7 @@ def test_byo_lane_remembered_model_does_not_overwrite_present_model(
 
     assert response.status_code == 200
     stored = json.loads(config_path.read_text())
-    assert stored["providers"]["generate"]["model"] == "claude-sonnet-4-6"
-    assert stored["providers"]["cogitate"]["model"] == "claude-sonnet-4-6"
+    assert stored["providers"]["active"]["model"] == "claude-sonnet-4-6"
 
 
 def test_lane_switch_to_confidential_rejects_without_config_write(
@@ -950,8 +892,7 @@ def test_lane_switch_to_confidential_rejects_without_config_write(
         "served_model_id": "served-model",
         "credential_created_at": "2026-05-24T00:00:00Z",
         "credential_fingerprint_sha256": "fingerprint",
-        "prior_generate_provider": "google",
-        "prior_cogitate_provider": "openai",
+        "prior_active": {"provider": "google", "model": "gemini-flash-latest"},
         "prior_local_endpoint": None,
     }
     _write_config(journal_path, config)
@@ -964,8 +905,7 @@ def test_lane_switch_to_confidential_rejects_without_config_write(
     assert response.status_code == 200
     payload = response.get_json()
     assert payload["active_lane"]["lane"] == "confidential"
-    assert payload["generate"]["provider"] == "local"
-    assert payload["cogitate"]["provider"] == "local"
+    assert payload["active"]["provider"] == "local"
 
 
 def test_switch_from_byo_model_to_local_resolves_local_default(
@@ -995,11 +935,7 @@ def test_switch_to_cloud_without_memory_resolves_provider_default(
     client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"] = {
-        "provider": "google",
-        "model": "gemini-pro-latest",
-    }
-    config["providers"]["cogitate"] = {
+    config["providers"]["active"] = {
         "provider": "google",
         "model": "gemini-pro-latest",
     }
@@ -1015,13 +951,13 @@ def test_switch_to_cloud_without_memory_resolves_provider_default(
     assert resolve_provider("generate") == ("anthropic", "claude-sonnet-4-6")
 
 
-def test_legacy_explicit_model_resolves_without_ui_interaction(
+def test_active_explicit_model_resolves_without_ui_interaction(
     settings_client_with_journal,
 ):
     _client, journal_path = settings_client_with_journal
     config_path = journal_path / "config" / "journal.json"
     config = json.loads(config_path.read_text())
-    config["providers"]["generate"] = {
+    config["providers"]["active"] = {
         "provider": "openai",
         "model": "gpt-5.5",
     }
@@ -1108,8 +1044,10 @@ def test_get_providers_scout_google_grandfather_is_zero_touch(
         "enabled_at": "2026-05-23T00:00:00Z",
         "key_fingerprint_sha256": "fingerprint",
     }
-    config["providers"]["generate"]["provider"] = "google"
-    config["providers"]["cogitate"]["provider"] = "google"
+    config["providers"]["active"] = {
+        "provider": "google",
+        "model": "gemini-flash-latest",
+    }
     _write_config(journal_path, config)
     before = config_path.read_bytes()
 
@@ -1354,29 +1292,3 @@ def test_get_providers_ai_readiness_includes_local_on_mlx(settings_client, monke
     assert payload["local_backend"] == "mlx"
     assert "local" in payload["ai_readiness"]
     assert payload["ai_readiness"]["local"]["status"] == "ready"
-
-
-def test_put_providers_clear_refuses_noncanonical_path_but_removes_config(
-    settings_client_with_journal,
-):
-    client, journal_path = settings_client_with_journal
-    noncanonical = journal_path / "elsewhere.json"
-    noncanonical.write_text("secret", encoding="utf-8")
-    config_path = journal_path / "config" / "journal.json"
-    config = json.loads(config_path.read_text())
-    config["providers"]["vertex_credentials"] = str(noncanonical)
-    config["providers"].setdefault("key_validation", {})["google_vertex"] = {
-        "valid": True,
-    }
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"vertex_credentials": ""},
-    )
-
-    assert response.status_code == 200
-    assert noncanonical.exists()
-    config = json.loads(config_path.read_text())
-    assert "vertex_credentials" not in config["providers"]
-    assert "google_vertex" not in config["providers"]["key_validation"]
diff --git a/solstone/apps/thinking/tests/test_thinking_byo_flow_js.py b/solstone/apps/thinking/tests/test_thinking_byo_flow_js.py
index eaf776c9b..557a3ca5c 100644
--- a/solstone/apps/thinking/tests/test_thinking_byo_flow_js.py
+++ b/solstone/apps/thinking/tests/test_thinking_byo_flow_js.py
@@ -355,7 +355,7 @@ async function main() {
       ],
     },
     byo_models: {},
-    generate: {provider: 'openai', model: 'not-anthropic'},
+    active: {provider: 'openai', model: 'not-anthropic'},
   };
   let mode = '';
   let selected = '';
@@ -549,7 +549,7 @@ def test_byo_preselection_and_payload_driven_tiers() -> None:
             """
 const injected = {
   byo_models: {anthropic: 'remembered-model'},
-  generate: {provider: 'anthropic', model: 'active-model'},
+  active: {provider: 'anthropic', model: 'active-model'},
   model_tiers: {
     anthropic: [
       {tier: 'lite', label: 'Injected Lite Label', model: 'payload-lite-id'},
@@ -561,8 +561,8 @@ const injected = {
 
 assert(preselectByoModel('anthropic', injected) === 'remembered-model', 'remembered model wins');
 delete injected.byo_models.anthropic;
-assert(preselectByoModel('anthropic', injected) === 'active-model', 'matching active generate model wins second');
-injected.generate.provider = 'google';
+assert(preselectByoModel('anthropic', injected) === 'active-model', 'matching active model wins second');
+injected.active.provider = 'google';
 assert(preselectByoModel('anthropic', injected) === 'payload-lite-id', 'lite tier wins last');
 
 const rows = byoTierRows('anthropic', injected, 'payload-mid-id', text);
@@ -607,7 +607,7 @@ const state = {
   byoCustomModel: '',
   byoCustomCheckedModel: '',
   providers: {
-    generate: {provider: 'anthropic', model: 'injected-mid-id'},
+    active: {provider: 'anthropic', model: 'injected-mid-id'},
     model_tiers: {
       anthropic: [
         {tier: 'lite', label: 'Injected Lite', model: 'injected-lite-id'},
@@ -667,7 +667,7 @@ const state = {
   byoCustomCheckedModel: '',
   providers: {
     scout_enabled: false,
-    generate: {provider: 'anthropic', model: 'injected-mid-id'},
+    active: {provider: 'anthropic', model: 'injected-mid-id'},
     model_tiers: {
       anthropic: [
         {tier: 'top', label: 'Injected Top', model: 'injected-top-id'},
@@ -955,7 +955,7 @@ const state = {
   providers: {
     scout_enabled: false,
     byo_models: {openai: 'remembered-gpt'},
-    generate: {provider: 'anthropic', model: 'old-active'},
+    active: {provider: 'anthropic', model: 'old-active'},
     model_tiers: {
       openai: [
         {tier: 'lite', label: 'Lite GPT', model: 'lite-gpt'},
@@ -1063,7 +1063,7 @@ const state = {
   providers: {
     scout_enabled: false,
     byo_models: {google: 'remembered-google'},
-    generate: {provider: 'google', model: 'active-google'},
+    active: {provider: 'google', model: 'active-google'},
     model_tiers: {
       google: [
         {tier: 'top', label: 'Remembered Google', model: 'remembered-google'},
@@ -1100,7 +1100,7 @@ changeByoProvider('google');
 assert(state.byoSelectedModel === 'active-google', 'active-effective model should win when no remembered model exists');
 
 state.byoSelectedModel = 'old-model';
-state.providers.generate = {provider: 'anthropic', model: 'other-active'};
+state.providers.active = {provider: 'anthropic', model: 'other-active'};
 changeByoProvider('google');
 assert(state.byoSelectedModel === 'google-lite', 'lite model should win when no remembered or active model exists');
 
diff --git a/solstone/apps/thinking/tests/test_vertex_credentials.py b/solstone/apps/thinking/tests/test_vertex_credentials.py
deleted file mode 100644
index 8d68d30bf..000000000
--- a/solstone/apps/thinking/tests/test_vertex_credentials.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-import json
-
-import pytest
-
-from solstone.apps.thinking.vertex_credentials import (
-    delete_vertex_credentials,
-    save_vertex_credentials,
-)
-
-
-def _valid_creds(**overrides):
-    creds = {
-        "type": "service_account",
-        "project_id": "test-project",
-        "client_email": "test@test-project.iam.gserviceaccount.com",
-        "private_key": "-----BEGIN RSA PRIVATE KEY-----\nfake\n-----END RSA PRIVATE KEY-----\n",
-    }
-    creds.update(overrides)
-    return creds
-
-
-def test_save_writes_canonical_bytes_and_mode(tmp_path):
-    journal_root = tmp_path / "journal"
-    creds = _valid_creds(project_id="test-projéct")
-
-    creds_file = save_vertex_credentials(creds, journal_root)
-
-    assert creds_file == journal_root / ".config" / "vertex-credentials.json"
-    assert creds_file.exists()
-    assert creds_file.stat().st_mode & 0o777 == 0o600
-    expected = (json.dumps(creds, indent=2, ensure_ascii=False) + "\n").encode("utf-8")
-    assert creds_file.read_bytes() == expected
-
-
-def test_save_atomic_failure_preserves_existing_bytes(tmp_path, monkeypatch):
-    journal_root = tmp_path / "journal"
-    creds_file = save_vertex_credentials(_valid_creds(project_id="v1"), journal_root)
-    v1_bytes = creds_file.read_bytes()
-
-    def fail_replace(_src, _dst):
-        raise OSError("replace failed")
-
-    monkeypatch.setattr("solstone.think.journal_io.atomic.os.replace", fail_replace)
-
-    with pytest.raises(OSError):
-        save_vertex_credentials(_valid_creds(project_id="v2"), journal_root)
-
-    assert creds_file.read_bytes() == v1_bytes
-    assert list((journal_root / ".config").glob(".tmp_*")) == []
-
-
-def test_delete_refuses_noncanonical_path(tmp_path):
-    journal_root = tmp_path / "journal"
-    noncanonical = journal_root / "elsewhere.json"
-    noncanonical.parent.mkdir(parents=True, exist_ok=True)
-    noncanonical.write_text("secret", encoding="utf-8")
-
-    assert delete_vertex_credentials(noncanonical, journal_root) is False
-    assert noncanonical.exists()
-
-
-def test_delete_removes_canonical(tmp_path):
-    journal_root = tmp_path / "journal"
-    creds_file = save_vertex_credentials(_valid_creds(), journal_root)
-
-    assert delete_vertex_credentials(str(creds_file), journal_root) is True
-    assert not creds_file.exists()
diff --git a/solstone/apps/thinking/tests/test_workspace_html.py b/solstone/apps/thinking/tests/test_workspace_html.py
index 4b720032a..45287f018 100644
--- a/solstone/apps/thinking/tests/test_workspace_html.py
+++ b/solstone/apps/thinking/tests/test_workspace_html.py
@@ -92,12 +92,6 @@ def test_workspace_renders_each_lane(settings_env):
     assert html.count('id="byoLaneStatus"') == 1
     assert 'id="byoKeyStatus"' in html
     for control_id in (
-        "field-generate-provider",
-        "field-cogitate-provider",
-        "field-google-backend",
-        "vertexSave",
-        "vertexClear",
-        "vertexCredsInput",
         "localEndpointUrl",
         "localEndpointModel",
         "localEndpointCredential",
@@ -105,7 +99,8 @@ def test_workspace_renders_each_lane(settings_env):
         "localEndpointClear",
     ):
         assert f'id="{control_id}"' in html
-    assert "<details" in html
+    assert "advanced provider controls" not in html
+    assert "Vertex" not in html
     assert "Choose how sol thinks" not in html
     assert "window.THINKING =" not in html
     assert "window.THINKING_COPY =" not in html
@@ -223,7 +218,6 @@ def test_thinking_deck_copy_constants() -> None:
         "local": "local",
         "confidential": "confidential processing",
         "byo": "your own AI engine",
-        "advanced": "advanced split",
     }
     assert thinking_copy.GLANCE == {
         "lane_label": "sol is thinking with",
diff --git a/solstone/apps/thinking/vertex_credentials.py b/solstone/apps/thinking/vertex_credentials.py
deleted file mode 100644
index 9b3f8b0ad..000000000
--- a/solstone/apps/thinking/vertex_credentials.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-"""Owns <journal>/.config/vertex-credentials.json for Vertex credentials."""
-
-import json
-from pathlib import Path
-
-from solstone.think.journal_io.atomic import atomic_replace
-
-
-def _canonical_path(journal_root: Path) -> Path:
-    return journal_root / ".config" / "vertex-credentials.json"
-
-
-def save_vertex_credentials(creds_data: dict, journal_root: Path) -> Path:
-    """Save Vertex credentials to the canonical journal secret path."""
-    path = _canonical_path(journal_root)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    payload = json.dumps(creds_data, indent=2, ensure_ascii=False) + "\n"
-    atomic_replace(path, payload, mode=0o600)
-    return path
-
-
-def delete_vertex_credentials(configured_path: str | Path, journal_root: Path) -> bool:
-    """Guard canonical path resolution before unlinking Vertex credentials.
-
-    Returns whether the guard matched and an unlink was attempted. This does not
-    touch config; callers own config mutation.
-    """
-    canonical = _canonical_path(journal_root)
-    if Path(configured_path).resolve() != canonical.resolve():
-        return False
-    try:
-        canonical.unlink(missing_ok=True)
-    except OSError:
-        pass
-    return True
diff --git a/solstone/apps/thinking/workspace.html b/solstone/apps/thinking/workspace.html
index cb81dcf4b..a6074206f 100644
--- a/solstone/apps/thinking/workspace.html
+++ b/solstone/apps/thinking/workspace.html
@@ -590,40 +590,6 @@
         </article>
       </section>
 
-      <details class="disclosure">
-        <summary>advanced provider controls</summary>
-        <div class="details-grid">
-          <div class="field">
-            <label for="field-generate-provider">generate provider</label>
-            <select id="field-generate-provider"></select>
-          </div>
-          <div class="field">
-            <label for="field-cogitate-provider">cogitate provider</label>
-            <select id="field-cogitate-provider"></select>
-          </div>
-        </div>
-        <div class="message" id="advancedStatus"></div>
-
-        <div class="details-grid">
-          <div class="field">
-            <label for="field-google-backend">Google backend</label>
-            <select id="field-google-backend">
-              <option value="auto">auto</option>
-              <option value="aistudio">AI Studio</option>
-              <option value="vertex">Vertex</option>
-            </select>
-          </div>
-          <div class="field">
-            <label for="vertexCredsInput">Vertex credentials JSON</label>
-            <textarea id="vertexCredsInput" rows="5"></textarea>
-          </div>
-        </div>
-        <div class="inline-actions">
-          <button type="button" class="btn" id="vertexSave">save Vertex credentials</button>
-          <button type="button" class="btn ghost" id="vertexClear">clear Vertex credentials</button>
-        </div>
-        <div class="message" id="vertexStatus"></div>
-      </details>
       </section>
 
       <section class="view" data-view="confidential-setup" hidden>
diff --git a/solstone/convey/chat.py b/solstone/convey/chat.py
index 26686ba10..7c8722682 100644
--- a/solstone/convey/chat.py
+++ b/solstone/convey/chat.py
@@ -995,7 +995,6 @@ def _spawn_chat_generate(action: dict[str, Any]) -> ChatSpawnResult:
         spawn_agent(
             prompt="",
             name="chat",
-            provider=None,
             config=config,
             use_id=action["raw_use_id"],
         )
@@ -1049,7 +1048,6 @@ def _spawn_talent(action: dict[str, Any]) -> bool:
         spawn_agent(
             prompt=prompt,
             name=spawn_name,
-            provider=None,
             config=config,
             use_id=action["use_id"],
         )
diff --git a/solstone/convey/utils.py b/solstone/convey/utils.py
index 0bac322f4..f94786bc7 100644
--- a/solstone/convey/utils.py
+++ b/solstone/convey/utils.py
@@ -127,7 +127,6 @@ def time_since(epoch: int) -> str:
 def spawn_agent(
     prompt: str,
     name: str,
-    provider: Optional[str] = None,
     config: Optional[dict[str, Any]] = None,
     use_id: Optional[str] = None,
 ) -> str:
@@ -139,8 +138,7 @@ def spawn_agent(
     Args:
         prompt: The task or question for the agent
         name: Agent name - system (e.g., "default") or app-qualified (e.g., "entities:entity_assist")
-        provider: Optional provider override (openai, google, anthropic)
-        config: Additional configuration (max_tokens, facet, session_id, etc.)
+        config: Additional launch configuration (facet, session_id, etc.)
         use_id: Optional pre-reserved Cortex use_id to reuse for the request
 
     Returns:
@@ -156,7 +154,6 @@ def spawn_agent(
     return cortex_request(
         prompt=prompt,
         name=name,
-        provider=provider,
         config=config,
         use_id=use_id,
     )
diff --git a/solstone/observe/describe.py b/solstone/observe/describe.py
index 7bb01cf1f..1d31b2bfb 100644
--- a/solstone/observe/describe.py
+++ b/solstone/observe/describe.py
@@ -760,7 +760,7 @@ class VideoProcessor:
                 promoted = True
 
         try:
-            frame_provider, frame_model = resolve_provider("generate")
+            frame_provider, _ = resolve_provider("generate")
             if frame_provider == NO_BRAIN_PROVIDER:
                 logger.info("No thinking engine selected; deferring frame description")
                 return
@@ -782,7 +782,6 @@ class VideoProcessor:
                         frame_img,
                     ),
                     context=FRAME_CONTEXT,
-                    model=frame_model,
                     system_instruction=system_instruction,
                     json_output=True,
                     json_schema=_SCHEMA,
@@ -1087,7 +1086,7 @@ class VideoProcessor:
                     # Determine output format from metadata
                     is_json = cat_meta.get("output") == "json"
 
-                    cat_provider, cat_model = resolve_provider("generate")
+                    cat_provider, _ = resolve_provider("generate")
                     if cat_provider == NO_BRAIN_PROVIDER:
                         logger.info(
                             "No thinking engine selected; deferring %s extraction",
@@ -1101,7 +1100,6 @@ class VideoProcessor:
                             f"Analyze this {category} screenshot.",
                             full_img,
                         ),
-                        model=cat_model,
                         system_instruction=cat_meta["prompt"] + redact_instruction,
                         json_output=is_json,
                         json_schema=cat_meta.get("json_schema"),
diff --git a/solstone/talent/journal/references/config.md b/solstone/talent/journal/references/config.md
index f83ef60ae..797ff4589 100644
--- a/solstone/talent/journal/references/config.md
+++ b/solstone/talent/journal/references/config.md
@@ -113,7 +113,7 @@ The `env` block stores configuration as environment variables that solstone load
 }
 ```
 
-**Managed provider keys are journal-config-exclusive.** For the managed provider API keys — `GOOGLE_API_KEY`, `OPENAI_API_KEY`, and `ANTHROPIC_API_KEY` — the journal config `env` section is the authoritative and exclusive source. At CLI startup, solstone loads the `env` block into the environment and then strips any of these managed keys that is *not* set in journal config, so a value set only in the shell is never used. This keeps the journal config the single, predictable place that decides which provider keys are in effect (useful when the journal is synced across machines). Google Vertex/ADC auth variables are not managed keys and are never stripped.
+**Managed provider keys are journal-config-exclusive.** For the managed provider API keys — `GOOGLE_API_KEY`, `OPENAI_API_KEY`, and `ANTHROPIC_API_KEY` — the journal config `env` section is the authoritative and exclusive source. At CLI startup, solstone loads the `env` block into the environment and then strips any of these managed keys that is *not* set in journal config, so a value set only in the shell is never used. This keeps the journal config the single, predictable place that decides which provider keys are in effect (useful when the journal is synced across machines).
 
 Other variables declared in the `env` block (for example `REVAI_ACCESS_TOKEN`, `PLAUD_ACCESS_TOKEN`) are loaded into the environment at startup as well.
 
@@ -230,14 +230,10 @@ Brain choice is managed in the Thinking app. Your journal stores that choice in
     "GOOGLE_API_KEY": "stored-by-settings"
   },
   "providers": {
-    "generate": {
+    "active": {
       "provider": "google",
       "model": "gemini-flash-latest"
     },
-    "cogitate": {
-      "provider": "openai",
-      "model": "gpt-5.4-mini"
-    },
     "local": {
       "endpoint_url": "http://127.0.0.1:8080",
       "served_model_id": "local-model-name",
@@ -249,17 +245,13 @@ Brain choice is managed in the Thinking app. Your journal stores that choice in
 
 ### Live provider keys
 
-**`providers.generate`** controls the active brain for generator-style requests.
-It may contain:
+**`providers.active`** controls the single brain used by both generate and
+cogitate requests. It contains:
 - `provider` – `"google"`, `"anthropic"`, `"openai"`, `"local"`, or omitted.
 - `model` – explicit model id for that provider.
 
-**`providers.cogitate`** controls the active brain for tool-using requests. It
-has the same `provider` and `model` shape.
-
-When no provider is pinned, Solstone uses configured cloud keys in the
-grandfathered `google` → `anthropic` → `openai` order, then the ready local
-runtime, then the no-brain state.
+There is no implicit key-based selection or fallback. A missing or invalid
+active profile is the no-brain state.
 
 **`env`** stores managed cloud API keys:
 - `GOOGLE_API_KEY`
@@ -275,17 +267,7 @@ Optional local endpoint fields:
 - `credential`
 - `parallel_slots`
 
-### Legacy routing keys
-
-These keys may still exist in older journals, but they no longer choose the
-provider or model:
-- `tier`
-- `backup`
-- `providers.models`
-- `providers.contexts.<context>.provider`
-- `providers.contexts.<context>.model`
+### Talent overrides
 
-`providers.contexts.<context>.disabled` and
-`providers.contexts.<context>.extract` are still used as talent metadata. Do not
-delete a `providers.contexts` block just because its old provider/model routing
-fields are no longer active.
+`talent_overrides.<talent>.disabled` and `talent_overrides.<talent>.extract`
+are optional talent metadata. Provider and model overrides are rejected.
diff --git a/solstone/think/batch.py b/solstone/think/batch.py
index db931f412..c168abc68 100644
--- a/solstone/think/batch.py
+++ b/solstone/think/batch.py
@@ -18,8 +18,6 @@ Example:
     async for req in batch.drain_batch():
         print(f"{req.my_id}: {req.response}")
 
-Provider-specific features:
-    - client: Optional client for connection reuse (Google only, others use singletons)
 """
 
 import asyncio
@@ -53,7 +51,6 @@ class BatchRequest:
         self,
         contents: Union[str, List[Any]],
         context: str,
-        model: Optional[str] = None,
         temperature: float = 0.3,
         max_output_tokens: int = 8192 * 2,
         system_instruction: Optional[str] = None,
@@ -64,7 +61,6 @@ class BatchRequest:
     ):
         self.contents = contents
         self.context = context
-        self.model = model
         self.temperature = temperature
         self.max_output_tokens = max_output_tokens
         self.system_instruction = system_instruction
@@ -77,7 +73,7 @@ class BatchRequest:
         self.response: Optional[str] = None
         self.error: Optional[str] = None
         self.duration: float = 0.0
-        self.model_used: str = model or ""
+        self.model_used: str = ""
         self.reason_code: Optional[str] = None
         self.provider: Optional[str] = None
         self.reset_at_ms: Optional[int] = None
@@ -107,7 +103,7 @@ class Batch:
             print(f"{req.task_id}: {req.response}")
     """
 
-    def __init__(self, max_concurrent: int = 5, client: Any = None):
+    def __init__(self, max_concurrent: int = 5):
         """
         Initialize batch processor.
 
@@ -115,13 +111,8 @@ class Batch:
         ----------
         max_concurrent : int
             Maximum number of concurrent API requests (default: 5)
-        client : Any, optional
-            Provider client for connection reuse. Passed through to backend.
-            Google: genai.Client instance for connection pooling
-            Other providers: Ignored (they use internal singletons)
         """
         self.max_concurrent = max_concurrent
-        self.client = client
         self.semaphore = asyncio.Semaphore(max_concurrent)
         self.result_queue: asyncio.Queue = asyncio.Queue()
         self.pending_tasks: set = set()
@@ -130,7 +121,6 @@ class Batch:
         self,
         contents: Union[str, List[Any]],
         context: str,
-        model: Optional[str] = None,
         temperature: float = 0.3,
         max_output_tokens: int = 8192 * 2,
         system_instruction: Optional[str] = None,
@@ -151,9 +141,6 @@ class Batch:
             The content to send to the model
         context : str
             Context string for provider routing (e.g., "observe.describe.frame")
-        model : str, optional
-            Model override. If not provided, resolved from context.
-
         Returns
         -------
         BatchRequest
@@ -162,7 +149,6 @@ class Batch:
         return BatchRequest(
             contents=contents,
             context=context,
-            model=model,
             temperature=temperature,
             max_output_tokens=max_output_tokens,
             system_instruction=system_instruction,
@@ -263,13 +249,6 @@ class Batch:
         start_time = time.time()
         try:
             async with self.semaphore:
-                # Build kwargs for provider-specific options
-                kwargs: dict = {}
-                if self.client is not None:
-                    kwargs["client"] = self.client
-                if request.model is not None:
-                    kwargs["model"] = request.model
-
                 result = await agenerate_with_result(
                     contents=request.contents,
                     context=request.context,
@@ -280,7 +259,6 @@ class Batch:
                     json_schema=request.json_schema,
                     thinking_budget=request.thinking_budget,
                     timeout_s=request.timeout_s,
-                    **kwargs,
                 )
                 error = finish_reason_error(
                     result,
@@ -298,13 +276,7 @@ class Batch:
                 request.response = result["text"]
                 request.error = None
 
-                # Track which model was actually used
-                if request.model:
-                    request.model_used = request.model
-                else:
-                    # Model was resolved from context - we don't have easy access
-                    # to what was resolved, so leave as empty string
-                    pass
+                request.model_used = str(result.get("model") or "")
         except Exception as e:
             request.duration = time.time() - start_time
             request.response = None
diff --git a/solstone/think/cortex_client.py b/solstone/think/cortex_client.py
index 34652d8f3..ca45b835d 100644
--- a/solstone/think/cortex_client.py
+++ b/solstone/think/cortex_client.py
@@ -90,7 +90,6 @@ def _check_claimed(use_id: str, window: float) -> bool:
 def cortex_request(
     prompt: str,
     name: str,
-    provider: Optional[str] = None,
     config: Optional[Dict[str, Any]] = None,
     use_id: Optional[str] = None,
     *,
@@ -101,8 +100,7 @@ def cortex_request(
     Args:
         prompt: The task or question for the talent
         name: Talent name - system (e.g., "chat") or app-qualified (e.g., "entities:entity_assist")
-        provider: AI provider - openai, google, or anthropic
-        config: Provider-specific configuration (model, max_output_tokens, thinking_budget, etc.)
+        config: Talent launch configuration (day, facet, output, etc.)
         use_id: Optional pre-reserved use_id. When omitted, a unique timestamp is allocated.
         claim_windows: Claim-wait schedule. Defaults to the fast-fail
             _DEFAULT_CLAIM_WINDOWS; the think orchestrator passes
@@ -147,7 +145,6 @@ def cortex_request(
         "ts": ts,
         "use_id": use_id,
         "prompt": prompt,
-        "provider": provider,
         "name": name,
     }
 
diff --git a/solstone/think/models.py b/solstone/think/models.py
index 9184a3a19..79c000e04 100644
--- a/solstone/think/models.py
+++ b/solstone/think/models.py
@@ -154,7 +154,6 @@ def model_supports(model: str, param: str) -> bool:
 
 
 NO_BRAIN_PROVIDER = "none"
-IMPLICIT_CLOUD_PROVIDER_ORDER = ("google", "anthropic", "openai")
 DEFAULT_MODEL_BY_PROVIDER: dict[str, str] = {
     "google": GEMINI_FLASH,
     "openai": GPT_5_MINI,
@@ -461,38 +460,6 @@ def get_context_registry() -> Dict[str, Dict[str, Any]]:
     return _context_registry
 
 
-def _resolve_default_provider(
-    providers: dict[str, Any],
-    agent_type: str,
-    *,
-    local_ready: bool | None = None,
-) -> str:
-    type_config = providers.get(agent_type, {}) if isinstance(providers, dict) else {}
-    if not isinstance(type_config, dict):
-        type_config = {}
-
-    explicit_provider = type_config.get("provider")
-    if isinstance(explicit_provider, str) and explicit_provider:
-        return explicit_provider
-
-    from solstone.think.providers import PROVIDER_METADATA
-    from solstone.think.providers.state import (
-        cloud_key_configured,
-        local_runtime_ready,
-    )
-
-    for provider in IMPLICIT_CLOUD_PROVIDER_ORDER:
-        env_key = PROVIDER_METADATA[provider]["env_key"]
-        if cloud_key_configured(env_key):
-            return provider
-
-    if local_ready is None:
-        local_ready = local_runtime_ready()
-    if local_ready:
-        return "local"
-    return NO_BRAIN_PROVIDER
-
-
 def default_model_for_provider(provider: str) -> str:
     """Return the single default model for a provider."""
     if provider == NO_BRAIN_PROVIDER:
@@ -504,27 +471,28 @@ def default_model_for_provider(provider: str) -> str:
 
 
 def resolve_provider(agent_type: str) -> tuple[str, str]:
-    """Resolve the active provider and model for an interface.
+    """Resolve the journal's one active thinking provider and model.
 
-    Precedence is explicit per-interface provider, configured cloud-key
-    presence in the grandfathered google -> anthropic -> openai order, local
-    runtime readiness, then NO_BRAIN_PROVIDER. Contexts, tiers, backups, and
-    providers.models overrides are intentionally ignored.
+    ``agent_type`` identifies the runtime interface for callers and diagnostics;
+    both generate and cogitate intentionally use the same active brain.
     """
+    if agent_type not in {"generate", "cogitate"}:
+        raise ValueError(f"Unknown thinking interface: {agent_type!r}")
     config = get_config()
     providers = config.get("providers", {})
     if not isinstance(providers, dict):
         providers = {}
 
-    type_config = providers.get(agent_type, {})
-    if not isinstance(type_config, dict):
-        type_config = {}
-
-    provider = _resolve_default_provider(providers, agent_type)
+    active = providers.get("active", {})
+    if not isinstance(active, dict):
+        active = {}
+    provider = active.get("provider")
+    if not isinstance(provider, str) or not provider:
+        provider = NO_BRAIN_PROVIDER
     if provider == NO_BRAIN_PROVIDER:
         return (NO_BRAIN_PROVIDER, "")
 
-    explicit_model = type_config.get("model")
+    explicit_model = active.get("model")
     if isinstance(explicit_model, str) and explicit_model.strip():
         return (provider, explicit_model.strip())
     return (provider, default_model_for_provider(provider))
@@ -548,53 +516,37 @@ def resolve_effective_route(context: str) -> tuple[str, str, str]:
 
 
 def is_local_provider_needed(config: dict[str, Any] | None = None) -> bool:
-    """Return True when journal provider config selects local anywhere."""
+    """Return True when the journal's active thinking provider is local."""
     journal_config = config if config is not None else get_config()
     providers = journal_config.get("providers", {})
     if not isinstance(providers, dict):
         return False
-
-    for agent_type in ("generate", "cogitate"):
-        type_config = providers.get(agent_type, {})
-        if isinstance(type_config, dict) and type_config.get("provider") == "local":
-            return True
-
-    from solstone.think.providers.state import local_runtime_ready
-
-    local_ready = local_runtime_ready()
-    return any(
-        _resolve_default_provider(providers, agent_type, local_ready=local_ready)
-        == "local"
-        for agent_type in ("generate", "cogitate")
-    )
+    active = providers.get("active", {})
+    return isinstance(active, dict) and active.get("provider") == "local"
 
 
 def no_thinking_engine_chosen(config: dict[str, Any] | None = None) -> bool:
-    """Return True when neither default thinking interface has an engine."""
+    """Return True when the journal has no active thinking engine."""
     journal_config = config if config is not None else get_config()
     providers = journal_config.get("providers", {})
     if not isinstance(providers, dict):
         providers = {}
-    from solstone.think.providers.state import local_runtime_ready
-
-    local_ready = local_runtime_ready()
-    return all(
-        _resolve_default_provider(providers, agent_type, local_ready=local_ready)
-        == NO_BRAIN_PROVIDER
-        for agent_type in ("generate", "cogitate")
-    )
+    active = providers.get("active", {})
+    return not isinstance(active, dict) or not active.get("provider")
 
 
 def type_default_is_local(
     agent_type: str, config: dict[str, Any] | None = None
 ) -> bool:
-    """Return True when the explicit per-type provider for agent_type is local."""
+    """Return True when the active brain is local for this runtime interface."""
+    if agent_type not in {"generate", "cogitate"}:
+        raise ValueError(f"Unknown thinking interface: {agent_type!r}")
     journal_config = config if config is not None else get_config()
     providers = journal_config.get("providers", {})
     if not isinstance(providers, dict):
         return False
-    type_config = providers.get(agent_type, {})
-    return isinstance(type_config, dict) and type_config.get("provider") == "local"
+    active = providers.get("active", {})
+    return isinstance(active, dict) and active.get("provider") == "local"
 
 
 def log_token_usage(
@@ -703,24 +655,6 @@ def log_token_usage(
         logger.warning("failed to log token usage", exc_info=True)
 
 
-_CLOUD_MODEL_FAMILIES = {"openai", "google", "anthropic"}
-
-
-def _reject_local_cloud_model_override(
-    provider: str, model_override: str | None
-) -> None:
-    """Fail loudly when a local provider is paired with an explicit cloud model override."""
-    if (
-        provider == "local"
-        and model_override
-        and get_model_provider(model_override) in _CLOUD_MODEL_FAMILIES
-    ):
-        raise ValueError(
-            f"local provider cannot serve cloud model override {model_override!r}: "
-            "remove the model override or select a matching cloud provider."
-        )
-
-
 def _raise_if_no_brain(provider: str) -> None:
     if provider == NO_BRAIN_PROVIDER:
         raise NoBrainConfiguredError()
@@ -1135,7 +1069,6 @@ def generate(
     json_schema: dict | None = None,
     thinking_budget: Optional[int] = None,
     timeout_s: Optional[float] = None,
-    **kwargs: Any,
 ) -> str:
     """Generate text using the configured generate provider.
 
@@ -1161,9 +1094,6 @@ def generate(
         Token budget for model thinking (ignored by providers that don't support it).
     timeout_s : float, optional
         Request timeout in seconds.
-    **kwargs
-        Additional provider-specific options passed through to the backend.
-
     Returns
     -------
     str
@@ -1181,15 +1111,9 @@ def generate(
     if json_schema is not None:
         json_output = True
 
-    # Allow model override via kwargs (used by callers with explicit model selection)
-    model_override = kwargs.pop("model", None)
-
     provider, model = resolve_provider("generate")
-    if model_override:
-        model = model_override
 
     _raise_if_no_brain(provider)
-    _reject_local_cloud_model_override(provider, model_override)
     _raise_if_confidential_unverified()
 
     # Get provider module via registry (raises ValueError for unknown providers)
@@ -1199,10 +1123,10 @@ def generate(
     timeout_s = DEFAULT_PROVIDER_TIMEOUT_S if timeout_s is None else timeout_s
 
     # Call provider's run_generate (returns GenerateResult)
+    provider_options = {} if provider == "local" else {"provider": provider}
     result = provider_mod.run_generate(
         contents=contents,
         model=model,
-        provider=provider,
         temperature=temperature,
         max_output_tokens=max_output_tokens,
         system_instruction=system_instruction,
@@ -1210,7 +1134,7 @@ def generate(
         json_schema=provider_schema,
         thinking_budget=thinking_budget,
         timeout_s=timeout_s,
-        **kwargs,
+        **provider_options,
     )
 
     # Log token usage centrally (before validation so truncated responses
@@ -1245,7 +1169,8 @@ def generate_with_result(
     json_schema: dict | None = None,
     thinking_budget: Optional[int] = None,
     timeout_s: Optional[float] = None,
-    **kwargs: Any,
+    inference_retry_index: int = 0,
+    local_exclusive_admission: bool = False,
 ) -> dict:
     """Generate text and return full result with usage data.
 
@@ -1275,9 +1200,6 @@ def generate_with_result(
         Token budget for model thinking (ignored by providers that don't support it).
     timeout_s : float, optional
         Request timeout in seconds.
-    **kwargs
-        Additional provider-specific options passed through to the backend.
-
     Returns
     -------
     dict
@@ -1290,19 +1212,9 @@ def generate_with_result(
     if json_schema is not None:
         json_output = True
 
-    model_override = kwargs.pop("model", None)
-    provider_override = kwargs.pop("provider", None)
-
     provider, model = resolve_provider("generate")
-    if provider_override:
-        provider = provider_override
-        if not model_override:
-            model = default_model_for_provider(provider)
-    if model_override:
-        model = model_override
 
     _raise_if_no_brain(provider)
-    _reject_local_cloud_model_override(provider, model_override)
     _raise_if_confidential_unverified()
 
     provider_mod = get_provider_module(provider)
@@ -1310,10 +1222,18 @@ def generate_with_result(
 
     timeout_s = DEFAULT_PROVIDER_TIMEOUT_S if timeout_s is None else timeout_s
 
+    provider_options: dict[str, Any]
+    if provider == "local":
+        provider_options = {}
+        if inference_retry_index:
+            provider_options["inference_retry_index"] = inference_retry_index
+        if local_exclusive_admission:
+            provider_options["local_exclusive_admission"] = True
+    else:
+        provider_options = {"provider": provider}
     result = provider_mod.run_generate(
         contents=contents,
         model=model,
-        provider=provider,
         temperature=temperature,
         max_output_tokens=max_output_tokens,
         system_instruction=system_instruction,
@@ -1321,7 +1241,7 @@ def generate_with_result(
         json_schema=provider_schema,
         thinking_budget=thinking_budget,
         timeout_s=timeout_s,
-        **kwargs,
+        **provider_options,
     )
 
     # Log token usage centrally (before validation so truncated responses
@@ -1354,7 +1274,6 @@ async def agenerate_with_result(
     json_schema: dict | None = None,
     thinking_budget: Optional[int] = None,
     timeout_s: Optional[float] = None,
-    **kwargs: Any,
 ) -> dict:
     """Async generate text and return the full GenerateResult dict."""
     from solstone.think.providers import get_provider_module
@@ -1362,19 +1281,9 @@ async def agenerate_with_result(
     if json_schema is not None:
         json_output = True
 
-    model_override = kwargs.pop("model", None)
-    provider_override = kwargs.pop("provider", None)
-
     provider, model = resolve_provider("generate")
-    if provider_override:
-        provider = provider_override
-        if not model_override:
-            model = default_model_for_provider(provider)
-    if model_override:
-        model = model_override
 
     _raise_if_no_brain(provider)
-    _reject_local_cloud_model_override(provider, model_override)
     _raise_if_confidential_unverified()
 
     provider_mod = get_provider_module(provider)
@@ -1382,10 +1291,10 @@ async def agenerate_with_result(
 
     timeout_s = DEFAULT_PROVIDER_TIMEOUT_S if timeout_s is None else timeout_s
 
+    provider_options = {} if provider == "local" else {"provider": provider}
     result = await provider_mod.run_agenerate(
         contents=contents,
         model=model,
-        provider=provider,
         temperature=temperature,
         max_output_tokens=max_output_tokens,
         system_instruction=system_instruction,
@@ -1393,7 +1302,7 @@ async def agenerate_with_result(
         json_schema=provider_schema,
         thinking_budget=thinking_budget,
         timeout_s=timeout_s,
-        **kwargs,
+        **provider_options,
     )
 
     if result.get("usage"):
@@ -1423,7 +1332,6 @@ async def agenerate(
     json_schema: dict | None = None,
     thinking_budget: Optional[int] = None,
     timeout_s: Optional[float] = None,
-    **kwargs: Any,
 ) -> str:
     """Async generate text using the configured generate provider.
 
@@ -1449,9 +1357,6 @@ async def agenerate(
         Token budget for model thinking (ignored by providers that don't support it).
     timeout_s : float, optional
         Request timeout in seconds.
-    **kwargs
-        Additional provider-specific options passed through to the backend.
-
     Returns
     -------
     str
@@ -1469,15 +1374,9 @@ async def agenerate(
     if json_schema is not None:
         json_output = True
 
-    # Allow model override via kwargs (used by Batch for explicit model selection)
-    model_override = kwargs.pop("model", None)
-
     provider, model = resolve_provider("generate")
-    if model_override:
-        model = model_override
 
     _raise_if_no_brain(provider)
-    _reject_local_cloud_model_override(provider, model_override)
     _raise_if_confidential_unverified()
 
     # Get provider module via registry (raises ValueError for unknown providers)
@@ -1487,10 +1386,10 @@ async def agenerate(
     timeout_s = DEFAULT_PROVIDER_TIMEOUT_S if timeout_s is None else timeout_s
 
     # Call provider's run_agenerate (returns GenerateResult)
+    provider_options = {} if provider == "local" else {"provider": provider}
     result = await provider_mod.run_agenerate(
         contents=contents,
         model=model,
-        provider=provider,
         temperature=temperature,
         max_output_tokens=max_output_tokens,
         system_instruction=system_instruction,
@@ -1498,7 +1397,7 @@ async def agenerate(
         json_schema=provider_schema,
         thinking_budget=thinking_budget,
         timeout_s=timeout_s,
-        **kwargs,
+        **provider_options,
     )
 
     # Log token usage centrally (before validation so truncated responses
diff --git a/solstone/think/providers/__init__.py b/solstone/think/providers/__init__.py
index d40429f57..d41b23388 100644
--- a/solstone/think/providers/__init__.py
+++ b/solstone/think/providers/__init__.py
@@ -3,8 +3,9 @@
 
 """AI provider backends for think.
 
-This package contains provider-specific implementations for LLM generation
-and agent execution. Effective provider modules expose:
+This package exposes one OpenHands/LiteLLM cloud transport plus the local policy
+wrapper used for bundled and OpenAI-compatible endpoint execution. Effective
+provider modules expose:
 
 - run_generate(): Sync text generation, returns GenerateResult
 - run_agenerate(): Async text generation, returns GenerateResult
@@ -20,7 +21,6 @@ Available providers:
 - local: bundled llama-server or configured OpenAI-compatible endpoint
 """
 
-import shutil
 from importlib import import_module
 from types import ModuleType
 from typing import Any, Dict, List
@@ -53,10 +53,6 @@ PROVIDER_METADATA: Dict[str, Dict[str, Any]] = {
     "google": {
         "label": "Google (Gemini)",
         "env_key": "GOOGLE_API_KEY",
-        "vertex_env_keys": [
-            "GOOGLE_GENAI_USE_VERTEXAI",
-            "GOOGLE_APPLICATION_CREDENTIALS",
-        ],
     },
     "openai": {
         "label": "OpenAI (GPT)",
@@ -82,8 +78,7 @@ def managed_provider_env_keys() -> set[str]:
     journal config's ``env`` section is the authoritative and exclusive source — a
     managed key absent from journal config is stripped from ``os.environ`` at CLI
     startup (see :func:`solstone.think.utils.setup_cli`) so a shell-set value is
-    never used. Vertex/ADC auth vars (``vertex_env_keys``) are deliberately excluded:
-    they are file/ADC credentials a user may legitimately set in the shell.
+    never used.
     """
     return {m["env_key"] for m in PROVIDER_METADATA.values() if m.get("env_key")}
 
@@ -136,15 +131,12 @@ def get_provider_list() -> List[Dict[str, Any]]:
             "label": meta.get("label", name),
             "env_key": meta.get("env_key", ""),
         }
-        if "vertex_env_keys" in meta:
-            provider["vertex_env_keys"] = meta["vertex_env_keys"]
         providers.append(provider)
     return providers
 
 
 def build_provider_status(
     providers_list: List[Dict[str, Any]] | None = None,
-    vertex_creds_configured: bool = False,
 ) -> Dict[str, Dict[str, Any]]:
     """Build per-provider readiness status.
 
@@ -152,9 +144,6 @@ def build_provider_status(
     ----------
     providers_list
         Output of get_provider_list().
-    vertex_creds_configured
-        Whether Vertex AI credentials are configured (for Google).
-
     Returns
     -------
     Dict[str, Dict[str, Any]]
@@ -164,80 +153,26 @@ def build_provider_status(
     if providers_list is None:
         providers_list = get_provider_list()
 
-    status = {}
+    status: dict[str, dict[str, Any]] = {}
     for provider in providers_list:
         from solstone.think.providers import state as provider_state
 
         name = provider["name"]
         env_key = provider.get("env_key", "")
-        meta = PROVIDER_METADATA.get(name, {})
-        cogitate_cli = meta.get("cogitate_cli", "")
-        issues: list[str] = []
-
         if name == "local":
             status[name] = provider_state.local_status_dict()
             continue
-        elif name in {"google", "anthropic", "openai"}:
-            configured = provider_state.cloud_key_configured(env_key)
-            status[name] = {
-                "provider": name,
-                "configured": configured,
-                "generate_ready": configured,
-                "cogitate_ready": configured,
-                "issues": [] if configured else [f"{env_key} not set"],
-            }
-            continue
-        else:
-            configured = provider_state.cloud_key_configured(env_key)
-            if not configured and env_key:
-                issues.append(f"{env_key} not set")
-
-        cogitate_cli_found = bool(shutil.which(cogitate_cli)) if cogitate_cli else False
-        if cogitate_cli and not cogitate_cli_found:
-            install_cmd = meta.get("cogitate_cli_install")
-            if install_cmd:
-                issues.append(
-                    f"{cogitate_cli} CLI not found on PATH — run: {install_cmd}"
-                )
-            else:
-                issues.append(f"{cogitate_cli} CLI not found on PATH")
-        cogitate_ready = configured and cogitate_cli_found
-
-        generate_ready = configured
-
+        configured = provider_state.cloud_key_configured(env_key)
         status[name] = {
+            "provider": name,
             "configured": configured,
-            "generate_ready": generate_ready,
-            "cogitate_ready": cogitate_ready,
-            "cogitate_cli": cogitate_cli,
-            "cogitate_cli_found": cogitate_cli_found,
-            "issues": issues,
+            "generate_ready": configured,
+            "cogitate_ready": configured,
+            "issues": [] if configured else [f"{env_key} not set"],
         }
     return status
 
 
-def get_provider_models(provider: str) -> list[dict]:
-    """Get available models for a provider.
-
-    Parameters
-    ----------
-    provider
-        Provider name (e.g., "google", "openai", "anthropic").
-
-    Returns
-    -------
-    list[dict]
-        List of raw model info objects returned by the provider API.
-
-    Raises
-    ------
-    ValueError
-        If the provider is not registered.
-    """
-    module = get_provider_module(provider)
-    return module.list_models(provider)
-
-
 def validate_key(provider: str, api_key: str) -> dict:
     """Validate an API key for a provider.
 
@@ -298,7 +233,6 @@ __all__ = [
     "get_provider_module",
     "get_provider_list",
     "build_provider_status",
-    "get_provider_models",
     "validate_key",
     "validate_model",
     "managed_provider_env_keys",
diff --git a/solstone/think/providers/anthropic.py b/solstone/think/providers/anthropic.py
deleted file mode 100644
index 1431ff12c..000000000
--- a/solstone/think/providers/anthropic.py
+++ /dev/null
@@ -1,499 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-"""Anthropic Claude provider for agents and direct LLM generation.
-
-This module provides the Anthropic Claude provider for the ``journal providers check`` CLI
-and run_generate/run_agenerate functions returning GenerateResult.
-
-Common Parameters
------------------
-contents : str or list
-    The content to send to the model.
-model : str
-    Model name to use.
-temperature : float
-    Temperature for generation (default: 0.3).
-max_output_tokens : int
-    Maximum tokens for the model's response output.
-system_instruction : str, optional
-    System instruction for the model.
-json_output : bool
-    Whether to request JSON response format.
-thinking_budget : int, optional
-    Token budget for model thinking.
-timeout_s : float, optional
-    Request timeout in seconds.
-**kwargs
-    Additional provider-specific options.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import Any
-
-from anthropic import AsyncAnthropic
-from anthropic._constants import MODEL_NONSTREAMING_TOKENS
-from anthropic.types import (
-    Message,
-    MessageParam,
-    RedactedThinkingBlock,
-    ThinkingBlock,
-)
-
-from solstone.think.models import (
-    CLAUDE_SONNET_4,
-    DEFAULT_PROVIDER_TIMEOUT_S,
-    model_supports,
-)
-from solstone.think.providers._image import encode_image_part, is_image_part
-
-from .shared import GenerateResult, classify_provider_error
-
-# Default values are now handled internally
-_DEFAULT_MODEL = CLAUDE_SONNET_4
-
-logger = logging.getLogger(__name__)
-
-_DEFAULT_MAX_TOKENS = 8096 * 2
-_MIN_THINKING_BUDGET = 1024  # Anthropic minimum
-_DEFAULT_THINKING_BUDGET = 10000
-_MAX_TOKENS_BUFFER = (
-    1000  # Anthropic rejects requests where max_tokens <= thinking.budget_tokens.
-)
-_NONSTREAMING_TIME_CAP_TOKENS = (
-    21_333  # SDK time formula: 60*60*max_tokens/128_000 > 600 ≈ 21,333.
-)
-# anthropic._constants.MODEL_NONSTREAMING_TOKENS adds per-model non-streaming caps on top of this threshold.
-
-
-# ---------------------------------------------------------------------------
-# run_generate / run_agenerate functions
-# ---------------------------------------------------------------------------
-
-
-def _resolved_model(response: Any, requested: str) -> str:
-    """Return resolved response.model when it is a non-empty string, else requested."""
-    resolved = getattr(response, "model", None)
-    if isinstance(resolved, str) and resolved:
-        return resolved
-    return requested
-
-
-def _extract_usage_dict(response: Any) -> dict[str, Any] | None:
-    """Extract usage dict from Anthropic response.
-
-    Returns normalized usage dict or None if usage unavailable.
-    """
-    if not hasattr(response, "usage") or not response.usage:
-        return None
-
-    usage = response.usage
-    input_tokens = getattr(usage, "input_tokens", 0)
-    output_tokens = getattr(usage, "output_tokens", 0)
-    usage_dict: dict[str, Any] = {
-        "input_tokens": input_tokens,
-        "output_tokens": output_tokens,
-        "total_tokens": input_tokens + output_tokens,
-    }
-    # Add cache tokens if available and non-zero
-    cache_creation = getattr(usage, "cache_creation_input_tokens", None)
-    if cache_creation:
-        usage_dict["cache_creation_tokens"] = cache_creation
-    cache_read = getattr(usage, "cache_read_input_tokens", None)
-    if cache_read:
-        usage_dict["cached_tokens"] = cache_read
-    model_version = getattr(response, "model", None)
-    if isinstance(model_version, str) and model_version:
-        usage_dict["model_version"] = model_version
-    return usage_dict
-
-
-def _normalize_finish_reason(stop_reason: str | None) -> str | None:
-    """Normalize Anthropic stop_reason to standard values.
-
-    Returns normalized string: "stop", "max_tokens", or None.
-    """
-    if not stop_reason:
-        return None
-
-    reason = stop_reason.lower()
-    if reason == "end_turn":
-        return "stop"
-    elif reason == "max_tokens":
-        return "max_tokens"
-    elif reason == "stop_sequence":
-        return "stop"
-    else:
-        return reason
-
-
-def _extract_text_and_thinking(response: Any) -> tuple[str, list | None]:
-    """Extract text and thinking blocks from Anthropic response.
-
-    Returns tuple of (text, thinking_blocks).
-    """
-    text = ""
-    thinking_blocks = []
-
-    for block in response.content:
-        if getattr(block, "type", None) == "text":
-            text += block.text
-        elif isinstance(block, ThinkingBlock):
-            thinking_blocks.append(
-                {
-                    "summary": block.thinking,
-                    "signature": block.signature,
-                }
-            )
-        elif isinstance(block, RedactedThinkingBlock):
-            thinking_blocks.append(
-                {
-                    "summary": "[redacted]",
-                    "redacted_data": block.data,
-                }
-            )
-
-    return text, thinking_blocks if thinking_blocks else None
-
-
-def _adjust_budget_for_thinking(request_kwargs: dict[str, Any]) -> None:
-    """Lift max_tokens when thinking budget would otherwise collide with Anthropic validation."""
-    thinking = request_kwargs.get("thinking")
-    if not thinking:
-        return
-
-    budget_tokens = thinking.get("budget_tokens")
-    if not budget_tokens or budget_tokens <= 0:
-        return
-
-    max_tokens = request_kwargs["max_tokens"]
-    minimum_max_tokens = budget_tokens + _MAX_TOKENS_BUFFER + 1
-    if max_tokens <= budget_tokens + _MAX_TOKENS_BUFFER:
-        logger.info(
-            "Adjusted Anthropic max_tokens for thinking budget: %s -> %s",
-            max_tokens,
-            minimum_max_tokens,
-        )
-        # Anthropic requires max_tokens > thinking.budget_tokens; lift rather than clamp thinking so the caller's stated output floor is preserved.
-        request_kwargs["max_tokens"] = minimum_max_tokens
-
-
-def _requires_streaming(model: str, max_tokens: int) -> bool:
-    """Return whether the Anthropic SDK would require streaming for this request."""
-    if max_tokens > _NONSTREAMING_TIME_CAP_TOKENS:
-        return True
-    cap = MODEL_NONSTREAMING_TOKENS.get(model)
-    if cap is not None and max_tokens > cap:
-        return True
-    return False
-
-
-def _send_message(client: Any, request_kwargs: dict[str, Any]) -> Message:
-    """Dispatch sync message requests via create or stream based on Anthropic limits."""
-    if _requires_streaming(request_kwargs["model"], request_kwargs["max_tokens"]):
-        # Plain-float timeout maps to httpx Timeout(read=120s): silent streams
-        # are cut per-read; trickling streams can exceed wall-clock until L2/L4.
-        with client.messages.stream(**request_kwargs) as stream:
-            return stream.get_final_message()
-    return client.messages.create(**request_kwargs)
-
-
-async def _asend_message(client: Any, request_kwargs: dict[str, Any]) -> Message:
-    """Dispatch async message requests via create or stream based on Anthropic limits."""
-    if _requires_streaming(request_kwargs["model"], request_kwargs["max_tokens"]):
-        # Plain-float timeout maps to httpx Timeout(read=120s): silent streams
-        # are cut per-read; trickling streams can exceed wall-clock until L2/L4.
-        async with client.messages.stream(**request_kwargs) as stream:
-            return await stream.get_final_message()
-    return await client.messages.create(**request_kwargs)
-
-
-# Cache for Anthropic clients
-_anthropic_client = None
-_async_anthropic_client = None
-
-
-def _get_anthropic_client():
-    """Get or create sync Anthropic client."""
-    global _anthropic_client
-    if _anthropic_client is None:
-        from anthropic import Anthropic
-
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            raise ValueError("ANTHROPIC_API_KEY not found in environment")
-        _anthropic_client = Anthropic(
-            api_key=api_key,
-            timeout=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-    return _anthropic_client
-
-
-def _get_async_anthropic_client():
-    """Get or create async Anthropic client."""
-    global _async_anthropic_client
-    if _async_anthropic_client is None:
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            raise ValueError("ANTHROPIC_API_KEY not found in environment")
-        _async_anthropic_client = AsyncAnthropic(
-            api_key=api_key,
-            timeout=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-    return _async_anthropic_client
-
-
-def _convert_contents_to_messages(contents: Any) -> list[MessageParam]:
-    """Convert contents to Anthropic messages format."""
-    # Handle different content formats
-    if isinstance(contents, str):
-        return [{"role": "user", "content": contents}]
-    elif isinstance(contents, list):
-        # Check if it's already in messages format
-        if contents and isinstance(contents[0], dict) and "role" in contents[0]:
-            return contents
-        elif any(is_image_part(c) for c in contents):
-            content = []
-            for c in contents:
-                if is_image_part(c):
-                    media_type, b64 = encode_image_part(c)
-                    content.append(
-                        {
-                            "type": "image",
-                            "source": {
-                                "type": "base64",
-                                "media_type": media_type,
-                                "data": b64,
-                            },
-                        }
-                    )
-                else:
-                    content.append({"type": "text", "text": str(c)})
-            return [{"role": "user", "content": content}]
-        else:
-            # List of content parts - combine into single user message
-            combined = "\n".join(str(c) for c in contents)
-            return [{"role": "user", "content": combined}]
-    else:
-        return [{"role": "user", "content": str(contents)}]
-
-
-def run_generate(
-    contents: Any,
-    model: str = _DEFAULT_MODEL,
-    temperature: float = 0.3,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    thinking_budget: int | None = None,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text synchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = _get_anthropic_client()
-    messages = _convert_contents_to_messages(contents)
-
-    # Handle JSON output by adding to system instruction
-    system = system_instruction or ""
-    if json_schema is None and json_output:
-        json_instruction = "Respond with valid JSON only. No explanation or markdown."
-        system = f"{system}\n\n{json_instruction}" if system else json_instruction
-
-    # Build request kwargs
-    request_kwargs: dict[str, Any] = {
-        "model": model,
-        "max_tokens": max_output_tokens,
-        "messages": messages,
-    }
-
-    if system:
-        request_kwargs["system"] = system
-
-    # Note: Anthropic doesn't support temperature with thinking enabled
-    # Configure thinking if budget is provided
-    if thinking_budget and thinking_budget > 0:
-        request_kwargs["thinking"] = {
-            "type": "enabled",
-            "budget_tokens": thinking_budget,
-        }
-    elif model_supports(model, "temperature"):
-        request_kwargs["temperature"] = temperature
-    else:
-        # Some Anthropic reasoning models reject the temperature parameter.
-        pass
-    _adjust_budget_for_thinking(request_kwargs)
-
-    if timeout_s:
-        request_kwargs["timeout"] = timeout_s
-
-    if json_schema is not None:
-        request_kwargs["output_config"] = {
-            "format": {
-                "type": "json_schema",
-                "schema": json_schema,
-            }
-        }
-        response = _send_message(client, request_kwargs)
-        text, thinking = _extract_text_and_thinking(response)
-    else:
-        response = _send_message(client, request_kwargs)
-        text, thinking = _extract_text_and_thinking(response)
-
-    finish_reason = _normalize_finish_reason(response.stop_reason)
-    return GenerateResult(
-        text=text,
-        model=_resolved_model(response, model),
-        usage=_extract_usage_dict(response),
-        finish_reason=finish_reason,
-        thinking=thinking,
-    )
-
-
-async def run_agenerate(
-    contents: Any,
-    model: str = _DEFAULT_MODEL,
-    temperature: float = 0.3,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    thinking_budget: int | None = None,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text asynchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = _get_async_anthropic_client()
-    messages = _convert_contents_to_messages(contents)
-
-    # Handle JSON output by adding to system instruction
-    system = system_instruction or ""
-    if json_schema is None and json_output:
-        json_instruction = "Respond with valid JSON only. No explanation or markdown."
-        system = f"{system}\n\n{json_instruction}" if system else json_instruction
-
-    # Build request kwargs
-    request_kwargs: dict[str, Any] = {
-        "model": model,
-        "max_tokens": max_output_tokens,
-        "messages": messages,
-    }
-
-    if system:
-        request_kwargs["system"] = system
-
-    # Note: Anthropic doesn't support temperature with thinking enabled
-    # Configure thinking if budget is provided
-    if thinking_budget and thinking_budget > 0:
-        request_kwargs["thinking"] = {
-            "type": "enabled",
-            "budget_tokens": thinking_budget,
-        }
-    elif model_supports(model, "temperature"):
-        request_kwargs["temperature"] = temperature
-    else:
-        # Some Anthropic reasoning models reject the temperature parameter.
-        pass
-    _adjust_budget_for_thinking(request_kwargs)
-
-    if timeout_s:
-        request_kwargs["timeout"] = timeout_s
-
-    if json_schema is not None:
-        request_kwargs["output_config"] = {
-            "format": {
-                "type": "json_schema",
-                "schema": json_schema,
-            }
-        }
-        response = await _asend_message(client, request_kwargs)
-        text, thinking = _extract_text_and_thinking(response)
-    else:
-        response = await _asend_message(client, request_kwargs)
-        text, thinking = _extract_text_and_thinking(response)
-
-    finish_reason = _normalize_finish_reason(response.stop_reason)
-    return GenerateResult(
-        text=text,
-        model=_resolved_model(response, model),
-        usage=_extract_usage_dict(response),
-        finish_reason=finish_reason,
-        thinking=thinking,
-    )
-
-
-def list_models() -> list[dict]:
-    """List available Anthropic models.
-
-    Returns
-    -------
-    list[dict]
-        List of raw model info objects from the Anthropic API.
-    """
-    client = _get_anthropic_client()
-    return [m.model_dump() for m in client.models.list()]
-
-
-def validate_key(api_key: str) -> dict:
-    """Validate an Anthropic API key by listing models.
-
-    Creates a temporary client with the provided key. Never uses
-    the cached client or environment variables.
-
-    Returns {"valid": True} or {"valid": False, "error": "..."}.
-    """
-    try:
-        from anthropic import Anthropic
-
-        client = Anthropic(api_key=api_key, timeout=10)
-        list(client.models.list(limit=1))
-        return {"valid": True}
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "anthropic"),
-        }
-
-
-def validate_model(model: str, api_key: str) -> dict:
-    """Validate that an Anthropic API key can retrieve a model."""
-    import anthropic
-
-    try:
-        client = anthropic.Anthropic(api_key=api_key, timeout=10)
-        client.models.retrieve(model)
-        return {"valid": True}
-    except anthropic.NotFoundError as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": "model_not_found",
-        }
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "anthropic"),
-        }
-
-
-__all__ = [
-    "run_generate",
-    "run_agenerate",
-    "list_models",
-    "validate_key",
-    "validate_model",
-]
diff --git a/solstone/think/providers/google.py b/solstone/think/providers/google.py
deleted file mode 100644
index 6171eacfb..000000000
--- a/solstone/think/providers/google.py
+++ /dev/null
@@ -1,780 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-"""Gemini provider for agents and direct LLM generation.
-
-This module provides the Google Gemini provider for the ``journal providers check`` CLI
-and run_generate/run_agenerate functions returning GenerateResult.
-
-Common Parameters
------------------
-contents : str or list
-    The content to send to the model.
-model : str
-    Model name to use.
-temperature : float
-    Temperature for generation (default: 0.3).
-max_output_tokens : int
-    Maximum tokens for the model's response output.
-system_instruction : str, optional
-    System instruction for the model.
-json_output : bool
-    Whether to request JSON response format.
-thinking_budget : int, optional
-    Token budget for model thinking.
-timeout_s : float, optional
-    Request timeout in seconds.
-**kwargs
-    Provider-specific options (client).
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import TYPE_CHECKING, Any
-
-from solstone.think.models import DEFAULT_PROVIDER_TIMEOUT_S, GEMINI_FLASH
-
-from .shared import GenerateResult, classify_provider_error
-
-if TYPE_CHECKING:
-    from google import genai
-    from google.genai import types
-
-# Vertex's `maxOutputTokens` accepts 1..65535 inclusive — exactly 65536 returns
-# 400 INVALID_ARGUMENT ("supported range is from 1 (inclusive) to 65536
-# (exclusive)"). The clamp logic in _build_generate_config sums max_output_tokens
-# + thinking_budget into this single field, so the bound applies to the total.
-GEMINI_MAX_OUTPUT_TOKENS = 65535
-_DEFAULT_MAX_TOKENS = 8192
-_DEFAULT_MODEL = GEMINI_FLASH
-
-# Backend detection cache
-_detected_backend: str | None = None
-
-
-def _structured_to_google_contents(
-    messages: list[dict[str, str]],
-) -> list[types.Content]:
-    """Map role/content dicts to Gemini-native Content objects."""
-    from google.genai import types
-
-    mapped: list[types.Content] = []
-    for msg in messages:
-        role = msg["role"]
-        if role == "user":
-            google_role = "user"
-        elif role == "assistant":
-            google_role = "model"
-        else:
-            raise ValueError(f"Unknown message role: {role!r}")
-        mapped.append(
-            types.Content(
-                role=google_role,
-                parts=[types.Part(text=msg["content"])],
-            )
-        )
-    return mapped
-
-
-# ---------------------------------------------------------------------------
-# Client and helper functions for generate/agenerate
-# ---------------------------------------------------------------------------
-
-
-def _probe_backend(api_key: str) -> str:
-    """Probe AI Studio endpoint to classify key type.
-
-    Returns ``"aistudio"`` when the key works against the AI Studio models
-    endpoint (HTTP 200) or ``"vertex"`` otherwise. Network errors default
-    to ``"aistudio"`` for backward compatibility.
-    """
-    try:
-        import httpx
-
-        resp = httpx.get(
-            "https://generativelanguage.googleapis.com/v1beta/models",
-            params={"key": api_key},
-            timeout=5,
-        )
-        return "aistudio" if resp.status_code == 200 else "vertex"
-    except Exception:
-        return "aistudio"
-
-
-def _detect_backend(api_key: str) -> str:
-    """Return cached backend detection result, probing on first call."""
-    global _detected_backend
-    if _detected_backend is not None:
-        return _detected_backend
-    _detected_backend = _probe_backend(api_key)
-    return _detected_backend
-
-
-def _get_effective_backend(api_key: str) -> str:
-    """Return effective backend, checking config override before cache.
-
-    Reads ``providers.google_backend`` from journal config. Values
-    ``"aistudio"`` or ``"vertex"`` bypass detection; ``"auto"`` (the default
-    when the key is absent) uses :func:`_detect_backend`.
-    """
-    from solstone.think.utils import get_config
-
-    configured = get_config().get("providers", {}).get("google_backend", "auto")
-    if configured in ("aistudio", "vertex"):
-        return configured
-    return _detect_backend(api_key)
-
-
-def _active_backend() -> str | None:
-    """Return the currently-active Google backend ("aistudio" | "vertex"), or None.
-
-    Mirrors the resolution order in :func:`get_or_create_client` so callers can
-    decide backend-specific behavior (e.g. alias remapping) without duplicating
-    config-vs-env-vs-cache logic. Returns ``None`` when no backend can be
-    determined (no config override, no API key) — callers should treat that as
-    "unknown" rather than guessing.
-    """
-    from solstone.think.utils import get_config
-
-    configured = get_config().get("providers", {}).get("google_backend", "auto")
-    if configured in ("aistudio", "vertex"):
-        return configured
-    api_key = os.getenv("GOOGLE_API_KEY")
-    if api_key:
-        return _get_effective_backend(api_key)
-    return None
-
-
-# Google publishes the `gemini-*-latest` aliases on AI Studio
-# (`generativelanguage.googleapis.com`) but Vertex AI's publisher-model registry
-# only honors them for the flash tiers — `gemini-pro-latest` 404s on Vertex.
-# AI Studio is the default path for the vast majority of solstone users, so we
-# keep `-latest` as the canonical model identifier across the codebase (preserves
-# Google's auto-upgrade for those users) and remap only on the Vertex hop.
-# When bumping the Vertex target, list models from a Vertex-backed client and
-# pick the most recent `gemini-<N>.<M>-pro[-preview]` that resolves cleanly —
-# we deliberately track the latest preview here rather than retreating to GA,
-# matching the spirit of the `-latest` rail we're substituting for.
-_VERTEX_MODEL_ALIASES: dict[str, str] = {
-    "gemini-pro-latest": "gemini-3.1-pro-preview",
-}
-
-
-def _resolve_model_for_backend(model: str, backend: str | None) -> str:
-    """Substitute backend-specific identifiers for known provider aliases."""
-    if model not in _VERTEX_MODEL_ALIASES:
-        return model
-    if backend != "vertex":
-        return model
-    return _VERTEX_MODEL_ALIASES[model]
-
-
-def _resolve_model_for_vertex(model: str) -> str:
-    """Substitute Vertex-resolvable identifiers for AI-Studio-only aliases.
-
-    No-op unless the active backend is Vertex AND the model is a known-broken
-    alias on Vertex. See :data:`_VERTEX_MODEL_ALIASES` for the mapping and the
-    rationale comment above it.
-    """
-    return _resolve_model_for_backend(model, _active_backend())
-
-
-def get_or_create_client(client: genai.Client | None = None) -> genai.Client:
-    """Get existing client or create new one.
-
-    For Vertex AI backend, uses service account credentials from config
-    or falls back to GOOGLE_APPLICATION_CREDENTIALS env var.
-    For AI Studio / auto-detect, uses GOOGLE_API_KEY.
-    """
-    if client is not None:
-        return client
-
-    from google import genai
-    from google.genai import types
-
-    from solstone.think.utils import get_config
-
-    config = get_config()
-    providers_config = config.get("providers", {})
-
-    # attempts=3 (was 8) bounds the retry storm; per-call timeout arrives via
-    # _build_generate_config (models.py default 120s) and the SDK merges client
-    # retry_options + per-request timeout field-by-field. Worst-case wall is
-    # about 3 * DEFAULT_PROVIDER_TIMEOUT_S + SDK backoff, versus the unbounded
-    # hang attempts=8-with-no-timeout produced (the 77h describe wedge).
-    http_options = types.HttpOptions(
-        timeout=int(DEFAULT_PROVIDER_TIMEOUT_S * 1000),
-        retry_options=types.HttpRetryOptions(attempts=3),
-    )
-
-    api_key = os.getenv("GOOGLE_API_KEY")
-
-    # Determine backend
-    configured_backend = providers_config.get("google_backend", "auto")
-    if configured_backend == "vertex":
-        backend = "vertex"
-    elif configured_backend == "aistudio":
-        backend = "aistudio"
-    elif api_key:
-        backend = _get_effective_backend(api_key)
-    else:
-        raise ValueError("GOOGLE_API_KEY not found in environment")
-
-    if backend == "vertex":
-        creds_path = providers_config.get("vertex_credentials")
-
-        client_kwargs: dict[str, Any] = {
-            "vertexai": True,
-            "http_options": http_options,
-        }
-
-        if creds_path and os.path.exists(creds_path):
-            import json as _json
-
-            from google.oauth2.service_account import Credentials
-
-            creds = Credentials.from_service_account_file(
-                creds_path,
-                scopes=["https://www.googleapis.com/auth/cloud-platform"],
-            )
-            client_kwargs["credentials"] = creds
-            with open(creds_path, encoding="utf-8") as _f:
-                _sa_data = _json.load(_f)
-            if "project_id" in _sa_data:
-                client_kwargs["project"] = _sa_data["project_id"]
-        elif not os.getenv("GOOGLE_APPLICATION_CREDENTIALS"):
-            raise ValueError(
-                "Vertex AI backend requires service account credentials. "
-                "Configure in Settings or set GOOGLE_APPLICATION_CREDENTIALS."
-            )
-        # else: GOOGLE_APPLICATION_CREDENTIALS is set, SDK auto-discovers
-
-        client = genai.Client(**client_kwargs)
-    else:
-        # AI Studio path
-        if not api_key:
-            raise ValueError("GOOGLE_API_KEY not found in environment")
-        client = genai.Client(
-            api_key=api_key,
-            vertexai=False,
-            http_options=http_options,
-        )
-
-    return client
-
-
-def _build_generate_config(
-    temperature: float,
-    max_output_tokens: int,
-    system_instruction: str | None,
-    json_output: bool,
-    thinking_budget: int | None,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-) -> types.GenerateContentConfig:
-    """Build the GenerateContentConfig.
-
-    Note: Gemini's max_output_tokens is actually the total budget (thinking + output).
-    We compute this internally: total = max_output_tokens + thinking_budget.
-    """
-    from google.genai import types
-
-    # Compute total tokens: output + thinking budget
-    total_tokens = max_output_tokens + (thinking_budget or 0)
-    if total_tokens > GEMINI_MAX_OUTPUT_TOKENS:
-        clamped_max_output = min(max_output_tokens, GEMINI_MAX_OUTPUT_TOKENS)
-        clamped_thinking = max(0, GEMINI_MAX_OUTPUT_TOKENS - clamped_max_output)
-        logging.getLogger(__name__).warning(
-            "Clamping Gemini token budget: max_output_tokens=%s thinking_budget=%s "
-            "clamped_max_output_tokens=%s clamped_thinking_budget=%s",
-            max_output_tokens,
-            thinking_budget,
-            clamped_max_output,
-            clamped_thinking,
-        )
-        thinking_budget = clamped_thinking
-        total_tokens = clamped_max_output + clamped_thinking
-
-    config_args: dict[str, Any] = {
-        "temperature": temperature,
-        "max_output_tokens": total_tokens,
-    }
-
-    if system_instruction:
-        config_args["system_instruction"] = system_instruction
-
-    if json_output:
-        config_args["response_mime_type"] = "application/json"
-        if json_schema is not None:
-            config_args["response_json_schema"] = json_schema
-
-    # Set thinking config when caller explicitly specified a budget.
-    # thinking_budget=0 must explicitly disable thinking (not omit config),
-    # otherwise Gemini applies its own default budget consuming output tokens.
-    if thinking_budget is not None:
-        config_args["thinking_config"] = types.ThinkingConfig(
-            thinking_budget=thinking_budget
-        )
-
-    if timeout_s:
-        # Convert seconds to milliseconds for the SDK
-        timeout_ms = int(timeout_s * 1000)
-        config_args["http_options"] = types.HttpOptions(timeout=timeout_ms)
-
-    return types.GenerateContentConfig(**config_args)
-
-
-def _extract_response_text(response: Any) -> str:
-    """Extract text from response.
-
-    Returns response.text if available, or "" if the response is empty.
-    Raises on safety filter blocks.
-
-    Parameters
-    ----------
-    response
-        The response from the model.
-    """
-    if response is None:
-        raise ValueError("No response from model")
-
-    # Check for error conditions in candidates
-    finish_reason = _extract_finish_reason(response)
-    if finish_reason and "SAFETY" in finish_reason.upper():
-        raise ValueError(f"Response blocked by safety filters: {finish_reason}")
-
-    # Extract text; empty non-safety completions are represented honestly as empty.
-    text = response.text if response.text else ""
-    return text
-
-
-def _normalize_finish_reason(response: Any) -> str | None:
-    """Normalize finish_reason to standard values.
-
-    Returns normalized string: "stop", "max_tokens", "safety", or None.
-    """
-    raw = _extract_finish_reason(response)
-    if not raw:
-        return None
-
-    # Normalize (handle both enum names and string values)
-    reason = raw.upper().replace("FINISHREASON.", "")
-
-    if reason == "STOP":
-        return "stop"
-    elif reason == "MAX_TOKENS":
-        return "max_tokens"
-    elif "SAFETY" in reason:
-        return "safety"
-    elif reason == "RECITATION":
-        return "recitation"
-    else:
-        return reason.lower()
-
-
-def _extract_usage(response: Any) -> dict | None:
-    """Extract normalized usage dict from response."""
-    if not hasattr(response, "usage_metadata") or not response.usage_metadata:
-        return None
-
-    metadata = response.usage_metadata
-    usage: dict[str, Any] = {
-        "input_tokens": getattr(metadata, "prompt_token_count", 0),
-        "output_tokens": getattr(metadata, "candidates_token_count", 0),
-        "total_tokens": getattr(metadata, "total_token_count", 0),
-    }
-    model_version = getattr(response, "model_version", None)
-    if isinstance(model_version, str) and model_version:
-        usage["model_version"] = model_version
-    # Only include optional fields if non-zero
-    cached = getattr(metadata, "cached_content_token_count", 0)
-    if cached:
-        usage["cached_tokens"] = cached
-    reasoning = getattr(metadata, "thoughts_token_count", 0)
-    if reasoning:
-        usage["reasoning_tokens"] = reasoning
-    return usage
-
-
-def _resolved_model(response: Any, requested: str) -> str:
-    """Return resolved response.model_version when it is a non-empty string, else requested."""
-    resolved = getattr(response, "model_version", None)
-    if isinstance(resolved, str) and resolved:
-        return resolved
-    return requested
-
-
-def _extract_thinking(response: Any) -> list | None:
-    """Extract thinking blocks from response.
-
-    Returns list of ThinkingBlock dicts or None if no thinking.
-    """
-    if not hasattr(response, "candidates") or not response.candidates:
-        return None
-
-    thinking_blocks = []
-    for candidate in response.candidates:
-        if not candidate.content or not candidate.content.parts:
-            continue
-        for part in candidate.content.parts:
-            if getattr(part, "thought", False) and getattr(part, "text", None):
-                thinking_blocks.append({"summary": part.text})
-
-    return thinking_blocks if thinking_blocks else None
-
-
-def _extract_finish_reason(response: Any) -> str | None:
-    """Extract finish_reason from response candidates.
-
-    Returns the finish_reason string (e.g., "STOP", "MAX_TOKENS") or None
-    if not available.
-    """
-    if not hasattr(response, "candidates") or not response.candidates:
-        return None
-
-    candidate = response.candidates[0]
-    if hasattr(candidate, "finish_reason") and candidate.finish_reason:
-        # Convert enum to string if needed
-        reason = candidate.finish_reason
-        if hasattr(reason, "name"):
-            return reason.name
-        return str(reason)
-    return None
-
-
-def _summarize_contents(contents: Any) -> str:
-    """One-line, PII-free fingerprint of the contents passed to generate_content.
-
-    Captures part count, types, and image sizes — enough to correlate a 400 with
-    the call shape without leaking text bodies. Used only by error logging.
-    """
-    from google.genai import types
-
-    if isinstance(contents, str):
-        return f"str(len={len(contents)})"
-    if not isinstance(contents, list):
-        return f"other({type(contents).__name__})"
-    parts: list[str] = []
-    for item in contents:
-        if isinstance(item, str):
-            parts.append(f"s{len(item)}")
-        elif isinstance(item, dict) and "role" in item:
-            parts.append(f"d({item.get('role')})")
-        elif isinstance(item, types.Part):
-            mime = getattr(getattr(item, "inline_data", None), "mime_type", None)
-            parts.append(f"p({mime or '?'})")
-        elif isinstance(item, types.Content):
-            parts.append(f"c({item.role})")
-        else:
-            size = getattr(item, "size", None)
-            if size is not None:
-                parts.append(f"i({size[0]}x{size[1]})")
-            else:
-                parts.append(type(item).__name__[:6])
-    return f"list[{len(parts)}]={','.join(parts)}"
-
-
-def _log_provider_error(
-    exc: BaseException,
-    *,
-    model: str,
-    contents: Any,
-    config: types.GenerateContentConfig,
-) -> None:
-    """Emit a structured log line when generate_content raises a ClientError.
-
-    Captures the SDK-returned error body (which Cloud Monitoring does not surface)
-    so we can categorize 400s offline. WARNING level so the line lands in
-    solstone's normal log streams without changing existing exception propagation.
-    """
-    from google.genai import errors as _genai_errors
-
-    if not isinstance(exc, _genai_errors.APIError):
-        return
-
-    status_code = getattr(exc, "code", None) or getattr(exc, "status_code", None)
-    json_schema_present = getattr(config, "response_json_schema", None) is not None
-    thinking_cfg = getattr(config, "thinking_config", None)
-    thinking_budget = (
-        getattr(thinking_cfg, "thinking_budget", None) if thinking_cfg else None
-    )
-
-    logging.getLogger(__name__).warning(
-        "google_provider_error status=%s model=%s backend=%s "
-        "contents=%s json=%s schema=%s thinking_budget=%s max_output_tokens=%s "
-        "body=%s",
-        status_code,
-        model,
-        _active_backend() or "unknown",
-        _summarize_contents(contents),
-        bool(getattr(config, "response_mime_type", "")),
-        json_schema_present,
-        thinking_budget,
-        getattr(config, "max_output_tokens", None),
-        str(exc)[:2000],
-    )
-
-
-# ---------------------------------------------------------------------------
-# run_generate / run_agenerate functions
-# ---------------------------------------------------------------------------
-
-
-def run_generate(
-    contents: str | list[Any],
-    model: str = _DEFAULT_MODEL,
-    temperature: float = 0.3,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    thinking_budget: int | None = None,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text synchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = kwargs.get("client")
-
-    client = get_or_create_client(client)
-    model = _resolve_model_for_vertex(model)
-    if isinstance(contents, str):
-        contents = [contents]
-    elif (
-        isinstance(contents, list)
-        and contents
-        and isinstance(contents[0], dict)
-        and "role" in contents[0]
-    ):
-        contents = _structured_to_google_contents(contents)
-    config = _build_generate_config(
-        temperature=temperature,
-        max_output_tokens=max_output_tokens,
-        system_instruction=system_instruction,
-        json_output=json_output,
-        thinking_budget=thinking_budget,
-        json_schema=json_schema,
-        timeout_s=timeout_s,
-    )
-
-    try:
-        response = client.models.generate_content(
-            model=model,
-            contents=contents,
-            config=config,
-        )
-    except Exception as exc:
-        _log_provider_error(exc, model=model, contents=contents, config=config)
-        raise
-
-    return GenerateResult(
-        text=_extract_response_text(response),
-        model=_resolved_model(response, model),
-        usage=_extract_usage(response),
-        finish_reason=_normalize_finish_reason(response),
-        thinking=_extract_thinking(response),
-    )
-
-
-async def run_agenerate(
-    contents: str | list[Any],
-    model: str = _DEFAULT_MODEL,
-    temperature: float = 0.3,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    thinking_budget: int | None = None,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text asynchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = kwargs.get("client")
-
-    client = get_or_create_client(client)
-    model = _resolve_model_for_vertex(model)
-    if isinstance(contents, str):
-        contents = [contents]
-    elif (
-        isinstance(contents, list)
-        and contents
-        and isinstance(contents[0], dict)
-        and "role" in contents[0]
-    ):
-        contents = _structured_to_google_contents(contents)
-    config = _build_generate_config(
-        temperature=temperature,
-        max_output_tokens=max_output_tokens,
-        system_instruction=system_instruction,
-        json_output=json_output,
-        thinking_budget=thinking_budget,
-        json_schema=json_schema,
-        timeout_s=timeout_s,
-    )
-
-    try:
-        response = await client.aio.models.generate_content(
-            model=model,
-            contents=contents,
-            config=config,
-        )
-    except Exception as exc:
-        _log_provider_error(exc, model=model, contents=contents, config=config)
-        raise
-
-    return GenerateResult(
-        text=_extract_response_text(response),
-        model=_resolved_model(response, model),
-        usage=_extract_usage(response),
-        finish_reason=_normalize_finish_reason(response),
-        thinking=_extract_thinking(response),
-    )
-
-
-def list_models() -> list[dict]:
-    """List available Google Gemini models.
-
-    Returns
-    -------
-    list[dict]
-        List of raw model info objects from the Google Gemini API.
-    """
-    client = get_or_create_client()
-    return [m.model_dump() for m in client.models.list()]
-
-
-def validate_key(api_key: str) -> dict:
-    """Validate a Google API key by listing models.
-
-    Creates a temporary client with the provided key. Never uses
-    the cached client or environment variables.
-
-    Returns {"valid": True, "backend": "aistudio"|"vertex"} or
-    {"valid": False, "error": "..."}.
-    """
-    global _detected_backend
-    try:
-        from google import genai
-        from google.genai import types
-
-        # Probe backend for this specific key (always probes, bypasses cache).
-        backend = _probe_backend(api_key)
-
-        client_kwargs = {
-            "api_key": api_key,
-            "http_options": types.HttpOptions(timeout=10000),
-            "vertexai": backend == "vertex",
-        }
-
-        client = genai.Client(**client_kwargs)
-        list(client.models.list(config={"page_size": 1}))
-        _detected_backend = backend  # only cache after successful validation
-        return {"valid": True, "backend": backend}
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "google"),
-        }
-
-
-def validate_model(model: str, api_key: str) -> dict:
-    """Validate that a Google API key can retrieve a model."""
-    from google import genai
-    from google.genai import types
-    from google.genai.errors import ClientError
-
-    try:
-        backend = _probe_backend(api_key)
-        client = genai.Client(
-            api_key=api_key,
-            http_options=types.HttpOptions(timeout=10000),
-            vertexai=backend == "vertex",
-        )
-        client.models.get(model=_resolve_model_for_backend(model, backend))
-        return {"valid": True}
-    except ClientError as e:
-        if e.code == 404:
-            return {
-                "valid": False,
-                "error": str(e),
-                "reason_code": "model_not_found",
-            }
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "google"),
-        }
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "google"),
-        }
-
-
-def validate_vertex_credentials(
-    creds_path: str,
-) -> dict:
-    """Validate Vertex AI service account credentials by listing models.
-
-    Creates a temporary client with the provided SA credentials.
-
-    Returns {"valid": True, "email": "..."} or {"valid": False, "error": "..."}.
-    """
-    try:
-        import json as _json
-
-        from google import genai
-        from google.genai import types
-        from google.oauth2.service_account import Credentials
-
-        creds = Credentials.from_service_account_file(
-            creds_path,
-            scopes=["https://www.googleapis.com/auth/cloud-platform"],
-        )
-        client_kwargs: dict[str, Any] = {
-            "vertexai": True,
-            "credentials": creds,
-            "http_options": types.HttpOptions(timeout=10000),
-        }
-        with open(creds_path, encoding="utf-8") as _f:
-            _sa_data = _json.load(_f)
-        if "project_id" in _sa_data:
-            client_kwargs["project"] = _sa_data["project_id"]
-
-        client = genai.Client(**client_kwargs)
-        list(client.models.list(config={"page_size": 1}))
-        return {"valid": True, "email": creds.service_account_email}
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "google"),
-        }
-
-
-__all__ = [
-    "run_generate",
-    "run_agenerate",
-    "get_or_create_client",
-    "_detect_backend",
-    "_get_effective_backend",
-    "_active_backend",
-    "_resolve_model_for_backend",
-    "_resolve_model_for_vertex",
-    "list_models",
-    "validate_key",
-    "validate_model",
-    "validate_vertex_credentials",
-]
diff --git a/solstone/think/providers/local.py b/solstone/think/providers/local.py
index ccf651beb..f748f6691 100644
--- a/solstone/think/providers/local.py
+++ b/solstone/think/providers/local.py
@@ -551,6 +551,9 @@ def run_generate(
     del thinking_budget
     retry_index = int(kwargs.pop("inference_retry_index", 0) or 0)
     local_exclusive_admission = bool(kwargs.pop("local_exclusive_admission", False))
+    if kwargs:
+        unknown = ", ".join(sorted(kwargs))
+        raise TypeError(f"Unsupported local generate options: {unknown}")
     endpoint = resolve_local_endpoint()
     # Validate the requested logical id; served id comes from the server.
     normalize_model_id(model)
@@ -722,6 +725,9 @@ async def run_agenerate(
     del thinking_budget
     retry_index = int(kwargs.pop("inference_retry_index", 0) or 0)
     local_exclusive_admission = bool(kwargs.pop("local_exclusive_admission", False))
+    if kwargs:
+        unknown = ", ".join(sorted(kwargs))
+        raise TypeError(f"Unsupported local generate options: {unknown}")
     endpoint = resolve_local_endpoint()
     normalize_model_id(model)
     messages = _build_messages(contents, system_instruction)
diff --git a/solstone/think/providers/openai.py b/solstone/think/providers/openai.py
deleted file mode 100644
index 65402c1b7..000000000
--- a/solstone/think/providers/openai.py
+++ /dev/null
@@ -1,399 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-"""OpenAI provider for agents and direct LLM generation.
-
-This module provides the OpenAI provider for the ``journal providers check`` CLI
-and run_generate/run_agenerate functions returning GenerateResult.
-
-Common Parameters
------------------
-contents : str or list
-    The content to send to the model.
-model : str
-    Model name, optionally with a reasoning effort suffix.
-    Supported suffixes: ``-none``, ``-low``, ``-medium``, ``-high``, ``-xhigh``.
-    Example: ``"gpt-5.2-high"`` sends ``reasoning={"effort": "high"}`` to the API.
-    Without a suffix, ``reasoning`` is omitted (OpenAI model default).
-max_output_tokens : int
-    Maximum tokens for the model's response output.
-system_instruction : str, optional
-    System instruction for the model.
-json_output : bool
-    Whether to request JSON response format.
-timeout_s : float, optional
-    Request timeout in seconds.
-**kwargs
-    Additional provider-specific options.
-
-Note: GPT-5+ reasoning models don't support custom temperature (fixed at 1.0).
-"""
-
-from __future__ import annotations
-
-import os
-import re
-from typing import Any
-
-from solstone.think.models import (
-    DEFAULT_PROVIDER_TIMEOUT_S,
-    GPT_5,
-    OPENAI_EFFORT_SUFFIXES,
-)
-from solstone.think.providers._image import encode_image_part, is_image_part
-
-from .shared import GenerateResult, classify_provider_error
-
-# Agent configuration is now loaded via get_talent() in cortex.py
-
-_SCHEMA_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
-
-
-def _parse_model_effort(model: str) -> tuple[str, str | None]:
-    """Extract reasoning effort suffix from a model name.
-
-    Returns (api_model, effort) where api_model has the suffix stripped
-    and effort is the reasoning effort value (or None if no suffix).
-    """
-    for suffix in OPENAI_EFFORT_SUFFIXES:
-        if model.endswith(suffix):
-            return model[: -len(suffix)], suffix[1:]
-    return model, None
-
-
-# ---------------------------------------------------------------------------
-# run_generate / run_agenerate functions
-# ---------------------------------------------------------------------------
-
-# Cache for OpenAI clients
-_openai_client = None
-_async_openai_client = None
-
-
-def _get_openai_client():
-    """Get or create sync OpenAI client."""
-    global _openai_client
-    if _openai_client is None:
-        import openai
-
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY not found in environment")
-        _openai_client = openai.OpenAI(
-            api_key=api_key,
-            timeout=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-    return _openai_client
-
-
-def _get_async_openai_client():
-    """Get or create async OpenAI client."""
-    global _async_openai_client
-    if _async_openai_client is None:
-        import openai
-
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY not found in environment")
-        _async_openai_client = openai.AsyncOpenAI(
-            api_key=api_key,
-            timeout=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-    return _async_openai_client
-
-
-def _build_input(
-    contents: Any,
-    system_instruction: str | None = None,
-) -> tuple[Any, str | None]:
-    """Build OpenAI Responses input and system instructions."""
-    if isinstance(contents, str):
-        return contents, system_instruction
-    if isinstance(contents, list):
-        if contents and isinstance(contents[0], dict) and "role" in contents[0]:
-            return contents, system_instruction
-        if any(is_image_part(c) for c in contents):
-            content = []
-            for c in contents:
-                if is_image_part(c):
-                    media_type, b64 = encode_image_part(c)
-                    content.append(
-                        {
-                            "type": "input_image",
-                            "image_url": f"data:{media_type};base64,{b64}",
-                            "detail": "auto",
-                        }
-                    )
-                else:
-                    content.append({"type": "input_text", "text": str(c)})
-            return [{"role": "user", "content": content}], system_instruction
-        return "\n".join(str(c) for c in contents), system_instruction
-    return str(contents), system_instruction
-
-
-def _derive_schema_name(schema: dict | None) -> str:
-    """Return a valid schema name for OpenAI structured outputs."""
-    if isinstance(schema, dict):
-        title = schema.get("title")
-        if isinstance(title, str) and title and _SCHEMA_NAME_RE.fullmatch(title):
-            return title
-    return "response"
-
-
-def _normalize_finish_reason(response: Any) -> str | None:
-    """Normalize OpenAI finish_reason to standard values.
-
-    Returns normalized string: "stop", "max_tokens", "content_filter", or None.
-    """
-    if not response or not getattr(response, "status", None):
-        return None
-
-    status = response.status
-    if status == "completed":
-        return "stop"
-    if status == "incomplete":
-        incomplete_details = getattr(response, "incomplete_details", None)
-        if (
-            incomplete_details is not None
-            and getattr(incomplete_details, "reason", None) == "content_filter"
-        ):
-            return "content_filter"
-        return "max_tokens"
-    if status == "failed":
-        return "error"
-    return status
-
-
-def _extract_thinking(response: Any) -> list | None:
-    """Extract reasoning summaries from Responses API output.
-
-    Returns list of thinking block dicts or None if no reasoning.
-    """
-    if not hasattr(response, "output") or not response.output:
-        return None
-
-    thinking_blocks = []
-    for item in response.output:
-        if getattr(item, "type", None) != "reasoning":
-            continue
-        for summary in getattr(item, "summary", None) or []:
-            text = getattr(summary, "text", None)
-            if text:
-                thinking_blocks.append({"summary": text})
-
-    return thinking_blocks if thinking_blocks else None
-
-
-def _resolved_model(response: Any, requested: str) -> str:
-    """Return resolved response.model when it is a non-empty string, else requested."""
-    resolved = getattr(response, "model", None)
-    if isinstance(resolved, str) and resolved:
-        return resolved
-    return requested
-
-
-def _extract_usage(response: Any) -> dict | None:
-    """Extract normalized usage dict from OpenAI response."""
-    if not response.usage:
-        return None
-
-    usage: dict[str, Any] = {
-        "input_tokens": response.usage.input_tokens,
-        "output_tokens": response.usage.output_tokens,
-        "total_tokens": response.usage.total_tokens,
-    }
-    # Extract optional detail fields
-    input_details = getattr(response.usage, "input_tokens_details", None)
-    if input_details:
-        cached = getattr(input_details, "cached_tokens", 0)
-        if cached:
-            usage["cached_tokens"] = cached
-    output_details = getattr(response.usage, "output_tokens_details", None)
-    if output_details:
-        reasoning = getattr(output_details, "reasoning_tokens", 0)
-        if reasoning:
-            usage["reasoning_tokens"] = reasoning
-    model_version = getattr(response, "model", None)
-    if isinstance(model_version, str) and model_version:
-        usage["model_version"] = model_version
-    return usage
-
-
-def run_generate(
-    contents: Any,
-    model: str = GPT_5,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text synchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = _get_openai_client()
-    input_content, instructions = _build_input(contents, system_instruction)
-
-    # Parse effort suffix from model name (e.g., "gpt-5.2-high" → "gpt-5.2", "high")
-    api_model, effort = _parse_model_effort(model)
-
-    # Build request kwargs
-    request_kwargs: dict[str, Any] = {
-        "model": api_model,
-        "input": input_content,
-        "max_output_tokens": max_output_tokens,
-    }
-    if instructions is not None:
-        request_kwargs["instructions"] = instructions
-    if effort is not None:
-        request_kwargs["reasoning"] = {"effort": effort}
-
-    if json_schema is not None:
-        request_kwargs["text"] = {
-            "format": {
-                "type": "json_schema",
-                "name": _derive_schema_name(json_schema),
-                "schema": json_schema,
-                "strict": True,
-            }
-        }
-    elif json_output:
-        request_kwargs["text"] = {"format": {"type": "json_object"}}
-
-    if timeout_s:
-        request_kwargs["timeout"] = timeout_s
-
-    response = client.responses.create(**request_kwargs)
-    return GenerateResult(
-        text=response.output_text or "",
-        model=_resolved_model(response, model),
-        usage=_extract_usage(response),
-        finish_reason=_normalize_finish_reason(response),
-        thinking=_extract_thinking(response),
-    )
-
-
-async def run_agenerate(
-    contents: Any,
-    model: str = GPT_5,
-    max_output_tokens: int = 8192 * 2,
-    system_instruction: str | None = None,
-    json_output: bool = False,
-    json_schema: dict | None = None,
-    timeout_s: float | None = None,
-    **kwargs: Any,
-) -> GenerateResult:
-    """Generate text asynchronously.
-
-    Returns GenerateResult with text, usage, finish_reason, and thinking.
-    See module docstring for parameter details.
-    """
-    client = _get_async_openai_client()
-    input_content, instructions = _build_input(contents, system_instruction)
-
-    # Parse effort suffix from model name (e.g., "gpt-5.2-high" → "gpt-5.2", "high")
-    api_model, effort = _parse_model_effort(model)
-
-    # Build request kwargs
-    request_kwargs: dict[str, Any] = {
-        "model": api_model,
-        "input": input_content,
-        "max_output_tokens": max_output_tokens,
-    }
-    if instructions is not None:
-        request_kwargs["instructions"] = instructions
-    if effort is not None:
-        request_kwargs["reasoning"] = {"effort": effort}
-
-    if json_schema is not None:
-        request_kwargs["text"] = {
-            "format": {
-                "type": "json_schema",
-                "name": _derive_schema_name(json_schema),
-                "schema": json_schema,
-                "strict": True,
-            }
-        }
-    elif json_output:
-        request_kwargs["text"] = {"format": {"type": "json_object"}}
-
-    if timeout_s:
-        request_kwargs["timeout"] = timeout_s
-
-    response = await client.responses.create(**request_kwargs)
-    return GenerateResult(
-        text=response.output_text or "",
-        model=_resolved_model(response, model),
-        usage=_extract_usage(response),
-        finish_reason=_normalize_finish_reason(response),
-        thinking=_extract_thinking(response),
-    )
-
-
-def list_models() -> list[dict]:
-    """List available OpenAI models.
-
-    Returns
-    -------
-    list[dict]
-        List of raw model info objects from the OpenAI API.
-    """
-    client = _get_openai_client()
-    return [m.model_dump() for m in client.models.list()]
-
-
-def validate_key(api_key: str) -> dict:
-    """Validate an OpenAI API key by listing models.
-
-    Creates a temporary client with the provided key. Never uses
-    the cached client or environment variables.
-
-    Returns {"valid": True} or {"valid": False, "error": "..."}.
-    """
-    try:
-        import openai
-
-        client = openai.OpenAI(api_key=api_key, timeout=10)
-        list(client.models.list())
-        return {"valid": True}
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "openai"),
-        }
-
-
-def validate_model(model: str, api_key: str) -> dict:
-    """Validate that an OpenAI API key can retrieve a model."""
-    import openai
-
-    try:
-        client = openai.OpenAI(api_key=api_key, timeout=10)
-        client.models.retrieve(model)
-        return {"valid": True}
-    except openai.NotFoundError as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": "model_not_found",
-        }
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "reason_code": classify_provider_error(e, "openai"),
-        }
-
-
-__all__ = [
-    "run_generate",
-    "run_agenerate",
-    "list_models",
-    "validate_key",
-    "validate_model",
-]
diff --git a/solstone/think/providers/openhands.py b/solstone/think/providers/openhands.py
index eccd4091b..98a8231ee 100644
--- a/solstone/think/providers/openhands.py
+++ b/solstone/think/providers/openhands.py
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 # Copyright (c) 2026 sol pbc
 
-"""OpenHands provider facade for cogitate runs.
+"""Unified OpenHands/LiteLLM transport for personal cloud thinking.
 
 OpenHands and LiteLLM are installed on demand, so this module must stay importable
 without either package present. Keep all OpenHands/LiteLLM imports inside the
@@ -15,6 +15,7 @@ import json
 import logging
 import math
 import os
+import re
 import shutil
 import sys
 import threading
@@ -24,7 +25,6 @@ from collections.abc import Callable
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
-from importlib import import_module
 from pathlib import Path
 from typing import Any
 
@@ -54,6 +54,7 @@ from solstone.think.providers.local_admission import (
 from solstone.think.providers.local_server import LOCAL_MIN_CONTEXT_TOKENS
 from solstone.think.providers.shared import (
     USAGE_KEYS,
+    GenerateResult,
     JSONEventCallback,
     classify_provider_error,
     safe_raw,
@@ -62,12 +63,6 @@ from solstone.think.utils import get_journal, get_project_root, now_ms
 
 LOG = logging.getLogger("solstone.think.providers.openhands")
 
-_GENERATE_MODULES = {
-    "anthropic": "solstone.think.providers.anthropic",
-    "openai": "solstone.think.providers.openai",
-    "google": "solstone.think.providers.google",
-}
-
 _MODEL_PREFIXES = {
     "anthropic": "anthropic",
     "openai": "openai",
@@ -86,6 +81,25 @@ _COST_WARNING_TEXT = "Cost calculation failed"
 _LOCAL_OUTPUT_RESERVE_TOKENS = LOCAL_MIN_CONTEXT_TOKENS // 4
 _LOCAL_CONDENSER_MAX_TOKENS = LOCAL_MIN_CONTEXT_TOKENS * 11 // 16
 _LOCAL_CONDENSER_KEEP_FIRST = 4
+_GENERATE_NUM_RETRIES = 2
+_GEMINI_MAX_OUTPUT_TOKENS = 65_535
+_ANTHROPIC_THINKING_BUFFER = 1_000
+_SCHEMA_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
+
+
+@contextmanager
+def _openhands_import_policy():
+    """Contain OpenHands import side effects and irrelevant LiteLLM warnings."""
+    root_baseline = snapshot_root_logging()
+    os.environ.setdefault("OPENHANDS_SUPPRESS_BANNER", "1")
+    litellm_log = logging.getLogger("LiteLLM")
+    prior_litellm_level = litellm_log.level
+    litellm_log.setLevel(logging.ERROR)
+    try:
+        yield
+    finally:
+        litellm_log.setLevel(prior_litellm_level)
+        apply_http_logging_policy(root_baseline)
 
 
 def _prefixed_model(provider: str, model: str) -> str:
@@ -188,6 +202,417 @@ def _build_llm(provider: str, model: str) -> Any:
     return LLM(**llm_kwargs)
 
 
+def _parse_openai_effort(model: str) -> tuple[str, str | None]:
+    """Split Solstone's optional OpenAI reasoning-effort model suffix."""
+    from solstone.think.models import OPENAI_EFFORT_SUFFIXES
+
+    for suffix in OPENAI_EFFORT_SUFFIXES:
+        if model.endswith(suffix):
+            return model[: -len(suffix)], suffix[1:]
+    return model, None
+
+
+def _generate_token_budget(
+    provider: str,
+    max_output_tokens: int,
+    thinking_budget: int | None,
+) -> int:
+    """Return the provider-facing output ceiling for a generate call."""
+    if provider == "google":
+        total = max_output_tokens + max(0, thinking_budget or 0)
+        if total > _GEMINI_MAX_OUTPUT_TOKENS:
+            LOG.warning(
+                "Clamping Gemini token budget: max_output_tokens=%s "
+                "thinking_budget=%s total=%s clamp=%s",
+                max_output_tokens,
+                thinking_budget,
+                total,
+                _GEMINI_MAX_OUTPUT_TOKENS,
+            )
+            return _GEMINI_MAX_OUTPUT_TOKENS
+        return total
+    if provider == "anthropic" and thinking_budget and thinking_budget > 0:
+        return max(
+            max_output_tokens,
+            thinking_budget + _ANTHROPIC_THINKING_BUFFER + 1,
+        )
+    return max_output_tokens
+
+
+def _build_generate_llm(
+    provider: str,
+    model: str,
+    *,
+    max_output_tokens: int,
+    thinking_budget: int | None,
+    timeout_s: float,
+    api_key: str | None = None,
+    num_retries: int = _GENERATE_NUM_RETRIES,
+) -> tuple[Any, str]:
+    """Build a stateless OpenHands LLM for one direct generation request."""
+    from openhands.sdk import LLM
+
+    if provider not in _MODEL_PREFIXES:
+        raise ValueError(f"Unsupported OpenHands provider: {provider}")
+
+    api_model = model
+    effort = None
+    if provider == "openai":
+        api_model, effort = _parse_openai_effort(model)
+
+    return (
+        LLM(
+            model=_prefixed_model(provider, api_model),
+            api_key=api_key
+            if api_key is not None
+            else os.getenv(_API_KEY_ENV[provider]),
+            timeout=max(1, math.ceil(timeout_s)),
+            num_retries=num_retries,
+            max_output_tokens=_generate_token_budget(
+                provider,
+                max_output_tokens,
+                thinking_budget,
+            ),
+            # OpenHands defaults are agent-oriented: high reasoning, a 200k
+            # Anthropic thinking budget, prompt-cache breakpoints, and encrypted
+            # reasoning. Generate calls opt into reasoning explicitly instead.
+            reasoning_effort=effort,
+            extended_thinking_budget=None,
+            caching_prompt=False,
+            prompt_cache_retention=None,
+            enable_encrypted_reasoning=False,
+            openrouter_site_url="",
+            openrouter_app_name="",
+        ),
+        api_model,
+    )
+
+
+def _data_url(part: Any) -> str:
+    from solstone.think.providers._image import encode_image_part
+
+    media_type, payload = encode_image_part(part)
+    return f"data:{media_type};base64,{payload}"
+
+
+def _message_content(value: Any) -> list[Any]:
+    """Convert Solstone's generate input shapes to OpenHands content blocks."""
+    from openhands.sdk.llm import ImageContent, TextContent
+
+    from solstone.think.providers._image import is_image_part
+
+    if is_image_part(value):
+        return [ImageContent(image_urls=[_data_url(value)])]
+    if isinstance(value, list | tuple):
+        blocks: list[Any] = []
+        for item in value:
+            blocks.extend(_message_content(item))
+        return blocks
+    if isinstance(value, dict):
+        part_type = str(value.get("type") or "")
+        if part_type in {"text", "input_text", "output_text"}:
+            return [TextContent(text=str(value.get("text") or ""))]
+        if part_type in {"image_url", "input_image"}:
+            image_url = value.get("image_url")
+            if isinstance(image_url, dict):
+                image_url = image_url.get("url")
+            if isinstance(image_url, str) and image_url:
+                return [ImageContent(image_urls=[image_url])]
+    return [TextContent(text=str(value))]
+
+
+def _generate_messages(
+    contents: Any,
+    system_instruction: str | None,
+) -> list[Any]:
+    from openhands.sdk.llm import Message, TextContent
+
+    messages: list[Any] = []
+    if system_instruction:
+        messages.append(
+            Message(role="system", content=[TextContent(text=system_instruction)])
+        )
+
+    if (
+        isinstance(contents, list)
+        and contents
+        and isinstance(contents[0], dict)
+        and "role" in contents[0]
+    ):
+        for item in contents:
+            if not isinstance(item, dict):
+                raise ValueError("role-based generate contents must contain messages")
+            role = str(item.get("role") or "user")
+            if role == "model":
+                role = "assistant"
+            if role not in {"user", "system", "assistant", "tool"}:
+                raise ValueError(f"Unknown message role: {role!r}")
+            messages.append(
+                Message(role=role, content=_message_content(item.get("content", "")))
+            )
+    else:
+        messages.append(Message(role="user", content=_message_content(contents)))
+    return messages
+
+
+def _schema_name(schema: dict | None) -> str:
+    title = schema.get("title") if isinstance(schema, dict) else None
+    if isinstance(title, str) and _SCHEMA_NAME_RE.fullmatch(title):
+        return title
+    return "response"
+
+
+def _generate_call_kwargs(
+    provider: str,
+    model: str,
+    *,
+    temperature: float | None,
+    json_output: bool,
+    json_schema: dict | None,
+    thinking_budget: int | None,
+    timeout_s: float,
+    responses_api: bool,
+) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {"timeout": timeout_s}
+    # Preserve each direct provider's accepted parameter contract. OpenAI's
+    # reasoning models reject temperature, and Anthropic rejects it while
+    # extended thinking is enabled (plus a few model-specific cases).
+    include_temperature = provider == "google"
+    if provider == "anthropic" and not (thinking_budget and thinking_budget > 0):
+        from solstone.think.models import model_supports
+
+        include_temperature = model_supports(model, "temperature")
+    if temperature is not None and include_temperature:
+        kwargs["temperature"] = temperature
+
+    if provider == "google" and thinking_budget is not None:
+        kwargs["thinking"] = {
+            "type": "enabled" if thinking_budget > 0 else "disabled",
+            "budget_tokens": max(0, thinking_budget),
+        }
+    elif provider == "anthropic" and thinking_budget and thinking_budget > 0:
+        kwargs["thinking"] = {
+            "type": "enabled",
+            "budget_tokens": thinking_budget,
+        }
+
+    if json_schema is not None:
+        schema_format = {
+            "type": "json_schema",
+            "name": _schema_name(json_schema),
+            "schema": json_schema,
+            "strict": True,
+        }
+        if responses_api:
+            kwargs["text"] = {"format": schema_format}
+        else:
+            kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": schema_format,
+            }
+    elif json_output:
+        if responses_api:
+            kwargs["text"] = {"format": {"type": "json_object"}}
+        else:
+            kwargs["response_format"] = {"type": "json_object"}
+    return kwargs
+
+
+def _get(value: Any, key: str, default: Any = None) -> Any:
+    if isinstance(value, dict):
+        return value.get(key, default)
+    return getattr(value, key, default)
+
+
+def _response_text(response: Any) -> str:
+    parts = []
+    for content in response.message.content:
+        text = getattr(content, "text", None)
+        if isinstance(text, str):
+            parts.append(text)
+    return "".join(parts)
+
+
+def _response_thinking(response: Any) -> list[dict[str, Any]] | None:
+    message = response.message
+    blocks: list[dict[str, Any]] = []
+    for block in message.thinking_blocks:
+        thinking = getattr(block, "thinking", None)
+        if isinstance(thinking, str) and thinking:
+            item: dict[str, Any] = {"summary": thinking}
+            signature = getattr(block, "signature", None)
+            if signature:
+                item["signature"] = signature
+            blocks.append(item)
+            continue
+        data = getattr(block, "data", None)
+        if data:
+            blocks.append({"summary": "[redacted]", "redacted_data": data})
+
+    if not blocks and message.reasoning_content:
+        blocks.append({"summary": message.reasoning_content})
+    reasoning_item = message.responses_reasoning_item
+    if not blocks and reasoning_item is not None:
+        blocks.extend(
+            {"summary": summary}
+            for summary in reasoning_item.summary
+            if isinstance(summary, str) and summary
+        )
+    return blocks or None
+
+
+def _response_usage(response: Any) -> dict[str, Any] | None:
+    token_usage = response.metrics.accumulated_token_usage
+    if token_usage is None:
+        return None
+    usage: dict[str, Any] = {
+        "input_tokens": token_usage.prompt_tokens,
+        "output_tokens": token_usage.completion_tokens,
+        "total_tokens": token_usage.prompt_tokens + token_usage.completion_tokens,
+    }
+    if token_usage.cache_read_tokens:
+        usage["cached_tokens"] = token_usage.cache_read_tokens
+    if token_usage.cache_write_tokens:
+        usage["cache_creation_tokens"] = token_usage.cache_write_tokens
+    if token_usage.reasoning_tokens:
+        usage["reasoning_tokens"] = token_usage.reasoning_tokens
+    if not any(usage.values()):
+        return None
+    raw_model = _get(response.raw_response, "model")
+    if isinstance(raw_model, str) and raw_model:
+        usage["model_version"] = raw_model
+    return usage
+
+
+def _normalize_finish_reason(response: Any) -> str | None:
+    raw = response.raw_response
+    choices = _get(raw, "choices")
+    if choices:
+        reason = _get(choices[0], "finish_reason")
+    else:
+        status = _get(raw, "status")
+        if status == "completed":
+            return "stop"
+        if status == "incomplete":
+            details = _get(raw, "incomplete_details")
+            reason = _get(details, "reason", "max_tokens")
+        elif status == "failed":
+            return "error"
+        else:
+            reason = status
+    if not reason:
+        return None
+    normalized = str(reason).strip().lower()
+    return {
+        "end_turn": "stop",
+        "stop_sequence": "stop",
+        "length": "max_tokens",
+        "max_output_tokens": "max_tokens",
+    }.get(normalized, normalized)
+
+
+def _generate_result(response: Any, requested_model: str) -> GenerateResult:
+    raw_model = _get(response.raw_response, "model")
+    return GenerateResult(
+        text=_response_text(response),
+        model=raw_model
+        if isinstance(raw_model, str) and raw_model
+        else requested_model,
+        usage=_response_usage(response),
+        finish_reason=_normalize_finish_reason(response),
+        thinking=_response_thinking(response),
+    )
+
+
+def _run_generate(
+    contents: Any,
+    model: str,
+    *,
+    provider: str,
+    temperature: float | None,
+    max_output_tokens: int,
+    system_instruction: str | None,
+    json_output: bool,
+    thinking_budget: int | None,
+    json_schema: dict | None,
+    timeout_s: float,
+    api_key: str | None = None,
+    num_retries: int = _GENERATE_NUM_RETRIES,
+) -> GenerateResult:
+    with _openhands_import_policy():
+        llm, _ = _build_generate_llm(
+            provider,
+            model,
+            max_output_tokens=max_output_tokens,
+            thinking_budget=thinking_budget,
+            timeout_s=timeout_s,
+            api_key=api_key,
+            num_retries=num_retries,
+        )
+        messages = _generate_messages(contents, system_instruction)
+    # Direct OpenAI is intentionally Responses-first even for custom model ids,
+    # matching Solstone's previous native OpenAI contract. Other providers use
+    # chat completion through LiteLLM's provider translation.
+    responses_api = provider == "openai"
+    call_kwargs = _generate_call_kwargs(
+        provider,
+        model,
+        temperature=temperature,
+        json_output=json_output,
+        json_schema=json_schema,
+        thinking_budget=thinking_budget,
+        timeout_s=timeout_s,
+        responses_api=responses_api,
+    )
+    response = (
+        llm.responses(messages, **call_kwargs)
+        if responses_api
+        else llm.completion(messages, **call_kwargs)
+    )
+    return _generate_result(response, model)
+
+
+async def _run_agenerate(
+    contents: Any,
+    model: str,
+    *,
+    provider: str,
+    temperature: float | None,
+    max_output_tokens: int,
+    system_instruction: str | None,
+    json_output: bool,
+    thinking_budget: int | None,
+    json_schema: dict | None,
+    timeout_s: float,
+) -> GenerateResult:
+    with _openhands_import_policy():
+        llm, _ = _build_generate_llm(
+            provider,
+            model,
+            max_output_tokens=max_output_tokens,
+            thinking_budget=thinking_budget,
+            timeout_s=timeout_s,
+        )
+        messages = _generate_messages(contents, system_instruction)
+    responses_api = provider == "openai"
+    call_kwargs = _generate_call_kwargs(
+        provider,
+        model,
+        temperature=temperature,
+        json_output=json_output,
+        json_schema=json_schema,
+        thinking_budget=thinking_budget,
+        timeout_s=timeout_s,
+        responses_api=responses_api,
+    )
+    response = (
+        await llm.aresponses(messages, **call_kwargs)
+        if responses_api
+        else await llm.acompletion(messages, **call_kwargs)
+    )
+    return _generate_result(response, model)
+
+
 def _build_local_condenser(llm: Any) -> Any:
     """LLM-summarizing condenser for the bundled-local floor window.
 
@@ -329,25 +754,24 @@ def _ensure_sol_types() -> dict[str, Any]:
                     result = _run_command(decision.argv)
                 except Exception as exc:
                     command_error = exc
-                finally:
-                    try:
-                        self.slot_lease.reacquire()
-                    except LocalAdmissionCancelled:
-                        if result is not None:
-                            return SolObservation.from_text(
-                                result["text"], is_error=result["is_error"]
-                            )
+                try:
+                    self.slot_lease.reacquire()
+                except LocalAdmissionCancelled:
+                    if result is not None:
                         return SolObservation.from_text(
-                            "local_admission_cancelled: cogitate run interrupted "
-                            "before reacquiring local inference",
-                            is_error=True,
+                            result["text"], is_error=result["is_error"]
                         )
-                    except Exception as exc:
-                        self._store_terminal_error(exc)
-                        live_conversation = conversation or self._conversation
-                        if live_conversation is not None:
-                            live_conversation.interrupt()
-                        return SolObservation.from_text(str(exc), is_error=True)
+                    return SolObservation.from_text(
+                        "local_admission_cancelled: cogitate run interrupted "
+                        "before reacquiring local inference",
+                        is_error=True,
+                    )
+                except Exception as exc:
+                    self._store_terminal_error(exc)
+                    live_conversation = conversation or self._conversation
+                    if live_conversation is not None:
+                        live_conversation.interrupt()
+                    return SolObservation.from_text(str(exc), is_error=True)
                 if command_error is not None:
                     raise command_error
                 assert result is not None
@@ -1112,12 +1536,11 @@ async def run_cogitate(
     llm: Any | None = None
     usage_start: dict[str, int] | None = None
     try:
-        root_baseline = snapshot_root_logging()
-        from openhands.sdk import Conversation
-        from openhands.sdk.tool.registry import register_tool
-        from openhands.sdk.tool.spec import Tool
+        with _openhands_import_policy():
+            from openhands.sdk import Conversation
+            from openhands.sdk.tool.registry import register_tool
+            from openhands.sdk.tool.spec import Tool
 
-        apply_http_logging_policy(root_baseline)
         wants_emit_final = expects_emit_final(config)
         max_turns = int(config.get("max_turns", MAX_TURNS) or MAX_TURNS)
         cost_cap = float(
@@ -1421,28 +1844,138 @@ async def run_cogitate(
         raise
 
 
-def run_generate(contents: Any, model: str, **kwargs: Any) -> Any:
-    provider = kwargs.pop("provider")
-    module = import_module(_GENERATE_MODULES[provider])
-    return module.run_generate(contents=contents, model=model, **kwargs)
+def run_generate(
+    contents: Any,
+    model: str,
+    *,
+    provider: str,
+    temperature: float = 0.3,
+    max_output_tokens: int = 8192 * 2,
+    system_instruction: str | None = None,
+    json_output: bool = False,
+    thinking_budget: int | None = None,
+    json_schema: dict | None = None,
+    timeout_s: float = 120,
+    **kwargs: Any,
+) -> GenerateResult:
+    if kwargs:
+        unknown = ", ".join(sorted(kwargs))
+        raise TypeError(f"Unsupported generate options: {unknown}")
+    return _run_generate(
+        contents,
+        model,
+        provider=provider,
+        temperature=temperature,
+        max_output_tokens=max_output_tokens,
+        system_instruction=system_instruction,
+        json_output=json_output,
+        thinking_budget=thinking_budget,
+        json_schema=json_schema,
+        timeout_s=timeout_s,
+    )
 
 
-async def run_agenerate(contents: Any, model: str, **kwargs: Any) -> Any:
-    provider = kwargs.pop("provider")
-    module = import_module(_GENERATE_MODULES[provider])
-    return await module.run_agenerate(contents=contents, model=model, **kwargs)
+async def run_agenerate(
+    contents: Any,
+    model: str,
+    *,
+    provider: str,
+    temperature: float = 0.3,
+    max_output_tokens: int = 8192 * 2,
+    system_instruction: str | None = None,
+    json_output: bool = False,
+    thinking_budget: int | None = None,
+    json_schema: dict | None = None,
+    timeout_s: float = 120,
+    **kwargs: Any,
+) -> GenerateResult:
+    if kwargs:
+        unknown = ", ".join(sorted(kwargs))
+        raise TypeError(f"Unsupported generate options: {unknown}")
+    return await _run_agenerate(
+        contents,
+        model,
+        provider=provider,
+        temperature=temperature,
+        max_output_tokens=max_output_tokens,
+        system_instruction=system_instruction,
+        json_output=json_output,
+        thinking_budget=thinking_budget,
+        json_schema=json_schema,
+        timeout_s=timeout_s,
+    )
 
 
-def list_models(provider: str) -> list[dict]:
-    module = import_module(_GENERATE_MODULES[provider])
-    return module.list_models()
+def _exception_chain(exc: BaseException) -> list[BaseException]:
+    chain: list[BaseException] = []
+    current: BaseException | None = exc
+    while current is not None and current not in chain:
+        chain.append(current)
+        current = current.__cause__ or current.__context__
+    return chain
+
+
+def _model_not_found(exc: BaseException) -> bool:
+    for item in _exception_chain(exc):
+        status = getattr(item, "status_code", None)
+        if status is None:
+            status = getattr(getattr(item, "response", None), "status_code", None)
+        if status == 404 or "notfound" in type(item).__name__.lower():
+            return True
+    return False
+
+
+def _validation_reason(exc: BaseException, provider: str) -> str:
+    if _model_not_found(exc):
+        return "model_not_found"
+    for item in _exception_chain(exc):
+        reason = classify_provider_error(item, provider)
+        if reason != "unknown":
+            return reason
+    return "unknown"
+
+
+def _probe(provider: str, model: str, api_key: str) -> None:
+    _run_generate(
+        "Reply OK",
+        model,
+        provider=provider,
+        temperature=None,
+        max_output_tokens=8,
+        system_instruction=None,
+        json_output=False,
+        thinking_budget=None,
+        json_schema=None,
+        timeout_s=10,
+        api_key=api_key,
+        num_retries=0,
+    )
 
 
 def validate_key(provider: str, api_key: str) -> dict:
-    module = import_module(_GENERATE_MODULES[provider])
-    return module.validate_key(api_key)
+    """Verify a personal cloud key through the same transport used at runtime."""
+    from solstone.think.models import default_model_for_provider
+
+    try:
+        _probe(provider, default_model_for_provider(provider), api_key)
+        return {"valid": True}
+    except Exception as exc:
+        reason = _validation_reason(exc, provider)
+        # A 404 or quota response proves the endpoint accepted the credential;
+        # model selection performs the definitive, model-specific probe next.
+        if reason in {"model_not_found", "provider_quota_exceeded"}:
+            return {"valid": True, "probe_reason_code": reason}
+        return {"valid": False, "error": str(exc), "reason_code": reason}
 
 
 def validate_model(provider: str, model: str, api_key: str) -> dict:
-    module = import_module(_GENERATE_MODULES[provider])
-    return module.validate_model(model, api_key)
+    """Verify that a personal cloud key can actually run the selected model."""
+    try:
+        _probe(provider, model, api_key)
+        return {"valid": True}
+    except Exception as exc:
+        return {
+            "valid": False,
+            "error": str(exc),
+            "reason_code": _validation_reason(exc, provider),
+        }
diff --git a/solstone/think/providers/shared.py b/solstone/think/providers/shared.py
index 44891e9ab..8eb6c2918 100644
--- a/solstone/think/providers/shared.py
+++ b/solstone/think/providers/shared.py
@@ -236,6 +236,18 @@ def classify_provider_error(exc: BaseException, provider: str) -> str:
             return "provider_quota_exceeded"
         if exc_name == "ContextWindowExceededError":
             return "context_window_exceeded"
+        if exc_name in {"LLMContextWindowExceedError", "LLMContextWindowTooSmallError"}:
+            return "context_window_exceeded"
+        if exc_name == "LLMAuthenticationError":
+            return "provider_key_invalid"
+        if exc_name == "LLMRateLimitError":
+            return "provider_quota_exceeded"
+        if exc_name == "LLMTimeoutError":
+            return "chat_timeout"
+        if exc_name == "LLMServiceUnavailableError":
+            return "provider_unavailable"
+        if exc_name in {"LLMNoResponseError", "LLMResponseError"}:
+            return "provider_response_invalid"
         if _contains_any(message_lower, _CONTEXT_WINDOW_PATTERNS):
             return "context_window_exceeded"
         # MaxIterationsReached is OpenHands' event-code spelling of the same limit;
diff --git a/solstone/think/providers_cli.py b/solstone/think/providers_cli.py
index 512c7fe35..2918e5723 100644
--- a/solstone/think/providers_cli.py
+++ b/solstone/think/providers_cli.py
@@ -33,10 +33,7 @@ def _provider_status(provider_name: str) -> dict[str, object]:
     )
     if provider is None:
         return {}
-    return build_provider_status([provider], vertex_creds_configured=False).get(
-        provider_name,
-        {},
-    )
+    return build_provider_status([provider]).get(provider_name, {})
 
 
 def _check_generate(
diff --git a/solstone/think/services/spp.py b/solstone/think/services/spp.py
index b24907dc7..2af576369 100644
--- a/solstone/think/services/spp.py
+++ b/solstone/think/services/spp.py
@@ -176,14 +176,6 @@ def _local_block(providers: dict[str, Any]) -> dict[str, Any]:
     return local
 
 
-def _type_block(providers: dict[str, Any], agent_type: str) -> dict[str, Any]:
-    block = providers.get(agent_type)
-    if not isinstance(block, dict):
-        block = {}
-        providers[agent_type] = block
-    return block
-
-
 def provision_confidential_handoff(payload: dict[str, Any]) -> None:
     """Persist a portal-provisioned confidential handoff into journal config."""
 
@@ -198,16 +190,15 @@ def provision_confidential_handoff(payload: dict[str, Any]) -> None:
         providers = _providers_block(config)
         local = _local_block(providers)
         prior_local = dict(local) if local else None
-        generate = _type_block(providers, "generate")
-        cogitate = _type_block(providers, "cogitate")
-        prior_generate_provider = generate.get("provider")
-        prior_cogitate_provider = cogitate.get("provider")
+        active = providers.get("active")
+        prior_active = dict(active) if isinstance(active, dict) and active else None
 
         local["endpoint_url"] = values["endpoint_url"]
         local["served_model_id"] = values["served_model_id"]
         local["credential"] = values["credential"]
-        generate["provider"] = "local"
-        cogitate["provider"] = "local"
+        from solstone.think.models import LOCAL_MODEL
+
+        providers["active"] = {"provider": "local", "model": LOCAL_MODEL}
         config.setdefault("services", {})["confidential"] = {
             "enabled_at": _now_iso(),
             "account_id": values["account_id"],
@@ -215,16 +206,7 @@ def provision_confidential_handoff(payload: dict[str, Any]) -> None:
             "served_model_id": values["served_model_id"],
             "credential_created_at": values["created_at"],
             CREDENTIAL_FINGERPRINT_FIELD: _fingerprint_key(values["credential"]),
-            "prior_generate_provider": (
-                prior_generate_provider
-                if isinstance(prior_generate_provider, str)
-                else None
-            ),
-            "prior_cogitate_provider": (
-                prior_cogitate_provider
-                if isinstance(prior_cogitate_provider, str)
-                else None
-            ),
+            "prior_active": prior_active,
             "prior_local_endpoint": prior_local,
         }
         write_journal_config(config)
@@ -246,17 +228,14 @@ def disable_confidential() -> DisableOutcome:
             return DisableOutcome(was_enabled=False, credential_preserved=False)
 
         providers = _providers_block(config)
-        generate = _type_block(providers, "generate")
-        cogitate = _type_block(providers, "cogitate")
-        for type_block, field in (
-            (generate, "prior_generate_provider"),
-            (cogitate, "prior_cogitate_provider"),
-        ):
-            prior_provider = block.get(field)
-            if isinstance(prior_provider, str) and prior_provider:
-                type_block["provider"] = prior_provider
+        from solstone.think.models import LOCAL_MODEL
+
+        if providers.get("active") == {"provider": "local", "model": LOCAL_MODEL}:
+            prior_active = block.get("prior_active")
+            if isinstance(prior_active, dict) and prior_active:
+                providers["active"] = dict(prior_active)
             else:
-                type_block.pop("provider", None)
+                providers.pop("active", None)
 
         local = _local_block(providers)
         current_credential = local.get("credential")
diff --git a/solstone/think/setup.py b/solstone/think/setup.py
index f55707bee..e7e64e6e2 100644
--- a/solstone/think/setup.py
+++ b/solstone/think/setup.py
@@ -1391,20 +1391,15 @@ def step_brain(ctx: SetupContext, step_index: int) -> StepResult:
         return step_result("brain", "skipped", [], started_at, reason=reason_malformed)
 
     providers = cfg.get("providers", {})
-    for agent_type in ("generate", "cogitate"):
-        if agent_type in providers and not isinstance(providers[agent_type], dict):
-            print_step_skipped(ctx, step_index, "brain", reason_malformed)
-            return step_result(
-                "brain", "skipped", [], started_at, reason=reason_malformed
-            )
+    active = providers.get("active")
+    if active is not None and not isinstance(active, dict):
+        print_step_skipped(ctx, step_index, "brain", reason_malformed)
+        return step_result("brain", "skipped", [], started_at, reason=reason_malformed)
 
-    generate = providers.get("generate", {})
-    cogitate = providers.get("cogitate", {})
-    owner_chose_other = any(
-        type_config.get("provider") is not None
-        and type_config.get("provider") != "local"
-        for type_config in (generate, cogitate)
-    )
+    owner_chose_other = isinstance(active, dict) and active.get("provider") not in {
+        None,
+        "local",
+    }
     if owner_chose_other:
         reason = "a provider is already configured"
         print_step_skipped(ctx, step_index, "brain", reason)
@@ -1414,15 +1409,12 @@ def step_brain(ctx: SetupContext, step_index: int) -> StepResult:
     if "providers" not in cfg:
         cfg["providers"] = providers
         changed = True
-    for agent_type in ("generate", "cogitate"):
-        type_config = providers.get(agent_type)
-        if type_config is None:
-            type_config = {}
-            providers[agent_type] = type_config
-            changed = True
-        if type_config.get("provider") != "local":
-            type_config["provider"] = "local"
-            changed = True
+    from solstone.think.models import LOCAL_MODEL
+
+    local_active = {"provider": "local", "model": LOCAL_MODEL}
+    if active != local_active:
+        providers["active"] = local_active
+        changed = True
     if changed:
         write_journal_config(cfg, ctx.journal_path)
 
diff --git a/solstone/think/talent.py b/solstone/think/talent.py
index e64487567..c870433ac 100644
--- a/solstone/think/talent.py
+++ b/solstone/think/talent.py
@@ -319,9 +319,11 @@ def get_talent_configs(
                 info["app"] = app_name
                 configs[key] = info
 
-    # Merge journal config overrides from providers.contexts
-    providers_config = get_config().get("providers", {})
-    contexts = providers_config.get("contexts", {})
+    # Merge journal-owned enable/extract overrides. Thinking owns these talent
+    # controls; they are deliberately separate from provider routing.
+    contexts = get_config().get("talent_overrides", {})
+    if not isinstance(contexts, dict):
+        contexts = {}
 
     for key, info in configs.items():
         context_key = key_to_context(key)
diff --git a/solstone/think/talents.py b/solstone/think/talents.py
index fa82a3897..f38d5c526 100644
--- a/solstone/think/talents.py
+++ b/solstone/think/talents.py
@@ -556,7 +556,7 @@ def prepare_config(request: dict) -> dict:
 
     Config fields produced:
     - name: Talent name
-    - provider, model: Resolved from interface defaults/request
+    - provider, model: Resolved from the journal's active Thinking profile
     - user_instruction: Talent instruction from .md file
     - prompt: User's runtime query/request
     - transcript: Clustered transcript (if day provided)
@@ -572,9 +572,7 @@ def prepare_config(request: dict) -> dict:
     from solstone.think.models import (
         NO_BRAIN_PROVIDER,
         NoBrainConfiguredError,
-        default_model_for_provider,
         resolve_provider,
-        type_default_is_local,
     )
     from solstone.think.talent import get_talent, key_to_context
 
@@ -595,6 +593,17 @@ def prepare_config(request: dict) -> dict:
             f"talent {name!r} declares 'outbound_approval' in frontmatter; "
             "this field is launch-config-only and may not come from a talent definition"
         )
+    for field in ("provider", "model"):
+        if field in config:
+            raise ValueError(
+                f"talent {name!r} declares {field!r} in frontmatter; "
+                "thinking provider and model are configured only in Thinking"
+            )
+        if request.get(field) is not None:
+            raise ValueError(
+                f"request overrides for {field!r} are not allowed; "
+                "thinking provider and model are configured only in Thinking"
+            )
 
     # Config now contains all frontmatter fields plus:
     # - path: Path to the .md file
@@ -669,25 +678,7 @@ def prepare_config(request: dict) -> dict:
     # Resolve provider and model for the talent's interface
     context = key_to_context(name)
     talent_type = config["type"]
-    default_provider, default_model = resolve_provider(talent_type)
-
-    if type_default_is_local(talent_type):
-        # Local type-default is a hard runtime promise: a frontmatter/request
-        # cloud provider pin may not force a local-lane talent onto cloud.
-        # An explicit local request pin with a model is honored verbatim.
-        provider = default_provider
-        if config.get("provider") == "local" and config.get("model"):
-            model = config["model"]
-        else:
-            model = default_model
-    else:
-        provider = config.get("provider") or default_provider
-        model = config.get("model")
-        if not model:
-            if provider != default_provider:
-                model = default_model_for_provider(provider)
-            else:
-                model = default_model
+    provider, model = resolve_provider(talent_type)
 
     config["provider"] = provider
     config["model"] = model
@@ -1478,8 +1469,6 @@ async def _execute_generate(
             json_output=is_json_output,
             json_schema=runtime_json_schema,
             timeout_s=timeout_s,
-            provider=config.get("provider"),
-            model=config.get("model"),
         )
     except Exception as exc:
         provider = config.get("provider", "google")
@@ -1526,8 +1515,6 @@ async def _execute_generate(
                     json_output=is_json_output,
                     json_schema=runtime_json_schema,
                     timeout_s=timeout_s,
-                    provider=config.get("provider"),
-                    model=config.get("model"),
                     **retry_kwargs,
                 )
             except Exception as retry_exc:
diff --git a/solstone/think/utils.py b/solstone/think/utils.py
index ac30f9ca2..da4d7072e 100644
--- a/solstone/think/utils.py
+++ b/solstone/think/utils.py
@@ -966,7 +966,7 @@ def init_cli_runtime(verbose: bool, debug: bool) -> None:
     # managed provider API keys. Load every config-declared var into os.environ,
     # then strip any managed provider key (registry-derived) that config does not
     # set, so a stray shell-set provider key is never used. Non-managed vars are
-    # loaded as-is; Vertex/ADC auth vars are not managed keys and are never stripped.
+    # loaded as-is.
     config = get_config()
     config_env = config.get("env", {})
     for key, value in config_env.items():
@@ -985,9 +985,8 @@ def setup_cli(parser: argparse.ArgumentParser, *, parse_known: bool = False):
     (in ``journal.json``) are loaded into ``os.environ``. journal.json is the
     authoritative and exclusive source for managed provider API keys (the
     provider registry's ``env_key`` values): a managed provider key absent from
-    config is stripped so a shell-set value is never used. Vertex/ADC auth vars
-    are not managed keys and are never stripped; non-managed vars load as
-    declared.
+    config is stripped so a shell-set value is never used. Non-managed vars load
+    as declared.
     The parsed arguments are returned. If ``parse_known`` is ``True`` a tuple of
     ``(args, extra)`` is returned using :func:`argparse.ArgumentParser.parse_known_args`.
     """
diff --git a/tests/baselines/api/thinking/providers.json b/tests/baselines/api/thinking/providers.json
index 6fa6b7bea..99680b3b7 100644
--- a/tests/baselines/api/thinking/providers.json
+++ b/tests/baselines/api/thinking/providers.json
@@ -1,6 +1,9 @@
 {
+  "active": {
+    "model": "gemini-custom-flash-test",
+    "provider": "google"
+  },
   "active_lane": {
-    "cogitate": "byo",
     "confidential_attestation": {
       "last_verified": null,
       "provenance": null,
@@ -11,32 +14,12 @@
     "confidential_enabled": false,
     "confidential_operation": null,
     "confidential_provenance_configured": false,
-    "generate": "byo",
     "lane": "byo",
     "scout_enabled": false,
-    "scout_provenance_configured": false,
-    "split": false
+    "scout_provenance_configured": false
   },
   "ai_readiness": {
     "groups": [
-      {
-        "context": null,
-        "detail": "Open provider setup and add credentials, then try again.",
-        "interface": "cogitate",
-        "model": "gpt-5.4-mini",
-        "operator_detail": "reason_code=provider_key_missing; provider=openai; status=blocked; model=gpt-5.4-mini; interface=cogitate; message=OPENAI_API_KEY not set",
-        "provider": "openai",
-        "reason_code": "provider_key_missing",
-        "recovery_action": {
-          "href": "/app/thinking/#main",
-          "label": "Open Settings"
-        },
-        "semantic_key": "provider_key_missing:openai:",
-        "severity": "blocker",
-        "status": "blocked",
-        "summary": "OpenAI needs credentials before it can read your screen descriptions",
-        "work_key": null
-      },
       {
         "context": null,
         "detail": "Open provider setup and add credentials, then try again.",
@@ -61,18 +44,18 @@
         "context": null,
         "detail": "Open provider setup and add credentials, then try again.",
         "interface": "cogitate",
-        "model": "gpt-5.4-mini",
-        "operator_detail": "reason_code=provider_key_missing; provider=openai; status=blocked; model=gpt-5.4-mini; interface=cogitate; message=OPENAI_API_KEY not set",
-        "provider": "openai",
+        "model": "gemini-custom-flash-test",
+        "operator_detail": "reason_code=provider_key_missing; provider=google; status=blocked; model=gemini-custom-flash-test; interface=cogitate; message=GOOGLE_API_KEY not set",
+        "provider": "google",
         "reason_code": "provider_key_missing",
         "recovery_action": {
           "href": "/app/thinking/#main",
           "label": "Open Settings"
         },
-        "semantic_key": "provider_key_missing:openai:",
+        "semantic_key": "provider_key_missing:google:",
         "severity": "blocker",
         "status": "blocked",
-        "summary": "OpenAI needs credentials before it can read your screen descriptions",
+        "summary": "Gemini needs credentials before it can read your screen descriptions",
         "work_key": null
       },
       "generate": {
@@ -96,25 +79,25 @@
     },
     "local": {
       "context": null,
-      "detail": "Finish local model setup, then try the request again.",
+      "detail": "Local models require a supported GPU. This computer has no GPU acceleration available.",
       "interface": "generate",
       "model": "local/qwen3.5-4b",
-      "operator_detail": "reason_code=local_model_missing; provider=local; status=blocked; model=local/qwen3.5-4b; interface=generate",
+      "operator_detail": "reason_code=gpu_unavailable; provider=local; status=blocked; model=local/qwen3.5-4b; interface=generate",
       "provider": "local",
-      "reason_code": "local_model_missing",
+      "reason_code": "gpu_unavailable",
       "recovery_action": {
-        "href": "/app/thinking/#local-setup",
-        "label": "Open Local Model Setup"
+        "href": "/app/thinking/#main",
+        "label": "Open Settings"
       },
-      "semantic_key": "local_model_missing:local:local/qwen3.5-4b",
+      "semantic_key": "gpu_unavailable:local:local/qwen3.5-4b",
       "severity": "blocker",
       "status": "blocked",
-      "summary": "local model setup is not finished",
+      "summary": "local models need GPU acceleration on this computer",
       "work_key": null
     },
     "summary": {
-      "active_groups": 2,
-      "blocked_count": 2,
+      "active_groups": 1,
+      "blocked_count": 1,
       "severity": "blocker",
       "status": "blocked"
     }
@@ -125,15 +108,6 @@
     "openai": false
   },
   "byo_models": {},
-  "cogitate": {
-    "model": "gpt-5.4-mini",
-    "provider": "openai"
-  },
-  "generate": {
-    "model": "gemini-custom-flash-test",
-    "provider": "google"
-  },
-  "google_backend": "auto",
   "key_validation": {},
   "local": {
     "install_error": null,
@@ -260,11 +234,7 @@
     {
       "env_key": "GOOGLE_API_KEY",
       "label": "Google (Gemini)",
-      "name": "google",
-      "vertex_env_keys": [
-        "GOOGLE_GENAI_USE_VERTEXAI",
-        "GOOGLE_APPLICATION_CREDENTIALS"
-      ]
+      "name": "google"
     },
     {
       "env_key": "OPENAI_API_KEY",
@@ -272,7 +242,5 @@
       "name": "openai"
     }
   ],
-  "scout_enabled": false,
-  "vertex_credentials_configured": false,
-  "vertex_credentials_email": ""
+  "scout_enabled": false
 }
diff --git a/tests/fixtures/journal/config/journal.json b/tests/fixtures/journal/config/journal.json
index 0d05bd368..52fe322ce 100644
--- a/tests/fixtures/journal/config/journal.json
+++ b/tests/fixtures/journal/config/journal.json
@@ -41,14 +41,10 @@
     }
   },
   "providers": {
-    "generate": {
+    "active": {
       "provider": "google",
       "model": "gemini-custom-flash-test"
     },
-    "cogitate": {
-      "provider": "openai",
-      "model": "gpt-5.4-mini"
-    },
     "bundled": {
       "parakeet": {
         "install_state": "verifying",
diff --git a/tests/services/test_spp_storage.py b/tests/services/test_spp_storage.py
index 9afbc6782..c471f03c8 100644
--- a/tests/services/test_spp_storage.py
+++ b/tests/services/test_spp_storage.py
@@ -47,6 +47,19 @@ def _write_config(journal: Path, config: dict) -> None:
     write_journal_config(config, journal)
 
 
+@pytest.fixture(autouse=True)
+def _canonical_active_profile(journal_copy: Path) -> None:
+    config = _read_config(journal_copy)
+    providers = config.setdefault("providers", {})
+    providers.pop("generate", None)
+    providers.pop("cogitate", None)
+    providers["active"] = {
+        "provider": "google",
+        "model": "gemini-custom-flash-test",
+    }
+    _write_config(journal_copy, config)
+
+
 def test_confidential_provenance_delegates_to_config_helper(
     journal_copy: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -68,8 +81,10 @@ def test_provision_confidential_handoff_round_trip_writes_single_state(
     journal_copy: Path,
 ) -> None:
     config = _read_config(journal_copy)
-    config["providers"]["generate"]["model"] = "keep-generate-model"
-    config["providers"]["cogitate"]["model"] = "keep-cogitate-model"
+    config["providers"]["active"] = {
+        "provider": "openai",
+        "model": "keep-active-model",
+    }
     config["providers"]["local"] = {
         "endpoint_url": "http://prior.test/v1",
         "served_model_id": "prior-model",
@@ -85,13 +100,9 @@ def test_provision_confidential_handoff_round_trip_writes_single_state(
         "served_model_id": "confidential-model-one",
         "credential": "credential-one",
     }
-    assert saved["providers"]["generate"] == {
+    assert saved["providers"]["active"] == {
         "provider": "local",
-        "model": "keep-generate-model",
-    }
-    assert saved["providers"]["cogitate"] == {
-        "provider": "local",
-        "model": "keep-cogitate-model",
+        "model": "local/qwen3.5-4b",
     }
     block = saved["services"]["confidential"]
     assert set(block) == {
@@ -101,8 +112,7 @@ def test_provision_confidential_handoff_round_trip_writes_single_state(
         "served_model_id",
         "credential_created_at",
         CREDENTIAL_FINGERPRINT_FIELD,
-        "prior_generate_provider",
-        "prior_cogitate_provider",
+        "prior_active",
         "prior_local_endpoint",
     }
     assert block["account_id"] == "acct-one"
@@ -113,8 +123,10 @@ def test_provision_confidential_handoff_round_trip_writes_single_state(
         block[CREDENTIAL_FINGERPRINT_FIELD]
         == hashlib.sha256(b"credential-one").hexdigest()
     )
-    assert block["prior_generate_provider"] == "google"
-    assert block["prior_cogitate_provider"] == "openai"
+    assert block["prior_active"] == {
+        "provider": "openai",
+        "model": "keep-active-model",
+    }
     assert block["prior_local_endpoint"] == {
         "endpoint_url": "http://prior.test/v1",
         "served_model_id": "prior-model",
@@ -210,8 +222,10 @@ def test_disable_confidential_restores_prior_state_on_fingerprint_match(
 
     assert outcome == DisableOutcome(was_enabled=True, credential_preserved=False)
     saved = _read_config(journal_copy)
-    assert saved["providers"]["generate"]["provider"] == "google"
-    assert saved["providers"]["cogitate"]["provider"] == "openai"
+    assert saved["providers"]["active"] == {
+        "provider": "google",
+        "model": "gemini-custom-flash-test",
+    }
     assert saved["providers"]["local"] == {
         "endpoint_url": "http://prior.test",
         "served_model_id": "prior-model",
@@ -277,8 +291,10 @@ def test_disable_confidential_preserves_local_endpoint_when_current_credential_m
 
     assert outcome == DisableOutcome(was_enabled=True, credential_preserved=True)
     saved = _read_config(journal_copy)
-    assert saved["providers"]["generate"]["provider"] == "google"
-    assert saved["providers"]["cogitate"]["provider"] == "openai"
+    assert saved["providers"]["active"] == {
+        "provider": "google",
+        "model": "gemini-custom-flash-test",
+    }
     assert saved["providers"]["local"] == local
     assert "confidential" not in saved["services"]
 
@@ -305,8 +321,10 @@ def test_reenable_after_disable_lands_cleanly(journal_copy: Path) -> None:
     assert (
         saved["providers"]["local"]["endpoint_url"] == "https://spp-second.example.test"
     )
-    assert saved["services"]["confidential"]["prior_generate_provider"] == "google"
-    assert saved["services"]["confidential"]["prior_cogitate_provider"] == "openai"
+    assert saved["services"]["confidential"]["prior_active"] == {
+        "provider": "google",
+        "model": "gemini-custom-flash-test",
+    }
 
 
 def test_locked_parallel_writes_do_not_corrupt_config(journal_copy: Path) -> None:
@@ -361,7 +379,8 @@ def test_provision_requires_initialized_journal(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     journal = tmp_path / "journal"
-    (journal / "config").mkdir(parents=True)
+    (journal / "config").mkdir(parents=True, exist_ok=True)
+    (journal / "config" / "journal.json").unlink(missing_ok=True)
     monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
 
     with pytest.raises(JournalNotInitializedError):
diff --git a/tests/services/test_spp_transport.py b/tests/services/test_spp_transport.py
index 1a74230b8..85c4c18b0 100644
--- a/tests/services/test_spp_transport.py
+++ b/tests/services/test_spp_transport.py
@@ -78,8 +78,10 @@ def _write_confidential_config(tmp_path: Path, monkeypatch: pytest.MonkeyPatch)
                 "served_model_id": "confidential-model",
                 "credential_created_at": "2026-05-24T00:00:00Z",
                 "credential_fingerprint_sha256": "fingerprint",
-                "prior_generate_provider": "google",
-                "prior_cogitate_provider": "openai",
+                "prior_active": {
+                    "provider": "google",
+                    "model": "gemini-flash-latest",
+                },
                 "prior_local_endpoint": None,
             }
         }
diff --git a/tests/test_anthropic.py b/tests/test_anthropic.py
deleted file mode 100644
index b1be689bd..000000000
--- a/tests/test_anthropic.py
+++ /dev/null
@@ -1,1182 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-import asyncio
-import base64
-import importlib
-import io
-import json
-import sys
-import types
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from PIL import Image
-
-from solstone.think.models import (
-    CLAUDE_OPUS_4,
-    CLAUDE_SONNET_4,
-    DEFAULT_PROVIDER_TIMEOUT_S,
-    IncompleteJSONError,
-    _validate_json_response,
-)
-
-
-@pytest.fixture(autouse=True)
-def _restore_talents_module():
-    saved = sys.modules.pop("solstone.think.talents", None)
-    parent = sys.modules.get("solstone.think")
-    had_parent_attr = parent is not None and hasattr(parent, "talents")
-    saved_parent_attr = getattr(parent, "talents", None) if had_parent_attr else None
-    if had_parent_attr:
-        delattr(parent, "talents")
-    try:
-        yield
-    finally:
-        if saved is not None:
-            sys.modules["solstone.think.talents"] = saved
-        else:
-            sys.modules.pop("solstone.think.talents", None)
-        if parent is not None:
-            if had_parent_attr:
-                setattr(parent, "talents", saved_parent_attr)
-            elif hasattr(parent, "talents"):
-                delattr(parent, "talents")
-
-
-async def run_main(mod, argv, stdin_data=None):
-    sys.argv = argv
-    if stdin_data:
-        import io
-
-        sys.stdin = io.StringIO(stdin_data)
-    await mod.main_async()
-
-
-def _png_bytes(size: tuple[int, int] = (4, 3)) -> bytes:
-    image = Image.new("RGB", size, color="red")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG", compress_level=1)
-    return buf.getvalue()
-
-
-def _decoded_image(b64: str) -> Image.Image:
-    return Image.open(io.BytesIO(base64.b64decode(b64)))
-
-
-class DummyMessages:
-    async def create(self, **kwargs):
-        DummyMessages.kwargs = kwargs
-        return SimpleNamespace(content=[SimpleNamespace(type="text", text="ok")])
-
-
-class MockThinkingBlock:
-    """Mock ThinkingBlock that passes isinstance checks."""
-
-    type = "thinking"
-
-    def __init__(self, thinking: str, signature: str = "mock-signature"):
-        self.thinking = thinking
-        self.signature = signature
-
-
-class MockRedactedThinkingBlock:
-    """Mock RedactedThinkingBlock that passes isinstance checks."""
-
-    type = "redacted_thinking"
-
-    def __init__(self, data: str):
-        self.data = data
-
-
-class DummyMessagesWithThinking:
-    async def create(self, **kwargs):
-        DummyMessagesWithThinking.kwargs = kwargs
-        # Return response with both thinking and text content
-        return SimpleNamespace(
-            content=[
-                MockThinkingBlock("I'm thinking about this...", "test-signature-123"),
-                SimpleNamespace(type="text", text="ok"),
-            ]
-        )
-
-
-class DummyMessagesWithRedactedThinking:
-    async def create(self, **kwargs):
-        DummyMessagesWithRedactedThinking.kwargs = kwargs
-        # Return response with redacted thinking
-        return SimpleNamespace(
-            content=[
-                MockRedactedThinkingBlock("encrypted-data-xyz"),
-                SimpleNamespace(type="text", text="ok"),
-            ]
-        )
-
-
-class DummyMessagesError:
-    async def create(self, **kwargs):
-        DummyMessagesError.kwargs = kwargs
-        raise Exception("boo")
-
-
-def _setup_anthropic_stub(
-    monkeypatch, error=False, with_thinking=False, with_redacted_thinking=False
-):
-    # Create mock Anthropic client
-    anthropic_stub = types.ModuleType("anthropic")
-    anthropic_constants_stub = types.ModuleType("anthropic._constants")
-    anthropic_types_stub = types.ModuleType("anthropic.types")
-
-    class DummyClient:
-        def __init__(self, **kwargs):
-            if with_redacted_thinking:
-                self.messages = DummyMessagesWithRedactedThinking()
-            elif with_thinking:
-                self.messages = DummyMessagesWithThinking()
-            elif error:
-                self.messages = DummyMessagesError()
-            else:
-                self.messages = DummyMessages()
-
-    class DummyBadRequestError(Exception):
-        pass
-
-    anthropic_stub.Anthropic = DummyClient
-    anthropic_stub.AsyncAnthropic = DummyClient  # Add async version
-    anthropic_stub.BadRequestError = DummyBadRequestError
-    anthropic_constants_stub.MODEL_NONSTREAMING_TOKENS = {
-        "claude-opus-4-20250514": 8192,
-        "claude-opus-4-0": 8192,
-        "claude-4-opus-20250514": 8192,
-        "anthropic.claude-opus-4-20250514-v1:0": 8192,
-        "claude-opus-4@20250514": 8192,
-        "claude-opus-4-1-20250805": 8192,
-        "anthropic.claude-opus-4-1-20250805-v1:0": 8192,
-        "claude-opus-4-1@20250805": 8192,
-    }
-
-    # Add types to the types module
-    anthropic_types_stub.Message = SimpleNamespace
-    anthropic_types_stub.MessageParam = dict
-    anthropic_types_stub.ToolParam = dict
-    anthropic_types_stub.ToolUseBlock = SimpleNamespace
-    # Use our mock classes for isinstance checks
-    anthropic_types_stub.ThinkingBlock = MockThinkingBlock
-    anthropic_types_stub.RedactedThinkingBlock = MockRedactedThinkingBlock
-
-    # Add types as a submodule
-    anthropic_stub.types = anthropic_types_stub
-
-    # These anthropic* entries must be installed via monkeypatch.setitem so the
-    # stub is unconditionally torn down. Raw sys.modules assignments leak across
-    # workers and can cross-skip tests/test_provider_error_classification.py
-    # under nondeterministic xdist distribution.
-    monkeypatch.setitem(sys.modules, "anthropic", anthropic_stub)
-    monkeypatch.setitem(sys.modules, "anthropic._constants", anthropic_constants_stub)
-    monkeypatch.setitem(sys.modules, "anthropic.types", anthropic_types_stub)
-
-
-def _setup_openhands_cogitate_stub(
-    monkeypatch,
-    *,
-    error=False,
-    with_thinking=False,
-    with_redacted_thinking=False,
-):
-    from solstone.think.providers import openhands as openhands_provider
-
-    async def fake_run_cogitate(config, on_event=None):
-        if error:
-            raise RuntimeError("boo")
-        if on_event:
-            if with_thinking:
-                on_event(
-                    {
-                        "event": "thinking",
-                        "summary": "I'm thinking about this...",
-                        "signature": "test-signature-123",
-                        "redacted_data": None,
-                        "model": config.get("model"),
-                    }
-                )
-            if with_redacted_thinking:
-                on_event(
-                    {
-                        "event": "thinking",
-                        "summary": "[redacted]",
-                        "signature": None,
-                        "redacted_data": "encrypted-data-xyz",
-                        "model": config.get("model"),
-                    }
-                )
-            on_event({"event": "text_delta", "delta": "ok"})
-            on_event({"event": "finish", "result": "ok"})
-        return "ok"
-
-    monkeypatch.setattr(openhands_provider, "run_cogitate", fake_run_cogitate)
-
-
-def test_claude_main(monkeypatch, tmp_path, capsys):
-    _setup_openhands_cogitate_stub(monkeypatch)
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-    agents_dir = journal / "talents"
-    agents_dir.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "x")
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "anthropic",
-            "model": CLAUDE_SONNET_4,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol solstone.think.talents"], stdin_data=ndjson_input))
-
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    events = [json.loads(line) for line in out_lines]
-    assert events[0]["event"] == "start"
-    assert isinstance(events[0]["ts"], int)
-    # Prompt includes system instruction prepended during enrichment
-    assert "hello" in events[0]["prompt"]
-    assert events[0]["name"] == "exec"
-    assert events[0]["model"] == CLAUDE_SONNET_4
-    assert events[-1]["event"] == "finish"
-    assert isinstance(events[-1]["ts"], int)
-    assert events[-1]["result"] == "ok"
-
-    # Journal logging is now handled by cortex, not by agents directly
-    # So we don't check for journal files here
-
-
-def test_claude_outfile(monkeypatch, tmp_path, capsys):
-    _setup_openhands_cogitate_stub(monkeypatch)
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-    agents_dir = journal / "talents"
-    agents_dir.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "x")
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "anthropic",
-            "model": CLAUDE_SONNET_4,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol solstone.think.talents"], stdin_data=ndjson_input))
-
-    # Output file functionality was removed in NDJSON-only mode
-    # Check stdout instead
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    events = [json.loads(line) for line in out_lines]
-    assert events[0]["event"] == "start"
-    assert isinstance(events[0]["ts"], int)
-    # Prompt includes system instruction prepended during enrichment
-    assert "hello" in events[0]["prompt"]
-    assert events[0]["name"] == "exec"
-    assert events[0]["model"] == CLAUDE_SONNET_4
-    assert events[-1]["event"] == "finish"
-    assert isinstance(events[-1]["ts"], int)
-    assert events[-1]["result"] == "ok"
-
-    # Journal logging is now handled by cortex, not by agents directly
-    # So we don't check for journal files here
-
-
-def test_claude_thinking_events(monkeypatch, tmp_path, capsys):
-    """Test that thinking events are properly emitted for Claude models."""
-    _setup_openhands_cogitate_stub(monkeypatch, with_thinking=True)
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-    agents_dir = journal / "talents"
-    agents_dir.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "x")
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "anthropic",
-            "model": CLAUDE_SONNET_4,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol solstone.think.talents"], stdin_data=ndjson_input))
-
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    events = [json.loads(line) for line in out_lines]
-
-    # Check for thinking event
-    thinking_events = [e for e in events if e.get("event") == "thinking"]
-    assert len(thinking_events) == 1
-    assert "I'm thinking about this..." in thinking_events[0]["summary"]
-
-    # Check that regular events are still present
-    assert events[0]["event"] == "start"
-    assert events[-1]["event"] == "finish"
-    assert events[-1]["result"] == "ok"
-
-
-def test_claude_redacted_thinking_events(monkeypatch, tmp_path, capsys):
-    """Test that redacted thinking events are properly handled."""
-    _setup_openhands_cogitate_stub(monkeypatch, with_redacted_thinking=True)
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-    agents_dir = journal / "talents"
-    agents_dir.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "x")
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "anthropic",
-            "model": CLAUDE_SONNET_4,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol solstone.think.talents"], stdin_data=ndjson_input))
-
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    events = [json.loads(line) for line in out_lines]
-
-    # Check for redacted thinking event
-    thinking_events = [e for e in events if e.get("event") == "thinking"]
-    assert len(thinking_events) == 1
-    assert thinking_events[0]["summary"] == "[redacted]"
-
-    # Check that regular events are still present
-    assert events[0]["event"] == "start"
-    assert events[-1]["event"] == "finish"
-
-
-def test_claude_outfile_error(monkeypatch, tmp_path, capsys):
-    _setup_openhands_cogitate_stub(monkeypatch, error=True)
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-    agents_dir = journal / "talents"
-    agents_dir.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "x")
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "anthropic",
-            "model": CLAUDE_SONNET_4,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol solstone.think.talents"], stdin_data=ndjson_input))
-
-    # Error events should be written to stdout
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    if out_lines:  # May be empty if error is raised before any output
-        events = [json.loads(line) for line in out_lines if line]
-        if events:
-            assert any(e["event"] == "error" for e in events)
-
-
-class TestRunGenerateJsonSchema:
-    def test_run_generate_records_resolved_model_version(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = SimpleNamespace(
-            content=[SimpleNamespace(type="text", text="ok")],
-            usage=SimpleNamespace(input_tokens=10, output_tokens=5),
-            stop_reason="end_turn",
-            model="claude-haiku-4-5-20251001",
-        )
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        result = provider.run_generate(
-            "hello",
-            model="claude-haiku-4-5",
-            max_output_tokens=100,
-        )
-
-        assert result["model"] == "claude-haiku-4-5-20251001"
-        assert result["usage"]["model_version"] == "claude-haiku-4-5-20251001"
-
-    def test_run_generate_model_version_falls_back_to_requested(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = SimpleNamespace(
-            content=[SimpleNamespace(type="text", text="ok")],
-            usage=SimpleNamespace(input_tokens=10, output_tokens=5),
-            stop_reason="end_turn",
-        )
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        result = provider.run_generate(
-            "hello",
-            model="claude-haiku-4-5",
-            max_output_tokens=100,
-        )
-
-        assert result["model"] == "claude-haiku-4-5"
-        assert "model_version" not in result["usage"]
-
-    def test_structured_messages_passthrough(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="ok")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        messages = [
-            {"role": "user", "content": "first"},
-            {"role": "assistant", "content": "second"},
-            {"role": "user", "content": "third"},
-        ]
-
-        provider.run_generate(messages, system_instruction="base")
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["messages"] == messages
-        assert call_kwargs["system"] == "base"
-
-    def test_image_parts_build_anthropic_blocks(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="ok")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        image = Image.new("RGB", (5, 4), color="blue")
-
-        provider.run_generate(["before", image, "after"])
-
-        content = mock_client.messages.create.call_args.kwargs["messages"][0]["content"]
-        assert [block["type"] for block in content] == ["text", "image", "text"]
-        assert content[0]["text"] == "before"
-        assert content[2]["text"] == "after"
-        source = content[1]["source"]
-        assert source["type"] == "base64"
-        assert source["media_type"] == "image/png"
-        decoded = _decoded_image(source["data"])
-        assert decoded.size == image.size
-        assert decoded.format == "PNG"
-
-    def test_png_bytes_part_builds_anthropic_image_block(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="ok")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        data = _png_bytes((6, 3))
-
-        provider.run_generate(["prompt", data])
-
-        content = mock_client.messages.create.call_args.kwargs["messages"][0]["content"]
-        source = content[1]["source"]
-        assert source["media_type"] == "image/png"
-        decoded = _decoded_image(source["data"])
-        assert decoded.size == (6, 3)
-        assert decoded.format == "PNG"
-
-    def test_bad_bytes_raise_before_create(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        with pytest.raises(ValueError) as exc_info:
-            provider.run_generate(["prompt", b"not-an-image"])
-
-        assert "bytes" in str(exc_info.value)
-        assert "not-an-image" in str(exc_info.value)
-        assert mock_client.messages.create.call_count == 0
-
-    def test_cmyk_image_raises_before_create(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        image = Image.new("CMYK", (2, 2))
-
-        with pytest.raises(ValueError) as exc_info:
-            provider.run_generate(["prompt", image])
-
-        assert "Image" in str(exc_info.value)
-        assert "CMYK" in str(exc_info.value)
-        assert mock_client.messages.create.call_count == 0
-
-    def test_no_schema_keeps_prompt_append(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="{}")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            json_output=True,
-            system_instruction="base",
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["system"].endswith(
-            "Respond with valid JSON only. No explanation or markdown."
-        )
-
-    def test_with_schema_uses_output_config(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="{}")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        schema = {"type": "object"}
-
-        provider.run_generate(
-            "hello",
-            system_instruction="base",
-            json_schema=schema,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["output_config"] == {
-            "format": {"type": "json_schema", "schema": schema}
-        }
-        assert "tools" not in call_kwargs
-        assert "tool_choice" not in call_kwargs
-        assert call_kwargs["system"] == "base"
-
-    def test_structured_messages_with_schema_uses_output_config(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="{}")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-        schema = {"type": "object"}
-        messages = [
-            {"role": "user", "content": "first"},
-            {"role": "assistant", "content": "second"},
-            {"role": "user", "content": "third"},
-        ]
-
-        provider.run_generate(
-            messages,
-            system_instruction="base",
-            json_schema=schema,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["messages"] == messages
-        assert call_kwargs["output_config"] == {
-            "format": {"type": "json_schema", "schema": schema}
-        }
-        assert "tools" not in call_kwargs
-        assert "tool_choice" not in call_kwargs
-        assert call_kwargs["system"] == "base"
-
-    def test_async_with_schema_uses_output_config(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="{}")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-        schema = {"type": "object"}
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hello",
-                system_instruction="base",
-                json_schema=schema,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["output_config"] == {
-            "format": {"type": "json_schema", "schema": schema}
-        }
-        assert "tools" not in call_kwargs
-        assert "tool_choice" not in call_kwargs
-        assert call_kwargs["system"] == "base"
-
-    def test_schema_max_tokens_still_surfaces_incomplete_json(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="{}")]
-        mock_response.usage = None
-        mock_response.stop_reason = "max_tokens"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        result = provider.run_generate("hello", json_schema={"type": "object"})
-
-        assert result["finish_reason"] == "max_tokens"
-        with pytest.raises(IncompleteJSONError):
-            _validate_json_response(result, True)
-
-    def test_async_multi_image_parts_preserve_order(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.content = [SimpleNamespace(type="text", text="ok")]
-        mock_response.usage = None
-        mock_response.stop_reason = "end_turn"
-        mock_client.messages.create.return_value = mock_response
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-        first = Image.new("RGB", (3, 2), color="red")
-        second = Image.new("RGB", (4, 5), color="green")
-
-        asyncio.run(provider.run_agenerate(["prompt", first, second]))
-
-        content = mock_client.messages.create.call_args.kwargs["messages"][0]["content"]
-        assert [block["type"] for block in content] == ["text", "image", "image"]
-        assert content[0]["text"] == "prompt"
-        first_source = content[1]["source"]
-        second_source = content[2]["source"]
-        assert first_source["media_type"] == "image/png"
-        assert second_source["media_type"] == "image/png"
-        first_decoded = _decoded_image(first_source["data"])
-        second_decoded = _decoded_image(second_source["data"])
-        assert first_decoded.size == first.size
-        assert second_decoded.size == second.size
-        assert first_decoded.format == "PNG"
-        assert second_decoded.format == "PNG"
-
-
-def _make_response(content=None, stop_reason="end_turn"):
-    response = MagicMock()
-    response.content = (
-        content if content is not None else [SimpleNamespace(type="text", text="ok")]
-    )
-    response.usage = None
-    response.stop_reason = stop_reason
-    return response
-
-
-def _make_stream_cm(final_message, *, enter_side_effect=None):
-    cm = MagicMock()
-    if enter_side_effect is None:
-        stream = MagicMock()
-        stream.get_final_message = MagicMock(return_value=final_message)
-        cm.__enter__ = MagicMock(return_value=stream)
-    else:
-        cm.__enter__ = MagicMock(side_effect=enter_side_effect)
-    cm.__exit__ = MagicMock(return_value=False)
-    return cm
-
-
-def _make_async_stream_cm(final_message):
-    cm = MagicMock()
-    stream = MagicMock()
-    stream.get_final_message = AsyncMock(return_value=final_message)
-    cm.__aenter__ = AsyncMock(return_value=stream)
-    cm.__aexit__ = AsyncMock(return_value=False)
-    return cm
-
-
-class TestBudgetAdjustment:
-    def test_lifts_max_tokens_when_collides_with_thinking_budget(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            thinking_budget=4096,
-            max_output_tokens=4096,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 4096 + 1000 + 1
-        assert call_kwargs["thinking"]["budget_tokens"] == 4096
-
-    def test_leaves_max_tokens_when_buffer_satisfied(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            thinking_budget=4096,
-            max_output_tokens=8192,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 8192
-
-    def test_no_adjustment_without_thinking(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            thinking_budget=0,
-            max_output_tokens=4096,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 4096
-        assert "thinking" not in call_kwargs
-
-    def test_async_lifts_max_tokens_when_collides(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hello",
-                thinking_budget=4096,
-                max_output_tokens=4096,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 4096 + 1000 + 1
-        assert call_kwargs["thinking"]["budget_tokens"] == 4096
-
-
-class TestStreamingDispatch:
-    def test_streams_when_max_tokens_exceeds_time_formula(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_stream_cm(_make_response())
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-sonnet-4-5",
-            max_output_tokens=49152,
-        )
-
-        assert mock_client.messages.stream.call_count == 1
-        assert mock_client.messages.create.call_count == 0
-
-    def test_uses_create_below_threshold(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-sonnet-4-5",
-            max_output_tokens=8192,
-        )
-
-        assert mock_client.messages.create.call_count == 1
-        assert mock_client.messages.stream.call_count == 0
-
-    def test_create_carries_default_provider_timeout(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-sonnet-4-5",
-            max_output_tokens=8192,
-            timeout_s=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["timeout"] == DEFAULT_PROVIDER_TIMEOUT_S
-
-    def test_streams_when_per_model_cap_exceeded(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_stream_cm(_make_response())
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-opus-4-1-20250805",
-            max_output_tokens=16384,
-        )
-
-        assert mock_client.messages.stream.call_count == 1
-        assert mock_client.messages.create.call_count == 0
-
-    def test_stream_carries_default_provider_timeout(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_stream_cm(_make_response())
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-sonnet-4-5",
-            max_output_tokens=22000,
-            timeout_s=DEFAULT_PROVIDER_TIMEOUT_S,
-        )
-
-        # Streaming receives the same plain-float timeout; httpx maps it to read=120s.
-        call_kwargs = mock_client.messages.stream.call_args.kwargs
-        assert call_kwargs["timeout"] == DEFAULT_PROVIDER_TIMEOUT_S
-
-    def test_async_streams_when_max_tokens_exceeds_time_formula(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_async_stream_cm(
-            _make_response()
-        )
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hello",
-                model="claude-sonnet-4-5",
-                max_output_tokens=49152,
-            )
-        )
-
-        assert mock_client.messages.stream.call_count == 1
-        assert mock_client.messages.create.call_count == 0
-
-    def test_async_uses_create_below_threshold(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hello",
-                model="claude-sonnet-4-5",
-                max_output_tokens=8192,
-            )
-        )
-
-        assert mock_client.messages.create.call_count == 1
-        assert mock_client.messages.stream.call_count == 0
-
-    def test_interaction_thinking_and_streaming(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_stream_cm(_make_response())
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hello",
-            model="claude-sonnet-4-5",
-            thinking_budget=24576,
-            max_output_tokens=24576,
-        )
-
-        assert mock_client.messages.stream.call_count == 1
-        call_kwargs = mock_client.messages.stream.call_args.kwargs
-        assert call_kwargs["max_tokens"] == 25577
-
-
-class TestTemperatureCapabilityGate:
-    """Per-model temperature capability gate (omits `temperature` for opus-4-7)."""
-
-    def test_sync_omits_temperature_for_opus_4_7_create(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hi",
-            model=CLAUDE_OPUS_4,
-            temperature=0.3,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "temperature" not in call_kwargs
-        assert "thinking" not in call_kwargs
-
-    def test_async_omits_temperature_for_opus_4_7_create(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hi",
-                model=CLAUDE_OPUS_4,
-                temperature=0.3,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "temperature" not in call_kwargs
-        assert "thinking" not in call_kwargs
-
-    def test_sync_omits_temperature_for_opus_4_7_stream(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream.return_value = _make_stream_cm(_make_response())
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hi",
-            model=CLAUDE_OPUS_4,
-            temperature=0.3,
-            max_output_tokens=49152,
-        )
-
-        stream_kwargs = mock_client.messages.stream.call_args.kwargs
-        assert "temperature" not in stream_kwargs
-        assert mock_client.messages.create.call_count == 0
-
-    def test_async_omits_temperature_for_opus_4_7_stream(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.stream = MagicMock(
-            return_value=_make_async_stream_cm(_make_response())
-        )
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hi",
-                model=CLAUDE_OPUS_4,
-                temperature=0.3,
-                max_output_tokens=49152,
-            )
-        )
-
-        stream_kwargs = mock_client.messages.stream.call_args.kwargs
-        assert "temperature" not in stream_kwargs
-
-    def test_sync_keeps_temperature_for_sonnet_4_6(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hi",
-            model=CLAUDE_SONNET_4,
-            temperature=0.3,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["temperature"] == 0.3
-
-    def test_async_keeps_temperature_for_sonnet_4_6(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hi",
-                model=CLAUDE_SONNET_4,
-                temperature=0.3,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert call_kwargs["temperature"] == 0.3
-
-    def test_sync_thinking_budget_takes_precedence_for_opus_4_7(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hi",
-            model=CLAUDE_OPUS_4,
-            thinking_budget=4096,
-            max_output_tokens=8192,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "thinking" in call_kwargs
-        assert "temperature" not in call_kwargs
-
-    def test_async_thinking_budget_takes_precedence_for_opus_4_7(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hi",
-                model=CLAUDE_OPUS_4,
-                thinking_budget=4096,
-                max_output_tokens=8192,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "thinking" in call_kwargs
-        assert "temperature" not in call_kwargs
-
-    def test_sync_explicit_temperature_omitted_for_opus_4_7(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create.return_value = _make_response()
-        monkeypatch.setattr(provider, "_get_anthropic_client", lambda: mock_client)
-
-        provider.run_generate(
-            "hi",
-            model=CLAUDE_OPUS_4,
-            temperature=0.5,
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "temperature" not in call_kwargs
-
-    def test_async_explicit_temperature_omitted_for_opus_4_7(self, monkeypatch):
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.anthropic")
-        )
-        mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(return_value=_make_response())
-        monkeypatch.setattr(
-            provider, "_get_async_anthropic_client", lambda: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hi",
-                model=CLAUDE_OPUS_4,
-                temperature=0.5,
-            )
-        )
-
-        call_kwargs = mock_client.messages.create.call_args.kwargs
-        assert "temperature" not in call_kwargs
diff --git a/tests/test_batch.py b/tests/test_batch.py
index bbcb21bd4..9dc4296bc 100644
--- a/tests/test_batch.py
+++ b/tests/test_batch.py
@@ -22,21 +22,18 @@ def test_batch_request_creation():
     req = BatchRequest(contents="Test prompt", context="test.context")
     assert req.contents == "Test prompt"
     assert req.context == "test.context"
-    assert req.model is None
     assert req.temperature == 0.3
     assert req.response is None
     assert req.error is None
 
-    # With model override
+    # With generation options
     req2 = BatchRequest(
         contents=["Part 1", "Part 2"],
         context="test.context",
-        model="gemini-flash-lite-latest",
         temperature=0.7,
         json_output=True,
     )
     assert req2.contents == ["Part 1", "Part 2"]
-    assert req2.model == "gemini-flash-lite-latest"
     assert req2.temperature == 0.7
     assert req2.json_output is True
 
@@ -85,12 +82,12 @@ async def test_batch_basic(mock_agenerate):
 
 @pytest.mark.asyncio
 @patch("solstone.think.batch.agenerate_with_result", new_callable=AsyncMock)
-async def test_batch_with_model_override(mock_agenerate):
-    """Test batch with explicit model override."""
-    mock_agenerate.return_value = _result("Response")
+async def test_batch_records_resolved_model(mock_agenerate):
+    """The transport-reported model is recorded without a request override."""
+    mock_agenerate.return_value = _result("Response", model=GEMINI_FLASH)
 
     batch = Batch(max_concurrent=5)
-    req = batch.create(contents="Test", context="test.context", model=GEMINI_FLASH)
+    req = batch.create(contents="Test", context="test.context")
     batch.add(req)
 
     results = []
@@ -100,9 +97,8 @@ async def test_batch_with_model_override(mock_agenerate):
     assert len(results) == 1
     assert results[0].model_used == GEMINI_FLASH
 
-    # Verify model was passed through
     call_kwargs = mock_agenerate.call_args[1]
-    assert call_kwargs["model"] == GEMINI_FLASH
+    assert "model" not in call_kwargs
 
 
 @pytest.mark.asyncio
@@ -282,7 +278,7 @@ async def test_batch_dynamic_adding(mock_agenerate):
 @pytest.mark.asyncio
 @patch("solstone.think.batch.agenerate_with_result", new_callable=AsyncMock)
 async def test_batch_retry_pattern(mock_agenerate):
-    """Test retry pattern - add failed request back with different model."""
+    """Test retry pattern without bypassing the active model profile."""
     # First call fails, second succeeds
     call_count = 0
 
@@ -298,7 +294,7 @@ async def test_batch_retry_pattern(mock_agenerate):
     batch = Batch(max_concurrent=5)
 
     # Add initial request
-    req1 = batch.create(contents="Test", context="test.context", model=GEMINI_FLASH)
+    req1 = batch.create(contents="Test", context="test.context")
     req1.attempt = 1
     batch.add(req1)
 
@@ -306,12 +302,11 @@ async def test_batch_retry_pattern(mock_agenerate):
     async for req in batch.drain_batch():
         results.append(req)
 
-        # If error, retry with different model
+        # If error, retry through the same active profile.
         if req.error and req.attempt == 1:
             retry = batch.create(
                 contents=req.contents,
                 context="test.context",
-                model="gemini-flash-lite-latest",
             )
             retry.attempt = 2
             batch.add(retry)
@@ -336,7 +331,6 @@ async def test_batch_factory_method(mock_agenerate):
     req = batch.create(
         contents="Test",
         context="test.context",
-        model="gemini-flash-lite-latest",
         temperature=0.8,
         json_output=True,
     )
@@ -344,7 +338,6 @@ async def test_batch_factory_method(mock_agenerate):
     assert isinstance(req, BatchRequest)
     assert req.contents == "Test"
     assert req.context == "test.context"
-    assert req.model == "gemini-flash-lite-latest"
     assert req.temperature == 0.8
     assert req.json_output is True
 
@@ -440,21 +433,18 @@ async def test_batch_concurrency_limit(mock_agenerate):
 @patch("solstone.think.batch.agenerate_with_result", new_callable=AsyncMock)
 async def test_batch_update_method(mock_agenerate):
     """Test batch.update() method for modifying and re-adding requests."""
-    # Track which model was used in each call
-    call_models = []
+    call_temperatures = []
 
-    async def mock_track_model(*args, **kwargs):
-        call_models.append(kwargs.get("model", "unknown"))
-        return _result(f"Response from {kwargs.get('model', 'unknown')}")
+    async def mock_track_options(*args, **kwargs):
+        call_temperatures.append(kwargs["temperature"])
+        return _result(f"Response at {kwargs['temperature']}")
 
-    mock_agenerate.side_effect = mock_track_model
+    mock_agenerate.side_effect = mock_track_options
 
     batch = Batch(max_concurrent=5)
 
     # Create initial request
-    req = batch.create(
-        contents="Initial prompt", context="test.context", model=GEMINI_FLASH
-    )
+    req = batch.create(contents="Initial prompt", context="test.context")
     req.stage = "initial"
     batch.add(req)
 
@@ -465,12 +455,12 @@ async def test_batch_update_method(mock_agenerate):
         # Capture the response at this point
         results.append((result_count, completed_req.response, completed_req.stage))
 
-        # After first result, update and re-add with different model
+        # After first result, update generation options and re-add.
         if result_count == 1:
             batch.update(
                 completed_req,
                 contents="Updated prompt",
-                model="gemini-flash-lite-latest",
+                temperature=0.8,
                 stage="updated",  # Update custom attribute too
                 custom_field="test_value",  # Add new custom attribute
             )
@@ -480,12 +470,11 @@ async def test_batch_update_method(mock_agenerate):
     assert results[0][2] == "initial"  # First result was initial stage
     assert results[1][2] == "updated"  # Second result was updated stage
 
-    # Verify models used
-    assert call_models == [GEMINI_FLASH, "gemini-flash-lite-latest"]
+    assert call_temperatures == [0.3, 0.8]
 
     # Verify correct responses at each stage
-    assert results[0][1] == f"Response from {GEMINI_FLASH}"
-    assert results[1][1] == "Response from gemini-flash-lite-latest"
+    assert results[0][1] == "Response at 0.3"
+    assert results[1][1] == "Response at 0.8"
 
     # Verify custom attribute was set
     assert req.custom_field == "test_value"
@@ -528,28 +517,9 @@ async def test_batch_timeout_passthrough(mock_agenerate):
     assert call_kwargs["timeout_s"] == 45
 
 
-@pytest.mark.asyncio
-@patch("solstone.think.batch.agenerate_with_result", new_callable=AsyncMock)
-async def test_batch_client_passthrough(mock_agenerate):
-    """Test that client is passed through for Google connection reuse."""
-    mock_agenerate.return_value = _result("Response")
-
-    # Create a mock client (would be genai.Client for Google)
-    mock_client = object()
-
-    batch = Batch(max_concurrent=5, client=mock_client)
-    req = batch.create(contents="Test", context="test.context")
-    batch.add(req)
-
-    results = []
-    async for completed_req in batch.drain_batch():
-        results.append(completed_req)
-
-    assert len(results) == 1
-
-    # Verify client was passed through
-    call_kwargs = mock_agenerate.call_args[1]
-    assert call_kwargs["client"] is mock_client
+def test_batch_rejects_provider_specific_client_override():
+    with pytest.raises(TypeError, match="unexpected keyword argument 'client'"):
+        Batch(max_concurrent=5, client=object())
 
 
 @pytest.mark.asyncio
diff --git a/tests/test_chat_runtime.py b/tests/test_chat_runtime.py
index 67967e519..27cccaa1f 100644
--- a/tests/test_chat_runtime.py
+++ b/tests/test_chat_runtime.py
@@ -702,12 +702,11 @@ def test_terminal_talent_reports_back_without_redispatch(
 
     spawns: list[dict] = []
 
-    def fake_spawn_agent(prompt, name, provider, config, use_id):
+    def fake_spawn_agent(prompt, name, config, use_id):
         spawns.append(
             {
                 "prompt": prompt,
                 "name": name,
-                "provider": provider,
                 "config": dict(config),
                 "use_id": str(use_id),
             }
diff --git a/tests/test_cortex_client.py b/tests/test_cortex_client.py
index e58c98ba3..18e8cf15f 100644
--- a/tests/test_cortex_client.py
+++ b/tests/test_cortex_client.py
@@ -71,8 +71,7 @@ def test_cortex_request_broadcasts_to_callosum(sent_callosum_messages):
     use_id = cortex_request(
         prompt="Test prompt",
         name="chat",
-        provider="openai",
-        config={"model": GPT_5},
+        config={"facet": "work"},
     )
 
     # Verify broadcast was received
@@ -82,15 +81,16 @@ def test_cortex_request_broadcasts_to_callosum(sent_callosum_messages):
     assert msg["event"] == "request"
     assert msg["prompt"] == "Test prompt"
     assert msg["name"] == "chat"
-    assert msg["provider"] == "openai"
-    assert msg["model"] == GPT_5
+    assert msg["facet"] == "work"
+    assert "provider" not in msg
+    assert "model" not in msg
     assert msg["use_id"] == use_id
     assert "ts" in msg
 
 
 def test_cortex_request_returns_agent_id(sent_callosum_messages):
     """Test that cortex_request returns use_id string."""
-    use_id = cortex_request(prompt="Test", name="chat", provider="openai")
+    use_id = cortex_request(prompt="Test", name="chat")
 
     # Verify use_id is a string timestamp
     assert isinstance(use_id, str)
@@ -104,7 +104,6 @@ def test_cortex_request_uses_explicit_use_id(sent_callosum_messages):
     use_id = cortex_request(
         prompt="Test prompt",
         name="chat",
-        provider="openai",
         use_id="1713629000000",
     )
 
@@ -116,7 +115,7 @@ def test_cortex_request_unique_agent_ids(sent_callosum_messages):
     """Test that cortex_request generates unique agent IDs."""
     agent_ids = []
     for i in range(3):
-        use_id = cortex_request(prompt=f"Test {i}", name="chat", provider="openai")
+        use_id = cortex_request(prompt=f"Test {i}", name="chat")
         agent_ids.append(use_id)
 
     # All agent IDs should be unique
@@ -132,7 +131,7 @@ def test_cortex_request_raises_when_callosum_unavailable(tmp_path, monkeypatch):
     )
 
     with pytest.raises(CortexSpawnUnavailable) as excinfo:
-        cortex_request(prompt="Test", name="chat", provider="openai")
+        cortex_request(prompt="Test", name="chat")
 
     assert excinfo.value.detail == "FileNotFoundError"
 
@@ -147,7 +146,7 @@ def test_cortex_request_empty_journal(tmp_path, monkeypatch):
     )
     monkeypatch.setenv("SOLSTONE_JOURNAL", str(tmp_path))
 
-    use_id = cortex_request("test", "chat", "openai")
+    use_id = cortex_request("test", "chat")
     assert use_id is not None
     assert len(use_id) > 0
 
@@ -183,7 +182,7 @@ def test_cortex_request_returns_when_claim_appears_after_poll(tmp_path, monkeypa
 
     monkeypatch.setattr(cc, "get_use_log_status", fake_status)
 
-    use_id = cortex_request("test", "chat", "openai", use_id="1713629000001")
+    use_id = cortex_request("test", "chat", use_id="1713629000001")
 
     assert use_id == "1713629000001"
 
@@ -204,7 +203,7 @@ def test_cortex_request_rebroadcast_reuses_same_use_id(tmp_path, monkeypatch):
         lambda use_id: "running" if len(send_calls) >= 2 else "not_found",
     )
 
-    use_id = cortex_request("test", "chat", "openai", use_id="1713629000002")
+    use_id = cortex_request("test", "chat", use_id="1713629000002")
 
     assert use_id == "1713629000002"
     assert len(send_calls) >= 2
@@ -225,7 +224,7 @@ def test_cortex_request_raises_when_not_claimed(tmp_path, monkeypatch):
     monkeypatch.setattr(cc, "get_use_log_status", lambda use_id: "not_found")
 
     with pytest.raises(CortexNotClaimed) as excinfo:
-        cortex_request("test", "chat", "openai", use_id="1713629000003")
+        cortex_request("test", "chat", use_id="1713629000003")
 
     assert excinfo.value.use_id == "1713629000003"
     assert len(send_calls) == 3
@@ -248,9 +247,7 @@ def test_cortex_request_patient_windows_are_non_decreasing(tmp_path, monkeypatch
     monkeypatch.setattr(cc, "get_use_log_status", lambda use_id: "not_found")
 
     with pytest.raises(CortexNotClaimed) as excinfo:
-        cortex_request(
-            "test", "chat", "openai", use_id="1713629000005", claim_windows=windows
-        )
+        cortex_request("test", "chat", use_id="1713629000005", claim_windows=windows)
 
     assert len(send_times) == len(windows)
     assert "after 5 broadcasts" in excinfo.value.detail
@@ -277,7 +274,7 @@ def test_cortex_request_raises_spawn_unavailable_on_failed_rebroadcast(
     monkeypatch.setattr(cc, "get_use_log_status", lambda use_id: "not_found")
 
     with pytest.raises(CortexSpawnUnavailable) as excinfo:
-        cortex_request("test", "chat", "openai", use_id="1713629000006")
+        cortex_request("test", "chat", use_id="1713629000006")
 
     assert excinfo.value.detail == "FileNotFoundError"
     assert len(send_calls) == 2
@@ -307,11 +304,11 @@ def test_dispatch_cortex_request_patient_schedule_claims_after_default_would_fai
     )
 
     with pytest.raises(CortexNotClaimed):
-        cortex_request("test", "chat", "openai", use_id="1713629000007")
+        cortex_request("test", "chat", use_id="1713629000007")
 
     clock["value"] = 0.0
     result = think._dispatch_cortex_request(
-        prompt="test", name="chat", provider="openai", use_id="1713629000008"
+        prompt="test", name="chat", use_id="1713629000008"
     )
 
     assert result == "1713629000008"
@@ -329,7 +326,7 @@ def test_cortex_request_immediate_claim_does_not_sleep(tmp_path, monkeypatch):
 
     monkeypatch.setattr(cc.time, "sleep", fail_sleep)
 
-    use_id = cortex_request("test", "chat", "openai", use_id="1713629000004")
+    use_id = cortex_request("test", "chat", use_id="1713629000004")
 
     assert use_id == "1713629000004"
 
diff --git a/tests/test_describe_promote.py b/tests/test_describe_promote.py
index a5128166a..f913df177 100644
--- a/tests/test_describe_promote.py
+++ b/tests/test_describe_promote.py
@@ -165,7 +165,7 @@ class FakeBatch:
             response=None,
             error=None,
             duration=0.01,
-            model_used=kwargs.get("model") or "",
+            model_used="gemini-test",
             provider=None,
             reason_code=None,
             reset_at_ms=None,
diff --git a/tests/test_generate_full.py b/tests/test_generate_full.py
index 9c0004dd2..db997cae1 100644
--- a/tests/test_generate_full.py
+++ b/tests/test_generate_full.py
@@ -13,6 +13,7 @@ import asyncio
 import importlib
 import io
 import json
+import os
 from pathlib import Path
 from unittest.mock import MagicMock
 
@@ -24,6 +25,21 @@ FIXTURES = Path("tests/fixtures")
 
 def copy_day(tmp_path: Path, monkeypatch) -> Path:
     monkeypatch.setenv("SOLSTONE_JOURNAL", str(tmp_path))
+    config_dir = tmp_path / "config"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    (config_dir / "journal.json").write_text(
+        json.dumps(
+            {
+                "providers": {
+                    "active": {
+                        "provider": "google",
+                        "model": "gemini-2.0-flash",
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
     dest = day_path("20240101")
     src = FIXTURES / "journal" / "chronicle" / "20240101"
     copytree_tracked(src, dest)
@@ -39,11 +55,30 @@ MOCK_RESULT = {
 
 def run_generator_with_config(mod, config: dict, monkeypatch) -> list[dict]:
     """Run generator with NDJSON config and capture output events."""
+    config_path = Path(os.environ["SOLSTONE_JOURNAL"]) / "config" / "journal.json"
+    if not config_path.exists():
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(
+            json.dumps(
+                {
+                    "providers": {
+                        "active": {
+                            "provider": "google",
+                            "model": "gemini-2.0-flash",
+                        }
+                    }
+                }
+            ),
+            encoding="utf-8",
+        )
     # Mock argv to prevent argparse from seeing pytest args
     monkeypatch.setattr("sys.argv", ["sol"])
 
     # Mock stdin with config
-    stdin_data = json.dumps(config) + "\n"
+    request = {
+        key: value for key, value in config.items() if key not in {"provider", "model"}
+    }
+    stdin_data = json.dumps(request) + "\n"
     monkeypatch.setattr("sys.stdin", io.StringIO(stdin_data))
 
     # Capture stdout
@@ -109,8 +144,6 @@ def test_generate_output_ndjson(tmp_path, monkeypatch):
         "name": "test_gen",
         "day": "20240101",
         "output": "md",
-        "provider": "google",
-        "model": "gemini-2.0-flash",
     }
 
     events = run_generator_with_config(mod, config, monkeypatch)
@@ -1182,6 +1215,21 @@ def test_cogitate_not_skipped_without_sources(tmp_path, monkeypatch):
 
     # Create empty day directory (no transcripts)
     monkeypatch.setenv("SOLSTONE_JOURNAL", str(tmp_path))
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    (config_dir / "journal.json").write_text(
+        json.dumps(
+            {
+                "providers": {
+                    "active": {
+                        "provider": "google",
+                        "model": "gemini-2.0-flash",
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
     day_dir = day_path("20240101")
     day_dir.mkdir(parents=True, exist_ok=True)
 
diff --git a/tests/test_google.py b/tests/test_google.py
deleted file mode 100644
index 0976a1709..000000000
--- a/tests/test_google.py
+++ /dev/null
@@ -1,491 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-import asyncio
-import importlib
-import json
-import sys
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from google.genai import types as genai_types
-
-from solstone.think.models import DEFAULT_PROVIDER_TIMEOUT_S, GEMINI_FLASH
-from solstone.think.providers import google as google_provider
-from solstone.think.providers.google import (
-    _extract_finish_reason,
-    _extract_usage,
-    _resolved_model,
-)
-from tests.conftest import setup_google_genai_stub
-
-
-@pytest.fixture(autouse=True)
-def _restore_talents_module():
-    saved = sys.modules.pop("solstone.think.talents", None)
-    parent = sys.modules.get("solstone.think")
-    had_parent_attr = parent is not None and hasattr(parent, "talents")
-    saved_parent_attr = getattr(parent, "talents", None) if had_parent_attr else None
-    if had_parent_attr:
-        delattr(parent, "talents")
-    try:
-        yield
-    finally:
-        if saved is not None:
-            sys.modules["solstone.think.talents"] = saved
-        else:
-            sys.modules.pop("solstone.think.talents", None)
-        if parent is not None:
-            if had_parent_attr:
-                setattr(parent, "talents", saved_parent_attr)
-            elif hasattr(parent, "talents"):
-                delattr(parent, "talents")
-
-
-async def run_main(mod, argv, stdin_data=None):
-    sys.argv = argv
-    if stdin_data:
-        import io
-
-        sys.stdin = io.StringIO(stdin_data)
-    await mod.main_async()
-
-
-def _assert_structured_contents(contents):
-    assert [content.role for content in contents] == ["user", "model", "user"]
-    assert [[part.text for part in content.parts] for content in contents] == [
-        ["first"],
-        ["second"],
-        ["third"],
-    ]
-
-
-def _fake_generate_content_response(model_version):
-    return genai_types.GenerateContentResponse(
-        model_version=model_version,
-        candidates=[
-            genai_types.Candidate(
-                content=genai_types.Content(
-                    role="model",
-                    parts=[genai_types.Part(text="ok")],
-                ),
-                finish_reason=genai_types.FinishReason.STOP,
-            )
-        ],
-        usage_metadata=genai_types.GenerateContentResponseUsageMetadata(
-            prompt_token_count=1,
-            candidates_token_count=2,
-            total_token_count=3,
-        ),
-    )
-
-
-def test_build_generate_config_sets_default_provider_timeout_ms():
-    config = google_provider._build_generate_config(
-        temperature=0.3,
-        max_output_tokens=8192,
-        system_instruction=None,
-        json_output=False,
-        thinking_budget=None,
-        timeout_s=DEFAULT_PROVIDER_TIMEOUT_S,
-    )
-
-    assert config.http_options.timeout == DEFAULT_PROVIDER_TIMEOUT_S * 1000
-
-
-def test_get_or_create_client_sets_timeout_and_bounded_retries(monkeypatch):
-    provider = importlib.reload(
-        importlib.import_module("solstone.think.providers.google")
-    )
-    captured: dict[str, object] = {}
-
-    class CapturingClient:
-        def __init__(self, **kwargs):
-            captured.update(kwargs)
-            self.models = SimpleNamespace(list=lambda **_kwargs: [])
-
-    monkeypatch.setenv("GOOGLE_API_KEY", "test-key")
-    monkeypatch.setattr(
-        "solstone.think.utils.get_config",
-        lambda: {"providers": {"google_backend": "aistudio"}},
-    )
-    from google import genai as genai_module
-
-    monkeypatch.setattr(genai_module, "Client", CapturingClient)
-
-    provider.get_or_create_client()
-
-    http_options = captured["http_options"]
-    assert http_options.retry_options.attempts == 3
-    assert http_options.timeout == DEFAULT_PROVIDER_TIMEOUT_S * 1000
-
-
-def test_run_generate_records_resolved_model_version():
-    response = _fake_generate_content_response("gemini-3.5-flash")
-    client = SimpleNamespace(
-        models=SimpleNamespace(generate_content=MagicMock(return_value=response))
-    )
-
-    result = google_provider.run_generate(
-        contents="hello",
-        model="gemini-flash-latest",
-        client=client,
-    )
-
-    assert result["model"] == "gemini-3.5-flash"
-    assert result["usage"]["model_version"] == "gemini-3.5-flash"
-
-
-def test_resolved_model_ignores_non_string_model_version():
-    assert _resolved_model(MagicMock(), "gemini-flash-latest") == "gemini-flash-latest"
-
-
-def test_resolved_model_returns_string_model_version():
-    response = MagicMock()
-    response.model_version = "gemini-3.5-flash"
-
-    assert _resolved_model(response, "gemini-flash-latest") == "gemini-3.5-flash"
-
-
-def test_extract_usage_omits_non_string_model_version():
-    response = MagicMock()
-    metadata = MagicMock()
-    metadata.prompt_token_count = 1
-    metadata.candidates_token_count = 2
-    metadata.total_token_count = 3
-    metadata.cached_content_token_count = 0
-    metadata.thoughts_token_count = 0
-    response.usage_metadata = metadata
-
-    assert "model_version" not in _extract_usage(response)
-
-
-def test_extract_usage_records_string_model_version():
-    response = MagicMock()
-    response.model_version = "gemini-3.5-flash"
-    metadata = MagicMock()
-    metadata.prompt_token_count = 1
-    metadata.candidates_token_count = 2
-    metadata.total_token_count = 3
-    metadata.cached_content_token_count = 0
-    metadata.thoughts_token_count = 0
-    response.usage_metadata = metadata
-
-    assert _extract_usage(response)["model_version"] == "gemini-3.5-flash"
-
-
-def test_run_generate_model_version_falls_back_to_requested():
-    response = _fake_generate_content_response(None)
-    client = SimpleNamespace(
-        models=SimpleNamespace(generate_content=MagicMock(return_value=response))
-    )
-
-    result = google_provider.run_generate(
-        contents="hello",
-        model="gemini-flash-latest",
-        client=client,
-    )
-
-    assert result["model"] == "gemini-flash-latest"
-
-
-def test_google_main(monkeypatch, tmp_path, capsys):
-    mod = importlib.reload(importlib.import_module("solstone.think.talents"))
-
-    journal = tmp_path / "journal"
-    journal.mkdir()
-
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(journal))
-
-    async def fake_run_cogitate(config, on_event=None):
-        if on_event:
-            on_event({"event": "text_delta", "delta": "ok"})
-            on_event({"event": "finish", "result": "ok"})
-        return "ok"
-
-    from solstone.think.providers import openhands as openhands_provider
-
-    monkeypatch.setattr(openhands_provider, "run_cogitate", fake_run_cogitate)
-
-    ndjson_input = json.dumps(
-        {
-            "name": "exec",
-            "prompt": "hello",
-            "provider": "google",
-            "model": GEMINI_FLASH,
-            "tools": ["search_insights"],
-        }
-    )
-    asyncio.run(run_main(mod, ["sol think.talents"], stdin_data=ndjson_input))
-
-    out_lines = capsys.readouterr().out.strip().splitlines()
-    events = [json.loads(line) for line in out_lines]
-    assert events[0]["event"] == "start"
-    assert isinstance(events[0]["ts"], int)
-    assert "hello" in events[0]["prompt"]
-    assert events[0]["name"] == "exec"
-    assert events[0]["model"] == GEMINI_FLASH
-    assert events[-1]["event"] == "finish"
-    assert isinstance(events[-1]["ts"], int)
-    assert events[-1]["result"] == "ok"
-
-    # Journal logging is now handled by cortex, not by agents directly
-    # So we don't check for journal files here
-
-
-# ---------------------------------------------------------------------------
-# Tests for finish reason extraction and formatting
-# ---------------------------------------------------------------------------
-
-
-def test_extract_finish_reason_with_enum():
-    """Test extracting finish_reason from enum-style response."""
-
-    class MockEnum:
-        name = "STOP"
-
-    candidate = SimpleNamespace(finish_reason=MockEnum())
-    response = SimpleNamespace(candidates=[candidate])
-    assert _extract_finish_reason(response) == "STOP"
-
-
-def test_extract_finish_reason_with_string():
-    """Test extracting finish_reason when it's already a string."""
-    candidate = SimpleNamespace(finish_reason="MAX_TOKENS")
-    response = SimpleNamespace(candidates=[candidate])
-    assert _extract_finish_reason(response) == "MAX_TOKENS"
-
-
-def test_extract_finish_reason_no_candidates():
-    """Test extracting finish_reason when no candidates exist."""
-    response = SimpleNamespace(candidates=[])
-    assert _extract_finish_reason(response) is None
-
-    response = SimpleNamespace()
-    assert _extract_finish_reason(response) is None
-
-
-def test_run_generate_empty_stop_completion_returns_empty_text():
-    response = SimpleNamespace(
-        text="",
-        candidates=[SimpleNamespace(finish_reason="STOP", content=None)],
-        usage_metadata=None,
-    )
-    client = SimpleNamespace(
-        models=SimpleNamespace(generate_content=MagicMock(return_value=response))
-    )
-
-    result = google_provider.run_generate(
-        contents="hello",
-        model=GEMINI_FLASH,
-        client=client,
-    )
-
-    assert result["text"] == ""
-    assert result["finish_reason"] == "stop"
-
-
-def test_run_generate_empty_max_tokens_completion_returns_empty_text():
-    response = SimpleNamespace(
-        text="",
-        candidates=[SimpleNamespace(finish_reason="MAX_TOKENS", content=None)],
-        usage_metadata=None,
-    )
-    client = SimpleNamespace(
-        models=SimpleNamespace(generate_content=MagicMock(return_value=response))
-    )
-
-    result = google_provider.run_generate(
-        contents="hello",
-        model=GEMINI_FLASH,
-        client=client,
-    )
-
-    assert result["text"] == ""
-    assert result["finish_reason"] == "max_tokens"
-
-
-def test_run_generate_safety_completion_still_raises():
-    response = SimpleNamespace(
-        text="",
-        candidates=[SimpleNamespace(finish_reason="SAFETY")],
-        usage_metadata=None,
-    )
-    client = SimpleNamespace(
-        models=SimpleNamespace(generate_content=MagicMock(return_value=response))
-    )
-
-    with pytest.raises(ValueError, match="blocked by safety filters"):
-        google_provider.run_generate(
-            contents="hello",
-            model=GEMINI_FLASH,
-            client=client,
-        )
-
-
-class TestRunGenerateJsonSchema:
-    def test_structured_messages_sync_mapped_to_google_contents(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        mock_client = MagicMock()
-        mock_client.models.generate_content.return_value = SimpleNamespace(
-            text="[]",
-            candidates=[],
-            usage_metadata=None,
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-        messages = [
-            {"role": "user", "content": "first"},
-            {"role": "assistant", "content": "second"},
-            {"role": "user", "content": "third"},
-        ]
-
-        provider.run_generate(messages, model=GEMINI_FLASH)
-
-        contents = mock_client.models.generate_content.call_args.kwargs["contents"]
-        _assert_structured_contents(contents)
-
-    def test_structured_messages_async_mapped_to_google_contents(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        mock_client = MagicMock()
-        mock_client.aio.models.generate_content = AsyncMock(
-            return_value=SimpleNamespace(
-                text="[]",
-                candidates=[],
-                usage_metadata=None,
-            )
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-        messages = [
-            {"role": "user", "content": "first"},
-            {"role": "assistant", "content": "second"},
-            {"role": "user", "content": "third"},
-        ]
-
-        asyncio.run(provider.run_agenerate(messages, model=GEMINI_FLASH))
-
-        contents = mock_client.aio.models.generate_content.call_args.kwargs["contents"]
-        _assert_structured_contents(contents)
-
-    def test_no_schema_kwargs_unchanged(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        mock_client = MagicMock()
-        mock_client.models.generate_content.return_value = SimpleNamespace(
-            text="[]",
-            candidates=[],
-            usage_metadata=None,
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-
-        provider.run_generate("hello", model=GEMINI_FLASH, json_output=True)
-
-        config = mock_client.models.generate_content.call_args.kwargs["config"]
-        assert config.response_mime_type == "application/json"
-        assert getattr(config, "response_json_schema", None) is None
-
-    def test_with_schema_adds_json_schema(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        schema = {"type": "object"}
-        mock_client = MagicMock()
-        mock_client.models.generate_content.return_value = SimpleNamespace(
-            text="[]",
-            candidates=[],
-            usage_metadata=None,
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-
-        provider.run_generate(
-            "hello", model=GEMINI_FLASH, json_output=True, json_schema=schema
-        )
-
-        config = mock_client.models.generate_content.call_args.kwargs["config"]
-        assert config.response_mime_type == "application/json"
-        assert config.response_json_schema == schema
-
-    def test_async_no_schema_kwargs_unchanged(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        mock_client = MagicMock()
-        mock_client.aio.models.generate_content = AsyncMock(
-            return_value=SimpleNamespace(
-                text="[]",
-                candidates=[],
-                usage_metadata=None,
-            )
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate("hello", model=GEMINI_FLASH, json_output=True)
-        )
-
-        config = mock_client.aio.models.generate_content.call_args.kwargs["config"]
-        assert config.response_mime_type == "application/json"
-        assert getattr(config, "response_json_schema", None) is None
-
-    def test_async_with_schema_adds_json_schema(self, monkeypatch):
-        setup_google_genai_stub(monkeypatch, with_thinking=False)
-        sys.modules.pop("solstone.think.providers.google", None)
-        provider = importlib.reload(
-            importlib.import_module("solstone.think.providers.google")
-        )
-
-        schema = {"type": "object"}
-        mock_client = MagicMock()
-        mock_client.aio.models.generate_content = AsyncMock(
-            return_value=SimpleNamespace(
-                text="[]",
-                candidates=[],
-                usage_metadata=None,
-            )
-        )
-        monkeypatch.setattr(
-            provider, "get_or_create_client", lambda _client=None: mock_client
-        )
-
-        asyncio.run(
-            provider.run_agenerate(
-                "hello",
-                model=GEMINI_FLASH,
-                json_output=True,
-                json_schema=schema,
-            )
-        )
-
-        config = mock_client.aio.models.generate_content.call_args.kwargs["config"]
-        assert config.response_mime_type == "application/json"
-        assert config.response_json_schema == schema
diff --git a/tests/test_google_sdk.py b/tests/test_google_sdk.py
index 41d38813a..debead6a1 100644
--- a/tests/test_google_sdk.py
+++ b/tests/test_google_sdk.py
@@ -14,11 +14,10 @@ def test_google_provider_metadata_has_no_cogitate_cli() -> None:
 
 
 @pytest.mark.parametrize(
-    ("api_key", "vertex_creds_configured", "expected_status"),
+    ("api_key", "expected_status"),
     [
         (
             "",
-            False,
             {
                 "provider": "google",
                 "configured": False,
@@ -29,7 +28,6 @@ def test_google_provider_metadata_has_no_cogitate_cli() -> None:
         ),
         (
             "key",
-            False,
             {
                 "provider": "google",
                 "configured": True,
@@ -38,37 +36,19 @@ def test_google_provider_metadata_has_no_cogitate_cli() -> None:
                 "issues": [],
             },
         ),
-        (
-            "",
-            True,
-            {
-                "provider": "google",
-                "configured": False,
-                "generate_ready": False,
-                "cogitate_ready": False,
-                "issues": ["GOOGLE_API_KEY not set"],
-            },
-        ),
     ],
 )
-def test_google_provider_status_ignores_gemini_path(
+def test_google_provider_status_uses_managed_key_only(
     monkeypatch,
     api_key: str,
-    vertex_creds_configured: bool,
     expected_status: dict[str, object],
 ) -> None:
     if api_key:
         monkeypatch.setenv("GOOGLE_API_KEY", api_key)
     else:
         monkeypatch.delenv("GOOGLE_API_KEY", raising=False)
-    monkeypatch.setattr(
-        "solstone.think.providers.shutil.which",
-        lambda _name: (_ for _ in ()).throw(AssertionError("which should not run")),
-    )
-
     status = build_provider_status(
         [{"name": "google", "env_key": "GOOGLE_API_KEY"}],
-        vertex_creds_configured=vertex_creds_configured,
     )["google"]
 
     assert "cogitate_cli" not in status
diff --git a/tests/test_lane_failure_honesty.py b/tests/test_lane_failure_honesty.py
index 3bac74e84..2fe4c556f 100644
--- a/tests/test_lane_failure_honesty.py
+++ b/tests/test_lane_failure_honesty.py
@@ -17,8 +17,6 @@ from solstone.think import models
 from solstone.think.journal_config import write_journal_config
 from solstone.think.models import (
     CLAUDE_SONNET_4,
-    GEMINI_FLASH,
-    GPT_5_MINI,
     LOCAL_MODEL,
     IncompleteJSONError,
     resolve_provider,
@@ -86,17 +84,12 @@ def _write_test_config(
     interface: str = "generate",
     env: dict[str, str] | None = None,
     local_endpoint: dict[str, Any] | None = None,
-    legacy: bool = True,
 ) -> dict[str, Any]:
-    section: dict[str, Any] = {"provider": provider, "model": model}
-    if legacy:
-        section.update(
-            {"tier": 1, "backup": "google" if provider != "google" else "openai"}
-        )
+    del interface
     config: dict[str, Any] = {
         "env": env or {},
         "providers": {
-            interface: section,
+            "active": {"provider": provider, "model": model},
         },
     }
     if local_endpoint is not None:
@@ -163,18 +156,59 @@ def _install_generate_probe(
 ) -> LaneProbe:
     observations: list[CallObservation] = []
     counts: dict[str, int] = {}
-    providers = [*CLOUD_PROVIDERS]
+
+    def fake_cloud_generate(
+        contents: Any, model: str, *, provider: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        del contents
+        observations.append(
+            CallObservation(
+                target="solstone.think.providers.openhands",
+                method="generate",
+                provider=provider,
+                model=model,
+                kwargs=dict(kwargs),
+            )
+        )
+        if provider != active_provider:
+            raise AssertionError(f"inactive provider dispatched: {provider}")
+        counts[provider] = counts.get(provider, 0) + 1
+        if active is not None:
+            return active(counts[provider], kwargs)
+        return _result()
+
+    async def fake_cloud_agenerate(
+        contents: Any, model: str, *, provider: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        del contents
+        observations.append(
+            CallObservation(
+                target="solstone.think.providers.openhands",
+                method="agenerate",
+                provider=provider,
+                model=model,
+                kwargs=dict(kwargs),
+            )
+        )
+        raise AssertionError(f"async generate path dispatched: {provider}")
+
+    monkeypatch.setattr(
+        "solstone.think.providers.openhands.run_generate", fake_cloud_generate
+    )
+    monkeypatch.setattr(
+        "solstone.think.providers.openhands.run_agenerate", fake_cloud_agenerate
+    )
+
     if patch_local:
-        providers.append("local")
 
-    def make_sync(provider: str) -> Callable[..., dict[str, Any]]:
-        def fake_run_generate(
+        def fake_local_generate(
             contents: Any, model: str, **kwargs: Any
         ) -> dict[str, Any]:
             del contents
+            provider = "local"
             observations.append(
                 CallObservation(
-                    target=f"solstone.think.providers.{provider}",
+                    target="solstone.think.providers.local",
                     method="generate",
                     provider=provider,
                     model=model,
@@ -188,10 +222,7 @@ def _install_generate_probe(
                 return active(counts[provider], kwargs)
             return _result()
 
-        return fake_run_generate
-
-    def make_async(provider: str) -> Callable[..., Any]:
-        async def fake_run_agenerate(
+        async def fake_local_agenerate(
             contents: Any,
             model: str,
             **kwargs: Any,
@@ -199,25 +230,20 @@ def _install_generate_probe(
             del contents
             observations.append(
                 CallObservation(
-                    target=f"solstone.think.providers.{provider}",
+                    target="solstone.think.providers.local",
                     method="agenerate",
-                    provider=provider,
+                    provider="local",
                     model=model,
                     kwargs=dict(kwargs),
                 )
             )
-            raise AssertionError(f"async generate path dispatched: {provider}")
+            raise AssertionError("async generate path dispatched: local")
 
-        return fake_run_agenerate
-
-    for provider in providers:
         monkeypatch.setattr(
-            f"solstone.think.providers.{provider}.run_generate",
-            make_sync(provider),
+            "solstone.think.providers.local.run_generate", fake_local_generate
         )
         monkeypatch.setattr(
-            f"solstone.think.providers.{provider}.run_agenerate",
-            make_async(provider),
+            "solstone.think.providers.local.run_agenerate", fake_local_agenerate
         )
     return LaneProbe(observations)
 
@@ -225,53 +251,42 @@ def _install_generate_probe(
 def _install_cloud_generate_tripwires(monkeypatch: pytest.MonkeyPatch) -> LaneProbe:
     observations: list[CallObservation] = []
 
-    def make_sync(provider: str) -> Callable[..., dict[str, Any]]:
-        def fake_run_generate(
-            contents: Any, model: str, **kwargs: Any
-        ) -> dict[str, Any]:
-            del contents
-            observations.append(
-                CallObservation(
-                    target=f"solstone.think.providers.{provider}",
-                    method="generate",
-                    provider=provider,
-                    model=model,
-                    kwargs=dict(kwargs),
-                )
+    def fake_run_generate(
+        contents: Any, model: str, *, provider: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        del contents
+        observations.append(
+            CallObservation(
+                target="solstone.think.providers.openhands",
+                method="generate",
+                provider=provider,
+                model=model,
+                kwargs=dict(kwargs),
             )
-            raise AssertionError(f"cloud provider dispatched: {provider}")
-
-        return fake_run_generate
+        )
+        raise AssertionError(f"cloud provider dispatched: {provider}")
 
-    def make_async(provider: str) -> Callable[..., Any]:
-        async def fake_run_agenerate(
-            contents: Any,
-            model: str,
-            **kwargs: Any,
-        ) -> dict[str, Any]:
-            del contents
-            observations.append(
-                CallObservation(
-                    target=f"solstone.think.providers.{provider}",
-                    method="agenerate",
-                    provider=provider,
-                    model=model,
-                    kwargs=dict(kwargs),
-                )
+    async def fake_run_agenerate(
+        contents: Any, model: str, *, provider: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        del contents
+        observations.append(
+            CallObservation(
+                target="solstone.think.providers.openhands",
+                method="agenerate",
+                provider=provider,
+                model=model,
+                kwargs=dict(kwargs),
             )
-            raise AssertionError(f"async cloud provider dispatched: {provider}")
-
-        return fake_run_agenerate
-
-    for provider in CLOUD_PROVIDERS:
-        monkeypatch.setattr(
-            f"solstone.think.providers.{provider}.run_generate",
-            make_sync(provider),
-        )
-        monkeypatch.setattr(
-            f"solstone.think.providers.{provider}.run_agenerate",
-            make_async(provider),
         )
+        raise AssertionError(f"async cloud provider dispatched: {provider}")
+
+    monkeypatch.setattr(
+        "solstone.think.providers.openhands.run_generate", fake_run_generate
+    )
+    monkeypatch.setattr(
+        "solstone.think.providers.openhands.run_agenerate", fake_run_agenerate
+    )
     return LaneProbe(observations)
 
 
@@ -943,172 +958,3 @@ async def test_attempted_failed_segment_remains_repair_selectable(
         "complete": 0,
         "raw_blocked": 0,
     }
-
-
-@pytest.mark.parametrize(
-    (
-        "legacy_config",
-        "modern_config",
-        "interface",
-        "expected_provider",
-        "expected_model",
-    ),
-    [
-        (
-            {
-                "env": {
-                    "ANTHROPIC_API_KEY": "test-anthropic-key",
-                    "GOOGLE_API_KEY": "test-google-key",
-                },
-                "providers": {
-                    "generate": {
-                        "provider": "anthropic",
-                        "model": CLAUDE_SONNET_4,
-                        "tier": 1,
-                        "backup": "google",
-                    },
-                    "contexts": {
-                        "talent.system.test_generator": {
-                            "provider": "google",
-                            "model": GEMINI_FLASH,
-                            "tier": 3,
-                        }
-                    },
-                    "models": {"google": {"1": "legacy-gemini-pro"}},
-                },
-            },
-            {
-                "env": {
-                    "ANTHROPIC_API_KEY": "test-anthropic-key",
-                    "GOOGLE_API_KEY": "test-google-key",
-                },
-                "providers": {
-                    "generate": {
-                        "provider": "anthropic",
-                        "model": CLAUDE_SONNET_4,
-                    }
-                },
-            },
-            "generate",
-            "anthropic",
-            CLAUDE_SONNET_4,
-        ),
-        (
-            {
-                "env": {"GOOGLE_API_KEY": "test-google-key"},
-                "providers": {
-                    "generate": {
-                        "model": "gemini-custom-flash-test",
-                        "tier": 2,
-                        "backup": "anthropic",
-                    },
-                    "contexts": {
-                        "talent.system.test_generator": {
-                            "provider": "anthropic",
-                            "model": CLAUDE_SONNET_4,
-                        }
-                    },
-                    "models": {"anthropic": {"2": "claude-legacy"}},
-                },
-            },
-            {
-                "env": {"GOOGLE_API_KEY": "test-google-key"},
-                "providers": {
-                    "generate": {
-                        "model": "gemini-custom-flash-test",
-                    }
-                },
-            },
-            "generate",
-            "google",
-            "gemini-custom-flash-test",
-        ),
-        (
-            {
-                "env": {"GOOGLE_API_KEY": "test-google-key"},
-                "providers": {
-                    "generate": {
-                        "provider": "local",
-                        "tier": 3,
-                        "backup": "google",
-                    },
-                    "contexts": {
-                        "talent.system.test_generator": {
-                            "provider": "google",
-                            "model": GEMINI_FLASH,
-                        }
-                    },
-                    "models": {"local": {"1": "legacy-local-pro"}},
-                },
-            },
-            {
-                "env": {"GOOGLE_API_KEY": "test-google-key"},
-                "providers": {"generate": {"provider": "local"}},
-            },
-            "generate",
-            "local",
-            LOCAL_MODEL,
-        ),
-        (
-            {
-                "env": {
-                    "OPENAI_API_KEY": "test-openai-key",
-                    "ANTHROPIC_API_KEY": "test-anthropic-key",
-                },
-                "providers": {
-                    "cogitate": {
-                        "provider": "openai",
-                        "model": GPT_5_MINI,
-                        "tier": 1,
-                        "backup": "anthropic",
-                    },
-                    "contexts": {
-                        "talent.system.test_agent": {
-                            "provider": "anthropic",
-                            "model": CLAUDE_SONNET_4,
-                            "tier": 1,
-                        }
-                    },
-                    "models": {"openai": {"1": "legacy-gpt-pro"}},
-                },
-            },
-            {
-                "env": {"OPENAI_API_KEY": "test-openai-key"},
-                "providers": {
-                    "cogitate": {
-                        "provider": "openai",
-                        "model": GPT_5_MINI,
-                    }
-                },
-            },
-            "cogitate",
-            "openai",
-            GPT_5_MINI,
-        ),
-    ],
-)
-def test_grandfathered_legacy_provider_keys_are_inert_for_routing(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    legacy_config: dict[str, Any],
-    modern_config: dict[str, Any],
-    interface: str,
-    expected_provider: str,
-    expected_model: str,
-):
-    _clear_provider_env(monkeypatch)
-    monkeypatch.setenv("SOLSTONE_JOURNAL", str(tmp_path))
-
-    write_journal_config(legacy_config, tmp_path)
-    assert resolve_provider(interface) == (expected_provider, expected_model)
-    legacy_roundtrip = json.loads(
-        (tmp_path / "config" / "journal.json").read_text(encoding="utf-8")
-    )
-    write_journal_config(legacy_roundtrip, tmp_path)
-    assert (
-        json.loads((tmp_path / "config" / "journal.json").read_text(encoding="utf-8"))
-        == legacy_config
-    )
-
-    write_journal_config(modern_config, tmp_path)
-    assert resolve_provider(interface) == (expected_provider, expected_model)
diff --git a/tests/test_local.py b/tests/test_local.py
index c915d851e..9d5491437 100644
--- a/tests/test_local.py
+++ b/tests/test_local.py
@@ -165,19 +165,6 @@ def test_parse_response_fails_closed_on_bad_finish_reasons(raw):
     assert exc_info.value.reason_code == "provider_response_invalid"
 
 
-def test_cloud_generate_providers_do_not_reference_local_budget():
-    root = Path(__file__).resolve().parents[1]
-
-    for rel_path in (
-        "solstone/think/providers/anthropic.py",
-        "solstone/think/providers/google.py",
-        "solstone/think/providers/openai.py",
-    ):
-        text = (root / rel_path).read_text(encoding="utf-8")
-        assert "local_budget" not in text
-        assert "fit_contents" not in text
-
-
 def test_list_models_returns_specs():
     models = _provider().list_models("local")
 
@@ -2341,7 +2328,9 @@ def test_llama_server_pins_are_real_b9291_digests():
 def _select_local_provider(monkeypatch) -> None:
     monkeypatch.setattr(
         "solstone.think.models.get_config",
-        lambda: {"providers": {"generate": {"provider": "local"}}},
+        lambda: {
+            "providers": {"active": {"provider": "local", "model": "local/qwen3.5-4b"}}
+        },
     )
 
 
@@ -2351,7 +2340,11 @@ def test_build_provider_status_local_not_selected_is_inert(monkeypatch):
     health_calls = []
     monkeypatch.setattr(
         "solstone.think.models.get_config",
-        lambda: {"providers": {"generate": {"provider": "google"}}},
+        lambda: {
+            "providers": {
+                "active": {"provider": "google", "model": "gemini-flash-latest"}
+            }
+        },
     )
     monkeypatch.setattr(
         "solstone.think.providers.local_install.inspect_readiness",
diff --git a/tests/test_local_command_home.py b/tests/test_local_command_home.py
index c6a656235..05979f2f3 100644
--- a/tests/test_local_command_home.py
+++ b/tests/test_local_command_home.py
@@ -121,7 +121,6 @@ def test_local_commands_are_journal_help_only(monkeypatch, capsys) -> None:
     [
         (["navigate", "/x"], "journal navigate"),
         (["identity"], "journal identity"),
-        (["settings", "providers", "install", "local"], "journal install-provider"),
     ],
 )
 def test_old_sol_call_paths_redirect(args: list[str], pointer: str) -> None:
diff --git a/tests/test_local_routing.py b/tests/test_local_routing.py
index 47fdaa26a..44d33a8be 100644
--- a/tests/test_local_routing.py
+++ b/tests/test_local_routing.py
@@ -23,12 +23,12 @@ def _write_config(journal: Path, config: dict) -> None:
     )
 
 
-def test_prepare_config_local_type_default_ignores_segment_summary_provider_pin(
+def test_prepare_config_uses_active_local_and_ignores_legacy_context_pin(
     journal_copy: Path,
 ) -> None:
     config = _read_config(journal_copy)
     providers = config.setdefault("providers", {})
-    providers["generate"] = {"provider": "local"}
+    providers["active"] = {"provider": "local", "model": LOCAL_MODEL}
     contexts = providers.setdefault("contexts", {})
     contexts["talent.timeline.segment_summary"] = {
         "provider": "google",
@@ -42,21 +42,21 @@ def test_prepare_config_local_type_default_ignores_segment_summary_provider_pin(
     assert prepared["model"] == LOCAL_MODEL
 
 
-def test_prepare_config_honors_explicit_local_request_model_pin(
+def test_prepare_config_rejects_explicit_request_model_pin(
     journal_copy: Path,
 ) -> None:
     config = _read_config(journal_copy)
     providers = config.setdefault("providers", {})
-    providers["generate"] = {"provider": "local"}
+    providers["active"] = {"provider": "local", "model": LOCAL_MODEL}
     _write_config(journal_copy, config)
 
-    prepared = prepare_config(
-        {
-            "name": "timeline:segment_summary",
-            "provider": "local",
-            "model": "local/custom-7b",
-        }
-    )
+    import pytest
 
-    assert prepared["provider"] == "local"
-    assert prepared["model"] == "local/custom-7b"
+    with pytest.raises(ValueError, match="request overrides for 'provider'"):
+        prepare_config(
+            {
+                "name": "timeline:segment_summary",
+                "provider": "local",
+                "model": "local/custom-7b",
+            }
+        )
diff --git a/tests/test_models.py b/tests/test_models.py
index 1f54e7f3c..6312a47f2 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -246,8 +246,8 @@ def test_resolve_provider_default_generate(use_fixtures_journal):
 def test_resolve_provider_default_cogitate(use_fixtures_journal):
     """Cogitate resolves the configured active provider/model."""
     provider, model = resolve_provider("cogitate")
-    assert provider == "openai"
-    assert model == GPT_5_MINI
+    assert provider == "google"
+    assert model == "gemini-custom-flash-test"
 
 
 def test_resolve_provider_contexts_are_inert(monkeypatch, tmp_path):
@@ -257,7 +257,7 @@ def test_resolve_provider_contexts_are_inert(monkeypatch, tmp_path):
         monkeypatch,
         {
             "providers": {
-                "generate": {
+                "active": {
                     "provider": "google",
                     "model": "gemini-flash-latest",
                 },
@@ -287,7 +287,7 @@ def test_resolve_provider_ordering_witness(monkeypatch, tmp_path):
         monkeypatch,
         {
             "providers": {
-                "generate": {
+                "active": {
                     "provider": "anthropic",
                     "model": "claude-haiku-4-5",
                 }
@@ -382,8 +382,7 @@ def test_default_model_by_provider():
 @pytest.mark.parametrize(
     "config",
     [
-        {"providers": {"generate": {"provider": "local"}}},
-        {"providers": {"cogitate": {"provider": "local"}}},
+        {"providers": {"active": {"provider": "local"}}},
     ],
 )
 def test_is_local_provider_needed_true_for_selected_surfaces(config):
@@ -394,7 +393,7 @@ def test_is_local_provider_needed_true_for_selected_surfaces(config):
     "config",
     [
         {},
-        {"providers": {"generate": {"provider": "google"}}},
+        {"providers": {"active": {"provider": "google"}}},
         {"providers": {"contexts": {"talent.*": {"provider": "anthropic"}}}},
         {"providers": {"contexts": {"talent.*": {"provider": "local"}}}},
         {"providers": []},
@@ -407,7 +406,7 @@ def test_is_local_provider_needed_false_when_not_selected(config, monkeypatch):
     assert is_local_provider_needed(config) is False
 
 
-def test_is_local_provider_needed_true_for_implicit_local(monkeypatch):
+def test_is_local_provider_needed_does_not_infer_from_runtime(monkeypatch):
     monkeypatch.delenv("GOOGLE_API_KEY", raising=False)
     monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
     monkeypatch.delenv("OPENAI_API_KEY", raising=False)
@@ -415,7 +414,7 @@ def test_is_local_provider_needed_true_for_implicit_local(monkeypatch):
         "solstone.think.providers.state.local_runtime_ready", lambda: True
     )
 
-    assert is_local_provider_needed({}) is True
+    assert is_local_provider_needed({}) is False
 
 
 def test_resolve_provider_legacy_keys_are_inert(
@@ -427,7 +426,7 @@ def test_resolve_provider_legacy_keys_are_inert(
         monkeypatch,
         {
             "providers": {
-                "generate": {
+                "active": {
                     "provider": "google",
                     "model": "gemini-flash-latest",
                     "tier": 1,
@@ -457,7 +456,7 @@ def test_resolve_provider_model_key_wins_even_when_tier_present(
         monkeypatch,
         {
             "providers": {
-                "generate": {
+                "active": {
                     "provider": "google",
                     "tier": 1,
                     "model": "gemini-custom-flash-test",
@@ -478,7 +477,7 @@ def test_resolve_provider_local_type_default_ignores_context_pins(
         monkeypatch,
         {
             "providers": {
-                "generate": {"provider": "local"},
+                "active": {"provider": "local"},
                 "contexts": {
                     "talent.timeline.segment_summary": {
                         "provider": "google",
@@ -501,27 +500,18 @@ def test_legacy_context_toggles_remain_on_disk_but_not_routing(
         monkeypatch,
         {
             "providers": {
-                "generate": {"provider": "google", "model": GEMINI_FLASH},
-                "contexts": {
-                    "talent.x": {
-                        "provider": "local",
-                        "tier": 3,
-                        "disabled": True,
-                        "extract": "foo",
-                    }
-                },
-            }
+                "active": {"provider": "google", "model": GEMINI_FLASH},
+            },
+            "talent_overrides": {"talent.x": {"disabled": True, "extract": "foo"}},
         },
     )
 
     assert resolve_provider("generate") == ("google", GEMINI_FLASH)
 
     stored = json.loads((tmp_path / "config" / "journal.json").read_text())
-    context = stored["providers"]["contexts"]["talent.x"]
-    assert context["provider"] == "local"
+    context = stored["talent_overrides"]["talent.x"]
     assert context["disabled"] is True
     assert context["extract"] == "foo"
-    assert context["tier"] == 3
 
 
 def test_prepare_config_legacy_context_routing_keys_are_inert(
@@ -533,15 +523,12 @@ def test_prepare_config_legacy_context_routing_keys_are_inert(
     config_path = journal_copy / "config" / "journal.json"
     config = json.loads(config_path.read_text(encoding="utf-8"))
     config["providers"] = {
-        "generate": {"provider": "anthropic", "model": CLAUDE_SONNET_4},
-        "contexts": {
-            "talent.timeline.segment_summary": {
-                "provider": "google",
-                "model": "gemini-flash-lite-latest",
-                "tier": 3,
-                "backup": "openai",
-            }
-        },
+        "active": {"provider": "anthropic", "model": CLAUDE_SONNET_4},
+    }
+    config["talent_overrides"] = {
+        "talent.timeline.segment_summary": {
+            "disabled": False,
+        }
     }
     config_path.write_text(json.dumps(config), encoding="utf-8")
 
@@ -561,7 +548,7 @@ def test_prepare_config_frontmatter_provider_pin_is_dead_through_dispatch_identi
     config = json.loads(config_path.read_text(encoding="utf-8"))
     config["env"] = {"GOOGLE_API_KEY": "test-google-key"}
     config["providers"] = {
-        "generate": {"provider": "anthropic", "model": CLAUDE_SONNET_4}
+        "active": {"provider": "anthropic", "model": CLAUDE_SONNET_4}
     }
     config_path.write_text(json.dumps(config), encoding="utf-8")
 
@@ -581,74 +568,64 @@ def test_resolve_provider_cogitate_system_talents_stay_local(
     _write_tmp_journal_config(
         tmp_path,
         monkeypatch,
-        {"providers": {"cogitate": {"provider": "local"}}},
+        {"providers": {"active": {"provider": "local"}}},
     )
 
     assert resolve_provider("cogitate") == ("local", LOCAL_MODEL)
 
 
-def test_resolve_provider_split_lane_other_type_stays_cloud(
+def test_generate_and_cogitate_share_one_active_profile(
     use_fixtures_journal, monkeypatch, tmp_path
 ):
-    """A local generate lane does not force the cogitate lane local."""
+    """Both runtime interfaces resolve the same active profile."""
     _write_tmp_journal_config(
         tmp_path,
         monkeypatch,
         {
             "providers": {
-                "generate": {"provider": "local"},
-                "cogitate": {"provider": "openai"},
+                "active": {"provider": "openai"},
             }
         },
     )
 
-    assert resolve_provider("generate") == ("local", LOCAL_MODEL)
+    assert resolve_provider("generate") == ("openai", GPT_5_MINI)
     assert resolve_provider("cogitate") == ("openai", GPT_5_MINI)
 
 
-def test_generate_rejects_cloud_model_override_for_local_provider():
-    with (
-        patch(
-            "solstone.think.models.resolve_provider",
-            return_value=("local", "local/qwen3.5-4b"),
-        ),
-        patch(
-            "solstone.think.providers.get_provider_module",
-            side_effect=AssertionError("provider module should not be invoked"),
-        ),
-    ):
-        with pytest.raises(ValueError, match="local provider cannot serve"):
-            generate("hello", "test.context", model="gpt-5.5")
+@pytest.mark.parametrize(
+    "call",
+    [
+        lambda: generate("hello", "test.context", model="gpt-5.5"),
+        lambda: generate_with_result("hello", "test.context", model="gpt-5.5"),
+        lambda: asyncio.run(agenerate("hello", "test.context", model="gpt-5.5")),
+    ],
+)
+def test_generate_entry_points_reject_request_model_overrides(call):
+    """Provider/model selection belongs exclusively to the active profile."""
+    with pytest.raises(TypeError, match="unexpected keyword argument 'model'"):
+        call()
 
 
-def test_generate_with_result_rejects_cloud_model_override_for_local_provider():
+def test_local_generate_entry_points_do_not_pass_cloud_transport_options():
+    provider_module = SimpleNamespace(
+        run_generate=MagicMock(return_value={"text": "ok", "finish_reason": "stop"}),
+        run_agenerate=AsyncMock(return_value={"text": "ok", "finish_reason": "stop"}),
+    )
     with (
         patch(
             "solstone.think.models.resolve_provider",
-            return_value=("local", "local/qwen3.5-4b"),
+            return_value=("local", LOCAL_MODEL),
         ),
         patch(
             "solstone.think.providers.get_provider_module",
-            side_effect=AssertionError("provider module should not be invoked"),
+            return_value=provider_module,
         ),
     ):
-        with pytest.raises(ValueError, match="local provider cannot serve"):
-            generate_with_result("hello", "test.context", model="gpt-5.5")
-
+        assert generate("hello", "test.context") == "ok"
+        assert asyncio.run(agenerate("hello", "test.context")) == "ok"
 
-def test_agenerate_rejects_cloud_model_override_for_local_provider():
-    with (
-        patch(
-            "solstone.think.models.resolve_provider",
-            return_value=("local", "local/qwen3.5-4b"),
-        ),
-        patch(
-            "solstone.think.providers.get_provider_module",
-            side_effect=AssertionError("provider module should not be invoked"),
-        ),
-    ):
-        with pytest.raises(ValueError, match="local provider cannot serve"):
-            asyncio.run(agenerate("hello", "test.context", model="gpt-5.5"))
+    assert "provider" not in provider_module.run_generate.call_args.kwargs
+    assert "provider" not in provider_module.run_agenerate.call_args.kwargs
 
 
 def test_generate_stops_before_provider_module_when_no_brain():
@@ -696,40 +673,6 @@ def test_agenerate_stops_before_provider_module_when_no_brain():
             asyncio.run(agenerate("hello", "test.context"))
 
 
-def test_unknown_model_override_for_local_provider_proceeds_to_provider():
-    provider_module = SimpleNamespace(
-        run_generate=MagicMock(
-            return_value={"text": "ok", "finish_reason": "stop"},
-        ),
-        run_agenerate=AsyncMock(
-            return_value={"text": "ok", "finish_reason": "stop"},
-        ),
-    )
-
-    with (
-        patch(
-            "solstone.think.models.resolve_provider",
-            return_value=("local", "local/qwen3.5-4b"),
-        ),
-        patch(
-            "solstone.think.providers.get_provider_module",
-            return_value=provider_module,
-        ),
-    ):
-        assert generate("hello", "test.context", model="served-model") == "ok"
-        assert generate_with_result("hello", "test.context", model="served-model") == {
-            "text": "ok",
-            "finish_reason": "stop",
-        }
-        assert (
-            asyncio.run(agenerate("hello", "test.context", model="served-model"))
-            == "ok"
-        )
-
-    assert provider_module.run_generate.call_count == 2
-    assert provider_module.run_agenerate.call_count == 1
-
-
 # ---------------------------------------------------------------------------
 # Dynamic context registry tests
 # ---------------------------------------------------------------------------
diff --git a/tests/test_no_implicit_cloud.py b/tests/test_no_implicit_cloud.py
index 017c49b81..66a37d066 100644
--- a/tests/test_no_implicit_cloud.py
+++ b/tests/test_no_implicit_cloud.py
@@ -19,7 +19,6 @@ from solstone.think import models, talents
 from solstone.think.models import (
     CLAUDE_SONNET_4,
     GEMINI_FLASH,
-    GPT_5_MINI,
     LOCAL_MODEL,
     NO_BRAIN_PROVIDER,
     AttestationFailedError,
@@ -66,12 +65,6 @@ def _cloud_call_mocks(monkeypatch: pytest.MonkeyPatch) -> list[Mock]:
         ("solstone.think.providers.openhands", "run_generate"),
         ("solstone.think.providers.openhands", "run_agenerate"),
         ("solstone.think.providers.openhands", "run_cogitate"),
-        ("solstone.think.providers.google", "run_generate"),
-        ("solstone.think.providers.google", "run_agenerate"),
-        ("solstone.think.providers.openai", "run_generate"),
-        ("solstone.think.providers.openai", "run_agenerate"),
-        ("solstone.think.providers.anthropic", "run_generate"),
-        ("solstone.think.providers.anthropic", "run_agenerate"),
     ]
     for module_name, attr in targets:
         mock = Mock(side_effect=AssertionError("cloud call attempted"))
@@ -103,16 +96,17 @@ def _confidential_config(*, provider_pins: bool = True) -> dict:
                 "served_model_id": "confidential-model",
                 "credential_created_at": "2026-05-24T00:00:00Z",
                 "credential_fingerprint_sha256": "fingerprint",
-                "prior_generate_provider": "google",
-                "prior_cogitate_provider": "openai",
+                "prior_active": {
+                    "provider": "google",
+                    "model": GEMINI_FLASH,
+                },
                 "prior_local_endpoint": None,
             }
         },
     }
     if provider_pins:
         config["providers"] = {
-            "generate": {"provider": "google", "backup": "openai"},
-            "cogitate": {"provider": "openai", "backup": "anthropic"},
+            "active": {"provider": "google", "model": GEMINI_FLASH},
         }
     return config
 
@@ -449,8 +443,7 @@ def test_confidential_local_lane_stops_before_any_provider_dispatch(
     _empty_journal(tmp_path, monkeypatch)
     config = _confidential_config()
     config["providers"] = {
-        "generate": {"provider": "local"},
-        "cogitate": {"provider": "local"},
+        "active": {"provider": "local", "model": LOCAL_MODEL},
     }
     _write_journal_config(tmp_path, config)
     establish = _install_failing_confidential_transport(monkeypatch)
@@ -563,6 +556,9 @@ def test_confidential_gate_keys_on_provenance_not_provider_resolution(
     _empty_journal(tmp_path, monkeypatch)
     config = _confidential_config(provider_pins=False)
     config["env"] = {"GOOGLE_API_KEY": "stray-google-key"}
+    config["providers"] = {
+        "active": {"provider": "local", "model": LOCAL_MODEL},
+    }
     _write_journal_config(tmp_path, config)
     establish = _install_failing_confidential_transport(monkeypatch)
     mocks = _cloud_call_mocks(monkeypatch)
@@ -803,47 +799,45 @@ def test_none_provider_module_fails_closed(tmp_path, monkeypatch):
 
 
 @pytest.mark.parametrize(
-    ("agent_type", "env_key", "expected_provider", "expected_model"),
+    ("agent_type", "env_key"),
     [
-        ("generate", "GOOGLE_API_KEY", "google", GEMINI_FLASH),
-        ("generate", "ANTHROPIC_API_KEY", "anthropic", CLAUDE_SONNET_4),
-        ("generate", "OPENAI_API_KEY", "openai", GPT_5_MINI),
-        ("cogitate", "GOOGLE_API_KEY", "google", GEMINI_FLASH),
-        ("cogitate", "ANTHROPIC_API_KEY", "anthropic", CLAUDE_SONNET_4),
-        ("cogitate", "OPENAI_API_KEY", "openai", GPT_5_MINI),
+        ("generate", "GOOGLE_API_KEY"),
+        ("generate", "ANTHROPIC_API_KEY"),
+        ("generate", "OPENAI_API_KEY"),
+        ("cogitate", "GOOGLE_API_KEY"),
+        ("cogitate", "ANTHROPIC_API_KEY"),
+        ("cogitate", "OPENAI_API_KEY"),
     ],
 )
-def test_key_presence_grandfathers_existing_installs(
+def test_key_presence_does_not_implicitly_select_a_provider(
     tmp_path,
     monkeypatch,
     agent_type: str,
     env_key: str,
-    expected_provider: str,
-    expected_model: str,
 ):
     _empty_journal(tmp_path, monkeypatch)
     original = _write_journal_config(tmp_path, {"env": {env_key: "test-key"}})
 
     provider, model = resolve_provider(agent_type)
 
-    assert provider == expected_provider
-    assert model == expected_model
+    assert provider == NO_BRAIN_PROVIDER
+    assert model == ""
     assert (tmp_path / "config" / "journal.json").read_text(
         encoding="utf-8"
     ) == original
 
 
-def test_model_only_config_uses_key_selected_provider(tmp_path, monkeypatch):
+def test_model_only_config_does_not_infer_provider_from_key(tmp_path, monkeypatch):
     _empty_journal(tmp_path, monkeypatch)
     _write_journal_config(
         tmp_path,
         {
             "env": {"GOOGLE_API_KEY": "test-key"},
-            "providers": {"generate": {"model": "gemini-custom"}},
+            "providers": {"active": {"model": "gemini-custom"}},
         },
     )
 
-    assert resolve_provider("generate") == ("google", "gemini-custom")
+    assert resolve_provider("generate") == (NO_BRAIN_PROVIDER, "")
 
 
 def test_explicit_provider_does_not_fall_through_to_keyed_provider(
@@ -854,28 +848,21 @@ def test_explicit_provider_does_not_fall_through_to_keyed_provider(
         tmp_path,
         {
             "env": {"GOOGLE_API_KEY": "test-key"},
-            "providers": {"generate": {"provider": "anthropic"}},
+            "providers": {"active": {"provider": "anthropic"}},
         },
     )
-    google = Mock(side_effect=AssertionError("google dispatched"))
-    monkeypatch.setattr("solstone.think.providers.google.run_generate", google)
 
     assert resolve_provider("generate") == ("anthropic", CLAUDE_SONNET_4)
-    with pytest.raises(ValueError, match="ANTHROPIC_API_KEY not found"):
-        models.generate("hello", "any.context")
-    google.assert_not_called()
 
 
-def test_accepted_grandfather_divergence_lite_context_now_uses_brain_model(
-    tmp_path, monkeypatch
-):
+def test_key_only_config_requires_maintenance_migration(tmp_path, monkeypatch):
     _empty_journal(tmp_path, monkeypatch)
     _write_journal_config(tmp_path, {"env": {"GOOGLE_API_KEY": "test-key"}})
 
-    assert resolve_provider("generate") == ("google", GEMINI_FLASH)
+    assert resolve_provider("generate") == (NO_BRAIN_PROVIDER, "")
 
 
-def test_implicit_local_when_runtime_ready(tmp_path, monkeypatch):
+def test_runtime_readiness_does_not_implicitly_select_local(tmp_path, monkeypatch):
     _empty_journal(tmp_path, monkeypatch)
     monkeypatch.setattr(
         "solstone.think.providers.state.local_runtime_ready", lambda: True
@@ -883,9 +870,9 @@ def test_implicit_local_when_runtime_ready(tmp_path, monkeypatch):
 
     provider, model = resolve_provider("generate")
 
-    assert provider == "local"
-    assert model == LOCAL_MODEL
-    assert is_local_provider_needed() is True
+    assert provider == NO_BRAIN_PROVIDER
+    assert model == ""
+    assert is_local_provider_needed() is False
     assert not (tmp_path / "config" / "journal.json").exists()
 
 
@@ -898,7 +885,7 @@ def test_explicit_local_type_default_neutralizes_cloud_context_pin(
         tmp_path,
         {
             "providers": {
-                "generate": {"provider": "local"},
+                "active": {"provider": "local"},
                 "contexts": {
                     "talent.timeline.segment_summary": {
                         "provider": "google",
diff --git a/tests/test_openai.py b/tests/test_openai.py
deleted file mode 100644
index c16291214..000000000
--- a/tests/test_openai.py
+++ /dev/null
@@ -1,816 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-import asyncio
-import base64
-import importlib
-import io
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from PIL import Image
-
-from solstone.think.models import DEFAULT_PROVIDER_TIMEOUT_S
-
-
-def _openai_provider():
-    return importlib.reload(importlib.import_module("solstone.think.providers.openai"))
-
-
-def _make_openai_response(text="Hello"):
-    response = MagicMock()
-    response.output_text = text
-    response.status = "completed"
-    response.incomplete_details = None
-    response.usage = None
-    response.output = []
-    return response
-
-
-def _png_bytes(size: tuple[int, int] = (4, 3)) -> bytes:
-    image = Image.new("RGB", size, color="red")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG", compress_level=1)
-    return buf.getvalue()
-
-
-def _decode_openai_image_part(part):
-    prefix, b64 = part["image_url"].split(",", 1)
-    assert prefix.startswith("data:")
-    assert prefix.endswith(";base64")
-    return prefix[5:-7], Image.open(io.BytesIO(base64.b64decode(b64)))
-
-
-class TestParseModelEffort:
-    def test_no_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2") == ("gpt-5.2", None)
-
-    def test_high_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-high") == ("gpt-5.2", "high")
-
-    def test_low_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-low") == ("gpt-5.2", "low")
-
-    def test_medium_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-medium") == ("gpt-5.2", "medium")
-
-    def test_none_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-none") == ("gpt-5.2", "none")
-
-    def test_xhigh_suffix(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-xhigh") == ("gpt-5.2", "xhigh")
-
-    def test_unknown_suffix_not_stripped(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("gpt-5.2-turbo") == (
-            "gpt-5.2-turbo",
-            None,
-        )
-
-    def test_non_gpt_model_passthrough(self):
-        provider = _openai_provider()
-        assert provider._parse_model_effort("claude-sonnet-4-5") == (
-            "claude-sonnet-4-5",
-            None,
-        )
-
-
-class TestBuildInput:
-    def test_string_input(self):
-        provider = _openai_provider()
-        assert provider._build_input("hello") == ("hello", None)
-
-    def test_string_with_system(self):
-        provider = _openai_provider()
-        assert provider._build_input("hello", "sys") == ("hello", "sys")
-
-    def test_list_of_parts(self):
-        provider = _openai_provider()
-        assert provider._build_input(["part1", "part2"]) == ("part1\npart2", None)
-
-    def test_message_list(self):
-        provider = _openai_provider()
-        message = [{"role": "user", "content": "hi"}]
-        assert provider._build_input(message) == (message, None)
-
-    def test_non_string(self):
-        provider = _openai_provider()
-        assert provider._build_input(42) == ("42", None)
-
-
-class TestExtractUsage:
-    def test_extract_usage_with_details(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.usage.input_tokens = 100
-        mock_response.usage.output_tokens = 50
-        mock_response.usage.total_tokens = 150
-        mock_response.usage.input_tokens_details.cached_tokens = 20
-        mock_response.usage.output_tokens_details.reasoning_tokens = 10
-
-        assert provider._extract_usage(mock_response) == {
-            "input_tokens": 100,
-            "output_tokens": 50,
-            "total_tokens": 150,
-            "cached_tokens": 20,
-            "reasoning_tokens": 10,
-        }
-
-    def test_extract_usage_missing(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.usage = None
-        assert provider._extract_usage(mock_response) is None
-
-    def test_extract_usage_without_details(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.usage.input_tokens = 100
-        mock_response.usage.output_tokens = 50
-        mock_response.usage.total_tokens = 150
-        mock_response.usage.input_tokens_details = None
-        mock_response.usage.output_tokens_details = None
-
-        assert provider._extract_usage(mock_response) == {
-            "input_tokens": 100,
-            "output_tokens": 50,
-            "total_tokens": 150,
-        }
-
-
-class TestNormalizeFinishReason:
-    def test_completed(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.status = "completed"
-        assert provider._normalize_finish_reason(mock_response) == "stop"
-
-    def test_incomplete_max_tokens(self):
-        provider = _openai_provider()
-        incomplete_details = MagicMock()
-        incomplete_details.reason = "max_output_tokens"
-        mock_response = MagicMock()
-        mock_response.status = "incomplete"
-        mock_response.incomplete_details = incomplete_details
-        assert provider._normalize_finish_reason(mock_response) == "max_tokens"
-
-    def test_incomplete_content_filter(self):
-        provider = _openai_provider()
-        incomplete_details = MagicMock()
-        incomplete_details.reason = "content_filter"
-        mock_response = MagicMock()
-        mock_response.status = "incomplete"
-        mock_response.incomplete_details = incomplete_details
-        assert provider._normalize_finish_reason(mock_response) == "content_filter"
-
-    def test_incomplete_without_details(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.status = "incomplete"
-        mock_response.incomplete_details = None
-        assert provider._normalize_finish_reason(mock_response) == "max_tokens"
-
-    def test_failed(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.status = "failed"
-        assert provider._normalize_finish_reason(mock_response) == "error"
-
-
-class TestExtractThinking:
-    def test_reasoning_summary_extracted(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        reasoning_item = MagicMock()
-        reasoning_item.type = "reasoning"
-        summary = MagicMock()
-        summary.text = "Let me think..."
-        reasoning_item.summary = [summary]
-        mock_response.output = [reasoning_item]
-
-        assert provider._extract_thinking(mock_response) == [
-            {"summary": "Let me think..."},
-        ]
-
-    def test_no_reasoning_items(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.output = [MagicMock(type="message")]
-        assert provider._extract_thinking(mock_response) is None
-
-    def test_empty_output(self):
-        provider = _openai_provider()
-        mock_response = MagicMock()
-        mock_response.output = []
-        assert provider._extract_thinking(mock_response) is None
-
-
-class TestRunGenerate:
-    def test_basic_generate(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello world"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = MagicMock()
-        mock_response.usage.input_tokens = 10
-        mock_response.usage.output_tokens = 5
-        mock_response.usage.total_tokens = 15
-        mock_response.usage.input_tokens_details = None
-        mock_response.usage.output_tokens_details = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            result = provider.run_generate("hello", model="gpt-5.2")
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["model"] == "gpt-5.2"
-        assert called_kwargs["input"] == "hello"
-        assert called_kwargs["max_output_tokens"] == 16384
-        assert "instructions" not in called_kwargs
-        assert result["text"] == "Hello world"
-        assert result["finish_reason"] == "stop"
-        assert result["thinking"] is None
-        assert result["usage"] == {
-            "input_tokens": 10,
-            "output_tokens": 5,
-            "total_tokens": 15,
-        }
-
-    def test_run_generate_records_resolved_model_version(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = _make_openai_response("Hello world")
-        mock_response.model = "gpt-5-2025-08-07"
-        mock_response.usage = MagicMock()
-        mock_response.usage.input_tokens = 10
-        mock_response.usage.output_tokens = 5
-        mock_response.usage.total_tokens = 15
-        mock_response.usage.input_tokens_details = None
-        mock_response.usage.output_tokens_details = None
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            result = provider.run_generate("hello", model="gpt-5")
-
-        assert result["model"] == "gpt-5-2025-08-07"
-        assert result["usage"]["model_version"] == "gpt-5-2025-08-07"
-
-    def test_run_generate_model_version_falls_back_to_requested(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = _make_openai_response("Hello world")
-        mock_response.model = MagicMock()
-        mock_response.usage = MagicMock()
-        mock_response.usage.input_tokens = 10
-        mock_response.usage.output_tokens = 5
-        mock_response.usage.total_tokens = 15
-        mock_response.usage.input_tokens_details = None
-        mock_response.usage.output_tokens_details = None
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            result = provider.run_generate("hello", model="gpt-5")
-
-        assert result["model"] == "gpt-5"
-        assert "model_version" not in result["usage"]
-
-    def test_structured_messages_passthrough(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello world"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-        messages = [
-            {"role": "user", "content": "first"},
-            {"role": "assistant", "content": "second"},
-            {"role": "user", "content": "third"},
-        ]
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(messages, system_instruction="Be helpful")
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["input"] == messages
-        assert called_kwargs["instructions"] == "Be helpful"
-
-    def test_image_parts_build_structured_input(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock(return_value=_make_openai_response())
-        image = Image.new("RGB", (5, 4), color="blue")
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(["before", image, "after"], model="gpt-5.2")
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        message = called_kwargs["input"][0]
-        assert message["role"] == "user"
-        parts = message["content"]
-        assert [part["type"] for part in parts] == [
-            "input_text",
-            "input_image",
-            "input_text",
-        ]
-        assert parts[0]["text"] == "before"
-        assert parts[2]["text"] == "after"
-        assert parts[1]["detail"] == "auto"
-        media_type, decoded = _decode_openai_image_part(parts[1])
-        assert media_type == "image/png"
-        assert decoded.size == image.size
-        assert decoded.format == "PNG"
-
-    def test_png_bytes_part_builds_data_url(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock(return_value=_make_openai_response())
-        data = _png_bytes((6, 3))
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(["prompt", data], model="gpt-5.2")
-
-        parts = mock_client.responses.create.call_args.kwargs["input"][0]["content"]
-        media_type, decoded = _decode_openai_image_part(parts[1])
-        assert media_type == "image/png"
-        assert decoded.size == (6, 3)
-        assert decoded.format == "PNG"
-
-    def test_bad_bytes_raise_before_create(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-
-        with (
-            patch(
-                "solstone.think.providers.openai._get_openai_client",
-                return_value=mock_client,
-            ),
-            pytest.raises(ValueError) as exc_info,
-        ):
-            provider.run_generate(["prompt", b"not-an-image"], model="gpt-5.2")
-
-        assert "bytes" in str(exc_info.value)
-        assert "not-an-image" in str(exc_info.value)
-        assert mock_client.responses.create.call_count == 0
-
-    def test_cmyk_image_raises_before_create(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        image = Image.new("CMYK", (2, 2))
-
-        with (
-            patch(
-                "solstone.think.providers.openai._get_openai_client",
-                return_value=mock_client,
-            ),
-            pytest.raises(ValueError) as exc_info,
-        ):
-            provider.run_generate(["prompt", image], model="gpt-5.2")
-
-        assert "Image" in str(exc_info.value)
-        assert "CMYK" in str(exc_info.value)
-        assert mock_client.responses.create.call_count == 0
-
-    def test_with_effort_suffix(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", model="gpt-5.2-high")
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["model"] == "gpt-5.2"
-        assert called_kwargs["reasoning"] == {"effort": "high"}
-
-    def test_with_json_output(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", model="gpt-5.2", json_output=True)
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"] == {"format": {"type": "json_object"}}
-
-    def test_no_schema_format_unchanged(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(
-                "hello",
-                model="gpt-5.2",
-                json_output=True,
-                json_schema=None,
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"] == {"format": {"type": "json_object"}}
-
-    def test_with_schema_format_shape(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-        schema = {"type": "object"}
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", model="gpt-5.2", json_schema=schema)
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"] == {
-            "format": {
-                "type": "json_schema",
-                "name": "response",
-                "schema": schema,
-                "strict": True,
-            }
-        }
-
-    def test_schema_title_becomes_name(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(
-                "hello",
-                model="gpt-5.2",
-                json_schema={"title": "MyThing", "type": "object"},
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"]["format"]["name"] == "MyThing"
-
-    def test_schema_bad_title_falls_back(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate(
-                "hello",
-                model="gpt-5.2",
-                json_schema={"title": "bad name with spaces", "type": "object"},
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"]["format"]["name"] == "response"
-
-    def test_with_system_instruction(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", system_instruction="Be helpful")
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["instructions"] == "Be helpful"
-
-    def test_with_timeout(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", timeout_s=30.0)
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["timeout"] == 30.0
-
-    def test_with_default_provider_timeout(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = MagicMock(return_value=_make_openai_response())
-
-        with patch(
-            "solstone.think.providers.openai._get_openai_client",
-            return_value=mock_client,
-        ):
-            provider.run_generate("hello", timeout_s=DEFAULT_PROVIDER_TIMEOUT_S)
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["timeout"] == DEFAULT_PROVIDER_TIMEOUT_S
-
-
-class TestRunAgenerate:
-    def test_basic_agenerate(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello world"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = MagicMock()
-        mock_response.usage.input_tokens = 10
-        mock_response.usage.output_tokens = 5
-        mock_response.usage.total_tokens = 15
-        mock_response.usage.input_tokens_details = None
-        mock_response.usage.output_tokens_details = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            result = asyncio.run(provider.run_agenerate("hello", model="gpt-5.2"))
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["model"] == "gpt-5.2"
-        assert called_kwargs["input"] == "hello"
-        assert called_kwargs["max_output_tokens"] == 16384
-        assert result["text"] == "Hello world"
-        assert result["finish_reason"] == "stop"
-        assert result["thinking"] is None
-
-    def test_with_thinking(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        reasoning_item = MagicMock()
-        reasoning_item.type = "reasoning"
-        summary = MagicMock()
-        summary.text = "Let me think..."
-        reasoning_item.summary = [summary]
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = [reasoning_item]
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            result = asyncio.run(provider.run_agenerate("hello", model="gpt-5.2"))
-
-        assert result["thinking"] == [{"summary": "Let me think..."}]
-
-    def test_async_multi_image_parts_preserve_order(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock(return_value=_make_openai_response())
-        first = Image.new("RGB", (3, 2), color="red")
-        second = Image.new("RGB", (4, 5), color="green")
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            asyncio.run(
-                provider.run_agenerate(
-                    ["prompt", first, second],
-                    model="gpt-5.2",
-                )
-            )
-
-        parts = mock_client.responses.create.call_args.kwargs["input"][0]["content"]
-        assert [part["type"] for part in parts] == [
-            "input_text",
-            "input_image",
-            "input_image",
-        ]
-        assert parts[0]["text"] == "prompt"
-        first_media_type, first_decoded = _decode_openai_image_part(parts[1])
-        second_media_type, second_decoded = _decode_openai_image_part(parts[2])
-        assert first_media_type == "image/png"
-        assert second_media_type == "image/png"
-        assert first_decoded.size == first.size
-        assert second_decoded.size == second.size
-        assert first_decoded.format == "PNG"
-        assert second_decoded.format == "PNG"
-
-    def test_no_schema_format_unchanged(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "Hello"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            asyncio.run(
-                provider.run_agenerate(
-                    "hello",
-                    model="gpt-5.2",
-                    json_output=True,
-                    json_schema=None,
-                )
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"] == {"format": {"type": "json_object"}}
-
-    def test_with_schema_format_shape(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-        schema = {"type": "object"}
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            asyncio.run(
-                provider.run_agenerate("hello", model="gpt-5.2", json_schema=schema)
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"] == {
-            "format": {
-                "type": "json_schema",
-                "name": "response",
-                "schema": schema,
-                "strict": True,
-            }
-        }
-
-    def test_schema_title_becomes_name(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            asyncio.run(
-                provider.run_agenerate(
-                    "hello",
-                    model="gpt-5.2",
-                    json_schema={"title": "MyThing", "type": "object"},
-                )
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"]["format"]["name"] == "MyThing"
-
-    def test_schema_bad_title_falls_back(self):
-        provider = _openai_provider()
-        mock_client = MagicMock()
-        mock_client.responses.create = AsyncMock()
-        mock_response = MagicMock()
-        mock_response.output_text = "{}"
-        mock_response.status = "completed"
-        mock_response.incomplete_details = None
-        mock_response.usage = None
-        mock_response.output = []
-        mock_client.responses.create.return_value = mock_response
-
-        with patch(
-            "solstone.think.providers.openai._get_async_openai_client",
-            return_value=mock_client,
-        ):
-            asyncio.run(
-                provider.run_agenerate(
-                    "hello",
-                    model="gpt-5.2",
-                    json_schema={"title": "bad name with spaces", "type": "object"},
-                )
-            )
-
-        called_kwargs = mock_client.responses.create.call_args.kwargs
-        assert called_kwargs["text"]["format"]["name"] == "response"
diff --git a/tests/test_openhands_generate.py b/tests/test_openhands_generate.py
new file mode 100644
index 000000000..91b00479b
--- /dev/null
+++ b/tests/test_openhands_generate.py
@@ -0,0 +1,249 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from PIL import Image
+
+from solstone.think.providers import openhands
+
+
+def _response(
+    text: str = "hello",
+    *,
+    model: str = "provider-model",
+    finish_reason: str = "stop",
+    reasoning: str | None = None,
+):
+    usage = SimpleNamespace(
+        prompt_tokens=11,
+        completion_tokens=7,
+        cache_read_tokens=3,
+        cache_write_tokens=0,
+        reasoning_tokens=2,
+    )
+    message = SimpleNamespace(
+        content=[SimpleNamespace(text=text)],
+        thinking_blocks=[],
+        reasoning_content=reasoning,
+        responses_reasoning_item=None,
+    )
+    return SimpleNamespace(
+        message=message,
+        metrics=SimpleNamespace(accumulated_token_usage=usage),
+        raw_response={
+            "model": model,
+            "choices": [{"finish_reason": finish_reason}],
+        },
+    )
+
+
+def test_generate_google_uses_openhands_chat_and_normalizes_result(monkeypatch):
+    llm = MagicMock()
+    llm.completion.return_value = _response(reasoning="brief reasoning")
+    monkeypatch.setattr(
+        openhands,
+        "_build_generate_llm",
+        lambda *args, **kwargs: (llm, "gemini-flash-latest"),
+    )
+
+    result = openhands.run_generate(
+        "hello",
+        "gemini-flash-latest",
+        provider="google",
+        thinking_budget=128,
+        json_schema={"title": "Reply", "type": "object"},
+        max_output_tokens=256,
+    )
+
+    llm.completion.assert_called_once()
+    assert not llm.responses.called
+    messages = llm.completion.call_args.args[0]
+    assert messages[0].role == "user"
+    assert messages[0].content[0].text == "hello"
+    kwargs = llm.completion.call_args.kwargs
+    assert kwargs["thinking"] == {"type": "enabled", "budget_tokens": 128}
+    assert kwargs["response_format"]["json_schema"]["name"] == "Reply"
+    assert result == {
+        "text": "hello",
+        "model": "provider-model",
+        "usage": {
+            "input_tokens": 11,
+            "output_tokens": 7,
+            "total_tokens": 18,
+            "cached_tokens": 3,
+            "reasoning_tokens": 2,
+            "model_version": "provider-model",
+        },
+        "finish_reason": "stop",
+        "thinking": [{"summary": "brief reasoning"}],
+    }
+
+
+def test_generate_restores_process_logging_after_openhands_import(monkeypatch):
+    llm = MagicMock()
+    llm.completion.return_value = _response()
+    baseline = object()
+    restored = []
+    monkeypatch.delenv("OPENHANDS_SUPPRESS_BANNER", raising=False)
+    monkeypatch.setattr(openhands, "snapshot_root_logging", lambda: baseline)
+    monkeypatch.setattr(
+        openhands,
+        "apply_http_logging_policy",
+        lambda value: restored.append(value),
+    )
+    monkeypatch.setattr(
+        openhands,
+        "_build_generate_llm",
+        lambda *args, **kwargs: (llm, "gemini-flash-latest"),
+    )
+
+    openhands.run_generate("hello", "gemini-flash-latest", provider="google")
+
+    assert restored == [baseline]
+    assert openhands.os.environ["OPENHANDS_SUPPRESS_BANNER"] == "1"
+
+
+def test_generate_openai_uses_responses_json_schema(monkeypatch):
+    llm = MagicMock()
+    llm.responses.return_value = _response(text='{"ok":true}', model="gpt-5.5")
+    monkeypatch.setattr(
+        openhands,
+        "_build_generate_llm",
+        lambda *args, **kwargs: (llm, "gpt-5.5"),
+    )
+
+    result = openhands.run_generate(
+        "hello",
+        "gpt-5.5-high",
+        provider="openai",
+        json_schema={"type": "object"},
+    )
+
+    llm.responses.assert_called_once()
+    assert not llm.completion.called
+    assert llm.responses.call_args.kwargs["text"]["format"] == {
+        "type": "json_schema",
+        "name": "response",
+        "schema": {"type": "object"},
+        "strict": True,
+    }
+    assert result["text"] == '{"ok":true}'
+
+
+def test_generate_messages_preserve_roles_and_multimodal_content():
+    messages = openhands._generate_messages(
+        [
+            {"role": "model", "content": "earlier"},
+            {"role": "user", "content": ["look", Image.new("RGB", (2, 2))]},
+        ],
+        "system",
+    )
+
+    assert [message.role for message in messages] == ["system", "assistant", "user"]
+    assert messages[2].content[0].text == "look"
+    assert messages[2].content[1].image_urls[0].startswith("data:image/png;base64,")
+
+
+def test_generate_provider_thinking_and_token_budget_mapping(caplog):
+    assert openhands._generate_token_budget("google", 100, 25) == 125
+    assert openhands._generate_token_budget("anthropic", 100, 200) == 1201
+    assert openhands._generate_token_budget("openai", 100, 200) == 100
+    assert openhands._parse_openai_effort("gpt-5.5-xhigh") == ("gpt-5.5", "xhigh")
+    assert openhands._generate_call_kwargs(
+        "google",
+        "gemini-flash-latest",
+        temperature=None,
+        json_output=False,
+        json_schema=None,
+        thinking_budget=0,
+        timeout_s=10,
+        responses_api=False,
+    )["thinking"] == {"type": "disabled", "budget_tokens": 0}
+
+    assert "temperature" not in openhands._generate_call_kwargs(
+        "openai",
+        "gpt-5.5",
+        temperature=0.3,
+        json_output=False,
+        json_schema=None,
+        thinking_budget=None,
+        timeout_s=10,
+        responses_api=True,
+    )
+    assert "temperature" not in openhands._generate_call_kwargs(
+        "anthropic",
+        "claude-sonnet-4-6",
+        temperature=0.3,
+        json_output=False,
+        json_schema=None,
+        thinking_budget=1_024,
+        timeout_s=10,
+        responses_api=False,
+    )
+
+    assert openhands._generate_token_budget("google", 65_000, 1_000) == 65_535
+    assert "Clamping Gemini token budget" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_agenerate_uses_async_openhands_transport(monkeypatch):
+    llm = MagicMock()
+    llm.acompletion = AsyncMock(return_value=_response())
+    monkeypatch.setattr(
+        openhands,
+        "_build_generate_llm",
+        lambda *args, **kwargs: (llm, "claude-sonnet-4-6"),
+    )
+
+    result = await openhands.run_agenerate(
+        "hello",
+        "claude-sonnet-4-6",
+        provider="anthropic",
+        thinking_budget=1_024,
+    )
+
+    llm.acompletion.assert_awaited_once()
+    assert llm.acompletion.call_args.kwargs["thinking"] == {
+        "type": "enabled",
+        "budget_tokens": 1_024,
+    }
+    assert result["text"] == "hello"
+
+
+def test_validation_uses_runtime_probe_and_classifies_results(monkeypatch):
+    monkeypatch.setattr(openhands, "_probe", lambda *args: None)
+    assert openhands.validate_key("google", "key") == {"valid": True}
+    assert openhands.validate_model("openai", "gpt-5.5", "key") == {"valid": True}
+
+    class NotFoundError(RuntimeError):
+        status_code = 404
+
+    def missing(*_args):
+        raise NotFoundError("missing")
+
+    monkeypatch.setattr(openhands, "_probe", missing)
+    assert openhands.validate_key("google", "key") == {
+        "valid": True,
+        "probe_reason_code": "model_not_found",
+    }
+    assert openhands.validate_model("google", "missing", "key")["reason_code"] == (
+        "model_not_found"
+    )
+
+
+def test_async_entry_point_rejects_transport_specific_options():
+    with pytest.raises(TypeError, match="Unsupported generate options: client"):
+        asyncio.run(
+            openhands.run_agenerate(
+                "hello",
+                "gemini-flash-latest",
+                provider="google",
+                client=object(),
+            )
+        )
diff --git a/tests/test_output_hooks.py b/tests/test_output_hooks.py
index b66299d36..2b86a8644 100644
--- a/tests/test_output_hooks.py
+++ b/tests/test_output_hooks.py
@@ -13,6 +13,7 @@ import asyncio
 import importlib
 import io
 import json
+import os
 from pathlib import Path
 
 from solstone.think.talent import load_post_hook, load_pre_hook
@@ -39,10 +40,29 @@ MOCK_RESULT = {
 
 def run_generator_with_config(mod, config: dict, monkeypatch) -> list[dict]:
     """Run generator with NDJSON config and capture output events."""
+    config_path = Path(os.environ["SOLSTONE_JOURNAL"]) / "config" / "journal.json"
+    if not config_path.exists():
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(
+            json.dumps(
+                {
+                    "providers": {
+                        "active": {
+                            "provider": "google",
+                            "model": "gemini-2.0-flash",
+                        }
+                    }
+                }
+            ),
+            encoding="utf-8",
+        )
     # Mock argv to prevent argparse from seeing pytest args
     monkeypatch.setattr("sys.argv", ["sol"])
 
-    stdin_data = json.dumps(config) + "\n"
+    request = {
+        key: value for key, value in config.items() if key not in {"provider", "model"}
+    }
+    stdin_data = json.dumps(request) + "\n"
     monkeypatch.setattr("sys.stdin", io.StringIO(stdin_data))
 
     captured_output = io.StringIO()
diff --git a/tests/test_pdf_worker.py b/tests/test_pdf_worker.py
index 5a951ead7..ed8ff0dda 100644
--- a/tests/test_pdf_worker.py
+++ b/tests/test_pdf_worker.py
@@ -358,7 +358,7 @@ def test_run_pdf_worker_tiny_address_limit_maps_to_engine_failure(tmp_path):
         run_pdf_worker(
             "inspect",
             pdf,
-            env={ENV_RLIMIT_AS_MB: "64"},
+            env={ENV_RLIMIT_AS_MB: "16"},
             timeout_seconds=20,
         )
 
diff --git a/tests/test_provider_models.py b/tests/test_provider_models.py
deleted file mode 100644
index b6e96d2c0..000000000
--- a/tests/test_provider_models.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-from unittest.mock import Mock, patch
-
-import pytest
-
-from solstone.think import providers
-from solstone.think.providers import anthropic, get_provider_models, google, openai
-
-
-def test_get_provider_models_anthropic():
-    model = Mock()
-    model.model_dump.return_value = {"id": "claude-sonnet-4-20250514", "type": "model"}
-
-    client = Mock()
-    client.models.list.return_value = [model]
-
-    with patch(
-        "solstone.think.providers.anthropic._get_anthropic_client", return_value=client
-    ):
-        result = get_provider_models("anthropic")
-
-    assert result == [{"id": "claude-sonnet-4-20250514", "type": "model"}]
-
-
-def test_get_provider_models_openai():
-    model = Mock()
-    model.model_dump.return_value = {"id": "gpt-4o", "object": "model"}
-
-    client = Mock()
-    client.models.list.return_value = [model]
-
-    with patch(
-        "solstone.think.providers.openai._get_openai_client", return_value=client
-    ):
-        result = get_provider_models("openai")
-
-    assert result == [{"id": "gpt-4o", "object": "model"}]
-
-
-def test_get_provider_models_google():
-    model = Mock()
-    model.model_dump.return_value = {
-        "name": "models/gemini-2.0-flash",
-        "display_name": "Gemini 2.0 Flash",
-    }
-
-    client = Mock()
-    client.models.list.return_value = [model]
-
-    with patch(
-        "solstone.think.providers.google.get_or_create_client", return_value=client
-    ):
-        result = get_provider_models("google")
-
-    assert result == [
-        {"name": "models/gemini-2.0-flash", "display_name": "Gemini 2.0 Flash"}
-    ]
-
-
-def test_get_provider_models_unknown():
-    with pytest.raises(ValueError):
-        get_provider_models("bogus")
-
-
-def test_list_models_in_provider_all():
-    assert "list_models" in anthropic.__all__
-    assert "list_models" in openai.__all__
-    assert "list_models" in google.__all__
-    assert "get_provider_models" in providers.__all__
diff --git a/tests/test_provider_state.py b/tests/test_provider_state.py
index c5074f2a5..d77646f72 100644
--- a/tests/test_provider_state.py
+++ b/tests/test_provider_state.py
@@ -825,9 +825,13 @@ def test_local_readiness_byo_unreachable(monkeypatch):
 @pytest.mark.parametrize(
     ("selected_config", "reachable", "expected_issues"),
     [
-        ({"providers": {"generate": {"provider": "local"}}}, True, []),
         (
-            {"providers": {"generate": {"provider": "google"}}},
+            {"providers": {"active": {"provider": "local", "model": "local/test"}}},
+            True,
+            [],
+        ),
+        (
+            {"providers": {"active": {"provider": "google", "model": "gemini-test"}}},
             False,
             ["local_endpoint_unreachable"],
         ),
@@ -855,7 +859,7 @@ def test_local_status_dict_byo(
 
     assert status == {
         "configured": True,
-        "selected": selected_config["providers"]["generate"]["provider"] == "local",
+        "selected": selected_config["providers"]["active"]["provider"] == "local",
         "generate_ready": reachable,
         "cogitate_ready": reachable,
         "cogitate_cli": None,
diff --git a/tests/test_providers.py b/tests/test_providers.py
index 70e381cc4..e744a506b 100644
--- a/tests/test_providers.py
+++ b/tests/test_providers.py
@@ -28,9 +28,9 @@ def test_cogitate_baseline_ready_with_hosted_key(monkeypatch) -> None:
     import litellm  # noqa: F401
     import openhands.sdk  # noqa: F401
 
-    status = build_provider_status(
-        [_provider("anthropic", "ANTHROPIC_API_KEY")], False
-    )["anthropic"]
+    status = build_provider_status([_provider("anthropic", "ANTHROPIC_API_KEY")])[
+        "anthropic"
+    ]
 
     assert status == {
         "provider": "anthropic",
@@ -51,7 +51,7 @@ def test_cloud_provider_status_never_carries_install_gate(
     else:
         monkeypatch.delenv(env_key, raising=False)
 
-    status = build_provider_status([_provider(name, env_key)], False)[name]
+    status = build_provider_status([_provider(name, env_key)])[name]
 
     assert set(status) == {
         "provider",
@@ -102,7 +102,6 @@ def test_inert_upgrade_path_for_stale_bundled_config(
             _provider("anthropic", "ANTHROPIC_API_KEY"),
             _provider("openai", "OPENAI_API_KEY"),
         ],
-        False,
     )
 
     assert status["anthropic"]["cogitate_ready"] is True
diff --git a/tests/test_providers_check.py b/tests/test_providers_check.py
index 564742320..c74d09113 100644
--- a/tests/test_providers_check.py
+++ b/tests/test_providers_check.py
@@ -103,10 +103,7 @@ def test_run_check_targeted_uses_active_routes(tmp_path, monkeypatch):
     _patch_health_journal(monkeypatch, providers_cli, tmp_path)
     monkeypatch.setattr(
         "solstone.think.models.resolve_provider",
-        lambda interface: {
-            "generate": ("google", "gemini-flash-latest"),
-            "cogitate": ("openai", "gpt-5.4-mini"),
-        }[interface],
+        lambda _interface: ("google", "gemini-flash-latest"),
     )
     gen_mock = MagicMock(return_value=("ok", "ok", None))
     monkeypatch.setattr(providers_cli, "_check_generate", gen_mock)
@@ -123,13 +120,13 @@ def test_run_check_targeted_uses_active_routes(tmp_path, monkeypatch):
 
     assert exc_info.value.code == 0
     gen_mock.assert_called_once_with("google", "gemini-flash-latest", 1)
-    cog_inner.assert_called_once_with("openai", "gpt-5.4-mini", 1)
+    cog_inner.assert_called_once_with("google", "gemini-flash-latest", 1)
     payload = json.loads((tmp_path / "health" / "talents.json").read_text())
     assert {
         (row["provider"], row["model"], row["interface"]) for row in payload["results"]
     } == {
         ("google", "gemini-flash-latest", "generate"),
-        ("openai", "gpt-5.4-mini", "cogitate"),
+        ("google", "gemini-flash-latest", "cogitate"),
     }
 
 
diff --git a/tests/test_providers_google.py b/tests/test_providers_google.py
deleted file mode 100644
index 85db4f829..000000000
--- a/tests/test_providers_google.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-import logging
-
-
-def test_build_generate_config_passes_through_at_cap(caplog):
-    """Sum exactly at the inclusive cap (65535) passes through without clamp."""
-    from solstone.think.providers.google import (
-        GEMINI_MAX_OUTPUT_TOKENS,
-        _build_generate_config,
-    )
-
-    with caplog.at_level(logging.WARNING, logger="solstone.think.providers.google"):
-        config = _build_generate_config(
-            temperature=0.3,
-            max_output_tokens=49151,
-            system_instruction=None,
-            json_output=False,
-            thinking_budget=16384,
-        )
-
-    warnings = [
-        record
-        for record in caplog.records
-        if record.name == "solstone.think.providers.google"
-        and record.levelno == logging.WARNING
-    ]
-    assert config.max_output_tokens == GEMINI_MAX_OUTPUT_TOKENS  # 65535
-    assert config.thinking_config.thinking_budget == 16384
-    assert warnings == []
-
-
-def test_build_generate_config_clamps_at_inclusive_cap(caplog):
-    """Vertex rejects max_output_tokens=65536 — clamp to 65535 inclusive.
-
-    Regression for the talent-default case (49152 + 16384 = 65536) that landed
-    as 400 INVALID_ARGUMENT in production before this bound was lowered from
-    65536 to 65535.
-    """
-    from solstone.think.providers.google import (
-        GEMINI_MAX_OUTPUT_TOKENS,
-        _build_generate_config,
-    )
-
-    with caplog.at_level(logging.WARNING, logger="solstone.think.providers.google"):
-        config = _build_generate_config(
-            temperature=0.3,
-            max_output_tokens=49152,
-            system_instruction=None,
-            json_output=False,
-            thinking_budget=16384,
-        )
-
-    warnings = [
-        record
-        for record in caplog.records
-        if record.name == "solstone.think.providers.google"
-        and record.levelno == logging.WARNING
-    ]
-    assert config.max_output_tokens == GEMINI_MAX_OUTPUT_TOKENS  # 65535
-    assert config.thinking_config.thinking_budget == 16383
-    assert len(warnings) == 1
-    assert "max_output_tokens=49152" in warnings[0].message
-    assert "thinking_budget=16384" in warnings[0].message
-    assert "clamped_thinking_budget=16383" in warnings[0].message
-
-
-def test_build_generate_config_clamps_oversized(caplog):
-    """Inputs well over the cap clamp max_output_tokens first, then thinking."""
-    from solstone.think.providers.google import (
-        GEMINI_MAX_OUTPUT_TOKENS,
-        _build_generate_config,
-    )
-
-    with caplog.at_level(logging.WARNING, logger="solstone.think.providers.google"):
-        config = _build_generate_config(
-            temperature=0.3,
-            max_output_tokens=49152,
-            system_instruction=None,
-            json_output=False,
-            thinking_budget=24576,
-        )
-
-    warnings = [
-        record
-        for record in caplog.records
-        if record.name == "solstone.think.providers.google"
-        and record.levelno == logging.WARNING
-    ]
-    assert config.max_output_tokens == GEMINI_MAX_OUTPUT_TOKENS  # 65535
-    # 65535 - 49152 = 16383 left for thinking
-    assert config.thinking_config.thinking_budget == 16383
-    assert len(warnings) == 1
-    assert "max_output_tokens=49152" in warnings[0].message
-    assert "thinking_budget=24576" in warnings[0].message
-    assert "clamped_thinking_budget=16383" in warnings[0].message
diff --git a/tests/test_pulse.py b/tests/test_pulse.py
index ca550913c..e7a807db2 100644
--- a/tests/test_pulse.py
+++ b/tests/test_pulse.py
@@ -24,8 +24,7 @@ def _select_local_provider(journal_path):
         json.dumps(
             {
                 "providers": {
-                    "generate": {"provider": "local"},
-                    "cogitate": {"provider": "local"},
+                    "active": {"provider": "local", "model": "local/qwen3.5-4b"},
                 }
             }
         ),
diff --git a/tests/test_settings_call_parity.py b/tests/test_settings_call_parity.py
index 4762d6cd9..69f71060a 100644
--- a/tests/test_settings_call_parity.py
+++ b/tests/test_settings_call_parity.py
@@ -97,24 +97,12 @@ def _assert_json(result, expected: Any) -> None:
     assert result.stderr == ""
 
 
-def _fake_creds(email: str = "test@test.iam.gserviceaccount.com") -> dict[str, str]:
-    return {
-        "type": "service_account",
-        "project_id": "test-project",
-        "client_email": email,
-        "private_key": "fake-private-key",
-    }
-
-
 def test_show_and_read_verbs_select_http_fields(journal_copy: Path) -> None:
     show = runner.invoke(settings_call.app, ["show"])
     keys = runner.invoke(settings_call.app, ["keys", "show"])
-    providers = runner.invoke(settings_call.app, ["providers", "show"])
-    google = runner.invoke(settings_call.app, ["google-backend", "show"])
     transcribe = runner.invoke(settings_call.app, ["transcribe", "show"])
     identity = runner.invoke(settings_call.app, ["identity", "show"])
     observer = runner.invoke(settings_call.app, ["observer", "show"])
-    vertex = runner.invoke(settings_call.app, ["vertex-credentials", "show"])
 
     assert show.exit_code == 0
     show_payload = json.loads(show.stdout)
@@ -132,15 +120,6 @@ def test_show_and_read_verbs_select_http_fields(journal_copy: Path) -> None:
 
     assert keys.exit_code == 0
     assert json.loads(keys.stdout) == {key: False for key in show_payload["keys"]}
-    for result, command in (
-        (providers, "providers show"),
-        (google, "google-backend show"),
-        (vertex, "vertex-credentials show"),
-    ):
-        assert result.exit_code == 2
-        assert result.stderr == (
-            f"Moved to `sol call thinking {command}` — run that instead.\n"
-        )
     assert transcribe.exit_code == 0
     assert set(json.loads(transcribe.stdout)) == {"backends", "api_keys", "config"}
     assert identity.exit_code == 0
@@ -151,13 +130,9 @@ def test_show_and_read_verbs_select_http_fields(journal_copy: Path) -> None:
 
 def test_settings_config_projects_service_validation_only(journal_copy: Path) -> None:
     config = _read_config(journal_copy)
-    config.setdefault("providers", {})["key_validation"] = {
+    config["service_key_validation"] = {
         "revai": {"valid": True, "timestamp": "2026-01-01T00:00:00+00:00"},
         "plaud": {"valid": False, "error": "bad token"},
-        "google": {"valid": True},
-        "openai": {"valid": True},
-        "anthropic": {"valid": True},
-        "google_vertex": {"valid": True},
     }
     _write_config(journal_copy, config)
 
@@ -181,12 +156,12 @@ def test_keys_set_clear_validate_and_invalid_env(
         "REVAI_ACCESS_TOKEN, PLAUD_ACCESS_TOKEN\n"
     )
 
-    moved = runner.invoke(
+    ai_key = runner.invoke(
         settings_call.app,
         ["keys", "set", "ANTHROPIC_API_KEY", "anthropic-test-key"],
     )
-    assert moved.exit_code == 2
-    assert moved.stderr == ("Moved to `sol call thinking keys …` — run that instead.\n")
+    assert ai_key.exit_code == 1
+    assert ai_key.stderr.startswith("Invalid env var: ANTHROPIC_API_KEY.")
     assert "ANTHROPIC_API_KEY" not in _read_config(journal_copy).get("env", {})
 
     service_set = runner.invoke(
@@ -203,7 +178,7 @@ def test_keys_set_clear_validate_and_invalid_env(
             "timestamp": "2026-04-17T12:00:00+00:00",
         },
     }
-    assert _read_config(journal_copy)["providers"]["key_validation"]["revai"]["valid"]
+    assert _read_config(journal_copy)["service_key_validation"]["revai"]["valid"]
     keys_shown = runner.invoke(settings_call.app, ["keys", "show"])
     assert keys_shown.exit_code == 0
     assert "revai-token" not in keys_shown.stdout
@@ -225,30 +200,7 @@ def test_keys_set_clear_validate_and_invalid_env(
     )
     cached = runner.invoke(settings_call.app, ["keys", "validate", "--cache-result"])
     assert cached.exit_code == 0
-    assert _read_config(journal_copy)["providers"]["key_validation"]["plaud"]["valid"]
-
-
-def test_moved_provider_verbs_exit_two() -> None:
-    commands = [
-        ["providers", "set-generate", "--provider", "openai"],
-        ["providers", "set-cogitate", "--provider", "openai"],
-        [
-            "providers",
-            "set-local-endpoint",
-            "--url",
-            "http://host.test",
-            "--model",
-            "m",
-        ],
-        ["providers", "clear-local-endpoint"],
-        ["google-backend", "set", "vertex"],
-        ["vertex-credentials", "import", "creds.json"],
-        ["vertex-credentials", "clear"],
-    ]
-    for command in commands:
-        result = runner.invoke(settings_call.app, command)
-        assert result.exit_code == 2
-        assert result.stderr.startswith("Moved to `sol call thinking ")
+    assert _read_config(journal_copy)["service_key_validation"]["plaud"]["valid"]
 
 
 def test_transcribe_setters(journal_copy: Path) -> None:
diff --git a/tests/test_setup.py b/tests/test_setup.py
index b600d9727..85ae3a967 100644
--- a/tests/test_setup.py
+++ b/tests/test_setup.py
@@ -292,13 +292,10 @@ def read_journal_config_file(journal: Path) -> dict[str, Any]:
     return json.loads((journal / "config" / "journal.json").read_text(encoding="utf-8"))
 
 
-def provider_lanes(journal: Path) -> tuple[str | None, str | None]:
+def active_provider(journal: Path) -> str | None:
     config = read_journal_config_file(journal)
     providers = config.get("providers", {})
-    return (
-        providers.get("generate", {}).get("provider"),
-        providers.get("cogitate", {}).get("provider"),
-    )
+    return providers.get("active", {}).get("provider")
 
 
 def step_by_name(manifest: dict[str, Any], name: str) -> dict[str, Any]:
@@ -603,7 +600,7 @@ def test_brain_capable_sets_lane_and_triggers_bootstrap(
 
     assert rc == 0
     assert elapsed < 1
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     manifest = read_manifest(journal)
     assert step_by_name(manifest, "brain")["status"] == "ok"
     assert_command(calls, 5, expected_brain_bootstrap_command())
@@ -631,7 +628,7 @@ def test_brain_skip_brain_sets_lane_and_skips(
     rc = setup.main(["--yes", "--journal", str(journal), "--skip-brain"])
 
     assert rc == 0
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     brain_step = step_by_name(read_manifest(journal), "brain")
     assert brain_step["status"] == "skipped"
     assert brain_step["reason"] == "--skip-brain"
@@ -668,7 +665,7 @@ def test_brain_skip_models_derives_skip_brain(
     brain_step = step_by_name(manifest, "brain")
     assert brain_step["status"] == "skipped"
     assert brain_step["reason"] == "--skip-models implies --skip-brain"
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     assert expected_brain_bootstrap_command() not in calls
 
 
@@ -693,7 +690,7 @@ def test_brain_skip_service_sets_lane_and_skips(
     rc = setup.main(["--yes", "--journal", str(journal), "--skip-service"])
 
     assert rc == 0
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     brain_step = step_by_name(read_manifest(journal), "brain")
     assert brain_step["status"] == "skipped"
     assert brain_step["reason"] == "--skip-service"
@@ -723,7 +720,7 @@ def test_brain_blocked_verdict_skips_without_trigger(
     assert rc == 0
     manifest = read_manifest(journal)
     assert manifest["completed_at"] is not None
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     brain_step = step_by_name(manifest, "brain")
     assert brain_step["status"] == "skipped"
     assert brain_step["reason"] == "local provider unavailable on this host"
@@ -782,10 +779,7 @@ def test_brain_preserves_existing_provider_lane(
     config_path = journal / "config" / "journal.json"
     config_path.parent.mkdir(parents=True)
     original_config = {
-        "providers": {
-            "generate": {"provider": "anthropic"},
-            "cogitate": {"provider": "anthropic", "tier": 2},
-        }
+        "providers": {"active": {"provider": "anthropic", "model": "claude-sonnet-5"}}
     }
     config_path.write_text(json.dumps(original_config), encoding="utf-8")
     calls = patch_subprocess(monkeypatch)
@@ -805,8 +799,8 @@ def test_brain_preserves_existing_provider_lane(
     "original_config",
     [
         {"providers": "anthropic"},
-        {"providers": {"generate": "anthropic"}},
-        {"providers": {"cogitate": ["local"]}},
+        {"providers": {"active": "anthropic"}},
+        {"providers": {"active": ["local"]}},
     ],
 )
 def test_brain_skips_on_malformed_provider_config(
@@ -901,14 +895,14 @@ def test_brain_rerun_after_defer_triggers_bootstrap(
     first_brain = step_by_name(first_manifest, "brain")
     assert first_brain["status"] == "skipped"
     assert first_brain["reason"] == "--skip-brain"
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     assert expected_brain_bootstrap_command() not in first_calls
 
     second_calls = patch_subprocess(monkeypatch)
     second_rc = setup.main(["--yes", "--journal", str(journal)])
 
     assert second_rc == 0
-    assert provider_lanes(journal) == ("local", "local")
+    assert active_provider(journal) == "local"
     second_brain = step_by_name(read_manifest(journal), "brain")
     assert second_brain["status"] == "ok"
     assert expected_brain_bootstrap_command() in second_calls
diff --git a/tests/test_steward.py b/tests/test_steward.py
index 68d5589ad..5cebb048b 100644
--- a/tests/test_steward.py
+++ b/tests/test_steward.py
@@ -48,8 +48,7 @@ def _select_local_provider(journal: Path) -> None:
         json.dumps(
             {
                 "providers": {
-                    "generate": {"provider": "local"},
-                    "cogitate": {"provider": "local"},
+                    "active": {"provider": "local", "model": "local/qwen3.5-4b"},
                 }
             }
         ),
diff --git a/tests/test_talents_process.py b/tests/test_talents_process.py
index 1fa13d889..4fddb6efd 100644
--- a/tests/test_talents_process.py
+++ b/tests/test_talents_process.py
@@ -19,6 +19,13 @@ import pytest
 def test_talent_main_sigterm_exits_without_cancelled_traceback(tmp_path):
     journal = tmp_path / "journal"
     journal.mkdir()
+    (journal / "config").mkdir()
+    (journal / "config" / "journal.json").write_text(
+        json.dumps(
+            {"providers": {"active": {"provider": "test", "model": "test-model"}}}
+        ),
+        encoding="utf-8",
+    )
 
     talent_dir = tmp_path / "talent"
     talent_dir.mkdir()
@@ -82,8 +89,6 @@ def test_talent_main_sigterm_exits_without_cancelled_traceback(tmp_path):
     request = {
         "name": "test_cogitate",
         "prompt": "hello",
-        "provider": "test",
-        "model": "test-model",
     }
     assert proc.stdin is not None
     proc.stdin.write(json.dumps(request).encode("utf-8") + b"\n")
diff --git a/tests/test_think_activity.py b/tests/test_think_activity.py
index 35acb7168..97ad4fd51 100644
--- a/tests/test_think_activity.py
+++ b/tests/test_think_activity.py
@@ -1616,6 +1616,21 @@ def test_prepare_config_substitutes_facet_and_activity_md_dir_for_daily_cogitate
     )
 
     monkeypatch.setenv("GOOGLE_API_KEY", "x")
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    (config_dir / "journal.json").write_text(
+        json.dumps(
+            {
+                "providers": {
+                    "active": {
+                        "provider": "google",
+                        "model": "gemini-flash-latest",
+                    }
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
 
     config = mod.prepare_config(
         {
diff --git a/tests/test_think_segment.py b/tests/test_think_segment.py
index 2bc5b1bdd..9631cc3f8 100644
--- a/tests/test_think_segment.py
+++ b/tests/test_think_segment.py
@@ -2457,7 +2457,6 @@ class TestDispatchCortexRequest:
         result = cortex_client.cortex_request(
             prompt="hi",
             name="test",
-            provider="local",
             use_id="1713629000008",
         )
 
diff --git a/tests/test_think_utils.py b/tests/test_think_utils.py
index 19e276788..9186d3273 100644
--- a/tests/test_think_utils.py
+++ b/tests/test_think_utils.py
@@ -787,16 +787,6 @@ class TestSetupCliConfigEnv:
 
         assert os.environ.get("MY_TOOL_TOKEN") == "from_shell"
 
-    def test_vertex_adc_vars_survive_managed_key_strip(self, monkeypatch, cli_env):
-        """Test that Vertex/ADC env vars are not managed provider keys."""
-        monkeypatch.setenv("GOOGLE_GENAI_USE_VERTEXAI", "true")
-        monkeypatch.setenv("GOOGLE_APPLICATION_CREDENTIALS", "/some/path")
-
-        cli_env({"identity": {"name": "Test"}, "env": {}})
-
-        assert os.environ.get("GOOGLE_GENAI_USE_VERTEXAI") == "true"
-        assert os.environ.get("GOOGLE_APPLICATION_CREDENTIALS") == "/some/path"
-
     def test_empty_config_value_strips_managed_key(self, monkeypatch, cli_env):
         """Test that empty managed-key config values are treated as absent."""
         monkeypatch.setenv("GOOGLE_API_KEY", "from_shell")
diff --git a/tests/test_thinking_call_parity.py b/tests/test_thinking_call_parity.py
index d635bacbf..a876efc0c 100644
--- a/tests/test_thinking_call_parity.py
+++ b/tests/test_thinking_call_parity.py
@@ -26,7 +26,6 @@ API_ENV_KEYS = (
     "OPENAI_API_KEY",
     "REVAI_ACCESS_TOKEN",
     "PLAUD_ACCESS_TOKEN",
-    "GOOGLE_APPLICATION_CREDENTIALS",
 )
 
 
@@ -40,6 +39,20 @@ class _FixedDateTime:
 def _thinking_client(journal_copy: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     for key in API_ENV_KEYS:
         monkeypatch.delenv(key, raising=False)
+    config = json.loads(
+        (journal_copy / "config" / "journal.json").read_text(encoding="utf-8")
+    )
+    providers = config.setdefault("providers", {})
+    providers.pop("generate", None)
+    providers.pop("cogitate", None)
+    providers["active"] = {
+        "provider": "google",
+        "model": "gemini-custom-flash-test",
+    }
+    (journal_copy / "config" / "journal.json").write_text(
+        json.dumps(config, indent=2) + "\n",
+        encoding="utf-8",
+    )
     client = ConveyClient(
         session=make_test_client(journal_copy),
         base_url="",
@@ -60,12 +73,8 @@ def fake_validators(monkeypatch: pytest.MonkeyPatch) -> None:
     def validate_key(provider: str, api_key: str) -> dict[str, Any]:
         return {"valid": True, "provider": provider, "fingerprint": api_key[-4:]}
 
-    def validate_vertex(path: str) -> dict[str, Any]:
-        return {"valid": True, "path": path}
-
     monkeypatch.setattr(thinking_routes, "datetime", _FixedDateTime)
     monkeypatch.setattr(thinking_routes, "validate_key", validate_key)
-    monkeypatch.setattr(thinking_routes, "validate_vertex_credentials", validate_vertex)
 
 
 def _read_config(journal: Path) -> dict[str, Any]:
@@ -85,15 +94,6 @@ def _assert_json(result, expected: Any) -> None:
     assert result.stderr == ""
 
 
-def _fake_creds(email: str = "test@test.iam.gservice.test") -> dict[str, str]:
-    return {
-        "type": "service_credential",
-        "project_id": "test-project",
-        "client_email": email,
-        "private_key": "fake-private-key",
-    }
-
-
 def _approved_scout_payload(key: str = "google-scout-key") -> dict[str, str]:
     return {
         "state": "approved",
@@ -119,8 +119,6 @@ def _first_json(stdout: str) -> tuple[Any, str]:
 def test_show_verbs_select_http_fields() -> None:
     keys = runner.invoke(thinking_call.app, ["keys", "show"])
     providers = runner.invoke(thinking_call.app, ["providers", "show"])
-    google = runner.invoke(thinking_call.app, ["google-backend", "show"])
-    vertex = runner.invoke(thinking_call.app, ["vertex-credentials", "show"])
 
     assert keys.exit_code == 0
     keys_payload = json.loads(keys.stdout)
@@ -133,8 +131,7 @@ def test_show_verbs_select_http_fields() -> None:
 
     assert providers.exit_code == 0
     providers_payload = json.loads(providers.stdout)
-    assert providers_payload["generate"]["provider"] == "google"
-    assert providers_payload["cogitate"]["provider"] == "openai"
+    assert providers_payload["active"]["provider"] == "google"
     assert providers_payload["local_override"]["enabled"] is False
     assert providers_payload["active_lane"]["lane"] == "byo"
     assert providers_payload["active_lane"]["confidential_attestation"] == {
@@ -144,15 +141,6 @@ def test_show_verbs_select_http_fields() -> None:
         "reason": "confidential_not_configured",
     }
 
-    assert google.exit_code == 0
-    assert json.loads(google.stdout) == {
-        "google_backend": "auto",
-        "vertex_credentials_configured": False,
-        "vertex_credentials_email": "",
-    }
-    assert vertex.exit_code == 0
-    assert json.loads(vertex.stdout)["configured"] is False
-
 
 def test_scout_status_matches_http_payload(journal_copy: Path) -> None:
     _clear_scout(journal_copy)
@@ -346,7 +334,7 @@ def test_providers_show_human_and_set_errors(
     monkeypatch.setattr(
         thinking_routes,
         "build_provider_status",
-        lambda providers, vertex_creds_configured: provider_status,
+        lambda providers: provider_status,
     )
 
     human = runner.invoke(thinking_call.app, ["providers", "show", "--human"])
@@ -361,14 +349,14 @@ def test_providers_show_human_and_set_errors(
 
     success = runner.invoke(
         thinking_call.app,
-        ["providers", "set-generate", "--provider", "openai"],
+        ["providers", "set-active", "--provider", "openai"],
     )
     assert success.exit_code == 0
     assert json.loads(success.stdout)["provider"] == "openai"
 
     bad_provider = runner.invoke(
         thinking_call.app,
-        ["providers", "set-generate", "--provider", "invalid"],
+        ["providers", "set-active", "--provider", "invalid"],
     )
     assert bad_provider.exit_code == 1
     assert bad_provider.stderr == (
@@ -377,7 +365,7 @@ def test_providers_show_human_and_set_errors(
 
     bad_tier = runner.invoke(
         thinking_call.app,
-        ["providers", "set-generate", "--tier", "9"],
+        ["providers", "set-active", "--tier", "9"],
     )
     assert bad_tier.exit_code != 0
     assert "No such option: --tier" in bad_tier.stderr
@@ -467,58 +455,6 @@ def test_local_endpoint_verbs_use_http_shapes(
     }
 
 
-def test_google_backend_and_vertex_credentials(
-    journal_copy: Path,
-    tmp_path: Path,
-    fake_validators: None,
-) -> None:
-    google_bad = runner.invoke(thinking_call.app, ["google-backend", "set", "invalid"])
-    assert google_bad.exit_code == 1
-    assert google_bad.stderr == (
-        "Invalid google_backend: invalid. Must be one of: auto, aistudio, vertex\n"
-    )
-
-    google_set = runner.invoke(thinking_call.app, ["google-backend", "set", "vertex"])
-    _assert_json(google_set, {"google_backend": "vertex"})
-    assert _read_config(journal_copy)["providers"]["google_backend"] == "vertex"
-
-    missing = runner.invoke(
-        thinking_call.app,
-        ["vertex-credentials", "import", str(tmp_path / "missing.json")],
-    )
-    assert missing.exit_code == 1
-    assert missing.stderr == f"Credential file not found: {tmp_path / 'missing.json'}\n"
-
-    creds_path = tmp_path / "creds.json"
-    creds_path.write_text(json.dumps(_fake_creds()), encoding="utf-8")
-    imported = runner.invoke(
-        thinking_call.app,
-        ["vertex-credentials", "import", str(creds_path), "--skip-validation"],
-    )
-    assert imported.exit_code == 0
-    payload = json.loads(imported.stdout)
-    canonical = journal_copy / ".config" / "vertex-credentials.json"
-    assert payload == {
-        "configured": True,
-        "email": "test@test.iam.gservice.test",
-        "path": str(canonical),
-        "validation": None,
-    }
-    assert canonical.exists()
-    assert "fake-private-key" not in imported.stdout
-
-    shown = runner.invoke(thinking_call.app, ["vertex-credentials", "show"])
-    assert shown.exit_code == 0
-    shown_payload = json.loads(shown.stdout)
-    assert shown_payload["configured"] is True
-    assert shown_payload["email"] == "test@test.iam.gservice.test"
-    assert "fake-private-key" not in shown.stdout
-
-    cleared = runner.invoke(thinking_call.app, ["vertex-credentials", "clear"])
-    _assert_json(cleared, {"configured": False})
-    assert not canonical.exists()
-
-
 def test_local_verbs_hit_expected_endpoints(monkeypatch: pytest.MonkeyPatch) -> None:
     calls: list[dict[str, Any]] = []
 
diff --git a/tests/test_thinking_defaults.py b/tests/test_thinking_defaults.py
index fd03cce82..3efd9fc75 100644
--- a/tests/test_thinking_defaults.py
+++ b/tests/test_thinking_defaults.py
@@ -195,7 +195,7 @@ def test_segment_default_byo_endpoint_uses_configured_slot_cap_and_does_not_prob
         monkeypatch,
         tmp_path,
         {
-            "generate": {"provider": "local"},
+            "active": {"provider": "local", "model": "local/qwen3.5-4b"},
             "local": {
                 "endpoint_url": "https://example.invalid/v1",
                 "served_model_id": "some-model",
@@ -219,7 +219,7 @@ def test_segment_default_confidential_endpoint_uses_cpu_formula_and_does_not_pro
         monkeypatch,
         tmp_path,
         {
-            "generate": {"provider": "local"},
+            "active": {"provider": "local", "model": "local/qwen3.5-4b"},
             "local": {
                 "endpoint_url": "https://example.invalid/v1",
                 "served_model_id": "some-model",
@@ -242,7 +242,7 @@ def test_describe_default_byo_endpoint_uses_configured_slot_cap_and_does_not_pro
         monkeypatch,
         tmp_path,
         {
-            "generate": {"provider": "local"},
+            "active": {"provider": "local", "model": "local/qwen3.5-4b"},
             "local": {
                 "endpoint_url": "https://example.invalid/v1",
                 "served_model_id": "some-model",
@@ -264,7 +264,7 @@ def test_describe_default_confidential_endpoint_uses_cpu_formula_and_does_not_pr
         monkeypatch,
         tmp_path,
         {
-            "generate": {"provider": "local"},
+            "active": {"provider": "local", "model": "local/qwen3.5-4b"},
             "local": {
                 "endpoint_url": "https://example.invalid/v1",
                 "served_model_id": "some-model",
diff --git a/tests/test_validate_key.py b/tests/test_validate_key.py
deleted file mode 100644
index 461eb8662..000000000
--- a/tests/test_validate_key.py
+++ /dev/null
@@ -1,639 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-import types
-from unittest.mock import Mock, patch
-
-import pytest
-
-from solstone.convey import create_app
-from solstone.think.providers import anthropic, google, openai, validate_key
-
-
-@pytest.fixture
-def settings_client(journal_copy):
-    app = create_app(str(journal_copy))
-    app.config["TESTING"] = True
-    return app.test_client(), journal_copy
-
-
-@pytest.fixture(autouse=True)
-def reset_google_backend_cache():
-    original = google._detected_backend
-    google._detected_backend = None
-    yield
-    google._detected_backend = original
-
-
-def test_validate_key_anthropic_success():
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    with patch("anthropic.Anthropic", return_value=client) as mock_cls:
-        result = anthropic.validate_key("test-key")
-
-    assert result == {"valid": True}
-    mock_cls.assert_called_once_with(api_key="test-key", timeout=10)
-
-
-def test_validate_key_anthropic_auth_error():
-    client = Mock()
-    client.models.list.side_effect = Exception("invalid x-api-key")
-
-    with patch("anthropic.Anthropic", return_value=client):
-        result = anthropic.validate_key("bad-key")
-
-    assert result["valid"] is False
-    assert "invalid x-api-key" in result["error"]
-
-
-def test_validate_key_openai_success():
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    with patch("openai.OpenAI", return_value=client) as mock_cls:
-        result = openai.validate_key("test-key")
-
-    assert result == {"valid": True}
-    mock_cls.assert_called_once_with(api_key="test-key", timeout=10)
-
-
-def test_validate_key_openai_auth_error():
-    client = Mock()
-    client.models.list.side_effect = Exception("Incorrect API key")
-
-    with patch("openai.OpenAI", return_value=client):
-        result = openai.validate_key("bad-key")
-
-    assert result["valid"] is False
-    assert "Incorrect API key" in result["error"]
-
-
-def test_validate_key_google_success():
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    with (
-        patch("google.genai.Client", return_value=client) as mock_cls,
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_key("test-key")
-
-    assert result == {"valid": True, "backend": "aistudio"}
-    mock_cls.assert_called_once()
-    assert mock_cls.call_args.kwargs["api_key"] == "test-key"
-
-
-def test_validate_key_google_auth_error():
-    client = Mock()
-    client.models.list.side_effect = Exception("API key not valid")
-
-    with (
-        patch("google.genai.Client", return_value=client),
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_key("bad-key")
-
-    assert result["valid"] is False
-    assert "API key not valid" in result["error"]
-
-
-def test_validate_key_google_returns_backend_aistudio():
-    """validate_key returns backend field when successful."""
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    with (
-        patch("google.genai.Client", return_value=client),
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_key("test-key")
-
-    assert result == {"valid": True, "backend": "aistudio"}
-
-
-def test_validate_key_google_returns_backend_vertex():
-    """validate_key returns vertex backend and uses vertexai=True."""
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    with (
-        patch("google.genai.Client", return_value=client) as mock_cls,
-        patch.object(google, "_probe_backend", return_value="vertex"),
-    ):
-        result = google.validate_key("test-key")
-
-    assert result == {"valid": True, "backend": "vertex"}
-    assert mock_cls.call_args.kwargs["vertexai"] is True
-    assert mock_cls.call_args.kwargs["api_key"] == "test-key"
-
-
-def test_validate_vertex_credentials(tmp_path, monkeypatch):
-    """validate_vertex_credentials creates SA-authenticated client."""
-    import json
-
-    sa_file = tmp_path / "sa.json"
-    sa_file.write_text(
-        json.dumps(
-            {
-                "type": "service_account",
-                "project_id": "test-project",
-                "client_email": "test@project.iam.gserviceaccount.com",
-                "private_key": "fake",
-            }
-        )
-    )
-
-    client = Mock()
-    client.models.list.return_value = [Mock()]
-
-    mock_creds = Mock()
-    mock_creds.service_account_email = "test@project.iam.gserviceaccount.com"
-    mock_credentials = Mock()
-    mock_credentials.from_service_account_file.return_value = mock_creds
-
-    oauth2_mod = types.ModuleType("google.oauth2")
-    service_account_mod = types.ModuleType("google.oauth2.service_account")
-    service_account_mod.Credentials = mock_credentials
-    oauth2_mod.service_account = service_account_mod
-    google_mod = sys.modules["google"]
-    google_mod.oauth2 = oauth2_mod
-    monkeypatch.setitem(sys.modules, "google.oauth2", oauth2_mod)
-    monkeypatch.setitem(
-        sys.modules, "google.oauth2.service_account", service_account_mod
-    )
-
-    with (
-        patch("google.genai.Client", return_value=client) as mock_cls,
-    ):
-        result = google.validate_vertex_credentials(str(sa_file))
-
-    assert result == {
-        "valid": True,
-        "email": "test@project.iam.gserviceaccount.com",
-    }
-    assert mock_cls.call_args.kwargs["vertexai"] is True
-    assert mock_cls.call_args.kwargs["credentials"] is mock_creds
-    assert mock_cls.call_args.kwargs["project"] == "test-project"
-    assert "api_key" not in mock_cls.call_args.kwargs
-
-
-def test_probe_backend_aistudio():
-    """HTTP 200 from AI Studio endpoint -> aistudio."""
-    mock_resp = Mock()
-    mock_resp.status_code = 200
-    with patch("httpx.get", return_value=mock_resp):
-        result = google._probe_backend("test-key")
-    assert result == "aistudio"
-
-
-def test_probe_backend_vertex():
-    """Non-200 from AI Studio endpoint -> vertex."""
-    mock_resp = Mock()
-    mock_resp.status_code = 403
-    with patch("httpx.get", return_value=mock_resp):
-        result = google._probe_backend("test-key")
-    assert result == "vertex"
-
-
-def test_probe_backend_error_defaults_aistudio():
-    """Network error defaults to aistudio."""
-    with patch("httpx.get", side_effect=Exception("timeout")):
-        result = google._probe_backend("test-key")
-    assert result == "aistudio"
-
-
-def test_detect_backend_caches():
-    """Second call returns cached result without probing."""
-    import solstone.think.providers.google as gmod
-
-    original = gmod._detected_backend
-    try:
-        gmod._detected_backend = None
-        mock_resp = Mock()
-        mock_resp.status_code = 403
-        with patch("httpx.get", return_value=mock_resp) as mock_get:
-            r1 = gmod._detect_backend("key")
-            r2 = gmod._detect_backend("key")
-        assert r1 == "vertex"
-        assert r2 == "vertex"
-        assert mock_get.call_count == 1
-    finally:
-        gmod._detected_backend = original
-
-
-def test_get_effective_backend_config_override():
-    """Config override skips detection."""
-    import solstone.think.providers.google as gmod
-
-    original = gmod._detected_backend
-    try:
-        gmod._detected_backend = None
-        config = {"providers": {"google_backend": "vertex"}}
-        with patch("solstone.think.utils.get_config", return_value=config):
-            result = gmod._get_effective_backend("key")
-        assert result == "vertex"
-        assert gmod._detected_backend is None
-    finally:
-        gmod._detected_backend = original
-
-
-def test_validate_key_dispatcher_success():
-    with patch(
-        "solstone.think.providers.google.validate_key", return_value={"valid": True}
-    ):
-        result = validate_key("google", "test-key")
-
-    assert result == {"valid": True}
-
-
-def test_validate_key_dispatcher_unknown_provider():
-    with pytest.raises(ValueError, match="Unknown provider") as exc_info:
-        validate_key("bogus", "test-key")
-
-    assert (
-        str(exc_info.value)
-        == "Unknown provider: 'bogus'. Valid providers: anthropic, google, local, openai"
-    )
-
-
-def test_validate_key_timeout():
-    """Validate that timeout exceptions are caught and reported."""
-    client = Mock()
-    client.models.list.side_effect = TimeoutError("Connection timed out")
-
-    with patch("openai.OpenAI", return_value=client):
-        result = openai.validate_key("test-key")
-
-    assert result["valid"] is False
-    assert "timed out" in result["error"]
-
-
-def test_thinking_keys_saves_key_validation(settings_client):
-    client, journal = settings_client
-
-    with patch(
-        "solstone.apps.thinking.routes.validate_key",
-        return_value={"valid": False, "error": "bad key"},
-    ):
-        response = client.put(
-            "/app/thinking/api/keys",
-            json={"env_var": "GOOGLE_API_KEY", "value": "bad-key"},
-        )
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["success"] is True
-    assert payload["key_validation"]["google"]["valid"] is False
-    assert payload["key_validation"]["google"]["error"] == "bad key"
-    assert "timestamp" in payload["key_validation"]["google"]
-
-    config = json.loads((journal / "config" / "journal.json").read_text())
-    assert config["providers"]["key_validation"]["google"]["valid"] is False
-
-
-@pytest.mark.parametrize(
-    ("reason_code", "error"),
-    [
-        ("provider_key_invalid", "invalid credentials"),
-        ("chat_timeout", "provider timed out"),
-        ("network_unreachable", "network down"),
-    ],
-)
-def test_thinking_keys_surfaces_distinct_validation_failures(
-    settings_client, reason_code, error
-):
-    client, _journal = settings_client
-
-    with patch(
-        "solstone.apps.thinking.routes.validate_key",
-        return_value={"valid": False, "error": error, "reason_code": reason_code},
-    ):
-        response = client.put(
-            "/app/thinking/api/keys",
-            json={"env_var": "OPENAI_API_KEY", "value": "bad-key"},
-        )
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    validation = payload["key_validation"]["openai"]
-    assert validation["valid"] is False
-    assert validation["reason_code"] == reason_code
-    assert validation["error"] == error
-    assert validation.get("ready") is not True
-
-
-def test_thinking_keys_clears_key_validation(settings_client):
-    client, journal = settings_client
-    config_path = journal / "config" / "journal.json"
-    config = json.loads(config_path.read_text())
-    config.setdefault("env", {})["GOOGLE_API_KEY"] = "existing-key"
-    config["providers"]["key_validation"] = {
-        "google": {"valid": True, "timestamp": "2026-01-01T00:00:00+00:00"}
-    }
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    response = client.put(
-        "/app/thinking/api/keys",
-        json={"env_var": "GOOGLE_API_KEY", "value": ""},
-    )
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["success"] is True
-    assert "google" not in payload["key_validation"]
-
-    saved = json.loads(config_path.read_text())
-    assert "GOOGLE_API_KEY" not in saved["env"]
-    assert "google" not in saved["providers"]["key_validation"]
-
-
-def test_thinking_keys_env_mirrors_os_environ(settings_client, monkeypatch):
-    """The HTTP env-section save path must mirror into os.environ in-process,
-    matching the CLI pattern (apps/thinking/call.py keys_set/keys_clear).
-    Without this, /api/providers reports `configured: false` until restart."""
-    client, _ = settings_client
-    monkeypatch.delenv("GOOGLE_API_KEY", raising=False)
-
-    with patch(
-        "solstone.apps.thinking.routes.validate_key",
-        return_value={"valid": True},
-    ):
-        response = client.put(
-            "/app/thinking/api/keys",
-            json={"env_var": "GOOGLE_API_KEY", "value": "live-key"},
-        )
-
-    assert response.status_code == 200
-    assert os.environ.get("GOOGLE_API_KEY") == "live-key"
-
-    response = client.put(
-        "/app/thinking/api/keys",
-        json={"env_var": "GOOGLE_API_KEY", "value": ""},
-    )
-
-    assert response.status_code == 200
-    assert "GOOGLE_API_KEY" not in os.environ
-
-
-def test_get_providers_includes_key_validation(settings_client):
-    client, journal = settings_client
-    config_path = journal / "config" / "journal.json"
-    config = json.loads(config_path.read_text())
-    config.setdefault("providers", {})["key_validation"] = {
-        "openai": {"valid": True, "timestamp": "2026-01-01T00:00:00+00:00"}
-    }
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    response = client.get("/app/thinking/api/providers")
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["key_validation"]["openai"]["valid"] is True
-
-
-def test_validate_all_keys_endpoint(settings_client):
-    client, journal = settings_client
-    config_path = journal / "config" / "journal.json"
-    config = json.loads(config_path.read_text())
-    config.setdefault("env", {})["GOOGLE_API_KEY"] = "google-key"
-    config["env"]["OPENAI_API_KEY"] = "openai-key"
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    def fake_validate(provider: str, api_key: str) -> dict:
-        return {
-            "valid": provider == "google",
-            "error": "" if provider == "google" else "bad key",
-        }
-
-    with patch("solstone.apps.thinking.routes.validate_key", side_effect=fake_validate):
-        response = client.post("/app/thinking/api/validate-keys")
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["success"] is True
-    assert payload["key_validation"]["google"]["valid"] is True
-    assert payload["key_validation"]["openai"]["valid"] is False
-    assert "timestamp" in payload["key_validation"]["google"]
-
-    saved = json.loads(config_path.read_text())
-    assert set(saved["providers"]["key_validation"]) == {"google", "openai"}
-
-
-def test_thinking_lane_switch_requires_byo_provider(settings_client):
-    client, _journal = settings_client
-
-    response = client.put("/app/thinking/api/providers", json={"lane": "byo"})
-
-    assert response.status_code == 400
-    payload = response.get_json()
-    assert payload["reason_code"] == "invalid_config_value"
-    assert payload["detail"] == (
-        "No BYO provider selected. Must be one of: anthropic, google, local, openai"
-    )
-
-
-def test_thinking_lane_switch_rejects_unsupported_byo_provider(settings_client):
-    client, _journal = settings_client
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"lane": "byo", "provider": "bogus"},
-    )
-
-    assert response.status_code == 400
-    payload = response.get_json()
-    assert payload["reason_code"] == "invalid_config_value"
-    assert payload["detail"] == (
-        "Invalid provider for BYO lane. Must be one of: anthropic, google, local, openai"
-    )
-
-
-def test_providers_google_backend_roundtrip(settings_client):
-    """PUT/GET google_backend."""
-    client, journal = settings_client
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"google_backend": "vertex"},
-    )
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["google_backend"] == "vertex"
-
-    # Verify persisted
-    config = json.loads((journal / "config" / "journal.json").read_text())
-    assert config["providers"]["google_backend"] == "vertex"
-
-    # GET returns the same
-    response = client.get("/app/thinking/api/providers")
-    payload = response.get_json()
-    assert payload["google_backend"] == "vertex"
-
-
-def test_providers_vertex_credentials_roundtrip(settings_client):
-    """PUT/GET vertex_credentials saves file and returns email."""
-    client, journal = settings_client
-
-    sa_json = json.dumps(
-        {
-            "type": "service_account",
-            "project_id": "test-project",
-            "client_email": "test@test-project.iam.gserviceaccount.com",
-            "private_key": "-----BEGIN RSA PRIVATE KEY-----\nfake\n-----END RSA PRIVATE KEY-----\n",
-            "client_id": "123",
-            "token_uri": "https://oauth2.googleapis.com/token",
-        }
-    )
-
-    # Mock validation (don't actually call Google API)
-    with patch(
-        "solstone.apps.thinking.routes.validate_vertex_credentials",
-        return_value={
-            "valid": True,
-            "email": "test@test-project.iam.gserviceaccount.com",
-        },
-    ):
-        response = client.put(
-            "/app/thinking/api/providers",
-            json={"vertex_credentials": sa_json},
-        )
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["vertex_credentials_configured"] is True
-    assert (
-        payload["vertex_credentials_email"]
-        == "test@test-project.iam.gserviceaccount.com"
-    )
-
-    # Verify file saved with correct permissions
-    creds_file = journal / ".config" / "vertex-credentials.json"
-    assert creds_file.exists()
-    assert oct(creds_file.stat().st_mode & 0o777) == "0o600"
-
-    # Verify config stores path
-    config = json.loads((journal / "config" / "journal.json").read_text())
-    assert config["providers"]["vertex_credentials"] == str(creds_file)
-
-    # GET returns status without secrets
-    response = client.get("/app/thinking/api/providers")
-    payload = response.get_json()
-    assert payload["vertex_credentials_configured"] is True
-    assert (
-        payload["vertex_credentials_email"]
-        == "test@test-project.iam.gserviceaccount.com"
-    )
-    assert "private_key" not in json.dumps(payload)
-
-    # Remove credentials
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"vertex_credentials": ""},
-    )
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["vertex_credentials_configured"] is False
-    assert payload["vertex_credentials_email"] == ""
-    assert not creds_file.exists()
-
-
-def test_providers_vertex_credentials_invalid_json(settings_client):
-    """Invalid JSON in vertex_credentials is rejected."""
-    client, _journal = settings_client
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"vertex_credentials": "not json"},
-    )
-    assert response.status_code == 400
-    data = response.get_json()
-    assert data["reason_code"] == "invalid_json_request"
-    assert "Invalid JSON" in data["detail"]
-
-
-def test_providers_vertex_credentials_missing_fields(settings_client):
-    """SA JSON missing required fields is rejected."""
-    client, _journal = settings_client
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"vertex_credentials": json.dumps({"type": "service_account"})},
-    )
-    assert response.status_code == 400
-    data = response.get_json()
-    assert data["reason_code"] == "missing_required_field"
-    assert "Missing required fields" in data["detail"]
-
-
-def test_providers_google_backend_invalid(settings_client):
-    """Invalid google_backend is rejected."""
-    client, _journal = settings_client
-
-    response = client.put(
-        "/app/thinking/api/providers",
-        json={"google_backend": "invalid"},
-    )
-    assert response.status_code == 400
-    data = response.get_json()
-    assert data["reason_code"] == "invalid_config_value"
-    assert "Invalid google_backend" in data["detail"]
-
-
-def test_validate_all_keys_with_vertex_credentials(settings_client):
-    """validate-all-keys validates vertex credentials when configured."""
-    client, journal = settings_client
-    config_path = journal / "config" / "journal.json"
-
-    # Set up vertex backend + credentials
-    config = json.loads(config_path.read_text())
-    config.setdefault("providers", {})["google_backend"] = "vertex"
-    config["providers"]["vertex_credentials"] = str(
-        journal / "config" / "vertex-credentials.json"
-    )
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    with patch(
-        "solstone.apps.thinking.routes.validate_vertex_credentials",
-        return_value={"valid": True, "backend": "vertex"},
-    ) as mock_validate:
-        response = client.post("/app/thinking/api/validate-keys")
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    assert payload["key_validation"]["google_vertex"]["valid"] is True
-    assert payload["key_validation"]["google_vertex"]["backend"] == "vertex"
-    mock_validate.assert_called_once()
-
-
-def test_validate_all_keys_surfaces_vertex_credential_failure(settings_client):
-    client, journal = settings_client
-    config_path = journal / "config" / "journal.json"
-    config = json.loads(config_path.read_text())
-    config.setdefault("providers", {})["google_backend"] = "vertex"
-    config["providers"]["vertex_credentials"] = str(
-        journal / "config" / "vertex-credentials.json"
-    )
-    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
-
-    with patch(
-        "solstone.apps.thinking.routes.validate_vertex_credentials",
-        return_value={
-            "valid": False,
-            "error": "Application Default Credentials failed",
-            "reason_code": "provider_key_invalid",
-        },
-    ):
-        response = client.get("/app/thinking/api/validate-keys")
-
-    assert response.status_code == 200
-    payload = response.get_json()
-    validation = payload["key_validation"]["google_vertex"]
-    assert validation["valid"] is False
-    assert validation["reason_code"] == "provider_key_invalid"
-    assert validation["error"] == "Application Default Credentials failed"
-    assert validation.get("ready") is not True
diff --git a/tests/test_validate_model.py b/tests/test_validate_model.py
deleted file mode 100644
index 280cb51c1..000000000
--- a/tests/test_validate_model.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 sol pbc
-
-from __future__ import annotations
-
-import sys
-import types
-from unittest.mock import Mock, patch
-
-import httpx
-import pytest
-
-from solstone.think.providers import anthropic, google, openai, validate_model
-
-
-@pytest.fixture(autouse=True)
-def reset_google_backend_cache():
-    original = google._detected_backend
-    google._detected_backend = None
-    yield
-    google._detected_backend = original
-
-
-@pytest.fixture(autouse=True)
-def install_google_errors_stub(monkeypatch):
-    errors_mod = types.ModuleType("google.genai.errors")
-
-    class ClientError(Exception):
-        def __init__(self, code: int, response_json: object):
-            self.code = code
-            self.status = "NOT_FOUND" if code == 404 else "UNAUTHENTICATED"
-            super().__init__(f"{code} {self.status}. {response_json}")
-
-    ClientError.__module__ = "google.genai.errors"
-    errors_mod.ClientError = ClientError
-    monkeypatch.setitem(sys.modules, "google.genai.errors", errors_mod)
-    if "google.genai" in sys.modules:
-        monkeypatch.setattr(
-            sys.modules["google.genai"], "errors", errors_mod, raising=False
-        )
-
-
-def _anthropic_error(exc_type: type[BaseException], status_code: int) -> BaseException:
-    import anthropic as anthropic_sdk
-
-    response = httpx.Response(
-        status_code,
-        request=httpx.Request("GET", "https://api.anthropic.com/v1/models/model"),
-    )
-    assert issubclass(exc_type, anthropic_sdk.APIStatusError)
-    return exc_type(
-        "provider error", response=response, body={"error": "provider error"}
-    )
-
-
-def _openai_error(exc_type: type[BaseException], status_code: int) -> BaseException:
-    import openai as openai_sdk
-
-    response = httpx.Response(
-        status_code,
-        request=httpx.Request("GET", "https://api.openai.com/v1/models/model"),
-    )
-    assert issubclass(exc_type, openai_sdk.APIStatusError)
-    return exc_type(
-        "provider error", response=response, body={"error": "provider error"}
-    )
-
-
-def _google_client_error(status_code: int) -> BaseException:
-    from google.genai.errors import ClientError
-
-    status = "NOT_FOUND" if status_code == 404 else "UNAUTHENTICATED"
-    return ClientError(
-        status_code,
-        {"error": {"message": "provider error", "status": status}},
-    )
-
-
-def test_validate_model_anthropic_success():
-    client = Mock()
-
-    with patch("anthropic.Anthropic", return_value=client) as mock_cls:
-        result = anthropic.validate_model("claude-opus-4-8", "test-key")
-
-    assert result == {"valid": True}
-    mock_cls.assert_called_once_with(api_key="test-key", timeout=10)
-    client.models.retrieve.assert_called_once_with("claude-opus-4-8")
-
-
-def test_validate_model_anthropic_auth_error():
-    import anthropic as anthropic_sdk
-
-    client = Mock()
-    client.models.retrieve.side_effect = _anthropic_error(
-        anthropic_sdk.AuthenticationError,
-        401,
-    )
-
-    with patch("anthropic.Anthropic", return_value=client):
-        result = anthropic.validate_model("claude-opus-4-8", "bad-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "provider_key_invalid"
-
-
-def test_validate_model_anthropic_model_not_found():
-    import anthropic as anthropic_sdk
-
-    client = Mock()
-    client.models.retrieve.side_effect = _anthropic_error(
-        anthropic_sdk.NotFoundError,
-        404,
-    )
-
-    with patch("anthropic.Anthropic", return_value=client):
-        result = anthropic.validate_model("missing-model", "test-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "model_not_found"
-
-
-def test_validate_model_openai_success():
-    client = Mock()
-
-    with patch("openai.OpenAI", return_value=client) as mock_cls:
-        result = openai.validate_model("gpt-5.5", "test-key")
-
-    assert result == {"valid": True}
-    mock_cls.assert_called_once_with(api_key="test-key", timeout=10)
-    client.models.retrieve.assert_called_once_with("gpt-5.5")
-
-
-def test_validate_model_openai_auth_error():
-    import openai as openai_sdk
-
-    client = Mock()
-    client.models.retrieve.side_effect = _openai_error(
-        openai_sdk.AuthenticationError,
-        401,
-    )
-
-    with patch("openai.OpenAI", return_value=client):
-        result = openai.validate_model("gpt-5.5", "bad-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "provider_key_invalid"
-
-
-def test_validate_model_openai_model_not_found():
-    import openai as openai_sdk
-
-    client = Mock()
-    client.models.retrieve.side_effect = _openai_error(openai_sdk.NotFoundError, 404)
-
-    with patch("openai.OpenAI", return_value=client):
-        result = openai.validate_model("missing-model", "test-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "model_not_found"
-
-
-def test_validate_model_google_success():
-    client = Mock()
-
-    with (
-        patch("google.genai.Client", return_value=client) as mock_cls,
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_model("gemini-flash-latest", "test-key")
-
-    assert result == {"valid": True}
-    assert mock_cls.call_args.kwargs["api_key"] == "test-key"
-    assert mock_cls.call_args.kwargs["vertexai"] is False
-    assert mock_cls.call_args.kwargs["http_options"].timeout == 10000
-    client.models.get.assert_called_once_with(model="gemini-flash-latest")
-
-
-def test_validate_model_google_auth_error():
-    client = Mock()
-    client.models.get.side_effect = _google_client_error(401)
-
-    with (
-        patch("google.genai.Client", return_value=client),
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_model("gemini-flash-latest", "bad-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "provider_key_invalid"
-
-
-def test_validate_model_google_model_not_found():
-    client = Mock()
-    client.models.get.side_effect = _google_client_error(404)
-
-    with (
-        patch("google.genai.Client", return_value=client),
-        patch.object(google, "_probe_backend", return_value="aistudio"),
-    ):
-        result = google.validate_model("missing-model", "test-key")
-
-    assert result["valid"] is False
-    assert result["reason_code"] == "model_not_found"
-
-
-def test_validate_model_google_vertex_alias_uses_probed_backend():
-    client = Mock()
-
-    with (
-        patch("google.genai.Client", return_value=client) as mock_cls,
-        patch.object(google, "_probe_backend", return_value="vertex"),
-    ):
-        result = google.validate_model("gemini-pro-latest", "test-key")
-
-    assert result == {"valid": True}
-    assert mock_cls.call_args.kwargs["vertexai"] is True
-    client.models.get.assert_called_once_with(model="gemini-3.1-pro-preview")
-
-
-def test_validate_model_google_does_not_mutate_detected_backend():
-    client = Mock()
-    google._detected_backend = None
-
-    with (
-        patch("google.genai.Client", return_value=client),
-        patch.object(google, "_probe_backend", return_value="vertex"),
-    ):
-        result = google.validate_model("gemini-flash-latest", "test-key")
-
-    assert result == {"valid": True}
-    assert google._detected_backend is None
-
-
-def test_resolve_model_for_vertex_still_uses_active_backend():
-    with patch.object(google, "_active_backend", return_value="aistudio"):
-        assert (
-            google._resolve_model_for_vertex("gemini-pro-latest") == "gemini-pro-latest"
-        )
-    with patch.object(google, "_active_backend", return_value="vertex"):
-        assert (
-            google._resolve_model_for_vertex("gemini-pro-latest")
-            == "gemini-3.1-pro-preview"
-        )
-
-
-def test_validate_model_dispatcher_success():
-    with patch(
-        "solstone.think.providers.google.validate_model",
-        return_value={"valid": True},
-    ) as mock_validate:
-        result = validate_model("google", "gemini-pro-latest", "test-key")
-
-    assert result == {"valid": True}
-    mock_validate.assert_called_once_with("gemini-pro-latest", "test-key")
diff --git a/uv.lock b/uv.lock
index 3eb2d6cbd..2985aad3a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -183,25 +183,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/75/f9/f1c10e223c7b56a38109a3f2eb4e7fe9a757ea3ed3a166754fb30f65e466/ansicon-1.89.0-py2.py3-none-any.whl", hash = "sha256:f1def52d17f65c2c9682cf8370c03f541f410c1752d6a14029f97318e4b9dfec", size = 63675, upload-time = "2019-04-29T20:23:53.83Z" },
 ]
 
-[[package]]
-name = "anthropic"
-version = "0.79.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "docstring-parser" },
-    { name = "httpx" },
-    { name = "jiter" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/15/b1/91aea3f8fd180d01d133d931a167a78a3737b3fd39ccef2ae8d6619c24fd/anthropic-0.79.0.tar.gz", hash = "sha256:8707aafb3b1176ed6c13e2b1c9fb3efddce90d17aee5d8b83a86c70dcdcca871", size = 509825, upload-time = "2026-02-07T18:06:18.388Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/b2/cc0b8e874a18d7da50b0fda8c99e4ac123f23bf47b471827c5f6f3e4a767/anthropic-0.79.0-py3-none-any.whl", hash = "sha256:04cbd473b6bbda4ca2e41dd670fe2f829a911530f01697d0a1e37321eb75f3cf", size = 405918, upload-time = "2026-02-07T18:06:20.246Z" },
-]
-
 [[package]]
 name = "anyio"
 version = "4.12.1"
@@ -4316,7 +4297,6 @@ dependencies = [
 
 [package.optional-dependencies]
 journal-host = [
-    { name = "anthropic" },
     { name = "av" },
     { name = "blessed" },
     { name = "flask", extra = ["async"] },
@@ -4395,7 +4375,6 @@ journal-cuda = [
 
 [package.metadata]
 requires-dist = [
-    { name = "anthropic", marker = "extra == 'journal-host'" },
     { name = "argon2-cffi" },
     { name = "av", marker = "extra == 'journal-host'" },
     { name = "blessed", marker = "extra == 'journal-host'", specifier = ">=1.20.0" },