From 3a06864010e04118fa0f6c93e31af0df849239c4 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 17:20:08 +0800
Subject: [PATCH 01/17] feat(providers): add a service-level model-list source

Each endpoint service names the URL that lists the ids it serves, spelled out
rather than derived from a variant's baseUrl and protocol: DeepSeek's
`/anthropic` variant would derive `/anthropic/v1/models` and Vercel's
bare-origin one a root `/models`, and neither route exists. Both Cloudflare
entries serve no list at all, so they stay absent and those accounts remain
freeform-only.
---
 packages/foundation/providers/AGENTS.md       | 26 +++++++++++++---
 .../providers/src/__tests__/resolve.test.ts   | 29 ++++++++++++++++-
 packages/foundation/providers/src/catalog.ts  | 31 +++++++++++++++++++
 packages/foundation/providers/src/index.ts    |  8 ++++-
 4 files changed, 87 insertions(+), 7 deletions(-)

diff --git a/packages/foundation/providers/AGENTS.md b/packages/foundation/providers/AGENTS.md
index 9b32a969..21b772e5 100644
--- a/packages/foundation/providers/AGENTS.md
+++ b/packages/foundation/providers/AGENTS.md
@@ -38,6 +38,15 @@ Pure data plus pure functions: no hooks, no browser APIs, no I/O. Its only depen
     exactly this reason: the client used the raw field once and immediately disagreed with the
     resolver about the same account — showing a pinned endpoint for one that resolves per agent.
     Display, edit-form prefill, and resolution have to answer the question identically.
+- **`models` is service-level and spelled out, never derived.** One secret reaches one model list,
+  and the ids are identical whichever protocol shape an agent resolves to — so the list belongs to
+  the service, not the variant, and one fetch serves every agent bound to the account. The URL is
+  written out because deriving it from a variant's `baseUrl` + protocol is wrong wherever variants
+  sit on different paths: DeepSeek's `/anthropic` variant would give `/anthropic/v1/models` and
+  Vercel's bare-origin one a root `/models`, neither of which exists. `wire` picks the auth header
+  and response shape only. Absent means the service serves no list, and the account is freeform-only
+  — true for both Cloudflare entries, whose `/compat` route has no model-list path (docs + verified
+  live). Anthropic's list defaults to `limit=20`, so the full list must be asked for.
 - **A missing variant is a claim about the vendor, so verify it.** Omitting `openai-responses`
   refuses codex outright, and an unverified assumption that "that endpoint doesn't serve it anyway"
   once shipped exactly that gap for xAI, OpenRouter and Vercel — all three do serve
@@ -72,11 +81,18 @@ known provider" and fall through to current behavior, never fail a session.
 ## Not here yet
 
 Registering a **custom** provider for an endpoint no agent knows — opencode
-`provider.<id>.{npm, models}`, pi `registerProvider` with `models[]` — is unimplemented. pi's
-`models[]` requires `reasoning` / `input` / `cost` / `contextWindow` / `maxTokens`, which no
-`/v1/models` response carries and `contextWindow` feeds pi's compaction math, so the metadata source
-is a real decision. Until it lands, endpoints without a known provider keep the pre-existing
-behavior (baseUrl override on a guessed provider).
+`provider.<id>.{npm, models}`, pi `registerProvider` with `models[]` — is unimplemented. Endpoints
+without a known provider keep the pre-existing behavior (baseUrl override on a guessed provider).
+
+Metadata is **not** the blocker it was once recorded as: both agents accept a bare id and fill the
+rest themselves (checked against opencode's config schema, where every `Model` field is optional in
+v1 and v2, and pi's `modelFromJson`, which defaults `contextWindow` to 128000 and `maxTokens` to
+16384). The reason to still avoid declaring models is the opposite one — **declaring a model the
+agent already knows destroys good metadata.** pi's `applyModelsJson` replaces on id match, so
+redeclaring `deepseek-v4-pro` overwrites its real 1M context window with that 128000 default and
+makes the session compact constantly, silently. If custom registration is ever built, it must
+declare only ids the agent's own catalog lacks, and reach for pi's `modelOverrides` (a field-level
+patch that does not replace) whenever a known model needs one value changed.
 
 **Do not fake the gap by passing a wire hint.** pi's `ProviderConfigInput` accepts `api`, so
 `registerProvider({ baseUrl, api })` typechecks — and the SDK discards it on any call without
diff --git a/packages/foundation/providers/src/__tests__/resolve.test.ts b/packages/foundation/providers/src/__tests__/resolve.test.ts
index 78e4c50b..fae1809b 100644
--- a/packages/foundation/providers/src/__tests__/resolve.test.ts
+++ b/packages/foundation/providers/src/__tests__/resolve.test.ts
@@ -1,7 +1,7 @@
 import type { Account, AgentKind, AgentRuntimes } from '@linkcode/schema';
 import { nullthrow } from 'foxts/guard';
 import { describe, expect, it } from 'vitest';
-import { serviceById } from '../catalog';
+import { endpointServiceById, modelListSource, serviceById } from '../catalog';
 import { detectedLoginSuggestions } from '../detected-logins';
 import { resolveBinding, serviceProtocols } from '../resolve';
 import { fillTemplate, templatePlaceholders } from '../template';
@@ -276,6 +276,33 @@ describe('catalog helpers', () => {
     expect(serviceProtocols(undefined)).toEqual([]);
   });
 
+  it('resolves a model-list source only for services that serve one', () => {
+    // Service root, deliberately not the `/anthropic` variant's path.
+    expect(modelListSource('deepseek')).toEqual({
+      url: 'https://api.deepseek.com/models',
+      wire: 'openai',
+    });
+    expect(modelListSource('anthropic-api')?.wire).toBe('anthropic');
+    // Both Cloudflare routes serve no list, and oauth services have no secret to ask with.
+    expect(modelListSource('cloudflare-gateway')).toBeUndefined();
+    expect(modelListSource('cloudflare-anthropic')).toBeUndefined();
+    expect(modelListSource('claude-sub')).toBeUndefined();
+    expect(modelListSource('custom')).toBeUndefined();
+    expect(modelListSource(undefined)).toBeUndefined();
+  });
+
+  it('keeps the model-list url independent of the variant an agent resolves to', () => {
+    // Deriving from the resolved variant is what this replaced: the anthropic variants of these two
+    // sit on different paths, so appending would ask a route that does not exist.
+    for (const id of ['deepseek', 'vercel-gateway']) {
+      const service = nullthrow(endpointServiceById(id), `${id} missing`);
+      const anthropic = nullthrow(service.variants.anthropic, `${id} anthropic variant missing`);
+      expect(nullthrow(service.models, `${id} model list missing`).url).not.toBe(
+        `${anthropic.baseUrl}/models`,
+      );
+    }
+  });
+
   it('extracts and fills endpoint template placeholders', () => {
     const cloudflare = serviceById('cloudflare-anthropic');
     if (cloudflare?.kind !== 'endpoint') throw new Error('cloudflare descriptor missing');
diff --git a/packages/foundation/providers/src/catalog.ts b/packages/foundation/providers/src/catalog.ts
index b6cdf9bc..5287aed5 100644
--- a/packages/foundation/providers/src/catalog.ts
+++ b/packages/foundation/providers/src/catalog.ts
@@ -23,6 +23,21 @@ export interface ServiceVariant {
   knownProvider?: Partial<Record<AgentKind, string>>;
 }
 
+/**
+ * Where to read the ids this service serves. Service-level, not per variant: one secret reaches one
+ * model list, and the ids are the same whichever protocol shape an agent ends up using.
+ *
+ * The URL is spelled out rather than derived from a variant's `baseUrl` + protocol, because
+ * derivation is wrong for any service whose variants sit on different paths — DeepSeek's
+ * `/anthropic` variant would yield `/anthropic/v1/models`, and Vercel's bare-origin one a root
+ * `/models`. Absent means the service serves no list and the account is freeform-only.
+ */
+export interface ServiceModelList {
+  url: string;
+  /** Decides auth header and response shape only; the chat/responses split is irrelevant here. */
+  wire: 'anthropic' | 'openai';
+}
+
 export type ServiceDescriptor =
   /** Delegates to an agent CLI's own login store — no secret handled by LinkCode. */
   | { id: string; label: string; group: 'subscription'; kind: 'oauth'; agent: AgentKind }
@@ -35,6 +50,7 @@ export type ServiceDescriptor =
       /** How the one secret authenticates. Service-level: every variant accepts the same secret. */
       credentialType: 'api-key' | 'auth-token';
       variants: Partial<Record<AccountProtocol, ServiceVariant>>;
+      models?: ServiceModelList;
       secretPlaceholder?: string;
     }
   /** Free-form endpoint — the full account form. */
@@ -55,6 +71,8 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
         knownProvider: { opencode: 'anthropic', pi: 'anthropic' },
       },
     },
+    // `limit` defaults to 20, so it must be asked for explicitly to get the whole list.
+    models: { url: 'https://api.anthropic.com/v1/models?limit=1000', wire: 'anthropic' },
     secretPlaceholder: 'sk-ant-…',
   },
   {
@@ -72,6 +90,7 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
       // resolve to the Responses adapter, so reaching chat here needs a custom registration.
       'openai-chat': { baseUrl: 'https://api.openai.com/v1' },
     },
+    models: { url: 'https://api.openai.com/v1/models', wire: 'openai' },
     secretPlaceholder: 'sk-…',
   },
   {
@@ -89,6 +108,7 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
       // own `xai` entries are chat-shaped, and opencode/pi prefer those.
       'openai-responses': { baseUrl: 'https://api.x.ai/v1' },
     },
+    models: { url: 'https://api.x.ai/v1/models', wire: 'openai' },
     secretPlaceholder: 'xai-…',
   },
   {
@@ -107,6 +127,8 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
         knownProvider: { opencode: 'deepseek', pi: 'deepseek' },
       },
     },
+    // Service root, not the `/anthropic` variant's path — that one serves no list.
+    models: { url: 'https://api.deepseek.com/models', wire: 'openai' },
     secretPlaceholder: 'sk-…',
   },
   {
@@ -124,6 +146,7 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
       // The "Anthropic skin" is guaranteed only for Claude models.
       anthropic: { baseUrl: 'https://openrouter.ai/api' },
     },
+    models: { url: 'https://openrouter.ai/api/v1/models', wire: 'openai' },
     secretPlaceholder: 'sk-or-v1-…',
   },
   {
@@ -141,6 +164,7 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
       // Anthropic-shaped endpoint; translates server-side, so it also serves non-Anthropic models.
       anthropic: { baseUrl: 'https://ai-gateway.vercel.sh' },
     },
+    models: { url: 'https://ai-gateway.vercel.sh/v1/models', wire: 'openai' },
   },
   {
     id: 'cloudflare-gateway',
@@ -148,6 +172,8 @@ export const SERVICE_CATALOG: ServiceDescriptor[] = [
     group: 'gateway',
     kind: 'endpoint',
     credentialType: 'auth-token',
+    // No `models`: `/compat` has no model-list route at all (docs + verified live), so a Cloudflare
+    // gateway account is freeform-only.
     variants: {
       // `/compat` serves chat completions only — Cloudflare's Responses route is a different path
       // (`/openai/responses`), so there is deliberately no responses variant here.
@@ -185,3 +211,8 @@ export function endpointServiceById(id: string | undefined): EndpointService | u
   const service = serviceById(id);
   return service?.kind === 'endpoint' ? service : undefined;
 }
+
+/** Where to read this service's model ids, or undefined when it serves no list. */
+export function modelListSource(id: string | undefined): ServiceModelList | undefined {
+  return endpointServiceById(id)?.models;
+}
diff --git a/packages/foundation/providers/src/index.ts b/packages/foundation/providers/src/index.ts
index d7aebb17..9af0dbc3 100644
--- a/packages/foundation/providers/src/index.ts
+++ b/packages/foundation/providers/src/index.ts
@@ -2,9 +2,15 @@ export type {
   EndpointService,
   ServiceDescriptor,
   ServiceGroup,
+  ServiceModelList,
   ServiceVariant,
 } from './catalog';
-export { endpointServiceById, SERVICE_CATALOG, serviceById } from './catalog';
+export {
+  endpointServiceById,
+  modelListSource,
+  SERVICE_CATALOG,
+  serviceById,
+} from './catalog';
 export type { DetectedLoginSuggestion } from './detected-logins';
 export { detectedLoginSuggestions } from './detected-logins';
 export type { BindingTier, BindingUnavailableReason, ResolvedBinding } from './resolve';

From 2d5dc3a1088a24552b3909d8e4e8218734244d2b Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 17:54:30 +0800
Subject: [PATCH 02/17] feat(schema,engine): make the account's picked model
 set the only model source

An account now carries the models the user selected (`Account.models`) instead
of one free-text default, and the pick itself lives per agent as
`ProviderConfig.model`. Nothing falls back to the agent's own choice any more,
so a bound agent with no pick refuses to start rather than running on a model
the user never chose; an agent with no account bound keeps resolving its own.

`config.probe-models` now names a service and lets the daemon resolve the list
URL from the catalog, so a saved account is probed by id and its stored secret
never travels back out to the client.

Both wire versions move: removing `Account.model`, renaming `defaultModel`, and
dropping the `null` tier from `StartOptions.model` are breaking. `loadConfig`
carries both old fields over on read, since zod would otherwise strip them and
silently lose every existing user's configured model.

The model inputs are gone from the account forms; the multi-select that replaces
them lands with the picker work.
---
 apps/daemon/src/__tests__/config.test.ts      | 11 ++-
 apps/daemon/src/config.ts                     | 23 ++++-
 packages/client/core/src/client.ts            | 10 +-
 .../client/core/src/client/control-channel.ts | 16 ++--
 packages/client/sdk/src/client.ts             |  9 +-
 packages/client/sdk/src/operations.ts         |  8 +-
 .../__tests__/default-models.test.ts          | 35 ++-----
 .../settings/providers/__tests__/view.test.ts | 16 ++--
 .../src/settings/providers/add-flow.tsx       | 52 +++--------
 .../src/settings/providers/default-models.ts  | 24 ++---
 .../workbench/src/settings/providers/view.ts  |  8 +-
 .../src/surface/use-workbench-sessions.ts     |  4 +-
 .../integration/dev-mock-transport.test.ts    |  4 +-
 .../foundation/schema/src/model/account.ts    | 22 +++--
 .../schema/src/model/agent/input.ts           |  7 +-
 .../schema/src/model/provider-config.ts       |  6 +-
 packages/foundation/schema/src/wire/config.ts | 15 +--
 .../foundation/schema/src/wire/message.ts     |  4 +-
 .../__tests__/engine-agent-catalog.test.ts    |  4 +-
 .../src/__tests__/engine-model-probe.test.ts  | 93 ++++++++++++++++---
 .../engine/src/__tests__/model-probe.test.ts  | 44 ++++++---
 .../src/__tests__/provider-config.test.ts     | 22 +++--
 .../src/__tests__/start-options-mcp.test.ts   | 21 +++++
 packages/host/engine/src/agent/model-probe.ts | 17 ++--
 .../host/engine/src/agent/provider-config.ts  | 10 +-
 .../host/engine/src/agent/request-handler.ts  | 25 ++++-
 .../src/session/start-options-resolver.ts     | 18 +++-
 .../__tests__/new-session-surface.test.tsx    | 10 +-
 .../ui/src/shell/new-session-surface.tsx      |  6 +-
 .../ui/src/shell/providers/account-detail.tsx |  7 +-
 30 files changed, 343 insertions(+), 208 deletions(-)

diff --git a/apps/daemon/src/__tests__/config.test.ts b/apps/daemon/src/__tests__/config.test.ts
index b7ec922d..399b3b69 100644
--- a/apps/daemon/src/__tests__/config.test.ts
+++ b/apps/daemon/src/__tests__/config.test.ts
@@ -76,8 +76,9 @@ describe('loadConfig providers', () => {
 
     const config = loadConfig(vault);
 
+    // `defaultModel` carries over as the persisted pick; without that it would be silently stripped.
     expect(config.providers).toEqual({
-      'claude-code': { enabled: true, defaultModel: 'sonnet' },
+      'claude-code': { enabled: true, model: 'sonnet' },
     });
     expect(errorSpy).toHaveBeenCalled();
   });
@@ -236,6 +237,14 @@ describe('loadConfig accounts', () => {
     expect(errorSpy).toHaveBeenCalled();
   });
 
+  it("carries a pre-selection account's single model over as its picked set", () => {
+    writeAccountsConfig([{ ...validAccount, model: 'deepseek-v4-pro' }]);
+
+    expect(loadConfig(vault).accounts).toEqual([
+      { ...validAccount, models: [{ id: 'deepseek-v4-pro' }] },
+    ]);
+  });
+
   it('drops an account whose stored secret is gone, rather than half-loading it', () => {
     const errorSpy = vi.spyOn(logger, 'warn').mockImplementation(noop);
     // The post-migration on-disk shape: an api-key credential with no key. With an empty vault the
diff --git a/apps/daemon/src/config.ts b/apps/daemon/src/config.ts
index a9387305..690e1cce 100644
--- a/apps/daemon/src/config.ts
+++ b/apps/daemon/src/config.ts
@@ -211,7 +211,7 @@ function parseAccounts(store: SecretStore, raw: unknown): Parsed<Accounts> {
     // secret that is gone fails the schema and lands in the same drop-and-log path as a malformed one.
     const attached = withAccountSecret(store, value);
     migrated ||= attached.migrated;
-    const account = AccountSchema.safeParse(attached.value);
+    const account = AccountSchema.safeParse(withPickedModels(attached.value));
     if (!account.success) {
       logger.warn({ operation: 'config.load' }, 'Dropping invalid account config');
       continue;
@@ -221,6 +221,25 @@ function parseAccounts(store: SecretStore, raw: unknown): Parsed<Accounts> {
   return { value: accounts, migrated };
 }
 
+/** Pre-selection configs stored one free-text model per account; carry it over as the picked set,
+ * or zod strips the unknown key and the user silently loses their model. Idempotent. */
+function withPickedModels(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value;
+  const { model, ...rest } = value as { model?: unknown; models?: unknown };
+  if (typeof model !== 'string' || model === '' || rest.models !== undefined) return rest;
+  return { ...rest, models: [{ id: model }] };
+}
+
+/** Same carry-over for the per-agent default, which is now the persisted pick. */
+function withPickedModel(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value;
+  const { defaultModel, ...rest } = value as { defaultModel?: unknown; model?: unknown };
+  if (typeof defaultModel !== 'string' || defaultModel === '' || rest.model !== undefined) {
+    return rest;
+  }
+  return { ...rest, model: defaultModel };
+}
+
 /**
  * Parse element by element like {@link parseAccounts}: one invalid server is dropped and logged,
  * never blanking the rest.
@@ -270,7 +289,7 @@ function parseProviders(store: SecretStore, raw: unknown): Parsed<ProvidersConfi
     }
     const attached = withProviderSecret(store, kind.data, value);
     migrated ||= attached.migrated;
-    const config = ProviderConfigSchema.safeParse(attached.value);
+    const config = ProviderConfigSchema.safeParse(withPickedModel(attached.value));
     if (!config.success) {
       logger.warn({ agentKind: key, operation: 'config.load' }, 'Dropping invalid provider config');
       continue;
diff --git a/packages/client/core/src/client.ts b/packages/client/core/src/client.ts
index c075411e..adf89e50 100644
--- a/packages/client/core/src/client.ts
+++ b/packages/client/core/src/client.ts
@@ -1,6 +1,5 @@
 import type {
   Account,
-  AccountEndpoint,
   AccountModel,
   AccountSecret,
   Accounts,
@@ -841,9 +840,12 @@ export class LinkCodeClient {
     return this.control.getAccounts();
   }
 
-  /** Model list an endpoint serves, read daemon-side with a not-yet-saved secret. */
-  probeAccountModels(endpoint: AccountEndpoint, secret: AccountSecret): Promise<AccountModel[]> {
-    return this.control.probeAccountModels(endpoint, secret);
+  /** Models a service serves, read daemon-side with an unsaved secret or a saved account's own. */
+  probeAccountModels(
+    service: string,
+    credential: { type: 'inline'; secret: AccountSecret } | { type: 'account'; accountId: string },
+  ): Promise<AccountModel[]> {
+    return this.control.probeAccountModels(service, credential);
   }
 
   /** Masked custom MCP servers (env/header keys only — the daemon never returns values). */
diff --git a/packages/client/core/src/client/control-channel.ts b/packages/client/core/src/client/control-channel.ts
index 03202a44..13276f8c 100644
--- a/packages/client/core/src/client/control-channel.ts
+++ b/packages/client/core/src/client/control-channel.ts
@@ -1,6 +1,5 @@
 import type {
   Account,
-  AccountEndpoint,
   AccountModel,
   AccountSecret,
   Accounts,
@@ -579,14 +578,19 @@ export class ControlChannel {
     }));
   }
 
-  /** Ask the daemon what an endpoint serves, using a not-yet-saved secret: the account forms offer
-   * the answer as the model picker. The daemon must do it — the renderer's CSP blocks the fetch. */
-  probeAccountModels(endpoint: AccountEndpoint, secret: AccountSecret): Promise<AccountModel[]> {
+  /** Ask the daemon which models a service serves, so the account forms can offer a real list to
+   * pick from. The daemon must do it — the renderer's CSP blocks the fetch, and it resolves the list
+   * URL from the service catalog itself. Pass a secret the add form has not saved yet, or the id of
+   * a saved account so its stored secret never leaves the daemon. */
+  probeAccountModels(
+    service: string,
+    credential: { type: 'inline'; secret: AccountSecret } | { type: 'account'; accountId: string },
+  ): Promise<AccountModel[]> {
     return this.sendCorrelated('accountModels', (clientReqId) => ({
       kind: 'config.probe-models',
       clientReqId,
-      endpoint,
-      secret,
+      service,
+      credential,
     }));
   }
 
diff --git a/packages/client/sdk/src/client.ts b/packages/client/sdk/src/client.ts
index b1990617..2f27207c 100644
--- a/packages/client/sdk/src/client.ts
+++ b/packages/client/sdk/src/client.ts
@@ -10,7 +10,6 @@ import type {
 import { LinkCodeClient } from '@linkcode/client-core';
 import type {
   Account,
-  AccountEndpoint,
   AccountModel,
   AccountSecret,
   Accounts,
@@ -291,12 +290,12 @@ export class LinkCodeSdkClient {
     return toResult(this.raw.setAccounts(accounts));
   }
 
-  /** Enumerate what an endpoint serves, using a secret that is not saved yet. */
+  /** Enumerate the models a service serves, with an unsaved secret or a saved account's own. */
   probeAccountModels(
-    endpoint: AccountEndpoint,
-    secret: AccountSecret,
+    service: string,
+    credential: { type: 'inline'; secret: AccountSecret } | { type: 'account'; accountId: string },
   ): RequestResult<AccountModel[]> {
-    return toResult(this.raw.probeAccountModels(endpoint, secret));
+    return toResult(this.raw.probeAccountModels(service, credential));
   }
 
   /** Masked custom MCP servers (data plane) — env/header keys only, never a secret value. */
diff --git a/packages/client/sdk/src/operations.ts b/packages/client/sdk/src/operations.ts
index ed353144..b59c551b 100644
--- a/packages/client/sdk/src/operations.ts
+++ b/packages/client/sdk/src/operations.ts
@@ -7,7 +7,6 @@ import type {
 } from '@linkcode/client-core';
 import type {
   Account,
-  AccountEndpoint,
   AccountModel,
   AccountSecret,
   Accounts,
@@ -278,9 +277,12 @@ export function setAccounts(options: Options<{ accounts: Accounts }>): RequestRe
 }
 
 export function probeAccountModels(
-  options: Options<{ endpoint: AccountEndpoint; secret: AccountSecret }>,
+  options: Options<{
+    service: string;
+    credential: { type: 'inline'; secret: AccountSecret } | { type: 'account'; accountId: string };
+  }>,
 ): RequestResult<AccountModel[]> {
-  return resolveClient(options).probeAccountModels(options.endpoint, options.secret);
+  return resolveClient(options).probeAccountModels(options.service, options.credential);
 }
 
 /** Masked custom MCP servers — env/header keys only, never a secret value. */
diff --git a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
index a8d49fda..88bef1cb 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
@@ -27,46 +27,23 @@ afterEach(() => {
 });
 
 describe('configuredDefaultModels', () => {
-  it('uses an active account model before the provider default and ignores stale bindings', () => {
+  it('reads the per-agent pick and reports nothing for an agent that has none', () => {
     const providers = {
-      codex: {
-        enabled: true,
-        activeAccountId: 'account-1',
-        defaultModel: 'provider-model',
-      },
-      'claude-code': {
-        enabled: true,
-        activeAccountId: 'missing-account',
-        defaultModel: 'claude-provider-model',
-      },
+      codex: { enabled: true, activeAccountId: 'account-1', model: 'gpt-5.6-sol' },
+      // Bound but unpicked: no model to report, so a session start refuses rather than guessing.
+      'claude-code': { enabled: true, activeAccountId: 'account-1' },
     } satisfies ProvidersConfig;
-    const accounts = [
-      {
-        id: 'account-1',
-        label: 'Configured account',
-        credential: { type: 'oauth', agent: 'codex' },
-        model: 'account-model',
-        createdAt: 0,
-      },
-    ] satisfies Accounts;
 
-    expect(configuredDefaultModels(providers, accounts)).toEqual({
-      codex: 'account-model',
-      'claude-code': 'claude-provider-model',
-    });
+    expect(configuredDefaultModels(providers)).toEqual({ codex: 'gpt-5.6-sol' });
   });
 
-  it('keeps defaults unresolved until both configuration sources have loaded', () => {
+  it('keeps the pick unresolved until the provider config has loaded', () => {
     const { result, rerender } = renderHook(() => useConfiguredDefaultModels());
 
     expect(result.current).toBeNull();
 
     providersData = {};
     rerender();
-    expect(result.current).toBeNull();
-
-    accountsData = [];
-    rerender();
     expect(result.current).toEqual({});
   });
 });
diff --git a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
index 058ccb53..2c082c8e 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
@@ -12,7 +12,7 @@ import {
 } from '../view';
 
 const providers: ProvidersConfig = {
-  'claude-code': { enabled: true, activeAccountId: 'acc_a', defaultModel: 'claude-opus-4-8' },
+  'claude-code': { enabled: true, activeAccountId: 'acc_a', model: 'claude-opus-4-8' },
   codex: { enabled: false, activeAccountId: 'acc_b' },
   opencode: { enabled: true },
 };
@@ -29,14 +29,14 @@ describe('binding transforms', () => {
 
   it('unbinds by dropping only activeAccountId', () => {
     const next = withBinding(providers, 'claude-code', undefined);
-    expect(next['claude-code']).toEqual({ enabled: true, defaultModel: 'claude-opus-4-8' });
+    expect(next['claude-code']).toEqual({ enabled: true, model: 'claude-opus-4-8' });
   });
 
   it('sets and clears the default model without touching the binding', () => {
     expect(withModel(providers, 'claude-code', 'claude-sonnet-5')['claude-code']).toEqual({
       enabled: true,
       activeAccountId: 'acc_a',
-      defaultModel: 'claude-sonnet-5',
+      model: 'claude-sonnet-5',
     });
     expect(withModel(providers, 'claude-code', undefined)['claude-code']).toEqual({
       enabled: true,
@@ -46,7 +46,7 @@ describe('binding transforms', () => {
 
   it('clears every binding of a removed account, identity-stable when none matched', () => {
     const next = withoutAccount(providers, 'acc_a');
-    expect(next['claude-code']).toEqual({ enabled: true, defaultModel: 'claude-opus-4-8' });
+    expect(next['claude-code']).toEqual({ enabled: true, model: 'claude-opus-4-8' });
     expect(next.codex).toEqual({ enabled: false, activeAccountId: 'acc_b' });
     expect(withoutAccount(providers, 'acc_missing')).toBe(providers);
   });
@@ -58,7 +58,7 @@ describe('view helpers', () => {
     const snippet = accountConfigSnippet(providers, 'acc_a');
     expect(JSON.parse(snippet)).toEqual({
       providers: {
-        'claude-code': { enabled: true, activeAccountId: 'acc_a', defaultModel: 'claude-opus-4-8' },
+        'claude-code': { enabled: true, activeAccountId: 'acc_a', model: 'claude-opus-4-8' },
       },
     });
   });
@@ -156,7 +156,7 @@ describe('view helpers', () => {
       service: 'openrouter',
       credential: { type: 'api-key', key: 'old-secret' },
       endpoint: { baseUrl: 'https://old.example.com/v1', protocol: 'openai-chat' },
-      model: 'old-model',
+      models: [{ id: 'old-model' }],
       extraEnv: { GATEWAY_MODE: 'strict' },
     };
 
@@ -167,7 +167,6 @@ describe('view helpers', () => {
         secret: 'new-secret',
         baseUrl: 'https://new.example.com/v1',
         protocol: 'anthropic',
-        model: 'new-model',
       }),
     ).toEqual({
       id: 'acc_a',
@@ -176,7 +175,8 @@ describe('view helpers', () => {
       service: 'openrouter',
       credential: { type: 'auth-token', token: 'new-secret' },
       endpoint: { baseUrl: 'https://new.example.com/v1', protocol: 'anthropic' },
-      model: 'new-model',
+      // The picked set survives an edit: this form does not manage it.
+      models: [{ id: 'old-model' }],
       extraEnv: { GATEWAY_MODE: 'strict' },
     });
   });
diff --git a/packages/client/workbench/src/settings/providers/add-flow.tsx b/packages/client/workbench/src/settings/providers/add-flow.tsx
index 88f91860..ce907e0d 100644
--- a/packages/client/workbench/src/settings/providers/add-flow.tsx
+++ b/packages/client/workbench/src/settings/providers/add-flow.tsx
@@ -67,7 +67,6 @@ function catalogAccount(service: EndpointService, draft: CatalogDraft): Account
         ? { type: 'auth-token', token: draft.secret }
         : { type: 'api-key', key: draft.secret },
     ...(!isObjectEmpty(trimmed) && { endpointParams: trimmed }),
-    ...(draft.model.trim() && { model: draft.model.trim() }),
   };
 }
 
@@ -94,13 +93,10 @@ function accountFromCustomDraft(draft: CustomDraft, account?: Account): Account
   const base =
     account === undefined
       ? newAccountBase(draft.label)
-      : (({
-          credential: _credential,
-          endpoint: _endpoint,
-          label: _label,
-          model: _model,
-          ...rest
-        }) => rest)(account);
+      : // `models` is deliberately kept: this form does not manage the picked set.
+        (({ credential: _credential, endpoint: _endpoint, label: _label, ...rest }) => rest)(
+          account,
+        );
   return {
     ...base,
     label: draft.label.trim(),
@@ -110,7 +106,6 @@ function accountFromCustomDraft(draft: CustomDraft, account?: Account): Account
         : { type: 'api-key', key: draft.secret },
     ...(draft.baseUrl.trim() &&
       protocol && { endpoint: { baseUrl: draft.baseUrl.trim(), protocol } }),
-    ...(draft.model.trim() && { model: draft.model.trim() }),
   };
 }
 
@@ -356,7 +351,6 @@ function OauthCreateForm({
 const CatalogDraftSchema = z.object({
   label: z.string().min(1),
   secret: z.string().min(1),
-  model: z.string(),
   placeholders: z.record(z.string(), z.string()),
 });
 type CatalogDraft = z.infer<typeof CatalogDraftSchema>;
@@ -398,7 +392,7 @@ function CatalogAccountForm({
     formState: { isSubmitting },
   } = useForm<CatalogDraft>({
     resolver: zodResolver(catalogDraftSchema(service)),
-    defaultValues: { label: serviceName, secret: '', model: '', placeholders: {} },
+    defaultValues: { label: serviceName, secret: '', placeholders: {} },
   });
 
   const secretLabel =
@@ -419,26 +413,16 @@ function CatalogAccountForm({
           <Input className="w-full" autoComplete="off" {...register(`placeholders.${key}`)} />
         </Field>
       ))}
-      <div className="flex gap-3">
-        <div className="flex-1">
-          <Field>
-            <FieldLabel>{secretLabel}</FieldLabel>
-            <Input
-              type="password"
-              className="w-full"
-              autoComplete="off"
-              placeholder={service.secretPlaceholder}
-              {...register('secret')}
-            />
-          </Field>
-        </div>
-        <div className="flex-1">
-          <Field>
-            <FieldLabel>{t('form.model')}</FieldLabel>
-            <Input className="w-full" autoComplete="off" {...register('model')} />
-          </Field>
-        </div>
-      </div>
+      <Field>
+        <FieldLabel>{secretLabel}</FieldLabel>
+        <Input
+          type="password"
+          className="w-full"
+          autoComplete="off"
+          placeholder={service.secretPlaceholder}
+          {...register('secret')}
+        />
+      </Field>
       <p className="mt-1 truncate font-mono text-muted-foreground text-xs">
         {serviceProtocols(service.id).join(' · ')}
       </p>
@@ -457,7 +441,6 @@ const CustomDraftSchema = z.object({
   secret: z.string().min(1),
   baseUrl: z.string(),
   protocol: z.string(),
-  model: z.string(),
 });
 type CustomDraft = z.infer<typeof CustomDraftSchema>;
 
@@ -495,7 +478,6 @@ function CustomAccountForm({
       // resolve time, so showing it would invite the user to "keep" a value that does nothing.
       baseUrl: (account && pinnedEndpoint(account)?.baseUrl) ?? '',
       protocol: (account && pinnedEndpoint(account)?.protocol) ?? '',
-      model: account?.model ?? '',
     },
   });
 
@@ -556,10 +538,6 @@ function CustomAccountForm({
           </Field>
         </div>
       </div>
-      <Field>
-        <FieldLabel>{t('form.model')}</FieldLabel>
-        <Input className="w-full" autoComplete="off" {...register('model')} />
-      </Field>
       <div className="flex justify-end pt-1">
         <Button type="submit" size="sm" disabled={busy || isSubmitting}>
           {account === undefined ? t('form.submit') : t('form.save')}
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index 78877678..872965c4 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -1,29 +1,25 @@
-import type { Accounts, AgentKind, ProvidersConfig } from '@linkcode/schema';
+import type { AgentKind, ProvidersConfig } from '@linkcode/schema';
 import { AgentKindSchema } from '@linkcode/schema';
-import { getAccounts, getProviderConfig } from '@linkcode/sdk';
+import { getProviderConfig } from '@linkcode/sdk';
 import { useData } from '../../runtime/tayori';
 
-/** Resolve the daemon configuration's effective model per agent using the same precedence as
- * session start: the active account overrides the provider-level default. */
+/** The model each agent currently runs on, as session start resolves it: the agent's persisted pick.
+ * The bound account contributes the set that pick came from, never the pick itself. */
 export function configuredDefaultModels(
   providers: ProvidersConfig | undefined,
-  accounts: Accounts | undefined,
 ): Partial<Record<AgentKind, string>> {
-  const defaults: Partial<Record<AgentKind, string>> = {};
+  const picked: Partial<Record<AgentKind, string>> = {};
   for (const kind of AgentKindSchema.options) {
-    const provider = providers?.[kind];
-    const account = accounts?.find((candidate) => candidate.id === provider?.activeAccountId);
-    const model = account?.model ?? provider?.defaultModel;
-    if (model !== undefined) defaults[kind] = model;
+    const model = providers?.[kind]?.model;
+    if (model !== undefined) picked[kind] = model;
   }
-  return defaults;
+  return picked;
 }
 
 /** Configured defaults for new-session controls. `null` means one of the daemon-owned sources is
  * still unresolved; consumers must not replace that unknown value with a guessed provider model. */
 export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>> | null {
   const { data: providers } = useData(getProviderConfig, {});
-  const { data: accounts } = useData(getAccounts, {});
-  if (providers === undefined || accounts === undefined) return null;
-  return configuredDefaultModels(providers, accounts);
+  if (providers === undefined) return null;
+  return configuredDefaultModels(providers);
 }
diff --git a/packages/client/workbench/src/settings/providers/view.ts b/packages/client/workbench/src/settings/providers/view.ts
index 3467dce9..e36e6da4 100644
--- a/packages/client/workbench/src/settings/providers/view.ts
+++ b/packages/client/workbench/src/settings/providers/view.ts
@@ -138,7 +138,7 @@ export function providerAccountDetailViewModel(
     return {
       kind,
       ...binding,
-      currentModel: providers?.[kind]?.defaultModel ?? '',
+      currentModel: providers?.[kind]?.model ?? '',
     };
   });
   const boundAgents = boundAgentKinds(providers, account.id);
@@ -154,7 +154,7 @@ export function providerAccountDetailViewModel(
     ...(!(account.service === undefined) && { service: account.service }),
     ...(!(serviceLabel === undefined) && { serviceLabel }),
     ...(routing !== undefined && { routing }),
-    ...(!(account.model === undefined) && { accountModel: account.model }),
+    ...(account.models !== undefined && { accountModels: account.models.map(({ id }) => id) }),
     ...(!(boundAgents.length === 0) && {
       configPreview: accountConfigSnippet(providers, account.id),
     }),
@@ -250,10 +250,10 @@ export function withModel(
 ): ProvidersConfig {
   const entry = providers[kind] ?? { enabled: true };
   if (model === undefined) {
-    const { defaultModel: _cleared, ...rest } = entry;
+    const { model: _cleared, ...rest } = entry;
     return { ...providers, [kind]: rest };
   }
-  return { ...providers, [kind]: { ...entry, defaultModel: model } };
+  return { ...providers, [kind]: { ...entry, model } };
 }
 
 /** Drop every binding referencing a removed account; returns the input unchanged when none did. */
diff --git a/packages/client/workbench/src/surface/use-workbench-sessions.ts b/packages/client/workbench/src/surface/use-workbench-sessions.ts
index f36dfbfd..6cbf72e7 100644
--- a/packages/client/workbench/src/surface/use-workbench-sessions.ts
+++ b/packages/client/workbench/src/surface/use-workbench-sessions.ts
@@ -48,7 +48,7 @@ export interface WorkbenchSessions {
   create: (opts: {
     kind: AgentKind;
     cwd: string;
-    model?: string | null;
+    model?: string;
     effort?: EffortLevel;
     approvalPolicyId?: string;
     modeId?: SessionModeId;
@@ -193,7 +193,7 @@ export function useWorkbenchSessions(onError: (err: unknown) => void): Workbench
   async function create(opts: {
     kind: AgentKind;
     cwd: string;
-    model?: string | null;
+    model?: string;
     effort?: EffortLevel;
     approvalPolicyId?: string;
     modeId?: SessionModeId;
diff --git a/packages/client/workbench/tests/integration/dev-mock-transport.test.ts b/packages/client/workbench/tests/integration/dev-mock-transport.test.ts
index 31893341..bce1c99d 100644
--- a/packages/client/workbench/tests/integration/dev-mock-transport.test.ts
+++ b/packages/client/workbench/tests/integration/dev-mock-transport.test.ts
@@ -121,7 +121,7 @@ describe('dev mock transport', () => {
     expect(replyText).toContain('Hello mocked daemon');
 
     const providers = {
-      codex: { enabled: true, defaultModel: 'mock-model' },
+      codex: { enabled: true, model: 'mock-model' },
     } satisfies ProvidersConfig;
     await client.setProviderConfig(providers);
     expect(await client.getProviderConfig()).toEqual(providers);
@@ -147,7 +147,7 @@ describe('dev mock transport', () => {
       { ...boundAccount, label: 'Updated relay' },
     ]);
     expect(await client.getProviderConfig()).toEqual({
-      codex: { enabled: true, defaultModel: 'mock-model', activeAccountId: 'acc_2' },
+      codex: { enabled: true, model: 'mock-model', activeAccountId: 'acc_2' },
     });
 
     client.dispose();
diff --git a/packages/foundation/schema/src/model/account.ts b/packages/foundation/schema/src/model/account.ts
index 0603549f..18eb9eb5 100644
--- a/packages/foundation/schema/src/model/account.ts
+++ b/packages/foundation/schema/src/model/account.ts
@@ -39,6 +39,14 @@ export const AccountEndpointSchema = z.object({
 });
 export type AccountEndpoint = z.infer<typeof AccountEndpointSchema>;
 
+/** A model an account can run on: read from the service's own model list, or typed by the user for
+ * an endpoint that serves no list. `label` is the provider's display name when it ships one. */
+export const AccountModelSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().optional(),
+});
+export type AccountModel = z.infer<typeof AccountModelSchema>;
+
 export const AccountSchema = z.object({
   /** Stable id referenced by `providers[kind].activeAccountId` and `StartOptions.config.accountId`. */
   id: z.string().min(1),
@@ -54,22 +62,16 @@ export const AccountSchema = z.object({
    * gateway ids). The account holds these rather than a resolved URL, because one secret can
    * resolve to a different endpoint per agent. */
   endpointParams: z.record(z.string(), z.string()).optional(),
-  /** Per-account default model (vendor-specific), overriding the provider default when set. */
-  model: z.string().optional(),
+  /** The models the user picked for this account, and the only ones its pickers offer. Fetched from
+   * the service's model list, typed in freehand, or both; an empty or absent set means no session
+   * can start on this account until the user picks one. */
+  models: z.array(AccountModelSchema).optional(),
   /** Extra environment injected into the agent process (escape hatch, e.g. gateway flags). */
   extraEnv: z.record(z.string(), z.string()).optional(),
   createdAt: TimestampSchema,
 });
 export type Account = z.infer<typeof AccountSchema>;
 
-/** A model an endpoint advertises on its own model list, as read by the daemon's probe. `label` is
- * the provider's display name when it ships one; relays usually ship the bare id only. */
-export const AccountModelSchema = z.object({
-  id: z.string().min(1),
-  label: z.string().optional(),
-});
-export type AccountModel = z.infer<typeof AccountModelSchema>;
-
 /** The global account pool, keyed by position; account ids are unique within it. */
 export const AccountsSchema = z.array(AccountSchema);
 export type Accounts = z.infer<typeof AccountsSchema>;
diff --git a/packages/foundation/schema/src/model/agent/input.ts b/packages/foundation/schema/src/model/agent/input.ts
index 1a00b8b9..3701cd2c 100644
--- a/packages/foundation/schema/src/model/agent/input.ts
+++ b/packages/foundation/schema/src/model/agent/input.ts
@@ -64,9 +64,10 @@ export const StartOptionsSchema = z.object({
   cwd: z.string().min(1),
   /** Existing local branch and whether to use the original checkout or a managed worktree. */
   branch: BranchSelectionSchema.optional(),
-  /** Model id override (vendor-specific). Undefined applies the LinkCode-configured default;
-   * null explicitly defers to the agent/provider's own default. */
-  model: z.string().nullable().optional(),
+  /** Model id (vendor-specific). Undefined falls back to the agent's persisted pick
+   * (`ProviderConfig.model`); if that is unset too, the session refuses to start rather than
+   * letting the agent choose for itself. */
+  model: z.string().optional(),
   /** Initial session mode (e.g. plan / accept-edits), if the agent advertises modes. */
   modeId: SessionModeIdSchema.optional(),
   /** Initial reasoning effort, if the selected adapter supports effort. */
diff --git a/packages/foundation/schema/src/model/provider-config.ts b/packages/foundation/schema/src/model/provider-config.ts
index bdc9286f..0f9bc37b 100644
--- a/packages/foundation/schema/src/model/provider-config.ts
+++ b/packages/foundation/schema/src/model/provider-config.ts
@@ -7,8 +7,10 @@ import { AgentKindSchema } from './primitives';
 export const ProviderConfigSchema = z.object({
   /** Whether the agent is offered in the client's agent picker. */
   enabled: z.boolean().default(true),
-  /** Default model used when the client starts a session without specifying one. */
-  defaultModel: z.string().optional(),
+  /** The model this agent currently runs on, picked by the user from the bound account's set and
+   * persisted so it survives across sessions. Not a fallback default: unset means no session can
+   * start, because nothing else resolves a model. */
+  model: z.string().optional(),
   /** Legacy provider API key, superseded by the global account pool (`account.ts`) but kept so
    * pre-account configs still load; the resolver falls back to it when `activeAccountId` is unset. */
   apiKey: z.string().optional(),
diff --git a/packages/foundation/schema/src/wire/config.ts b/packages/foundation/schema/src/wire/config.ts
index eed2644b..00694dac 100644
--- a/packages/foundation/schema/src/wire/config.ts
+++ b/packages/foundation/schema/src/wire/config.ts
@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import {
-  AccountEndpointSchema,
   AccountModelSchema,
   AccountSchema,
   AccountSecretSchema,
@@ -38,14 +37,18 @@ export const configWireVariants = [
     agent: AgentKindSchema,
     account: AccountSchema,
   }),
-  /** Enumerate what an endpoint serves, before the account is saved: the daemon reads the
-   * endpoint's own model list with the given secret. The client cannot do this itself — the
-   * renderer's CSP blocks remote fetches, and only the daemon may hold the secret. */
+  /** Enumerate the ids a service serves. The daemon resolves the list URL from the service catalog
+   * and makes the call itself — the renderer's CSP blocks remote fetches, and the secret belongs on
+   * that side. `inline` carries a secret the add form has not saved yet; `account` names a saved one
+   * so its stored secret never travels back out to the client. */
   z.object({
     kind: z.literal('config.probe-models'),
     clientReqId: WireRequestIdSchema,
-    endpoint: AccountEndpointSchema,
-    secret: AccountSecretSchema,
+    service: z.string().min(1),
+    credential: z.discriminatedUnion('type', [
+      z.object({ type: z.literal('inline'), secret: AccountSecretSchema }),
+      z.object({ type: z.literal('account'), accountId: z.string().min(1) }),
+    ]),
   }),
   z.object({
     kind: z.literal('config.probe-models.result'),
diff --git a/packages/foundation/schema/src/wire/message.ts b/packages/foundation/schema/src/wire/message.ts
index 8445c3c4..759512b5 100644
--- a/packages/foundation/schema/src/wire/message.ts
+++ b/packages/foundation/schema/src/wire/message.ts
@@ -9,11 +9,11 @@ import { WIRE_PAYLOAD_KINDS, WirePayloadSchema } from './payload';
  */
 
 /** Stamped on every frame this build sends; bump on any wire schema change. */
-export const WIRE_PROTOCOL_VERSION = 73 as const;
+export const WIRE_PROTOCOL_VERSION = 74 as const;
 
 /** The oldest `v` this build still accepts. Bump only for a breaking change — a variant or field
  * removed, renamed, or given a new meaning; additive changes leave it alone. */
-export const MIN_COMPATIBLE_WIRE_VERSION = 68 as const;
+export const MIN_COMPATIBLE_WIRE_VERSION = 74 as const;
 
 /** Complete wire message: version + unique id + timestamp + payload. */
 export const WireMessageSchema = z.object({
diff --git a/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts b/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
index 06cd6bfa..d587fdec 100644
--- a/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
+++ b/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
@@ -32,12 +32,12 @@ describe('engine agent catalog', () => {
       label: 'Catalog account',
       credential: { type: 'api-key', key: 'catalog-key' },
       endpoint: { baseUrl: 'https://catalog.example.test', protocol: 'openai-chat' },
-      model: 'provider/model',
+      models: [{ id: 'provider/model' }],
       createdAt: 0,
     };
     providers.update({
       providers: {
-        'claude-code': { enabled: true, activeAccountId: account.id },
+        'claude-code': { enabled: true, activeAccountId: account.id, model: 'provider/model' },
       },
       accounts: [account],
     });
diff --git a/packages/host/engine/src/__tests__/engine-model-probe.test.ts b/packages/host/engine/src/__tests__/engine-model-probe.test.ts
index 35803127..b2de8813 100644
--- a/packages/host/engine/src/__tests__/engine-model-probe.test.ts
+++ b/packages/host/engine/src/__tests__/engine-model-probe.test.ts
@@ -5,6 +5,7 @@ import type { WirePayload } from '@linkcode/schema';
 import { nullthrow } from 'foxts/guard';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { probeEndpointModels, requestModelListAtAddress } from '../agent/model-probe';
+import { InMemoryProviderConfigStore } from '../agent/provider-config';
 import { createSessionHarness } from './fixtures/session-harness';
 
 /** The probe is a real HTTP round-trip, so its reply lands after `inject`'s task settle. */
@@ -34,19 +35,30 @@ function baseUrl(server: Server): string {
   return `http://127.0.0.1:${port}`;
 }
 
-const localModelProbe: typeof probeEndpointModels = (endpoint, secret) =>
-  probeEndpointModels(endpoint, secret, (url, headers) =>
+let relay: Server | undefined;
+
+/** Sends the catalog's own path at the local relay, so the relay records which path the service
+ * descriptor resolved to while the real HTTP round-trip stays under test. */
+const localModelProbe: typeof probeEndpointModels = (source, secret) => {
+  const resolved = new URL(source.url);
+  const local = `${baseUrl(nullthrow(relay, 'relay not started'))}${resolved.pathname}${resolved.search}`;
+  return probeEndpointModels({ ...source, url: local }, secret, (url, headers) =>
     requestModelListAtAddress(url, headers, { address: '127.0.0.1', family: 4 }),
   );
+};
 
-function createHarness() {
-  return createSessionHarness(undefined, undefined, undefined, undefined, undefined, undefined, {
-    modelProbe: localModelProbe,
-  });
+function createHarness(providerStore?: InMemoryProviderConfigStore) {
+  return createSessionHarness(
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    providerStore,
+    { modelProbe: localModelProbe },
+  );
 }
 
-let relay: Server | undefined;
-
 afterEach(async () => {
   const server = relay;
   if (server) {
@@ -62,7 +74,7 @@ describe('config.probe-models', () => {
     const seen: string[] = [];
     relay = await startRelay((url) => {
       seen.push(url);
-      return url === '/v1/models'
+      return url === '/models'
         ? { status: 200, body: JSON.stringify({ data: [{ id: 'gpt-5' }, { id: 'gpt-5-mini' }] }) }
         : { status: 404, body: '{}' };
     });
@@ -72,8 +84,8 @@ describe('config.probe-models', () => {
     await h.inject({
       kind: 'config.probe-models',
       clientReqId: 'probe-1',
-      endpoint: { baseUrl: `${baseUrl(relay)}/v1`, protocol: 'openai-chat' },
-      secret: { type: 'api-key', key: 'sk-test' },
+      service: 'deepseek',
+      credential: { type: 'inline', secret: { type: 'api-key', key: 'sk-test' } },
     });
 
     await expect(replyFor(h.sent, 'probe-1')).resolves.toEqual({
@@ -81,7 +93,8 @@ describe('config.probe-models', () => {
       replyTo: 'probe-1',
       models: [{ id: 'gpt-5' }, { id: 'gpt-5-mini' }],
     });
-    expect(seen).toEqual(['/v1/models']);
+    // The service's own path, not one derived from a variant's baseUrl.
+    expect(seen).toEqual(['/models']);
   });
 
   it("relays the endpoint's own rejection to the client", async () => {
@@ -95,8 +108,8 @@ describe('config.probe-models', () => {
     await h.inject({
       kind: 'config.probe-models',
       clientReqId: 'probe-2',
-      endpoint: { baseUrl: baseUrl(relay), protocol: 'anthropic' },
-      secret: { type: 'api-key', key: 'bad' },
+      service: 'anthropic-api',
+      credential: { type: 'inline', secret: { type: 'api-key', key: 'bad' } },
     });
 
     const failed = await replyFor(h.sent, 'probe-2');
@@ -104,4 +117,56 @@ describe('config.probe-models', () => {
     expect(failed.message).toContain('401');
     expect(failed.message).toContain('invalid api key');
   });
+
+  it('refuses a service that serves no model list', async () => {
+    const h = createHarness();
+    await h.engine.start();
+
+    await h.inject({
+      kind: 'config.probe-models',
+      clientReqId: 'probe-3',
+      service: 'cloudflare-gateway',
+      credential: { type: 'inline', secret: { type: 'auth-token', token: 'cf' } },
+    });
+
+    const failed = await replyFor(h.sent, 'probe-3');
+    if (failed.kind !== 'request.failed') throw new Error('no request.failed for probe-3');
+    expect(failed.message).toContain('serves no model list');
+  });
+
+  it('reads a saved account by id so its secret never travels through the client', async () => {
+    const seen: string[] = [];
+    relay = await startRelay((url) => {
+      seen.push(url);
+      return { status: 200, body: JSON.stringify({ data: [{ id: 'deepseek-v4-pro' }] }) };
+    });
+    const providerStore = new InMemoryProviderConfigStore();
+    providerStore.update({
+      accounts: [
+        {
+          id: 'acc_saved',
+          label: 'Saved',
+          service: 'deepseek',
+          credential: { type: 'api-key', key: 'sk-stored' },
+          createdAt: 0,
+        },
+      ],
+    });
+    const h = createHarness(providerStore);
+    await h.engine.start();
+
+    await h.inject({
+      kind: 'config.probe-models',
+      clientReqId: 'probe-4',
+      service: 'deepseek',
+      credential: { type: 'account', accountId: 'acc_saved' },
+    });
+
+    await expect(replyFor(h.sent, 'probe-4')).resolves.toEqual({
+      kind: 'config.probe-models.result',
+      replyTo: 'probe-4',
+      models: [{ id: 'deepseek-v4-pro' }],
+    });
+    expect(seen).toEqual(['/models']);
+  });
 });
diff --git a/packages/host/engine/src/__tests__/model-probe.test.ts b/packages/host/engine/src/__tests__/model-probe.test.ts
index 5d7ab454..d55b58dc 100644
--- a/packages/host/engine/src/__tests__/model-probe.test.ts
+++ b/packages/host/engine/src/__tests__/model-probe.test.ts
@@ -1,18 +1,27 @@
 import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
+import type { ServiceModelList } from '@linkcode/providers';
 import type { AccountEndpoint } from '@linkcode/schema';
 import { describe, expect, it, vi } from 'vitest';
 import type { ModelListRequest } from '../agent/model-probe';
 import {
   modelListHeaders,
-  modelListUrl,
+  modelListUrlFromEndpoint,
   probeEndpointModels,
   requestModelListAtAddress,
   resolvePublicEndpoint,
 } from '../agent/model-probe';
 
-const anthropic: AccountEndpoint = { baseUrl: 'https://relay.test/', protocol: 'anthropic' };
-const openai: AccountEndpoint = { baseUrl: 'https://relay.test/v1', protocol: 'openai-chat' };
+const anthropicEndpoint: AccountEndpoint = {
+  baseUrl: 'https://relay.test/',
+  protocol: 'anthropic',
+};
+const openaiEndpoint: AccountEndpoint = {
+  baseUrl: 'https://relay.test/v1',
+  protocol: 'openai-chat',
+};
+const anthropic: ServiceModelList = { url: 'https://relay.test/v1/models', wire: 'anthropic' };
+const openai: ServiceModelList = { url: 'https://relay.test/v1/models', wire: 'openai' };
 const REJECTION_PATTERN = /401.*invalid api key/;
 const NOT_A_LIST_PATTERN = /did not answer a model list/;
 const HTTP_PATTERN = /HTTP/;
@@ -25,31 +34,42 @@ function jsonResponse(body: unknown): Awaited<ReturnType<ModelListRequest>> {
   return { status: 200, statusText: 'OK', body: JSON.stringify(body) };
 }
 
-describe('endpoint model list addressing', () => {
+describe('custom endpoint model list addressing', () => {
   it('appends /v1 for Anthropic-shaped base URLs and only /models for OpenAI-shaped ones', () => {
-    expect(modelListUrl(anthropic)).toBe('https://relay.test/v1/models?limit=1000');
-    expect(modelListUrl(openai)).toBe('https://relay.test/v1/models');
+    // Only custom accounts reach this: catalog services carry an explicit URL instead.
+    expect(modelListUrlFromEndpoint(anthropicEndpoint)).toBe(
+      'https://relay.test/v1/models?limit=1000',
+    );
+    expect(modelListUrlFromEndpoint(openaiEndpoint)).toBe('https://relay.test/v1/models');
   });
 
   it('rejects URL components that string-appending could misaddress', () => {
     expect(() =>
-      modelListUrl({ baseUrl: 'https://relay.test/v1?tenant=x', protocol: 'openai-chat' }),
+      modelListUrlFromEndpoint({
+        baseUrl: 'https://relay.test/v1?tenant=x',
+        protocol: 'openai-chat',
+      }),
     ).toThrow(INVALID_ENDPOINT_PATTERN);
     expect(() =>
-      modelListUrl({ baseUrl: 'https://user:secret@relay.test/v1', protocol: 'openai-chat' }),
+      modelListUrlFromEndpoint({
+        baseUrl: 'https://user:secret@relay.test/v1',
+        protocol: 'openai-chat',
+      }),
     ).toThrow(INVALID_ENDPOINT_PATTERN);
   });
 
-  it('authenticates per protocol and credential shape', () => {
-    expect(modelListHeaders(anthropic, { type: 'api-key', key: 'k' })).toMatchObject({
+  it('authenticates per wire and credential shape', () => {
+    expect(modelListHeaders('anthropic', { type: 'api-key', key: 'k' })).toMatchObject({
       'x-api-key': 'k',
       'anthropic-version': '2023-06-01',
     });
-    expect(modelListHeaders(anthropic, { type: 'auth-token', token: 't' })).toMatchObject({
+    expect(modelListHeaders('anthropic', { type: 'auth-token', token: 't' })).toMatchObject({
       authorization: 'Bearer t',
       'anthropic-version': '2023-06-01',
     });
-    expect(modelListHeaders(openai, { type: 'api-key', key: 'k' }).authorization).toBe('Bearer k');
+    expect(modelListHeaders('openai', { type: 'api-key', key: 'k' }).authorization).toBe(
+      'Bearer k',
+    );
   });
 });
 
diff --git a/packages/host/engine/src/__tests__/provider-config.test.ts b/packages/host/engine/src/__tests__/provider-config.test.ts
index 363672d0..a4d8ef4c 100644
--- a/packages/host/engine/src/__tests__/provider-config.test.ts
+++ b/packages/host/engine/src/__tests__/provider-config.test.ts
@@ -10,13 +10,12 @@ describe('applyProviderDefaults', () => {
     expect(applyProviderDefaults(baseOpts, providers).options).toBe(baseOpts);
   });
 
-  it('fills the default model only when the client did not specify one', () => {
-    const providers: ProvidersConfig = { codex: { enabled: true, defaultModel: 'o4-mini' } };
+  it('fills the persisted pick only when the client did not specify one', () => {
+    const providers: ProvidersConfig = { codex: { enabled: true, model: 'o4-mini' } };
     expect(applyProviderDefaults(baseOpts, providers).options.model).toBe('o4-mini');
     expect(applyProviderDefaults({ ...baseOpts, model: 'gpt-4o' }, providers).options.model).toBe(
       'gpt-4o',
     );
-    expect(applyProviderDefaults({ ...baseOpts, model: null }, providers).options.model).toBeNull();
   });
 
   it('injects the api key into config, preserving existing config keys', () => {
@@ -27,7 +26,7 @@ describe('applyProviderDefaults', () => {
 
   it('does not mutate the input options', () => {
     const providers: ProvidersConfig = {
-      codex: { enabled: true, defaultModel: 'o4-mini', apiKey: 'sk' },
+      codex: { enabled: true, model: 'o4-mini', apiKey: 'sk' },
     };
     const opts: StartOptions = { kind: 'codex', cwd: '/repo' };
     applyProviderDefaults(opts, providers);
@@ -120,13 +119,16 @@ describe('applyProviderDefaults account pool', () => {
     expect(forOpencode.options.config).toMatchObject({ knownProvider: 'openai' });
   });
 
-  it('prefers the account model over the provider default model', () => {
+  it('takes the model from the agent, never from the bound account', () => {
+    // The account holds the set the pick came from; only `providers[kind].model` names the pick.
     const providers: ProvidersConfig = {
-      codex: { enabled: true, defaultModel: 'o4-mini', activeAccountId: 'acc_1' },
+      codex: { enabled: true, model: 'o4-mini', activeAccountId: 'acc_1' },
     };
     expect(
-      applyProviderDefaults(baseOpts, providers, [{ ...account, model: 'gpt-5' }]).options.model,
-    ).toBe('gpt-5');
+      applyProviderDefaults(baseOpts, providers, [
+        { ...account, models: [{ id: 'gpt-5' }, { id: 'o4-mini' }] },
+      ]).options.model,
+    ).toBe('o4-mini');
   });
 
   it('falls back to the legacy apiKey when the bound account id is stale', () => {
@@ -160,7 +162,7 @@ describe('accountBinding', () => {
 
   it('preserves unrelated providers and accounts while binding the selected agent', () => {
     const providers: ProvidersConfig = {
-      codex: { enabled: true, defaultModel: 'gpt-5' },
+      codex: { enabled: true, model: 'gpt-5' },
       opencode: { enabled: false, activeAccountId: 'acc_2' },
     };
     const other: Account = {
@@ -172,7 +174,7 @@ describe('accountBinding', () => {
 
     expect(accountBinding(providers, [other], 'codex', account)).toEqual({
       providers: {
-        codex: { enabled: true, defaultModel: 'gpt-5', activeAccountId: 'acc_1' },
+        codex: { enabled: true, model: 'gpt-5', activeAccountId: 'acc_1' },
         opencode: { enabled: false, activeAccountId: 'acc_2' },
       },
       accounts: [other, account],
diff --git a/packages/host/engine/src/__tests__/start-options-mcp.test.ts b/packages/host/engine/src/__tests__/start-options-mcp.test.ts
index 74e7114f..e4639024 100644
--- a/packages/host/engine/src/__tests__/start-options-mcp.test.ts
+++ b/packages/host/engine/src/__tests__/start-options-mcp.test.ts
@@ -160,6 +160,11 @@ describe('account binding at session start', () => {
   function storeWith(account: Account, agent: AgentKind): InMemoryProviderConfigStore {
     const store = new InMemoryProviderConfigStore();
     store.createAndBindAccount(agent, account);
+    // A bound agent without a picked model refuses to start; these cases are about endpoints.
+    const providers = store.get();
+    store.update({
+      providers: { ...providers, [agent]: { ...providers[agent], model: 'picked-model' } },
+    });
     return store;
   }
 
@@ -171,6 +176,22 @@ describe('account binding at session start', () => {
     ...overrides,
   });
 
+  it('refuses a bound agent with no picked model, but lets an unbound one resolve its own', async () => {
+    const store = new InMemoryProviderConfigStore();
+    store.createAndBindAccount('codex', account({ service: 'openai-api' }));
+    const bound = new SessionStartOptionsResolver(store, undefined);
+    await expect(
+      Effect.runPromise(bound.resolve({ kind: 'codex', cwd: '/repo' }, SESSION)),
+    ).rejects.toThrow('No model selected for codex');
+
+    // Nothing bound: the agent still runs on whatever it resolves for itself.
+    const unbound = new SessionStartOptionsResolver(new InMemoryProviderConfigStore(), undefined);
+    const { options } = await Effect.runPromise(
+      unbound.resolve({ kind: 'codex', cwd: '/repo' }, SESSION),
+    );
+    expect(options.model).toBeUndefined();
+  });
+
   it('refuses the session when the bound account has no endpoint the agent speaks', async () => {
     const anthropicOnly = account({
       endpoint: { baseUrl: 'https://api.anthropic.com', protocol: 'anthropic' },
diff --git a/packages/host/engine/src/agent/model-probe.ts b/packages/host/engine/src/agent/model-probe.ts
index 02a3a859..79411e66 100644
--- a/packages/host/engine/src/agent/model-probe.ts
+++ b/packages/host/engine/src/agent/model-probe.ts
@@ -3,6 +3,7 @@ import { lookup as dnsLookup } from 'node:dns/promises';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { BlockList, isIP } from 'node:net';
+import type { ServiceModelList } from '@linkcode/providers';
 import type { AccountEndpoint, AccountModel, AccountSecret } from '@linkcode/schema';
 import { extractErrorMessage } from 'foxts/extract-error-message';
 import { z } from 'zod';
@@ -88,7 +89,9 @@ export type ModelListRequest = (
 ) => Promise<ModelListResponse>;
 export type ModelProbe = typeof probeEndpointModels;
 
-export function modelListUrl(endpoint: AccountEndpoint): string {
+/** A custom account names its own endpoint, so its list path can only be guessed from the protocol.
+ * Catalog services never come through here — they carry an explicit URL (`@linkcode/providers`). */
+export function modelListUrlFromEndpoint(endpoint: AccountEndpoint): string {
   const url = new URL(endpoint.baseUrl);
   if (url.username || url.password || url.search || url.hash) {
     throw new Error('Model detection endpoint cannot contain credentials, a query, or a fragment');
@@ -100,11 +103,11 @@ export function modelListUrl(endpoint: AccountEndpoint): string {
 }
 
 export function modelListHeaders(
-  endpoint: AccountEndpoint,
+  wire: ServiceModelList['wire'],
   secret: AccountSecret,
 ): Record<string, string> {
   const headers: Record<string, string> = { accept: 'application/json' };
-  if (endpoint.protocol === 'anthropic') {
+  if (wire === 'anthropic') {
     headers['anthropic-version'] = ANTHROPIC_VERSION;
     // An Anthropic-shaped gateway authenticates with whichever header its own credential is.
     if (secret.type === 'api-key') headers['x-api-key'] = secret.key;
@@ -246,21 +249,21 @@ export function requestModelListAtAddress(
   });
 }
 
-/** Model ids the endpoint advertises, deduped, in the order it listed them. Rejects with a
+/** Model ids the source advertises, deduped, in the order it listed them. Rejects with a
  * user-facing message (status + the vendor's own reason) — the dialog shows it verbatim. */
 export async function probeEndpointModels(
-  endpoint: AccountEndpoint,
+  source: ServiceModelList,
   secret: AccountSecret,
   request: ModelListRequest = requestPublicModelList,
 ): Promise<AccountModel[]> {
-  const url = new URL(modelListUrl(endpoint));
+  const url = new URL(source.url);
   const controller = new AbortController();
   const timeout = setTimeout(() => {
     controller.abort(new Error('Model detection timed out'));
   }, PROBE_TIMEOUT_MS);
   let response: ModelListResponse;
   try {
-    response = await request(url, modelListHeaders(endpoint, secret), controller.signal);
+    response = await request(url, modelListHeaders(source.wire, secret), controller.signal);
   } finally {
     clearTimeout(timeout);
   }
diff --git a/packages/host/engine/src/agent/provider-config.ts b/packages/host/engine/src/agent/provider-config.ts
index b2872f02..5a53678a 100644
--- a/packages/host/engine/src/agent/provider-config.ts
+++ b/packages/host/engine/src/agent/provider-config.ts
@@ -121,8 +121,8 @@ export interface AppliedProviderDefaults {
 }
 
 /** Apply the stored config to a session's StartOptions: resolve the bound account (or legacy
- * per-agent api key) and inject the credential/endpoint bundle into `config`; a resolved account's
- * `model` outranks the provider default. Returns a new object; never mutates the input. */
+ * per-agent api key), inject the credential/endpoint bundle into `config`, and fall back to the
+ * agent's persisted model pick. Returns a new object; never mutates the input. */
 export function applyProviderDefaults(
   opts: StartOptions,
   providers: ProvidersConfig,
@@ -133,10 +133,8 @@ export function applyProviderDefaults(
   if (!config && !account) return { options: opts };
 
   const next: StartOptions = { ...opts };
-  if (next.model === undefined) {
-    const model = account?.model ?? config?.defaultModel;
-    if (model !== undefined) next.model = model;
-  }
+  // The account holds the models the user may pick from; the pick itself is per agent.
+  if (next.model === undefined && config?.model !== undefined) next.model = config.model;
   if (account) {
     const resolved = accountConfigBundle(account, opts.kind);
     if ('unavailable' in resolved) return { options: next, unavailable: resolved.unavailable };
diff --git a/packages/host/engine/src/agent/request-handler.ts b/packages/host/engine/src/agent/request-handler.ts
index 76a1d223..f5deb272 100644
--- a/packages/host/engine/src/agent/request-handler.ts
+++ b/packages/host/engine/src/agent/request-handler.ts
@@ -1,5 +1,6 @@
 import type { AdapterFactory } from '@linkcode/agent-adapter';
-import type { WirePayload } from '@linkcode/schema';
+import { modelListSource } from '@linkcode/providers';
+import type { AccountSecret, WirePayload } from '@linkcode/schema';
 import type { Transport } from '@linkcode/transport';
 import { createWireMessage } from '@linkcode/transport';
 import { Effect } from 'effect';
@@ -150,7 +151,11 @@ export class AgentRequestHandler {
           payload.clientReqId,
           Effect.tryPromise({
             try: async () => {
-              const models = await this.probeModels(payload.endpoint, payload.secret);
+              const source = modelListSource(payload.service);
+              if (!source) {
+                throw new Error(`${payload.service} serves no model list`);
+              }
+              const models = await this.probeModels(source, this.probeSecret(payload.credential));
               this.transport.send(
                 createWireMessage({
                   kind: 'config.probe-models.result',
@@ -205,6 +210,22 @@ export class AgentRequestHandler {
         return Effect.void;
     }
   }
+
+  /** The secret to probe with. A saved account is named by id rather than shipping its secret back
+   * out to the client and in again; an oauth login holds none, so it cannot be probed. */
+  private probeSecret(
+    credential: Extract<AgentRequest, { kind: 'config.probe-models' }>['credential'],
+  ): AccountSecret {
+    if (credential.type === 'inline') return credential.secret;
+    const account = this.providers
+      .getAccounts()
+      .find((candidate) => candidate.id === credential.accountId);
+    if (!account) throw new Error('Account not found');
+    if (account.credential.type === 'oauth') {
+      throw new Error('A subscription login holds no secret to read the model list with');
+    }
+    return account.credential;
+  }
 }
 
 function updateProviderConfig(
diff --git a/packages/host/engine/src/session/start-options-resolver.ts b/packages/host/engine/src/session/start-options-resolver.ts
index 91566d02..324afb79 100644
--- a/packages/host/engine/src/session/start-options-resolver.ts
+++ b/packages/host/engine/src/session/start-options-resolver.ts
@@ -32,11 +32,9 @@ export class SessionStartOptionsResolver {
     options: StartOptions,
     sessionId: SessionId,
   ): Effect.Effect<ResolvedStartOptions, RequestError | OperationError> {
-    const defaults = applyProviderDefaults(
-      options,
-      this.providers.get(),
-      this.providers.getAccounts(),
-    );
+    const providers = this.providers.get();
+    const defaults = applyProviderDefaults(options, providers, this.providers.getAccounts());
+    const accountBound = providers[options.kind]?.activeAccountId !== undefined;
     const { translator } = this;
     const withCustomMcpServers = this.withCustomMcpServers.bind(this);
     const withSimulatorMcp = this.withSimulatorMcp.bind(this);
@@ -51,6 +49,16 @@ export class SessionStartOptionsResolver {
           }),
         );
       }
+      if (accountBound && defaults.options.model === undefined) {
+        // With an account bound, its selected set is the only model source and nothing falls back to
+        // the agent's own choice. Unbound agents keep running on whatever they resolve themselves.
+        return yield* Effect.fail(
+          new RequestError({
+            code: 'unsupported',
+            message: `No model selected for ${options.kind}`,
+          }),
+        );
+      }
       const custom = yield* withCustomMcpServers(defaults.options);
       const resolved = withSimulatorMcp(custom.options, sessionId);
       const upstream = translationUpstream(resolved);
diff --git a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
index 5f7cb78f..8da5b65f 100644
--- a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
+++ b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
@@ -768,7 +768,7 @@ describe('NewSessionSurface', () => {
     );
   });
 
-  it('can return remembered model and effort choices to provider defaults', async () => {
+  it('can return remembered model and effort choices to the configured ones', async () => {
     const user = userEvent.setup();
     const onSubmit = vi.fn().mockResolvedValue(undefined);
     render(
@@ -799,9 +799,11 @@ describe('NewSessionSurface', () => {
     typeInComposer('use provider defaults');
     await pressInComposer('Enter');
     await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
-    expect(onSubmit.mock.calls[0]?.[0]).toEqual(
-      expect.objectContaining({ model: null, effort: null }),
-    );
+    const submitted = onSubmit.mock.calls[0]?.[0];
+    expect(submitted).toEqual(expect.objectContaining({ effort: null }));
+    // No "back to the provider's own model" tier any more: an absent model defers to the
+    // agent's persisted pick, which the daemon resolves.
+    expect(submitted?.model).toBeUndefined();
   });
 
   it('submits a model only after the user explicitly selects it', async () => {
diff --git a/packages/presentation/ui/src/shell/new-session-surface.tsx b/packages/presentation/ui/src/shell/new-session-surface.tsx
index 887dc705..f73fca2f 100644
--- a/packages/presentation/ui/src/shell/new-session-surface.tsx
+++ b/packages/presentation/ui/src/shell/new-session-surface.tsx
@@ -55,8 +55,8 @@ export interface NewSessionSubmission {
   cwd: string;
   /** The picked workspace backing `cwd` — lets the caller persist it as the next draft's default. */
   workspaceId: WorkspaceId;
-  /** Null explicitly returns this provider to its configured/default model. */
-  model?: string | null;
+  /** Absent falls back to the agent's persisted pick; there is no "return to default" tier. */
+  model?: string;
   /** Null explicitly returns this provider to its default effort. */
   effort?: EffortLevel | null;
   approvalPolicyId?: string;
@@ -231,7 +231,7 @@ export function NewSessionSurface({
         kind: provider,
         cwd: selected.cwd,
         workspaceId: selected.workspaceId,
-        model: localModel === null ? null : (selectedModel ?? undefined),
+        model: localModel === null ? undefined : (selectedModel ?? undefined),
         ...(localEffort === null
           ? { effort: null }
           : constrainedEffort !== null && { effort: constrainedEffort }),
diff --git a/packages/presentation/ui/src/shell/providers/account-detail.tsx b/packages/presentation/ui/src/shell/providers/account-detail.tsx
index ed280183..9265b726 100644
--- a/packages/presentation/ui/src/shell/providers/account-detail.tsx
+++ b/packages/presentation/ui/src/shell/providers/account-detail.tsx
@@ -74,7 +74,8 @@ export interface ProviderAccountDetailViewModel {
   label: string;
   credential: ProviderCredentialViewModel;
   routing?: ProviderAccountRouting;
-  accountModel?: string;
+  /** Model ids the user picked for this account — the only ones its pickers offer. */
+  accountModels?: string[];
   bindings: ProviderBindingViewModel[];
   boundAgents: AgentKind[];
   availableBindingCount: number;
@@ -198,10 +199,10 @@ export function AccountDetail({
               </span>
             </DetailRow>
           ) : null}
-          {account.accountModel !== undefined && account.accountModel !== '' ? (
+          {account.accountModels !== undefined && account.accountModels.length > 0 ? (
             <DetailRow label={t('accountModel')}>
               <span className="min-w-0 flex-1 truncate font-mono text-muted-foreground text-xs">
-                {account.accountModel}
+                {account.accountModels.join(' · ')}
               </span>
             </DetailRow>
           ) : null}

From 0bae73978de6808df25704ab17a61aa3eb5ba5b5 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 18:38:34 +0800
Subject: [PATCH 03/17] feat(agent-adapter): route a bare picked model id
 through opencode's known provider

A picked model id comes from the service's own model list and carries no
provider, while opencode routes only by `providerID/modelID`. `resolveModelRef`
qualifies it with `config.knownProvider`; with neither half available the ref is
still refused, since a stored unroutable id would report a successful switch
while every prompt silently omitted the field.

Both reflection paths compare resolved refs and emit the id the user picked
rather than opencode's prefixed readback, so the client's selected set still
matches what the session reports.
---
 packages/host/agent-adapter/AGENTS.md         |  2 +-
 .../src/__tests__/opencode.test.ts            | 24 ++++++++++++-
 .../src/native/opencode/adapter.ts            | 34 ++++++++++++++++---
 3 files changed, 53 insertions(+), 7 deletions(-)

diff --git a/packages/host/agent-adapter/AGENTS.md b/packages/host/agent-adapter/AGENTS.md
index a4d0e70f..14f3068e 100644
--- a/packages/host/agent-adapter/AGENTS.md
+++ b/packages/host/agent-adapter/AGENTS.md
@@ -90,7 +90,7 @@ Every new adapter MUST honor these (`base.ts`); downstream relies on them, they
 ## opencode & pi
 
 - **opencode** — `consumeEvents()` keeps one active `event.subscribe({directory: cwd})` and resubscribes after a clean SSE close at normal turn end (`session.idle`) or on cancel. The directory scope is LOAD-BEARING: events ride a per-directory instance bus, so a bare `subscribe()` silently misses every session event whenever the daemon cwd differs from the session cwd (verified live on 1.17.11). A close is fatal ONLY while a turn is active with no cancel pending, and the fatal path emits status `stopped` (NOT `idle`) so the UI disables the composer — misclassifying it (the pre-fix bug) stranded the composer enabled against a dead adapter. Each event has its own try/catch; the resubscribe delay prevents an empty-response busy loop.
-- **opencode control plane** (CODE-224, live-verified on binary 1.18.2 × SDK 1.17.18 — script + readback transcript attached to the issue): `set-model` and `set-approval-policy` are pure store-then-emit — the pick is resent on every `session.promptAsync`/`session.command` as the `model`/`agent` fields, and a mid-session change routes the very next turn (assistant `providerID`/`modelID`/`agent` readback all flip; next-turn semantics, in-flight turns unaffected). User and assistant `message.updated` frames reflect the actually routed `providerID/modelID`, including the native default when no override was sent. No dedicated switched/ack event fires on the legacy bus, so the immediate reflect is the only switch confirmation channel. `set-model` rejects refs that aren't `providerID/modelID` (a stored bare id would emit a "successful" model-update while prompts silently omit the field) and rejects cross-provider switches when a per-account credential was injected at spawn (the injection is spawn-time-only, scoped to one provider). **The approval-policy axis IS opencode's agent axis**: selectable agents from `app.agents({directory})` (`mode === 'primary'|'all'`, non-hidden — hidden primaries like `compaction`/`title` and subagents are excluded) are advertised as policies, default = first primary (the TUI's own default); permission posture stays config-driven (CODE-136). The axis is dynamic: a failed discovery at start hides it for the session (a later `$` shell command retries and re-arms it on success). `$` shell runs under the selected agent. Resume adopts the Session record's last-used `model`/`agent` (both live-verified to update after every turn) unless `StartOptions.model` overrides; a credential-carrying resume without an explicit model pre-reads that record off the shared history server BEFORE the spawn, because the credential injection is spawn-time-only and keyed by the model's provider. There is NO effort axis — opencode's only analogue is per-model `variant` keys (free strings, incompatible with the closed `EffortLevel` enum; a follow-up on the dynamic catalog). **The model catalog is adapter-advertised** (CODE-226): `provider.list({directory})` at start → `available-models-update` (full-replace, engine-cached, attach-replayed — the command-catalog contract), filtered to connected / key-less `api`-source providers and narrowed to the credential-injected provider when one is in play; the composer prefers this catalog over the static `AGENT_MODEL_OPTIONS` table (which deliberately has no opencode entry — its model set is provider-dependent, not a fixed vendor list).
+- **opencode control plane** (CODE-224, live-verified on binary 1.18.2 × SDK 1.17.18 — script + readback transcript attached to the issue): `set-model` and `set-approval-policy` are pure store-then-emit — the pick is resent on every `session.promptAsync`/`session.command` as the `model`/`agent` fields, and a mid-session change routes the very next turn (assistant `providerID`/`modelID`/`agent` readback all flip; next-turn semantics, in-flight turns unaffected). User and assistant `message.updated` frames reflect the actually routed `providerID/modelID`, including the native default when no override was sent. No dedicated switched/ack event fires on the legacy bus, so the immediate reflect is the only switch confirmation channel. `set-model` rejects refs that aren't `providerID/modelID` **and cannot be qualified** — a picked model id comes from the service's own model list and carries no provider, so `config.knownProvider` supplies the missing half (`resolveModelRef`); with neither, a stored bare id would emit a "successful" model-update while prompts silently omit the field. Both reflection paths compare *resolved* refs and then emit the id the user picked, not opencode's prefixed readback, so the client's selected set still matches and rejects cross-provider switches when a per-account credential was injected at spawn (the injection is spawn-time-only, scoped to one provider). **The approval-policy axis IS opencode's agent axis**: selectable agents from `app.agents({directory})` (`mode === 'primary'|'all'`, non-hidden — hidden primaries like `compaction`/`title` and subagents are excluded) are advertised as policies, default = first primary (the TUI's own default); permission posture stays config-driven (CODE-136). The axis is dynamic: a failed discovery at start hides it for the session (a later `$` shell command retries and re-arms it on success). `$` shell runs under the selected agent. Resume adopts the Session record's last-used `model`/`agent` (both live-verified to update after every turn) unless `StartOptions.model` overrides; a credential-carrying resume without an explicit model pre-reads that record off the shared history server BEFORE the spawn, because the credential injection is spawn-time-only and keyed by the model's provider. There is NO effort axis — opencode's only analogue is per-model `variant` keys (free strings, incompatible with the closed `EffortLevel` enum; a follow-up on the dynamic catalog). **The model catalog is adapter-advertised** (CODE-226): `provider.list({directory})` at start → `available-models-update` (full-replace, engine-cached, attach-replayed — the command-catalog contract), filtered to connected / key-less `api`-source providers and narrowed to the credential-injected provider when one is in play; the composer prefers this catalog over the static `AGENT_MODEL_OPTIONS` table (which deliberately has no opencode entry — its model set is provider-dependent, not a fixed vendor list).
 - **opencode turn lifecycle** (all verified live on 1.17.11, CODE-136): prompts go through `session.promptAsync` — the blocking `session.prompt` holds its HTTP response open for the whole turn, so `send()` would not return until the turn ended. `session.status {busy|retry}` is the on-stream acknowledgement that the active turn is running, and it ALWAYS precedes the turn's own error/idle — the `turnStarted` gate built on it is what keeps the previous turn's post-settle stragglers (an abort's DUPLICATE idle; the error re-fired with a stack after the settle) from falsely settling or poisoning a next turn that was already dispatched. An abort delivers `session.error {MessageAbortedError}` + `session.idle` — the error folds into the cancel path (stop `cancelled`), never surfaces as an error. Other `session.error`s fail the turn: `ProviderAuthError` → `AUTH_FAILED_ERROR_CODE` (non-recoverable, triggers the daemon login re-probe), everything else recoverable; `sessionID` is OPTIONAL on this one event — an unattributed error still counts as ours. A failed turn's idle settle emits status `idle` but NO `end_turn` stop. An idle absorbed before the busy acknowledgement logs a `console.warn` — the one trace if a server never emits `session.status` (the turn would then hang at `running`).
 - **opencode RPC results resolve, they don't reject**: the generated client returns `{error}` for HTTP and network failures alike (`throwOnError` is never set) — every RPC result goes through `okOrThrow` or a failure silently reads as success (a permission reply that never landed, a prompt that never started).
 - **opencode permissions & questions** (CODE-136): opencode's default posture is allow-all — asks only fire when the user's own config (or a future preset) says `ask`. `permission.asked` → the shared `requestPermission` round-trip → `permission.reply({reply: 'once'|'always'|'reject'})`; `always` is persisted server-side as a saved rule. `question.asked` → `requestQuestion` → `question.reply({answers})` (one label array per question) or `question.reject`. An UNANSWERED ask gates the turn server-side forever, so a teardown-cancelled permission replies `reject` and a cancelled question calls `reject` — reply failures after a cancel are swallowed (the abort already discarded the ask). Asks cite their tool via `tool.callID`, but tool cards are announced under the PART id — `toolPartIdByCallId` re-joins them. A custom "Other" answer rides as an extra label: upstream `Question.reply` hands the answer arrays to the asking tool verbatim, with no validation against option labels (verified in anomalyco/opencode source).
diff --git a/packages/host/agent-adapter/src/__tests__/opencode.test.ts b/packages/host/agent-adapter/src/__tests__/opencode.test.ts
index 06a505c0..e1747a49 100644
--- a/packages/host/agent-adapter/src/__tests__/opencode.test.ts
+++ b/packages/host/agent-adapter/src/__tests__/opencode.test.ts
@@ -1628,7 +1628,29 @@ describe('OpenCodeAdapter control plane (CODE-224)', () => {
     });
   });
 
-  it('rejects a set-model ref that is not providerID/modelID', async () => {
+  it('qualifies a bare picked id with the endpoint’s known provider', async () => {
+    // A picked id comes from the service's model list and carries no provider; opencode routes
+    // only by providerID/modelID, so `knownProvider` supplies the missing half.
+    const adapter = new OpenCodeAdapter();
+    const events: AgentEvent[] = [];
+    adapter.onEvent((e) => events.push(e));
+    await adapter.start({
+      kind: 'opencode',
+      cwd: '/tmp/repo',
+      config: { knownProvider: 'deepseek' },
+    });
+
+    await adapter.send({ type: 'set-model', model: 'deepseek-v4-pro' });
+    // Reflected as the user picked it, so the client's own selected set matches.
+    expect(events).toContainEqual({ type: 'model-update', model: 'deepseek-v4-pro' });
+
+    await adapter.send({ type: 'prompt', content: [{ type: 'text', text: 'hi' }] });
+    expect(client.session.promptAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ model: { providerID: 'deepseek', modelID: 'deepseek-v4-pro' } }),
+    );
+  });
+
+  it('rejects a bare set-model ref when no known provider can qualify it', async () => {
     const { adapter, events } = await makeAdapter();
     events.length = 0;
 
diff --git a/packages/host/agent-adapter/src/native/opencode/adapter.ts b/packages/host/agent-adapter/src/native/opencode/adapter.ts
index 4d91fc8b..c76571fe 100644
--- a/packages/host/agent-adapter/src/native/opencode/adapter.ts
+++ b/packages/host/agent-adapter/src/native/opencode/adapter.ts
@@ -148,6 +148,17 @@ function parseModelRef(model: string): { providerID: string; modelID: string } |
   return { providerID, modelID };
 }
 
+/** A selected model id is the vendor's own, taken from the service's model list and carrying no
+ * provider — opencode routes only by `providerID/modelID`, so qualify it with the endpoint's id in
+ * opencode's catalog. Without a known provider a bare id stays unroutable and is rejected. */
+function resolveModelRef(
+  model: string,
+  knownProvider: string | undefined,
+): { providerID: string; modelID: string } | undefined {
+  if (model.includes('/')) return parseModelRef(model);
+  return knownProvider === undefined ? undefined : { providerID: knownProvider, modelID: model };
+}
+
 type OpencodeModule = typeof import('@opencode-ai/sdk/v2');
 type OpencodeClient = ReturnType<OpencodeModule['createOpencodeClient']>;
 type OpencodeProviderList = NonNullable<
@@ -384,7 +395,14 @@ export class OpenCodeAdapter extends BaseAgentAdapter {
     }
     // A resumed session record confirms its current model. A fresh override is confirmed only when
     // the running server advertises that exact ref; a request or failed catalog is not acceptance.
-    if (opts.model && (opts.model === resumedModel || availableModels?.has(opts.model))) {
+    // Compare as resolved refs: a picked id is the vendor's own and carries no provider, while the
+    // catalog and the session record are always `providerID/modelID`.
+    const requested = this.model();
+    const advertised =
+      requested === undefined
+        ? false
+        : availableModels?.has(`${requested.providerID}/${requested.modelID}`) === true;
+    if (opts.model && (advertised || opts.model === resumedModel)) {
       this.emitModel(opts.model);
     }
     void this.consumeEvents();
@@ -760,9 +778,9 @@ export class OpenCodeAdapter extends BaseAgentAdapter {
    * the legacy bus — the immediate reflect below is the only confirmation channel there is. */
   protected override onSetModel(model: string): Promise<void> {
     invariant(this.opts, 'opencode: session not started');
-    const parsed = parseModelRef(model);
+    const parsed = resolveModelRef(model, readAgentCredential(this.opts.config).knownProvider);
     if (!parsed) {
-      // Storing an unparseable ref would emit a "successful" model-update while every following
+      // Storing an unroutable ref would emit a "successful" model-update while every following
       // prompt silently omits the model field and keeps running on the previous one.
       return Promise.reject(
         new Error(`opencode: model must be 'providerID/modelID' (got '${model}')`),
@@ -821,7 +839,8 @@ export class OpenCodeAdapter extends BaseAgentAdapter {
   }
 
   private model(): { providerID: string; modelID: string } | undefined {
-    return this.opts?.model ? parseModelRef(this.opts.model) : undefined;
+    if (!this.opts?.model) return undefined;
+    return resolveModelRef(this.opts.model, readAgentCredential(this.opts.config).knownProvider);
   }
 
   /** Runs for the whole session, dispatching every SSE event and replacing a stream the server
@@ -964,7 +983,12 @@ export class OpenCodeAdapter extends BaseAgentAdapter {
     ) {
       return;
     }
-    this.emitModel(model);
+    // opencode always reports `providerID/modelID`. When that is the pick resolved, reflect the
+    // pick verbatim instead — the client matches against the ids the user selected, which are bare.
+    const requested = this.model();
+    const routedThePick =
+      requested !== undefined && `${requested.providerID}/${requested.modelID}` === model;
+    this.emitModel(routedThePick && this.opts?.model ? this.opts.model : model);
   }
 
   /** Turn settle on `session.idle`, guarded on liveness AND `turnStarted`: an abort's duplicate

From f7435f8529250a38b44db6573ad25574ef964d47 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 18:59:50 +0800
Subject: [PATCH 04/17] feat(workbench,i18n): pick an account's models from the
 service's own list
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every account form now carries a model set instead of a free-text default: fetch
the ids the service serves, tick the ones to keep, and add any missing id by
hand. Endpoints that serve no list — the Cloudflare gateways, custom accounts —
are freeform only, which is the same control with the fetch button absent.

Sources differ by account and are injected rather than read in the form, since
the forms are presentation and only the settings page sits inside the data-plane
provider tree: a catalog service is probed with the unsaved secret, a saved
account by id, and a subscription reads codex's start catalog or, for
claude-code, the curated table it has no enumeration API to replace.

A picked id the list stops returning is kept and stays ticked. It is either a
hand-typed entry or one the vendor retired, and dropping it would change the
account's model set behind the user's back on the next fetch.
---
 .../__tests__/model-selection.test.tsx        | 101 ++++++++++
 .../settings/providers/__tests__/view.test.ts |   4 +-
 .../src/settings/providers/add-flow.tsx       | 141 ++++++++++++--
 .../settings/providers/model-selection.tsx    | 180 ++++++++++++++++++
 .../settings/providers/providers-settings.tsx |   5 +
 packages/presentation/i18n/src/locales/en.ts  |  12 +-
 .../presentation/i18n/src/locales/zh-cn.ts    |  12 +-
 7 files changed, 436 insertions(+), 19 deletions(-)
 create mode 100644 packages/client/workbench/src/settings/providers/__tests__/model-selection.test.tsx
 create mode 100644 packages/client/workbench/src/settings/providers/model-selection.tsx

diff --git a/packages/client/workbench/src/settings/providers/__tests__/model-selection.test.tsx b/packages/client/workbench/src/settings/providers/__tests__/model-selection.test.tsx
new file mode 100644
index 00000000..6368bc97
--- /dev/null
+++ b/packages/client/workbench/src/settings/providers/__tests__/model-selection.test.tsx
@@ -0,0 +1,101 @@
+// @vitest-environment jsdom
+
+import type { AccountModel } from '@linkcode/schema';
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { nullthrow } from 'foxts/guard';
+import { useState } from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ModelSelection } from '../model-selection';
+
+function translateKey(key: string): string {
+  return key;
+}
+
+vi.mock('use-intl', () => ({
+  useTranslations: () => translateKey,
+}));
+
+afterEach(cleanup);
+
+const NONE: AccountModel[] = [];
+const RE_REFRESH = /models\.refresh/;
+const RE_ADD = /models\.add/;
+const RE_BAD_KEY = /invalid api key/;
+
+/** Renders with the selection held above, the way both account forms do through `Controller`. */
+function Harness({
+  initial = NONE,
+  onFetch,
+}: {
+  initial?: AccountModel[];
+  onFetch?: () => Promise<AccountModel[]>;
+}): React.ReactNode {
+  const [selected, setSelected] = useState(initial);
+  return <ModelSelection onChange={setSelected} onFetch={onFetch} selected={selected} />;
+}
+
+function rowFor(id: string): HTMLInputElement {
+  const row = nullthrow(screen.getByText(id).closest('label'), `no row for ${id}`);
+  return nullthrow(row.querySelector('input'), `no checkbox for ${id}`);
+}
+
+describe('ModelSelection', () => {
+  it('fetches a list, and only ticked ids become the set', async () => {
+    const onFetch = vi
+      .fn()
+      .mockResolvedValue([
+        { id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' },
+        { id: 'deepseek-v4-flash' },
+      ]);
+    render(<Harness onFetch={onFetch} />);
+
+    fireEvent.click(screen.getByRole('button', { name: RE_REFRESH }));
+    await waitFor(() => expect(screen.getByText('deepseek-v4-pro')).toBeTruthy());
+
+    expect(rowFor('deepseek-v4-pro').checked).toBe(false);
+    fireEvent.click(rowFor('deepseek-v4-pro'));
+    await waitFor(() => expect(rowFor('deepseek-v4-pro').checked).toBe(true));
+    expect(rowFor('deepseek-v4-flash').checked).toBe(false);
+  });
+
+  it('keeps a picked id the list no longer returns, rather than silently unpicking it', async () => {
+    // A freeform entry, or one the vendor has retired: dropping it would change the account's set
+    // behind the user's back on the next refresh.
+    const onFetch = vi.fn().mockResolvedValue([{ id: 'gpt-5' }]);
+    render(<Harness initial={[{ id: 'retired-model' }]} onFetch={onFetch} />);
+
+    fireEvent.click(screen.getByRole('button', { name: RE_REFRESH }));
+    await waitFor(() => expect(screen.getByText('gpt-5')).toBeTruthy());
+
+    expect(rowFor('retired-model').checked).toBe(true);
+  });
+
+  it('adds a hand-typed id and refuses a duplicate', () => {
+    render(<Harness initial={[{ id: 'already' }]} />);
+
+    const input = screen.getByPlaceholderText('models.addPlaceholder');
+    fireEvent.change(input, { target: { value: 'typed-model' } });
+    fireEvent.click(screen.getByRole('button', { name: RE_ADD }));
+    expect(rowFor('typed-model').checked).toBe(true);
+    expect((input as HTMLInputElement).value).toBe('');
+
+    fireEvent.change(input, { target: { value: 'already' } });
+    fireEvent.click(screen.getByRole('button', { name: RE_ADD }));
+    expect(screen.getAllByText('already')).toHaveLength(1);
+  });
+
+  it("surfaces the fetch failure's own reason instead of swallowing it", async () => {
+    const onFetch = vi.fn().mockRejectedValue(new Error('401 Unauthorized — invalid api key'));
+    render(<Harness onFetch={onFetch} />);
+
+    fireEvent.click(screen.getByRole('button', { name: RE_REFRESH }));
+    await waitFor(() => expect(screen.getByText(RE_BAD_KEY)).toBeTruthy());
+  });
+
+  it('offers no fetch when nothing can list the endpoint', () => {
+    render(<Harness />);
+
+    expect(screen.queryByRole('button', { name: RE_REFRESH })).toBeNull();
+    expect(screen.getByText('models.hintUnlistable')).toBeTruthy();
+  });
+});
diff --git a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
index 2c082c8e..a748f139 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
@@ -167,6 +167,7 @@ describe('view helpers', () => {
         secret: 'new-secret',
         baseUrl: 'https://new.example.com/v1',
         protocol: 'anthropic',
+        models: [{ id: 'new-model' }],
       }),
     ).toEqual({
       id: 'acc_a',
@@ -175,8 +176,7 @@ describe('view helpers', () => {
       service: 'openrouter',
       credential: { type: 'auth-token', token: 'new-secret' },
       endpoint: { baseUrl: 'https://new.example.com/v1', protocol: 'anthropic' },
-      // The picked set survives an edit: this form does not manage it.
-      models: [{ id: 'old-model' }],
+      models: [{ id: 'new-model' }],
       extraEnv: { GATEWAY_MODE: 'strict' },
     });
   });
diff --git a/packages/client/workbench/src/settings/providers/add-flow.tsx b/packages/client/workbench/src/settings/providers/add-flow.tsx
index ce907e0d..185a54f1 100644
--- a/packages/client/workbench/src/settings/providers/add-flow.tsx
+++ b/packages/client/workbench/src/settings/providers/add-flow.tsx
@@ -1,13 +1,15 @@
 import { zodResolver } from '@hookform/resolvers/zod';
 import type { EndpointService, ServiceDescriptor, ServiceGroup } from '@linkcode/providers';
 import {
+  modelListSource,
   pinnedEndpoint,
   SERVICE_CATALOG,
   serviceById,
   serviceProtocols,
   templatePlaceholders,
 } from '@linkcode/providers';
-import type { Account, AccountProtocol, AgentRuntimes } from '@linkcode/schema';
+import type { Account, AccountModel, AccountProtocol, AgentRuntimes } from '@linkcode/schema';
+import { AccountModelSchema } from '@linkcode/schema';
 import { AgentOnboardingCard, ServiceIcon } from '@linkcode/ui';
 import { Button } from 'coss-ui/components/button';
 import { Field, FieldLabel } from 'coss-ui/components/field';
@@ -27,6 +29,8 @@ import { Controller, useForm } from 'react-hook-form';
 import { useTranslations } from 'use-intl';
 import { z } from 'zod';
 import type { AgentRuntimeOnboarding } from '../../agent-runtime/onboarding';
+import type { ModelSources } from './model-selection';
+import { ModelSelection } from './model-selection';
 
 const GROUPS: ServiceGroup[] = ['subscription', 'direct', 'gateway', 'custom'];
 
@@ -43,11 +47,13 @@ function newAccountBase(label: string): Pick<Account, 'id' | 'label' | 'createdA
 export function oauthAccount(
   service: Extract<ServiceDescriptor, { kind: 'oauth' }>,
   label: string,
+  models: AccountModel[] = [],
 ): Account {
   return {
     ...newAccountBase(label),
     service: service.id,
     credential: { type: 'oauth', agent: service.agent },
+    ...(models.length > 0 && { models }),
   };
 }
 
@@ -67,6 +73,7 @@ function catalogAccount(service: EndpointService, draft: CatalogDraft): Account
         ? { type: 'auth-token', token: draft.secret }
         : { type: 'api-key', key: draft.secret },
     ...(!isObjectEmpty(trimmed) && { endpointParams: trimmed }),
+    ...(draft.models.length > 0 && { models: draft.models }),
   };
 }
 
@@ -93,10 +100,13 @@ function accountFromCustomDraft(draft: CustomDraft, account?: Account): Account
   const base =
     account === undefined
       ? newAccountBase(draft.label)
-      : // `models` is deliberately kept: this form does not manage the picked set.
-        (({ credential: _credential, endpoint: _endpoint, label: _label, ...rest }) => rest)(
-          account,
-        );
+      : (({
+          credential: _credential,
+          endpoint: _endpoint,
+          label: _label,
+          models: _models,
+          ...rest
+        }) => rest)(account);
   return {
     ...base,
     label: draft.label.trim(),
@@ -106,6 +116,7 @@ function accountFromCustomDraft(draft: CustomDraft, account?: Account): Account
         : { type: 'api-key', key: draft.secret },
     ...(draft.baseUrl.trim() &&
       protocol && { endpoint: { baseUrl: draft.baseUrl.trim(), protocol } }),
+    ...(draft.models.length > 0 && { models: draft.models }),
   };
 }
 
@@ -152,6 +163,7 @@ export function ServiceCatalogView({
 /** Step two: the per-service seeded form (or the free-form one for `custom`). */
 export function AddAccountForm({
   serviceId,
+  sources,
   runtimes,
   onboarding,
   busy,
@@ -159,6 +171,7 @@ export function AddAccountForm({
   onSubmit,
 }: {
   serviceId: string;
+  sources?: ModelSources;
   runtimes: AgentRuntimes | undefined;
   onboarding: AgentRuntimeOnboarding;
   busy: boolean;
@@ -183,15 +196,16 @@ export function AddAccountForm({
       {service.kind === 'oauth' ? (
         <OauthCreateForm
           service={service}
+          sources={sources}
           runtimes={runtimes}
           onboarding={onboarding}
           busy={busy}
           onSubmit={onSubmit}
         />
       ) : service.kind === 'endpoint' ? (
-        <CatalogAccountForm service={service} busy={busy} onSubmit={onSubmit} />
+        <CatalogAccountForm service={service} sources={sources} busy={busy} onSubmit={onSubmit} />
       ) : (
-        <CustomAccountForm busy={busy} onSubmit={onSubmit} />
+        <CustomAccountForm sources={sources} busy={busy} onSubmit={onSubmit} />
       )}
     </div>
   );
@@ -200,11 +214,13 @@ export function AddAccountForm({
 /** Existing-account editor shown inside the account management dialog. */
 export function EditAccountForm({
   account,
+  sources,
   busy,
   onBack,
   onSubmit,
 }: {
   account: Account;
+  sources?: ModelSources;
   busy: boolean;
   onBack: () => void;
   onSubmit: (account: Account) => void;
@@ -226,44 +242,70 @@ export function EditAccountForm({
         </h3>
       </div>
       {account.credential.type === 'oauth' ? (
-        <OauthEditForm account={account} busy={busy} onSubmit={onSubmit} />
+        <OauthEditForm account={account} sources={sources} busy={busy} onSubmit={onSubmit} />
       ) : (
-        <CustomAccountForm account={account} busy={busy} onSubmit={onSubmit} />
+        <CustomAccountForm account={account} sources={sources} busy={busy} onSubmit={onSubmit} />
       )}
     </div>
   );
 }
 
-const OauthEditDraftSchema = z.object({ label: z.string().min(1) });
+const OauthEditDraftSchema = z.object({
+  label: z.string().min(1),
+  models: z.array(AccountModelSchema),
+});
 type OauthEditDraft = z.infer<typeof OauthEditDraftSchema>;
 
 function OauthEditForm({
   account,
+  sources,
   busy,
   onSubmit,
 }: {
   account: Account;
+  sources?: ModelSources;
   busy: boolean;
   onSubmit: (account: Account) => void;
 }): React.ReactNode {
   const t = useTranslations('settings.providers');
   const {
     register,
+    control,
     handleSubmit,
     formState: { isSubmitting },
   } = useForm<OauthEditDraft>({
     resolver: zodResolver(OauthEditDraftSchema),
-    defaultValues: { label: account.label },
+    defaultValues: { label: account.label, models: account.models ?? [] },
   });
+  const agent = account.credential.type === 'oauth' ? account.credential.agent : undefined;
+  const fetchModels = agent === undefined || !sources ? undefined : () => sources.oauth(agent);
   return (
     <form
       className="flex flex-col gap-3"
-      onSubmit={handleSubmit((draft) => onSubmit({ ...account, label: draft.label.trim() }))}
+      onSubmit={handleSubmit((draft) =>
+        onSubmit({
+          ...account,
+          label: draft.label.trim(),
+          ...(draft.models.length > 0 ? { models: draft.models } : { models: undefined }),
+        }),
+      )}
     >
       <Field>
         <FieldLabel>{t('form.label')}</FieldLabel>
         <Input className="w-full" autoComplete="off" {...register('label')} />
       </Field>
+      <Controller
+        control={control}
+        name="models"
+        render={({ field }) => (
+          <ModelSelection
+            disabled={busy}
+            onChange={field.onChange}
+            onFetch={fetchModels}
+            selected={field.value}
+          />
+        )}
+      />
       <p className="text-muted-foreground text-xs">{t('oauthEditHint')}</p>
       <div className="flex justify-end pt-1">
         <Button type="submit" size="sm" disabled={busy || isSubmitting}>
@@ -277,12 +319,14 @@ function OauthEditForm({
 /** Subscription accounts are persisted only after the agent CLI login succeeds. */
 function OauthCreateForm({
   service,
+  sources,
   runtimes,
   onboarding,
   busy,
   onSubmit,
 }: {
   service: Extract<ServiceDescriptor, { kind: 'oauth' }>;
+  sources?: ModelSources;
   runtimes: AgentRuntimes | undefined;
   onboarding: AgentRuntimeOnboarding;
   busy: boolean;
@@ -291,6 +335,8 @@ function OauthCreateForm({
   const t = useTranslations('settings.providers');
   const serviceName = t(`serviceName.${service.id}`);
   const [label, setLabel] = useState(serviceName);
+  const [models, setModels] = useState<AccountModel[]>([]);
+  const fetchModels = sources ? () => sources.oauth(service.agent) : undefined;
   const auth = runtimes?.[service.agent]?.auth;
   const loggedIn = auth?.loggedIn === true;
   const cue = onboarding.cues[service.agent] ?? { state: 'needs-login', phase: 'idle' as const };
@@ -309,6 +355,12 @@ function OauthCreateForm({
           onChange={(event) => setLabel(event.target.value)}
         />
       </Field>
+      <ModelSelection
+        disabled={busy || loginInProgress}
+        onChange={setModels}
+        onFetch={fetchModels}
+        selected={models}
+      />
       {loggedIn ? (
         <>
           <p className="text-muted-foreground text-xs">
@@ -321,7 +373,7 @@ function OauthCreateForm({
               type="button"
               size="sm"
               disabled={busy || label.trim() === ''}
-              onClick={() => onSubmit(oauthAccount(service, label))}
+              onClick={() => onSubmit(oauthAccount(service, label, models))}
             >
               {t('form.submit')}
             </Button>
@@ -337,7 +389,7 @@ function OauthCreateForm({
             busy || label.trim() === ''
               ? undefined
               : (kind) => {
-                  onboarding.login(kind, () => onSubmit(oauthAccount(service, label)));
+                  onboarding.login(kind, () => onSubmit(oauthAccount(service, label, models)));
                 }
           }
           onSubmitLoginCode={onboarding.submitLoginCode}
@@ -352,6 +404,7 @@ const CatalogDraftSchema = z.object({
   label: z.string().min(1),
   secret: z.string().min(1),
   placeholders: z.record(z.string(), z.string()),
+  models: z.array(AccountModelSchema),
 });
 type CatalogDraft = z.infer<typeof CatalogDraftSchema>;
 
@@ -375,10 +428,12 @@ function placeholderLabel(key: string): string {
 
 function CatalogAccountForm({
   service,
+  sources,
   busy,
   onSubmit,
 }: {
   service: EndpointService;
+  sources?: ModelSources;
   busy: boolean;
   onSubmit: (account: Account) => void;
 }): React.ReactNode {
@@ -388,16 +443,34 @@ function CatalogAccountForm({
 
   const {
     register,
+    control,
+    getValues,
     handleSubmit,
     formState: { isSubmitting },
   } = useForm<CatalogDraft>({
     resolver: zodResolver(catalogDraftSchema(service)),
-    defaultValues: { label: serviceName, secret: '', placeholders: {} },
+    defaultValues: { label: serviceName, secret: '', placeholders: {}, models: [] },
   });
 
   const secretLabel =
     service.credentialType === 'auth-token' ? t('credentialAuthToken') : t('credentialApiKey');
 
+  /** The secret is read at click time rather than watched: the button stays enabled and says what
+   * is missing, instead of subscribing the whole form to every keystroke. */
+  const fetchModels =
+    sources && service.models
+      ? async (): Promise<AccountModel[]> => {
+          const secret = getValues('secret');
+          if (!secret) throw new Error(t('models.secretFirst'));
+          return sources.probeInline(
+            service.id,
+            service.credentialType === 'auth-token'
+              ? { type: 'auth-token', token: secret }
+              : { type: 'api-key', key: secret },
+          );
+        }
+      : undefined;
+
   return (
     <form
       className="flex flex-col gap-3"
@@ -423,6 +496,18 @@ function CatalogAccountForm({
           {...register('secret')}
         />
       </Field>
+      <Controller
+        control={control}
+        name="models"
+        render={({ field }) => (
+          <ModelSelection
+            disabled={busy}
+            onChange={field.onChange}
+            onFetch={fetchModels}
+            selected={field.value}
+          />
+        )}
+      />
       <p className="mt-1 truncate font-mono text-muted-foreground text-xs">
         {serviceProtocols(service.id).join(' · ')}
       </p>
@@ -441,16 +526,19 @@ const CustomDraftSchema = z.object({
   secret: z.string().min(1),
   baseUrl: z.string(),
   protocol: z.string(),
+  models: z.array(AccountModelSchema),
 });
 type CustomDraft = z.infer<typeof CustomDraftSchema>;
 
 /** The full free-form account form (any endpoint, any protocol) — no catalog seeding. */
 function CustomAccountForm({
   account,
+  sources,
   busy,
   onSubmit,
 }: {
   account?: Account;
+  sources?: ModelSources;
   busy: boolean;
   onSubmit: (account: Account) => void;
 }): React.ReactNode {
@@ -478,8 +566,19 @@ function CustomAccountForm({
       // resolve time, so showing it would invite the user to "keep" a value that does nothing.
       baseUrl: (account && pinnedEndpoint(account)?.baseUrl) ?? '',
       protocol: (account && pinnedEndpoint(account)?.protocol) ?? '',
+      models: account?.models ?? [],
     },
   });
+  // A saved account is probed by id so its stored secret stays on the daemon side. A custom account
+  // names no service, so nothing can list its models and the set stays freeform.
+  const service = account?.service;
+  const fetchModels =
+    sources !== undefined &&
+    account !== undefined &&
+    service !== undefined &&
+    modelListSource(service) !== undefined
+      ? (): Promise<AccountModel[]> => sources.probeAccount(service, account.id)
+      : undefined;
 
   const typeItems = [
     { value: 'api-key', label: t('credentialApiKey') },
@@ -538,6 +637,18 @@ function CustomAccountForm({
           </Field>
         </div>
       </div>
+      <Controller
+        control={control}
+        name="models"
+        render={({ field }) => (
+          <ModelSelection
+            disabled={busy}
+            onChange={field.onChange}
+            onFetch={fetchModels}
+            selected={field.value}
+          />
+        )}
+      />
       <div className="flex justify-end pt-1">
         <Button type="submit" size="sm" disabled={busy || isSubmitting}>
           {account === undefined ? t('form.submit') : t('form.save')}
diff --git a/packages/client/workbench/src/settings/providers/model-selection.tsx b/packages/client/workbench/src/settings/providers/model-selection.tsx
new file mode 100644
index 00000000..35d12daf
--- /dev/null
+++ b/packages/client/workbench/src/settings/providers/model-selection.tsx
@@ -0,0 +1,180 @@
+import type { AccountModel, AccountSecret, AgentKind } from '@linkcode/schema';
+import { getAgentCatalog, probeAccountModels } from '@linkcode/sdk';
+import { AGENT_MODEL_OPTIONS } from '@linkcode/ui';
+import { Button } from 'coss-ui/components/button';
+import { Checkbox } from 'coss-ui/components/checkbox';
+import { Input } from 'coss-ui/components/input';
+import { extractErrorMessage } from 'foxts/extract-error-message';
+import { PlusIcon, RefreshCwIcon } from 'lucide-react';
+import { useState } from 'react';
+import { useTranslations } from 'use-intl';
+import { useMutation } from '../../runtime/tayori';
+
+/**
+ * The account's model set: the ids its pickers will offer, and the only ones its sessions can run
+ * on. Fetching is the caller's business — a catalog service is read from its own model list, a
+ * subscription from the agent's start catalog, and an endpoint that lists nothing stays freeform.
+ */
+export interface ModelSelectionProps {
+  /** Read the ids this account can offer. Absent when nothing can list them. */
+  onFetch?: () => Promise<AccountModel[]>;
+  selected: AccountModel[];
+  onChange: (models: AccountModel[]) => void;
+  disabled?: boolean;
+}
+
+/**
+ * Where the account forms read model ids from. The forms take these as a prop rather than calling
+ * the data plane themselves: they are presentation, and only the settings page sits inside the
+ * provider tree. Absent sources mean nothing can list, so every set is freeform.
+ */
+export interface ModelSources {
+  /** Probe a catalog service with a secret the form has not saved yet. */
+  probeInline: (service: string, secret: AccountSecret) => Promise<AccountModel[]>;
+  /** Probe a saved account by id, leaving its stored secret on the daemon side. */
+  probeAccount: (service: string, accountId: string) => Promise<AccountModel[]>;
+  /** A subscription login holds no secret to probe with: codex enumerates its own models through
+   * the start catalog, and claude-code has no enumeration API at all so the curated table stands
+   * in for one. */
+  oauth: (agent: AgentKind) => Promise<AccountModel[]>;
+}
+
+export function useModelSources(): ModelSources {
+  const probe = useMutation(probeAccountModels);
+  const fetchCatalog = useMutation(getAgentCatalog);
+  return {
+    probeInline: (service, secret) =>
+      probe.trigger({ service, credential: { type: 'inline', secret } }),
+    probeAccount: (service, accountId) =>
+      probe.trigger({ service, credential: { type: 'account', accountId } }),
+    async oauth(agent) {
+      if (agent === 'claude-code') {
+        return (AGENT_MODEL_OPTIONS[agent] ?? []).map(({ id, label }) => ({ id, label }));
+      }
+      const { models } = await fetchCatalog.trigger({ agentKind: agent });
+      return models.map(({ id, label }) => ({ id, label }));
+    },
+  };
+}
+
+/** Fetched ids plus any already-picked id the fetch did not return — a freeform entry, or one the
+ * vendor has since retired. Dropping the latter would silently unpick a working model. */
+function rows(fetched: AccountModel[], selected: AccountModel[]): AccountModel[] {
+  const known = new Set(fetched.map(({ id }) => id));
+  return [...fetched, ...selected.filter(({ id }) => !known.has(id))];
+}
+
+export function ModelSelection({
+  onFetch,
+  selected,
+  onChange,
+  disabled = false,
+}: ModelSelectionProps): React.ReactNode {
+  const t = useTranslations('settings.providers');
+  const [fetched, setFetched] = useState<AccountModel[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | undefined>(undefined);
+  const [draft, setDraft] = useState('');
+
+  const picked = new Set(selected.map(({ id }) => id));
+  const listed = rows(fetched, selected);
+
+  const refresh = async (): Promise<void> => {
+    if (!onFetch) return;
+    setLoading(true);
+    setError(undefined);
+    try {
+      setFetched(await onFetch());
+    } catch (error_) {
+      // The vendor's own reason (bad key, unreachable host) is the whole value of the failure.
+      setError(extractErrorMessage(error_, false) ?? t('models.fetchFailed'));
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const toggle = (model: AccountModel, next: boolean): void => {
+    onChange(
+      next ? [...selected, model] : selected.filter((candidate) => candidate.id !== model.id),
+    );
+  };
+
+  const addDraft = (): void => {
+    const id = draft.trim();
+    if (!id || picked.has(id)) return;
+    onChange([...selected, { id }]);
+    setDraft('');
+  };
+
+  return (
+    <div className="flex flex-col gap-2">
+      <div className="flex items-center justify-between gap-2">
+        <span className="font-medium text-sm">{t('models.label')}</span>
+        {onFetch ? (
+          <Button
+            type="button"
+            size="sm"
+            variant="outline"
+            disabled={disabled || loading}
+            onClick={() => {
+              void refresh();
+            }}
+          >
+            <RefreshCwIcon className={loading ? 'size-4 animate-spin' : 'size-4'} />
+            {t('models.refresh')}
+          </Button>
+        ) : null}
+      </div>
+      <p className="text-muted-foreground text-xs">
+        {onFetch ? t('models.hint') : t('models.hintUnlistable')}
+      </p>
+      {error !== undefined ? <p className="text-destructive text-xs">{error}</p> : null}
+      {listed.length > 0 ? (
+        <div className="flex max-h-56 flex-col gap-1 overflow-y-auto rounded-lg border border-border p-2">
+          {listed.map((model) => (
+            <label
+              className="flex min-w-0 items-center gap-2 rounded-md px-1.5 py-(--density-row-py) hover:bg-muted/50"
+              key={model.id}
+            >
+              <Checkbox
+                checked={picked.has(model.id)}
+                disabled={disabled}
+                onCheckedChange={(next) => toggle(model, next)}
+              />
+              <span className="min-w-0 flex-1 truncate font-mono text-xs">{model.id}</span>
+              {model.label !== undefined ? (
+                <span className="shrink-0 text-label-tertiary text-xs">{model.label}</span>
+              ) : null}
+            </label>
+          ))}
+        </div>
+      ) : null}
+      <div className="flex gap-2">
+        <Input
+          autoComplete="off"
+          className="flex-1"
+          disabled={disabled}
+          onChange={(event) => setDraft(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key !== 'Enter') return;
+            // Enter here adds an id; letting it bubble would submit the whole account form.
+            event.preventDefault();
+            addDraft();
+          }}
+          placeholder={t('models.addPlaceholder')}
+          value={draft}
+        />
+        <Button
+          type="button"
+          size="sm"
+          variant="outline"
+          disabled={disabled || draft.trim() === ''}
+          onClick={addDraft}
+        >
+          <PlusIcon className="size-4" />
+          {t('models.add')}
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/packages/client/workbench/src/settings/providers/providers-settings.tsx b/packages/client/workbench/src/settings/providers/providers-settings.tsx
index 98955b5b..b029e38f 100644
--- a/packages/client/workbench/src/settings/providers/providers-settings.tsx
+++ b/packages/client/workbench/src/settings/providers/providers-settings.tsx
@@ -21,6 +21,7 @@ import { useAgentRuntimes } from '../../agent-runtime/hooks';
 import { useAgentRuntimeOnboarding } from '../../agent-runtime/onboarding';
 import { useData, useMutation } from '../../runtime/tayori';
 import { AddAccountForm, EditAccountForm, oauthAccount, ServiceCatalogView } from './add-flow';
+import { useModelSources } from './model-selection';
 import { useProvidersSettingsStore } from './store';
 import {
   providerAccountDetailViewModel,
@@ -48,6 +49,8 @@ export function ProvidersSettingsPanel(): React.ReactNode {
   const bindAccount = useMutation(createAndBindAccount);
   const saveAccounts = useMutation(setAccounts);
   const saveProviders = useMutation(setProviderConfig);
+  // The forms are presentation; only this page sits inside the data-plane provider tree.
+  const modelSources = useModelSources();
 
   const view = useProvidersSettingsStore((state) => state.view);
   const select = useProvidersSettingsStore((state) => state.select);
@@ -169,6 +172,7 @@ export function ProvidersSettingsPanel(): React.ReactNode {
                 {view.kind === 'add-form' ? (
                   <AddAccountForm
                     serviceId={view.service}
+                    sources={modelSources}
                     runtimes={runtimes}
                     onboarding={onboarding}
                     busy={busy}
@@ -184,6 +188,7 @@ export function ProvidersSettingsPanel(): React.ReactNode {
                   view.editing ? (
                     <EditAccountForm
                       account={selected}
+                      sources={modelSources}
                       busy={saveAccounts.isMutating}
                       onBack={backToAccount}
                       onSubmit={(account) => {
diff --git a/packages/presentation/i18n/src/locales/en.ts b/packages/presentation/i18n/src/locales/en.ts
index 9ddcecb9..5faf0e3f 100644
--- a/packages/presentation/i18n/src/locales/en.ts
+++ b/packages/presentation/i18n/src/locales/en.ts
@@ -1025,7 +1025,17 @@ export const en = {
       copySecret: 'Copy',
       endpoint: 'Endpoint',
       protocols: 'Protocol shapes',
-      accountModel: 'Default model',
+      accountModel: 'Models',
+      models: {
+        label: 'Models',
+        hint: 'Fetch this service’s model list and tick the ones you want; only ticked models are offered in the composer.',
+        hintUnlistable: 'This endpoint serves no model list — add model ids by hand.',
+        refresh: 'Fetch list',
+        fetchFailed: 'Could not read the model list',
+        secretFirst: 'Enter the key first, then fetch the model list',
+        add: 'Add',
+        addPlaceholder: 'Add a model id by hand',
+      },
       loginState: 'Login',
       loggedIn: 'Signed in',
       loggedOut: 'Signed out',
diff --git a/packages/presentation/i18n/src/locales/zh-cn.ts b/packages/presentation/i18n/src/locales/zh-cn.ts
index 6978c123..3f88e8cb 100644
--- a/packages/presentation/i18n/src/locales/zh-cn.ts
+++ b/packages/presentation/i18n/src/locales/zh-cn.ts
@@ -999,7 +999,17 @@ export const zhCN = {
       copySecret: '复制',
       endpoint: '端点',
       protocols: '协议形态',
-      accountModel: '默认模型',
+      accountModel: '可用模型',
+      models: {
+        label: '可用模型',
+        hint: '获取该服务的模型列表后勾选；只有勾选的模型会出现在输入框的模型选择里。',
+        hintUnlistable: '该端点不提供模型列表，请手动填写模型 ID。',
+        refresh: '获取列表',
+        fetchFailed: '获取模型列表失败',
+        secretFirst: '请先填写密钥，再获取模型列表',
+        add: '添加',
+        addPlaceholder: '手动添加模型 ID',
+      },
       loginState: '登录状态',
       loggedIn: '已登录',
       loggedOut: '未登录',

From c430eba824b1d610cff0f8cf530baf9822219921 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 20:17:14 +0800
Subject: [PATCH 05/17] feat(workbench,ui): offer only the bound account's
 models, and refuse to send without one

The composer and the new-session surface now read the set picked on the agent's
bound account, which outranks both the adapter-advertised catalog and the curated
table: a claude-code account pointing at DeepSeek stops offering Anthropic ids it
cannot reach.

Present-but-empty and absent mean different things in that set, and the send gate
turns on the difference. An account bound with nothing picked blocks sending,
matching the daemon's own refusal instead of discovering it a round trip later.
An agent with no account bound is absent, still resolves its own model, and is
not blocked.

AGENT_DEFAULT_MODELS is gone: guessing a provider's model is exactly what the
picked set replaces, and an unresolved model now blocks the send rather than
silently starting on a vendor default. Rebinding an agent drops a pick the new
account does not list, since keeping it would run the next session on a model
that account never offered.
---
 .../src/renderer/src/shell/desktop-shell.tsx  |  3 +
 .../__tests__/default-models.test.ts          | 51 +++++++++++++++-
 .../settings/providers/__tests__/view.test.ts | 23 ++++++++
 .../src/settings/providers/default-models.ts  | 36 ++++++++++-
 .../settings/providers/providers-settings.tsx |  2 +-
 .../workbench/src/settings/providers/view.ts  | 18 +++++-
 .../workbench/src/surface/workbench.tsx       |  7 ++-
 .../__tests__/new-session-surface.test.tsx    | 59 +++++++++++++++++++
 .../presentation/ui/src/shell/agent-models.ts |  8 ---
 .../ui/src/shell/conversation-surface.tsx     | 16 ++++-
 .../ui/src/shell/new-session-surface.tsx      | 33 +++++++----
 .../presentation/ui/src/shell/shell-frame.tsx |  7 +++
 12 files changed, 234 insertions(+), 29 deletions(-)

diff --git a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
index f7722673..e266b09d 100644
--- a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
+++ b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
@@ -80,6 +80,7 @@ export function DesktopShell({
   attachmentSupport,
   agentCatalogs,
   newSessionDefaultModels,
+  accountModels,
   newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
@@ -429,6 +430,7 @@ export function DesktopShell({
           attachmentSupport={attachmentSupport}
           agentCatalogs={agentCatalogs}
           defaultModels={newSessionDefaultModels}
+          accountModels={accountModels}
           preferredModels={newSessionPreferredModels}
           preferredEfforts={newSessionPreferredEfforts}
           preferredBranches={newSessionPreferredBranches}
@@ -453,6 +455,7 @@ export function DesktopShell({
           composer={conversationComposer}
           agentKind={active?.kind}
           agentLabel={agentLabel}
+          accountModels={active ? accountModels?.[active.kind] : undefined}
           attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
           cwd={active?.cwd}
           runtimeCues={runtimeCues}
diff --git a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
index 88bef1cb..49a62362 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
@@ -4,7 +4,12 @@ import type { Accounts, ProvidersConfig } from '@linkcode/schema';
 import { getProviderConfig } from '@linkcode/sdk';
 import { cleanup, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { configuredDefaultModels, useConfiguredDefaultModels } from '../default-models';
+import {
+  accountModelOptions,
+  configuredDefaultModels,
+  useAccountModelOptions,
+  useConfiguredDefaultModels,
+} from '../default-models';
 
 const { useDataMock } = vi.hoisted(() => ({ useDataMock: vi.fn() }));
 
@@ -47,3 +52,47 @@ describe('configuredDefaultModels', () => {
     expect(result.current).toEqual({});
   });
 });
+
+describe('accountModelOptions', () => {
+  it('distinguishes a bound agent with nothing picked from one with no account at all', () => {
+    const providers = {
+      codex: { enabled: true, activeAccountId: 'acc_1' },
+      'claude-code': { enabled: true, activeAccountId: 'acc_2' },
+      // No account bound: absent, so its pickers fall through and its sends are not blocked.
+      opencode: { enabled: true },
+    } satisfies ProvidersConfig;
+    const accounts = [
+      {
+        id: 'acc_1',
+        label: 'Picked',
+        credential: { type: 'api-key', key: 'k' },
+        models: [{ id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' }, { id: 'deepseek-v4-flash' }],
+        createdAt: 0,
+      },
+      { id: 'acc_2', label: 'Unpicked', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+    ] satisfies Accounts;
+
+    expect(accountModelOptions(providers, accounts)).toEqual({
+      codex: [
+        { id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' },
+        // A relay ships bare ids; the id doubles as the label rather than rendering blank.
+        { id: 'deepseek-v4-flash', label: 'deepseek-v4-flash' },
+      ],
+      'claude-code': [],
+    });
+  });
+
+  it('stays unresolved until both sources have loaded', () => {
+    const { result, rerender } = renderHook(() => useAccountModelOptions());
+
+    expect(result.current).toBeNull();
+
+    providersData = {};
+    rerender();
+    expect(result.current).toBeNull();
+
+    accountsData = [];
+    rerender();
+    expect(result.current).toEqual({});
+  });
+});
diff --git a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
index a748f139..50a0680f 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
@@ -32,6 +32,29 @@ describe('binding transforms', () => {
     expect(next['claude-code']).toEqual({ enabled: true, model: 'claude-opus-4-8' });
   });
 
+  it('drops a pick the newly bound account does not offer, and keeps one it does', () => {
+    const offers = (id: string, models: string[]): Accounts[number] => ({
+      id,
+      label: id,
+      credential: { type: 'api-key', key: 'k' },
+      models: models.map((model) => ({ id: model })),
+      createdAt: 0,
+    });
+    const pool = [offers('acc_keep', ['claude-opus-4-8']), offers('acc_drop', ['deepseek-v4-pro'])];
+
+    // Rebinding to an account that lists the pick leaves it alone.
+    expect(withBinding(providers, 'claude-code', 'acc_keep', pool)['claude-code']).toEqual({
+      enabled: true,
+      activeAccountId: 'acc_keep',
+      model: 'claude-opus-4-8',
+    });
+    // One that does not would otherwise start the next session on a model it never listed.
+    expect(withBinding(providers, 'claude-code', 'acc_drop', pool)['claude-code']).toEqual({
+      enabled: true,
+      activeAccountId: 'acc_drop',
+    });
+  });
+
   it('sets and clears the default model without touching the binding', () => {
     expect(withModel(providers, 'claude-code', 'claude-sonnet-5')['claude-code']).toEqual({
       enabled: true,
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index 872965c4..a8875e3c 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -1,6 +1,6 @@
-import type { AgentKind, ProvidersConfig } from '@linkcode/schema';
+import type { Accounts, AgentKind, AgentModelOption, ProvidersConfig } from '@linkcode/schema';
 import { AgentKindSchema } from '@linkcode/schema';
-import { getProviderConfig } from '@linkcode/sdk';
+import { getAccounts, getProviderConfig } from '@linkcode/sdk';
 import { useData } from '../../runtime/tayori';
 
 /** The model each agent currently runs on, as session start resolves it: the agent's persisted pick.
@@ -23,3 +23,35 @@ export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>>
   if (providers === undefined) return null;
   return configuredDefaultModels(providers);
 }
+
+/**
+ * The models each agent may be switched to: the set picked on its bound account, and nothing else.
+ *
+ * Present-but-empty and absent mean different things, and callers rely on the difference. An entry
+ * exists for every agent with an account bound, so `[]` says "bound, nothing picked yet" and blocks
+ * sends the way the daemon does. Absent says "no account bound", where the agent still resolves its
+ * own model — so its pickers fall through to the adapter catalog or the curated table, and nothing
+ * blocks.
+ */
+export function accountModelOptions(
+  providers: ProvidersConfig | undefined,
+  accounts: Accounts | undefined,
+): Partial<Record<AgentKind, AgentModelOption[]>> {
+  const options: Partial<Record<AgentKind, AgentModelOption[]>> = {};
+  for (const kind of AgentKindSchema.options) {
+    const accountId = providers?.[kind]?.activeAccountId;
+    if (accountId === undefined) continue;
+    const models = accounts?.find((candidate) => candidate.id === accountId)?.models ?? [];
+    options[kind] = models.map(({ id, label }) => ({ id, label: label ?? id }));
+  }
+  return options;
+}
+
+/** `null` until both daemon-owned sources have loaded, so a picker never briefly offers a set the
+ * account does not actually have. */
+export function useAccountModelOptions(): Partial<Record<AgentKind, AgentModelOption[]>> | null {
+  const { data: providers } = useData(getProviderConfig, {});
+  const { data: accounts } = useData(getAccounts, {});
+  if (providers === undefined || accounts === undefined) return null;
+  return accountModelOptions(providers, accounts);
+}
diff --git a/packages/client/workbench/src/settings/providers/providers-settings.tsx b/packages/client/workbench/src/settings/providers/providers-settings.tsx
index b029e38f..fb33dc49 100644
--- a/packages/client/workbench/src/settings/providers/providers-settings.tsx
+++ b/packages/client/workbench/src/settings/providers/providers-settings.tsx
@@ -77,7 +77,7 @@ export function ProvidersSettingsPanel(): React.ReactNode {
   };
 
   const handleSetBinding = (kind: AgentKind, accountId: string | undefined): void => {
-    void applyProviders(withBinding(providers ?? {}, kind, accountId));
+    void applyProviders(withBinding(providers ?? {}, kind, accountId, pool));
   };
 
   const handleSetModel = (kind: AgentKind, model: string | undefined): void => {
diff --git a/packages/client/workbench/src/settings/providers/view.ts b/packages/client/workbench/src/settings/providers/view.ts
index e36e6da4..271641d4 100644
--- a/packages/client/workbench/src/settings/providers/view.ts
+++ b/packages/client/workbench/src/settings/providers/view.ts
@@ -219,18 +219,32 @@ export function providerAccountListViewModel(
   };
 }
 
-/** Bind (or, with undefined, unbind) an agent's active account; other fields survive untouched. */
+/**
+ * Bind (or, with undefined, unbind) an agent's active account; other fields survive untouched — with
+ * one exception. The pick lives per agent while the set it came from lives on the account, so a
+ * rebind can orphan it. Dropping a pick the new account does not offer leaves the agent unpicked,
+ * which blocks its sends until the user chooses again; keeping it would run the next session on a
+ * model that account never listed.
+ */
 export function withBinding(
   providers: ProvidersConfig,
   kind: AgentKind,
   accountId: string | undefined,
+  accounts: Accounts = [],
 ): ProvidersConfig {
   const entry = providers[kind] ?? { enabled: true };
   if (accountId === undefined) {
     const { activeAccountId: _cleared, ...rest } = entry;
     return { ...providers, [kind]: rest };
   }
-  return { ...providers, [kind]: { ...entry, activeAccountId: accountId } };
+  const offered = accounts.find((candidate) => candidate.id === accountId)?.models;
+  const orphaned =
+    entry.model !== undefined && !(offered ?? []).some(({ id }) => id === entry.model);
+  const { model: _dropped, ...kept } = entry;
+  return {
+    ...providers,
+    [kind]: { ...(orphaned ? kept : entry), activeAccountId: accountId },
+  };
 }
 
 /** Toggle whether the agent is offered in the client's agent picker. */
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index fd1e18da..92f900e8 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -57,7 +57,10 @@ import { WorkbenchCommandPalette } from '../palette/command-palette';
 import { openCommandPalette } from '../palette/store';
 import { useWorkbenchSdkClient } from '../runtime/provider';
 import { useMutation } from '../runtime/tayori';
-import { useConfiguredDefaultModels } from '../settings/providers/default-models';
+import {
+  useAccountModelOptions,
+  useConfiguredDefaultModels,
+} from '../settings/providers/default-models';
 import { RuntimeBranchStatus } from '../sidebar/branch-status';
 import { useSidebarGroupCollapseStore } from '../sidebar/collapse-store';
 import { useSidebarOrderStore } from '../sidebar/order-store';
@@ -241,6 +244,7 @@ function WorkbenchSessionSurface({
   const currentPlan: CurrentPlan | null = selectCurrentPlan(conversation);
   const { mentionItems, onMentionQueryChange } = useFileMentionSource();
   const newSessionDefaultModels = useConfiguredDefaultModels();
+  const accountModels = useAccountModelOptions();
   const sdkClient = useWorkbenchSdkClient();
   const activeSessionId = sessions.activeId;
   // Announce observation of the focused session so the daemon replays buffered per-session state
@@ -651,6 +655,7 @@ function WorkbenchSessionSurface({
       newSessionWorkspaceId={newSessionWorkspaceId}
       onNewSessionWorkspaceChange={handleNewSessionWorkspaceChange}
       newSessionDefaultModels={newSessionDefaultModels}
+      accountModels={accountModels}
       agentCatalogs={agentCatalogs}
       newSessionPreferredModels={newSessionPreferredModels}
       newSessionPreferredEfforts={newSessionPreferredEfforts}
diff --git a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
index 8da5b65f..d81840f9 100644
--- a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
+++ b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
@@ -4,6 +4,7 @@ import type { AgentStartCatalog } from '@linkcode/schema';
 import { WorkspaceIdSchema } from '@linkcode/schema';
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { wait } from 'foxts/wait';
 import { useState } from 'react';
 import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 import type { NewSessionBranchPickerComponentProps } from '../new-session-branch-picker';
@@ -43,6 +44,7 @@ const PROJECT_WORKSPACE = {
 };
 const RE_MODEL_DEFAULT = /modelDefault/;
 const RE_SONNET_5 = /Sonnet 5/;
+const RE_DEEPSEEK_PRO = /DeepSeek V4 Pro/;
 const RE_CONFIGURED_CLAUDE_MODEL = /configured\/claude-model/;
 const RE_OPUS_4_8 = /Opus 4.8/;
 const RE_MEDIUM_EFFORT = /Medium/;
@@ -284,6 +286,8 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
+        // Nothing guesses a model any more, so the configured one has to be supplied.
+        defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
         draft={{ initialProvider: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
@@ -564,6 +568,8 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
+        // Nothing guesses a model any more, so the configured one has to be supplied.
+        defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
         draft={{
           initialProvider: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
@@ -806,12 +812,65 @@ describe('NewSessionSurface', () => {
     expect(submitted?.model).toBeUndefined();
   });
 
+  it("offers only the bound account's picked models, ignoring the curated table", async () => {
+    const user = userEvent.setup();
+    render(
+      <NewSessionSurface
+        accountModels={{ 'claude-code': [{ id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' }] }}
+        chatWorkspace={CHAT_WORKSPACE}
+        defaultModels={{ 'claude-code': 'deepseek-v4-pro' }}
+        draft={{
+          initialProvider: 'claude-code',
+          initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
+        }}
+        mentionItems={[]}
+        onMentionQueryChange={vi.fn()}
+        onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
+        onSubmit={vi.fn().mockResolvedValue(undefined)}
+        workspaces={[]}
+      />,
+    );
+
+    await user.click(screen.getByRole('button', { name: RE_DEEPSEEK_PRO }));
+    await user.click(await screen.findByRole('menuitem', { name: RE_DEEPSEEK_PRO }));
+    expect(await screen.findByRole('menuitemradio', { name: 'DeepSeek V4 Pro' })).toBeTruthy();
+    // The curated Anthropic table would otherwise supply these for claude-code.
+    expect(screen.queryByRole('menuitemradio', { name: 'Opus 5' })).toBeNull();
+  });
+
+  it('refuses to send when an account is bound but no model is picked', async () => {
+    const onSubmit = vi.fn().mockResolvedValue(undefined);
+    render(
+      <NewSessionSurface
+        // Bound with an empty set: the daemon would refuse this start, so the composer does too.
+        accountModels={{ 'claude-code': [] }}
+        chatWorkspace={CHAT_WORKSPACE}
+        draft={{
+          initialProvider: 'claude-code',
+          initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
+        }}
+        mentionItems={[]}
+        onMentionQueryChange={vi.fn()}
+        onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
+        onSubmit={onSubmit}
+        workspaces={[]}
+      />,
+    );
+
+    typeInComposer('hello');
+    await pressInComposer('Enter');
+    await wait(0);
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+
   it('submits a model only after the user explicitly selects it', async () => {
     const user = userEvent.setup();
     const onSubmit = vi.fn().mockResolvedValue(undefined);
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
+        // Nothing guesses a model any more, so the configured one has to be supplied.
+        defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
         draft={{
           initialProvider: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
diff --git a/packages/presentation/ui/src/shell/agent-models.ts b/packages/presentation/ui/src/shell/agent-models.ts
index 62be173a..48f3f790 100644
--- a/packages/presentation/ui/src/shell/agent-models.ts
+++ b/packages/presentation/ui/src/shell/agent-models.ts
@@ -56,14 +56,6 @@ export function resolveModel(
   );
 }
 
-/** Verified provider defaults used before a session exists to reflect its served model. A saved
- * account/provider default supplied by the workbench takes precedence over these values. */
-export const AGENT_DEFAULT_MODELS: Readonly<Partial<Record<AgentKind, string>>> = {
-  'claude-code': 'claude-sonnet-5',
-  codex: 'gpt-5.6-sol',
-  'grok-build': 'grok-4.5',
-};
-
 const CODEX_BASE_EFFORTS = ['low', 'medium', 'high', 'xhigh'] satisfies EffortLevel[];
 
 /**
diff --git a/packages/presentation/ui/src/shell/conversation-surface.tsx b/packages/presentation/ui/src/shell/conversation-surface.tsx
index af94c9b5..1a7d2ef3 100644
--- a/packages/presentation/ui/src/shell/conversation-surface.tsx
+++ b/packages/presentation/ui/src/shell/conversation-surface.tsx
@@ -1,4 +1,10 @@
-import type { AgentKind, ContentBlock, EffortLevel, QuestionOutcome } from '@linkcode/schema';
+import type {
+  AgentKind,
+  AgentModelOption,
+  ContentBlock,
+  EffortLevel,
+  QuestionOutcome,
+} from '@linkcode/schema';
 import { useRef } from 'react';
 import type { StickToBottomContext } from 'use-stick-to-bottom';
 import { ArtifactHostActionsProvider } from '../chat/artifacts/context';
@@ -32,6 +38,9 @@ export interface ConversationSurfaceProps {
   composer: ConversationComposerController;
   agentKind?: AgentKind;
   agentLabel?: string;
+  /** The models picked on this agent's bound account — the only ones it may switch to. Absent means
+   * no account is bound, so the adapter catalog or the curated table supplies the choices instead. */
+  accountModels?: AgentModelOption[];
   /** Frontend capability stub used until attachment support is advertised by the session. */
   attachmentsSupported?: boolean;
   cwd?: string;
@@ -85,6 +94,7 @@ export function ConversationSurface({
   conversation,
   composer,
   agentKind,
+  accountModels,
   agentLabel,
   attachmentsSupported = false,
   cwd,
@@ -183,7 +193,9 @@ export function ConversationSurface({
           approvalPolicy={conversation.approvalPolicy}
           currentModel={conversation.currentModel}
           currentEffort={conversation.currentEffort}
-          agentModels={conversation.availableModels}
+          // The account's picked set is the user's own answer to "which models may this run on",
+          // so it outranks both the adapter catalog and the curated table.
+          agentModels={accountModels ?? conversation.availableModels}
           directiveControls={composer.directiveControls}
           onSend={composer.onSend}
           // Scrolls at submit, not acceptance: the jump must feel tied to pressing send, and a
diff --git a/packages/presentation/ui/src/shell/new-session-surface.tsx b/packages/presentation/ui/src/shell/new-session-surface.tsx
index f73fca2f..9a4bdd63 100644
--- a/packages/presentation/ui/src/shell/new-session-surface.tsx
+++ b/packages/presentation/ui/src/shell/new-session-surface.tsx
@@ -1,6 +1,7 @@
 import type {
   AgentInput,
   AgentKind,
+  AgentModelOption,
   AgentStartCatalog,
   BranchMode,
   BranchSelection,
@@ -35,7 +36,7 @@ import { useTranslations } from 'use-intl';
 import { AGENT_LABELS } from '../chat/agent-icon';
 import { cn } from '../lib/cn';
 import { repositoryLabel } from '../repository-label';
-import { AGENT_DEFAULT_MODELS, AGENT_MODEL_OPTIONS, resolveModel } from './agent-models';
+import { AGENT_MODEL_OPTIONS, resolveModel } from './agent-models';
 import type { AgentRuntimeCues } from './agent-onboarding-card';
 import { AgentOnboardingCard } from './agent-onboarding-card';
 import type { ComposerDirectiveControls, MentionItem } from './composer';
@@ -89,6 +90,9 @@ export interface NewSessionSurfaceProps {
   /** Effective user-configured model defaults. `null` means they are still loading; when omitted,
    * built-in provider defaults fill missing kinds for standalone consumers. */
   defaultModels?: Readonly<Partial<Record<AgentKind, string>>> | null;
+  /** The models each agent may run on, picked on its bound account. An agent absent here has no
+   * account bound and falls back to its adapter catalog or the curated table. */
+  accountModels?: Readonly<Partial<Record<AgentKind, AgentModelOption[]>>> | null;
   /** Last accepted model per provider. Unlike configured defaults, this is an explicit override. */
   preferredModels?: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last accepted effort per provider. Missing kinds retain the provider default. */
@@ -144,6 +148,7 @@ export function NewSessionSurface({
   attachmentSupport,
   agentCatalogs,
   defaultModels,
+  accountModels,
   preferredModels,
   preferredEfforts,
   preferredBranches,
@@ -182,20 +187,21 @@ export function NewSessionSurface({
   const localModel = selectedModels[provider];
   const selectedModel =
     localModel === undefined ? (preferredModels?.[provider] ?? null) : localModel;
-  // The catalog default is what the agent's own config would start on, so it outranks the built-in
-  // guess but yields to anything the user expressed through LinkCode.
+  // The catalog default is what the agent's own config would start on, so it yields to anything the
+  // user expressed through LinkCode. Nothing guesses past it: an unresolved model blocks the send
+  // rather than starting a session on a model nobody chose.
   const displayedModel =
     selectedModel ??
-    (defaultModels === null
-      ? null
-      : (defaultModels?.[provider] ??
-        catalog?.defaultModel ??
-        AGENT_DEFAULT_MODELS[provider] ??
-        null));
+    (defaultModels === null ? null : (defaultModels?.[provider] ?? catalog?.defaultModel ?? null));
   const localEffort = selectedEfforts[provider];
   const effort = localEffort === undefined ? (preferredEfforts?.[provider] ?? null) : localEffort;
   const dynamicModels = catalog && catalog.models.length > 0 ? catalog.models : null;
-  const modelOption = resolveModel(dynamicModels ?? AGENT_MODEL_OPTIONS[provider], displayedModel);
+  // The account's picked set is the user's own answer to which models this agent may run on, so it
+  // outranks the adapter catalog and the curated table both. An entry present here means an account
+  // is bound, which is also what makes a missing model fatal rather than the agent's own business.
+  const boundSet = accountModels?.[provider];
+  const pickable = boundSet ?? dynamicModels ?? AGENT_MODEL_OPTIONS[provider];
+  const modelOption = resolveModel(pickable, displayedModel);
   const effortLevels = modelOption?.effortLevels;
   const constrainedEffort =
     effortLevels === undefined || effortLevels.includes(effort ?? 'low') ? effort : null;
@@ -358,11 +364,14 @@ export function NewSessionSurface({
             mentionItems={mentionItems}
             onMentionQueryChange={(query) => onMentionQueryChange(selected?.cwd, query)}
             runtimeCues={runtimeCues}
-            sendBlocked={cue !== undefined}
+            // With an account bound, its set is the only model source, so an unresolved model would
+            // be refused by the daemon anyway — refuse here instead of after a round trip. An agent
+            // with no account bound still resolves its own, and must not be blocked.
+            sendBlocked={cue !== undefined || (boundSet !== undefined && displayedModel === null)}
             currentModeId={modeId}
             currentModel={displayedModel}
             currentEffort={displayedEffort}
-            agentModels={dynamicModels}
+            agentModels={pickable ?? null}
             approvalPolicy={approvalPolicy}
             approvalPolicyPlaceholder={t('permissionMode')}
             selectableProviders={SELECTABLE_PROVIDERS}
diff --git a/packages/presentation/ui/src/shell/shell-frame.tsx b/packages/presentation/ui/src/shell/shell-frame.tsx
index 5b3dc521..08f3f4cd 100644
--- a/packages/presentation/ui/src/shell/shell-frame.tsx
+++ b/packages/presentation/ui/src/shell/shell-frame.tsx
@@ -1,5 +1,6 @@
 import type {
   AgentKind,
+  AgentModelOption,
   BranchSelection,
   ContentBlock,
   EffortLevel,
@@ -57,6 +58,9 @@ export interface ShellFrameProps
   agentCatalogs?: AgentStartCatalogs;
   /** Effective daemon-configured default models for new sessions; null while unresolved. */
   newSessionDefaultModels: Readonly<Partial<Record<AgentKind, string>>> | null;
+  /** The models each agent may run on, picked on its bound account. An agent absent here has no
+   * account bound and keeps falling back to whatever its adapter or the curated table advertises. */
+  accountModels: Readonly<Partial<Record<AgentKind, AgentModelOption[]>>> | null;
   /** Last model accepted by LinkCode per provider, submitted as a new-session override. */
   newSessionPreferredModels: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last effort accepted by LinkCode per provider for new sessions. */
@@ -131,6 +135,7 @@ export function ShellFrame({
   attachmentSupport,
   agentCatalogs,
   newSessionDefaultModels,
+  accountModels,
   newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
@@ -222,6 +227,7 @@ export function ShellFrame({
             attachmentSupport={attachmentSupport}
             agentCatalogs={agentCatalogs}
             defaultModels={newSessionDefaultModels}
+            accountModels={accountModels}
             preferredModels={newSessionPreferredModels}
             preferredEfforts={newSessionPreferredEfforts}
             preferredBranches={newSessionPreferredBranches}
@@ -243,6 +249,7 @@ export function ShellFrame({
             composer={conversationComposer}
             agentKind={active?.kind}
             agentLabel={active ? active.kind : undefined}
+            accountModels={active ? accountModels?.[active.kind] : undefined}
             attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
             disabled={!active || active.status === 'stopped'}
             isRunning={isRunning}

From c7f4e64737d40eb2bc2bf3acf289e838a817ac1e Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 20:52:09 +0800
Subject: [PATCH 06/17] feat(schema,engine): record which account each session
 run resolved to
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A live session's account is fixed at spawn — credentials and base URL are
injected once — so the client needs to know it to scope that session's model
menu. Nothing recorded it: the resolved account existed only inside
`applyProviderDefaults`.

`accountConfigBundle` now echoes `accountId` into the resolved config, which
`resolveAccount` already reads on the way in, so the same key serves both
directions and a client can pin a session to one account. Each run lifts just
that id into `SessionRun`, and `SessionInfo` reports the latest run's, mirroring
how `historyId` already works — a rebind between runs is legitimate, so only the
newest describes what a session is actually talking to.

Only the id is persisted; the rest of `config` carries secrets.
---
 .../schema/src/model/session/record.ts        |  6 ++
 .../__tests__/engine-agent-catalog.test.ts    |  1 +
 .../__tests__/engine-session-records.test.ts  | 81 +++++++++++++++++++
 .../src/__tests__/provider-config.test.ts     |  8 +-
 .../host/engine/src/agent/provider-config.ts  | 12 ++-
 .../engine/src/session/lifecycle-service.ts   | 18 +++--
 .../src/session/session-record-registry.ts    | 15 +++-
 7 files changed, 132 insertions(+), 9 deletions(-)

diff --git a/packages/foundation/schema/src/model/session/record.ts b/packages/foundation/schema/src/model/session/record.ts
index 0717fdfb..25c0769c 100644
--- a/packages/foundation/schema/src/model/session/record.ts
+++ b/packages/foundation/schema/src/model/session/record.ts
@@ -36,6 +36,9 @@ export type SessionOrigin = z.infer<typeof SessionOriginSchema>;
  * session accumulates runs; `historyId` is backfilled once the adapter reports it (session-ref). */
 export const SessionRunSchema = z.object({
   historyId: AgentHistoryIdSchema.optional(),
+  /** The account this run resolved to. Credentials and base URL are injected once at spawn, so the
+   * account is fixed for the run's lifetime and a later rebind does not move it. */
+  accountId: z.string().min(1).optional(),
   startedAt: TimestampSchema,
   endedAt: TimestampSchema.optional(),
 });
@@ -76,6 +79,9 @@ export const SessionInfoSchema = z.object({
   automation: SessionAutomationSchema.optional(),
   /** Latest run's provider-local history id — the transcript to read this session's past from. */
   historyId: AgentHistoryIdSchema.optional(),
+  /** Latest run's account. The model menu of a live session scopes to it, because the account
+   * cannot change mid-session. */
+  accountId: z.string().min(1).optional(),
   /** Provider-history operations supported by this session's adapter/runtime. */
   historyCapabilities: AgentHistoryCapabilitiesSchema.optional(),
 });
diff --git a/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts b/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
index d587fdec..d8489422 100644
--- a/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
+++ b/packages/host/engine/src/__tests__/engine-agent-catalog.test.ts
@@ -62,6 +62,7 @@ describe('engine agent catalog', () => {
       cwd: '/repo',
       model: 'provider/model',
       config: {
+        accountId: 'catalog-account',
         apiKey: 'catalog-key',
         baseUrl: 'https://catalog.example.test',
         protocol: 'openai-chat',
diff --git a/packages/host/engine/src/__tests__/engine-session-records.test.ts b/packages/host/engine/src/__tests__/engine-session-records.test.ts
index 969706d8..b302b87b 100644
--- a/packages/host/engine/src/__tests__/engine-session-records.test.ts
+++ b/packages/host/engine/src/__tests__/engine-session-records.test.ts
@@ -11,6 +11,7 @@ import type {
 } from '@linkcode/schema';
 import { MessageIdSchema, textBlock } from '@linkcode/schema';
 import { describe, expect, it, vi } from 'vitest';
+import { InMemoryProviderConfigStore } from '../agent/provider-config';
 import type { SessionStore } from '../session/session-store';
 import { InMemorySessionStore } from '../session/session-store';
 import { InMemoryWorkspaceStore } from '../workspace/workspace-store';
@@ -923,3 +924,83 @@ describe('engine session records', () => {
     expect(await inner.load()).toHaveLength(1);
   });
 });
+
+describe('session account attribution', () => {
+  function storeBoundTo(accountId: string, model: string): InMemoryProviderConfigStore {
+    const providers = new InMemoryProviderConfigStore();
+    providers.update({
+      providers: { 'claude-code': { enabled: true, activeAccountId: accountId, model } },
+      accounts: [
+        {
+          id: accountId,
+          label: 'Bound',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-test' },
+          models: [{ id: model }],
+          createdAt: 0,
+        },
+      ],
+    });
+    return providers;
+  }
+
+  it("records the account a run resolved to and reports the latest run's", async () => {
+    const providers = storeBoundTo('acc_bound', 'claude-opus-5');
+    const store = new InMemorySessionStore();
+    const h = harness(store, undefined, undefined, undefined, undefined, providers);
+    await h.engine.start();
+
+    await h.inject({
+      kind: 'session.start',
+      clientReqId: 'r1',
+      opts: { kind: 'claude-code', cwd: '/repo' },
+    });
+    await h.inject({ kind: 'session.list', clientReqId: 'r2' });
+
+    expect(listedSessions(h.sent, 'r2')[0]?.accountId).toBe('acc_bound');
+    // Persisted per run, so a restart still knows what the session is talking to.
+    expect((await store.load())[0].runs[0].accountId).toBe('acc_bound');
+  });
+
+  it('honours an account the client pinned over the bound one', async () => {
+    const providers = storeBoundTo('acc_bound', 'claude-opus-5');
+    const pool = providers.getAccounts();
+    providers.update({
+      accounts: [
+        ...pool,
+        {
+          id: 'acc_pinned',
+          label: 'Pinned',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-other' },
+          models: [{ id: 'claude-sonnet-5' }],
+          createdAt: 0,
+        },
+      ],
+    });
+    const h = harness(
+      new InMemorySessionStore(),
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      providers,
+    );
+    await h.engine.start();
+
+    // This is how picking a model that belongs to another account reaches the daemon.
+    await h.inject({
+      kind: 'session.start',
+      clientReqId: 'r1',
+      opts: {
+        kind: 'claude-code',
+        cwd: '/repo',
+        model: 'claude-sonnet-5',
+        config: { accountId: 'acc_pinned' },
+      },
+    });
+    await h.inject({ kind: 'session.list', clientReqId: 'r2' });
+
+    expect(listedSessions(h.sent, 'r2')[0]?.accountId).toBe('acc_pinned');
+  });
+});
diff --git a/packages/host/engine/src/__tests__/provider-config.test.ts b/packages/host/engine/src/__tests__/provider-config.test.ts
index a4d8ef4c..ce49777f 100644
--- a/packages/host/engine/src/__tests__/provider-config.test.ts
+++ b/packages/host/engine/src/__tests__/provider-config.test.ts
@@ -45,6 +45,7 @@ describe('applyProviderDefaults account pool', () => {
   it('injects the credential from the account bound via activeAccountId', () => {
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'acc_1' } };
     expect(applyProviderDefaults(baseOpts, providers, [account]).options.config).toEqual({
+      accountId: 'acc_1',
       apiKey: 'sk-acc',
     });
   });
@@ -76,6 +77,7 @@ describe('applyProviderDefaults account pool', () => {
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'gw' } };
     const merged = applyProviderDefaults(baseOpts, providers, [gateway]);
     expect(merged.options.config).toEqual({
+      accountId: 'gw',
       authToken: 'or-tok',
       baseUrl: 'https://relay.example.com/v1',
       protocol: 'openai-responses',
@@ -107,6 +109,7 @@ describe('applyProviderDefaults account pool', () => {
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'oa' } };
     // Codex overrides the base URL of its own Responses provider, so it carries no knownProvider.
     expect(applyProviderDefaults(baseOpts, providers, [openai]).options.config).toEqual({
+      accountId: 'oa',
       apiKey: 'sk-oa',
       baseUrl: 'https://api.openai.com/v1',
       protocol: 'openai-responses',
@@ -148,7 +151,10 @@ describe('applyProviderDefaults account pool', () => {
       createdAt: 0,
     };
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'oauth_1' } };
-    expect(applyProviderDefaults(baseOpts, providers, [oauth]).options.config).toEqual({});
+    // The account still resolves — it just contributes no secret, only its id.
+    expect(applyProviderDefaults(baseOpts, providers, [oauth]).options.config).toEqual({
+      accountId: 'oauth_1',
+    });
   });
 });
 
diff --git a/packages/host/engine/src/agent/provider-config.ts b/packages/host/engine/src/agent/provider-config.ts
index 5a53678a..0613d02b 100644
--- a/packages/host/engine/src/agent/provider-config.ts
+++ b/packages/host/engine/src/agent/provider-config.ts
@@ -102,7 +102,9 @@ function accountConfigBundle(
 ): { bundle: Record<string, unknown> } | { unavailable: BindingUnavailableReason } {
   const binding = resolveBinding(account, kind);
   if (binding.tier === 'unavailable') return { unavailable: binding.reason };
-  const bundle: Record<string, unknown> = {};
+  // Echoed back so the caller can record which account a run actually resolved to; `resolveAccount`
+  // reads the same key on the way in, which is how a client pins a session to one account.
+  const bundle: Record<string, unknown> = { accountId: account.id };
   const { credential, extraEnv } = account;
   if (credential.type === 'api-key') bundle.apiKey = credential.key;
   else if (credential.type === 'auth-token') bundle.authToken = credential.token;
@@ -113,6 +115,14 @@ function accountConfigBundle(
   return { bundle };
 }
 
+/** The account a resolved `StartOptions` names — written by `accountConfigBundle`, or pinned by a
+ * client that picked a model belonging to a specific account. Callers record it per run; the rest of
+ * `config` carries secrets and must never be persisted. */
+export function resolvedAccountId(opts: StartOptions): string | undefined {
+  const id = opts.config?.accountId;
+  return typeof id === 'string' && id.length > 0 ? id : undefined;
+}
+
 export interface AppliedProviderDefaults {
   readonly options: StartOptions;
   /** Why the bound account cannot back this agent. A session must refuse to start rather than
diff --git a/packages/host/engine/src/session/lifecycle-service.ts b/packages/host/engine/src/session/lifecycle-service.ts
index 67eb6d78..0ed0ad09 100644
--- a/packages/host/engine/src/session/lifecycle-service.ts
+++ b/packages/host/engine/src/session/lifecycle-service.ts
@@ -13,6 +13,7 @@ import type {
 } from '@linkcode/schema';
 import { Effect, Semaphore } from 'effect';
 import { nullthrow } from 'foxts/guard';
+import { resolvedAccountId } from '../agent/provider-config';
 import type { SessionDriver } from '../automation';
 import type { EngineFailure } from '../failure';
 import { RequestError, toOperationFailure } from '../failure';
@@ -101,7 +102,7 @@ export class SessionLifecycleService {
         createdVia: resolved.createdVia,
         createdAt: now,
         updatedAt: now,
-        runs: [{ startedAt: now }],
+        runs: [{ startedAt: now, ...accountOfRun(resolved) }],
       };
       yield* sessions.startLive(
         replyTo,
@@ -176,7 +177,7 @@ export class SessionLifecycleService {
         origin: { type: 'imported', historyId, importedAt: now },
         createdAt: now,
         updatedAt: now,
-        runs: [{ historyId, startedAt: now }],
+        runs: [{ historyId, startedAt: now, ...accountOfRun(startOptions) }],
       };
       yield* sessions.startLive(
         replyTo,
@@ -252,7 +253,7 @@ export class SessionLifecycleService {
                   liveCursor.contentFingerprint,
                 )
               : branchCursor;
-          records.beginRun(sourceSessionId);
+          records.beginRun(sourceSessionId, resolvedAccountId(startOptions));
           yield* sessions.startLive(
             replyTo,
             source,
@@ -314,7 +315,7 @@ export class SessionLifecycleService {
           } else if (record.cwd) {
             yield* workspaceTouch(workspaces, record.cwd);
           }
-          record.runs.push({ historyId, startedAt: Date.now() });
+          record.runs.push({ historyId, startedAt: Date.now(), ...accountOfRun(startOptions) });
           yield* sessions.startLive(
             replyTo,
             record,
@@ -353,7 +354,7 @@ export class SessionLifecycleService {
         automation: options.automation,
         createdAt: now,
         updatedAt: now,
-        runs: [{ startedAt: now }],
+        runs: [{ startedAt: now, ...accountOfRun(startOptions) }],
       };
       if (startOptions.cwd) yield* workspaceTouch(workspaces, startOptions.cwd);
       yield* sessions.startLive(undefined, record, (adapter) =>
@@ -425,3 +426,10 @@ function workspaceRegisterWorktree(
       }),
   });
 }
+
+/** The run's account, spread into a `SessionRun` so an unresolved one stays absent rather than
+ * writing `undefined` into the record. */
+function accountOfRun(opts: StartOptions): { accountId?: string } {
+  const accountId = resolvedAccountId(opts);
+  return accountId === undefined ? {} : { accountId };
+}
diff --git a/packages/host/engine/src/session/session-record-registry.ts b/packages/host/engine/src/session/session-record-registry.ts
index 39fa3c9f..b3dad8cf 100644
--- a/packages/host/engine/src/session/session-record-registry.ts
+++ b/packages/host/engine/src/session/session-record-registry.ts
@@ -82,6 +82,7 @@ export class SessionRecordRegistry {
       createdVia: record.createdVia,
       automation: record.automation,
       historyId: latestHistoryId(record),
+      accountId: latestAccountId(record),
     }));
   }
 
@@ -137,10 +138,10 @@ export class SessionRecordRegistry {
     this.persist(record);
   }
 
-  beginRun(sessionId: SessionId): void {
+  beginRun(sessionId: SessionId, accountId?: string): void {
     const record = this.records.get(sessionId);
     if (!record) return;
-    record.runs.push({ startedAt: Date.now() });
+    record.runs.push({ startedAt: Date.now(), ...(accountId !== undefined && { accountId }) });
     this.persist(record);
   }
 
@@ -210,6 +211,16 @@ function storeFailure(operation: string, publicMessage: string, cause: unknown):
   return new OperationError({ subsystem: 'store', operation, publicMessage, cause });
 }
 
+/** The account the newest run resolved to. Older runs may name a different one — a rebind between
+ * runs is legitimate — so only the latest describes what a live session is actually talking to. */
+function latestAccountId(record: SessionRecord): string | undefined {
+  for (let index = record.runs.length - 1; index >= 0; index -= 1) {
+    const accountId = record.runs[index].accountId;
+    if (accountId !== undefined) return accountId;
+  }
+  return undefined;
+}
+
 function latestHistoryId(record: SessionRecord): AgentHistoryId | undefined {
   for (let index = record.runs.length - 1; index >= 0; index -= 1) {
     const historyId = record.runs[index].historyId;

From 1608dc43f636de138dc2e6f4d32742c1d40e6381 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 21:13:33 +0800
Subject: [PATCH 07/17] feat(workbench,ui): pick models across every account an
 agent can bind
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The new-session menu now spans every account `resolveBinding` accepts for the
agent, grouped per account, so choosing a model also chooses which account
serves it. One agent reaches several providers without a trip through Settings —
previously the menu showed only the single bound account's set, which made it
offer less than the curated table it replaced.

A live session's menu stays scoped to its own account: credentials and base URL
are injected at spawn, so offering another account's models would advertise a
switch the adapter cannot make.

Model identity becomes (account, model). Two accounts legitimately serve the
same id — a direct DeepSeek key and an OpenRouter one both list
`deepseek-v4-pro` — and the menu previously used the bare id as both its React
key and its radio value, which would collapse the two into one unselectable row.
`modelChoiceKey` keys them apart, the pick hands back the whole entry rather than
a string to re-parse, and `resolveModel` takes an account tiebreak so the trigger
label names the right one.

The chosen account rides `config.accountId`, which `resolveAccount` already
honours ahead of the bound one.
---
 .../src/renderer/src/shell/desktop-shell.tsx  |  4 +-
 .../__tests__/default-models.test.ts          | 98 +++++++++++++------
 .../src/settings/providers/default-models.ts  | 71 ++++++++++----
 .../src/surface/use-workbench-sessions.ts     | 10 +-
 .../workbench/src/surface/workbench.tsx       | 14 ++-
 .../__tests__/new-session-surface.test.tsx    | 54 ++++++++++
 .../presentation/ui/src/shell/agent-models.ts | 23 ++++-
 .../ui/src/shell/composer-controls.tsx        | 38 +++++--
 .../presentation/ui/src/shell/composer.tsx    | 12 ++-
 .../ui/src/shell/conversation-surface.tsx     | 26 ++---
 .../ui/src/shell/new-session-surface.tsx      | 42 +++++---
 .../presentation/ui/src/shell/shell-frame.tsx | 11 ++-
 12 files changed, 310 insertions(+), 93 deletions(-)

diff --git a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
index e266b09d..7c69e7af 100644
--- a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
+++ b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
@@ -81,6 +81,7 @@ export function DesktopShell({
   agentCatalogs,
   newSessionDefaultModels,
   accountModels,
+  sessionModels,
   newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
@@ -455,7 +456,8 @@ export function DesktopShell({
           composer={conversationComposer}
           agentKind={active?.kind}
           agentLabel={agentLabel}
-          accountModels={active ? accountModels?.[active.kind] : undefined}
+          accountModels={sessionModels}
+          accountId={active?.accountId}
           attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
           cwd={active?.cwd}
           runtimeCues={runtimeCues}
diff --git a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
index 49a62362..058421ff 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
@@ -2,10 +2,12 @@
 
 import type { Accounts, ProvidersConfig } from '@linkcode/schema';
 import { getProviderConfig } from '@linkcode/sdk';
+import { modelChoiceKey } from '@linkcode/ui';
 import { cleanup, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   accountModelOptions,
+  accountModelOptionsFor,
   configuredDefaultModels,
   useAccountModelOptions,
   useConfiguredDefaultModels,
@@ -53,42 +55,82 @@ describe('configuredDefaultModels', () => {
   });
 });
 
+const anthropicAccount = {
+  id: 'acc_anthropic',
+  label: 'Anthropic',
+  service: 'anthropic-api',
+  credential: { type: 'api-key', key: 'k' },
+  models: [{ id: 'claude-opus-5', label: 'Opus 5' }],
+  createdAt: 0,
+} satisfies Accounts[number];
+
+const deepseekAccount = {
+  id: 'acc_deepseek',
+  label: 'DeepSeek',
+  service: 'deepseek',
+  credential: { type: 'api-key', key: 'k' },
+  models: [{ id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' }, { id: 'deepseek-v4-flash' }],
+  createdAt: 0,
+} satisfies Accounts[number];
+
 describe('accountModelOptions', () => {
-  it('distinguishes a bound agent with nothing picked from one with no account at all', () => {
-    const providers = {
-      codex: { enabled: true, activeAccountId: 'acc_1' },
-      'claude-code': { enabled: true, activeAccountId: 'acc_2' },
-      // No account bound: absent, so its pickers fall through and its sends are not blocked.
-      opencode: { enabled: true },
-    } satisfies ProvidersConfig;
-    const accounts = [
+  it('spans every account that can back the agent, tagged with the account it came from', () => {
+    const options = accountModelOptions([anthropicAccount, deepseekAccount]);
+
+    // claude-code speaks both: Anthropic natively, DeepSeek through its Anthropic-shaped endpoint.
+    expect(options['claude-code']).toEqual([
       {
-        id: 'acc_1',
-        label: 'Picked',
-        credential: { type: 'api-key', key: 'k' },
-        models: [{ id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' }, { id: 'deepseek-v4-flash' }],
-        createdAt: 0,
+        id: 'claude-opus-5',
+        label: 'Opus 5',
+        description: 'Anthropic',
+        accountId: 'acc_anthropic',
       },
-      { id: 'acc_2', label: 'Unpicked', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
-    ] satisfies Accounts;
-
-    expect(accountModelOptions(providers, accounts)).toEqual({
-      codex: [
-        { id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro' },
+      {
+        id: 'deepseek-v4-pro',
+        label: 'DeepSeek V4 Pro',
+        description: 'DeepSeek',
+        accountId: 'acc_deepseek',
+      },
+      {
+        id: 'deepseek-v4-flash',
         // A relay ships bare ids; the id doubles as the label rather than rendering blank.
-        { id: 'deepseek-v4-flash', label: 'deepseek-v4-flash' },
-      ],
-      'claude-code': [],
-    });
+        label: 'deepseek-v4-flash',
+        description: 'DeepSeek',
+        accountId: 'acc_deepseek',
+      },
+    ]);
   });
 
-  it('stays unresolved until both sources have loaded', () => {
-    const { result, rerender } = renderHook(() => useAccountModelOptions());
+  it('omits an agent no account can back, and keeps a bindable-but-unpicked one empty', () => {
+    // grok-build only accepts an xAI account, so neither of these can back it.
+    expect(accountModelOptions([anthropicAccount, deepseekAccount])['grok-build']).toBeUndefined();
+    // Bindable with nothing ticked: present-and-empty, which is what blocks sending.
+    expect(
+      accountModelOptions([{ ...anthropicAccount, models: undefined }])['claude-code'],
+    ).toEqual([]);
+  });
 
-    expect(result.current).toBeNull();
+  it('keeps same-id models from two accounts as separate, identifiable entries', () => {
+    const shared = { ...anthropicAccount, id: 'acc_other', label: 'Work key' };
+    const options = accountModelOptions([anthropicAccount, shared])['claude-code'] ?? [];
+
+    expect(options).toHaveLength(2);
+    expect(new Set(options.map(modelChoiceKey)).size).toBe(2);
+  });
+
+  it('scopes to one account for a live session, whose account cannot change', () => {
+    const accounts = [anthropicAccount, deepseekAccount];
+    expect(accountModelOptionsFor(accounts, 'acc_deepseek')?.map(({ id }) => id)).toEqual([
+      'deepseek-v4-pro',
+      'deepseek-v4-flash',
+    ]);
+    expect(accountModelOptionsFor(accounts, 'gone')).toBeUndefined();
+    expect(accountModelOptionsFor(accounts, undefined)).toBeUndefined();
+  });
+
+  it('stays unresolved until the account pool has loaded', () => {
+    const { result, rerender } = renderHook(() => useAccountModelOptions());
 
-    providersData = {};
-    rerender();
     expect(result.current).toBeNull();
 
     accountsData = [];
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index a8875e3c..29d16b32 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -1,6 +1,8 @@
-import type { Accounts, AgentKind, AgentModelOption, ProvidersConfig } from '@linkcode/schema';
+import { resolveBinding } from '@linkcode/providers';
+import type { Account, Accounts, AgentKind, ProvidersConfig } from '@linkcode/schema';
 import { AgentKindSchema } from '@linkcode/schema';
 import { getAccounts, getProviderConfig } from '@linkcode/sdk';
+import type { ModelOption } from '@linkcode/ui';
 import { useData } from '../../runtime/tayori';
 
 /** The model each agent currently runs on, as session start resolves it: the agent's persisted pick.
@@ -25,33 +27,64 @@ export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>>
 }
 
 /**
- * The models each agent may be switched to: the set picked on its bound account, and nothing else.
+ * Every model a new session of this agent could run on: the picked sets of *all* accounts the agent
+ * can bind, not just the one bound now. Choosing a model therefore also chooses its account, which
+ * is what lets one agent reach several providers without a trip through Settings.
+ *
+ * `description` carries the account label so `groupModelsByProvider` renders one submenu per
+ * account, and `accountId` rides along so the pick names the account it came from — two accounts
+ * legitimately serve the same model id.
  *
  * Present-but-empty and absent mean different things, and callers rely on the difference. An entry
- * exists for every agent with an account bound, so `[]` says "bound, nothing picked yet" and blocks
- * sends the way the daemon does. Absent says "no account bound", where the agent still resolves its
- * own model — so its pickers fall through to the adapter catalog or the curated table, and nothing
- * blocks.
+ * exists whenever at least one account can back the agent, so `[]` says "bindable, nothing picked
+ * yet" and blocks sends the way the daemon does. Absent says "no account can back this agent", where
+ * it still resolves its own model — pickers fall through to the adapter catalog or the curated table,
+ * and nothing blocks.
  */
 export function accountModelOptions(
-  providers: ProvidersConfig | undefined,
   accounts: Accounts | undefined,
-): Partial<Record<AgentKind, AgentModelOption[]>> {
-  const options: Partial<Record<AgentKind, AgentModelOption[]>> = {};
+): Partial<Record<AgentKind, ModelOption[]>> {
+  const options: Partial<Record<AgentKind, ModelOption[]>> = {};
   for (const kind of AgentKindSchema.options) {
-    const accountId = providers?.[kind]?.activeAccountId;
-    if (accountId === undefined) continue;
-    const models = accounts?.find((candidate) => candidate.id === accountId)?.models ?? [];
-    options[kind] = models.map(({ id, label }) => ({ id, label: label ?? id }));
+    const bindable = (accounts ?? []).filter(
+      (account) => resolveBinding(account, kind).tier !== 'unavailable',
+    );
+    if (bindable.length === 0) continue;
+    options[kind] = bindable.flatMap((account) => modelOptionsOf(account));
   }
   return options;
 }
 
-/** `null` until both daemon-owned sources have loaded, so a picker never briefly offers a set the
- * account does not actually have. */
-export function useAccountModelOptions(): Partial<Record<AgentKind, AgentModelOption[]>> | null {
-  const { data: providers } = useData(getProviderConfig, {});
+/** One account's picked models. A live session's menu uses this: its account is fixed at spawn, so
+ * offering another account's models would advertise a switch the adapter cannot make. */
+export function accountModelOptionsFor(
+  accounts: Accounts | undefined,
+  accountId: string | undefined,
+): ModelOption[] | undefined {
+  if (accountId === undefined) return undefined;
+  const account = accounts?.find((candidate) => candidate.id === accountId);
+  return account === undefined ? undefined : modelOptionsOf(account);
+}
+
+function modelOptionsOf(account: Account): ModelOption[] {
+  return (account.models ?? []).map(({ id, label }) => ({
+    id,
+    label: label ?? id,
+    description: account.label,
+    accountId: account.id,
+  }));
+}
+
+/** `null` until the account pool has loaded, so a picker never briefly offers a set that is not
+ * actually available. */
+export function useAccountModelOptions(): Partial<Record<AgentKind, ModelOption[]>> | null {
+  const { data: accounts } = useData(getAccounts, {});
+  if (accounts === undefined) return null;
+  return accountModelOptions(accounts);
+}
+
+/** The models a live session may switch between — its own account's, and only those. */
+export function useSessionModelOptions(accountId: string | undefined): ModelOption[] | undefined {
   const { data: accounts } = useData(getAccounts, {});
-  if (providers === undefined || accounts === undefined) return null;
-  return accountModelOptions(providers, accounts);
+  return accountModelOptionsFor(accounts, accountId);
 }
diff --git a/packages/client/workbench/src/surface/use-workbench-sessions.ts b/packages/client/workbench/src/surface/use-workbench-sessions.ts
index 6cbf72e7..01664162 100644
--- a/packages/client/workbench/src/surface/use-workbench-sessions.ts
+++ b/packages/client/workbench/src/surface/use-workbench-sessions.ts
@@ -49,6 +49,8 @@ export interface WorkbenchSessions {
     kind: AgentKind;
     cwd: string;
     model?: string;
+    /** Pins the session to the account the picked model belongs to. */
+    accountId?: string;
     effort?: EffortLevel;
     approvalPolicyId?: string;
     modeId?: SessionModeId;
@@ -194,6 +196,8 @@ export function useWorkbenchSessions(onError: (err: unknown) => void): Workbench
     kind: AgentKind;
     cwd: string;
     model?: string;
+    /** Pins the session to the account the picked model belongs to. */
+    accountId?: string;
     effort?: EffortLevel;
     approvalPolicyId?: string;
     modeId?: SessionModeId;
@@ -203,11 +207,15 @@ export function useWorkbenchSessions(onError: (err: unknown) => void): Workbench
     // Captured now: by resolve time the surface still shows the draft, and the recorded
     // transition should be draft → new thread.
     const from = currentLocation;
+    // Pins the session to the account the picked model belongs to. The daemon merges its own
+    // credential bundle over this, so only the account choice travels from the client.
+    const { accountId, ...rest } = opts;
+    const startOptions = accountId === undefined ? rest : { ...rest, config: { accountId } };
     // Rejections propagate to the caller (the new-session page stays up); onError above still
     // reports them via the error banner.
     let sessionId: SessionId;
     try {
-      const result = await createMutation.trigger({ opts });
+      const result = await createMutation.trigger({ opts: startOptions });
       sessionId = result.sessionId;
       showMcpWarnings(result.mcpWarnings, tMcpWarnings);
     } catch (error) {
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index 92f900e8..2f87ef02 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -31,6 +31,7 @@ import type {
   ComposerDirectiveControls,
   ConversationComposerController,
   CurrentPlan,
+  ModelOption,
   NewSessionDraft,
   NewSessionSubmission,
   PermissionDecision,
@@ -60,6 +61,7 @@ import { useMutation } from '../runtime/tayori';
 import {
   useAccountModelOptions,
   useConfiguredDefaultModels,
+  useSessionModelOptions,
 } from '../settings/providers/default-models';
 import { RuntimeBranchStatus } from '../sidebar/branch-status';
 import { useSidebarGroupCollapseStore } from '../sidebar/collapse-store';
@@ -245,6 +247,8 @@ function WorkbenchSessionSurface({
   const { mentionItems, onMentionQueryChange } = useFileMentionSource();
   const newSessionDefaultModels = useConfiguredDefaultModels();
   const accountModels = useAccountModelOptions();
+  // Scoped to the active session's own account: it was fixed at spawn and cannot change.
+  const sessionModels = useSessionModelOptions(active?.accountId);
   const sdkClient = useWorkbenchSdkClient();
   const activeSessionId = sessions.activeId;
   // Announce observation of the focused session so the daemon replays buffered per-session state
@@ -378,6 +382,7 @@ function WorkbenchSessionSurface({
       kind: submission.kind,
       cwd: submission.cwd,
       model: submission.model,
+      accountId: submission.accountId,
       effort: submission.effort ?? undefined,
       approvalPolicyId: submission.approvalPolicyId,
       modeId: submission.modeId,
@@ -448,14 +453,16 @@ function WorkbenchSessionSurface({
       .then(noop);
   }
 
-  function handleModelChange(model: string): Promise<void> {
+  function handleModelChange(model: ModelOption): Promise<void> {
     if (!sessions.activeId) return Promise.reject(new Error('No active session'));
     onClearError();
     // Let the rejection propagate: the composer awaits it to decide whether to reflect the pick.
     // onError (wired into modelMutation above) still reports the failure via the error banner.
     const provider = active?.kind;
-    return modelMutation.trigger({ sessionId: sessions.activeId, model }).then(() => {
-      if (provider) rememberSelection(provider, { model });
+    return modelMutation.trigger({ sessionId: sessions.activeId, model: model.id }).then(() => {
+      // The account is not part of a live switch — it is fixed at spawn, and this menu only ever
+      // offers the session's own account's models.
+      if (provider) rememberSelection(provider, { model: model.id });
     });
   }
 
@@ -656,6 +663,7 @@ function WorkbenchSessionSurface({
       onNewSessionWorkspaceChange={handleNewSessionWorkspaceChange}
       newSessionDefaultModels={newSessionDefaultModels}
       accountModels={accountModels}
+      sessionModels={sessionModels}
       agentCatalogs={agentCatalogs}
       newSessionPreferredModels={newSessionPreferredModels}
       newSessionPreferredEfforts={newSessionPreferredEfforts}
diff --git a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
index d81840f9..4f1efa8d 100644
--- a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
+++ b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
@@ -58,6 +58,8 @@ const RE_LOW_EFFORT = /Low/;
 const RE_GPT_56_SOL = /GPT-5.6-Sol/;
 const RE_PROVIDER_CLAUDE_CODE_MENU = /provider.*Claude Code/;
 const RE_MODEL_SONNET_5_MENU = /model.*Sonnet 5/;
+const RE_OPUS_5 = /Opus 5/;
+const RE_MODEL_MENU = /^model/;
 const RE_MODEL_GPT_56_SOL_MENU = /model.*GPT-5\.6-Sol/;
 const RE_MODEL_DEFAULT_MENU = /model.*modelDefault/;
 const RE_MODEL_PI_SONNET_MENU = /model.*Pi Sonnet/;
@@ -812,6 +814,58 @@ describe('NewSessionSurface', () => {
     expect(submitted?.model).toBeUndefined();
   });
 
+  it('starts on the account the picked model belongs to, not the one bound', async () => {
+    const user = userEvent.setup();
+    const onSubmit = vi.fn().mockResolvedValue(undefined);
+    render(
+      <NewSessionSurface
+        accountModels={{
+          'claude-code': [
+            {
+              id: 'claude-opus-5',
+              label: 'Opus 5',
+              description: 'Anthropic',
+              accountId: 'acc_ant',
+            },
+            {
+              id: 'deepseek-v4-pro',
+              label: 'DeepSeek V4 Pro',
+              description: 'DeepSeek',
+              accountId: 'acc_ds',
+            },
+          ],
+        }}
+        chatWorkspace={CHAT_WORKSPACE}
+        defaultModels={{ 'claude-code': 'claude-opus-5' }}
+        draft={{
+          initialProvider: 'claude-code',
+          initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
+        }}
+        mentionItems={[]}
+        onMentionQueryChange={vi.fn()}
+        onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
+        onSubmit={onSubmit}
+        workspaces={[]}
+      />,
+    );
+
+    // Two accounts → one submenu each. Submenu triggers are keyboard-driven here: base-ui leaves
+    // them `pointer-events: none` in jsdom.
+    await user.click(screen.getByRole('button', { name: RE_OPUS_5 }));
+    await user.click(await screen.findByRole('menuitem', { name: RE_MODEL_MENU }));
+    (await screen.findByRole('menuitem', { name: 'DeepSeek' })).focus();
+    await user.keyboard('{ArrowRight}');
+    fireEvent.click(await screen.findByRole('menuitemradio', { name: 'DeepSeek V4 Pro' }));
+    typeInComposer('hello');
+    await pressInComposer('Enter');
+
+    await waitFor(() =>
+      expect(onSubmit).toHaveBeenCalledWith(
+        expect.objectContaining({ model: 'deepseek-v4-pro', accountId: 'acc_ds' }),
+      ),
+    );
+  });
+
   it("offers only the bound account's picked models, ignoring the curated table", async () => {
     const user = userEvent.setup();
     render(
diff --git a/packages/presentation/ui/src/shell/agent-models.ts b/packages/presentation/ui/src/shell/agent-models.ts
index 48f3f790..0cf6ebf9 100644
--- a/packages/presentation/ui/src/shell/agent-models.ts
+++ b/packages/presentation/ui/src/shell/agent-models.ts
@@ -3,6 +3,9 @@ import type { AgentKind, EffortLevel } from '@linkcode/schema';
 export interface ModelOption {
   id: string;
   label: string;
+  /** The account offering this model, when the list spans several. Two accounts can serve the same
+   * `id`, so this is what makes an entry identifiable — see {@link modelChoiceKey}. */
+  accountId?: string;
   /** Secondary line in the picker (adapter-advertised catalogs carry the provider name here,
    * disambiguating same-named models across providers); static table entries omit it. */
   description?: string;
@@ -18,6 +21,15 @@ export interface ModelProviderGroups {
   groups: Array<{ label: string; options: ModelOption[] }>;
 }
 
+/**
+ * Identity of one entry in a model menu. The model id alone is not unique once a list spans
+ * accounts — a direct DeepSeek account and an OpenRouter one both serve `deepseek-v4-pro` — and
+ * reusing it as a React key or a radio value collapses the two into one unselectable row.
+ */
+export function modelChoiceKey(option: ModelOption): string {
+  return `${option.accountId ?? ''}:${option.id}`;
+}
+
 /** Group a catalog by its provider subtitle (`description`, per the adapter convention above),
  * preserving catalog order within groups and first-appearance order across them. Returns null
  * below two distinct providers — a single-provider list reads better flat. */
@@ -44,15 +56,20 @@ export function groupModelsByProvider(
 
 /** Resolve a reflected model id (from `model-update`) to its catalog entry. The daemon emits the
  * *served* id, which may be a pinned snapshot of an alias (e.g. `claude-haiku-4-5-20251001`);
- * prefix-match only after an exact match fails so `gpt-5.4-mini` never mis-resolves to `gpt-5.4`. */
+ * prefix-match only after an exact match fails so `gpt-5.4-mini` never mis-resolves to `gpt-5.4`.
+ * `accountId` narrows first where known, so a list spanning accounts labels the right entry. */
 export function resolveModel(
   options: readonly ModelOption[] | undefined,
   id: string | null,
+  accountId?: string,
 ): ModelOption | undefined {
   if (id === null) return undefined;
+  const scoped =
+    accountId === undefined ? options : options?.filter((option) => option.accountId === accountId);
+  const candidates = scoped?.length ? scoped : options;
   return (
-    options?.find((option) => option.id === id) ??
-    options?.find((option) => id.startsWith(`${option.id}-`))
+    candidates?.find((option) => option.id === id) ??
+    candidates?.find((option) => id.startsWith(`${option.id}-`))
   );
 }
 
diff --git a/packages/presentation/ui/src/shell/composer-controls.tsx b/packages/presentation/ui/src/shell/composer-controls.tsx
index 7860235a..1b8f4b18 100644
--- a/packages/presentation/ui/src/shell/composer-controls.tsx
+++ b/packages/presentation/ui/src/shell/composer-controls.tsx
@@ -30,7 +30,7 @@ import { AGENT_LABELS, AgentIcon } from '../chat/agent-icon';
 import type { EffortOption } from './agent-efforts';
 import { EFFORT_OPTIONS_BY_ID } from './agent-efforts';
 import type { ModelOption } from './agent-models';
-import { groupModelsByProvider, resolveModel } from './agent-models';
+import { groupModelsByProvider, modelChoiceKey, resolveModel } from './agent-models';
 import type { AgentRuntimeCue, AgentRuntimeCues } from './agent-onboarding-card';
 
 // Linear lookup: the policy/effort lists are a handful of entries at most.
@@ -219,6 +219,7 @@ export function ModelSelectorMenu({
   modelOptions,
   effortOptions,
   selectedModelId,
+  selectedAccountId,
   selectedEffortId,
   onSelectModel,
   onSelectEffort,
@@ -235,8 +236,11 @@ export function ModelSelectorMenu({
   modelOptions?: ModelOption[];
   effortOptions?: EffortOption[];
   selectedModelId: string | null;
+  /** Disambiguates the selection when the list spans accounts serving the same model id. */
+  selectedAccountId?: string;
   selectedEffortId: EffortLevel | null;
-  onSelectModel: (model: string) => void;
+  /** Carries the whole entry: a cross-account list needs the account alongside the id. */
+  onSelectModel: (model: ModelOption) => void;
   onSelectEffort: (effort: EffortLevel) => void;
   /** Draft-only escape hatch back to the provider/configured model default. */
   onResetModel?: () => void;
@@ -245,7 +249,7 @@ export function ModelSelectorMenu({
   onSelectProvider?: (provider: AgentKind) => void;
 }): React.ReactNode {
   const t = useTranslations('workbench.composer');
-  const selectedModel = resolveModel(modelOptions, selectedModelId);
+  const selectedModel = resolveModel(modelOptions, selectedModelId, selectedAccountId);
   const providerGroups = groupModelsByProvider(modelOptions);
   const selectedEffort =
     optionById(effortOptions, selectedEffortId) ??
@@ -327,12 +331,22 @@ export function ModelSelectorMenu({
             </MenuSubTrigger>
             <MenuSubPopup className="w-56">
               <MenuRadioGroup
-                value={selectedModel?.id ?? selectedModelId ?? ''}
-                onValueChange={(value) => onSelectModel(String(value))}
+                value={selectedModel === undefined ? '' : modelChoiceKey(selectedModel)}
+                onValueChange={(value) => {
+                  // Keyed by (account, model), so map back to the entry rather than parsing it.
+                  const picked = modelOptions?.find(
+                    (option) => modelChoiceKey(option) === String(value),
+                  );
+                  if (picked) onSelectModel(picked);
+                }}
               >
                 {providerGroups === null ? (
                   modelOptions?.map((option) => (
-                    <MenuRadioItem key={option.id} closeOnClick value={option.id}>
+                    <MenuRadioItem
+                      key={modelChoiceKey(option)}
+                      closeOnClick
+                      value={modelChoiceKey(option)}
+                    >
                       <span className="flex min-w-0 flex-col">
                         <span>{option.label}</span>
                         {option.description ? (
@@ -346,7 +360,11 @@ export function ModelSelectorMenu({
                 ) : (
                   <>
                     {providerGroups.ungrouped.map((option) => (
-                      <MenuRadioItem key={option.id} closeOnClick value={option.id}>
+                      <MenuRadioItem
+                        key={modelChoiceKey(option)}
+                        closeOnClick
+                        value={modelChoiceKey(option)}
+                      >
                         {option.label}
                       </MenuRadioItem>
                     ))}
@@ -357,7 +375,11 @@ export function ModelSelectorMenu({
                         <MenuSubTrigger>{group.label}</MenuSubTrigger>
                         <MenuSubPopup className="w-56">
                           {group.options.map((option) => (
-                            <MenuRadioItem key={option.id} closeOnClick value={option.id}>
+                            <MenuRadioItem
+                              key={modelChoiceKey(option)}
+                              closeOnClick
+                              value={modelChoiceKey(option)}
+                            >
                               {option.label}
                             </MenuRadioItem>
                           ))}
diff --git a/packages/presentation/ui/src/shell/composer.tsx b/packages/presentation/ui/src/shell/composer.tsx
index 7ead16cf..aa0d8d2f 100644
--- a/packages/presentation/ui/src/shell/composer.tsx
+++ b/packages/presentation/ui/src/shell/composer.tsx
@@ -32,6 +32,7 @@ import {
 } from '../chat/prompt-input';
 import { cn } from '../lib/cn';
 import { effortOptionsForModel } from './agent-efforts';
+import type { ModelOption } from './agent-models';
 import { AGENT_MODEL_OPTIONS, resolveModel } from './agent-models';
 import type { AgentRuntimeCues } from './agent-onboarding-card';
 import type { ComposerAttachment } from './composer-attachments';
@@ -174,7 +175,10 @@ export interface ComposerProps {
   onApprovalPolicyChange?: (policyId: string) => Promise<void>;
   /** Sends the model switch (`set-model`); the active model is reflected from `model-update`, not
    * locally — a rejected switch keeps the previous model. */
-  onModelChange?: (model: string) => Promise<void>;
+  /** Receives the whole entry, so a cross-account pick names the account it belongs to. */
+  onModelChange?: (model: ModelOption) => Promise<void>;
+  /** The account the current model belongs to; disambiguates a list spanning several. */
+  currentAccountId?: string;
   /** Sends the reasoning-effort switch (`set-effort`); reflected from `effort-update`, same contract. */
   onEffortChange?: (effort: EffortLevel) => Promise<void>;
   /** Clears a draft's explicit model override. Omitted for live sessions. */
@@ -228,6 +232,7 @@ export function Composer({
   onModeChange,
   onApprovalPolicyChange,
   onModelChange,
+  currentAccountId,
   onEffortChange,
   onResetModel,
   onResetEffort,
@@ -833,8 +838,8 @@ export function Composer({
 
   // Server-reflected like mode/policy: the pick shows once `model-update` / `effort-update` echoes
   // it back; a rejected switch leaves the previous value and the failure lands in the error banner.
-  function selectModel(modelId: string): void {
-    void onModelChange?.(modelId).catch(noop);
+  function selectModel(model: ModelOption): void {
+    void onModelChange?.(model).catch(noop);
   }
 
   function selectEffort(effort: EffortLevel): void {
@@ -1024,6 +1029,7 @@ export function Composer({
                     provider={agentKind}
                     runtimeCues={runtimeCues}
                     selectableProviders={selectableProviders}
+                    selectedAccountId={currentAccountId}
                     selectedEffortId={currentEffort ?? null}
                     selectedModelId={currentModel ?? null}
                     onResetEffort={onResetEffort}
diff --git a/packages/presentation/ui/src/shell/conversation-surface.tsx b/packages/presentation/ui/src/shell/conversation-surface.tsx
index 1a7d2ef3..1c54021e 100644
--- a/packages/presentation/ui/src/shell/conversation-surface.tsx
+++ b/packages/presentation/ui/src/shell/conversation-surface.tsx
@@ -1,10 +1,4 @@
-import type {
-  AgentKind,
-  AgentModelOption,
-  ContentBlock,
-  EffortLevel,
-  QuestionOutcome,
-} from '@linkcode/schema';
+import type { AgentKind, ContentBlock, EffortLevel, QuestionOutcome } from '@linkcode/schema';
 import { useRef } from 'react';
 import type { StickToBottomContext } from 'use-stick-to-bottom';
 import { ArtifactHostActionsProvider } from '../chat/artifacts/context';
@@ -13,6 +7,7 @@ import { selectPendingPromptItems } from '../chat/conversation-prompts';
 import { ConversationView } from '../chat/conversation-view';
 import type { ConversationViewModel, PromptEditState } from '../chat/types';
 import { cn } from '../lib/cn';
+import type { ModelOption } from './agent-models';
 import type { AgentRuntimeCues } from './agent-onboarding-card';
 import { AgentOnboardingCard } from './agent-onboarding-card';
 import type { ComposerDirectiveControls, ComposerHandle, MentionItem } from './composer';
@@ -29,7 +24,7 @@ export interface ConversationComposerController {
   directiveControls: ComposerDirectiveControls;
   onModeChange?: (modeId: string) => Promise<void>;
   onApprovalPolicyChange?: (policyId: string) => Promise<void>;
-  onModelChange?: (model: string) => Promise<void>;
+  onModelChange?: (model: ModelOption) => Promise<void>;
   onEffortChange?: (effort: EffortLevel) => Promise<void>;
 }
 
@@ -38,9 +33,12 @@ export interface ConversationSurfaceProps {
   composer: ConversationComposerController;
   agentKind?: AgentKind;
   agentLabel?: string;
-  /** The models picked on this agent's bound account — the only ones it may switch to. Absent means
-   * no account is bound, so the adapter catalog or the curated table supplies the choices instead. */
-  accountModels?: AgentModelOption[];
+  /** The models picked on *this session's* account — the only ones it may switch to, because its
+   * account is fixed at spawn. Absent means no account backs it, so the adapter catalog or the
+   * curated table supplies the choices instead. */
+  accountModels?: ModelOption[];
+  /** The session's account, so a reflected model id resolves against the right entry. */
+  accountId?: string;
   /** Frontend capability stub used until attachment support is advertised by the session. */
   attachmentsSupported?: boolean;
   cwd?: string;
@@ -95,6 +93,7 @@ export function ConversationSurface({
   composer,
   agentKind,
   accountModels,
+  accountId,
   agentLabel,
   attachmentsSupported = false,
   cwd,
@@ -193,9 +192,10 @@ export function ConversationSurface({
           approvalPolicy={conversation.approvalPolicy}
           currentModel={conversation.currentModel}
           currentEffort={conversation.currentEffort}
-          // The account's picked set is the user's own answer to "which models may this run on",
-          // so it outranks both the adapter catalog and the curated table.
+          // The session account's picked set is the user's own answer to "which models may this run
+          // on", so it outranks both the adapter catalog and the curated table.
           agentModels={accountModels ?? conversation.availableModels}
+          currentAccountId={accountId}
           directiveControls={composer.directiveControls}
           onSend={composer.onSend}
           // Scrolls at submit, not acceptance: the jump must feel tied to pressing send, and a
diff --git a/packages/presentation/ui/src/shell/new-session-surface.tsx b/packages/presentation/ui/src/shell/new-session-surface.tsx
index 9a4bdd63..52a6a995 100644
--- a/packages/presentation/ui/src/shell/new-session-surface.tsx
+++ b/packages/presentation/ui/src/shell/new-session-surface.tsx
@@ -1,7 +1,6 @@
 import type {
   AgentInput,
   AgentKind,
-  AgentModelOption,
   AgentStartCatalog,
   BranchMode,
   BranchSelection,
@@ -36,6 +35,7 @@ import { useTranslations } from 'use-intl';
 import { AGENT_LABELS } from '../chat/agent-icon';
 import { cn } from '../lib/cn';
 import { repositoryLabel } from '../repository-label';
+import type { ModelOption } from './agent-models';
 import { AGENT_MODEL_OPTIONS, resolveModel } from './agent-models';
 import type { AgentRuntimeCues } from './agent-onboarding-card';
 import { AgentOnboardingCard } from './agent-onboarding-card';
@@ -58,6 +58,8 @@ export interface NewSessionSubmission {
   workspaceId: WorkspaceId;
   /** Absent falls back to the agent's persisted pick; there is no "return to default" tier. */
   model?: string;
+  /** The account the picked model belongs to, pinning the session to it. */
+  accountId?: string;
   /** Null explicitly returns this provider to its default effort. */
   effort?: EffortLevel | null;
   approvalPolicyId?: string;
@@ -92,7 +94,7 @@ export interface NewSessionSurfaceProps {
   defaultModels?: Readonly<Partial<Record<AgentKind, string>>> | null;
   /** The models each agent may run on, picked on its bound account. An agent absent here has no
    * account bound and falls back to its adapter catalog or the curated table. */
-  accountModels?: Readonly<Partial<Record<AgentKind, AgentModelOption[]>>> | null;
+  accountModels?: Readonly<Partial<Record<AgentKind, ModelOption[]>>> | null;
   /** Last accepted model per provider. Unlike configured defaults, this is an explicit override. */
   preferredModels?: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last accepted effort per provider. Missing kinds retain the provider default. */
@@ -168,6 +170,10 @@ export function NewSessionSurface({
   const [selectedModels, setSelectedModels] = useState<Partial<Record<AgentKind, string | null>>>(
     {},
   );
+  /** The account each picked model belongs to; null once the pick is reset. */
+  const [selectedAccounts, setSelectedAccounts] = useState<
+    Partial<Record<AgentKind, string | null>>
+  >({});
   const [selectedEfforts, setSelectedEfforts] = useState<
     Partial<Record<AgentKind, EffortLevel | null>>
   >({});
@@ -196,12 +202,15 @@ export function NewSessionSurface({
   const localEffort = selectedEfforts[provider];
   const effort = localEffort === undefined ? (preferredEfforts?.[provider] ?? null) : localEffort;
   const dynamicModels = catalog && catalog.models.length > 0 ? catalog.models : null;
-  // The account's picked set is the user's own answer to which models this agent may run on, so it
-  // outranks the adapter catalog and the curated table both. An entry present here means an account
-  // is bound, which is also what makes a missing model fatal rather than the agent's own business.
-  const boundSet = accountModels?.[provider];
-  const pickable = boundSet ?? dynamicModels ?? AGENT_MODEL_OPTIONS[provider];
-  const modelOption = resolveModel(pickable, displayedModel);
+  // Every account that can back this agent contributes, so a pick chooses the account too. The set
+  // outranks the adapter catalog and the curated table both, and an entry present here means at
+  // least one account is bindable — which is what makes a missing model fatal rather than the
+  // agent's own business.
+  const bindableSet = accountModels?.[provider];
+  const pickable = bindableSet ?? dynamicModels ?? AGENT_MODEL_OPTIONS[provider];
+  const localAccount = selectedAccounts[provider];
+  const selectedAccountId = localAccount ?? undefined;
+  const modelOption = resolveModel(pickable, displayedModel, selectedAccountId);
   const effortLevels = modelOption?.effortLevels;
   const constrainedEffort =
     effortLevels === undefined || effortLevels.includes(effort ?? 'low') ? effort : null;
@@ -238,6 +247,10 @@ export function NewSessionSurface({
         cwd: selected.cwd,
         workspaceId: selected.workspaceId,
         model: localModel === null ? undefined : (selectedModel ?? undefined),
+        // Pins the session to the account whose entry was picked; without it the daemon would fall
+        // back to whichever account happens to be bound.
+        ...(localModel !== null &&
+          modelOption?.accountId !== undefined && { accountId: modelOption.accountId }),
         ...(localEffort === null
           ? { effort: null }
           : constrainedEffort !== null && { effort: constrainedEffort }),
@@ -268,8 +281,11 @@ export function NewSessionSurface({
     return Promise.resolve();
   }
 
-  function handleModelChange(nextModel: string): Promise<void> {
-    setSelectedModels((current) => ({ ...current, [provider]: nextModel }));
+  function handleModelChange(next: ModelOption): Promise<void> {
+    setSelectedModels((current) => ({ ...current, [provider]: next.id }));
+    // The account is part of the pick: two accounts can serve the same id, and the session must
+    // start on the one whose entry was chosen.
+    setSelectedAccounts((current) => ({ ...current, [provider]: next.accountId ?? null }));
     return Promise.resolve();
   }
 
@@ -280,6 +296,7 @@ export function NewSessionSurface({
 
   function handleResetModel(): void {
     setSelectedModels((current) => ({ ...current, [provider]: null }));
+    setSelectedAccounts((current) => ({ ...current, [provider]: null }));
   }
 
   function handleResetEffort(): void {
@@ -367,11 +384,14 @@ export function NewSessionSurface({
             // With an account bound, its set is the only model source, so an unresolved model would
             // be refused by the daemon anyway — refuse here instead of after a round trip. An agent
             // with no account bound still resolves its own, and must not be blocked.
-            sendBlocked={cue !== undefined || (boundSet !== undefined && displayedModel === null)}
+            sendBlocked={
+              cue !== undefined || (bindableSet !== undefined && displayedModel === null)
+            }
             currentModeId={modeId}
             currentModel={displayedModel}
             currentEffort={displayedEffort}
             agentModels={pickable ?? null}
+            currentAccountId={selectedAccountId}
             approvalPolicy={approvalPolicy}
             approvalPolicyPlaceholder={t('permissionMode')}
             selectableProviders={SELECTABLE_PROVIDERS}
diff --git a/packages/presentation/ui/src/shell/shell-frame.tsx b/packages/presentation/ui/src/shell/shell-frame.tsx
index 08f3f4cd..3340ec68 100644
--- a/packages/presentation/ui/src/shell/shell-frame.tsx
+++ b/packages/presentation/ui/src/shell/shell-frame.tsx
@@ -1,6 +1,5 @@
 import type {
   AgentKind,
-  AgentModelOption,
   BranchSelection,
   ContentBlock,
   EffortLevel,
@@ -12,6 +11,7 @@ import type {
 } from '@linkcode/schema';
 import type { ConversationViewModel } from '../chat';
 import type { PermissionDecision } from '../chat/conversation-prompts';
+import type { ModelOption } from './agent-models';
 import type { AgentRuntimeCues } from './agent-onboarding-card';
 import type { MentionItem } from './composer';
 import type { ConversationComposerController } from './conversation-surface';
@@ -60,7 +60,10 @@ export interface ShellFrameProps
   newSessionDefaultModels: Readonly<Partial<Record<AgentKind, string>>> | null;
   /** The models each agent may run on, picked on its bound account. An agent absent here has no
    * account bound and keeps falling back to whatever its adapter or the curated table advertises. */
-  accountModels: Readonly<Partial<Record<AgentKind, AgentModelOption[]>>> | null;
+  accountModels: Readonly<Partial<Record<AgentKind, ModelOption[]>>> | null;
+  /** The active session's own account's models — the whole live menu, since a running session's
+   * account is fixed at spawn. */
+  sessionModels?: ModelOption[];
   /** Last model accepted by LinkCode per provider, submitted as a new-session override. */
   newSessionPreferredModels: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last effort accepted by LinkCode per provider for new sessions. */
@@ -136,6 +139,7 @@ export function ShellFrame({
   agentCatalogs,
   newSessionDefaultModels,
   accountModels,
+  sessionModels,
   newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
@@ -249,7 +253,8 @@ export function ShellFrame({
             composer={conversationComposer}
             agentKind={active?.kind}
             agentLabel={active ? active.kind : undefined}
-            accountModels={active ? accountModels?.[active.kind] : undefined}
+            accountModels={sessionModels}
+            accountId={active?.accountId}
             attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
             disabled={!active || active.status === 'stopped'}
             isRunning={isRunning}

From 8634d2c814d1c8f1efabe00bc7daa6d9526df08f Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 21:30:58 +0800
Subject: [PATCH 08/17] feat(workbench): give the model pick a single owner in
 daemon config
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The model an agent runs on was remembered twice: `providers[kind].model` on the
daemon and `modelsByProvider` in renderer localStorage. Two owners meant Settings
and the composer could disagree, and a scheduled or script session ignored
whatever the composer last used.

The accepted pick now writes daemon config, carrying the account it came from —
choosing a model is also choosing who serves it, so leaving the old binding would
run the next session on an account that never listed that model. The client copy
is gone and the persisted store moves to v6 so a stale blob cannot resurrect a
memory with no owner.

Written once a selection is known to have been accepted rather than on the menu
click, keeping the existing confirm-then-remember discipline: an abandoned draft
never rewrites config, and a provider that rejects a model leaves the previous one
standing. The pick still takes effect on the session immediately — it rides the
start options either way.

Nothing re-sends a configured model at session start now; the daemon resolves it,
so the client specifying it again could only let the two disagree.
---
 .../src/renderer/src/shell/desktop-shell.tsx  |  2 -
 .../src/settings/providers/default-models.ts  | 26 ++++++++++-
 .../workbench/src/settings/providers/view.ts  | 12 ++++-
 .../new-session-defaults-store.test.ts        | 21 +++------
 .../src/surface/new-session-defaults-store.ts | 26 +++--------
 .../workbench/src/surface/workbench.tsx       | 23 +++++++---
 .../__tests__/new-session-surface.test.tsx    | 45 ++++++++++---------
 .../ui/src/shell/new-session-surface.tsx      |  6 +--
 .../presentation/ui/src/shell/shell-frame.tsx |  4 --
 9 files changed, 89 insertions(+), 76 deletions(-)

diff --git a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
index 7c69e7af..fb469b89 100644
--- a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
+++ b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
@@ -82,7 +82,6 @@ export function DesktopShell({
   newSessionDefaultModels,
   accountModels,
   sessionModels,
-  newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
   NewSessionBranchPickerComponent,
@@ -432,7 +431,6 @@ export function DesktopShell({
           agentCatalogs={agentCatalogs}
           defaultModels={newSessionDefaultModels}
           accountModels={accountModels}
-          preferredModels={newSessionPreferredModels}
           preferredEfforts={newSessionPreferredEfforts}
           preferredBranches={newSessionPreferredBranches}
           NewSessionBranchPickerComponent={NewSessionBranchPickerComponent}
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index 29d16b32..c12e7d5b 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -1,9 +1,10 @@
 import { resolveBinding } from '@linkcode/providers';
 import type { Account, Accounts, AgentKind, ProvidersConfig } from '@linkcode/schema';
 import { AgentKindSchema } from '@linkcode/schema';
-import { getAccounts, getProviderConfig } from '@linkcode/sdk';
+import { getAccounts, getProviderConfig, setProviderConfig } from '@linkcode/sdk';
 import type { ModelOption } from '@linkcode/ui';
-import { useData } from '../../runtime/tayori';
+import { useData, useMutation } from '../../runtime/tayori';
+import { withModel } from './view';
 
 /** The model each agent currently runs on, as session start resolves it: the agent's persisted pick.
  * The bound account contributes the set that pick came from, never the pick itself. */
@@ -88,3 +89,24 @@ export function useSessionModelOptions(accountId: string | undefined): ModelOpti
   const { data: accounts } = useData(getAccounts, {});
   return accountModelOptionsFor(accounts, accountId);
 }
+
+/**
+ * Persist what an agent runs on. This is the only model memory: the daemon owns it, so Settings and
+ * the composer cannot disagree and a scheduled or script session inherits the same pick. Passing the
+ * account rebinds the agent to it — picking a model is also picking who serves it.
+ *
+ * Called once a selection is known to have been accepted, not on the menu click, so an abandoned
+ * draft never rewrites config and a provider that rejects a model leaves the previous one standing.
+ */
+export function usePersistPickedModel(): (
+  kind: AgentKind,
+  model: string,
+  accountId?: string,
+) => Promise<void> {
+  const { data: providers, mutate } = useData(getProviderConfig, {});
+  const save = useMutation(setProviderConfig);
+  return async (kind, model, accountId) => {
+    await save.trigger({ providers: withModel(providers ?? {}, kind, model, accountId) });
+    await mutate();
+  };
+}
diff --git a/packages/client/workbench/src/settings/providers/view.ts b/packages/client/workbench/src/settings/providers/view.ts
index 271641d4..0a540933 100644
--- a/packages/client/workbench/src/settings/providers/view.ts
+++ b/packages/client/workbench/src/settings/providers/view.ts
@@ -256,18 +256,26 @@ export function withEnabled(
   return { ...providers, [kind]: { ...providers[kind], enabled } };
 }
 
-/** Set (or, with undefined, clear) an agent's default model. */
+/**
+ * Set (or, with undefined, clear) the model an agent runs on. Passing the account the model came
+ * from rebinds the agent to it, because a model and the account serving it are one choice — leaving
+ * the old binding in place would run the next session on an account that never listed this model.
+ */
 export function withModel(
   providers: ProvidersConfig,
   kind: AgentKind,
   model: string | undefined,
+  accountId?: string,
 ): ProvidersConfig {
   const entry = providers[kind] ?? { enabled: true };
   if (model === undefined) {
     const { model: _cleared, ...rest } = entry;
     return { ...providers, [kind]: rest };
   }
-  return { ...providers, [kind]: { ...entry, model } };
+  return {
+    ...providers,
+    [kind]: { ...entry, model, ...(accountId !== undefined && { activeAccountId: accountId }) },
+  };
 }
 
 /** Drop every binding referencing a removed account; returns the input unchanged when none did. */
diff --git a/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts b/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
index 768fa808..84472fe8 100644
--- a/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
+++ b/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
@@ -25,41 +25,34 @@ beforeEach(() => storage.clear());
 afterAll(() => vi.unstubAllGlobals());
 
 describe('new-session defaults', () => {
-  it('keeps successful model and effort choices isolated per provider', async () => {
+  it('keeps successful effort choices isolated per provider', async () => {
     const store = await loadStore();
 
+    // A confirmed model rides the same shape but is not stored here — daemon config owns it.
     store
       .getState()
       .remember('claude-code', WORKSPACE_ID, { model: 'claude-opus-4-8', effort: 'high' });
     store.getState().rememberSelection('claude-code', { effort: 'medium' });
     store.getState().rememberSelection('codex', { model: 'gpt-5.6-terra', effort: 'low' });
 
-    expect(store.getState().modelsByProvider).toEqual({
-      'claude-code': 'claude-opus-4-8',
-      codex: 'gpt-5.6-terra',
-    });
     expect(store.getState().effortsByProvider).toEqual({ 'claude-code': 'medium', codex: 'low' });
   });
 
-  it('clears an explicitly rejected selection without disturbing the other axis', async () => {
+  it('clears an explicitly rejected effort', async () => {
     const store = await loadStore();
-    store
-      .getState()
-      .remember('claude-code', WORKSPACE_ID, { model: 'claude-opus-4-8', effort: 'ultracode' });
+    store.getState().remember('claude-code', WORKSPACE_ID, { effort: 'ultracode' });
 
     store.getState().remember('claude-code', WORKSPACE_ID, { effort: null });
 
-    expect(store.getState().modelsByProvider).toEqual({ 'claude-code': 'claude-opus-4-8' });
     expect(store.getState().effortsByProvider).toEqual({});
   });
 
-  it('rehydrates model and effort choices after a renderer restart', async () => {
+  it('rehydrates effort choices after a renderer restart', async () => {
     const first = await loadStore();
-    first.getState().remember('grok-build', WORKSPACE_ID, { model: 'grok-4.5', effort: 'medium' });
+    first.getState().remember('grok-build', WORKSPACE_ID, { effort: 'medium' });
 
     const restarted = await loadStore();
 
-    expect(restarted.getState().modelsByProvider).toEqual({ 'grok-build': 'grok-4.5' });
     expect(restarted.getState().effortsByProvider).toEqual({ 'grok-build': 'medium' });
   });
 
@@ -84,7 +77,6 @@ describe('new-session defaults', () => {
         state: {
           lastProvider: 'codex',
           lastWorkspaceId: WORKSPACE_ID,
-          modelsByProvider: { codex: '' },
           effortsByProvider: { codex: 'unsupported' },
         },
         version: 0,
@@ -94,7 +86,6 @@ describe('new-session defaults', () => {
     const store = await loadStore();
 
     expect(store.getState().lastProvider).toBeNull();
-    expect(store.getState().modelsByProvider).toEqual({});
     expect(store.getState().effortsByProvider).toEqual({});
     expect(store.getState().branchesByWorkspace).toEqual({});
   });
diff --git a/packages/client/workbench/src/surface/new-session-defaults-store.ts b/packages/client/workbench/src/surface/new-session-defaults-store.ts
index 48244320..b4eb6e54 100644
--- a/packages/client/workbench/src/surface/new-session-defaults-store.ts
+++ b/packages/client/workbench/src/surface/new-session-defaults-store.ts
@@ -13,7 +13,6 @@ const PersistedNewSessionDefaultsSchema = z
   .object({
     lastProvider: AgentKindSchema.nullable(),
     lastWorkspaceId: WorkspaceIdSchema.nullable(),
-    modelsByProvider: z.partialRecord(AgentKindSchema, z.string().min(1)),
     effortsByProvider: z.partialRecord(AgentKindSchema, EffortLevelSchema),
     branchesByWorkspace: z.record(z.string(), BranchSelectionSchema),
   })
@@ -21,7 +20,8 @@ const PersistedNewSessionDefaultsSchema = z
 type PersistedNewSessionDefaults = z.infer<typeof PersistedNewSessionDefaultsSchema>;
 
 export interface NewSessionSelection {
-  /** Null clears a remembered selection after an explicit reset or rejected reflection. */
+  /** Confirmed model, for callers that route it onward. This store does not persist it — the model
+   * an agent runs on lives in daemon config (`usePersistPickedModel`), so there is one owner. */
   model?: string | null;
   /** Null clears a remembered selection after an explicit reset or rejected reflection. */
   effort?: EffortLevel | null;
@@ -32,8 +32,6 @@ export interface NewSessionDefaultsState {
   lastProvider: AgentKind | null;
   /** Workspace of the last successful submit; ids that no longer exist are skipped at resolve time. */
   lastWorkspaceId: WorkspaceId | null;
-  /** Last model accepted by LinkCode per provider; absent means defer to configured defaults. */
-  modelsByProvider: Partial<Record<AgentKind, string>>;
   /** Last effort accepted by LinkCode per provider; absent means defer to the provider default. */
   effortsByProvider: Partial<Record<AgentKind, EffortLevel>>;
   /** Last explicitly selected branch per workspace. */
@@ -51,14 +49,7 @@ function selectionPatch(
   state: NewSessionDefaultsState,
   provider: AgentKind,
   selection: NewSessionSelection,
-): Pick<NewSessionDefaultsState, 'modelsByProvider' | 'effortsByProvider'> {
-  let modelsByProvider = state.modelsByProvider;
-  if (selection.model !== undefined) {
-    modelsByProvider = { ...modelsByProvider };
-    if (selection.model === null) Reflect.deleteProperty(modelsByProvider, provider);
-    else modelsByProvider[provider] = selection.model;
-  }
-
+): Pick<NewSessionDefaultsState, 'effortsByProvider'> {
   let effortsByProvider = state.effortsByProvider;
   if (selection.effort !== undefined) {
     effortsByProvider = { ...effortsByProvider };
@@ -66,10 +57,7 @@ function selectionPatch(
     else effortsByProvider[provider] = selection.effort;
   }
 
-  return {
-    modelsByProvider,
-    effortsByProvider,
-  };
+  return { effortsByProvider };
 }
 
 /** Persists the new-session page's defaults, so the next draft preselects the last-used picks. */
@@ -84,7 +72,6 @@ export const useNewSessionDefaultsStore = create<NewSessionDefaultsState>()(
     (set) => ({
       lastProvider: null,
       lastWorkspaceId: null,
-      modelsByProvider: {},
       effortsByProvider: {},
       branchesByWorkspace: {},
       remember: (provider, workspaceId, selection, branch) =>
@@ -101,12 +88,13 @@ export const useNewSessionDefaultsStore = create<NewSessionDefaultsState>()(
         set((state) => selectionPatch(state, provider, selection)),
     }),
     {
-      name: 'linkcode.workbench.new-session-defaults:v5',
+      // v6 drops `modelsByProvider`: the model pick now lives in daemon config, so a stale blob
+      // would resurrect a client-side memory that no longer has an owner.
+      name: 'linkcode.workbench.new-session-defaults:v6',
       schema: PersistedNewSessionDefaultsSchema,
       partialize: (state) => ({
         lastProvider: state.lastProvider,
         lastWorkspaceId: state.lastWorkspaceId,
-        modelsByProvider: state.modelsByProvider,
         effortsByProvider: state.effortsByProvider,
         branchesByWorkspace: state.branchesByWorkspace,
       }),
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index 2f87ef02..54ecde8d 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -61,6 +61,7 @@ import { useMutation } from '../runtime/tayori';
 import {
   useAccountModelOptions,
   useConfiguredDefaultModels,
+  usePersistPickedModel,
   useSessionModelOptions,
 } from '../settings/providers/default-models';
 import { RuntimeBranchStatus } from '../sidebar/branch-status';
@@ -278,7 +279,6 @@ function WorkbenchSessionSurface({
   const setThreadOrder = useSidebarOrderStore((state) => state.setThreadOrder);
   const lastProvider = useNewSessionDefaultsStore((state) => state.lastProvider);
   const lastWorkspaceId = useNewSessionDefaultsStore((state) => state.lastWorkspaceId);
-  const newSessionPreferredModels = useNewSessionDefaultsStore((state) => state.modelsByProvider);
   const newSessionPreferredEfforts = useNewSessionDefaultsStore((state) => state.effortsByProvider);
   const newSessionPreferredBranches = useNewSessionDefaultsStore(
     (state) => state.branchesByWorkspace,
@@ -286,6 +286,7 @@ function WorkbenchSessionSurface({
   const onboarding = useAgentRuntimeOnboarding();
   const rememberNewSessionDefaults = useNewSessionDefaultsStore((state) => state.remember);
   const rememberSelection = useNewSessionDefaultsStore((state) => state.rememberSelection);
+  const persistPickedModel = usePersistPickedModel();
   const [previewExpandedKeys, addPreviewExpanded, removePreviewExpanded] = useSet<string>();
   const threadGroups = useMemo<ThreadGroupViewModel[]>(() => {
     const { pinnedGroup, rest } = extractPinnedGroup(sessions.sessions, pinnedSessionIds);
@@ -412,7 +413,18 @@ function WorkbenchSessionSurface({
           sdkClient.raw.eventsSnapshot(sessionId),
         );
         if (newlyConfirmed.model === undefined && newlyConfirmed.effort === undefined) return;
-        rememberSelection(submission.kind, newlyConfirmed);
+        if (newlyConfirmed.effort !== undefined) {
+          rememberSelection(submission.kind, { effort: newlyConfirmed.effort });
+        }
+        // The model lands in daemon config rather than a client store, together with the account it
+        // came from, so Settings shows the rebind and non-composer sessions inherit the pick.
+        if (newlyConfirmed.model) {
+          void persistPickedModel(
+            submission.kind,
+            newlyConfirmed.model,
+            submission.accountId,
+          ).catch(noop);
+        }
       })
       .catch(noop);
   }
@@ -460,9 +472,9 @@ function WorkbenchSessionSurface({
     // onError (wired into modelMutation above) still reports the failure via the error banner.
     const provider = active?.kind;
     return modelMutation.trigger({ sessionId: sessions.activeId, model: model.id }).then(() => {
-      // The account is not part of a live switch — it is fixed at spawn, and this menu only ever
-      // offers the session's own account's models.
-      if (provider) rememberSelection(provider, { model: model.id });
+      // No account change: it is fixed at spawn, and this menu only ever offers the session's own
+      // account's models.
+      if (provider) void persistPickedModel(provider, model.id).catch(noop);
     });
   }
 
@@ -665,7 +677,6 @@ function WorkbenchSessionSurface({
       accountModels={accountModels}
       sessionModels={sessionModels}
       agentCatalogs={agentCatalogs}
-      newSessionPreferredModels={newSessionPreferredModels}
       newSessionPreferredEfforts={newSessionPreferredEfforts}
       newSessionPreferredBranches={newSessionPreferredBranches}
       NewSessionBranchPickerComponent={RuntimeNewSessionBranchPicker}
diff --git a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
index 4f1efa8d..57f88313 100644
--- a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
+++ b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
@@ -694,13 +694,14 @@ describe('NewSessionSurface', () => {
     expect(screen.getByRole('button', { name: RE_CONFIGURED_CLAUDE_MODEL })).toBeTruthy();
   });
 
-  it('shows and explicitly submits the last successful provider model without reselection', async () => {
+  it('shows and explicitly submits the configured model without reselection', async () => {
     const onSubmit = vi.fn().mockResolvedValue(undefined);
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        defaultModels={{ 'claude-code': 'custom/claude-model' }}
-        preferredModels={{ 'claude-code': 'claude-opus-4-8' }}
+        // The configured value *is* the last accepted pick now: it is persisted daemon-side rather
+        // than shadowed by a second client-side memory.
+        defaultModels={{ 'claude-code': 'claude-opus-4-8' }}
         draft={{
           initialProvider: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
@@ -717,9 +718,10 @@ describe('NewSessionSurface', () => {
     typeInComposer('use my last model');
     await pressInComposer('Enter');
 
-    await waitFor(() =>
-      expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({ model: 'claude-opus-4-8' })),
-    );
+    // Shown but not re-sent: the daemon resolves the configured model, so specifying it again would
+    // only risk the two disagreeing.
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    expect(onSubmit.mock.calls[0]?.[0]?.model).toBeUndefined();
   });
 
   it('drops remembered Codex ultra when the fallback model switches to Luna', async () => {
@@ -729,7 +731,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
         preferredEfforts={{ codex: 'ultra' }}
-        preferredModels={{ codex: 'gpt-5.6-sol' }}
+        defaultModels={{ codex: 'gpt-5.6-sol' }}
         draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
@@ -750,12 +752,12 @@ describe('NewSessionSurface', () => {
     expect(onSubmit.mock.calls[0]?.[0]).not.toHaveProperty('effort');
   });
 
-  it('submits a remembered dynamic-provider model even without a draft catalog', async () => {
+  it('shows a configured dynamic-provider model even without a draft catalog', async () => {
     const onSubmit = vi.fn().mockResolvedValue(undefined);
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        preferredModels={{ opencode: 'anthropic/claude-sonnet-4-6' }}
+        defaultModels={{ opencode: 'anthropic/claude-sonnet-4-6' }}
         draft={{ initialProvider: 'opencode', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
@@ -769,11 +771,8 @@ describe('NewSessionSurface', () => {
     typeInComposer('use remembered dynamic model');
     await pressInComposer('Enter');
 
-    await waitFor(() =>
-      expect(onSubmit).toHaveBeenCalledWith(
-        expect.objectContaining({ model: 'anthropic/claude-sonnet-4-6' }),
-      ),
-    );
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    expect(onSubmit.mock.calls[0]?.[0]?.model).toBeUndefined();
   });
 
   it('can return remembered model and effort choices to the configured ones', async () => {
@@ -784,7 +783,6 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ 'claude-code': 'configured/claude-model' }}
         preferredEfforts={{ 'claude-code': 'high' }}
-        preferredModels={{ 'claude-code': 'claude-opus-4-8' }}
         draft={{
           initialProvider: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
@@ -797,6 +795,11 @@ describe('NewSessionSurface', () => {
       />,
     );
 
+    // Pick a model locally, so there is something to reset back to the configured one.
+    await user.click(screen.getByRole('button', { name: RE_CONFIGURED_CLAUDE_MODEL }));
+    await user.click(await screen.findByRole('menuitem', { name: RE_MODEL_MENU }));
+    fireEvent.click(await screen.findByRole('menuitemradio', { name: 'Opus 4.8' }));
+
     await user.click(screen.getByRole('button', { name: RE_OPUS_4_8 }));
     await user.click(await screen.findByRole('menuitem', { name: 'resetToDefault' }));
     expect(screen.getByRole('button', { name: RE_CONFIGURED_CLAUDE_MODEL })).toBeTruthy();
@@ -1124,7 +1127,7 @@ describe('NewSessionSurface', () => {
     expect(screen.getByRole('button', { name: RE_PI_BASIC })).toBeTruthy();
   });
 
-  it("lets a remembered pick outrank the agent's own default", async () => {
+  it("lets the configured model outrank the agent's own default", async () => {
     const onSubmit = vi.fn().mockResolvedValue(undefined);
     render(
       <NewSessionSurface
@@ -1135,18 +1138,18 @@ describe('NewSessionSurface', () => {
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
         onSubmit={onSubmit}
-        preferredModels={{ pi: 'pi/basic' }}
+        defaultModels={{ pi: 'pi/basic' }}
         workspaces={[]}
       />,
     );
 
+    // The configured model wins the display over `catalog.defaultModel`; neither travels, since the
+    // daemon resolves the configured one itself.
     expect(screen.getByRole('button', { name: RE_PI_BASIC })).toBeTruthy();
     typeInComposer('use my last model');
     await pressInComposer('Enter');
-    // A remembered pick is an explicit choice, so unlike the catalog default it does travel.
-    await waitFor(() =>
-      expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({ model: 'pi/basic' })),
-    );
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledOnce());
+    expect(onSubmit.mock.calls[0]?.[0]?.model).toBeUndefined();
   });
 
   it('submits compatible Pi catalog choices and suppresses stale effort for models without it', async () => {
diff --git a/packages/presentation/ui/src/shell/new-session-surface.tsx b/packages/presentation/ui/src/shell/new-session-surface.tsx
index 52a6a995..e4ce734b 100644
--- a/packages/presentation/ui/src/shell/new-session-surface.tsx
+++ b/packages/presentation/ui/src/shell/new-session-surface.tsx
@@ -95,8 +95,6 @@ export interface NewSessionSurfaceProps {
   /** The models each agent may run on, picked on its bound account. An agent absent here has no
    * account bound and falls back to its adapter catalog or the curated table. */
   accountModels?: Readonly<Partial<Record<AgentKind, ModelOption[]>>> | null;
-  /** Last accepted model per provider. Unlike configured defaults, this is an explicit override. */
-  preferredModels?: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last accepted effort per provider. Missing kinds retain the provider default. */
   preferredEfforts?: Readonly<Partial<Record<AgentKind, EffortLevel>>>;
   /** Last successfully used branch and checkout mode per workspace. */
@@ -151,7 +149,6 @@ export function NewSessionSurface({
   agentCatalogs,
   defaultModels,
   accountModels,
-  preferredModels,
   preferredEfforts,
   preferredBranches,
   NewSessionBranchPickerComponent,
@@ -191,8 +188,7 @@ export function NewSessionSurface({
   const branchMode = selectedBranch?.mode ?? 'local';
   const catalog = agentCatalogs?.[provider];
   const localModel = selectedModels[provider];
-  const selectedModel =
-    localModel === undefined ? (preferredModels?.[provider] ?? null) : localModel;
+  const selectedModel = localModel === undefined ? null : localModel;
   // The catalog default is what the agent's own config would start on, so it yields to anything the
   // user expressed through LinkCode. Nothing guesses past it: an unresolved model blocks the send
   // rather than starting a session on a model nobody chose.
diff --git a/packages/presentation/ui/src/shell/shell-frame.tsx b/packages/presentation/ui/src/shell/shell-frame.tsx
index 3340ec68..7c9d5c33 100644
--- a/packages/presentation/ui/src/shell/shell-frame.tsx
+++ b/packages/presentation/ui/src/shell/shell-frame.tsx
@@ -64,8 +64,6 @@ export interface ShellFrameProps
   /** The active session's own account's models — the whole live menu, since a running session's
    * account is fixed at spawn. */
   sessionModels?: ModelOption[];
-  /** Last model accepted by LinkCode per provider, submitted as a new-session override. */
-  newSessionPreferredModels: Readonly<Partial<Record<AgentKind, string>>>;
   /** Last effort accepted by LinkCode per provider for new sessions. */
   newSessionPreferredEfforts: Readonly<Partial<Record<AgentKind, EffortLevel>>>;
   newSessionPreferredBranches: Readonly<Record<string, BranchSelection>>;
@@ -140,7 +138,6 @@ export function ShellFrame({
   newSessionDefaultModels,
   accountModels,
   sessionModels,
-  newSessionPreferredModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
   NewSessionBranchPickerComponent,
@@ -232,7 +229,6 @@ export function ShellFrame({
             agentCatalogs={agentCatalogs}
             defaultModels={newSessionDefaultModels}
             accountModels={accountModels}
-            preferredModels={newSessionPreferredModels}
             preferredEfforts={newSessionPreferredEfforts}
             preferredBranches={newSessionPreferredBranches}
             NewSessionBranchPickerComponent={NewSessionBranchPickerComponent}

From 12fde6175f757e7ba0164098ba95a3197ed424f3 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Thu, 6 Aug 2026 21:51:43 +0800
Subject: [PATCH 09/17] refactor(ui,workbench,i18n): call the agent a Harness,
 not a provider
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

"Provider" meant two different things in adjacent UI: the composer's provider
picker chose the *agent*, while the Providers settings page means accounts.
`onOpenProviderSettings: (kind: AgentKind) => void` had both in one signature.

Agent-meaning UI text and client identifiers now say harness —
`selectableHarnesses`, `onHarnessChange`, `lastHarness`, and the composer's menu
label. Account-meaning strings keep "provider", `AgentKind` and every wire and
daemon term are untouched, and `groupModelsByProvider` stays as the one genuine
model-provider use. Same UI/i18n-only discipline already recorded for
Thread/`session`.

Two things this turned up. Translation keys are not typechecked, so the rename
would have silently emptied strings — a test asserting the old menu label is what
caught it. And the store test had hand-copied its storage key, which drifted at
the previous version bump and had quietly turned the malformed-blob test into a
vacuous pass; the key is now exported and imported, and the test verified to fail
against a well-formed blob.
---
 AGENTS.md                                     |  1 +
 .../src/settings/history-import-tab.tsx       |  2 +-
 .../new-session-defaults-store.test.ts        |  9 ++-
 .../src/surface/new-session-defaults-store.ts | 23 ++++--
 .../workbench/src/surface/workbench.tsx       |  4 +-
 packages/presentation/i18n/src/locales/en.ts  | 10 +--
 .../presentation/i18n/src/locales/zh-cn.ts    | 10 +--
 .../__tests__/new-session-surface.test.tsx    | 78 +++++++++----------
 .../ui/src/shell/composer-controls.tsx        | 50 ++++++------
 .../presentation/ui/src/shell/composer.tsx    | 26 +++----
 .../ui/src/shell/new-session-surface.tsx      | 68 ++++++++--------
 .../ui/src/shell/plugins/plugins-tab.tsx      |  4 +-
 12 files changed, 148 insertions(+), 137 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index ee0d1beb..e9f69d6b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -92,6 +92,7 @@ Large rewrites are encouraged when they're the right fix — replace subsystems
 - Keep table-definition / schema modules free of hooks and browser APIs so they stay importable anywhere.
 - Directory names must describe responsibility, not incidental data. For example, a sidebar footer belongs with sidebar/workbench presentation, not in a `host/` folder just because it displays host state; a layout adapter belongs under layout, not a one-file pseudo-subsystem.
 - Terminology: the product term **Thread** is the code/wire term **`session`** — the rename is UI/i18n-only. Never rename `session` in wire or code identifiers.
+- Terminology: **"provider" means the account/service** (DeepSeek, OpenRouter) — never the agent. The agent is a **Harness**, so client-side UI text and identifiers use that (`selectableHarnesses`, `onHarnessChange`, `lastHarness`); `AgentKind` and every wire/daemon term stay as they are. The two meanings used to collide in adjacent UI — the composer's "provider" picker chose the *agent* while the Providers settings page meant accounts. `groupModelsByProvider` is the genuine exception: it groups by *model* provider.
 
 ## Tooling And Aliases
 
diff --git a/apps/desktop/src/renderer/src/settings/history-import-tab.tsx b/apps/desktop/src/renderer/src/settings/history-import-tab.tsx
index e153a5cc..b8e72466 100644
--- a/apps/desktop/src/renderer/src/settings/history-import-tab.tsx
+++ b/apps/desktop/src/renderer/src/settings/history-import-tab.tsx
@@ -71,7 +71,7 @@ export function HistoryImportTab({ kind }: { kind: AgentKind }): React.ReactNode
     <>
       <DesktopChromePortal segment="main" position="left" className="gap-2 px-2">
         <span className="min-w-0 truncate font-semibold text-sm">
-          {t('panelTitle', { provider: AGENT_LABELS[kind] })}
+          {t('panelTitle', { harness: AGENT_LABELS[kind] })}
         </span>
         {surface.count > 0 && (
           <span className="shrink-0 text-muted-foreground text-xs">
diff --git a/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts b/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
index 84472fe8..7a98d95a 100644
--- a/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
+++ b/packages/client/workbench/src/surface/__tests__/new-session-defaults-store.test.ts
@@ -1,7 +1,10 @@
 import { WorkspaceIdSchema } from '@linkcode/schema';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { NEW_SESSION_DEFAULTS_STORAGE_KEY } from '../new-session-defaults-store';
 
-const STORAGE_KEY = 'linkcode.workbench.new-session-defaults:v5';
+// Imported rather than restated: a hand-copied key drifted once, and the mismatch turned the
+// malformed-blob test below into a vacuous pass.
+const STORAGE_KEY = NEW_SESSION_DEFAULTS_STORAGE_KEY;
 const WORKSPACE_ID = WorkspaceIdSchema.parse('workspace-1');
 const stored = new Map<string, string>();
 const storage = {
@@ -75,7 +78,7 @@ describe('new-session defaults', () => {
       STORAGE_KEY,
       JSON.stringify({
         state: {
-          lastProvider: 'codex',
+          lastHarness: 'codex',
           lastWorkspaceId: WORKSPACE_ID,
           effortsByProvider: { codex: 'unsupported' },
         },
@@ -85,7 +88,7 @@ describe('new-session defaults', () => {
 
     const store = await loadStore();
 
-    expect(store.getState().lastProvider).toBeNull();
+    expect(store.getState().lastHarness).toBeNull();
     expect(store.getState().effortsByProvider).toEqual({});
     expect(store.getState().branchesByWorkspace).toEqual({});
   });
diff --git a/packages/client/workbench/src/surface/new-session-defaults-store.ts b/packages/client/workbench/src/surface/new-session-defaults-store.ts
index b4eb6e54..577494a8 100644
--- a/packages/client/workbench/src/surface/new-session-defaults-store.ts
+++ b/packages/client/workbench/src/surface/new-session-defaults-store.ts
@@ -9,9 +9,18 @@ import {
 import { z } from 'zod';
 import { create } from 'zustand';
 
+/**
+ * Exported so tests cannot drift from it — one did, and a silent key mismatch turned the
+ * malformed-blob test into a vacuous pass.
+ *
+ * v6 dropped `modelsByProvider` (the model pick moved to daemon config) and v7 renamed
+ * `lastProvider` to `lastHarness`; a stale blob is discarded by the schema either way.
+ */
+export const NEW_SESSION_DEFAULTS_STORAGE_KEY = 'linkcode.workbench.new-session-defaults:v7';
+
 const PersistedNewSessionDefaultsSchema = z
   .object({
-    lastProvider: AgentKindSchema.nullable(),
+    lastHarness: AgentKindSchema.nullable(),
     lastWorkspaceId: WorkspaceIdSchema.nullable(),
     effortsByProvider: z.partialRecord(AgentKindSchema, EffortLevelSchema),
     branchesByWorkspace: z.record(z.string(), BranchSelectionSchema),
@@ -29,7 +38,7 @@ export interface NewSessionSelection {
 
 export interface NewSessionDefaultsState {
   /** Provider of the last successful new-session submit; null before the first (→ claude-code). */
-  lastProvider: AgentKind | null;
+  lastHarness: AgentKind | null;
   /** Workspace of the last successful submit; ids that no longer exist are skipped at resolve time. */
   lastWorkspaceId: WorkspaceId | null;
   /** Last effort accepted by LinkCode per provider; absent means defer to the provider default. */
@@ -70,14 +79,14 @@ export const useNewSessionDefaultsStore = create<NewSessionDefaultsState>()(
     PersistedNewSessionDefaults
   >(
     (set) => ({
-      lastProvider: null,
+      lastHarness: null,
       lastWorkspaceId: null,
       effortsByProvider: {},
       branchesByWorkspace: {},
       remember: (provider, workspaceId, selection, branch) =>
         set((state) => ({
           ...selectionPatch(state, provider, selection),
-          lastProvider: provider,
+          lastHarness: provider,
           lastWorkspaceId: workspaceId,
           branchesByWorkspace:
             branch === undefined
@@ -88,12 +97,10 @@ export const useNewSessionDefaultsStore = create<NewSessionDefaultsState>()(
         set((state) => selectionPatch(state, provider, selection)),
     }),
     {
-      // v6 drops `modelsByProvider`: the model pick now lives in daemon config, so a stale blob
-      // would resurrect a client-side memory that no longer has an owner.
-      name: 'linkcode.workbench.new-session-defaults:v6',
+      name: NEW_SESSION_DEFAULTS_STORAGE_KEY,
       schema: PersistedNewSessionDefaultsSchema,
       partialize: (state) => ({
-        lastProvider: state.lastProvider,
+        lastHarness: state.lastHarness,
         lastWorkspaceId: state.lastWorkspaceId,
         effortsByProvider: state.effortsByProvider,
         branchesByWorkspace: state.branchesByWorkspace,
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index 54ecde8d..0a0f64c6 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -277,7 +277,7 @@ function WorkbenchSessionSurface({
   const threadOrder = useSidebarOrderStore((state) => state.threadOrder);
   const setGroupOrder = useSidebarOrderStore((state) => state.setGroupOrder);
   const setThreadOrder = useSidebarOrderStore((state) => state.setThreadOrder);
-  const lastProvider = useNewSessionDefaultsStore((state) => state.lastProvider);
+  const lastHarness = useNewSessionDefaultsStore((state) => state.lastHarness);
   const lastWorkspaceId = useNewSessionDefaultsStore((state) => state.lastWorkspaceId);
   const newSessionPreferredEfforts = useNewSessionDefaultsStore((state) => state.effortsByProvider);
   const newSessionPreferredBranches = useNewSessionDefaultsStore(
@@ -591,7 +591,7 @@ function WorkbenchSessionSurface({
   const draft: NewSessionDraft | null = sessions.draft
     ? {
         initialWorkspaceId,
-        initialProvider: lastProvider ?? 'claude-code',
+        initialHarness: lastHarness ?? 'claude-code',
       }
     : null;
 
diff --git a/packages/presentation/i18n/src/locales/en.ts b/packages/presentation/i18n/src/locales/en.ts
index 5faf0e3f..be5f1269 100644
--- a/packages/presentation/i18n/src/locales/en.ts
+++ b/packages/presentation/i18n/src/locales/en.ts
@@ -348,7 +348,7 @@ export const en = {
       attachmentUnsupportedAgent: "This agent doesn't support image attachments yet",
       attachmentReadFailed: 'Failed to read the file',
       approvalTitle: 'How should {agent} actions be approved?',
-      provider: 'Provider',
+      harness: 'Harness',
     },
     mode: {
       label: 'Mode',
@@ -768,9 +768,9 @@ export const en = {
       tabMarket: 'Market',
       tabMcp: 'MCP',
       tabSkills: 'Skills',
-      discoveryFailed: 'Could not read {provider} plugins: {reason}',
+      discoveryFailed: 'Could not read {harness} plugins: {reason}',
       discoveryFailedUnknown: 'discovery failed',
-      runtimeMissing: '{provider} was not detected; install it to manage its plugins here.',
+      runtimeMissing: '{harness} was not detected; install it to manage its plugins here.',
       installedEmptyHint: 'No plugins installed for this agent yet — pick one from Market.',
       marketEmptyHint: 'No installable entries in this agent’s plugin marketplace.',
       marketCount: '{count} available',
@@ -867,7 +867,7 @@ export const en = {
     },
     historyImport: {
       portalLabel: 'Import chat history',
-      panelTitle: 'Import chat history from {provider}',
+      panelTitle: 'Import chat history from {harness}',
       conversationCount: '{count, plural, one {# conversation} other {# conversations}}',
       refresh: 'Refresh',
       sortLabel: 'Sort order',
@@ -880,7 +880,7 @@ export const en = {
       importedBadge: 'Imported',
       open: 'Open',
       emptyTitle: 'No history yet',
-      emptyHint: 'This provider has no local conversation history on this machine.',
+      emptyHint: 'This harness has no local conversation history on this machine.',
       loadFailedTitle: 'Failed to load history',
       retry: 'Retry',
       showingLatest:
diff --git a/packages/presentation/i18n/src/locales/zh-cn.ts b/packages/presentation/i18n/src/locales/zh-cn.ts
index 3f88e8cb..7650c538 100644
--- a/packages/presentation/i18n/src/locales/zh-cn.ts
+++ b/packages/presentation/i18n/src/locales/zh-cn.ts
@@ -338,7 +338,7 @@ export const zhCN = {
       attachmentUnsupportedAgent: '当前 agent 暂不支持图片附件',
       attachmentReadFailed: '读取文件失败',
       approvalTitle: '如何审批 {agent} 的操作？',
-      provider: '提供方',
+      harness: '编码助手',
     },
     mode: {
       label: '模式',
@@ -753,9 +753,9 @@ export const zhCN = {
       tabMarket: '市场',
       tabMcp: 'MCP',
       tabSkills: '技能',
-      discoveryFailed: '无法读取 {provider} 的插件：{reason}',
+      discoveryFailed: '无法读取 {harness} 的插件：{reason}',
       discoveryFailedUnknown: '扫描失败',
-      runtimeMissing: '未检测到 {provider}，安装后即可在这里管理它的插件。',
+      runtimeMissing: '未检测到 {harness}，安装后即可在这里管理它的插件。',
       installedEmptyHint: '该智能体还没有安装任何插件；到「市场」里挑一个。',
       marketEmptyHint: '该智能体的插件市场里没有可安装的条目。',
       marketCount: '{count} 个可安装',
@@ -850,7 +850,7 @@ export const zhCN = {
     },
     historyImport: {
       portalLabel: '导入聊天历史',
-      panelTitle: '从 {provider} 导入聊天历史',
+      panelTitle: '从 {harness} 导入聊天历史',
       conversationCount: '{count} 条对话',
       refresh: '刷新',
       sortLabel: '排序方式',
@@ -863,7 +863,7 @@ export const zhCN = {
       importedBadge: '已导入',
       open: '打开',
       emptyTitle: '暂无历史对话',
-      emptyHint: '该提供方在本机还没有历史对话。',
+      emptyHint: '该编码助手在本机还没有历史对话。',
       loadFailedTitle: '无法加载历史记录',
       retry: '重试',
       showingLatest: '仅显示最近 {count} 条对话',
diff --git a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
index 57f88313..4a16c31e 100644
--- a/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
+++ b/packages/presentation/ui/src/shell/__tests__/new-session-surface.test.tsx
@@ -56,7 +56,7 @@ const RE_PI_WIDE = /Pi Wide/;
 const RE_HIGH_EFFORT = /High/;
 const RE_LOW_EFFORT = /Low/;
 const RE_GPT_56_SOL = /GPT-5.6-Sol/;
-const RE_PROVIDER_CLAUDE_CODE_MENU = /provider.*Claude Code/;
+const RE_HARNESS_CLAUDE_CODE_MENU = /harness.*Claude Code/;
 const RE_MODEL_SONNET_5_MENU = /model.*Sonnet 5/;
 const RE_OPUS_5 = /Opus 5/;
 const RE_MODEL_MENU = /^model/;
@@ -122,7 +122,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={null}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: null }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: null }}
         mentionItems={[]}
         runtimeCues={{ codex: { state: 'needs-login', phase: 'idle' } }}
         onMentionQueryChange={vi.fn()}
@@ -147,7 +147,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         NewSessionBranchPickerComponent={BranchPicker}
         chatWorkspace={selection.chatWorkspace}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: selection.initialWorkspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: selection.initialWorkspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn()}
@@ -165,7 +165,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         NewSessionBranchPickerComponent={BranchPickerTest}
         chatWorkspace={null}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: PROJECT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: PROJECT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn()}
@@ -191,7 +191,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         NewSessionBranchPickerComponent={BranchPickerTest}
         chatWorkspace={null}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: PROJECT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: PROJECT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn()}
@@ -220,7 +220,7 @@ describe('NewSessionSurface', () => {
         <NewSessionSurface
           chatWorkspace={CHAT_WORKSPACE}
           draft={{
-            initialProvider: provider,
+            initialHarness: provider,
             initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
           }}
           mentionItems={[]}
@@ -253,7 +253,7 @@ describe('NewSessionSurface', () => {
       render(
         <NewSessionSurface
           chatWorkspace={CHAT_WORKSPACE}
-          draft={{ initialProvider: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+          draft={{ initialHarness: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
           mentionItems={[]}
           onMentionQueryChange={vi.fn()}
           onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -270,7 +270,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -290,7 +290,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         // Nothing guesses a model any more, so the configured one has to be supplied.
         defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
-        draft={{ initialProvider: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -313,7 +313,7 @@ describe('NewSessionSurface', () => {
       render(
         <NewSessionSurface
           chatWorkspace={CHAT_WORKSPACE}
-          draft={{ initialProvider: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+          draft={{ initialHarness: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
           mentionItems={[]}
           onMentionQueryChange={vi.fn()}
           onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -338,7 +338,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -377,7 +377,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         attachmentSupport={{ codex: true }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -424,7 +424,7 @@ describe('NewSessionSurface', () => {
         <NewSessionSurface
           attachmentSupport={{ codex: true }}
           chatWorkspace={CHAT_WORKSPACE}
-          draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+          draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
           mentionItems={[]}
           onMentionQueryChange={vi.fn()}
           onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -488,7 +488,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         attachmentSupport={{ codex: true }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -524,7 +524,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'grok-build', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'grok-build', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -548,7 +548,7 @@ describe('NewSessionSurface', () => {
       render(
         <NewSessionSurface
           chatWorkspace={CHAT_WORKSPACE}
-          draft={{ initialProvider: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+          draft={{ initialHarness: provider, initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
           mentionItems={[]}
           onMentionQueryChange={vi.fn()}
           onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -573,7 +573,7 @@ describe('NewSessionSurface', () => {
         // Nothing guesses a model any more, so the configured one has to be supplied.
         defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -586,7 +586,7 @@ describe('NewSessionSurface', () => {
 
     await user.click(screen.getByRole('button', { name: RE_SONNET_5 }));
     const providerItem = await screen.findByRole('menuitem', {
-      name: RE_PROVIDER_CLAUDE_CODE_MENU,
+      name: RE_HARNESS_CLAUDE_CODE_MENU,
     });
     expect(screen.getByRole('menuitem', { name: RE_MODEL_SONNET_5_MENU })).toBeTruthy();
     providerItem.focus();
@@ -616,7 +616,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         preferredEfforts={{ 'claude-code': 'medium' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -643,7 +643,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ 'claude-code': 'custom/claude-model' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -668,7 +668,7 @@ describe('NewSessionSurface', () => {
     const props = {
       chatWorkspace: CHAT_WORKSPACE,
       draft: {
-        initialProvider: 'claude-code' as const,
+        initialHarness: 'claude-code' as const,
         initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
       },
       mentionItems: [],
@@ -703,7 +703,7 @@ describe('NewSessionSurface', () => {
         // than shadowed by a second client-side memory.
         defaultModels={{ 'claude-code': 'claude-opus-4-8' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -732,7 +732,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         preferredEfforts={{ codex: 'ultra' }}
         defaultModels={{ codex: 'gpt-5.6-sol' }}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -758,7 +758,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ opencode: 'anthropic/claude-sonnet-4-6' }}
-        draft={{ initialProvider: 'opencode', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'opencode', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -784,7 +784,7 @@ describe('NewSessionSurface', () => {
         defaultModels={{ 'claude-code': 'configured/claude-model' }}
         preferredEfforts={{ 'claude-code': 'high' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -841,7 +841,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ 'claude-code': 'claude-opus-5' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -877,7 +877,7 @@ describe('NewSessionSurface', () => {
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ 'claude-code': 'deepseek-v4-pro' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -903,7 +903,7 @@ describe('NewSessionSurface', () => {
         accountModels={{ 'claude-code': [] }}
         chatWorkspace={CHAT_WORKSPACE}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -929,7 +929,7 @@ describe('NewSessionSurface', () => {
         // Nothing guesses a model any more, so the configured one has to be supplied.
         defaultModels={{ 'claude-code': 'claude-sonnet-5' }}
         draft={{
-          initialProvider: 'claude-code',
+          initialHarness: 'claude-code',
           initialWorkspaceId: CHAT_WORKSPACE.workspaceId,
         }}
         mentionItems={[]}
@@ -964,7 +964,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'claude-code', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1000,7 +1000,7 @@ describe('NewSessionSurface', () => {
           },
         }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1026,7 +1026,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         agentCatalogs={{ pi: PI_CONFIGURED_CATALOG }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1053,7 +1053,7 @@ describe('NewSessionSurface', () => {
           pi: { ...PI_CONFIGURED_CATALOG, defaultModel: 'pi/basic' },
         }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1072,7 +1072,7 @@ describe('NewSessionSurface', () => {
         agentCatalogs={{ pi: PI_CONFIGURED_CATALOG }}
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ pi: 'pi/wide' }}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1095,7 +1095,7 @@ describe('NewSessionSurface', () => {
         agentCatalogs={{ pi: modelless }}
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ pi: 'pi/wide' }}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1115,7 +1115,7 @@ describe('NewSessionSurface', () => {
         agentCatalogs={{ pi: PI_CONFIGURED_CATALOG }}
         chatWorkspace={CHAT_WORKSPACE}
         defaultModels={{ pi: 'pi/basic' }}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1133,7 +1133,7 @@ describe('NewSessionSurface', () => {
       <NewSessionSurface
         agentCatalogs={{ pi: PI_CONFIGURED_CATALOG }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1171,7 +1171,7 @@ describe('NewSessionSurface', () => {
           },
         }}
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'pi', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[]}
         onMentionQueryChange={vi.fn()}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
@@ -1220,7 +1220,7 @@ describe('NewSessionSurface', () => {
     render(
       <NewSessionSurface
         chatWorkspace={CHAT_WORKSPACE}
-        draft={{ initialProvider: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
+        draft={{ initialHarness: 'codex', initialWorkspaceId: CHAT_WORKSPACE.workspaceId }}
         mentionItems={[{ id: 'package.json', label: 'package.json', value: 'package.json' }]}
         onMentionQueryChange={onMentionQueryChange}
         onRegisterWorkspace={vi.fn().mockResolvedValue(CHAT_WORKSPACE)}
diff --git a/packages/presentation/ui/src/shell/composer-controls.tsx b/packages/presentation/ui/src/shell/composer-controls.tsx
index 1b8f4b18..b62438ca 100644
--- a/packages/presentation/ui/src/shell/composer-controls.tsx
+++ b/packages/presentation/ui/src/shell/composer-controls.tsx
@@ -145,7 +145,7 @@ export function ApprovalPolicyMenu({
   );
 }
 
-// Known workflow-mode glyphs; unknown provider modes fall back to a generic one.
+// Known workflow-mode glyphs; unknown harness modes fall back to a generic one.
 const MODE_CHIP_ICONS: Record<string, typeof ListTodoIcon> = {
   plan: ListTodoIcon,
   goal: TargetIcon,
@@ -182,7 +182,7 @@ export function SessionModeChip({
   );
 }
 
-/** Availability badge on a provider submenu item; nothing renders for a ready runtime. */
+/** Availability badge on a harness submenu item; nothing renders for a ready runtime. */
 function RuntimeCueBadge({ cue }: { cue?: AgentRuntimeCue }): React.ReactNode {
   const t = useTranslations('workbench.agentRuntime');
   if (!cue) return null;
@@ -213,8 +213,8 @@ function RuntimeCueBadge({ cue }: { cue?: AgentRuntimeCue }): React.ReactNode {
 
 export function ModelSelectorMenu({
   disabled,
-  provider,
-  selectableProviders,
+  harness,
+  selectableHarnesses,
   runtimeCues,
   modelOptions,
   effortOptions,
@@ -225,13 +225,13 @@ export function ModelSelectorMenu({
   onSelectEffort,
   onResetModel,
   onResetEffort,
-  onSelectProvider,
+  onSelectHarness,
 }: {
   disabled: boolean;
-  provider?: AgentKind;
-  /** Providers offered for selection; absent/empty when the session's provider is fixed. */
-  selectableProviders?: AgentKind[];
-  /** Runtime availability per provider: a cue renders as a muted badge on the submenu item. */
+  harness?: AgentKind;
+  /** Harnesses offered for selection; absent/empty when the session's harness is fixed. */
+  selectableHarnesses?: AgentKind[];
+  /** Runtime availability per harness: a cue renders as a muted badge on the submenu item. */
   runtimeCues?: AgentRuntimeCues;
   modelOptions?: ModelOption[];
   effortOptions?: EffortOption[];
@@ -242,11 +242,11 @@ export function ModelSelectorMenu({
   /** Carries the whole entry: a cross-account list needs the account alongside the id. */
   onSelectModel: (model: ModelOption) => void;
   onSelectEffort: (effort: EffortLevel) => void;
-  /** Draft-only escape hatch back to the provider/configured model default. */
+  /** Draft-only escape hatch back to the harness/configured model default. */
   onResetModel?: () => void;
-  /** Draft-only escape hatch back to the provider effort default. */
+  /** Draft-only escape hatch back to the harness effort default. */
   onResetEffort?: () => void;
-  onSelectProvider?: (provider: AgentKind) => void;
+  onSelectHarness?: (harness: AgentKind) => void;
 }): React.ReactNode {
   const t = useTranslations('workbench.composer');
   const selectedModel = resolveModel(modelOptions, selectedModelId, selectedAccountId);
@@ -254,18 +254,18 @@ export function ModelSelectorMenu({
   const selectedEffort =
     optionById(effortOptions, selectedEffortId) ??
     (selectedEffortId ? EFFORT_OPTIONS_BY_ID[selectedEffortId] : undefined);
-  const providers = selectableProviders ?? [];
+  const harnesses = selectableHarnesses ?? [];
   const hasEfforts = Boolean(effortOptions?.length);
   const hasModels = Boolean(modelOptions?.length);
   const modelLabel = selectedModel?.label ?? selectedModelId ?? t('modelDefault');
   const effortLabel = selectedEffort?.label ?? t('effortDefault');
-  // A draft provider picker must keep the model axis visible even when that provider discovers
+  // A draft harness picker must keep the model axis visible even when that harness discovers
   // its concrete model only after session start (OpenCode/Pi). The live update replaces Default.
-  const showsModel = providers.length > 0 || hasModels || selectedModelId !== null;
+  const showsModel = harnesses.length > 0 || hasModels || selectedModelId !== null;
 
-  if (!hasEfforts && !showsModel && providers.length === 0) return null;
+  if (!hasEfforts && !showsModel && harnesses.length === 0) return null;
   const selectorLabels: string[] = [];
-  if (provider) selectorLabels.push(AGENT_LABELS[provider]);
+  if (harness) selectorLabels.push(AGENT_LABELS[harness]);
   if (showsModel) selectorLabels.push(modelLabel);
   if (hasEfforts) selectorLabels.push(`${t('effort')}: ${effortLabel}`);
 
@@ -276,7 +276,7 @@ export function ModelSelectorMenu({
         disabled={disabled}
         render={<Button className="shrink-0" size="sm" type="button" variant="ghost" />}
       >
-        {provider && providers.length > 0 ? <AgentIcon kind={provider} variant="brand" /> : null}
+        {harness && harnesses.length > 0 ? <AgentIcon kind={harness} variant="brand" /> : null}
         {showsModel ? modelLabel : null}
         {hasEfforts ? (
           <span className="flex items-center gap-2 font-normal text-muted-foreground">
@@ -290,23 +290,23 @@ export function ModelSelectorMenu({
         <ChevronDownIcon className="size-3 text-label-tertiary" />
       </MenuTrigger>
       <MenuPopup align="end" className="w-56" side="top" sideOffset={8}>
-        {onSelectProvider && providers.length > 0 ? (
+        {onSelectHarness && harnesses.length > 0 ? (
           <MenuSub>
             <MenuSubTrigger>
-              <span>{t('provider')}</span>
+              <span>{t('harness')}</span>
               <span className="flex min-w-0 flex-1 items-center justify-end gap-1.5 text-muted-foreground">
-                {provider ? <AgentIcon kind={provider} variant="brand" /> : null}
+                {harness ? <AgentIcon kind={harness} variant="brand" /> : null}
                 <span className="truncate">
-                  {provider ? AGENT_LABELS[provider] : t('modelDefault')}
+                  {harness ? AGENT_LABELS[harness] : t('modelDefault')}
                 </span>
               </span>
             </MenuSubTrigger>
             <MenuSubPopup className="w-60">
               <MenuRadioGroup
-                value={provider ?? ''}
-                onValueChange={(value) => onSelectProvider(value as AgentKind)}
+                value={harness ?? ''}
+                onValueChange={(value) => onSelectHarness(value as AgentKind)}
               >
-                {providers.map((kind) => (
+                {harnesses.map((kind) => (
                   <MenuRadioItem key={kind} className="pe-2" closeOnClick value={kind}>
                     <span className="flex min-w-0 items-center justify-between gap-2">
                       <span className="flex min-w-0 items-center gap-2">
diff --git a/packages/presentation/ui/src/shell/composer.tsx b/packages/presentation/ui/src/shell/composer.tsx
index aa0d8d2f..e2541245 100644
--- a/packages/presentation/ui/src/shell/composer.tsx
+++ b/packages/presentation/ui/src/shell/composer.tsx
@@ -185,12 +185,12 @@ export interface ComposerProps {
   onResetModel?: () => void;
   /** Clears a draft's explicit effort override. Omitted for live sessions. */
   onResetEffort?: () => void;
-  /** Providers offered for selection (the new-session composer). Absent or empty means the
-   * provider is fixed — the trigger then hides the provider glyph and submenu. */
-  selectableProviders?: AgentKind[];
-  /** Runtime availability badges for the provider submenu (CODE-112). */
+  /** Harnesses offered for selection (the new-session composer). Absent or empty means the
+   * harness is fixed — the trigger then hides the harness glyph and submenu. */
+  selectableHarnesses?: AgentKind[];
+  /** Runtime availability badges for the harness submenu (CODE-112). */
   runtimeCues?: AgentRuntimeCues;
-  onProviderChange?: (provider: AgentKind) => Promise<void>;
+  onHarnessChange?: (harness: AgentKind) => Promise<void>;
   /** Strip rendered at the bottom of the composer card (e.g. the new-session workspace bar). */
   contextBar?: React.ReactNode;
   /** Opens a native file picker and returns the picked images, ready to stage. Absent (webview):
@@ -236,9 +236,9 @@ export function Composer({
   onEffortChange,
   onResetModel,
   onResetEffort,
-  selectableProviders,
+  selectableHarnesses,
   runtimeCues,
-  onProviderChange,
+  onHarnessChange,
   contextBar,
   onPickAttachmentFiles,
 }: ComposerProps): React.ReactNode {
@@ -1026,9 +1026,9 @@ export function Composer({
                     disabled={interactionDisabled}
                     effortOptions={effortOptions}
                     modelOptions={modelOptions}
-                    provider={agentKind}
+                    harness={agentKind}
                     runtimeCues={runtimeCues}
-                    selectableProviders={selectableProviders}
+                    selectableHarnesses={selectableHarnesses}
                     selectedAccountId={currentAccountId}
                     selectedEffortId={currentEffort ?? null}
                     selectedModelId={currentModel ?? null}
@@ -1036,10 +1036,10 @@ export function Composer({
                     onResetModel={onResetModel}
                     onSelectEffort={selectEffort}
                     onSelectModel={selectModel}
-                    onSelectProvider={
-                      onProviderChange
-                        ? (provider) => {
-                            void onProviderChange(provider).catch(noop);
+                    onSelectHarness={
+                      onHarnessChange
+                        ? (harness) => {
+                            void onHarnessChange(harness).catch(noop);
                           }
                         : undefined
                     }
diff --git a/packages/presentation/ui/src/shell/new-session-surface.tsx b/packages/presentation/ui/src/shell/new-session-surface.tsx
index e4ce734b..0e4ee620 100644
--- a/packages/presentation/ui/src/shell/new-session-surface.tsx
+++ b/packages/presentation/ui/src/shell/new-session-surface.tsx
@@ -48,7 +48,7 @@ import { DEFAULT_MODE_ID } from './session-modes';
 export interface NewSessionDraft {
   /** Resolved by the workbench (explicit pick → last used → chat → first project); null = none available. */
   initialWorkspaceId: WorkspaceId | null;
-  initialProvider: AgentKind;
+  initialHarness: AgentKind;
 }
 
 export interface NewSessionSubmission {
@@ -60,7 +60,7 @@ export interface NewSessionSubmission {
   model?: string;
   /** The account the picked model belongs to, pinning the session to it. */
   accountId?: string;
-  /** Null explicitly returns this provider to its default effort. */
+  /** Null explicitly returns this harness to its default effort. */
   effort?: EffortLevel | null;
   approvalPolicyId?: string;
   modeId?: SessionModeId;
@@ -84,18 +84,18 @@ export interface NewSessionSurfaceProps {
   className?: string;
   topContent?: React.ReactNode;
   /** Runtime availability per agent (CODE-112): a cue renders the onboarding card for the picked
-   * provider and blocks sending until the runtime is ready; badges ride the provider submenu. */
+   * harness and blocks sending until the runtime is ready; badges ride the harness submenu. */
   runtimeCues?: AgentRuntimeCues;
   /** Frontend capability stub used until attachment support is advertised by sessions. */
   attachmentSupport?: AttachmentSupportByAgent;
   agentCatalogs?: AgentStartCatalogs;
   /** Effective user-configured model defaults. `null` means they are still loading; when omitted,
-   * built-in provider defaults fill missing kinds for standalone consumers. */
+   * built-in harness defaults fill missing kinds for standalone consumers. */
   defaultModels?: Readonly<Partial<Record<AgentKind, string>>> | null;
   /** The models each agent may run on, picked on its bound account. An agent absent here has no
    * account bound and falls back to its adapter catalog or the curated table. */
   accountModels?: Readonly<Partial<Record<AgentKind, ModelOption[]>>> | null;
-  /** Last accepted effort per provider. Missing kinds retain the provider default. */
+  /** Last accepted effort per harness. Missing kinds retain the harness default. */
   preferredEfforts?: Readonly<Partial<Record<AgentKind, EffortLevel>>>;
   /** Last successfully used branch and checkout mode per workspace. */
   preferredBranches?: Readonly<Record<string, BranchSelection>>;
@@ -121,7 +121,7 @@ export interface NewSessionSurfaceProps {
   onPickAttachmentFiles?: () => Promise<ComposerAttachment[]>;
 }
 
-const SELECTABLE_PROVIDERS = Object.keys(AGENT_LABELS) as AgentKind[];
+const SELECTABLE_HARNESSES = Object.keys(AGENT_LABELS) as AgentKind[];
 
 function workspaceById(
   workspaces: readonly WorkspaceRecord[],
@@ -163,7 +163,7 @@ export function NewSessionSurface({
   onPickAttachmentFiles,
 }: NewSessionSurfaceProps): React.ReactNode {
   const t = useTranslations('workbench.newSession');
-  const [provider, setProvider] = useState(draft.initialProvider);
+  const [harness, setHarness] = useState(draft.initialHarness);
   const [selectedModels, setSelectedModels] = useState<Partial<Record<AgentKind, string | null>>>(
     {},
   );
@@ -186,25 +186,25 @@ export function NewSessionSurface({
     ? (selectedBranches[selected.workspaceId] ?? preferredBranches?.[selected.workspaceId])
     : undefined;
   const branchMode = selectedBranch?.mode ?? 'local';
-  const catalog = agentCatalogs?.[provider];
-  const localModel = selectedModels[provider];
+  const catalog = agentCatalogs?.[harness];
+  const localModel = selectedModels[harness];
   const selectedModel = localModel === undefined ? null : localModel;
   // The catalog default is what the agent's own config would start on, so it yields to anything the
   // user expressed through LinkCode. Nothing guesses past it: an unresolved model blocks the send
   // rather than starting a session on a model nobody chose.
   const displayedModel =
     selectedModel ??
-    (defaultModels === null ? null : (defaultModels?.[provider] ?? catalog?.defaultModel ?? null));
-  const localEffort = selectedEfforts[provider];
-  const effort = localEffort === undefined ? (preferredEfforts?.[provider] ?? null) : localEffort;
+    (defaultModels === null ? null : (defaultModels?.[harness] ?? catalog?.defaultModel ?? null));
+  const localEffort = selectedEfforts[harness];
+  const effort = localEffort === undefined ? (preferredEfforts?.[harness] ?? null) : localEffort;
   const dynamicModels = catalog && catalog.models.length > 0 ? catalog.models : null;
   // Every account that can back this agent contributes, so a pick chooses the account too. The set
   // outranks the adapter catalog and the curated table both, and an entry present here means at
   // least one account is bindable — which is what makes a missing model fatal rather than the
   // agent's own business.
-  const bindableSet = accountModels?.[provider];
-  const pickable = bindableSet ?? dynamicModels ?? AGENT_MODEL_OPTIONS[provider];
-  const localAccount = selectedAccounts[provider];
+  const bindableSet = accountModels?.[harness];
+  const pickable = bindableSet ?? dynamicModels ?? AGENT_MODEL_OPTIONS[harness];
+  const localAccount = selectedAccounts[harness];
   const selectedAccountId = localAccount ?? undefined;
   const modelOption = resolveModel(pickable, displayedModel, selectedAccountId);
   const effortLevels = modelOption?.effortLevels;
@@ -226,7 +226,7 @@ export function NewSessionSurface({
   // Only a real pick travels to the adapter. Every catalog default — policy, model, effort — is a
   // display value: submitting one would read as an explicit choice and override the agent's own
   // startup resolution — claude's `permissions.defaultMode`, codex's configured `config.toml`.
-  const pickedPolicyId = selectedPolicies[provider];
+  const pickedPolicyId = selectedPolicies[harness];
   const currentPolicyId =
     pickedPolicyId ?? catalog?.defaultPolicyId ?? catalog?.policies[0]?.policyId;
   const approvalPolicy =
@@ -239,7 +239,7 @@ export function NewSessionSurface({
     setPending(true);
     try {
       await onSubmit({
-        kind: provider,
+        kind: harness,
         cwd: selected.cwd,
         workspaceId: selected.workspaceId,
         model: localModel === null ? undefined : (selectedModel ?? undefined),
@@ -272,31 +272,31 @@ export function NewSessionSurface({
     return submit({ type: 'shell-command', command });
   }
 
-  function handleProviderChange(nextProvider: AgentKind): Promise<void> {
-    setProvider(nextProvider);
+  function handleHarnessChange(nextHarness: AgentKind): Promise<void> {
+    setHarness(nextHarness);
     return Promise.resolve();
   }
 
   function handleModelChange(next: ModelOption): Promise<void> {
-    setSelectedModels((current) => ({ ...current, [provider]: next.id }));
+    setSelectedModels((current) => ({ ...current, [harness]: next.id }));
     // The account is part of the pick: two accounts can serve the same id, and the session must
     // start on the one whose entry was chosen.
-    setSelectedAccounts((current) => ({ ...current, [provider]: next.accountId ?? null }));
+    setSelectedAccounts((current) => ({ ...current, [harness]: next.accountId ?? null }));
     return Promise.resolve();
   }
 
   function handleEffortChange(nextEffort: EffortLevel): Promise<void> {
-    setSelectedEfforts((current) => ({ ...current, [provider]: nextEffort }));
+    setSelectedEfforts((current) => ({ ...current, [harness]: nextEffort }));
     return Promise.resolve();
   }
 
   function handleResetModel(): void {
-    setSelectedModels((current) => ({ ...current, [provider]: null }));
-    setSelectedAccounts((current) => ({ ...current, [provider]: null }));
+    setSelectedModels((current) => ({ ...current, [harness]: null }));
+    setSelectedAccounts((current) => ({ ...current, [harness]: null }));
   }
 
   function handleResetEffort(): void {
-    setSelectedEfforts((current) => ({ ...current, [provider]: null }));
+    setSelectedEfforts((current) => ({ ...current, [harness]: null }));
   }
 
   function handleModeChange(nextModeId: string): Promise<void> {
@@ -305,7 +305,7 @@ export function NewSessionSurface({
   }
 
   function handleApprovalPolicyChange(policyId: string): Promise<void> {
-    setSelectedPolicies((current) => ({ ...current, [provider]: policyId }));
+    setSelectedPolicies((current) => ({ ...current, [harness]: policyId }));
     return Promise.resolve();
   }
 
@@ -313,8 +313,8 @@ export function NewSessionSurface({
     selected && !isChatSelected
       ? t('headingIn', { name: selected.name ?? repositoryLabel(selected.cwd) })
       : t('heading');
-  const cue = runtimeCues?.[provider];
-  const capabilities = AGENT_INPUT_CAPABILITIES[provider];
+  const cue = runtimeCues?.[harness];
+  const capabilities = AGENT_INPUT_CAPABILITIES[harness];
   const directiveControls: ComposerDirectiveControls = {
     slash: capabilities.slashCommands
       ? { state: 'loading', onInvokeCommand: handleInvokeCommand }
@@ -358,7 +358,7 @@ export function NewSessionSurface({
               <div className="mx-auto max-w-3xl">
                 <AgentOnboardingCard
                   cue={cue}
-                  kind={provider}
+                  kind={harness}
                   onContinueUnverified={onContinueUnverified}
                   onDownload={onDownloadAgent}
                   onOpenProviderSettings={onOpenProviderSettings}
@@ -367,9 +367,9 @@ export function NewSessionSurface({
             </div>
           )}
           <Composer
-            agentLabel={AGENT_LABELS[provider]}
-            agentKind={provider}
-            attachmentsSupported={Boolean(attachmentSupport?.[provider])}
+            agentLabel={AGENT_LABELS[harness]}
+            agentKind={harness}
+            attachmentsSupported={Boolean(attachmentSupport?.[harness])}
             blockDirectivesWithAttachments
             disabled={pending || !selected}
             directiveControls={directiveControls}
@@ -390,7 +390,7 @@ export function NewSessionSurface({
             currentAccountId={selectedAccountId}
             approvalPolicy={approvalPolicy}
             approvalPolicyPlaceholder={t('permissionMode')}
-            selectableProviders={SELECTABLE_PROVIDERS}
+            selectableHarnesses={SELECTABLE_HARNESSES}
             onSend={handleSend}
             onStop={noop}
             onPickAttachmentFiles={onPickAttachmentFiles}
@@ -400,7 +400,7 @@ export function NewSessionSurface({
             onModelChange={handleModelChange}
             onResetEffort={effort === null ? undefined : handleResetEffort}
             onResetModel={selectedModel === null ? undefined : handleResetModel}
-            onProviderChange={handleProviderChange}
+            onHarnessChange={handleHarnessChange}
             contextBar={
               <NewSessionContextBar
                 workspaces={workspaces}
diff --git a/packages/presentation/ui/src/shell/plugins/plugins-tab.tsx b/packages/presentation/ui/src/shell/plugins/plugins-tab.tsx
index 17df3360..124f972f 100644
--- a/packages/presentation/ui/src/shell/plugins/plugins-tab.tsx
+++ b/packages/presentation/ui/src/shell/plugins/plugins-tab.tsx
@@ -78,7 +78,7 @@ export function PluginsTab({
               {group.discoveryFailed ? (
                 <EmptyRow
                   text={t('discoveryFailed', {
-                    provider: label,
+                    harness: label,
                     reason: group.failureReason ?? t('discoveryFailedUnknown'),
                   })}
                 />
@@ -89,7 +89,7 @@ export function PluginsTab({
                     filtering
                       ? t('noSearchResults')
                       : missingRuntimes.has(group.provider)
-                        ? t('runtimeMissing', { provider: label })
+                        ? t('runtimeMissing', { harness: label })
                         : market
                           ? t('marketEmptyHint')
                           : t('installedEmptyHint')

From b36c706df2bc51c757de6cfd38ae9905a20015b1 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 13:44:37 +0800
Subject: [PATCH 10/17] refactor(engine): give every session relaunch one
 resolve and one run writer

---
 .../engine/src/session/lifecycle-service.ts   | 94 ++++++++++++++-----
 .../src/session/session-record-registry.ts    | 10 +-
 2 files changed, 77 insertions(+), 27 deletions(-)

diff --git a/packages/host/engine/src/session/lifecycle-service.ts b/packages/host/engine/src/session/lifecycle-service.ts
index 0ed0ad09..4c859baf 100644
--- a/packages/host/engine/src/session/lifecycle-service.ts
+++ b/packages/host/engine/src/session/lifecycle-service.ts
@@ -1,5 +1,7 @@
+import type { AgentAdapter } from '@linkcode/agent-adapter';
 import type {
   AgentHistoryId,
+  AgentInput,
   AgentKind,
   ContentBlock,
   MessageId,
@@ -23,7 +25,7 @@ import type { HistoryService } from './history-service';
 import { decodeLiveBranchCursor } from './live-session';
 import type { SessionOrchestrator } from './orchestrator';
 import type { SessionRecordRegistry } from './session-record-registry';
-import type { SessionStartOptionsResolver } from './start-options-resolver';
+import type { ResolvedStartOptions, SessionStartOptionsResolver } from './start-options-resolver';
 
 type RunEffect = <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions) => Promise<A>;
 
@@ -236,12 +238,11 @@ export class SessionLifecycleService {
           );
         }
 
-        const { history, records, sessions, startOptions: resolver } = this;
+        const { history, sessions } = this;
+        const resolveForRecord = this.resolveForRecord.bind(this);
+        const launchRun = this.launchRun.bind(this);
         return Effect.gen(function* () {
-          const { options: startOptions, warnings } = yield* resolver.resolve(
-            { kind: source.kind, cwd: source.cwd },
-            sourceSessionId,
-          );
+          const resolved = yield* resolveForRecord(source);
           yield* sessions.stopForReplacement(sourceSessionId);
           const resolvedBranchCursor =
             liveCursor.type === 'live'
@@ -253,17 +254,16 @@ export class SessionLifecycleService {
                   liveCursor.contentFingerprint,
                 )
               : branchCursor;
-          records.beginRun(sourceSessionId, resolvedAccountId(startOptions));
-          yield* sessions.startLive(
+          yield* launchRun(
             replyTo,
             source,
+            resolved,
             (adapter) =>
               history.branch(
                 adapter,
                 { historyId: sourceHistoryId, cursor: resolvedBranchCursor },
-                startOptions,
+                resolved.options,
               ),
-            warnings,
             {
               initialInput: { type: 'prompt', content },
               registerRecord: false,
@@ -299,13 +299,13 @@ export class SessionLifecycleService {
         // A never-prompted session has no provider transcript to resume from (the adapter only mints one
         // on the first prompt); waking it is a fresh start under the same LinkCode id.
         const historyId = this.records.historyId(sessionId);
-        const { history, sessions, startOptions: resolver, workspaces, worktrees } = this;
+        const { workspaces, worktrees } = this;
+        const resolveForRecord = this.resolveForRecord.bind(this);
+        const launchRun = this.launchRun.bind(this);
+        const resumeStrategy = this.resumeStrategy.bind(this);
         return Effect.gen(function* () {
           yield* worktrees.verifyResume(sessionId);
-          const { options: startOptions, warnings } = yield* resolver.resolve(
-            { kind: record.kind, cwd: record.cwd },
-            sessionId,
-          );
+          const resolved = yield* resolveForRecord(record);
           // Register before starting so a persistence failure cannot follow a successful
           // `session.started` reply with a contradictory request failure.
           const worktree = worktrees.get(sessionId);
@@ -315,21 +315,65 @@ export class SessionLifecycleService {
           } else if (record.cwd) {
             yield* workspaceTouch(workspaces, record.cwd);
           }
-          record.runs.push({ historyId, startedAt: Date.now(), ...accountOfRun(startOptions) });
-          yield* sessions.startLive(
-            replyTo,
-            record,
-            (adapter) =>
-              historyId === undefined
-                ? sessions.startAdapter(adapter, startOptions)
-                : history.resume(adapter, historyId, startOptions),
-            warnings,
-          );
+          yield* launchRun(replyTo, record, resolved, resumeStrategy(historyId, resolved.options), {
+            historyId,
+          });
         });
       }),
     );
   }
 
+  /** Resolve the options an existing record relaunches under. `override` is how a caller pins a
+   * model or account other than the daemon's current defaults. */
+  private resolveForRecord(
+    record: SessionRecord,
+    override?: Pick<StartOptions, 'model' | 'config'>,
+  ): Effect.Effect<ResolvedStartOptions, EngineFailure> {
+    return this.startOptions.resolve(
+      { kind: record.kind, cwd: record.cwd, ...override },
+      record.sessionId,
+    );
+  }
+
+  /** Record the run this launch begins, then bind the record to a fresh adapter. Every relaunch of
+   * an existing record goes through here, so `runs` has exactly one writer. */
+  private launchRun(
+    replyTo: string | undefined,
+    record: SessionRecord,
+    resolved: ResolvedStartOptions,
+    startAdapter: (adapter: AgentAdapter) => Effect.Effect<void, EngineFailure>,
+    options: {
+      historyId?: AgentHistoryId;
+      initialInput?: AgentInput;
+      registerRecord?: boolean;
+      rewindMessageId?: MessageId;
+    } = {},
+  ): Effect.Effect<void, EngineFailure> {
+    const { historyId, ...startOptions } = options;
+    return Effect.suspend(() => {
+      this.records.beginRun(record.sessionId, resolvedAccountId(resolved.options), historyId);
+      return this.sessions.startLive(
+        replyTo,
+        record,
+        startAdapter,
+        resolved.warnings,
+        startOptions,
+      );
+    });
+  }
+
+  /** Wake an adapter onto an existing transcript, or start it fresh when there is none to resume. */
+  private resumeStrategy(
+    historyId: AgentHistoryId | undefined,
+    options: StartOptions,
+  ): (adapter: AgentAdapter) => Effect.Effect<void, EngineFailure> {
+    const { history, sessions } = this;
+    return (adapter) =>
+      historyId === undefined
+        ? sessions.startAdapter(adapter, options)
+        : history.resume(adapter, historyId, options);
+  }
+
   private createAutomationSession(options: {
     kind: AgentKind;
     cwd: string;
diff --git a/packages/host/engine/src/session/session-record-registry.ts b/packages/host/engine/src/session/session-record-registry.ts
index b3dad8cf..862c09a1 100644
--- a/packages/host/engine/src/session/session-record-registry.ts
+++ b/packages/host/engine/src/session/session-record-registry.ts
@@ -138,10 +138,16 @@ export class SessionRecordRegistry {
     this.persist(record);
   }
 
-  beginRun(sessionId: SessionId, accountId?: string): void {
+  /** The single writer for a relaunch's run entry. `historyId` is known up front only when the
+   * relaunch resumes a transcript; a fresh one gets it later via {@link bindHistoryId}. */
+  beginRun(sessionId: SessionId, accountId?: string, historyId?: AgentHistoryId): void {
     const record = this.records.get(sessionId);
     if (!record) return;
-    record.runs.push({ startedAt: Date.now(), ...(accountId !== undefined && { accountId }) });
+    record.runs.push({
+      startedAt: Date.now(),
+      ...(accountId !== undefined && { accountId }),
+      ...(historyId !== undefined && { historyId }),
+    });
     this.persist(record);
   }
 

From e4e149df995774860351fd28a5c43e14789235d9 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 13:54:09 +0800
Subject: [PATCH 11/17] feat(schema,engine): switch a live thread to another
 account by relaunching it

---
 .../schema/src/model/agent/input.ts           |  10 +-
 .../__tests__/engine-session-records.test.ts  | 156 ++++++++++++++++++
 .../src/__tests__/fixtures/session-harness.ts |   6 +-
 .../engine/src/session/lifecycle-service.ts   |  79 +++++++++
 .../host/engine/src/session/orchestrator.ts   |   7 +
 .../engine/src/session/request-handler.ts     |  18 +-
 .../src/session/session-record-registry.ts    |   6 +
 7 files changed, 273 insertions(+), 9 deletions(-)

diff --git a/packages/foundation/schema/src/model/agent/input.ts b/packages/foundation/schema/src/model/agent/input.ts
index 3701cd2c..be0fa84b 100644
--- a/packages/foundation/schema/src/model/agent/input.ts
+++ b/packages/foundation/schema/src/model/agent/input.ts
@@ -170,8 +170,14 @@ export const AgentInputSchema = z.discriminatedUnion('type', [
    * adapters that advertise policies via `approval-policy-update` accept this; others reject it. */
   z.object({ type: z.literal('set-approval-policy'), policyId: ApprovalPolicyIdSchema }),
   /** Switch the model for the session, going forward (vendor-specific id). Only adapters that
-   * support changing the model on an already-running session accept this; others reject it. */
-  z.object({ type: z.literal('set-model'), model: z.string().min(1) }),
+   * support changing the model on an already-running session accept this; others reject it.
+   * `accountId` names the account the model was picked from; switching to a different one restarts
+   * the session and resumes its transcript, because credentials are injected once at spawn. */
+  z.object({
+    type: z.literal('set-model'),
+    model: z.string().min(1),
+    accountId: z.string().min(1).optional(),
+  }),
   /** Switch the reasoning-effort level for the session, going forward. Same acceptance rule as
    * `set-model`: only adapters that can rebind effort on a live session accept this. */
   z.object({ type: z.literal('set-effort'), effort: EffortLevelSchema }),
diff --git a/packages/host/engine/src/__tests__/engine-session-records.test.ts b/packages/host/engine/src/__tests__/engine-session-records.test.ts
index b302b87b..ca2655ae 100644
--- a/packages/host/engine/src/__tests__/engine-session-records.test.ts
+++ b/packages/host/engine/src/__tests__/engine-session-records.test.ts
@@ -1004,3 +1004,159 @@ describe('session account attribution', () => {
     expect(listedSessions(h.sent, 'r2')[0]?.accountId).toBe('acc_pinned');
   });
 });
+
+class ResumelessAdapter extends FakeAdapter {
+  override readonly historyCapabilities: AgentHistoryCapabilities = {
+    list: false,
+    read: true,
+    resume: false,
+  };
+}
+
+describe('live account switching', () => {
+  /** Two accounts an agent can bind, one of them currently bound. */
+  function twoAccountStore(): InMemoryProviderConfigStore {
+    const providers = new InMemoryProviderConfigStore();
+    providers.update({
+      providers: {
+        'claude-code': { enabled: true, activeAccountId: 'acc_first', model: 'model-first' },
+      },
+      accounts: [
+        {
+          id: 'acc_first',
+          label: 'First',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-first' },
+          models: [{ id: 'model-first' }],
+          createdAt: 0,
+        },
+        {
+          id: 'acc_second',
+          label: 'Second',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-second' },
+          models: [{ id: 'model-second' }],
+          createdAt: 0,
+        },
+      ],
+    });
+    return providers;
+  }
+
+  async function liveSession(
+    makeAdapter?: () => FakeAdapter,
+    options: { withTranscript?: boolean } = {},
+  ) {
+    const { withTranscript = true } = options;
+    const store = new InMemorySessionStore();
+    const h = harness(store, makeAdapter, undefined, undefined, undefined, twoAccountStore());
+    await h.engine.start();
+    await h.inject({
+      kind: 'session.start',
+      clientReqId: 'r1',
+      opts: { kind: 'claude-code', cwd: '/repo' },
+    });
+    const sessionId = startedId(h.sent, 'r1');
+    if (withTranscript) {
+      h.adapters[0].emit({ type: 'session-ref', historyId: asHistoryId('native-live') });
+      await tick();
+    }
+    return { ...h, store, sessionId };
+  }
+
+  function switchTo(
+    h: Awaited<ReturnType<typeof liveSession>>,
+    accountId: string,
+    model: string,
+    clientReqId = 'switch',
+  ) {
+    return h.inject({
+      kind: 'agent.input',
+      clientReqId,
+      sessionId: h.sessionId,
+      input: { type: 'set-model', model, accountId },
+    });
+  }
+
+  it('relaunches on the new account, resuming the transcript under the same id', async () => {
+    const h = await liveSession();
+
+    await switchTo(h, 'acc_second', 'model-second');
+
+    expect(h.sent).toContainEqual({ kind: 'request.succeeded', replyTo: 'switch' });
+    // A fresh adapter, resumed from the transcript the old one had established.
+    expect(h.adapters).toHaveLength(2);
+    expect(h.adapters[0].stopped).toBe(true);
+    expect(h.adapters[1].resumedFrom).toBe('native-live');
+    expect(h.adapters[1].resumedWith?.model).toBe('model-second');
+    expect(h.adapters[1].resumedWith?.config?.apiKey).toBe('sk-second');
+
+    const runs = (await h.store.load())[0].runs;
+    expect(runs).toHaveLength(2);
+    expect(runs[1].accountId).toBe('acc_second');
+
+    await h.inject({ kind: 'session.list', clientReqId: 'listed' });
+    expect(listedSessions(h.sent, 'listed')[0]?.accountId).toBe('acc_second');
+  });
+
+  it('forwards a pick on the session’s own account in place, recording no new run', async () => {
+    const h = await liveSession();
+
+    await switchTo(h, 'acc_first', 'model-first');
+
+    expect(h.sent).toContainEqual({ kind: 'request.succeeded', replyTo: 'switch' });
+    expect(h.adapters).toHaveLength(1);
+    expect(h.adapters[0].sentInputs).toContainEqual({
+      type: 'set-model',
+      model: 'model-first',
+      accountId: 'acc_first',
+    });
+    expect((await h.store.load())[0].runs).toHaveLength(1);
+  });
+
+  it('refuses a switch while a turn is running', async () => {
+    const h = await liveSession();
+    h.adapters[0].emit({ type: 'status', status: 'running' });
+    await tick();
+
+    await switchTo(h, 'acc_second', 'model-second');
+
+    expect(h.sent).toContainEqual({
+      kind: 'request.failed',
+      replyTo: 'switch',
+      code: 'conflict',
+      message: 'The session is busy; switch accounts once the turn has finished',
+    });
+    expect(h.adapters).toHaveLength(1);
+  });
+
+  it('refuses a switch on a session with no provider transcript rather than starting fresh', async () => {
+    const h = await liveSession(undefined, { withTranscript: false });
+
+    await switchTo(h, 'acc_second', 'model-second');
+
+    expect(h.sent).toContainEqual({
+      kind: 'request.failed',
+      replyTo: 'switch',
+      code: 'conflict',
+      message: 'The session has no provider transcript to carry to another account',
+    });
+    expect(h.adapters).toHaveLength(1);
+  });
+
+  it('refuses before teardown when the agent cannot resume, leaving the session live', async () => {
+    const h = await liveSession(() => new ResumelessAdapter());
+
+    await switchTo(h, 'acc_second', 'model-second');
+
+    expect(h.sent).toContainEqual({
+      kind: 'request.failed',
+      replyTo: 'switch',
+      code: 'unsupported',
+      message: 'claude-code: switching account needs history resume, which it does not support',
+    });
+    // The whole point of checking first: the session it refused to move is still running.
+    expect(h.adapters).toHaveLength(1);
+    expect(h.adapters[0].stopped).toBe(false);
+  });
+});
diff --git a/packages/host/engine/src/__tests__/fixtures/session-harness.ts b/packages/host/engine/src/__tests__/fixtures/session-harness.ts
index be9127b0..9226112e 100644
--- a/packages/host/engine/src/__tests__/fixtures/session-harness.ts
+++ b/packages/host/engine/src/__tests__/fixtures/session-harness.ts
@@ -37,6 +37,9 @@ export class FakeAdapter implements AgentAdapter {
 
   startedWith: StartOptions | null = null;
   resumedFrom: string | null = null;
+  /** The options a resume was spawned with — a relaunch carries its model/credentials here, not
+   * through `startedWith`. */
+  resumedWith: StartOptions | null = null;
   stopped = false;
   readonly sentInputs: AgentInput[] = [];
   private readonly listeners = new Set<(event: AgentEvent) => void>();
@@ -67,8 +70,9 @@ export class FakeAdapter implements AgentAdapter {
     });
   }
 
-  resumeHistory(opts: AgentHistoryResumeOptions): Promise<void> {
+  resumeHistory(opts: AgentHistoryResumeOptions, startOpts: StartOptions): Promise<void> {
     this.resumedFrom = opts.historyId;
+    this.resumedWith = startOpts;
     return Promise.resolve();
   }
 
diff --git a/packages/host/engine/src/session/lifecycle-service.ts b/packages/host/engine/src/session/lifecycle-service.ts
index 4c859baf..66bb9a7f 100644
--- a/packages/host/engine/src/session/lifecycle-service.ts
+++ b/packages/host/engine/src/session/lifecycle-service.ts
@@ -323,6 +323,85 @@ export class SessionLifecycleService {
     );
   }
 
+  /**
+   * Point a live session at a model belonging to `accountId`. Credentials and base URL are injected
+   * once at spawn, so a cross-account switch cannot happen in place: it is a relaunch under the same
+   * id that resumes the transcript. A switch within the session's own account stays in place, which
+   * is why the error channel is the adapter's untyped one rather than {@link EngineFailure}.
+   */
+  switchModel(
+    sessionId: SessionId,
+    model: string,
+    accountId: string,
+  ): Effect.Effect<void, unknown> {
+    return this.sessionSemaphore(sessionId).withPermit(
+      Effect.suspend(() => {
+        const record = this.records.get(sessionId);
+        if (!record) {
+          return Effect.fail(
+            new RequestError({ code: 'not_found', message: `Unknown session: ${sessionId}` }),
+          );
+        }
+        if (!this.sessions.has(sessionId)) {
+          return Effect.fail(
+            new RequestError({
+              code: 'conflict',
+              message: `Session is not running: ${sessionId}`,
+            }),
+          );
+        }
+        if (this.records.accountId(sessionId) === accountId) {
+          return this.sessions.sendInput(sessionId, { type: 'set-model', model, accountId });
+        }
+        if (this.sessions.isBusy(sessionId)) {
+          return Effect.fail(
+            new RequestError({
+              code: 'conflict',
+              message: 'The session is busy; switch accounts once the turn has finished',
+            }),
+          );
+        }
+        // Relaunching without a transcript would silently start a fresh conversation in place of
+        // the one on screen. Losing the thread is worse than refusing the switch.
+        const historyId = this.records.historyId(sessionId);
+        if (historyId === undefined) {
+          return Effect.fail(
+            new RequestError({
+              code: 'conflict',
+              message: 'The session has no provider transcript to carry to another account',
+            }),
+          );
+        }
+        // Asked before the teardown below: a refusal from `history.resume` would arrive with the
+        // old adapter already gone.
+        if (this.sessions.historyCapabilities(sessionId)?.resume !== true) {
+          return Effect.fail(
+            new RequestError({
+              code: 'unsupported',
+              message: `${record.kind}: switching account needs history resume, which it does not support`,
+            }),
+          );
+        }
+
+        const { sessions } = this;
+        const resolveForRecord = this.resolveForRecord.bind(this);
+        const launchRun = this.launchRun.bind(this);
+        const resumeStrategy = this.resumeStrategy.bind(this);
+        return Effect.gen(function* () {
+          const resolved = yield* resolveForRecord(record, { model, config: { accountId } });
+          yield* sessions.stopForReplacement(sessionId);
+          yield* launchRun(
+            undefined,
+            record,
+            resolved,
+            resumeStrategy(historyId, resolved.options),
+            { historyId, registerRecord: false },
+          );
+        });
+      }),
+    );
+  }
+
   /** Resolve the options an existing record relaunches under. `override` is how a caller pins a
    * model or account other than the daemon's current defaults. */
   private resolveForRecord(
diff --git a/packages/host/engine/src/session/orchestrator.ts b/packages/host/engine/src/session/orchestrator.ts
index 813e172c..24b093fd 100644
--- a/packages/host/engine/src/session/orchestrator.ts
+++ b/packages/host/engine/src/session/orchestrator.ts
@@ -2,6 +2,7 @@ import type { AdapterFactory, AgentAdapter, BrowserToolsetFactory } from '@linkc
 import { nextMessageId } from '@linkcode/agent-adapter';
 import type {
   AgentEvent,
+  AgentHistoryCapabilities,
   AgentInput,
   ContentBlock,
   McpWarning,
@@ -73,6 +74,12 @@ export class SessionOrchestrator {
     return session !== undefined && (session.turnInputActive || session.status === 'running');
   }
 
+  /** The running adapter's history capabilities — asked of the live instance rather than a fresh
+   * one, so a caller about to tear it down learns what *this* session can do. */
+  historyCapabilities(sessionId: SessionId): AgentHistoryCapabilities | undefined {
+    return this.sessions.get(sessionId)?.adapter.historyCapabilities;
+  }
+
   replay(sessionId: SessionId): void {
     const session = this.sessions.get(sessionId);
     if (session) this.events.broadcast(sessionId, session.replay());
diff --git a/packages/host/engine/src/session/request-handler.ts b/packages/host/engine/src/session/request-handler.ts
index 21725d99..49c71c81 100644
--- a/packages/host/engine/src/session/request-handler.ts
+++ b/packages/host/engine/src/session/request-handler.ts
@@ -38,15 +38,21 @@ export class SessionRequestHandler {
           payload.clientReqId,
           this.lifecycle.start(payload.clientReqId, payload.opts),
         );
-      case 'agent.input':
+      case 'agent.input': {
+        const { input, sessionId } = payload;
+        // A model pick naming an account can mean a relaunch on that account, which lifecycle owns.
+        // Both paths answer with the same plain ack, so the client's contract is unchanged.
+        const applied =
+          input.type === 'set-model' && input.accountId !== undefined
+            ? this.lifecycle.switchModel(sessionId, input.model, input.accountId)
+            : this.sessions.sendInput(sessionId, input);
         return this.responder.reply(
           payload.clientReqId,
-          this.sessions
-            .sendInput(payload.sessionId, payload.input)
-            .pipe(
-              Effect.andThen(Effect.sync(() => this.responder.sendSuccess(payload.clientReqId))),
-            ),
+          applied.pipe(
+            Effect.andThen(Effect.sync(() => this.responder.sendSuccess(payload.clientReqId))),
+          ),
         );
+      }
       case 'session.stop':
         return this.responder.reply(
           payload.clientReqId,
diff --git a/packages/host/engine/src/session/session-record-registry.ts b/packages/host/engine/src/session/session-record-registry.ts
index 862c09a1..c5d7e556 100644
--- a/packages/host/engine/src/session/session-record-registry.ts
+++ b/packages/host/engine/src/session/session-record-registry.ts
@@ -178,6 +178,12 @@ export class SessionRecordRegistry {
     return record ? latestHistoryId(record) : undefined;
   }
 
+  /** The account the newest run resolved to — what a live session is actually talking to. */
+  accountId(sessionId: SessionId): string | undefined {
+    const record = this.records.get(sessionId);
+    return record ? latestAccountId(record) : undefined;
+  }
+
   /** The in-memory record is authoritative while running; persistence is best-effort. */
   private persist(record: SessionRecord): void {
     record.updatedAt = Date.now();

From d589b9369367df3450e79d5de1020c7777c9b656 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 14:03:19 +0800
Subject: [PATCH 12/17] feat(workbench,ui,i18n): let a live thread pick any
 account's model

---
 .../src/renderer/src/shell/desktop-shell.tsx  |  3 +-
 packages/client/core/src/client.ts            |  4 +-
 .../client/core/src/client/control-channel.ts | 12 ++-
 packages/client/sdk/src/client.ts             |  4 +-
 packages/client/sdk/src/operations.ts         |  4 +-
 .../__tests__/default-models.test.ts          | 11 ---
 .../src/settings/providers/default-models.ts  | 24 +-----
 .../workbench/src/surface/workbench.tsx       | 20 ++---
 packages/presentation/i18n/src/locales/en.ts  |  1 +
 .../presentation/i18n/src/locales/zh-cn.ts    |  1 +
 .../ui/src/__tests__/agent-models.test.ts     | 22 +++++-
 .../presentation/ui/src/shell/agent-models.ts | 14 ++++
 .../ui/src/shell/composer-controls.tsx        | 75 ++++++++++++-------
 .../presentation/ui/src/shell/composer.tsx    |  4 +
 .../ui/src/shell/conversation-surface.tsx     |  8 +-
 .../presentation/ui/src/shell/shell-frame.tsx |  6 +-
 16 files changed, 127 insertions(+), 86 deletions(-)

diff --git a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
index fb469b89..545d0594 100644
--- a/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
+++ b/apps/desktop/src/renderer/src/shell/desktop-shell.tsx
@@ -81,7 +81,6 @@ export function DesktopShell({
   agentCatalogs,
   newSessionDefaultModels,
   accountModels,
-  sessionModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
   NewSessionBranchPickerComponent,
@@ -454,7 +453,7 @@ export function DesktopShell({
           composer={conversationComposer}
           agentKind={active?.kind}
           agentLabel={agentLabel}
-          accountModels={sessionModels}
+          accountModels={active ? accountModels?.[active.kind] : undefined}
           accountId={active?.accountId}
           attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
           cwd={active?.cwd}
diff --git a/packages/client/core/src/client.ts b/packages/client/core/src/client.ts
index adf89e50..61694d36 100644
--- a/packages/client/core/src/client.ts
+++ b/packages/client/core/src/client.ts
@@ -792,8 +792,8 @@ export class LinkCodeClient {
     return this.control.setSubscriptionMode(mode);
   }
 
-  setModel(sessionId: SessionId, model: string): Promise<RequestAck> {
-    return this.control.setModel(sessionId, model);
+  setModel(sessionId: SessionId, model: string, accountId?: string): Promise<RequestAck> {
+    return this.control.setModel(sessionId, model, accountId);
   }
 
   setEffort(sessionId: SessionId, effort: EffortLevel): Promise<RequestAck> {
diff --git a/packages/client/core/src/client/control-channel.ts b/packages/client/core/src/client/control-channel.ts
index 13276f8c..15f795e6 100644
--- a/packages/client/core/src/client/control-channel.ts
+++ b/packages/client/core/src/client/control-channel.ts
@@ -266,9 +266,15 @@ export class ControlChannel {
     }));
   }
 
-  /** Switch the session's model, going forward. Rejects if the adapter can't rebind a live session. */
-  setModel(sessionId: SessionId, model: string): Promise<RequestAck> {
-    return this.send(sessionId, { type: 'set-model', model });
+  /** Switch the session's model, going forward. Rejects if the adapter can't rebind a live session.
+   * `accountId` names the account the model came from: picking one the session isn't running on
+   * restarts it on that account and resumes the transcript. */
+  setModel(sessionId: SessionId, model: string, accountId?: string): Promise<RequestAck> {
+    return this.send(sessionId, {
+      type: 'set-model',
+      model,
+      ...(accountId !== undefined && { accountId }),
+    });
   }
 
   /** Switch the session's reasoning-effort level, going forward. Same acceptance rule as setModel. */
diff --git a/packages/client/sdk/src/client.ts b/packages/client/sdk/src/client.ts
index 2f27207c..e2798f0a 100644
--- a/packages/client/sdk/src/client.ts
+++ b/packages/client/sdk/src/client.ts
@@ -242,8 +242,8 @@ export class LinkCodeSdkClient {
     return toResult(this.raw.cancel(sessionId));
   }
 
-  setModel(sessionId: SessionId, model: string): RequestResult<{ ok: true }> {
-    return toResult(this.raw.setModel(sessionId, model));
+  setModel(sessionId: SessionId, model: string, accountId?: string): RequestResult<{ ok: true }> {
+    return toResult(this.raw.setModel(sessionId, model, accountId));
   }
 
   setEffort(sessionId: SessionId, effort: EffortLevel): RequestResult<{ ok: true }> {
diff --git a/packages/client/sdk/src/operations.ts b/packages/client/sdk/src/operations.ts
index b59c551b..5b8e0d45 100644
--- a/packages/client/sdk/src/operations.ts
+++ b/packages/client/sdk/src/operations.ts
@@ -221,9 +221,9 @@ export function cancelTurn(
 }
 
 export function setModel(
-  options: Options<{ sessionId: SessionId; model: string }>,
+  options: Options<{ sessionId: SessionId; model: string; accountId?: string }>,
 ): RequestResult<{ ok: true }> {
-  return resolveClient(options).setModel(options.sessionId, options.model);
+  return resolveClient(options).setModel(options.sessionId, options.model, options.accountId);
 }
 
 export function setEffort(
diff --git a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
index 058421ff..37b666cd 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
@@ -7,7 +7,6 @@ import { cleanup, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   accountModelOptions,
-  accountModelOptionsFor,
   configuredDefaultModels,
   useAccountModelOptions,
   useConfiguredDefaultModels,
@@ -118,16 +117,6 @@ describe('accountModelOptions', () => {
     expect(new Set(options.map(modelChoiceKey)).size).toBe(2);
   });
 
-  it('scopes to one account for a live session, whose account cannot change', () => {
-    const accounts = [anthropicAccount, deepseekAccount];
-    expect(accountModelOptionsFor(accounts, 'acc_deepseek')?.map(({ id }) => id)).toEqual([
-      'deepseek-v4-pro',
-      'deepseek-v4-flash',
-    ]);
-    expect(accountModelOptionsFor(accounts, 'gone')).toBeUndefined();
-    expect(accountModelOptionsFor(accounts, undefined)).toBeUndefined();
-  });
-
   it('stays unresolved until the account pool has loaded', () => {
     const { result, rerender } = renderHook(() => useAccountModelOptions());
 
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index c12e7d5b..ecbfa48a 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -28,9 +28,10 @@ export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>>
 }
 
 /**
- * Every model a new session of this agent could run on: the picked sets of *all* accounts the agent
- * can bind, not just the one bound now. Choosing a model therefore also chooses its account, which
- * is what lets one agent reach several providers without a trip through Settings.
+ * Every model this agent could run on: the picked sets of *all* accounts it can bind, not just the
+ * one bound now. Choosing a model therefore also chooses its account, which is what lets one agent
+ * reach several providers without a trip through Settings. Live sessions read the same list — a
+ * cross-account pick there restarts the thread on that account rather than rebinding in place.
  *
  * `description` carries the account label so `groupModelsByProvider` renders one submenu per
  * account, and `accountId` rides along so the pick names the account it came from — two accounts
@@ -56,17 +57,6 @@ export function accountModelOptions(
   return options;
 }
 
-/** One account's picked models. A live session's menu uses this: its account is fixed at spawn, so
- * offering another account's models would advertise a switch the adapter cannot make. */
-export function accountModelOptionsFor(
-  accounts: Accounts | undefined,
-  accountId: string | undefined,
-): ModelOption[] | undefined {
-  if (accountId === undefined) return undefined;
-  const account = accounts?.find((candidate) => candidate.id === accountId);
-  return account === undefined ? undefined : modelOptionsOf(account);
-}
-
 function modelOptionsOf(account: Account): ModelOption[] {
   return (account.models ?? []).map(({ id, label }) => ({
     id,
@@ -84,12 +74,6 @@ export function useAccountModelOptions(): Partial<Record<AgentKind, ModelOption[
   return accountModelOptions(accounts);
 }
 
-/** The models a live session may switch between — its own account's, and only those. */
-export function useSessionModelOptions(accountId: string | undefined): ModelOption[] | undefined {
-  const { data: accounts } = useData(getAccounts, {});
-  return accountModelOptionsFor(accounts, accountId);
-}
-
 /**
  * Persist what an agent runs on. This is the only model memory: the daemon owns it, so Settings and
  * the composer cannot disagree and a scheduled or script session inherits the same pick. Passing the
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index 0a0f64c6..929b3a24 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -62,7 +62,6 @@ import {
   useAccountModelOptions,
   useConfiguredDefaultModels,
   usePersistPickedModel,
-  useSessionModelOptions,
 } from '../settings/providers/default-models';
 import { RuntimeBranchStatus } from '../sidebar/branch-status';
 import { useSidebarGroupCollapseStore } from '../sidebar/collapse-store';
@@ -248,8 +247,6 @@ function WorkbenchSessionSurface({
   const { mentionItems, onMentionQueryChange } = useFileMentionSource();
   const newSessionDefaultModels = useConfiguredDefaultModels();
   const accountModels = useAccountModelOptions();
-  // Scoped to the active session's own account: it was fixed at spawn and cannot change.
-  const sessionModels = useSessionModelOptions(active?.accountId);
   const sdkClient = useWorkbenchSdkClient();
   const activeSessionId = sessions.activeId;
   // Announce observation of the focused session so the daemon replays buffered per-session state
@@ -471,11 +468,17 @@ function WorkbenchSessionSurface({
     // Let the rejection propagate: the composer awaits it to decide whether to reflect the pick.
     // onError (wired into modelMutation above) still reports the failure via the error banner.
     const provider = active?.kind;
-    return modelMutation.trigger({ sessionId: sessions.activeId, model: model.id }).then(() => {
-      // No account change: it is fixed at spawn, and this menu only ever offers the session's own
-      // account's models.
-      if (provider) void persistPickedModel(provider, model.id).catch(noop);
-    });
+    return modelMutation
+      .trigger({
+        sessionId: sessions.activeId,
+        model: model.id,
+        ...(model.accountId !== undefined && { accountId: model.accountId }),
+      })
+      .then(() => {
+        // Persisting the account too is what makes the switch outlive the running adapter: a later
+        // resume resolves from this config, not from the run it is reviving.
+        if (provider) void persistPickedModel(provider, model.id, model.accountId).catch(noop);
+      });
   }
 
   function handleEffortChange(effort: EffortLevel): Promise<void> {
@@ -675,7 +678,6 @@ function WorkbenchSessionSurface({
       onNewSessionWorkspaceChange={handleNewSessionWorkspaceChange}
       newSessionDefaultModels={newSessionDefaultModels}
       accountModels={accountModels}
-      sessionModels={sessionModels}
       agentCatalogs={agentCatalogs}
       newSessionPreferredEfforts={newSessionPreferredEfforts}
       newSessionPreferredBranches={newSessionPreferredBranches}
diff --git a/packages/presentation/i18n/src/locales/en.ts b/packages/presentation/i18n/src/locales/en.ts
index be5f1269..07dc547b 100644
--- a/packages/presentation/i18n/src/locales/en.ts
+++ b/packages/presentation/i18n/src/locales/en.ts
@@ -333,6 +333,7 @@ export const en = {
       effortDefault: 'Default',
       effortShort: 'Def.',
       model: 'Model',
+      modelSwitchRestarts: 'Switching account restarts this thread and resumes it',
       effort: 'Effort',
       resetToDefault: 'Reset to default',
       add: 'Add',
diff --git a/packages/presentation/i18n/src/locales/zh-cn.ts b/packages/presentation/i18n/src/locales/zh-cn.ts
index 7650c538..e05f0708 100644
--- a/packages/presentation/i18n/src/locales/zh-cn.ts
+++ b/packages/presentation/i18n/src/locales/zh-cn.ts
@@ -323,6 +323,7 @@ export const zhCN = {
       effortDefault: '默认',
       effortShort: '默认',
       model: '模型',
+      modelSwitchRestarts: '切换账号将重启并恢复此对话',
       effort: '推理强度',
       resetToDefault: '恢复默认设置',
       add: '添加',
diff --git a/packages/presentation/ui/src/__tests__/agent-models.test.ts b/packages/presentation/ui/src/__tests__/agent-models.test.ts
index 58ed7e47..68d1d1df 100644
--- a/packages/presentation/ui/src/__tests__/agent-models.test.ts
+++ b/packages/presentation/ui/src/__tests__/agent-models.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { effortOptionsForModel } from '../shell/agent-efforts';
-import { AGENT_MODEL_OPTIONS, groupModelsByProvider, resolveModel } from '../shell/agent-models';
+import {
+  AGENT_MODEL_OPTIONS,
+  groupModelsByProvider,
+  resolveModel,
+  switchesAccount,
+} from '../shell/agent-models';
 
 const claude = AGENT_MODEL_OPTIONS['claude-code'];
 const codex = AGENT_MODEL_OPTIONS.codex;
@@ -26,6 +31,21 @@ describe('resolveModel', () => {
   });
 });
 
+describe('switchesAccount', () => {
+  const onSecond = { id: 'model-a', label: 'A', accountId: 'acc_second' };
+
+  it('flags an entry from an account the session is not running on', () => {
+    expect(switchesAccount(onSecond, 'acc_first')).toBe(true);
+    expect(switchesAccount(onSecond, 'acc_second')).toBe(false);
+  });
+
+  it('stays false when either side has no account to compare', () => {
+    // A draft has no running account, and a curated-table entry belongs to none.
+    expect(switchesAccount(onSecond, undefined)).toBe(false);
+    expect(switchesAccount({ id: 'model-a', label: 'A' }, 'acc_first')).toBe(false);
+  });
+});
+
 describe('groupModelsByProvider', () => {
   const multiProvider = [
     { id: 'opencode/hy3', label: 'Hy3', description: 'OpenCode Zen' },
diff --git a/packages/presentation/ui/src/shell/agent-models.ts b/packages/presentation/ui/src/shell/agent-models.ts
index 0cf6ebf9..dd0b7af1 100644
--- a/packages/presentation/ui/src/shell/agent-models.ts
+++ b/packages/presentation/ui/src/shell/agent-models.ts
@@ -30,6 +30,20 @@ export function modelChoiceKey(option: ModelOption): string {
   return `${option.accountId ?? ''}:${option.id}`;
 }
 
+/** Whether picking this entry leaves the account a session is currently running on. Credentials and
+ * base URL are injected once at spawn, so such a pick relaunches the agent rather than rebinding it
+ * in place. Unknown accounts on either side mean the question doesn't apply. */
+export function switchesAccount(
+  option: ModelOption,
+  currentAccountId: string | undefined,
+): boolean {
+  return (
+    currentAccountId !== undefined &&
+    option.accountId !== undefined &&
+    option.accountId !== currentAccountId
+  );
+}
+
 /** Group a catalog by its provider subtitle (`description`, per the adapter convention above),
  * preserving catalog order within groups and first-appearance order across them. Returns null
  * below two distinct providers — a single-provider list reads better flat. */
diff --git a/packages/presentation/ui/src/shell/composer-controls.tsx b/packages/presentation/ui/src/shell/composer-controls.tsx
index b62438ca..2462bf7e 100644
--- a/packages/presentation/ui/src/shell/composer-controls.tsx
+++ b/packages/presentation/ui/src/shell/composer-controls.tsx
@@ -30,7 +30,12 @@ import { AGENT_LABELS, AgentIcon } from '../chat/agent-icon';
 import type { EffortOption } from './agent-efforts';
 import { EFFORT_OPTIONS_BY_ID } from './agent-efforts';
 import type { ModelOption } from './agent-models';
-import { groupModelsByProvider, modelChoiceKey, resolveModel } from './agent-models';
+import {
+  groupModelsByProvider,
+  modelChoiceKey,
+  resolveModel,
+  switchesAccount,
+} from './agent-models';
 import type { AgentRuntimeCue, AgentRuntimeCues } from './agent-onboarding-card';
 
 // Linear lookup: the policy/effort lists are a handful of entries at most.
@@ -211,6 +216,28 @@ function RuntimeCueBadge({ cue }: { cue?: AgentRuntimeCue }): React.ReactNode {
   );
 }
 
+/** One model entry. `description` is the account label the flat list needs to disambiguate; a
+ * provider submenu already names it and passes none. */
+function ModelMenuItem({
+  option,
+  description,
+  restartHint,
+}: {
+  option: ModelOption;
+  description?: string;
+  restartHint?: string;
+}): React.ReactNode {
+  return (
+    <MenuRadioItem closeOnClick value={modelChoiceKey(option)}>
+      <span className="flex min-w-0 flex-col">
+        <span>{option.label}</span>
+        {description ? <span className="text-muted-foreground text-xs">{description}</span> : null}
+        {restartHint ? <span className="text-2xs text-label-tertiary">{restartHint}</span> : null}
+      </span>
+    </MenuRadioItem>
+  );
+}
+
 export function ModelSelectorMenu({
   disabled,
   harness,
@@ -220,6 +247,7 @@ export function ModelSelectorMenu({
   effortOptions,
   selectedModelId,
   selectedAccountId,
+  accountSwitchRestarts = false,
   selectedEffortId,
   onSelectModel,
   onSelectEffort,
@@ -238,6 +266,9 @@ export function ModelSelectorMenu({
   selectedModelId: string | null;
   /** Disambiguates the selection when the list spans accounts serving the same model id. */
   selectedAccountId?: string;
+  /** Live sessions only: credentials are injected at spawn, so leaving `selectedAccountId` relaunches
+   * the agent. Entries from another account say so; a draft has nothing to restart. */
+  accountSwitchRestarts?: boolean;
   selectedEffortId: EffortLevel | null;
   /** Carries the whole entry: a cross-account list needs the account alongside the id. */
   onSelectModel: (model: ModelOption) => void;
@@ -251,6 +282,10 @@ export function ModelSelectorMenu({
   const t = useTranslations('workbench.composer');
   const selectedModel = resolveModel(modelOptions, selectedModelId, selectedAccountId);
   const providerGroups = groupModelsByProvider(modelOptions);
+  const restartHintFor = (option: ModelOption): string | undefined =>
+    accountSwitchRestarts && switchesAccount(option, selectedAccountId)
+      ? t('modelSwitchRestarts')
+      : undefined;
   const selectedEffort =
     optionById(effortOptions, selectedEffortId) ??
     (selectedEffortId ? EFFORT_OPTIONS_BY_ID[selectedEffortId] : undefined);
@@ -342,31 +377,21 @@ export function ModelSelectorMenu({
               >
                 {providerGroups === null ? (
                   modelOptions?.map((option) => (
-                    <MenuRadioItem
+                    <ModelMenuItem
                       key={modelChoiceKey(option)}
-                      closeOnClick
-                      value={modelChoiceKey(option)}
-                    >
-                      <span className="flex min-w-0 flex-col">
-                        <span>{option.label}</span>
-                        {option.description ? (
-                          <span className="text-muted-foreground text-xs">
-                            {option.description}
-                          </span>
-                        ) : null}
-                      </span>
-                    </MenuRadioItem>
+                      description={option.description}
+                      option={option}
+                      restartHint={restartHintFor(option)}
+                    />
                   ))
                 ) : (
                   <>
                     {providerGroups.ungrouped.map((option) => (
-                      <MenuRadioItem
+                      <ModelMenuItem
                         key={modelChoiceKey(option)}
-                        closeOnClick
-                        value={modelChoiceKey(option)}
-                      >
-                        {option.label}
-                      </MenuRadioItem>
+                        option={option}
+                        restartHint={restartHintFor(option)}
+                      />
                     ))}
                     {/* One submenu per provider; the trigger names the provider, so items drop
                      * the subtitle the flat list needs for disambiguation. */}
@@ -375,13 +400,11 @@ export function ModelSelectorMenu({
                         <MenuSubTrigger>{group.label}</MenuSubTrigger>
                         <MenuSubPopup className="w-56">
                           {group.options.map((option) => (
-                            <MenuRadioItem
+                            <ModelMenuItem
                               key={modelChoiceKey(option)}
-                              closeOnClick
-                              value={modelChoiceKey(option)}
-                            >
-                              {option.label}
-                            </MenuRadioItem>
+                              option={option}
+                              restartHint={restartHintFor(option)}
+                            />
                           ))}
                         </MenuSubPopup>
                       </MenuSub>
diff --git a/packages/presentation/ui/src/shell/composer.tsx b/packages/presentation/ui/src/shell/composer.tsx
index e2541245..5d3a9d85 100644
--- a/packages/presentation/ui/src/shell/composer.tsx
+++ b/packages/presentation/ui/src/shell/composer.tsx
@@ -179,6 +179,8 @@ export interface ComposerProps {
   onModelChange?: (model: ModelOption) => Promise<void>;
   /** The account the current model belongs to; disambiguates a list spanning several. */
   currentAccountId?: string;
+  /** Live sessions only: mark entries from another account, whose pick restarts the thread. */
+  accountSwitchRestarts?: boolean;
   /** Sends the reasoning-effort switch (`set-effort`); reflected from `effort-update`, same contract. */
   onEffortChange?: (effort: EffortLevel) => Promise<void>;
   /** Clears a draft's explicit model override. Omitted for live sessions. */
@@ -233,6 +235,7 @@ export function Composer({
   onApprovalPolicyChange,
   onModelChange,
   currentAccountId,
+  accountSwitchRestarts = false,
   onEffortChange,
   onResetModel,
   onResetEffort,
@@ -1029,6 +1032,7 @@ export function Composer({
                     harness={agentKind}
                     runtimeCues={runtimeCues}
                     selectableHarnesses={selectableHarnesses}
+                    accountSwitchRestarts={accountSwitchRestarts}
                     selectedAccountId={currentAccountId}
                     selectedEffortId={currentEffort ?? null}
                     selectedModelId={currentModel ?? null}
diff --git a/packages/presentation/ui/src/shell/conversation-surface.tsx b/packages/presentation/ui/src/shell/conversation-surface.tsx
index 1c54021e..acb61730 100644
--- a/packages/presentation/ui/src/shell/conversation-surface.tsx
+++ b/packages/presentation/ui/src/shell/conversation-surface.tsx
@@ -33,9 +33,8 @@ export interface ConversationSurfaceProps {
   composer: ConversationComposerController;
   agentKind?: AgentKind;
   agentLabel?: string;
-  /** The models picked on *this session's* account — the only ones it may switch to, because its
-   * account is fixed at spawn. Absent means no account backs it, so the adapter catalog or the
-   * curated table supplies the choices instead. */
+  /** Every model this session's agent may run on, across all accounts it can bind. Absent means no
+   * account backs it, so the adapter catalog or the curated table supplies the choices instead. */
   accountModels?: ModelOption[];
   /** The session's account, so a reflected model id resolves against the right entry. */
   accountId?: string;
@@ -196,6 +195,9 @@ export function ConversationSurface({
           // on", so it outranks both the adapter catalog and the curated table.
           agentModels={accountModels ?? conversation.availableModels}
           currentAccountId={accountId}
+          // Live thread: leaving its account means relaunching the agent, which the menu says out
+          // loud rather than letting a process restart happen invisibly.
+          accountSwitchRestarts
           directiveControls={composer.directiveControls}
           onSend={composer.onSend}
           // Scrolls at submit, not acceptance: the jump must feel tied to pressing send, and a
diff --git a/packages/presentation/ui/src/shell/shell-frame.tsx b/packages/presentation/ui/src/shell/shell-frame.tsx
index 7c9d5c33..6d908c00 100644
--- a/packages/presentation/ui/src/shell/shell-frame.tsx
+++ b/packages/presentation/ui/src/shell/shell-frame.tsx
@@ -61,9 +61,6 @@ export interface ShellFrameProps
   /** The models each agent may run on, picked on its bound account. An agent absent here has no
    * account bound and keeps falling back to whatever its adapter or the curated table advertises. */
   accountModels: Readonly<Partial<Record<AgentKind, ModelOption[]>>> | null;
-  /** The active session's own account's models — the whole live menu, since a running session's
-   * account is fixed at spawn. */
-  sessionModels?: ModelOption[];
   /** Last effort accepted by LinkCode per provider for new sessions. */
   newSessionPreferredEfforts: Readonly<Partial<Record<AgentKind, EffortLevel>>>;
   newSessionPreferredBranches: Readonly<Record<string, BranchSelection>>;
@@ -137,7 +134,6 @@ export function ShellFrame({
   agentCatalogs,
   newSessionDefaultModels,
   accountModels,
-  sessionModels,
   newSessionPreferredEfforts,
   newSessionPreferredBranches,
   NewSessionBranchPickerComponent,
@@ -249,7 +245,7 @@ export function ShellFrame({
             composer={conversationComposer}
             agentKind={active?.kind}
             agentLabel={active ? active.kind : undefined}
-            accountModels={sessionModels}
+            accountModels={active ? accountModels?.[active.kind] : undefined}
             accountId={active?.accountId}
             attachmentsSupported={Boolean(active && attachmentSupport?.[active.kind])}
             disabled={!active || active.status === 'stopped'}

From c8c91cab382d7d413605a4d2adfb12a4fc6b907c Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 14:10:39 +0800
Subject: [PATCH 13/17] docs(agent-adapter,schema): record that a cross-account
 switch relaunches the session

---
 packages/foundation/schema/src/model/session/record.ts | 4 ++--
 packages/host/agent-adapter/AGENTS.md                  | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/foundation/schema/src/model/session/record.ts b/packages/foundation/schema/src/model/session/record.ts
index 25c0769c..e7a056df 100644
--- a/packages/foundation/schema/src/model/session/record.ts
+++ b/packages/foundation/schema/src/model/session/record.ts
@@ -79,8 +79,8 @@ export const SessionInfoSchema = z.object({
   automation: SessionAutomationSchema.optional(),
   /** Latest run's provider-local history id — the transcript to read this session's past from. */
   historyId: AgentHistoryIdSchema.optional(),
-  /** Latest run's account. The model menu of a live session scopes to it, because the account
-   * cannot change mid-session. */
+  /** Latest run's account — what the session is talking to now. Picking a model from another
+   * account relaunches the session on it, which starts a new run. */
   accountId: z.string().min(1).optional(),
   /** Provider-history operations supported by this session's adapter/runtime. */
   historyCapabilities: AgentHistoryCapabilitiesSchema.optional(),
diff --git a/packages/host/agent-adapter/AGENTS.md b/packages/host/agent-adapter/AGENTS.md
index 14f3068e..e46443a4 100644
--- a/packages/host/agent-adapter/AGENTS.md
+++ b/packages/host/agent-adapter/AGENTS.md
@@ -106,13 +106,14 @@ Product code must branch on `historyCapabilities` — never assume an op is supp
 | claude-code | ✓ | ✓ (live) | ✓ (live) | ✓ | ✓ | ✗ | detected user install / managed dir |
 | codex | ✓ | ✓ (next turn) | ✓ (next turn, low–max; Sol/Terra ultra) | ✓ (3 tiers) | ✓ | ✓ | detected user install / managed dir |
 | opencode | ✓ | ✓ (next turn, same provider) | ✗ | ✓ (agent axis: build/plan/custom; hidden if discovery fails) | ✓ | ✓ | detected user install / managed dir (CODE-76; PATH-name fallback for unprobed hosts) |
-| pi | ✗ | ✗ | ✗ | fixed bypass | ✗ | ✗ | in-process JS: managed npm-closure import (CODE-219) / dev node_modules |
+| pi | ✓ | ✗ | ✗ | fixed bypass | ✗ | ✗ | in-process JS: managed npm-closure import (CODE-219) / dev node_modules |
 | grok-build | ✗ | ✓ (next turn) | ✓ (next turn, low–high) | fixed bypass | ✗ | ✗ | detected user install |
 
 `StartOptions.effort` enters through the same `onSetEffort` hook before `onStart`, so startup-only
 levels (Claude `max`) and live-switchable levels share validation and reflection behavior. The
 engine caches the emitted effort and replays it when the newly created session attaches.
 
+- **A live session can change account, but never in place.** Credentials and base URL are injected once at spawn, so the engine implements a cross-account `set-model` (one carrying `accountId`) as a relaunch under the same session id that resumes the transcript — `SessionLifecycleService.switchModel`, refused while a turn runs, without a transcript, or when the agent cannot resume. No adapter sees it: the old one is destroyed and a new one is constructed from fresh `StartOptions`. `onSetModel` therefore only ever handles a switch *within* the session's own account, which is why opencode's cross-provider rejection there remains correct.
 - **apiKey injection** (all read `StartOptions.config.apiKey`, five shapes): claude-code → `ANTHROPIC_API_KEY` in spawned env; codex → `CODEX_API_KEY` in the app-server env (the CLI still honors `CODEX_HOME`/config.toml auth); opencode → nested `config.provider[providerID].options.apiKey`; pi → `authStorage.setRuntimeApiKey` + `registerProvider`; grok-build → `XAI_API_KEY` in the headless process env.
   - **The two provider-routed agents need a provider id, and the model string is not a reliable source.** Precedence: model-ref (`providerID/modelID`, which decides routing) → for pi, the resumed session's own last-routed provider (`lastPiModelChange`, direct evidence) → `config.knownProvider` (the endpoint's id in the agent's own catalog, from `@linkcode/providers`) → for pi, its first available provider. Before `knownProvider` existed a bare model id left the credential uninjected entirely; putting it ahead of the resumed provider instead strands a resumed session on a provider that never got the key.
   - **pi's credential injection cannot change a provider's wire, and must not pretend to.** `registerProvider` with no `models` takes `applyProviderConfig`'s override-only branch (verified in the installed `dist/core/model-registry.js`), which rewrites `baseUrl` and leaves each model's `api` untouched. `config.api` is read in exactly two places — the `config.streamSimple` branch and the `config.models` branch — so on a baseUrl-only call it is **silently discarded**, despite `ProviderConfigInput` declaring `api?: Api`. Passing it typechecks and does nothing; an earlier revision of this adapter did exactly that, and mocked-`registerProvider` tests asserted the call shape and never noticed. This is why injection is only correct when the target provider's *built-in* wire already matches the endpoint — which is the case that matters, since pi ships correct metadata for every provider it knows. Aiming a provider at a differently-shaped endpoint needs a `models`-carrying call (`@linkcode/providers` AGENTS.md records why that is not built).

From 9ceb38698f92ebc76abea18f7f3cf3f397ec319c Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 14:37:19 +0800
Subject: [PATCH 14/17] fix(webview): seed the new-chat e2e with the current
 defaults key and field

---
 apps/webview/e2e/browser-smoke.e2e.mts | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/apps/webview/e2e/browser-smoke.e2e.mts b/apps/webview/e2e/browser-smoke.e2e.mts
index 12adad85..10bfb975 100644
--- a/apps/webview/e2e/browser-smoke.e2e.mts
+++ b/apps/webview/e2e/browser-smoke.e2e.mts
@@ -15,6 +15,7 @@ import { chromium } from 'playwright-core';
 const webviewDir = fileURLToPath(new URL('..', import.meta.url));
 const daemonDir = fileURLToPath(new URL('../../daemon', import.meta.url));
 const viteCli = fileURLToPath(new URL('../../bin/vite.js', import.meta.resolve('vite')));
+const newSessionDefaultsKey = 'linkcode.workbench.new-session-defaults:v7';
 const mockThreadTitle = 'Wire the workbench to the daemon';
 const mockChatThreadTitle = 'Prototype without git';
 const longThreadTitle = 'Long thread · navigation testbed';
@@ -69,12 +70,11 @@ async function sendPrompt(page: Page, prompt: string, appErrors: string[]): Prom
 }
 
 async function verifyNewChatIsolation(page: Page, appErrors: string[]): Promise<void> {
-  await page.evaluate(() => {
-    localStorage.setItem(
-      'linkcode.workbench.new-session-defaults:v5',
-      JSON.stringify({ state: { lastProvider: 'pi' }, version: 0 }),
-    );
-  });
+  // Must track NEW_SESSION_DEFAULTS_STORAGE_KEY and its schema: a stale blob is discarded silently,
+  // the new chat falls back to claude-code, and its `missing` mock runtime blocks Send forever.
+  await page.evaluate((key) => {
+    localStorage.setItem(key, JSON.stringify({ state: { lastHarness: 'pi' }, version: 0 }));
+  }, newSessionDefaultsKey);
   await page.reload({ waitUntil: 'domcontentloaded' });
   await page.locator('[data-thread-title]', { hasText: mockChatThreadTitle }).waitFor();
   await page.locator('[data-thread-title]', { hasText: mockChatThreadTitle }).click();
@@ -101,7 +101,14 @@ async function verifyNewChatIsolation(page: Page, appErrors: string[]): Promise<
     });
   });
 
-  await page.getByRole('button', { name: 'Send' }).click();
+  const send = page.getByRole('button', { name: 'Send' });
+  if (await send.isDisabled()) {
+    throw new Error(
+      `New chat cannot send: the ${newSessionDefaultsKey} seed did not resolve a sendable harness. ` +
+        'Check the storage key version and the persisted field names against new-session-defaults-store.ts.',
+    );
+  }
+  await send.click();
   await page.getByText(`You said: ${prompt}`, { exact: false }).waitFor({ timeout: 15000 });
   const titles = await page.evaluate(() => {
     const finish = Reflect.get(window, '__newChatIsolationProbe') as

From 47c820e851e7ace33fcff473c7673933d08a5b61 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 21:42:22 +0800
Subject: [PATCH 15/17] feat(schema,engine): let a thread keep its own model
 and account across relaunches

---
 .../schema/src/model/provider-config.ts       |  9 ++-
 .../schema/src/model/session/record.ts        |  3 +
 .../__tests__/engine-session-records.test.ts  | 55 +++++++++++++++++++
 .../engine/src/session/lifecycle-service.ts   | 30 ++++++----
 .../src/session/session-record-registry.ts    | 42 ++++++++++++--
 5 files changed, 121 insertions(+), 18 deletions(-)

diff --git a/packages/foundation/schema/src/model/provider-config.ts b/packages/foundation/schema/src/model/provider-config.ts
index 0f9bc37b..34b8be5c 100644
--- a/packages/foundation/schema/src/model/provider-config.ts
+++ b/packages/foundation/schema/src/model/provider-config.ts
@@ -14,8 +14,15 @@ export const ProviderConfigSchema = z.object({
   /** Legacy provider API key, superseded by the global account pool (`account.ts`) but kept so
    * pre-account configs still load; the resolver falls back to it when `activeAccountId` is unset. */
   apiKey: z.string().optional(),
-  /** Id of the pooled `Account` this agent's new sessions use (see `account.ts`). */
+  /** Id of the pooled `Account` this agent falls back to when nothing names one: automation,
+   * schedules, and IM-created threads, plus a new session started without picking a model.
+   * Sessions started from a picker carry their own account and never consult this. */
   activeAccountId: z.string().optional(),
+  /** The accounts whose models this agent offers in its pickers. **Absent means every bindable
+   * account**, so an added account is offered without a trip through Settings; an explicit list is
+   * the user narrowing it. Availability still gates it — listing an account that cannot back this
+   * agent offers nothing. */
+  enabledAccountIds: z.array(z.string().min(1)).optional(),
 });
 export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
 
diff --git a/packages/foundation/schema/src/model/session/record.ts b/packages/foundation/schema/src/model/session/record.ts
index e7a056df..8e4f9cfa 100644
--- a/packages/foundation/schema/src/model/session/record.ts
+++ b/packages/foundation/schema/src/model/session/record.ts
@@ -39,6 +39,9 @@ export const SessionRunSchema = z.object({
   /** The account this run resolved to. Credentials and base URL are injected once at spawn, so the
    * account is fixed for the run's lifetime and a later rebind does not move it. */
   accountId: z.string().min(1).optional(),
+  /** The model this run resolved to. Recorded with the account because the two are one choice, and
+   * read back on relaunch: a thread keeps its own pick instead of adopting a default that moved. */
+  model: z.string().min(1).optional(),
   startedAt: TimestampSchema,
   endedAt: TimestampSchema.optional(),
 });
diff --git a/packages/host/engine/src/__tests__/engine-session-records.test.ts b/packages/host/engine/src/__tests__/engine-session-records.test.ts
index ca2655ae..65aa51bf 100644
--- a/packages/host/engine/src/__tests__/engine-session-records.test.ts
+++ b/packages/host/engine/src/__tests__/engine-session-records.test.ts
@@ -10,6 +10,7 @@ import type {
   WorkspaceId,
 } from '@linkcode/schema';
 import { MessageIdSchema, textBlock } from '@linkcode/schema';
+import { nullthrow } from 'foxts/guard';
 import { describe, expect, it, vi } from 'vitest';
 import { InMemoryProviderConfigStore } from '../agent/provider-config';
 import type { SessionStore } from '../session/session-store';
@@ -1005,6 +1006,60 @@ describe('session account attribution', () => {
   });
 });
 
+describe('a session keeps its own pick', () => {
+  it('resumes on the run’s account and model after the daemon default moved', async () => {
+    const providers = new InMemoryProviderConfigStore();
+    providers.update({
+      providers: {
+        'claude-code': { enabled: true, activeAccountId: 'acc_first', model: 'model-first' },
+      },
+      accounts: [
+        {
+          id: 'acc_first',
+          label: 'First',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-first' },
+          models: [{ id: 'model-first' }],
+          createdAt: 0,
+        },
+        {
+          id: 'acc_second',
+          label: 'Second',
+          service: 'anthropic-api',
+          credential: { type: 'api-key', key: 'sk-second' },
+          models: [{ id: 'model-second' }],
+          createdAt: 0,
+        },
+      ],
+    });
+    const store = new InMemorySessionStore();
+    const h = harness(store, undefined, undefined, undefined, undefined, providers);
+    await h.engine.start();
+    await h.inject({
+      kind: 'session.start',
+      clientReqId: 'r1',
+      opts: { kind: 'claude-code', cwd: '/repo' },
+    });
+    const sessionId = startedId(h.sent, 'r1');
+    h.adapters[0].emit({ type: 'session-ref', historyId: asHistoryId('native-1') });
+    await tick();
+    await h.inject({ kind: 'session.stop', clientReqId: 'r2', sessionId });
+
+    // Settings moves the agent's default to the other account while the thread sleeps.
+    providers.update({
+      providers: {
+        'claude-code': { enabled: true, activeAccountId: 'acc_second', model: 'model-second' },
+      },
+    });
+    await h.inject({ kind: 'session.resume', clientReqId: 'r3', sessionId });
+
+    const resumed = nullthrow(h.adapters.at(-1));
+    expect(resumed.resumedWith?.model).toBe('model-first');
+    expect(resumed.resumedWith?.config?.apiKey).toBe('sk-first');
+    expect((await store.load())[0].runs.at(-1)?.accountId).toBe('acc_first');
+  });
+});
+
 class ResumelessAdapter extends FakeAdapter {
   override readonly historyCapabilities: AgentHistoryCapabilities = {
     list: false,
diff --git a/packages/host/engine/src/session/lifecycle-service.ts b/packages/host/engine/src/session/lifecycle-service.ts
index 66bb9a7f..ae06ff2e 100644
--- a/packages/host/engine/src/session/lifecycle-service.ts
+++ b/packages/host/engine/src/session/lifecycle-service.ts
@@ -104,7 +104,7 @@ export class SessionLifecycleService {
         createdVia: resolved.createdVia,
         createdAt: now,
         updatedAt: now,
-        runs: [{ startedAt: now, ...accountOfRun(resolved) }],
+        runs: [{ startedAt: now, ...runOf(resolved) }],
       };
       yield* sessions.startLive(
         replyTo,
@@ -179,7 +179,7 @@ export class SessionLifecycleService {
         origin: { type: 'imported', historyId, importedAt: now },
         createdAt: now,
         updatedAt: now,
-        runs: [{ historyId, startedAt: now, ...accountOfRun(startOptions) }],
+        runs: [{ historyId, startedAt: now, ...runOf(startOptions) }],
       };
       yield* sessions.startLive(
         replyTo,
@@ -402,14 +402,19 @@ export class SessionLifecycleService {
     );
   }
 
-  /** Resolve the options an existing record relaunches under. `override` is how a caller pins a
-   * model or account other than the daemon's current defaults. */
+  /**
+   * Resolve the options an existing record relaunches under. Absent an explicit `override`, the
+   * thread's own last run supplies the model and account: the daemon's configured default answers
+   * for new and unpinned sessions, and adopting it here would silently move a running thread to
+   * whatever Settings now says.
+   */
   private resolveForRecord(
     record: SessionRecord,
     override?: Pick<StartOptions, 'model' | 'config'>,
   ): Effect.Effect<ResolvedStartOptions, EngineFailure> {
+    const pinned = override ?? this.records.pinnedOptions(record.sessionId);
     return this.startOptions.resolve(
-      { kind: record.kind, cwd: record.cwd, ...override },
+      { kind: record.kind, cwd: record.cwd, ...pinned },
       record.sessionId,
     );
   }
@@ -430,7 +435,7 @@ export class SessionLifecycleService {
   ): Effect.Effect<void, EngineFailure> {
     const { historyId, ...startOptions } = options;
     return Effect.suspend(() => {
-      this.records.beginRun(record.sessionId, resolvedAccountId(resolved.options), historyId);
+      this.records.beginRun(record.sessionId, { ...runOf(resolved.options), historyId });
       return this.sessions.startLive(
         replyTo,
         record,
@@ -477,7 +482,7 @@ export class SessionLifecycleService {
         automation: options.automation,
         createdAt: now,
         updatedAt: now,
-        runs: [{ startedAt: now, ...accountOfRun(startOptions) }],
+        runs: [{ startedAt: now, ...runOf(startOptions) }],
       };
       if (startOptions.cwd) yield* workspaceTouch(workspaces, startOptions.cwd);
       yield* sessions.startLive(undefined, record, (adapter) =>
@@ -550,9 +555,12 @@ function workspaceRegisterWorktree(
   });
 }
 
-/** The run's account, spread into a `SessionRun` so an unresolved one stays absent rather than
- * writing `undefined` into the record. */
-function accountOfRun(opts: StartOptions): { accountId?: string } {
+/** What a run resolved to, spread into a `SessionRun`. Unresolved fields stay absent rather than
+ * writing `undefined` into the record, and are what a later relaunch reads back to stay put. */
+function runOf(opts: StartOptions): { accountId?: string; model?: string } {
   const accountId = resolvedAccountId(opts);
-  return accountId === undefined ? {} : { accountId };
+  return {
+    ...(accountId !== undefined && { accountId }),
+    ...(opts.model !== undefined && { model: opts.model }),
+  };
 }
diff --git a/packages/host/engine/src/session/session-record-registry.ts b/packages/host/engine/src/session/session-record-registry.ts
index c5d7e556..ed4ceebb 100644
--- a/packages/host/engine/src/session/session-record-registry.ts
+++ b/packages/host/engine/src/session/session-record-registry.ts
@@ -6,6 +6,8 @@ import type {
   SessionId,
   SessionInfo,
   SessionRecord,
+  SessionRun,
+  StartOptions,
 } from '@linkcode/schema';
 import { Effect } from 'effect';
 import { nullthrow } from 'foxts/guard';
@@ -140,14 +142,10 @@ export class SessionRecordRegistry {
 
   /** The single writer for a relaunch's run entry. `historyId` is known up front only when the
    * relaunch resumes a transcript; a fresh one gets it later via {@link bindHistoryId}. */
-  beginRun(sessionId: SessionId, accountId?: string, historyId?: AgentHistoryId): void {
+  beginRun(sessionId: SessionId, run: Omit<SessionRun, 'startedAt' | 'endedAt'> = {}): void {
     const record = this.records.get(sessionId);
     if (!record) return;
-    record.runs.push({
-      startedAt: Date.now(),
-      ...(accountId !== undefined && { accountId }),
-      ...(historyId !== undefined && { historyId }),
-    });
+    record.runs.push({ startedAt: Date.now(), ...definedFields(run) });
     this.persist(record);
   }
 
@@ -184,6 +182,23 @@ export class SessionRecordRegistry {
     return record ? latestAccountId(record) : undefined;
   }
 
+  /**
+   * What the newest run resolved to, shaped as a start-options override. A relaunch applies this so
+   * the thread keeps its own model and account; the daemon's configured default answers for new and
+   * unpinned sessions only, and may have moved since this one started.
+   */
+  pinnedOptions(sessionId: SessionId): Pick<StartOptions, 'model' | 'config'> | undefined {
+    const record = this.records.get(sessionId);
+    if (!record) return undefined;
+    const accountId = latestAccountId(record);
+    const model = latestModel(record);
+    if (accountId === undefined && model === undefined) return undefined;
+    return {
+      ...(model !== undefined && { model }),
+      ...(accountId !== undefined && { config: { accountId } }),
+    };
+  }
+
   /** The in-memory record is authoritative while running; persistence is best-effort. */
   private persist(record: SessionRecord): void {
     record.updatedAt = Date.now();
@@ -233,6 +248,21 @@ function latestAccountId(record: SessionRecord): string | undefined {
   return undefined;
 }
 
+function latestModel(record: SessionRecord): string | undefined {
+  for (let index = record.runs.length - 1; index >= 0; index -= 1) {
+    const model = record.runs[index].model;
+    if (model !== undefined) return model;
+  }
+  return undefined;
+}
+
+/** Spreading an explicit `undefined` would write the key into the persisted record. */
+function definedFields<T extends object>(fields: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== undefined),
+  ) as Partial<T>;
+}
+
 function latestHistoryId(record: SessionRecord): AgentHistoryId | undefined {
   for (let index = record.runs.length - 1; index >= 0; index -= 1) {
     const historyId = record.runs[index].historyId;

From ab457388ba00cda1db395411bebc1b5e8fc01130 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 21:57:22 +0800
Subject: [PATCH 16/17] feat(workbench,ui,i18n): enable accounts per agent, and
 make the default explicit

---
 .../__tests__/default-models.test.ts          |  29 +++-
 .../settings/providers/__tests__/view.test.ts |  54 +++++--
 .../src/settings/providers/default-models.ts  |  67 ++++-----
 .../settings/providers/providers-settings.tsx |  15 +-
 .../workbench/src/settings/providers/view.ts  | 119 +++++++++------
 .../workbench/src/surface/workbench.tsx       |  23 +--
 packages/presentation/i18n/src/locales/en.ts  |   9 +-
 .../presentation/i18n/src/locales/zh-cn.ts    |   9 +-
 .../ui/src/shell/providers/account-detail.tsx | 140 +++++++++++-------
 9 files changed, 297 insertions(+), 168 deletions(-)

diff --git a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
index 37b666cd..eea19086 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/default-models.test.ts
@@ -109,6 +109,27 @@ describe('accountModelOptions', () => {
     ).toEqual([]);
   });
 
+  it('offers only the accounts enabled for that agent, and every bindable one when unset', () => {
+    const pool = [anthropicAccount, deepseekAccount];
+    // Both can back claude-code, and an absent list means the user has narrowed nothing.
+    expect(accountModelOptions(pool, {})['claude-code']).toHaveLength(
+      accountModelOptions(pool)['claude-code']?.length ?? 0,
+    );
+
+    const narrowed = accountModelOptions(pool, {
+      'claude-code': { enabled: true, enabledAccountIds: ['acc_deepseek'] },
+    })['claude-code'];
+    expect(new Set(narrowed?.map((option) => option.accountId))).toEqual(new Set(['acc_deepseek']));
+
+    // Disabling every account leaves it present-and-empty, which blocks sending rather than
+    // silently handing the choice back to the agent.
+    expect(
+      accountModelOptions(pool, { 'claude-code': { enabled: true, enabledAccountIds: [] } })[
+        'claude-code'
+      ],
+    ).toEqual([]);
+  });
+
   it('keeps same-id models from two accounts as separate, identifiable entries', () => {
     const shared = { ...anthropicAccount, id: 'acc_other', label: 'Work key' };
     const options = accountModelOptions([anthropicAccount, shared])['claude-code'] ?? [];
@@ -117,13 +138,19 @@ describe('accountModelOptions', () => {
     expect(new Set(options.map(modelChoiceKey)).size).toBe(2);
   });
 
-  it('stays unresolved until the account pool has loaded', () => {
+  it('stays unresolved until both the account pool and the enabled lists have loaded', () => {
     const { result, rerender } = renderHook(() => useAccountModelOptions());
 
     expect(result.current).toBeNull();
 
+    // Accounts alone are not enough: the enabled list narrows them, so offering the unnarrowed set
+    // would briefly show models the user disabled.
     accountsData = [];
     rerender();
+    expect(result.current).toBeNull();
+
+    providersData = {};
+    rerender();
     expect(result.current).toEqual({});
   });
 });
diff --git a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
index 50a0680f..99a199cb 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
@@ -6,7 +6,8 @@ import {
   boundAgentKinds,
   maskSecret,
   providerAccountListViewModel,
-  withBinding,
+  withAccountEnabled,
+  withDefaultAccount,
   withModel,
   withoutAccount,
 } from '../view';
@@ -17,18 +18,18 @@ const providers: ProvidersConfig = {
   opencode: { enabled: true },
 };
 
-describe('binding transforms', () => {
-  it('binds while preserving the entry and defaults enabled for a fresh kind', () => {
-    const next = withBinding(providers, 'codex', 'acc_a');
+describe('provider config transforms', () => {
+  it('sets the default while preserving the entry and defaults enabled for a fresh kind', () => {
+    const next = withDefaultAccount(providers, 'codex', 'acc_a');
     expect(next.codex).toEqual({ enabled: false, activeAccountId: 'acc_a' });
-    expect(withBinding(providers, 'pi', 'acc_a').pi).toEqual({
+    expect(withDefaultAccount(providers, 'pi', 'acc_a').pi).toEqual({
       enabled: true,
       activeAccountId: 'acc_a',
     });
   });
 
-  it('unbinds by dropping only activeAccountId', () => {
-    const next = withBinding(providers, 'claude-code', undefined);
+  it('clears the default by dropping only activeAccountId', () => {
+    const next = withDefaultAccount(providers, 'claude-code', undefined);
     expect(next['claude-code']).toEqual({ enabled: true, model: 'claude-opus-4-8' });
   });
 
@@ -42,14 +43,14 @@ describe('binding transforms', () => {
     });
     const pool = [offers('acc_keep', ['claude-opus-4-8']), offers('acc_drop', ['deepseek-v4-pro'])];
 
-    // Rebinding to an account that lists the pick leaves it alone.
-    expect(withBinding(providers, 'claude-code', 'acc_keep', pool)['claude-code']).toEqual({
+    // Moving the default to an account that lists the pick leaves it alone.
+    expect(withDefaultAccount(providers, 'claude-code', 'acc_keep', pool)['claude-code']).toEqual({
       enabled: true,
       activeAccountId: 'acc_keep',
       model: 'claude-opus-4-8',
     });
     // One that does not would otherwise start the next session on a model it never listed.
-    expect(withBinding(providers, 'claude-code', 'acc_drop', pool)['claude-code']).toEqual({
+    expect(withDefaultAccount(providers, 'claude-code', 'acc_drop', pool)['claude-code']).toEqual({
       enabled: true,
       activeAccountId: 'acc_drop',
     });
@@ -67,6 +68,39 @@ describe('binding transforms', () => {
     });
   });
 
+  it('materializes the enabled list from what is bindable on the first disable', () => {
+    const pool: Accounts = [
+      { id: 'acc_a', label: 'A', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+      { id: 'acc_b', label: 'B', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+    ];
+
+    // Absent means "all bindable", so disabling one has to write the rest down explicitly.
+    const disabled = withAccountEnabled(providers, 'opencode', 'acc_a', false, pool);
+    expect(disabled.opencode?.enabledAccountIds).toEqual(['acc_b']);
+    // Re-enabling puts it back without duplicating.
+    const reEnabled = withAccountEnabled(disabled, 'opencode', 'acc_a', true, pool);
+    expect(reEnabled.opencode?.enabledAccountIds).toEqual(['acc_b', 'acc_a']);
+  });
+
+  it('clears the default when the account serving it is disabled', () => {
+    const pool: Accounts = [
+      { id: 'acc_a', label: 'A', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+    ];
+    // Leaving it would keep resolving unpinned sessions onto an account just removed from the menu.
+    const next = withAccountEnabled(providers, 'claude-code', 'acc_a', false, pool);
+    expect(next['claude-code']?.activeAccountId).toBeUndefined();
+    expect(next['claude-code']?.enabledAccountIds).toEqual([]);
+  });
+
+  it('leaves the default alone when a non-default account is disabled', () => {
+    const pool: Accounts = [
+      { id: 'acc_a', label: 'A', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+      { id: 'acc_b', label: 'B', credential: { type: 'api-key', key: 'k' }, createdAt: 0 },
+    ];
+    const next = withAccountEnabled(providers, 'claude-code', 'acc_b', false, pool);
+    expect(next['claude-code']?.activeAccountId).toBe('acc_a');
+  });
+
   it('clears every binding of a removed account, identity-stable when none matched', () => {
     const next = withoutAccount(providers, 'acc_a');
     expect(next['claude-code']).toEqual({ enabled: true, model: 'claude-opus-4-8' });
diff --git a/packages/client/workbench/src/settings/providers/default-models.ts b/packages/client/workbench/src/settings/providers/default-models.ts
index ecbfa48a..1d5d1be5 100644
--- a/packages/client/workbench/src/settings/providers/default-models.ts
+++ b/packages/client/workbench/src/settings/providers/default-models.ts
@@ -1,13 +1,12 @@
 import { resolveBinding } from '@linkcode/providers';
 import type { Account, Accounts, AgentKind, ProvidersConfig } from '@linkcode/schema';
 import { AgentKindSchema } from '@linkcode/schema';
-import { getAccounts, getProviderConfig, setProviderConfig } from '@linkcode/sdk';
+import { getAccounts, getProviderConfig } from '@linkcode/sdk';
 import type { ModelOption } from '@linkcode/ui';
-import { useData, useMutation } from '../../runtime/tayori';
-import { withModel } from './view';
+import { useData } from '../../runtime/tayori';
 
-/** The model each agent currently runs on, as session start resolves it: the agent's persisted pick.
- * The bound account contributes the set that pick came from, never the pick itself. */
+/** Each agent's configured default model — what a session starts on when nothing picked one, and
+ * what automation and scheduled runs always use. A running thread keeps its own pick instead. */
 export function configuredDefaultModels(
   providers: ProvidersConfig | undefined,
 ): Partial<Record<AgentKind, string>> {
@@ -28,9 +27,9 @@ export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>>
 }
 
 /**
- * Every model this agent could run on: the picked sets of *all* accounts it can bind, not just the
- * one bound now. Choosing a model therefore also chooses its account, which is what lets one agent
- * reach several providers without a trip through Settings. Live sessions read the same list — a
+ * Every model this agent offers: the picked sets of each account that can back it *and* is enabled
+ * for it. Choosing a model therefore also chooses its account, which is what lets one agent reach
+ * several providers without a trip through Settings. Live sessions read the same list — a
  * cross-account pick there restarts the thread on that account rather than rebinding in place.
  *
  * `description` carries the account label so `groupModelsByProvider` renders one submenu per
@@ -38,13 +37,15 @@ export function useConfiguredDefaultModels(): Partial<Record<AgentKind, string>>
  * legitimately serve the same model id.
  *
  * Present-but-empty and absent mean different things, and callers rely on the difference. An entry
- * exists whenever at least one account can back the agent, so `[]` says "bindable, nothing picked
+ * exists whenever at least one account can back the agent, so `[]` says "available, nothing picked
  * yet" and blocks sends the way the daemon does. Absent says "no account can back this agent", where
  * it still resolves its own model — pickers fall through to the adapter catalog or the curated table,
- * and nothing blocks.
+ * and nothing blocks. Disabling every account for an agent therefore blocks it rather than silently
+ * handing it back to the adapter's own choice.
  */
 export function accountModelOptions(
   accounts: Accounts | undefined,
+  providers?: ProvidersConfig,
 ): Partial<Record<AgentKind, ModelOption[]>> {
   const options: Partial<Record<AgentKind, ModelOption[]>> = {};
   for (const kind of AgentKindSchema.options) {
@@ -52,11 +53,25 @@ export function accountModelOptions(
       (account) => resolveBinding(account, kind).tier !== 'unavailable',
     );
     if (bindable.length === 0) continue;
-    options[kind] = bindable.flatMap((account) => modelOptionsOf(account));
+    const enabled = providers?.[kind]?.enabledAccountIds;
+    const offered =
+      enabled === undefined ? bindable : bindable.filter((account) => enabled.includes(account.id));
+    options[kind] = offered.flatMap((account) => modelOptionsOf(account));
   }
   return options;
 }
 
+/** Whether this account's models are offered for this agent. Absent list means every bindable one,
+ * so a newly added account is offered without a visit to Settings. */
+export function accountEnabledFor(
+  providers: ProvidersConfig | undefined,
+  kind: AgentKind,
+  accountId: string,
+): boolean {
+  const enabled = providers?.[kind]?.enabledAccountIds;
+  return enabled === undefined || enabled.includes(accountId);
+}
+
 function modelOptionsOf(account: Account): ModelOption[] {
   return (account.models ?? []).map(({ id, label }) => ({
     id,
@@ -66,31 +81,11 @@ function modelOptionsOf(account: Account): ModelOption[] {
   }));
 }
 
-/** `null` until the account pool has loaded, so a picker never briefly offers a set that is not
- * actually available. */
+/** `null` until both daemon-owned sources have loaded, so a picker never briefly offers a set that
+ * is not actually available — or one the enabled list would have narrowed. */
 export function useAccountModelOptions(): Partial<Record<AgentKind, ModelOption[]>> | null {
   const { data: accounts } = useData(getAccounts, {});
-  if (accounts === undefined) return null;
-  return accountModelOptions(accounts);
-}
-
-/**
- * Persist what an agent runs on. This is the only model memory: the daemon owns it, so Settings and
- * the composer cannot disagree and a scheduled or script session inherits the same pick. Passing the
- * account rebinds the agent to it — picking a model is also picking who serves it.
- *
- * Called once a selection is known to have been accepted, not on the menu click, so an abandoned
- * draft never rewrites config and a provider that rejects a model leaves the previous one standing.
- */
-export function usePersistPickedModel(): (
-  kind: AgentKind,
-  model: string,
-  accountId?: string,
-) => Promise<void> {
-  const { data: providers, mutate } = useData(getProviderConfig, {});
-  const save = useMutation(setProviderConfig);
-  return async (kind, model, accountId) => {
-    await save.trigger({ providers: withModel(providers ?? {}, kind, model, accountId) });
-    await mutate();
-  };
+  const { data: providers } = useData(getProviderConfig, {});
+  if (accounts === undefined || providers === undefined) return null;
+  return accountModelOptions(accounts, providers);
 }
diff --git a/packages/client/workbench/src/settings/providers/providers-settings.tsx b/packages/client/workbench/src/settings/providers/providers-settings.tsx
index fb33dc49..612174b5 100644
--- a/packages/client/workbench/src/settings/providers/providers-settings.tsx
+++ b/packages/client/workbench/src/settings/providers/providers-settings.tsx
@@ -26,7 +26,8 @@ import { useProvidersSettingsStore } from './store';
 import {
   providerAccountDetailViewModel,
   providerAccountListViewModel,
-  withBinding,
+  withAccountEnabled,
+  withDefaultAccount,
   withModel,
   withoutAccount,
 } from './view';
@@ -76,8 +77,13 @@ export function ProvidersSettingsPanel(): React.ReactNode {
     void mutateProviders();
   };
 
-  const handleSetBinding = (kind: AgentKind, accountId: string | undefined): void => {
-    void applyProviders(withBinding(providers ?? {}, kind, accountId, pool));
+  const handleSetDefaultAccount = (kind: AgentKind, accountId: string | undefined): void => {
+    void applyProviders(withDefaultAccount(providers ?? {}, kind, accountId, pool));
+  };
+
+  const handleSetAccountEnabled = (kind: AgentKind, enabled: boolean): void => {
+    if (!selected) return;
+    void applyProviders(withAccountEnabled(providers ?? {}, kind, selected.id, enabled, pool));
   };
 
   const handleSetModel = (kind: AgentKind, model: string | undefined): void => {
@@ -199,7 +205,8 @@ export function ProvidersSettingsPanel(): React.ReactNode {
                     <AccountDetail
                       account={selectedDetail}
                       busy={busy}
-                      onSetBinding={handleSetBinding}
+                      onSetAccountEnabled={handleSetAccountEnabled}
+                      onSetDefaultAccount={handleSetDefaultAccount}
                       onSetModel={handleSetModel}
                       onEdit={startEdit}
                       onRemove={() => {
diff --git a/packages/client/workbench/src/settings/providers/view.ts b/packages/client/workbench/src/settings/providers/view.ts
index 0a540933..adc54404 100644
--- a/packages/client/workbench/src/settings/providers/view.ts
+++ b/packages/client/workbench/src/settings/providers/view.ts
@@ -18,10 +18,11 @@ import type {
   ProviderAccountListItem,
   ProviderAccountListViewModel,
   ProviderAccountRouting,
-  ProviderBindingStatus,
-  ProviderBindingViewModel,
+  ProviderAgentStatus,
+  ProviderAgentViewModel,
   ProviderCredentialViewModel,
 } from '@linkcode/ui';
+import { accountEnabledFor } from './default-models';
 
 /** Pure view helpers for the Providers page — no hooks, unit-testable. */
 
@@ -33,7 +34,7 @@ export function maskSecret(secret: string): string {
   return `${secret.slice(0, 6)}…${secret.slice(-4)}`;
 }
 
-/** Agents whose active provider is this account, in stable agent order. */
+/** Agents that fall back to this account when nothing names one, in stable agent order. */
 export function boundAgentKinds(
   providers: ProvidersConfig | undefined,
   accountId: string,
@@ -86,42 +87,39 @@ function credentialViewModel(
   };
 }
 
-function bindingStatus(
+function agentStatus(
   account: Account,
   accountLabels: ReadonlyMap<string, string>,
   kind: AgentKind,
   providers: ProvidersConfig | undefined,
-): { bound: boolean; status: ProviderBindingStatus; tier: ProviderBindingViewModel['tier'] } {
+): Omit<ProviderAgentViewModel, 'kind' | 'defaultModel'> {
   const availability = resolveBinding(account, kind);
-  const boundId = providers?.[kind]?.activeAccountId;
-  const bound = boundId === account.id;
+  const defaultId = providers?.[kind]?.activeAccountId;
+  const isDefault = defaultId === account.id;
+  const enabled = accountEnabledFor(providers, kind, account.id);
   if (availability.tier === 'unavailable') {
-    if (availability.reason === 'oauth-other-agent' && account.credential.type === 'oauth') {
-      return {
-        bound,
-        tier: availability.tier,
-        status: { kind: 'unavailable-oauth', agent: account.credential.agent },
-      };
-    }
-    return {
-      bound,
-      tier: availability.tier,
-      status: {
-        kind:
-          availability.reason === 'endpoint-incomplete'
-            ? 'unavailable-endpoint-incomplete'
-            : 'unavailable-protocol',
-      },
-    };
+    const status: ProviderAgentStatus =
+      availability.reason === 'oauth-other-agent' && account.credential.type === 'oauth'
+        ? { kind: 'unavailable-oauth', agent: account.credential.agent }
+        : {
+            kind:
+              availability.reason === 'endpoint-incomplete'
+                ? 'unavailable-endpoint-incomplete'
+                : 'unavailable-protocol',
+          };
+    return { tier: availability.tier, enabled: false, isDefault: false, status };
   }
   return {
-    bound,
     tier: availability.tier,
-    status: bound
-      ? { kind: 'bound' }
-      : boundId === undefined
-        ? { kind: 'no-provider' }
-        : { kind: 'bound-elsewhere', accountLabel: accountLabels.get(boundId) ?? boundId },
+    enabled,
+    isDefault,
+    status: !enabled
+      ? { kind: 'disabled' }
+      : isDefault
+        ? { kind: 'default' }
+        : defaultId === undefined
+          ? { kind: 'enabled-no-default' }
+          : { kind: 'enabled', defaultLabel: accountLabels.get(defaultId) ?? defaultId },
   };
 }
 
@@ -133,12 +131,13 @@ export function providerAccountDetailViewModel(
   runtimes: AgentRuntimes | undefined,
 ): ProviderAccountDetailViewModel {
   const accountLabels = new Map(accounts.map((candidate) => [candidate.id, candidate.label]));
-  const bindings = AGENT_KINDS.map((kind): ProviderBindingViewModel => {
-    const binding = bindingStatus(account, accountLabels, kind, providers);
+  const agents = AGENT_KINDS.map((kind): ProviderAgentViewModel => {
+    const status = agentStatus(account, accountLabels, kind, providers);
+    // Only the default account's row edits the default model — the pick belongs to that pairing.
     return {
       kind,
-      ...binding,
-      currentModel: providers?.[kind]?.model ?? '',
+      ...status,
+      ...(status.isDefault && { defaultModel: providers?.[kind]?.model ?? '' }),
     };
   });
   const boundAgents = boundAgentKinds(providers, account.id);
@@ -148,13 +147,16 @@ export function providerAccountDetailViewModel(
     id: account.id,
     label: account.label,
     credential: credentialViewModel(account, runtimes),
-    bindings,
+    agents,
     boundAgents,
-    availableBindingCount: bindings.filter((binding) => binding.tier !== 'unavailable').length,
+    enabledAgentCount: agents.filter((agent) => agent.enabled).length,
+    availableAgentCount: agents.filter((agent) => agent.tier !== 'unavailable').length,
     ...(!(account.service === undefined) && { service: account.service }),
     ...(!(serviceLabel === undefined) && { serviceLabel }),
     ...(routing !== undefined && { routing }),
-    ...(account.models !== undefined && { accountModels: account.models.map(({ id }) => id) }),
+    ...(account.models !== undefined && {
+      accountModels: account.models.map(({ id, label }) => ({ id, label: label ?? id })),
+    }),
     ...(!(boundAgents.length === 0) && {
       configPreview: accountConfigSnippet(providers, account.id),
     }),
@@ -220,13 +222,13 @@ export function providerAccountListViewModel(
 }
 
 /**
- * Bind (or, with undefined, unbind) an agent's active account; other fields survive untouched — with
- * one exception. The pick lives per agent while the set it came from lives on the account, so a
- * rebind can orphan it. Dropping a pick the new account does not offer leaves the agent unpicked,
- * which blocks its sends until the user chooses again; keeping it would run the next session on a
- * model that account never listed.
+ * Set (or, with undefined, clear) the account an agent falls back to when nothing names one. Other
+ * fields survive untouched — with one exception. The default model lives per agent while the set it
+ * came from lives on the account, so moving the default can orphan it. Dropping a model the new
+ * account does not offer leaves the agent unpicked, which blocks its unpinned sends until the user
+ * chooses again; keeping it would run the next one on a model that account never listed.
  */
-export function withBinding(
+export function withDefaultAccount(
   providers: ProvidersConfig,
   kind: AgentKind,
   accountId: string | undefined,
@@ -247,6 +249,37 @@ export function withBinding(
   };
 }
 
+/**
+ * Show or hide one account's models in an agent's pickers. Absent `enabledAccountIds` means every
+ * bindable account, so the first disable has to materialize the list from what is bindable *now* —
+ * an account added later then joins the explicit list rather than being silently excluded.
+ *
+ * Disabling the agent's default account also clears the default: leaving it would keep resolving
+ * unpinned sessions onto an account the user just removed from the menu.
+ */
+export function withAccountEnabled(
+  providers: ProvidersConfig,
+  kind: AgentKind,
+  accountId: string,
+  enabled: boolean,
+  accounts: Accounts = [],
+): ProvidersConfig {
+  const entry = providers[kind] ?? { enabled: true };
+  const current =
+    entry.enabledAccountIds ??
+    accounts.reduce<string[]>((ids, account) => {
+      if (resolveBinding(account, kind).tier !== 'unavailable') ids.push(account.id);
+      return ids;
+    }, []);
+  const next = enabled
+    ? [...new Set([...current, accountId])]
+    : current.filter((id) => id !== accountId);
+  const withList: ProvidersConfig = { ...providers, [kind]: { ...entry, enabledAccountIds: next } };
+  return enabled || entry.activeAccountId !== accountId
+    ? withList
+    : withDefaultAccount(withList, kind, undefined);
+}
+
 /** Toggle whether the agent is offered in the client's agent picker. */
 export function withEnabled(
   providers: ProvidersConfig,
diff --git a/packages/client/workbench/src/surface/workbench.tsx b/packages/client/workbench/src/surface/workbench.tsx
index 929b3a24..34be5cb7 100644
--- a/packages/client/workbench/src/surface/workbench.tsx
+++ b/packages/client/workbench/src/surface/workbench.tsx
@@ -61,7 +61,6 @@ import { useMutation } from '../runtime/tayori';
 import {
   useAccountModelOptions,
   useConfiguredDefaultModels,
-  usePersistPickedModel,
 } from '../settings/providers/default-models';
 import { RuntimeBranchStatus } from '../sidebar/branch-status';
 import { useSidebarGroupCollapseStore } from '../sidebar/collapse-store';
@@ -283,7 +282,6 @@ function WorkbenchSessionSurface({
   const onboarding = useAgentRuntimeOnboarding();
   const rememberNewSessionDefaults = useNewSessionDefaultsStore((state) => state.remember);
   const rememberSelection = useNewSessionDefaultsStore((state) => state.rememberSelection);
-  const persistPickedModel = usePersistPickedModel();
   const [previewExpandedKeys, addPreviewExpanded, removePreviewExpanded] = useSet<string>();
   const threadGroups = useMemo<ThreadGroupViewModel[]>(() => {
     const { pinnedGroup, rest } = extractPinnedGroup(sessions.sessions, pinnedSessionIds);
@@ -409,19 +407,11 @@ function WorkbenchSessionSurface({
           startupSelection,
           sdkClient.raw.eventsSnapshot(sessionId),
         );
-        if (newlyConfirmed.model === undefined && newlyConfirmed.effort === undefined) return;
+        // The model is not remembered here: the session carries its own pick, and the agent's
+        // default is a deliberate Settings choice that starting one thread must not overwrite.
         if (newlyConfirmed.effort !== undefined) {
           rememberSelection(submission.kind, { effort: newlyConfirmed.effort });
         }
-        // The model lands in daemon config rather than a client store, together with the account it
-        // came from, so Settings shows the rebind and non-composer sessions inherit the pick.
-        if (newlyConfirmed.model) {
-          void persistPickedModel(
-            submission.kind,
-            newlyConfirmed.model,
-            submission.accountId,
-          ).catch(noop);
-        }
       })
       .catch(noop);
   }
@@ -467,18 +457,15 @@ function WorkbenchSessionSurface({
     onClearError();
     // Let the rejection propagate: the composer awaits it to decide whether to reflect the pick.
     // onError (wired into modelMutation above) still reports the failure via the error banner.
-    const provider = active?.kind;
+    // The engine records the accepted pick on the session's own run, so it survives a relaunch
+    // without touching the agent's configured default.
     return modelMutation
       .trigger({
         sessionId: sessions.activeId,
         model: model.id,
         ...(model.accountId !== undefined && { accountId: model.accountId }),
       })
-      .then(() => {
-        // Persisting the account too is what makes the switch outlive the running adapter: a later
-        // resume resolves from this config, not from the run it is reviving.
-        if (provider) void persistPickedModel(provider, model.id, model.accountId).catch(noop);
-      });
+      .then(noop);
   }
 
   function handleEffortChange(effort: EffortLevel): Promise<void> {
diff --git a/packages/presentation/i18n/src/locales/en.ts b/packages/presentation/i18n/src/locales/en.ts
index 07dc547b..184eb6d1 100644
--- a/packages/presentation/i18n/src/locales/en.ts
+++ b/packages/presentation/i18n/src/locales/en.ts
@@ -1043,9 +1043,12 @@ export const en = {
       oauthDelegate: 'Follows the {agent} CLI login',
       connections: 'Connected agents',
       connectionsEnabled: '{bound} / {available} enabled',
-      boundNote: 'Active provider for this agent',
-      boundElsewhere: 'Currently provided by “{label}”',
-      noProvider: 'No provider — follows the CLI login',
+      accountDefault: 'Shown in the model menu · used when no account is named',
+      accountEnabled: 'Shown in the model menu · “{label}” used when none is named',
+      accountEnabledNoDefault: 'Shown in the model menu · follows the CLI login when none is named',
+      accountDisabled: 'Hidden from this agent’s model menu',
+      setDefaultAccount: 'Use as default account',
+      clearDefaultAccount: 'Stop using as default account',
       translateBadge: 'Translated',
       translateNote: 'A local gateway translates Anthropic wire to OpenAI Chat',
       unavailableOauth: 'Only connects to {agent}',
diff --git a/packages/presentation/i18n/src/locales/zh-cn.ts b/packages/presentation/i18n/src/locales/zh-cn.ts
index e05f0708..a6002ec6 100644
--- a/packages/presentation/i18n/src/locales/zh-cn.ts
+++ b/packages/presentation/i18n/src/locales/zh-cn.ts
@@ -1017,9 +1017,12 @@ export const zhCN = {
       oauthDelegate: '跟随 {agent} CLI 登录',
       connections: '接入的智能体',
       connectionsEnabled: '{bound} / {available} 已启用',
-      boundNote: '此账号为当前 Provider',
-      boundElsewhere: '当前由「{label}」提供',
-      noProvider: '当前无 Provider · 跟随 CLI 登录',
+      accountDefault: '在模型菜单中显示 · 未指定账号时使用此账号',
+      accountEnabled: '在模型菜单中显示 · 未指定时使用「{label}」',
+      accountEnabledNoDefault: '在模型菜单中显示 · 未指定账号时跟随 CLI 登录',
+      accountDisabled: '不在此智能体的模型菜单中显示',
+      setDefaultAccount: '设为默认账号',
+      clearDefaultAccount: '取消默认账号',
       translateBadge: '经转换',
       translateNote: '本地网关将 Anthropic 协议转为 OpenAI Chat',
       unavailableOauth: '仅可接入 {agent}',
diff --git a/packages/presentation/ui/src/shell/providers/account-detail.tsx b/packages/presentation/ui/src/shell/providers/account-detail.tsx
index 9265b726..e89947ef 100644
--- a/packages/presentation/ui/src/shell/providers/account-detail.tsx
+++ b/packages/presentation/ui/src/shell/providers/account-detail.tsx
@@ -29,6 +29,7 @@ import {
   EyeOffIcon,
   MoreHorizontalIcon,
   PencilIcon,
+  StarIcon,
   Trash2Icon,
 } from 'lucide-react';
 import { useState } from 'react';
@@ -38,20 +39,25 @@ import { AGENT_MODEL_OPTIONS } from '../agent-models';
 import { ServiceIcon } from '../service-icon';
 import type { ProviderAccountRouting } from './routing';
 
-export type ProviderBindingStatus =
+export type ProviderAgentStatus =
   | { kind: 'unavailable-oauth'; agent: AgentKind }
   | { kind: 'unavailable-endpoint-incomplete' }
   | { kind: 'unavailable-protocol' }
-  | { kind: 'bound' }
-  | { kind: 'no-provider' }
-  | { kind: 'bound-elsewhere'; accountLabel: string };
+  | { kind: 'disabled' }
+  | { kind: 'default' }
+  | { kind: 'enabled-no-default' }
+  | { kind: 'enabled'; defaultLabel: string };
 
-export interface ProviderBindingViewModel {
+/** One agent row in an account's dialog: whether this account's models are offered to that agent,
+ * and whether it is also the agent's fallback for sessions that name no account. */
+export interface ProviderAgentViewModel {
   kind: AgentKind;
   tier: 'native' | 'translate' | 'unavailable';
-  status: ProviderBindingStatus;
-  bound: boolean;
-  currentModel: string;
+  status: ProviderAgentStatus;
+  enabled: boolean;
+  isDefault: boolean;
+  /** The agent's default model, present only on the row of the account that serves it. */
+  defaultModel?: string;
 }
 
 export type ProviderCredentialViewModel =
@@ -74,11 +80,13 @@ export interface ProviderAccountDetailViewModel {
   label: string;
   credential: ProviderCredentialViewModel;
   routing?: ProviderAccountRouting;
-  /** Model ids the user picked for this account — the only ones its pickers offer. */
-  accountModels?: string[];
-  bindings: ProviderBindingViewModel[];
+  /** Models the user picked for this account — the only ones its pickers offer. */
+  accountModels?: Array<{ id: string; label: string }>;
+  agents: ProviderAgentViewModel[];
+  /** Agents that fall back to this account; named in the removal warning. */
   boundAgents: AgentKind[];
-  availableBindingCount: number;
+  enabledAgentCount: number;
+  availableAgentCount: number;
   configPreview?: string;
 }
 
@@ -101,7 +109,8 @@ function DetailRow({
 export function AccountDetail({
   account,
   busy,
-  onSetBinding,
+  onSetAccountEnabled,
+  onSetDefaultAccount,
   onSetModel,
   onEdit,
   onRemove,
@@ -109,7 +118,10 @@ export function AccountDetail({
   account: ProviderAccountDetailViewModel;
   /** A providers/accounts write is in flight — hold the switches. */
   busy: boolean;
-  onSetBinding: (kind: AgentKind, accountId: string | undefined) => void;
+  /** Show or hide this account's models in that agent's pickers. */
+  onSetAccountEnabled: (kind: AgentKind, enabled: boolean) => void;
+  /** Make this account the agent's fallback, or clear it with undefined. */
+  onSetDefaultAccount: (kind: AgentKind, accountId: string | undefined) => void;
   onSetModel: (kind: AgentKind, model: string | undefined) => void;
   onEdit: () => void;
   onRemove: () => void;
@@ -202,7 +214,7 @@ export function AccountDetail({
           {account.accountModels !== undefined && account.accountModels.length > 0 ? (
             <DetailRow label={t('accountModel')}>
               <span className="min-w-0 flex-1 truncate font-mono text-muted-foreground text-xs">
-                {account.accountModels.join(' · ')}
+                {account.accountModels.map(({ id }) => id).join(' · ')}
               </span>
             </DetailRow>
           ) : null}
@@ -216,19 +228,21 @@ export function AccountDetail({
           </h3>
           <span className="text-muted-foreground text-xs">
             {t('connectionsEnabled', {
-              bound: account.boundAgents.length,
-              available: account.availableBindingCount,
+              bound: account.enabledAgentCount,
+              available: account.availableAgentCount,
             })}
           </span>
         </div>
         <div className="rounded-lg border border-border">
-          {account.bindings.map((binding) => (
-            <BindingRow
-              key={binding.kind}
+          {account.agents.map((agent) => (
+            <AgentRow
+              key={agent.kind}
               accountId={account.id}
-              binding={binding}
+              accountModels={account.accountModels ?? []}
+              agent={agent}
               busy={busy}
-              onSetBinding={onSetBinding}
+              onSetAccountEnabled={onSetAccountEnabled}
+              onSetDefaultAccount={onSetDefaultAccount}
               onSetModel={onSetModel}
             />
           ))}
@@ -311,10 +325,10 @@ function OauthRows({
   );
 }
 
-function bindingStatusLabel(
+function agentStatusLabel(
   t: ReturnType<typeof useTranslations<'settings.providers'>>,
   tAgent: ReturnType<typeof useTranslations<'workbench.agentKind'>>,
-  status: ProviderBindingStatus,
+  status: ProviderAgentStatus,
 ): string {
   switch (status.kind) {
     case 'unavailable-oauth':
@@ -323,69 +337,95 @@ function bindingStatusLabel(
       return t('unavailableEndpointIncomplete');
     case 'unavailable-protocol':
       return t('unavailableProtocol');
-    case 'bound':
-      return t('boundNote');
-    case 'no-provider':
-      return t('noProvider');
-    case 'bound-elsewhere':
-      return t('boundElsewhere', { label: status.accountLabel });
+    case 'disabled':
+      return t('accountDisabled');
+    case 'default':
+      return t('accountDefault');
+    case 'enabled-no-default':
+      return t('accountEnabledNoDefault');
+    case 'enabled':
+      return t('accountEnabled', { label: status.defaultLabel });
     default:
       return status satisfies never;
   }
 }
 
-function BindingRow({
+/**
+ * One agent's row. The switch decides whether this account's models appear in that agent's pickers;
+ * the star makes it the fallback for sessions that name no account (automation, schedules, IM), and
+ * only that pairing edits the default model.
+ */
+function AgentRow({
   accountId,
-  binding,
+  accountModels,
+  agent,
   busy,
-  onSetBinding,
+  onSetAccountEnabled,
+  onSetDefaultAccount,
   onSetModel,
 }: {
   accountId: string;
-  binding: ProviderBindingViewModel;
+  accountModels: Array<{ id: string; label: string }>;
+  agent: ProviderAgentViewModel;
   busy: boolean;
-  onSetBinding: (kind: AgentKind, accountId: string | undefined) => void;
+  onSetAccountEnabled: (kind: AgentKind, enabled: boolean) => void;
+  onSetDefaultAccount: (kind: AgentKind, accountId: string | undefined) => void;
   onSetModel: (kind: AgentKind, model: string | undefined) => void;
 }): React.ReactNode {
   const t = useTranslations('settings.providers');
   const tAgent = useTranslations('workbench.agentKind');
 
-  const unavailable = binding.tier === 'unavailable';
-  const status = bindingStatusLabel(t, tAgent, binding.status);
-  const note = binding.tier === 'translate' ? `${t('translateNote')} · ${status}` : status;
-  const modelOptions = AGENT_MODEL_OPTIONS[binding.kind];
+  const unavailable = agent.tier === 'unavailable';
+  const status = agentStatusLabel(t, tAgent, agent.status);
+  const note = agent.tier === 'translate' ? `${t('translateNote')} · ${status}` : status;
+  // An account with no listed models still serves the agent's own catalog, so fall back to the
+  // curated table rather than offering an empty select.
+  const modelOptions =
+    accountModels.length > 0 ? accountModels : (AGENT_MODEL_OPTIONS[agent.kind] ?? []);
+  const defaultModel = agent.defaultModel;
 
   return (
     <div
       className={`flex items-center gap-3 border-border border-t px-3 py-2.5 first:border-t-0 ${unavailable ? 'opacity-50' : ''}`}
     >
-      <AgentIcon kind={binding.kind} />
+      <AgentIcon kind={agent.kind} />
       <div className="min-w-0 flex-1">
         <div className="flex items-center gap-2">
-          <span className="font-medium text-sm">{tAgent(binding.kind)}</span>
-          {binding.tier === 'translate' ? (
+          <span className="font-medium text-sm">{tAgent(agent.kind)}</span>
+          {agent.tier === 'translate' ? (
             <Badge variant="outline">{t('translateBadge')}</Badge>
           ) : null}
         </div>
         <p className="truncate text-muted-foreground text-xs">{note}</p>
       </div>
-      {modelOptions && binding.bound ? (
+      {defaultModel !== undefined && modelOptions.length > 0 ? (
         <ModelSelect
           options={
-            modelOptions.some((option) => option.id === binding.currentModel) ||
-            binding.currentModel === ''
+            defaultModel === '' || modelOptions.some((option) => option.id === defaultModel)
               ? modelOptions
-              : [...modelOptions, { id: binding.currentModel, label: binding.currentModel }]
+              : [...modelOptions, { id: defaultModel, label: defaultModel }]
           }
-          value={binding.currentModel}
+          value={defaultModel}
           disabled={busy}
-          onChange={(model) => onSetModel(binding.kind, model === '' ? undefined : model)}
+          onChange={(model) => onSetModel(agent.kind, model === '' ? undefined : model)}
         />
       ) : null}
+      <Button
+        aria-label={agent.isDefault ? t('clearDefaultAccount') : t('setDefaultAccount')}
+        aria-pressed={agent.isDefault}
+        disabled={unavailable || !agent.enabled || busy}
+        onClick={() => onSetDefaultAccount(agent.kind, agent.isDefault ? undefined : accountId)}
+        size="icon-sm"
+        title={agent.isDefault ? t('clearDefaultAccount') : t('setDefaultAccount')}
+        type="button"
+        variant="ghost"
+      >
+        <StarIcon className={`size-4 ${agent.isDefault ? 'fill-current' : ''}`} />
+      </Button>
       <Switch
-        checked={binding.bound}
+        checked={agent.enabled}
         disabled={unavailable || busy}
-        onCheckedChange={(checked) => onSetBinding(binding.kind, checked ? accountId : undefined)}
+        onCheckedChange={(checked) => onSetAccountEnabled(agent.kind, checked)}
       />
     </div>
   );

From 00b75fec26721949d94f3e7716f347c45ebe23d6 Mon Sep 17 00:00:00 2001
From: Peron <peron_ap@icloud.com>
Date: Fri, 7 Aug 2026 22:04:52 +0800
Subject: [PATCH 17/17] docs(schema,engine,agent-adapter): record enabled
 accounts vs the agent's fallback

---
 packages/foundation/schema/src/model/account.ts   |  7 ++++---
 packages/host/agent-adapter/AGENTS.md             |  2 +-
 .../engine/src/session/start-options-resolver.ts  | 15 +++++++++------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/packages/foundation/schema/src/model/account.ts b/packages/foundation/schema/src/model/account.ts
index 18eb9eb5..dacc776c 100644
--- a/packages/foundation/schema/src/model/account.ts
+++ b/packages/foundation/schema/src/model/account.ts
@@ -3,9 +3,10 @@ import { AgentKindSchema, TimestampSchema } from './primitives';
 
 /**
  * A model-provider credential in the global account pool (data plane). The daemon persists these
- * in ~/.linkcode/config.json (0600) and injects the agent's bound account (`activeAccountId`) into
- * the adapter at session start. One credential can back several agents — natively when its
- * endpoint speaks the agent's protocol, via conversion otherwise.
+ * in ~/.linkcode/config.json (0600) and injects one into the adapter at session start: whichever
+ * `StartOptions.config.accountId` names, or the agent's `activeAccountId` when nothing does. One
+ * credential can back several agents — natively when its endpoint speaks the agent's protocol, via
+ * conversion otherwise — and several accounts can serve one agent at the same time.
  */
 
 /** What an endpoint speaks on the wire; decides native-routing vs. conversion. */
diff --git a/packages/host/agent-adapter/AGENTS.md b/packages/host/agent-adapter/AGENTS.md
index e46443a4..ef046143 100644
--- a/packages/host/agent-adapter/AGENTS.md
+++ b/packages/host/agent-adapter/AGENTS.md
@@ -113,7 +113,7 @@ Product code must branch on `historyCapabilities` — never assume an op is supp
 levels (Claude `max`) and live-switchable levels share validation and reflection behavior. The
 engine caches the emitted effort and replays it when the newly created session attaches.
 
-- **A live session can change account, but never in place.** Credentials and base URL are injected once at spawn, so the engine implements a cross-account `set-model` (one carrying `accountId`) as a relaunch under the same session id that resumes the transcript — `SessionLifecycleService.switchModel`, refused while a turn runs, without a transcript, or when the agent cannot resume. No adapter sees it: the old one is destroyed and a new one is constructed from fresh `StartOptions`. `onSetModel` therefore only ever handles a switch *within* the session's own account, which is why opencode's cross-provider rejection there remains correct.
+- **Several accounts can serve one agent at once, and a live session can move between them — never in place.** Which accounts an agent *offers* is `providers[kind].enabledAccountIds` (absent = every bindable one); which it *falls back to* when a session names none is `activeAccountId`, used by automation, schedules, and IM threads. Sessions started from a picker carry `config.accountId` and ignore the fallback. Credentials and base URL are injected once at spawn, so the engine implements a cross-account `set-model` (one carrying `accountId`) as a relaunch under the same session id that resumes the transcript — `SessionLifecycleService.switchModel`, refused while a turn runs, without a transcript, or when the agent cannot resume. Each run records the model and account it resolved to, and a relaunch reads them back, so a thread keeps its own pick even after the fallback moves. No adapter sees any of this: the old one is destroyed and a new one is constructed from fresh `StartOptions`. `onSetModel` therefore only ever handles a switch *within* the session's own account, which is why opencode's cross-provider rejection there remains correct.
 - **apiKey injection** (all read `StartOptions.config.apiKey`, five shapes): claude-code → `ANTHROPIC_API_KEY` in spawned env; codex → `CODEX_API_KEY` in the app-server env (the CLI still honors `CODEX_HOME`/config.toml auth); opencode → nested `config.provider[providerID].options.apiKey`; pi → `authStorage.setRuntimeApiKey` + `registerProvider`; grok-build → `XAI_API_KEY` in the headless process env.
   - **The two provider-routed agents need a provider id, and the model string is not a reliable source.** Precedence: model-ref (`providerID/modelID`, which decides routing) → for pi, the resumed session's own last-routed provider (`lastPiModelChange`, direct evidence) → `config.knownProvider` (the endpoint's id in the agent's own catalog, from `@linkcode/providers`) → for pi, its first available provider. Before `knownProvider` existed a bare model id left the credential uninjected entirely; putting it ahead of the resumed provider instead strands a resumed session on a provider that never got the key.
   - **pi's credential injection cannot change a provider's wire, and must not pretend to.** `registerProvider` with no `models` takes `applyProviderConfig`'s override-only branch (verified in the installed `dist/core/model-registry.js`), which rewrites `baseUrl` and leaves each model's `api` untouched. `config.api` is read in exactly two places — the `config.streamSimple` branch and the `config.models` branch — so on a baseUrl-only call it is **silently discarded**, despite `ProviderConfigInput` declaring `api?: Api`. Passing it typechecks and does nothing; an earlier revision of this adapter did exactly that, and mocked-`registerProvider` tests asserted the call shape and never noticed. This is why injection is only correct when the target provider's *built-in* wire already matches the endpoint — which is the case that matters, since pi ships correct metadata for every provider it knows. Aiming a provider at a differently-shaped endpoint needs a `models`-carrying call (`@linkcode/providers` AGENTS.md records why that is not built).
diff --git a/packages/host/engine/src/session/start-options-resolver.ts b/packages/host/engine/src/session/start-options-resolver.ts
index 324afb79..1457a2a4 100644
--- a/packages/host/engine/src/session/start-options-resolver.ts
+++ b/packages/host/engine/src/session/start-options-resolver.ts
@@ -3,7 +3,7 @@ import { Effect } from 'effect';
 import { isObjectEmpty } from 'foxts/is-object-empty';
 import type { CustomMcpServerService } from '../agent/custom-mcp-service';
 import type { ProviderConfigStore } from '../agent/provider-config';
-import { applyProviderDefaults } from '../agent/provider-config';
+import { applyProviderDefaults, resolvedAccountId } from '../agent/provider-config';
 import type { TranslatorService } from '../agent/translator';
 import { translationUpstream, withTranslatorEndpoint } from '../agent/translator';
 import { OperationError, RequestError } from '../failure';
@@ -34,7 +34,10 @@ export class SessionStartOptionsResolver {
   ): Effect.Effect<ResolvedStartOptions, RequestError | OperationError> {
     const providers = this.providers.get();
     const defaults = applyProviderDefaults(options, providers, this.providers.getAccounts());
-    const accountBound = providers[options.kind]?.activeAccountId !== undefined;
+    // Whether an account actually resolved — the caller's pin or, failing that, the agent's
+    // configured default. Asking that rather than "is a default set" also covers a pinned session
+    // on an agent with no default at all.
+    const accountResolved = resolvedAccountId(defaults.options) !== undefined;
     const { translator } = this;
     const withCustomMcpServers = this.withCustomMcpServers.bind(this);
     const withSimulatorMcp = this.withSimulatorMcp.bind(this);
@@ -45,13 +48,13 @@ export class SessionStartOptionsResolver {
         return yield* Effect.fail(
           new RequestError({
             code: 'unsupported',
-            message: `The bound account cannot back ${options.kind} (${defaults.unavailable})`,
+            message: `The account cannot back ${options.kind} (${defaults.unavailable})`,
           }),
         );
       }
-      if (accountBound && defaults.options.model === undefined) {
-        // With an account bound, its selected set is the only model source and nothing falls back to
-        // the agent's own choice. Unbound agents keep running on whatever they resolve themselves.
+      if (accountResolved && defaults.options.model === undefined) {
+        // With an account in play, its selected set is the only model source and nothing falls back
+        // to the agent's own choice. Agents with no account keep resolving their own.
         return yield* Effect.fail(
           new RequestError({
             code: 'unsupported',