diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index cd1efaa02..874a794bb 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -164,6 +164,7 @@ dependency guardrails.
 | `foundation/schema` | zod schemas — the single data contract. Every cross-process / cross-end / post-abstraction message type derives from here (`z.infer`). |
 | `foundation/transport` | Communication layer ("how messages travel"): local / ws / Socket.IO implementations, the `Hub` fan-out, and the versioned wire protocol. |
 | `foundation/common` | Shared framework-agnostic utilities that do not belong to the data contract or a product layer (for example Zustand persistence helpers). |
+| `foundation/providers` | The model-provider service directory plus `resolveBinding`, which picks the endpoint variant a given agent speaks. Shared by the daemon (session start) and the client (binding availability), so neither keeps its own copy. |
 | `host/agent-adapter` | One adapter per agent (`claude-code` / `codex` / `opencode` / `pi` / `grok-build`) plus the abstraction layer that normalizes native events into `schema`. |
 | `host/assets` | Managed-asset store for verified agent CLI pairs, in-process package closures, and standalone toolchains. |
 | `host/engine` | The host engine: session lifecycle and agent orchestration, driving `agent-adapter`. |
diff --git a/packages/client/workbench/package.json b/packages/client/workbench/package.json
index f9a2b3f66..25ef39bbc 100644
--- a/packages/client/workbench/package.json
+++ b/packages/client/workbench/package.json
@@ -18,6 +18,7 @@
     "@linkcode/client-core": "workspace:*",
     "@linkcode/common": "workspace:*",
     "@linkcode/i18n": "workspace:*",
+    "@linkcode/providers": "workspace:*",
     "@linkcode/schema": "workspace:*",
     "@linkcode/sdk": "workspace:*",
     "@linkcode/transport": "workspace:*",
diff --git a/packages/client/workbench/src/settings/agents-settings.tsx b/packages/client/workbench/src/settings/agents-settings.tsx
index fa2ffe943..a5c1ec21d 100644
--- a/packages/client/workbench/src/settings/agents-settings.tsx
+++ b/packages/client/workbench/src/settings/agents-settings.tsx
@@ -1,3 +1,4 @@
+import { resolveBinding } from '@linkcode/providers';
 import type { AgentKind, AgentRuntimeAvailability } from '@linkcode/schema';
 import { getAccounts, getProviderConfig, setProviderConfig } from '@linkcode/sdk';
 import { AgentIcon, AgentOnboardingCard, SettingsCard } from '@linkcode/ui';
@@ -8,7 +9,6 @@ import { useTranslations } from 'use-intl';
 import { useAgentRuntimes } from '../agent-runtime/hooks';
 import { useAgentRuntimeOnboarding } from '../agent-runtime/onboarding';
 import { useData, useMutation } from '../runtime/tayori';
-import { bindingAvailability } from './providers/capability';
 import { AGENT_KINDS, withEnabled } from './providers/view';
 import { SimulatorAgentAccessCard } from './simulator-access';
 
@@ -50,8 +50,7 @@ export function AgentsSettingsPanel({
           // A disabled agent's runtime gaps don't matter — no card, just the badge.
           const cue = enabled ? onboarding.cues[kind] : undefined;
           const translated =
-            boundAccount !== undefined &&
-            bindingAvailability(boundAccount, kind).tier === 'translate';
+            boundAccount !== undefined && resolveBinding(boundAccount, kind).tier === 'translate';
           // With no bound account the agent follows the CLI login — show who that is when probed.
           const cliIdentity =
             boundAccount === undefined && runtime?.auth?.loggedIn === true
diff --git a/packages/client/workbench/src/settings/providers/__tests__/add-flow.test.tsx b/packages/client/workbench/src/settings/providers/__tests__/add-flow.test.tsx
index 8d0fef32c..ddf981038 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/add-flow.test.tsx
+++ b/packages/client/workbench/src/settings/providers/__tests__/add-flow.test.tsx
@@ -164,4 +164,55 @@ describe('non-subscription account creation', () => {
       ),
     );
   });
+
+  it('asks nothing about protocol for a service serving several shapes', () => {
+    render(
+      <AddAccountForm
+        serviceId="openrouter"
+        runtimes={undefined}
+        onboarding={onboarding()}
+        busy={false}
+        onBack={vi.fn()}
+        onSubmit={vi.fn()}
+      />,
+    );
+
+    // Each agent resolves its own shape, so the user is never asked to pick one.
+    expect(screen.queryAllByRole('radio')).toHaveLength(0);
+  });
+
+  it('stores template values instead of a resolved endpoint', async () => {
+    const onSubmit = vi.fn();
+    const { container } = render(
+      <AddAccountForm
+        serviceId="cloudflare-gateway"
+        runtimes={undefined}
+        onboarding={onboarding()}
+        busy={false}
+        onBack={vi.fn()}
+        onSubmit={onSubmit}
+      />,
+    );
+
+    fireEvent.change(screen.getByRole('textbox', { name: 'Account ID' }), {
+      target: { value: '8f3a' },
+    });
+    fireEvent.change(screen.getByRole('textbox', { name: 'Gateway ID' }), {
+      target: { value: 'prod' },
+    });
+    const secret = container.querySelector('input[type="password"]');
+    if (!secret) throw new Error('credential input missing');
+    fireEvent.change(secret, { target: { value: 'cf-token' } });
+    fireEvent.click(screen.getByRole('button', { name: 'form.submit' }));
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalled());
+    const account = onSubmit.mock.calls[0]?.[0];
+    expect(account).toMatchObject({
+      service: 'cloudflare-gateway',
+      credential: { type: 'auth-token', token: 'cf-token' },
+      endpointParams: { account_id: '8f3a', gateway_id: 'prod' },
+    });
+    // One key can resolve to a different endpoint per agent, so none is pinned here.
+    expect(account).not.toHaveProperty('endpoint');
+  });
 });
diff --git a/packages/client/workbench/src/settings/providers/__tests__/capability.test.ts b/packages/client/workbench/src/settings/providers/__tests__/capability.test.ts
deleted file mode 100644
index e3a83195d..000000000
--- a/packages/client/workbench/src/settings/providers/__tests__/capability.test.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import type { Account, AgentRuntimes } from '@linkcode/schema';
-import { describe, expect, it } from 'vitest';
-import { bindingAvailability } from '../capability';
-import {
-  accountProtocol,
-  detectedLoginSuggestions,
-  fillTemplate,
-  serviceById,
-  templatePlaceholders,
-} from '../catalog';
-
-function account(overrides: Partial<Account>): Account {
-  return {
-    id: 'acc_test',
-    label: 'Test',
-    credential: { type: 'api-key', key: 'sk-test' },
-    createdAt: 0,
-    ...overrides,
-  };
-}
-
-describe('bindingAvailability', () => {
-  it('locks an oauth account to its own agent', () => {
-    const sub = account({ credential: { type: 'oauth', agent: 'claude-code' } });
-    expect(bindingAvailability(sub, 'claude-code')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(sub, 'codex')).toEqual({
-      tier: 'unavailable',
-      reason: 'oauth-other-agent',
-    });
-  });
-
-  it('routes anthropic endpoints natively to claude-code only', () => {
-    const anthropic = account({
-      endpoint: { baseUrl: 'https://api.anthropic.com', protocol: 'anthropic' },
-    });
-    expect(bindingAvailability(anthropic, 'claude-code')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(anthropic, 'codex')).toEqual({
-      tier: 'unavailable',
-      reason: 'protocol-unsupported',
-    });
-    expect(bindingAvailability(anthropic, 'opencode')).toEqual({
-      tier: 'unavailable',
-      reason: 'protocol-unsupported',
-    });
-  });
-
-  it('translates openai-chat endpoints for claude-code, native elsewhere', () => {
-    const gateway = account({
-      credential: { type: 'auth-token', token: 'sk-or-v1-x' },
-      endpoint: { baseUrl: 'https://openrouter.ai/api/v1', protocol: 'openai-chat' },
-    });
-    expect(bindingAvailability(gateway, 'claude-code')).toEqual({ tier: 'translate' });
-    expect(bindingAvailability(gateway, 'codex')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(gateway, 'opencode')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(gateway, 'pi')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(gateway, 'grok-build')).toEqual({
-      tier: 'unavailable',
-      reason: 'protocol-unsupported',
-    });
-  });
-
-  it('binds Grok Build to xAI catalog accounts', () => {
-    expect(bindingAvailability(account({ service: 'xai' }), 'grok-build')).toEqual({
-      tier: 'native',
-    });
-    expect(bindingAvailability(account({ service: 'openai-api' }), 'grok-build')).toEqual({
-      tier: 'unavailable',
-      reason: 'protocol-unsupported',
-    });
-  });
-
-  it('needs an endpoint URL before offering translation', () => {
-    // A bare openai-chat key (service-implied protocol, no endpoint) cannot be translated — the
-    // sidecar forwards to the account's base URL.
-    const bareKey = account({ service: 'openai-api' });
-    expect(bindingAvailability(bareKey, 'claude-code')).toEqual({
-      tier: 'unavailable',
-      reason: 'translation-needs-endpoint',
-    });
-    expect(bindingAvailability(bareKey, 'codex')).toEqual({ tier: 'native' });
-  });
-
-  it('keeps protocol-unknown legacy accounts bindable everywhere', () => {
-    const legacy = account({});
-    for (const kind of ['claude-code', 'codex', 'opencode', 'pi', 'grok-build'] as const) {
-      expect(bindingAvailability(legacy, kind)).toEqual({ tier: 'native' });
-    }
-  });
-
-  it('rejects openai-responses endpoints everywhere but codex', () => {
-    const responses = account({
-      endpoint: { baseUrl: 'https://example.com/v1', protocol: 'openai-responses' },
-    });
-    expect(bindingAvailability(responses, 'codex')).toEqual({ tier: 'native' });
-    expect(bindingAvailability(responses, 'claude-code')).toEqual({
-      tier: 'unavailable',
-      reason: 'protocol-unsupported',
-    });
-  });
-});
-
-describe('catalog helpers', () => {
-  it('extracts and fills endpoint template placeholders', () => {
-    const cloudflare = serviceById('cloudflare-gateway');
-    if (cloudflare?.kind !== 'endpoint') throw new Error('cloudflare descriptor missing');
-    const template = cloudflare.variants.find((variant) => variant.id === 'anthropic')!.baseUrl;
-    expect(templatePlaceholders(template)).toEqual(['account_id', 'gateway_id']);
-    expect(fillTemplate(template, { account_id: '8f3a', gateway_id: 'prod' })).toBe(
-      'https://gateway.ai.cloudflare.com/v1/8f3a/prod/anthropic',
-    );
-  });
-
-  it('suggests detected CLI logins the pool does not represent yet', () => {
-    const runtimes: AgentRuntimes = {
-      'claude-code': {
-        status: 'available',
-        auth: { loggedIn: true, method: 'claude.ai', subscriptionType: 'max', email: 'x@y.z' },
-      },
-      codex: { status: 'available', auth: { loggedIn: false } },
-    };
-    const suggested = detectedLoginSuggestions([], runtimes);
-    expect(suggested.map(({ service, auth }) => [service.id, auth.email])).toEqual([
-      ['claude-sub', 'x@y.z'],
-    ]);
-    // An existing oauth account for the agent absorbs the suggestion; unprobed runtimes yield none.
-    const claudeSub = account({ credential: { type: 'oauth', agent: 'claude-code' } });
-    expect(detectedLoginSuggestions([claudeSub], runtimes)).toEqual([]);
-    expect(detectedLoginSuggestions([], undefined)).toEqual([]);
-  });
-
-  it('implies a protocol from the service when the endpoint is absent', () => {
-    expect(accountProtocol(account({ service: 'anthropic-api' }))).toBe('anthropic');
-    expect(accountProtocol(account({ service: 'xai' }))).toBe('openai-chat');
-    // Dual-protocol gateways imply nothing without an endpoint.
-    expect(accountProtocol(account({ service: 'openrouter' }))).toBeUndefined();
-    expect(accountProtocol(account({}))).toBeUndefined();
-    // An explicit endpoint always wins.
-    expect(
-      accountProtocol(
-        account({
-          service: 'openrouter',
-          endpoint: { baseUrl: 'https://openrouter.ai/api', protocol: 'anthropic' },
-        }),
-      ),
-    ).toBe('anthropic');
-  });
-});
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 79c7dc226..058ccb532 100644
--- a/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
+++ b/packages/client/workbench/src/settings/providers/__tests__/view.test.ts
@@ -85,6 +85,14 @@ describe('view helpers', () => {
         service: 'claude-sub',
         credential: { type: 'oauth', agent: 'claude-code' },
       },
+      {
+        id: 'acc_c',
+        label: 'Proxy',
+        createdAt: 3,
+        service: 'openrouter',
+        endpoint: { baseUrl: 'https://proxy.internal/v1', protocol: 'openai-chat' },
+        credential: { type: 'auth-token', token: 'tok' },
+      },
     ];
     const runtimes: AgentRuntimes = {
       'claude-code': {
@@ -103,8 +111,9 @@ describe('view helpers', () => {
           label: 'Primary API',
           service: 'openai-api',
           serviceLabel: 'OpenAI API',
-          endpoint: 'https://api.openai.com/v1',
-          protocol: 'openai-chat',
+          // The stored endpoint is the catalog's own, so the row describes the service's shapes —
+          // the same answer the resolver gives, rather than a pin it will ignore.
+          routing: { kind: 'catalog', protocols: ['openai-chat', 'openai-responses'] },
           credentialType: 'api-key',
           boundAgents: ['claude-code'],
         },
@@ -117,6 +126,21 @@ describe('view helpers', () => {
           auth: { loggedIn: true, email: 'claude@example.com' },
           boundAgents: ['codex'],
         },
+        {
+          id: 'acc_c',
+          label: 'Proxy',
+          service: 'openrouter',
+          serviceLabel: 'OpenRouter',
+          // A URL the catalog never produces is the user's own, so it stays pinned and the row
+          // reports that one endpoint rather than the service's shapes.
+          routing: {
+            kind: 'pinned',
+            baseUrl: 'https://proxy.internal/v1',
+            protocol: 'openai-chat',
+          },
+          credentialType: 'auth-token',
+          boundAgents: [],
+        },
       ],
       detectedLogins: [{ service: 'chatgpt-sub', label: 'ChatGPT', email: 'codex@example.com' }],
       bindingCount: 2,
diff --git a/packages/client/workbench/src/settings/providers/add-flow.tsx b/packages/client/workbench/src/settings/providers/add-flow.tsx
index 203cf9270..88f918609 100644
--- a/packages/client/workbench/src/settings/providers/add-flow.tsx
+++ b/packages/client/workbench/src/settings/providers/add-flow.tsx
@@ -1,10 +1,17 @@
 import { zodResolver } from '@hookform/resolvers/zod';
+import type { EndpointService, ServiceDescriptor, ServiceGroup } from '@linkcode/providers';
+import {
+  pinnedEndpoint,
+  SERVICE_CATALOG,
+  serviceById,
+  serviceProtocols,
+  templatePlaceholders,
+} from '@linkcode/providers';
 import type { Account, AccountProtocol, AgentRuntimes } from '@linkcode/schema';
 import { AgentOnboardingCard, ServiceIcon } from '@linkcode/ui';
 import { Button } from 'coss-ui/components/button';
 import { Field, FieldLabel } from 'coss-ui/components/field';
 import { Input } from 'coss-ui/components/input';
-import { RadioGroup, RadioGroupItem } from 'coss-ui/components/radio-group';
 import {
   Select,
   SelectItem,
@@ -12,15 +19,14 @@ import {
   SelectTrigger,
   SelectValue,
 } from 'coss-ui/components/select';
+import { isObjectEmpty } from 'foxts/is-object-empty';
 import { ChevronLeftIcon } from 'lucide-react';
 import { useState } from 'react';
 import type { Control, FieldValues, Path } from 'react-hook-form';
-import { Controller, useForm, useWatch } from 'react-hook-form';
+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 { ServiceDescriptor, ServiceGroup, ServiceVariant } from './catalog';
-import { fillTemplate, SERVICE_CATALOG, serviceById, templatePlaceholders } from './catalog';
 
 const GROUPS: ServiceGroup[] = ['subscription', 'direct', 'gateway', 'custom'];
 
@@ -45,13 +51,11 @@ export function oauthAccount(
   };
 }
 
-function catalogAccount(
-  service: Extract<ServiceDescriptor, { kind: 'endpoint' }>,
-  variant: ServiceVariant,
-  draft: CatalogDraft,
-): Account {
+/** The account holds only the secret, the service key and any template values — each agent resolves
+ * its own endpoint from those, so no protocol is chosen here. */
+function catalogAccount(service: EndpointService, draft: CatalogDraft): Account {
   const trimmed: Record<string, string> = {};
-  for (const key of templatePlaceholders(variant.baseUrl)) {
+  for (const key of servicePlaceholders(service)) {
     const value = Object.hasOwn(draft.placeholders, key) ? draft.placeholders[key] : '';
     trimmed[key] = value.trim();
   }
@@ -59,14 +63,23 @@ function catalogAccount(
     ...newAccountBase(draft.label),
     service: service.id,
     credential:
-      variant.credentialType === 'auth-token'
+      service.credentialType === 'auth-token'
         ? { type: 'auth-token', token: draft.secret }
         : { type: 'api-key', key: draft.secret },
-    endpoint: { baseUrl: fillTemplate(variant.baseUrl, trimmed), protocol: variant.protocol },
+    ...(!isObjectEmpty(trimmed) && { endpointParams: trimmed }),
     ...(draft.model.trim() && { model: draft.model.trim() }),
   };
 }
 
+/** Placeholders across every variant: one secret covers them all, so the form asks once. */
+function servicePlaceholders(service: EndpointService): string[] {
+  const keys = new Set<string>();
+  for (const variant of Object.values(service.variants)) {
+    for (const key of templatePlaceholders(variant.baseUrl)) keys.add(key);
+  }
+  return [...keys];
+}
+
 function customAccount(draft: CustomDraft): Account {
   return accountFromCustomDraft(draft);
 }
@@ -348,9 +361,9 @@ const CatalogDraftSchema = z.object({
 });
 type CatalogDraft = z.infer<typeof CatalogDraftSchema>;
 
-function catalogDraftSchema(variant: ServiceVariant): typeof CatalogDraftSchema {
+function catalogDraftSchema(service: EndpointService): typeof CatalogDraftSchema {
   return CatalogDraftSchema.superRefine((draft, ctx) => {
-    for (const key of templatePlaceholders(variant.baseUrl)) {
+    for (const key of servicePlaceholders(service)) {
       const value = Object.hasOwn(draft.placeholders, key) ? draft.placeholders[key] : '';
       if (!value.trim()) {
         ctx.addIssue({ code: 'custom', path: ['placeholders', key], message: 'required' });
@@ -371,72 +384,37 @@ function CatalogAccountForm({
   busy,
   onSubmit,
 }: {
-  service: Extract<ServiceDescriptor, { kind: 'endpoint' }>;
+  service: EndpointService;
   busy: boolean;
   onSubmit: (account: Account) => void;
 }): React.ReactNode {
   const t = useTranslations('settings.providers');
   const serviceName = t(`serviceName.${service.id}`);
-  // The variant determines the form's shape (placeholders, secret kind); it is UI state, not a field.
-  const [variant, setVariant] = useState(service.variants[0]);
-  const placeholders = templatePlaceholders(variant.baseUrl);
+  const placeholders = servicePlaceholders(service);
 
   const {
     register,
-    control,
     handleSubmit,
     formState: { isSubmitting },
   } = useForm<CatalogDraft>({
-    resolver: zodResolver(catalogDraftSchema(variant)),
+    resolver: zodResolver(catalogDraftSchema(service)),
     defaultValues: { label: serviceName, secret: '', model: '', placeholders: {} },
   });
-  // Display-only subscription for the endpoint preview; fields are wired via register/Controller.
-  const placeholderValues = useWatch({ control, name: 'placeholders' });
 
   const secretLabel =
-    variant.credentialType === 'auth-token' ? t('credentialAuthToken') : t('credentialApiKey');
+    service.credentialType === 'auth-token' ? t('credentialAuthToken') : t('credentialApiKey');
 
   return (
     <form
       className="flex flex-col gap-3"
-      onSubmit={handleSubmit((draft) => onSubmit(catalogAccount(service, variant, draft)))}
+      onSubmit={handleSubmit((draft) => onSubmit(catalogAccount(service, draft)))}
     >
       <Field>
         <FieldLabel>{t('form.label')}</FieldLabel>
         <Input className="w-full" autoComplete="off" {...register('label')} />
       </Field>
-      {service.variants.length > 1 ? (
-        <Field>
-          <FieldLabel>{t('form.variant')}</FieldLabel>
-          <RadioGroup
-            className="gap-2"
-            value={variant.id}
-            onValueChange={(value) => {
-              const next = service.variants.find((candidate) => candidate.id === value);
-              if (next) setVariant(next);
-            }}
-          >
-            {service.variants.map((candidate) => (
-              <label
-                key={candidate.id}
-                className="flex cursor-pointer items-start gap-2.5 rounded-lg border border-border p-3"
-              >
-                <RadioGroupItem value={candidate.id} className="mt-0.5" />
-                <span className="min-w-0">
-                  <span className="block font-medium text-sm">
-                    {t(`variantName.${candidate.protocol}`)}
-                  </span>
-                  <span className="block text-muted-foreground text-xs">
-                    {t(`variantNote.${candidate.protocol}`)}
-                  </span>
-                </span>
-              </label>
-            ))}
-          </RadioGroup>
-        </Field>
-      ) : null}
       {placeholders.map((key) => (
-        <Field key={`${variant.id}:${key}`}>
+        <Field key={key}>
           <FieldLabel>{placeholderLabel(key)}</FieldLabel>
           <Input className="w-full" autoComplete="off" {...register(`placeholders.${key}`)} />
         </Field>
@@ -462,7 +440,7 @@ function CatalogAccountForm({
         </div>
       </div>
       <p className="mt-1 truncate font-mono text-muted-foreground text-xs">
-        {fillTemplate(variant.baseUrl, placeholderValues)} · {variant.protocol}
+        {serviceProtocols(service.id).join(' · ')}
       </p>
       <div className="flex justify-end pt-1">
         <Button type="submit" size="sm" disabled={busy || isSubmitting}>
@@ -513,8 +491,10 @@ function CustomAccountForm({
           : account?.credential.type === 'api-key'
             ? account.credential.key
             : '',
-      baseUrl: account?.endpoint?.baseUrl ?? '',
-      protocol: account?.endpoint?.protocol ?? '',
+      // Prefill only an endpoint that is actually honored: a catalog-derived one is ignored at
+      // 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 ?? '',
     },
   });
diff --git a/packages/client/workbench/src/settings/providers/capability.ts b/packages/client/workbench/src/settings/providers/capability.ts
deleted file mode 100644
index 6e571c925..000000000
--- a/packages/client/workbench/src/settings/providers/capability.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type { Account, AccountProtocol, AgentKind } from '@linkcode/schema';
-import { accountProtocol } from './catalog';
-
-/**
- * Which accounts each agent can bind, derived from the adapters' real injection seams — the UI
- * hardcodes nothing. Facts as of 2026-07 (packages/host/agent-adapter `credential.ts` + native
- * adapters, packages/host/engine `translator.ts`):
- * - claude-code speaks Anthropic natively (`ANTHROPIC_*` env); an `openai-chat` endpoint is
- *   reachable through the local aigateway translator, which needs a base URL AND a key.
- * - codex reaches any OpenAI-shaped endpoint via `OPENAI_BASE_URL` + `CODEX_API_KEY`.
- * - opencode and pi: openai-chat is the verified path; an Anthropic endpoint plausibly works but
- *   is unverified against the SDK — flip it here once verified live.
- * - grok-build only consumes an xAI key as `XAI_API_KEY`; it ignores custom endpoint base URLs.
- */
-const AGENT_NATIVE_PROTOCOLS: Record<AgentKind, AccountProtocol[]> = {
-  'claude-code': ['anthropic'],
-  codex: ['openai-chat', 'openai-responses'],
-  opencode: ['openai-chat'],
-  pi: ['openai-chat'],
-  'grok-build': [],
-};
-
-/** Cross-protocol pairs the local translation sidecar serves (engine `translationUpstream`). */
-const TRANSLATABLE: ReadonlyArray<{ agent: AgentKind; upstream: AccountProtocol }> = [
-  { agent: 'claude-code', upstream: 'openai-chat' },
-];
-
-export type BindingTier = 'native' | 'translate' | 'unavailable';
-
-export type BindingUnavailableReason =
-  | 'oauth-other-agent'
-  | 'protocol-unsupported'
-  | 'translation-needs-endpoint';
-
-export type BindingAvailability =
-  | { tier: 'native' | 'translate' }
-  | { tier: 'unavailable'; reason: BindingUnavailableReason };
-
-/** Whether (and how) this account can back sessions of the given agent. */
-export function bindingAvailability(account: Account, kind: AgentKind): BindingAvailability {
-  if (account.credential.type === 'oauth') {
-    // An OAuth account is one CLI's login; it cannot back another agent.
-    return account.credential.agent === kind
-      ? { tier: 'native' }
-      : { tier: 'unavailable', reason: 'oauth-other-agent' };
-  }
-  const protocol = accountProtocol(account);
-  if (kind === 'grok-build') {
-    // The headless CLI has no base-URL flag: only the xAI catalog entry is known to target its
-    // endpoint. Preserve pre-catalog bare keys, whose vendor was never recorded.
-    return account.service === 'xai' || (protocol === undefined && account.service === undefined)
-      ? { tier: 'native' }
-      : { tier: 'unavailable', reason: 'protocol-unsupported' };
-  }
-  // Unknown protocol (pre-catalog custom account without endpoint): keep it bindable everywhere,
-  // matching the pre-catalog behavior — the user knows which vendor the bare key belongs to.
-  if (protocol === undefined) return { tier: 'native' };
-  if (AGENT_NATIVE_PROTOCOLS[kind].includes(protocol)) return { tier: 'native' };
-  if (TRANSLATABLE.some((pair) => pair.agent === kind && pair.upstream === protocol)) {
-    // The translator forwards to `baseUrl` with the account's key — both are required.
-    return account.endpoint?.baseUrl
-      ? { tier: 'translate' }
-      : { tier: 'unavailable', reason: 'translation-needs-endpoint' };
-  }
-  return { tier: 'unavailable', reason: 'protocol-unsupported' };
-}
diff --git a/packages/client/workbench/src/settings/providers/catalog.ts b/packages/client/workbench/src/settings/providers/catalog.ts
deleted file mode 100644
index 5fbfc98b7..000000000
--- a/packages/client/workbench/src/settings/providers/catalog.ts
+++ /dev/null
@@ -1,214 +0,0 @@
-import type {
-  Account,
-  AccountProtocol,
-  Accounts,
-  AgentAuthStatus,
-  AgentKind,
-  AgentRuntimes,
-} from '@linkcode/schema';
-
-/**
- * The service directory behind the add-account flow, as pure data (no hooks); selecting an entry
- * seeds the form so the user only pastes a secret. Endpoint facts verified against vendor docs
- * (2026-07); a `{placeholder}` in a URL becomes a dedicated form field. The entry's `id` is
- * persisted as `Account.service`.
- */
-
-/** Grouping in the add-account catalog grid. */
-export type ServiceGroup = 'subscription' | 'direct' | 'gateway' | 'custom';
-
-/** One endpoint shape a service offers; dual-shape gateways expose one variant per protocol. */
-export interface ServiceVariant {
-  id: 'openai' | 'anthropic' | 'default';
-  protocol: AccountProtocol;
-  /** Endpoint URL, possibly templated with `{placeholder}` segments. */
-  baseUrl: string;
-  /** How the endpoint authenticates: bearer token (`auth-token`) or `x-api-key` (`api-key`). */
-  credentialType: 'api-key' | 'auth-token';
-}
-
-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 }
-  /** Key/token against a baked endpoint (direct vendor API or gateway). */
-  | {
-      id: string;
-      label: string;
-      group: ServiceGroup;
-      kind: 'endpoint';
-      variants: ServiceVariant[];
-      secretPlaceholder?: string;
-    }
-  /** Free-form endpoint — the full account form. */
-  | { id: 'custom'; label: string; group: 'custom'; kind: 'custom' };
-
-export const SERVICE_CATALOG: ServiceDescriptor[] = [
-  { id: 'claude-sub', label: 'Claude', group: 'subscription', kind: 'oauth', agent: 'claude-code' },
-  { id: 'chatgpt-sub', label: 'ChatGPT', group: 'subscription', kind: 'oauth', agent: 'codex' },
-  {
-    id: 'anthropic-api',
-    label: 'Anthropic API',
-    group: 'direct',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'default',
-        protocol: 'anthropic',
-        baseUrl: 'https://api.anthropic.com',
-        credentialType: 'api-key',
-      },
-    ],
-    secretPlaceholder: 'sk-ant-…',
-  },
-  {
-    id: 'openai-api',
-    label: 'OpenAI API',
-    group: 'direct',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'default',
-        protocol: 'openai-chat',
-        baseUrl: 'https://api.openai.com/v1',
-        credentialType: 'api-key',
-      },
-    ],
-    secretPlaceholder: 'sk-…',
-  },
-  {
-    id: 'xai',
-    label: 'xAI (Grok)',
-    group: 'direct',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'default',
-        protocol: 'openai-chat',
-        baseUrl: 'https://api.x.ai/v1',
-        credentialType: 'api-key',
-      },
-    ],
-    secretPlaceholder: 'xai-…',
-  },
-  {
-    id: 'openrouter',
-    label: 'OpenRouter',
-    group: 'gateway',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'openai',
-        protocol: 'openai-chat',
-        baseUrl: 'https://openrouter.ai/api/v1',
-        credentialType: 'auth-token',
-      },
-      {
-        // The "Anthropic skin" is guaranteed only for Claude models.
-        id: 'anthropic',
-        protocol: 'anthropic',
-        baseUrl: 'https://openrouter.ai/api',
-        credentialType: 'auth-token',
-      },
-    ],
-    secretPlaceholder: 'sk-or-v1-…',
-  },
-  {
-    id: 'vercel-gateway',
-    label: 'Vercel AI Gateway',
-    group: 'gateway',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'openai',
-        protocol: 'openai-chat',
-        baseUrl: 'https://ai-gateway.vercel.sh/v1',
-        credentialType: 'auth-token',
-      },
-      {
-        // Anthropic-shaped endpoint; translates server-side, so it also serves non-Anthropic models.
-        id: 'anthropic',
-        protocol: 'anthropic',
-        baseUrl: 'https://ai-gateway.vercel.sh',
-        credentialType: 'auth-token',
-      },
-    ],
-  },
-  {
-    id: 'cloudflare-gateway',
-    label: 'Cloudflare AI Gateway',
-    group: 'gateway',
-    kind: 'endpoint',
-    variants: [
-      {
-        id: 'openai',
-        protocol: 'openai-chat',
-        baseUrl: 'https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/compat',
-        credentialType: 'auth-token',
-      },
-      {
-        // Pass-through: needs a real Anthropic key.
-        id: 'anthropic',
-        protocol: 'anthropic',
-        baseUrl: 'https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/anthropic',
-        credentialType: 'api-key',
-      },
-    ],
-  },
-  { id: 'custom', label: 'Custom', group: 'custom', kind: 'custom' },
-];
-
-export function serviceById(id: string | undefined): ServiceDescriptor | undefined {
-  return id === undefined ? undefined : SERVICE_CATALOG.find((service) => service.id === id);
-}
-
-const PLACEHOLDER_PATTERN = /\{([a-z_]+)\}/g;
-
-/** Account-specific `{placeholder}` fields a templated endpoint URL needs filled. */
-export function templatePlaceholders(baseUrl: string): string[] {
-  return [...baseUrl.matchAll(PLACEHOLDER_PATTERN)].map((match) => match[1]);
-}
-
-export function fillTemplate(baseUrl: string, values: Record<string, string>): string {
-  return baseUrl.replaceAll(PLACEHOLDER_PATTERN, (whole, key: string) => values[key] ?? whole);
-}
-
-export interface DetectedLoginSuggestion {
-  service: Extract<ServiceDescriptor, { kind: 'oauth' }>;
-  auth: AgentAuthStatus;
-}
-
-/**
- * CLI logins the runtime probe sees that the pool does not represent yet, offered as one-click
- * "detected" cards: `loggedIn: true` with no oauth account for that agent. The pool stays
- * explicit user state — this is a suggestion, not an implicit member.
- */
-export function detectedLoginSuggestions(
-  accounts: Accounts,
-  runtimes: AgentRuntimes | undefined,
-): DetectedLoginSuggestion[] {
-  const suggestions: DetectedLoginSuggestion[] = [];
-  for (const service of SERVICE_CATALOG) {
-    if (service.kind !== 'oauth') continue;
-    const auth = runtimes?.[service.agent]?.auth;
-    if (auth?.loggedIn !== true) continue;
-    const represented = accounts.some(
-      (account) =>
-        account.credential.type === 'oauth' && account.credential.agent === service.agent,
-    );
-    if (!represented) suggestions.push({ service, auth });
-  }
-  return suggestions;
-}
-
-/**
- * The protocol an account's requests speak: the explicit endpoint protocol, or the one its
- * service implies. Undefined for pre-catalog custom accounts with no endpoint — compatibility is
- * unknown, so the UI keeps them bindable everywhere.
- */
-export function accountProtocol(account: Account): AccountProtocol | undefined {
-  if (account.endpoint) return account.endpoint.protocol;
-  const service = serviceById(account.service);
-  if (service?.kind !== 'endpoint') return undefined;
-  const protocols = new Set(service.variants.map((variant) => variant.protocol));
-  return protocols.size === 1 ? service.variants[0].protocol : undefined;
-}
diff --git a/packages/client/workbench/src/settings/providers/providers-settings.tsx b/packages/client/workbench/src/settings/providers/providers-settings.tsx
index be5df091a..98955b5b3 100644
--- a/packages/client/workbench/src/settings/providers/providers-settings.tsx
+++ b/packages/client/workbench/src/settings/providers/providers-settings.tsx
@@ -1,3 +1,4 @@
+import { serviceById } from '@linkcode/providers';
 import type { Account, AgentKind, ProvidersConfig } from '@linkcode/schema';
 import {
   createAndBindAccount,
@@ -20,7 +21,6 @@ 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 { serviceById } from './catalog';
 import { useProvidersSettingsStore } from './store';
 import {
   providerAccountDetailViewModel,
diff --git a/packages/client/workbench/src/settings/providers/view.ts b/packages/client/workbench/src/settings/providers/view.ts
index 935636695..3467dce94 100644
--- a/packages/client/workbench/src/settings/providers/view.ts
+++ b/packages/client/workbench/src/settings/providers/view.ts
@@ -1,3 +1,10 @@
+import {
+  detectedLoginSuggestions,
+  pinnedEndpoint,
+  resolveBinding,
+  serviceById,
+  serviceProtocols,
+} from '@linkcode/providers';
 import type {
   Account,
   Accounts,
@@ -10,12 +17,11 @@ import type {
   ProviderAccountDetailViewModel,
   ProviderAccountListItem,
   ProviderAccountListViewModel,
+  ProviderAccountRouting,
   ProviderBindingStatus,
   ProviderBindingViewModel,
   ProviderCredentialViewModel,
 } from '@linkcode/ui';
-import { bindingAvailability } from './capability';
-import { detectedLoginSuggestions, serviceById } from './catalog';
 
 /** Pure view helpers for the Providers page — no hooks, unit-testable. */
 
@@ -86,7 +92,7 @@ function bindingStatus(
   kind: AgentKind,
   providers: ProvidersConfig | undefined,
 ): { bound: boolean; status: ProviderBindingStatus; tier: ProviderBindingViewModel['tier'] } {
-  const availability = bindingAvailability(account, kind);
+  const availability = resolveBinding(account, kind);
   const boundId = providers?.[kind]?.activeAccountId;
   const bound = boundId === account.id;
   if (availability.tier === 'unavailable') {
@@ -102,8 +108,8 @@ function bindingStatus(
       tier: availability.tier,
       status: {
         kind:
-          availability.reason === 'translation-needs-endpoint'
-            ? 'unavailable-translation-endpoint'
+          availability.reason === 'endpoint-incomplete'
+            ? 'unavailable-endpoint-incomplete'
             : 'unavailable-protocol',
       },
     };
@@ -137,6 +143,7 @@ export function providerAccountDetailViewModel(
   });
   const boundAgents = boundAgentKinds(providers, account.id);
   const serviceLabel = serviceById(account.service)?.label;
+  const routing = accountRouting(account);
   return {
     id: account.id,
     label: account.label,
@@ -146,7 +153,7 @@ export function providerAccountDetailViewModel(
     availableBindingCount: bindings.filter((binding) => binding.tier !== 'unavailable').length,
     ...(!(account.service === undefined) && { service: account.service }),
     ...(!(serviceLabel === undefined) && { serviceLabel }),
-    ...(!(account.endpoint === undefined) && { endpoint: account.endpoint }),
+    ...(routing !== undefined && { routing }),
     ...(!(account.model === undefined) && { accountModel: account.model }),
     ...(!(boundAgents.length === 0) && {
       configPreview: accountConfigSnippet(providers, account.id),
@@ -154,12 +161,26 @@ export function providerAccountDetailViewModel(
   };
 }
 
+/**
+ * How this account reaches its provider, as the one axis the UI renders. A catalog account has no
+ * single endpoint — each agent resolves its own — so it advertises the shapes the service serves;
+ * only a user-named endpoint is a pin. Asking the resolver keeps this answer identical to the one
+ * a session start will act on.
+ */
+function accountRouting(account: Account): ProviderAccountRouting | undefined {
+  const pinned = pinnedEndpoint(account);
+  if (pinned) return { kind: 'pinned', baseUrl: pinned.baseUrl, protocol: pinned.protocol };
+  const protocols = serviceProtocols(account.service);
+  return protocols.length > 0 ? { kind: 'catalog', protocols } : undefined;
+}
+
 function providerAccountListItem(
   account: Account,
   providers: ProvidersConfig | undefined,
   runtimes: AgentRuntimes | undefined,
 ): ProviderAccountListItem {
   const serviceLabel = serviceById(account.service)?.label;
+  const routing = accountRouting(account);
   const auth =
     account.credential.type === 'oauth' ? runtimes?.[account.credential.agent]?.auth : undefined;
   return {
@@ -169,8 +190,7 @@ function providerAccountListItem(
     boundAgents: boundAgentKinds(providers, account.id),
     ...(account.service !== undefined && { service: account.service }),
     ...(serviceLabel !== undefined && { serviceLabel }),
-    ...(account.endpoint !== undefined && { endpoint: account.endpoint.baseUrl }),
-    ...(account.endpoint !== undefined && { protocol: account.endpoint.protocol }),
+    ...(routing !== undefined && { routing }),
     ...(auth !== undefined && {
       auth: {
         loggedIn: auth.loggedIn,
diff --git a/packages/foundation/providers/AGENTS.md b/packages/foundation/providers/AGENTS.md
new file mode 100644
index 000000000..9b32a9692
--- /dev/null
+++ b/packages/foundation/providers/AGENTS.md
@@ -0,0 +1,87 @@
+# packages/foundation/providers — model-provider service directory
+
+`@linkcode/providers` owns which endpoints each provider serves and which one a given agent uses.
+Both ends read it: the daemon resolves a session's endpoint at start (`packages/host/engine`
+`provider-config.ts`), the client renders binding availability (`packages/client/workbench`
+`settings/providers/view.ts`). It previously lived in workbench and the daemon had its own partial
+copy of the same facts — keep it here so there is one.
+
+Pure data plus pure functions: no hooks, no browser APIs, no I/O. Its only dependencies are
+`@linkcode/schema` types and `foxts`.
+
+## The model
+
+- A **variant is one protocol shape of one service**, reached with the *same secret*. Two endpoints
+  that need different secrets, or that mean different things to the user (a plan/reasoning tier
+  versus the standard API), are **separate services** — not variants. `cloudflare-gateway` and
+  `cloudflare-anthropic` are split for exactly this reason: the pass-through leg authenticates with
+  the user's own Anthropic key.
+- `variants` is keyed by `AccountProtocol`, so a service cannot declare two variants of one shape.
+- `credentialType` sits on the service, not the variant — that is what the shared-secret rule means.
+  Differing *header shape* per protocol would be fine (DeepSeek's Anthropic endpoint accepts both
+  `x-api-key` and `Authorization: Bearer`); differing secret *value* is not, and would break
+  automatic selection. Add a per-variant override only if a real service needs one.
+- **Variants are never user-selectable.** The add-account form asks for a secret (and any
+  `{placeholder}` values); `resolveBinding` picks the variant per agent. An `Account` therefore
+  stores `service` + `endpointParams`, not a resolved URL.
+- **`Account.endpoint` only outranks the catalog when the user named it.** The pre-variant add flow
+  wrote an endpoint onto *every* catalog account, so honoring all of them would pin existing
+  accounts to one protocol forever — an upgraded OpenAI account would lose codex, which works today
+  because `OPENAI_BASE_URL` points at a host that does serve `/responses`. `pinnedEndpoint()`
+  settles it by exact `baseUrl` match against the service's own variants: a match is the catalog's
+  own output and is replaced by per-agent resolution; anything else was typed by a human (a custom
+  account, or a catalog account edited through the custom form, which keeps its `service`) and is
+  kept. Match on the URL, not on "the service declares this protocol" — the looser rule would
+  silently discard a hand-typed proxy. A filled templated URL matches nothing and stays pinned;
+  those accounts were never broken.
+  - **Every caller asks `pinnedEndpoint()`, never `Account.endpoint` directly.** It is exported for
+    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.
+- **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
+  `POST {baseUrl}/responses` (checked against vendor docs 2026-08). Cloudflare's `/compat` genuinely
+  does not; its Responses route is `/openai/responses`, a different path, which is why that entry
+  has no responses variant. Added responses variants deliberately carry no `knownProvider`, so
+  `preferredProtocols` keeps opencode and pi on the shape their own catalogs know.
+
+## resolveBinding
+
+One table, no per-service special cases. A service-name check inside a protocol decision is the
+smell this package exists to remove.
+
+- `claude-code` — the `anthropic` variant natively; else `openai-chat` through the local translator.
+  **Only `openai-chat`**: `TranslatorUpstream.wire` is typed `'openai-chat'` and the sidecar
+  implements nothing else, so a responses-only service is unavailable rather than translated.
+- `codex` — `openai-responses` only. Chat Completions was removed from the CLI (`wire_api = "chat"`
+  is a config-load error since 0.122), so a chat endpoint answers 404 on `POST /responses`.
+- `opencode` / `pi` — any shape. They route by provider, so the preferred variant is the one whose
+  `knownProvider` names an entry in that agent's own catalog: the agent then carries the wire adapter
+  and model metadata and needs only the key. `knownProvider` reaches the adapters through
+  `StartOptions.config.knownProvider`.
+- `grok-build` — no endpoint axis at all (the headless CLI has no base-URL flag), so it is a vendor
+  check, deliberately its own branch rather than an escape hatch in the protocol match.
+- An `unavailable` result must fail a session start loudly; the engine does this rather than
+  starting an agent against an endpoint it cannot speak.
+
+`knownProvider` ids come from remote vocabularies — `models.dev` for opencode (its `api` field is
+the base URL, `npm` fixes the wire) and pi's `KnownProvider` union. A stale id must degrade to "no
+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).
+
+**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
+`models`. An earlier revision shipped exactly that, with a comment and a doc paragraph asserting the
+wire was pinned; nothing failed, because a baseUrl-only injection is correct precisely when the
+target provider's built-in wire already matches, which is every provider pi ships metadata for. The
+correct scope is therefore known providers, and the honest statement of the limit is that
+differently-shaped endpoints are out of scope until the metadata question is answered.
diff --git a/packages/foundation/providers/CLAUDE.md b/packages/foundation/providers/CLAUDE.md
new file mode 100644
index 000000000..43c994c2d
--- /dev/null
+++ b/packages/foundation/providers/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/packages/foundation/providers/package.json b/packages/foundation/providers/package.json
new file mode 100644
index 000000000..ddb3b1805
--- /dev/null
+++ b/packages/foundation/providers/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "@linkcode/providers",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "lint": "eslint --format=sukka ."
+  },
+  "dependencies": {
+    "@linkcode/schema": "workspace:*",
+    "foxts": "^5.8.1"
+  }
+}
diff --git a/packages/foundation/providers/src/__tests__/resolve.test.ts b/packages/foundation/providers/src/__tests__/resolve.test.ts
new file mode 100644
index 000000000..78e4c50b0
--- /dev/null
+++ b/packages/foundation/providers/src/__tests__/resolve.test.ts
@@ -0,0 +1,306 @@
+import type { Account, AgentKind, AgentRuntimes } from '@linkcode/schema';
+import { nullthrow } from 'foxts/guard';
+import { describe, expect, it } from 'vitest';
+import { serviceById } from '../catalog';
+import { detectedLoginSuggestions } from '../detected-logins';
+import { resolveBinding, serviceProtocols } from '../resolve';
+import { fillTemplate, templatePlaceholders } from '../template';
+
+function account(overrides: Partial<Account>): Account {
+  return {
+    id: 'acc_test',
+    label: 'Test',
+    credential: { type: 'api-key', key: 'sk-test' },
+    createdAt: 0,
+    ...overrides,
+  };
+}
+
+const ALL_KINDS: AgentKind[] = ['claude-code', 'codex', 'opencode', 'pi', 'grok-build'];
+
+describe('resolveBinding: one explicit endpoint', () => {
+  it('locks an oauth account to its own agent', () => {
+    const sub = account({ credential: { type: 'oauth', agent: 'claude-code' } });
+    expect(resolveBinding(sub, 'claude-code')).toEqual({ tier: 'native' });
+    expect(resolveBinding(sub, 'codex')).toEqual({
+      tier: 'unavailable',
+      reason: 'oauth-other-agent',
+    });
+  });
+
+  it('routes an anthropic endpoint natively to claude-code, opencode and pi', () => {
+    const endpoint = { baseUrl: 'https://api.anthropic.com', protocol: 'anthropic' } as const;
+    const anthropic = account({ endpoint });
+    for (const kind of ['claude-code', 'opencode', 'pi'] as const) {
+      expect(resolveBinding(anthropic, kind)).toEqual({ tier: 'native', ...endpoint });
+    }
+    expect(resolveBinding(anthropic, 'codex')).toEqual({
+      tier: 'unavailable',
+      reason: 'protocol-unsupported',
+    });
+  });
+
+  it('translates an openai-chat endpoint for claude-code and refuses it for codex', () => {
+    const endpoint = { baseUrl: 'https://api.example.com/v1', protocol: 'openai-chat' } as const;
+    const chat = account({ endpoint });
+    expect(resolveBinding(chat, 'claude-code')).toEqual({ tier: 'translate', ...endpoint });
+    expect(resolveBinding(chat, 'opencode')).toEqual({ tier: 'native', ...endpoint });
+    // Chat Completions is gone from the codex CLI — it can only reach a Responses endpoint.
+    expect(resolveBinding(chat, 'codex')).toEqual({
+      tier: 'unavailable',
+      reason: 'protocol-unsupported',
+    });
+  });
+
+  it('routes an openai-responses endpoint natively to codex, never translated', () => {
+    const endpoint = {
+      baseUrl: 'https://api.example.com/v1',
+      protocol: 'openai-responses',
+    } as const;
+    const responses = account({ endpoint });
+    expect(resolveBinding(responses, 'codex')).toEqual({ tier: 'native', ...endpoint });
+    // The sidecar implements only openai-chat, so this is unavailable rather than translated.
+    expect(resolveBinding(responses, 'claude-code')).toEqual({
+      tier: 'unavailable',
+      reason: 'protocol-unsupported',
+    });
+  });
+
+  it('keeps a pre-catalog bare key bindable everywhere', () => {
+    const legacy = account({});
+    for (const kind of ALL_KINDS) {
+      expect(resolveBinding(legacy, kind)).toEqual({ tier: 'native' });
+    }
+  });
+
+  it('binds grok-build only to xAI and pre-catalog bare keys', () => {
+    expect(resolveBinding(account({ service: 'xai' }), 'grok-build')).toEqual({ tier: 'native' });
+    expect(resolveBinding(account({}), 'grok-build')).toEqual({ tier: 'native' });
+    expect(resolveBinding(account({ service: 'openai-api' }), 'grok-build')).toEqual({
+      tier: 'unavailable',
+      reason: 'protocol-unsupported',
+    });
+  });
+});
+
+describe('resolveBinding: variant chosen per agent', () => {
+  it('gives each agent its own endpoint from one OpenAI API key', () => {
+    const openai = account({ service: 'openai-api' });
+    // Codex overrides the base URL of its built-in Responses provider.
+    expect(resolveBinding(openai, 'codex')).toEqual({
+      tier: 'native',
+      protocol: 'openai-responses',
+      baseUrl: 'https://api.openai.com/v1',
+    });
+    // claude-code has no anthropic variant here, so it falls back to the translator over chat.
+    expect(resolveBinding(openai, 'claude-code')).toEqual({
+      tier: 'translate',
+      protocol: 'openai-chat',
+      baseUrl: 'https://api.openai.com/v1',
+    });
+    // opencode and pi prefer the variant their own catalog knows.
+    expect(resolveBinding(openai, 'opencode')).toEqual({
+      tier: 'native',
+      protocol: 'openai-responses',
+      baseUrl: 'https://api.openai.com/v1',
+      knownProvider: 'openai',
+    });
+    expect(resolveBinding(openai, 'pi')).toMatchObject({ knownProvider: 'openai' });
+  });
+
+  it('serves every agent natively from one three-variant service', () => {
+    const deepseek = account({ service: 'deepseek' });
+    expect(resolveBinding(deepseek, 'claude-code')).toEqual({
+      tier: 'native',
+      protocol: 'anthropic',
+      baseUrl: 'https://api.deepseek.com/anthropic',
+    });
+    expect(resolveBinding(deepseek, 'codex')).toEqual({
+      tier: 'native',
+      protocol: 'openai-responses',
+      baseUrl: 'https://api.deepseek.com',
+    });
+    for (const kind of ['opencode', 'pi'] as const) {
+      expect(resolveBinding(deepseek, kind)).toEqual({
+        tier: 'native',
+        protocol: 'openai-chat',
+        baseUrl: 'https://api.deepseek.com',
+        knownProvider: 'deepseek',
+      });
+    }
+    // No translator anywhere: one key reaches four agents over three different wires.
+    expect(resolveBinding(deepseek, 'grok-build')).toEqual({
+      tier: 'unavailable',
+      reason: 'protocol-unsupported',
+    });
+  });
+
+  it('reaches codex on every service whose endpoint serves the Responses API', () => {
+    // Verified against vendor docs 2026-08: xAI, OpenRouter and Vercel all serve POST /responses
+    // at the base URL declared here, so codex must have a target on each.
+    const cases = [
+      ['xai', 'https://api.x.ai/v1'],
+      ['openrouter', 'https://openrouter.ai/api/v1'],
+      ['vercel-gateway', 'https://ai-gateway.vercel.sh/v1'],
+    ] as const;
+    for (const [service, baseUrl] of cases) {
+      expect(resolveBinding(account({ service }), 'codex')).toEqual({
+        tier: 'native',
+        protocol: 'openai-responses',
+        baseUrl,
+      });
+    }
+    // Cloudflare's `/compat` path serves chat completions only — its Responses route is elsewhere.
+    expect(
+      resolveBinding(
+        account({
+          service: 'cloudflare-gateway',
+          endpointParams: { account_id: 'a', gateway_id: 'g' },
+        }),
+        'codex',
+      ),
+    ).toEqual({ tier: 'unavailable', reason: 'protocol-unsupported' });
+  });
+
+  it('leaves opencode and pi on their known-provider variant when a responses one exists', () => {
+    // The added responses variants carry no knownProvider, so provider-routed agents are untouched.
+    for (const kind of ['opencode', 'pi'] as const) {
+      expect(resolveBinding(account({ service: 'xai' }), kind)).toMatchObject({
+        protocol: 'openai-chat',
+        knownProvider: 'xai',
+      });
+    }
+  });
+
+  it('prefers a native anthropic variant over translation', () => {
+    const openrouter = account({
+      service: 'openrouter',
+      credential: { type: 'auth-token', token: 'sk-or-v1-x' },
+    });
+    expect(resolveBinding(openrouter, 'claude-code')).toEqual({
+      tier: 'native',
+      protocol: 'anthropic',
+      baseUrl: 'https://openrouter.ai/api',
+    });
+    // The same key reaches codex over the Responses shape at the same gateway.
+    expect(resolveBinding(openrouter, 'codex')).toEqual({
+      tier: 'native',
+      protocol: 'openai-responses',
+      baseUrl: 'https://openrouter.ai/api/v1',
+    });
+    // The known provider wins over the anthropic variant that protocol order would reach first.
+    expect(resolveBinding(openrouter, 'opencode')).toEqual({
+      tier: 'native',
+      protocol: 'openai-chat',
+      baseUrl: 'https://openrouter.ai/api/v1',
+      knownProvider: 'openrouter',
+    });
+  });
+
+  it('fills a templated endpoint from endpointParams, and refuses an unfilled one', () => {
+    const params = { account_id: '8f3a', gateway_id: 'prod' };
+    expect(
+      resolveBinding(
+        account({ service: 'cloudflare-anthropic', endpointParams: params }),
+        'claude-code',
+      ),
+    ).toEqual({
+      tier: 'native',
+      protocol: 'anthropic',
+      baseUrl: 'https://gateway.ai.cloudflare.com/v1/8f3a/prod/anthropic',
+    });
+    // A literal `{account_id}` in the URL would 404 quietly; refuse the binding instead.
+    expect(resolveBinding(account({ service: 'cloudflare-anthropic' }), 'claude-code')).toEqual({
+      tier: 'unavailable',
+      reason: 'endpoint-incomplete',
+    });
+  });
+
+  it('re-resolves an account the pre-variant add flow pinned to one endpoint', () => {
+    // What the old add flow persisted for the `openai-api` catalog entry: the endpoint carries no
+    // user intent, and honoring it would refuse codex on an account that works today.
+    const upgraded = account({
+      service: 'openai-api',
+      endpoint: { baseUrl: 'https://api.openai.com/v1', protocol: 'openai-chat' },
+    });
+    expect(resolveBinding(upgraded, 'codex')).toEqual({
+      tier: 'native',
+      protocol: 'openai-responses',
+      baseUrl: 'https://api.openai.com/v1',
+    });
+    // It also picks up the known-provider injection, like a freshly created account.
+    expect(resolveBinding(upgraded, 'opencode')).toMatchObject({ knownProvider: 'openai' });
+  });
+
+  it('keeps a pinned endpoint whose template the catalog cannot match', () => {
+    // The stored URL is filled while the variant is templated, so it matches nothing and stays
+    // pinned — the pre-variant behavior, which was never broken for these accounts.
+    const cloudflare = account({
+      service: 'cloudflare-gateway',
+      credential: { type: 'auth-token', token: 'cf' },
+      endpoint: {
+        baseUrl: 'https://gateway.ai.cloudflare.com/v1/8f3a/prod/compat',
+        protocol: 'openai-chat',
+      },
+    });
+    expect(resolveBinding(cloudflare, 'claude-code')).toMatchObject({
+      tier: 'translate',
+      baseUrl: 'https://gateway.ai.cloudflare.com/v1/8f3a/prod/compat',
+    });
+  });
+
+  it('lets an explicit endpoint outrank the catalog while keeping the known provider', () => {
+    const pinned = account({
+      service: 'openrouter',
+      credential: { type: 'auth-token', token: 'sk-or-v1-x' },
+      endpoint: { baseUrl: 'https://proxy.example.com/v1', protocol: 'openai-chat' },
+    });
+    expect(resolveBinding(pinned, 'opencode')).toEqual({
+      tier: 'native',
+      protocol: 'openai-chat',
+      baseUrl: 'https://proxy.example.com/v1',
+      knownProvider: 'openrouter',
+    });
+  });
+});
+
+describe('catalog helpers', () => {
+  it('reports every protocol shape a service serves', () => {
+    expect(serviceProtocols('openai-api')).toEqual(['openai-chat', 'openai-responses']);
+    expect(serviceProtocols('openrouter')).toEqual([
+      'anthropic',
+      'openai-chat',
+      'openai-responses',
+    ]);
+    expect(serviceProtocols('claude-sub')).toEqual([]);
+    expect(serviceProtocols(undefined)).toEqual([]);
+  });
+
+  it('extracts and fills endpoint template placeholders', () => {
+    const cloudflare = serviceById('cloudflare-anthropic');
+    if (cloudflare?.kind !== 'endpoint') throw new Error('cloudflare descriptor missing');
+    const template = nullthrow(cloudflare.variants.anthropic, 'anthropic variant missing').baseUrl;
+    expect(templatePlaceholders(template)).toEqual(['account_id', 'gateway_id']);
+    expect(fillTemplate(template, { account_id: '8f3a', gateway_id: 'prod' })).toBe(
+      'https://gateway.ai.cloudflare.com/v1/8f3a/prod/anthropic',
+    );
+  });
+
+  it('suggests detected CLI logins the pool does not represent yet', () => {
+    const runtimes: AgentRuntimes = {
+      'claude-code': {
+        status: 'available',
+        auth: { loggedIn: true, method: 'claude.ai', subscriptionType: 'max', email: 'x@y.z' },
+      },
+      codex: { status: 'available', auth: { loggedIn: false } },
+    };
+    const suggested = detectedLoginSuggestions([], runtimes);
+    expect(suggested.map(({ service, auth }) => [service.id, auth.email])).toEqual([
+      ['claude-sub', 'x@y.z'],
+    ]);
+    // An existing oauth account for the agent absorbs the suggestion; unprobed runtimes yield none.
+    const claudeSub = account({ credential: { type: 'oauth', agent: 'claude-code' } });
+    expect(detectedLoginSuggestions([claudeSub], runtimes)).toEqual([]);
+    expect(detectedLoginSuggestions([], undefined)).toEqual([]);
+  });
+});
diff --git a/packages/foundation/providers/src/catalog.ts b/packages/foundation/providers/src/catalog.ts
new file mode 100644
index 000000000..b6cdf9bc0
--- /dev/null
+++ b/packages/foundation/providers/src/catalog.ts
@@ -0,0 +1,187 @@
+import type { AccountProtocol, AgentKind } from '@linkcode/schema';
+
+/**
+ * The service directory: which endpoints each provider serves, and which of them the coding agents
+ * already know by name. Read by the daemon (to resolve a session's endpoint) and by the client (to
+ * render binding availability) — endpoint facts verified against vendor docs, `knownProvider` ids
+ * against models.dev (opencode's catalog) and pi's `KnownProvider` union, 2026-08.
+ *
+ * A **variant** is one protocol shape of one service, reached with the *same* secret. Endpoints that
+ * need a different secret, or that mean something different to the user (a plan/reasoning tier
+ * versus the standard API), are separate services. Variants are never user-selectable — `resolve.ts`
+ * picks one per agent.
+ */
+
+/** Grouping in the add-account catalog grid. */
+export type ServiceGroup = 'subscription' | 'direct' | 'gateway' | 'custom';
+
+export interface ServiceVariant {
+  /** Endpoint URL, possibly templated with `{placeholder}` segments filled from `endpointParams`. */
+  baseUrl: string;
+  /** Ids for this endpoint in an agent's own provider catalog. Present means the agent already
+   * carries the wire adapter and model metadata, so it needs only the key injected. */
+  knownProvider?: Partial<Record<AgentKind, string>>;
+}
+
+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 }
+  /** Key/token against baked endpoints (direct vendor API or gateway). */
+  | {
+      id: string;
+      label: string;
+      group: ServiceGroup;
+      kind: 'endpoint';
+      /** How the one secret authenticates. Service-level: every variant accepts the same secret. */
+      credentialType: 'api-key' | 'auth-token';
+      variants: Partial<Record<AccountProtocol, ServiceVariant>>;
+      secretPlaceholder?: string;
+    }
+  /** Free-form endpoint — the full account form. */
+  | { id: 'custom'; label: string; group: 'custom'; kind: 'custom' };
+
+export const SERVICE_CATALOG: ServiceDescriptor[] = [
+  { id: 'claude-sub', label: 'Claude', group: 'subscription', kind: 'oauth', agent: 'claude-code' },
+  { id: 'chatgpt-sub', label: 'ChatGPT', group: 'subscription', kind: 'oauth', agent: 'codex' },
+  {
+    id: 'anthropic-api',
+    label: 'Anthropic API',
+    group: 'direct',
+    kind: 'endpoint',
+    credentialType: 'api-key',
+    variants: {
+      anthropic: {
+        baseUrl: 'https://api.anthropic.com',
+        knownProvider: { opencode: 'anthropic', pi: 'anthropic' },
+      },
+    },
+    secretPlaceholder: 'sk-ant-…',
+  },
+  {
+    id: 'openai-api',
+    label: 'OpenAI API',
+    group: 'direct',
+    kind: 'endpoint',
+    credentialType: 'api-key',
+    variants: {
+      'openai-responses': {
+        baseUrl: 'https://api.openai.com/v1',
+        knownProvider: { opencode: 'openai', pi: 'openai' },
+      },
+      // Same endpoint, legacy shape. No known provider: opencode's and pi's `openai` entries both
+      // resolve to the Responses adapter, so reaching chat here needs a custom registration.
+      'openai-chat': { baseUrl: 'https://api.openai.com/v1' },
+    },
+    secretPlaceholder: 'sk-…',
+  },
+  {
+    id: 'xai',
+    label: 'xAI (Grok)',
+    group: 'direct',
+    kind: 'endpoint',
+    credentialType: 'api-key',
+    variants: {
+      'openai-chat': {
+        baseUrl: 'https://api.x.ai/v1',
+        knownProvider: { opencode: 'xai', pi: 'xai' },
+      },
+      // Same endpoint, Responses shape — the only one codex speaks. No known provider: the agents'
+      // own `xai` entries are chat-shaped, and opencode/pi prefer those.
+      'openai-responses': { baseUrl: 'https://api.x.ai/v1' },
+    },
+    secretPlaceholder: 'xai-…',
+  },
+  {
+    id: 'deepseek',
+    label: 'DeepSeek',
+    group: 'direct',
+    kind: 'endpoint',
+    credentialType: 'api-key',
+    variants: {
+      // Claude model names are remapped server-side (opus → v4-pro, sonnet/haiku → v4-flash).
+      anthropic: { baseUrl: 'https://api.deepseek.com/anthropic' },
+      // Responses serves `deepseek-v4-flash` only; v4-pro is still unsupported there (2026-08).
+      'openai-responses': { baseUrl: 'https://api.deepseek.com' },
+      'openai-chat': {
+        baseUrl: 'https://api.deepseek.com',
+        knownProvider: { opencode: 'deepseek', pi: 'deepseek' },
+      },
+    },
+    secretPlaceholder: 'sk-…',
+  },
+  {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    group: 'gateway',
+    kind: 'endpoint',
+    credentialType: 'auth-token',
+    variants: {
+      'openai-chat': {
+        baseUrl: 'https://openrouter.ai/api/v1',
+        knownProvider: { opencode: 'openrouter', pi: 'openrouter' },
+      },
+      'openai-responses': { baseUrl: 'https://openrouter.ai/api/v1' },
+      // The "Anthropic skin" is guaranteed only for Claude models.
+      anthropic: { baseUrl: 'https://openrouter.ai/api' },
+    },
+    secretPlaceholder: 'sk-or-v1-…',
+  },
+  {
+    id: 'vercel-gateway',
+    label: 'Vercel AI Gateway',
+    group: 'gateway',
+    kind: 'endpoint',
+    credentialType: 'auth-token',
+    variants: {
+      'openai-chat': {
+        baseUrl: 'https://ai-gateway.vercel.sh/v1',
+        knownProvider: { opencode: 'vercel', pi: 'vercel-ai-gateway' },
+      },
+      'openai-responses': { baseUrl: 'https://ai-gateway.vercel.sh/v1' },
+      // Anthropic-shaped endpoint; translates server-side, so it also serves non-Anthropic models.
+      anthropic: { baseUrl: 'https://ai-gateway.vercel.sh' },
+    },
+  },
+  {
+    id: 'cloudflare-gateway',
+    label: 'Cloudflare AI Gateway',
+    group: 'gateway',
+    kind: 'endpoint',
+    credentialType: 'auth-token',
+    variants: {
+      // `/compat` serves chat completions only — Cloudflare's Responses route is a different path
+      // (`/openai/responses`), so there is deliberately no responses variant here.
+      'openai-chat': {
+        baseUrl: 'https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/compat',
+        knownProvider: { opencode: 'cloudflare-ai-gateway', pi: 'cloudflare-ai-gateway' },
+      },
+    },
+  },
+  {
+    // Its own service, not a variant of the gateway above: pass-through authenticates with the
+    // user's real Anthropic key, so the two cannot share one stored secret.
+    id: 'cloudflare-anthropic',
+    label: 'Cloudflare AI Gateway (Anthropic)',
+    group: 'gateway',
+    kind: 'endpoint',
+    credentialType: 'api-key',
+    variants: {
+      anthropic: {
+        baseUrl: 'https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/anthropic',
+      },
+    },
+    secretPlaceholder: 'sk-ant-…',
+  },
+  { id: 'custom', label: 'Custom', group: 'custom', kind: 'custom' },
+];
+
+export function serviceById(id: string | undefined): ServiceDescriptor | undefined {
+  return id === undefined ? undefined : SERVICE_CATALOG.find((service) => service.id === id);
+}
+
+export type EndpointService = Extract<ServiceDescriptor, { kind: 'endpoint' }>;
+
+export function endpointServiceById(id: string | undefined): EndpointService | undefined {
+  const service = serviceById(id);
+  return service?.kind === 'endpoint' ? service : undefined;
+}
diff --git a/packages/foundation/providers/src/detected-logins.ts b/packages/foundation/providers/src/detected-logins.ts
new file mode 100644
index 000000000..1ece4200d
--- /dev/null
+++ b/packages/foundation/providers/src/detected-logins.ts
@@ -0,0 +1,31 @@
+import type { Accounts, AgentAuthStatus, AgentRuntimes } from '@linkcode/schema';
+import type { ServiceDescriptor } from './catalog';
+import { SERVICE_CATALOG } from './catalog';
+
+export interface DetectedLoginSuggestion {
+  service: Extract<ServiceDescriptor, { kind: 'oauth' }>;
+  auth: AgentAuthStatus;
+}
+
+/**
+ * CLI logins the runtime probe sees that the pool does not represent yet, offered as one-click
+ * "detected" cards: `loggedIn: true` with no oauth account for that agent. The pool stays
+ * explicit user state — this is a suggestion, not an implicit member.
+ */
+export function detectedLoginSuggestions(
+  accounts: Accounts,
+  runtimes: AgentRuntimes | undefined,
+): DetectedLoginSuggestion[] {
+  const suggestions: DetectedLoginSuggestion[] = [];
+  for (const service of SERVICE_CATALOG) {
+    if (service.kind !== 'oauth') continue;
+    const auth = runtimes?.[service.agent]?.auth;
+    if (auth?.loggedIn !== true) continue;
+    const represented = accounts.some(
+      (account) =>
+        account.credential.type === 'oauth' && account.credential.agent === service.agent,
+    );
+    if (!represented) suggestions.push({ service, auth });
+  }
+  return suggestions;
+}
diff --git a/packages/foundation/providers/src/index.ts b/packages/foundation/providers/src/index.ts
new file mode 100644
index 000000000..d7aebb17f
--- /dev/null
+++ b/packages/foundation/providers/src/index.ts
@@ -0,0 +1,12 @@
+export type {
+  EndpointService,
+  ServiceDescriptor,
+  ServiceGroup,
+  ServiceVariant,
+} from './catalog';
+export { endpointServiceById, SERVICE_CATALOG, serviceById } from './catalog';
+export type { DetectedLoginSuggestion } from './detected-logins';
+export { detectedLoginSuggestions } from './detected-logins';
+export type { BindingTier, BindingUnavailableReason, ResolvedBinding } from './resolve';
+export { pinnedEndpoint, resolveBinding, serviceProtocols } from './resolve';
+export { fillTemplate, isTemplateFilled, templatePlaceholders } from './template';
diff --git a/packages/foundation/providers/src/resolve.ts b/packages/foundation/providers/src/resolve.ts
new file mode 100644
index 000000000..f2a4deb09
--- /dev/null
+++ b/packages/foundation/providers/src/resolve.ts
@@ -0,0 +1,181 @@
+import type { Account, AccountEndpoint, AccountProtocol, AgentKind } from '@linkcode/schema';
+import { AccountProtocolSchema } from '@linkcode/schema';
+import { never } from 'foxts/guard';
+import type { EndpointService, ServiceVariant } from './catalog';
+import { endpointServiceById } from './catalog';
+import { fillTemplate, isTemplateFilled } from './template';
+
+/**
+ * Which endpoint an agent uses for a given account, derived from the adapters' real injection seams
+ * (`packages/host/agent-adapter` `credential.ts` + native adapters, `packages/host/engine`
+ * `translator.ts`). One table, no per-service special cases — a service is either served by a
+ * variant the agent speaks or it is unavailable.
+ *
+ * - claude-code reads `ANTHROPIC_*` env, so it speaks Anthropic natively; an OpenAI-chat endpoint is
+ *   reachable through the local aigateway translator, which needs a base URL AND a key.
+ * - codex overrides the base URL of its built-in *Responses* provider. Chat Completions was removed
+ *   from the CLI (`wire_api = "chat"` is a config-load error since 0.122), so responses is the only
+ *   shape it can reach.
+ * - opencode and pi route by provider: any wire works, but a provider the agent already knows ships
+ *   the wire adapter and model metadata, so those variants are preferred.
+ * - grok-build has no base-URL flag at all; only an xAI key reaches its endpoint.
+ */
+
+export type BindingTier = 'native' | 'translate' | 'unavailable';
+
+export type BindingUnavailableReason =
+  | 'oauth-other-agent'
+  | 'protocol-unsupported'
+  /** A templated endpoint whose `{placeholder}` values are missing from the account. */
+  | 'endpoint-incomplete';
+
+export type ResolvedBinding =
+  | {
+      tier: 'native' | 'translate';
+      /** Absent when the account names no endpoint: an oauth login, or a pre-catalog bare key. */
+      protocol?: AccountProtocol;
+      baseUrl?: string;
+      /** The endpoint's id in this agent's own provider catalog, when it has one. */
+      knownProvider?: string;
+    }
+  | { tier: 'unavailable'; reason: BindingUnavailableReason };
+
+/** Stable resolution order for agents that accept every wire. */
+const PROTOCOL_ORDER = AccountProtocolSchema.options;
+
+/** Whether (and how) this account can back sessions of the given agent, plus the endpoint to use. */
+export function resolveBinding(account: Account, kind: AgentKind): ResolvedBinding {
+  if (account.credential.type === 'oauth') {
+    // An OAuth account is one CLI's login; it cannot back another agent.
+    return account.credential.agent === kind
+      ? { tier: 'native' }
+      : { tier: 'unavailable', reason: 'oauth-other-agent' };
+  }
+  if (kind === 'grok-build') return resolveGrokBuild(account);
+
+  const service = endpointServiceById(account.service);
+  const pinned = pinnedEndpoint(account);
+  if (pinned) {
+    return bind(
+      kind,
+      pinned.protocol,
+      pinned.baseUrl,
+      knownProviderFor(service?.variants[pinned.protocol], kind),
+    );
+  }
+  if (!service) {
+    // Vendor unknown (pre-catalog bare key): keep it bindable everywhere, matching the pre-catalog
+    // behavior — the user knows which vendor the key belongs to.
+    return { tier: 'native' };
+  }
+  return resolveService(service, account, kind);
+}
+
+/** Every protocol shape a service serves, for display. */
+export function serviceProtocols(id: string | undefined): AccountProtocol[] {
+  const service = endpointServiceById(id);
+  if (!service) return [];
+  return PROTOCOL_ORDER.filter((protocol) => service.variants[protocol] !== undefined);
+}
+
+function resolveGrokBuild(account: Account): ResolvedBinding {
+  // The headless CLI has no base-URL flag: only the xAI catalog entry is known to target its
+  // endpoint. Preserve pre-catalog bare keys, whose vendor was never recorded.
+  const bare = account.service === undefined && account.endpoint === undefined;
+  return bare || account.service === 'xai'
+    ? { tier: 'native' }
+    : { tier: 'unavailable', reason: 'protocol-unsupported' };
+}
+
+function resolveService(
+  service: EndpointService,
+  account: Account,
+  kind: AgentKind,
+): ResolvedBinding {
+  for (const protocol of preferredProtocols(service, kind)) {
+    const variant = service.variants[protocol];
+    if (!variant) continue;
+    const baseUrl = fillTemplate(variant.baseUrl, account.endpointParams ?? {});
+    if (!isTemplateFilled(baseUrl)) return { tier: 'unavailable', reason: 'endpoint-incomplete' };
+    return bind(kind, protocol, baseUrl, knownProviderFor(variant, kind));
+  }
+  return { tier: 'unavailable', reason: 'protocol-unsupported' };
+}
+
+/**
+ * The protocols to try, most preferred first. claude-code and codex have one native shape each
+ * (claude-code falling back to the translator); opencode and pi accept any, preferring a variant
+ * their own catalog already knows.
+ */
+function preferredProtocols(service: EndpointService, kind: AgentKind): AccountProtocol[] {
+  switch (kind) {
+    case 'claude-code':
+      return ['anthropic', 'openai-chat'];
+    case 'codex':
+      return ['openai-responses'];
+    case 'opencode':
+    case 'pi': {
+      const known = PROTOCOL_ORDER.filter(
+        (protocol) => service.variants[protocol]?.knownProvider?.[kind] !== undefined,
+      );
+      return [...known, ...PROTOCOL_ORDER.filter((protocol) => !known.includes(protocol))];
+    }
+    case 'grok-build':
+      return [];
+    default:
+      return never(kind, 'agent kind');
+  }
+}
+
+/** Tier for one concrete (agent, protocol) pair. */
+function bind(
+  kind: AgentKind,
+  protocol: AccountProtocol,
+  baseUrl: string,
+  knownProvider: string | undefined,
+): ResolvedBinding {
+  const resolved = { protocol, baseUrl, ...(knownProvider !== undefined && { knownProvider }) };
+  switch (kind) {
+    case 'claude-code':
+      if (protocol === 'anthropic') return { tier: 'native', ...resolved };
+      // The sidecar implements only `openai-chat` (engine `TranslatorUpstream.wire`).
+      return protocol === 'openai-chat'
+        ? { tier: 'translate', ...resolved }
+        : { tier: 'unavailable', reason: 'protocol-unsupported' };
+    case 'codex':
+      return protocol === 'openai-responses'
+        ? { tier: 'native', ...resolved }
+        : { tier: 'unavailable', reason: 'protocol-unsupported' };
+    case 'opencode':
+    case 'pi':
+      return { tier: 'native', ...resolved };
+    case 'grok-build':
+      return { tier: 'unavailable', reason: 'protocol-unsupported' };
+    default:
+      return never(kind, 'agent kind');
+  }
+}
+
+function knownProviderFor(
+  variant: ServiceVariant | undefined,
+  kind: AgentKind,
+): string | undefined {
+  return variant?.knownProvider?.[kind];
+}
+
+/**
+ * The endpoint the user named, if any. A stored endpoint the catalog itself produces is not one:
+ * the pre-variant add flow wrote one onto every catalog account, back when an account could only
+ * name a single endpoint, and honoring those would pin existing accounts to one protocol forever.
+ * A URL matching no variant was typed by a human — a custom account, or a catalog account edited by
+ * hand — and is kept.
+ *
+ * Read this rather than `Account.endpoint` anywhere the answer is shown or acted on, or a caller
+ * will describe an account differently from how it actually resolves.
+ */
+export function pinnedEndpoint(account: Account): AccountEndpoint | undefined {
+  const { endpoint } = account;
+  if (!endpoint) return undefined;
+  const variant = endpointServiceById(account.service)?.variants[endpoint.protocol];
+  return variant?.baseUrl === endpoint.baseUrl ? undefined : endpoint;
+}
diff --git a/packages/foundation/providers/src/template.ts b/packages/foundation/providers/src/template.ts
new file mode 100644
index 000000000..e05f07401
--- /dev/null
+++ b/packages/foundation/providers/src/template.ts
@@ -0,0 +1,16 @@
+const PLACEHOLDER_PATTERN = /\{([a-z_]+)\}/g;
+
+/** Account-specific `{placeholder}` fields a templated endpoint URL needs filled. */
+export function templatePlaceholders(baseUrl: string): string[] {
+  return [...baseUrl.matchAll(PLACEHOLDER_PATTERN)].map((match) => match[1]);
+}
+
+export function fillTemplate(baseUrl: string, values: Record<string, string>): string {
+  return baseUrl.replaceAll(PLACEHOLDER_PATTERN, (whole, key: string) => values[key] ?? whole);
+}
+
+/** Whether every `{placeholder}` was substituted. An unfilled one would silently request a literal
+ * `{account_id}` URL, so callers refuse the binding instead. */
+export function isTemplateFilled(baseUrl: string): boolean {
+  return templatePlaceholders(baseUrl).length === 0;
+}
diff --git a/packages/foundation/providers/tsconfig.json b/packages/foundation/providers/tsconfig.json
new file mode 100644
index 000000000..bf8a6170f
--- /dev/null
+++ b/packages/foundation/providers/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}
diff --git a/packages/foundation/schema/src/model/account.ts b/packages/foundation/schema/src/model/account.ts
index 3a7ef456f..0603549fb 100644
--- a/packages/foundation/schema/src/model/account.ts
+++ b/packages/foundation/schema/src/model/account.ts
@@ -31,7 +31,8 @@ export const AccountCredentialSchema = z.discriminatedUnion('type', [
 ]);
 export type AccountCredential = z.infer<typeof AccountCredentialSchema>;
 
-/** A custom endpoint (gateway / relay / local translator). Absent means the agent's native default. */
+/** An explicitly named endpoint: a custom account's own, or the local translator's. Outranks the
+ * service catalog; absent means the endpoint is resolved per agent from `service`. */
 export const AccountEndpointSchema = z.object({
   baseUrl: z.url(),
   protocol: AccountProtocolSchema,
@@ -44,11 +45,15 @@ export const AccountSchema = z.object({
   /** User-facing name. */
   label: z.string().min(1),
   /** Service-catalog key the account was created from (e.g. `openrouter`). Drives brand
-   * presentation and, when `endpoint` is absent, implies the protocol a bare key speaks.
+   * presentation and, when `endpoint` is absent, resolves the endpoint each agent uses.
    * Absent for custom and pre-catalog accounts. */
   service: z.string().optional(),
   credential: AccountCredentialSchema,
   endpoint: AccountEndpointSchema.optional(),
+  /** Values for a catalog endpoint's `{placeholder}` segments (e.g. Cloudflare's account and
+   * 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(),
   /** Extra environment injected into the agent process (escape hatch, e.g. gateway flags). */
diff --git a/packages/foundation/schema/src/wire/message.ts b/packages/foundation/schema/src/wire/message.ts
index d50bc63c6..8445c3c4a 100644
--- a/packages/foundation/schema/src/wire/message.ts
+++ b/packages/foundation/schema/src/wire/message.ts
@@ -9,7 +9,7 @@ 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 = 72 as const;
+export const WIRE_PROTOCOL_VERSION = 73 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. */
diff --git a/packages/host/agent-adapter/AGENTS.md b/packages/host/agent-adapter/AGENTS.md
index 05d652ed4..a4d0e70f0 100644
--- a/packages/host/agent-adapter/AGENTS.md
+++ b/packages/host/agent-adapter/AGENTS.md
@@ -113,7 +113,9 @@ 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.
 
-- **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` (providerID = before `/` in model); pi → `authStorage.setRuntimeApiKey`; grok-build → `XAI_API_KEY` in the headless process env.
+- **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).
 - **Interactive login** (`login.ts` dispatcher `startAgentCliLogin`, kinds in `AGENT_LOGIN_KINDS`): claude-code drives `claude auth login --claudeai` (remote callback page; the user pastes the code back via stdin); codex drives `account/login/start {type:'chatgpt'}` on a short-lived app-server (`native/codex/login.ts`) whose OWN localhost callback completes the flow — no code hand-back (`submitCode` is a no-op), settle = `account/login/completed {success, error?}`. Auth probing: claude `auth status --json` (stdout, structured); codex `login status` (TEXT only — signed-out rides STDERR + exit 1, parse both streams; `parseCodexLoginStatus` fails open on rewording).
 - **Fixed bypass visibility**: Pi's in-process tools and Grok Build's headless `--permission-mode bypassPermissions` have no interactive approval path. Both advertise a single `bypassPermissions` policy with an explicit non-switchable description; this is visibility only, never a claim that approval is available. `set-approval-policy` continues to reject.
 - **Cancellation**: codex `turn/interrupt` (queued prompts dropped; a cancel before the turn id is known is armed and fired on arrival); pi `session.abort()`; opencode `client.session.abort({sessionID, directory})` with the wait capped at 2s (opencode has blocked the abort RPC until the running tool exits — tens of seconds on 1.14.42+; the local cancel proceeds and the abort settles server-side); claude-code `Query#interrupt()` — if no terminal frame arrives before its ack, the old Query is detached and the next prompt rebuilds from the last session id so late cancellation fallout cannot settle a new turn; grok-build kills the active headless process. After any cancel, base `send()` also calls `teardown()`.
diff --git a/packages/host/agent-adapter/src/__tests__/opencode.test.ts b/packages/host/agent-adapter/src/__tests__/opencode.test.ts
index 678818e96..06a505c09 100644
--- a/packages/host/agent-adapter/src/__tests__/opencode.test.ts
+++ b/packages/host/agent-adapter/src/__tests__/opencode.test.ts
@@ -1382,6 +1382,37 @@ describe('OpenCodeAdapter server spawn (CODE-242)', () => {
     expect(typeof opts.port).toBe('number');
     expect(opts.port).not.toBe(4096);
   });
+
+  it('injects the credential under the resolved known provider when the model names none', async () => {
+    const seen: unknown[] = [];
+    sdkMock.createOpencode = (opts: unknown) => {
+      seen.push(opts);
+      client = new FakeClient();
+      return Promise.resolve({ client, server: { url: 'http://fake', close: closeServer } });
+    };
+    const adapter = new OpenCodeAdapter();
+    adapter.onEvent(noop);
+
+    await adapter.start({
+      kind: 'opencode',
+      cwd: '/tmp/repo',
+      model: 'gpt-5.5',
+      config: {
+        apiKey: 'sk-test',
+        baseUrl: 'https://api.openai.com/v1',
+        knownProvider: 'openai',
+      },
+    });
+
+    // Without the resolved provider id, a bare model id left the spawn unauthenticated.
+    expect(seen[0]).toMatchObject({
+      config: {
+        provider: {
+          openai: { options: { apiKey: 'sk-test', baseURL: 'https://api.openai.com/v1' } },
+        },
+      },
+    });
+  });
 });
 
 describe('OpenCodeAdapter server spawn retry', () => {
diff --git a/packages/host/agent-adapter/src/__tests__/pi-model.test.ts b/packages/host/agent-adapter/src/__tests__/pi-model.test.ts
index d1dfd78c3..55f9e053b 100644
--- a/packages/host/agent-adapter/src/__tests__/pi-model.test.ts
+++ b/packages/host/agent-adapter/src/__tests__/pi-model.test.ts
@@ -139,6 +139,24 @@ describe('Pi dynamic model catalog', () => {
     expect(catalog.models).toContainEqual(expect.objectContaining({ id: 'openai/gpt' }));
   });
 
+  it('targets the resolved known provider', async () => {
+    await new PiAdapter().startCatalog({
+      config: {
+        apiKey: 'account-key',
+        baseUrl: 'https://gateway.example.test/v1',
+        knownProvider: 'openai',
+      },
+    });
+
+    // No model ref names a provider, so without the resolved id this would target whichever
+    // provider happened to be first available.
+    expect(sdk.setRuntimeApiKey).toHaveBeenCalledWith('openai', 'account-key');
+    expect(sdk.registerProvider).toHaveBeenCalledWith('openai', {
+      baseUrl: 'https://gateway.example.test/v1',
+      apiKey: 'account-key',
+    });
+  });
+
   it('switches model and effort live and reflects SDK readback', async () => {
     const { adapter, events } = await start();
     events.length = 0;
@@ -179,4 +197,34 @@ describe('Pi native resume', () => {
     expect(sdk.open).toHaveBeenCalledWith(file);
     expect(sdk.createOptions).toMatchObject({ cwd: '/saved/cwd', sessionManager: manager });
   });
+
+  it('injects the credential under the provider the session last routed through', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'pi-resume-'));
+    vi.stubEnv('PI_CODING_AGENT_DIR', root);
+    mkdirSync(join(root, 'sessions', 'slug'), { recursive: true });
+    writeFileSync(join(root, 'sessions', 'slug', '2026_resume-id.jsonl'), '');
+    sdk.open.mockReturnValue({
+      getBranch: () => [{ type: 'model_change', provider: 'other', modelId: 'nulls' }],
+      getCwd: () => '/saved/cwd',
+    });
+    const adapter = new PiAdapter();
+    adapter.onEvent(noop);
+
+    await adapter.resumeHistory(
+      { historyId: asHistoryId('resume-id') },
+      {
+        kind: 'pi',
+        cwd: '/caller',
+        config: {
+          apiKey: 'account-key',
+          baseUrl: 'https://gateway.example.test/v1',
+          knownProvider: 'openai',
+        },
+      },
+    );
+
+    // The session's own last-routed provider outranks the account's catalog default: registering
+    // the key under `openai` would leave the model pi actually resumes without credentials.
+    expect(sdk.setRuntimeApiKey).toHaveBeenCalledWith('other', 'account-key');
+  });
 });
diff --git a/packages/host/agent-adapter/src/credential.ts b/packages/host/agent-adapter/src/credential.ts
index 8850ed359..b3075fd25 100644
--- a/packages/host/agent-adapter/src/credential.ts
+++ b/packages/host/agent-adapter/src/credential.ts
@@ -13,6 +13,9 @@ export interface AgentCredential {
   authToken?: string;
   /** Custom endpoint (gateway / relay / local translator). */
   baseUrl?: string;
+  /** This endpoint's id in the agent's own provider catalog, when it has one. Provider-routed
+   * agents (opencode, pi) inject the credential under it instead of guessing a provider. */
+  knownProvider?: string;
   /** Extra environment for the agent process. */
   extraEnv?: Record<string, string>;
 }
@@ -25,6 +28,7 @@ export function readAgentCredential(config: StartOptions['config']): AgentCreden
     apiKey: readString(config.apiKey),
     authToken: readString(config.authToken),
     baseUrl: readString(config.baseUrl),
+    knownProvider: readString(config.knownProvider),
     ...(extraEnv && { extraEnv }),
   };
 }
diff --git a/packages/host/agent-adapter/src/native/opencode/adapter.ts b/packages/host/agent-adapter/src/native/opencode/adapter.ts
index 40b46466b..4d91fc8b0 100644
--- a/packages/host/agent-adapter/src/native/opencode/adapter.ts
+++ b/packages/host/agent-adapter/src/native/opencode/adapter.ts
@@ -297,7 +297,9 @@ export class OpenCodeAdapter extends BaseAgentAdapter {
         // pre-adoption behavior for this path.
       }
     }
-    const providerID = opts.model?.includes('/') ? opts.model.split('/', 1)[0] : undefined;
+    // The model ref decides routing (prompts carry `{providerID, modelID}`), so it wins; the
+    // resolved known provider covers the common case of a model id typed without one.
+    const providerID = opts.model?.includes('/') ? opts.model.split('/', 1)[0] : cred.knownProvider;
     const options: { apiKey?: string; baseURL?: string } = {};
     const key = cred.apiKey ?? cred.authToken;
     if (key) options.apiKey = key;
diff --git a/packages/host/agent-adapter/src/native/pi/adapter.ts b/packages/host/agent-adapter/src/native/pi/adapter.ts
index cd1f85053..eb3519a92 100644
--- a/packages/host/agent-adapter/src/native/pi/adapter.ts
+++ b/packages/host/agent-adapter/src/native/pi/adapter.ts
@@ -144,12 +144,23 @@ function createConfiguredRegistry(
 
   const cred = readAgentCredential(opts.config);
   const key = cred.apiKey ?? cred.authToken;
-  const provider = ref?.provider ?? fallbackProvider ?? modelRegistry.getAvailable()[0]?.provider;
+  // The model ref decides which provider pi routes through, so it wins; a resumed session's own
+  // last-routed provider comes next, being direct evidence rather than a catalog default; the
+  // resolved known provider only replaces the "first available provider" guess.
+  const provider =
+    ref?.provider ??
+    fallbackProvider ??
+    cred.knownProvider ??
+    modelRegistry.getAvailable()[0]?.provider;
   if (!provider && (key || cred.baseUrl)) {
     throw new Error('pi: cannot target credential without a provider/model');
   }
   if (key && provider) authStorage.setRuntimeApiKey(provider, key);
   if (cred.baseUrl) {
+    // baseUrl override only: a models-less registerProvider rewrites the URL and leaves each
+    // model's wire at pi's built-in value, so this works exactly when that provider's built-in
+    // wire already matches the endpoint. Pointing a provider at a differently-shaped endpoint is
+    // not expressible without supplying full model metadata (see @linkcode/providers AGENTS.md).
     modelRegistry.registerProvider(provider, {
       baseUrl: cred.baseUrl,
       ...(key && { apiKey: key }),
diff --git a/packages/host/assets/src/pi-closure.gen.ts b/packages/host/assets/src/pi-closure.gen.ts
index 42702498b..8d43fd66e 100644
--- a/packages/host/assets/src/pi-closure.gen.ts
+++ b/packages/host/assets/src/pi-closure.gen.ts
@@ -1088,9 +1088,9 @@ const packages: NpmClosure['packages'] = [
   },
   {
     name: 'jose',
-    version: '6.2.4',
+    version: '6.2.7',
     integrity:
-      'sha512-N8acGzVsQy6M/fjFcxtysNc4Q379TcM5dM/qKkNtsHFji88yANnXTr7BLeP75iPnFwBfQzM/jg2BZ9+HZrHCZA==',
+      'sha512-hq1OB1bALKfydZNoViyg6hPVGV4i93ny9Op+n4zP5RSf7SCZEXa/TsG2O3IEr7+WlHRTPnpqDmHfMH6qXAD60w==',
     path: 'node_modules/jose',
   },
   {
@@ -1622,7 +1622,7 @@ const packages: NpmClosure['packages'] = [
 
 export const PI_CLOSURE: NpmClosure = {
   version: '0.80.6',
-  revision: 'b77bf10e9a04fe3f',
+  revision: 'd6ff0228b84fa10c',
   entry: 'node_modules/@earendil-works/pi-coding-agent/dist/index.js',
   packages,
 };
diff --git a/packages/host/engine/package.json b/packages/host/engine/package.json
index 5750e56b8..966c8ac49 100644
--- a/packages/host/engine/package.json
+++ b/packages/host/engine/package.json
@@ -14,6 +14,7 @@
   "dependencies": {
     "@linkcode/agent-adapter": "workspace:*",
     "@linkcode/common": "workspace:*",
+    "@linkcode/providers": "workspace:*",
     "@linkcode/schema": "workspace:*",
     "@linkcode/transport": "workspace:*",
     "acorn": "^8.17.0",
diff --git a/packages/host/engine/src/__tests__/provider-config.test.ts b/packages/host/engine/src/__tests__/provider-config.test.ts
index e26263cba..363672d00 100644
--- a/packages/host/engine/src/__tests__/provider-config.test.ts
+++ b/packages/host/engine/src/__tests__/provider-config.test.ts
@@ -7,20 +7,22 @@ const baseOpts: StartOptions = { kind: 'codex', cwd: '/repo' };
 describe('applyProviderDefaults', () => {
   it('returns the input untouched when no config exists for the kind', () => {
     const providers: ProvidersConfig = { 'claude-code': { enabled: true, apiKey: 'sk-x' } };
-    expect(applyProviderDefaults(baseOpts, providers)).toBe(baseOpts);
+    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' } };
-    expect(applyProviderDefaults(baseOpts, providers).model).toBe('o4-mini');
-    expect(applyProviderDefaults({ ...baseOpts, model: 'gpt-4o' }, providers).model).toBe('gpt-4o');
-    expect(applyProviderDefaults({ ...baseOpts, model: null }, providers).model).toBeNull();
+    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', () => {
     const providers: ProvidersConfig = { codex: { enabled: true, apiKey: 'sk-live' } };
     const merged = applyProviderDefaults({ ...baseOpts, config: { tools: ['a'] } }, providers);
-    expect(merged.config).toEqual({ tools: ['a'], apiKey: 'sk-live' });
+    expect(merged.options.config).toEqual({ tools: ['a'], apiKey: 'sk-live' });
   });
 
   it('does not mutate the input options', () => {
@@ -43,7 +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]).config).toEqual({
+    expect(applyProviderDefaults(baseOpts, providers, [account]).options.config).toEqual({
       apiKey: 'sk-acc',
     });
   });
@@ -61,40 +63,77 @@ describe('applyProviderDefaults account pool', () => {
       providers,
       [account, other],
     );
-    expect(merged.config).toMatchObject({ apiKey: 'sk-other' });
+    expect(merged.options.config).toMatchObject({ apiKey: 'sk-other' });
   });
 
   it('injects authToken, baseUrl and protocol for an auth-token account with an endpoint', () => {
     const gateway: Account = {
       id: 'gw',
-      label: 'OpenRouter',
+      label: 'Relay',
       credential: { type: 'auth-token', token: 'or-tok' },
-      endpoint: { baseUrl: 'https://openrouter.ai/api', protocol: 'anthropic' },
+      endpoint: { baseUrl: 'https://relay.example.com/v1', protocol: 'openai-responses' },
       createdAt: 0,
     };
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'gw' } };
     const merged = applyProviderDefaults(baseOpts, providers, [gateway]);
-    expect(merged.config).toEqual({
+    expect(merged.options.config).toEqual({
       authToken: 'or-tok',
-      baseUrl: 'https://openrouter.ai/api',
-      protocol: 'anthropic',
+      baseUrl: 'https://relay.example.com/v1',
+      protocol: 'openai-responses',
     });
   });
 
+  it('reports an account whose endpoint the agent cannot speak instead of injecting it', () => {
+    const anthropicOnly: Account = {
+      id: 'gw',
+      label: 'OpenRouter',
+      credential: { type: 'auth-token', token: 'or-tok' },
+      endpoint: { baseUrl: 'https://openrouter.ai/api', protocol: 'anthropic' },
+      createdAt: 0,
+    };
+    const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'gw' } };
+    const merged = applyProviderDefaults(baseOpts, providers, [anthropicOnly]);
+    expect(merged.unavailable).toBe('protocol-unsupported');
+    expect(merged.options.config?.baseUrl).toBeUndefined();
+  });
+
+  it('resolves a catalog service to the endpoint the bound agent speaks', () => {
+    const openai: Account = {
+      id: 'oa',
+      label: 'OpenAI',
+      service: 'openai-api',
+      credential: { type: 'api-key', key: 'sk-oa' },
+      createdAt: 0,
+    };
+    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({
+      apiKey: 'sk-oa',
+      baseUrl: 'https://api.openai.com/v1',
+      protocol: 'openai-responses',
+    });
+    const forOpencode = applyProviderDefaults(
+      { ...baseOpts, kind: 'opencode' },
+      { opencode: { enabled: true, activeAccountId: 'oa' } },
+      [openai],
+    );
+    expect(forOpencode.options.config).toMatchObject({ knownProvider: 'openai' });
+  });
+
   it('prefers the account model over the provider default model', () => {
     const providers: ProvidersConfig = {
       codex: { enabled: true, defaultModel: 'o4-mini', activeAccountId: 'acc_1' },
     };
-    expect(applyProviderDefaults(baseOpts, providers, [{ ...account, model: 'gpt-5' }]).model).toBe(
-      'gpt-5',
-    );
+    expect(
+      applyProviderDefaults(baseOpts, providers, [{ ...account, model: 'gpt-5' }]).options.model,
+    ).toBe('gpt-5');
   });
 
   it('falls back to the legacy apiKey when the bound account id is stale', () => {
     const providers: ProvidersConfig = {
       codex: { enabled: true, apiKey: 'sk-legacy', activeAccountId: 'deleted' },
     };
-    expect(applyProviderDefaults(baseOpts, providers, [account]).config).toEqual({
+    expect(applyProviderDefaults(baseOpts, providers, [account]).options.config).toEqual({
       apiKey: 'sk-legacy',
     });
   });
@@ -107,7 +146,7 @@ describe('applyProviderDefaults account pool', () => {
       createdAt: 0,
     };
     const providers: ProvidersConfig = { codex: { enabled: true, activeAccountId: 'oauth_1' } };
-    expect(applyProviderDefaults(baseOpts, providers, [oauth]).config).toEqual({});
+    expect(applyProviderDefaults(baseOpts, providers, [oauth]).options.config).toEqual({});
   });
 });
 
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 b1084c288..74e7114f1 100644
--- a/packages/host/engine/src/__tests__/start-options-mcp.test.ts
+++ b/packages/host/engine/src/__tests__/start-options-mcp.test.ts
@@ -1,5 +1,12 @@
 import type { PluginProviderAdapterFactory } from '@linkcode/agent-adapter';
-import type { CustomMcpServer, McpServer, PluginProvider, SessionId } from '@linkcode/schema';
+import type {
+  Account,
+  AgentKind,
+  CustomMcpServer,
+  McpServer,
+  PluginProvider,
+  SessionId,
+} from '@linkcode/schema';
 import { PluginSchema } from '@linkcode/schema';
 import { Effect } from 'effect';
 import { noop } from 'foxts/noop';
@@ -149,6 +156,53 @@ describe('simulator MCP injection at session start', () => {
   });
 });
 
+describe('account binding at session start', () => {
+  function storeWith(account: Account, agent: AgentKind): InMemoryProviderConfigStore {
+    const store = new InMemoryProviderConfigStore();
+    store.createAndBindAccount(agent, account);
+    return store;
+  }
+
+  const account = (overrides: Partial<Account>): Account => ({
+    id: 'acc_1',
+    label: 'Test',
+    credential: { type: 'api-key', key: 'sk-test' },
+    createdAt: 0,
+    ...overrides,
+  });
+
+  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' },
+    });
+    const resolver = new SessionStartOptionsResolver(storeWith(anthropicOnly, 'codex'), undefined);
+
+    // Starting anyway would point codex at an endpoint that answers 404 on /responses.
+    await expect(
+      Effect.runPromise(resolver.resolve({ kind: 'codex', cwd: '/repo' }, SESSION)),
+    ).rejects.toThrow('cannot back codex');
+  });
+
+  it('starts an account the pre-variant add flow pinned to one endpoint', async () => {
+    // Written by the old add flow for the `openai-api` catalog entry. It starts codex fine today,
+    // so honoring the pinned `openai-chat` protocol would break it on upgrade.
+    const upgraded = account({
+      service: 'openai-api',
+      endpoint: { baseUrl: 'https://api.openai.com/v1', protocol: 'openai-chat' },
+    });
+    const resolver = new SessionStartOptionsResolver(storeWith(upgraded, 'codex'), undefined);
+
+    const { options } = await Effect.runPromise(
+      resolver.resolve({ kind: 'codex', cwd: '/repo' }, SESSION),
+    );
+    expect(options.config).toMatchObject({
+      apiKey: 'sk-test',
+      baseUrl: 'https://api.openai.com/v1',
+      protocol: 'openai-responses',
+    });
+  });
+});
+
 describe('custom MCP injection at session start', () => {
   it('folds enabled custom servers in for claude-code, codex, and opencode', async () => {
     for (const kind of ['claude-code', 'codex', 'opencode'] as const) {
diff --git a/packages/host/engine/src/agent/provider-config.ts b/packages/host/engine/src/agent/provider-config.ts
index 7cc61f939..b2872f022 100644
--- a/packages/host/engine/src/agent/provider-config.ts
+++ b/packages/host/engine/src/agent/provider-config.ts
@@ -1,3 +1,5 @@
+import type { BindingUnavailableReason } from '@linkcode/providers';
+import { resolveBinding } from '@linkcode/providers';
 import type {
   Account,
   Accounts,
@@ -92,18 +94,30 @@ function resolveAccount(
 
 /** The adapter-facing bundle an account contributes to `StartOptions.config`; each adapter maps
  * the keys to its own env/options. An `oauth` account injects no secret — it delegates to the
- * agent CLI's own login store. */
-function accountConfigBundle(account: Account): Record<string, unknown> {
+ * agent CLI's own login store. The endpoint is resolved per agent, so one account can serve
+ * several natively. */
+function accountConfigBundle(
+  account: Account,
+  kind: AgentKind,
+): { bundle: Record<string, unknown> } | { unavailable: BindingUnavailableReason } {
+  const binding = resolveBinding(account, kind);
+  if (binding.tier === 'unavailable') return { unavailable: binding.reason };
   const bundle: Record<string, unknown> = {};
-  const { credential, endpoint, extraEnv } = account;
+  const { credential, extraEnv } = account;
   if (credential.type === 'api-key') bundle.apiKey = credential.key;
   else if (credential.type === 'auth-token') bundle.authToken = credential.token;
-  if (endpoint) {
-    bundle.baseUrl = endpoint.baseUrl;
-    bundle.protocol = endpoint.protocol;
-  }
+  if (binding.baseUrl !== undefined) bundle.baseUrl = binding.baseUrl;
+  if (binding.protocol !== undefined) bundle.protocol = binding.protocol;
+  if (binding.knownProvider !== undefined) bundle.knownProvider = binding.knownProvider;
   if (extraEnv) bundle.extraEnv = extraEnv;
-  return bundle;
+  return { bundle };
+}
+
+export interface AppliedProviderDefaults {
+  readonly options: StartOptions;
+  /** Why the bound account cannot back this agent. A session must refuse to start rather than
+   * run against an endpoint the agent cannot speak; pre-session reads may ignore it. */
+  readonly unavailable?: BindingUnavailableReason;
 }
 
 /** Apply the stored config to a session's StartOptions: resolve the bound account (or legacy
@@ -113,10 +127,10 @@ export function applyProviderDefaults(
   opts: StartOptions,
   providers: ProvidersConfig,
   accounts: Accounts = [],
-): StartOptions {
+): AppliedProviderDefaults {
   const config = providers[opts.kind];
   const account = resolveAccount(opts, config, accounts);
-  if (!config && !account) return opts;
+  if (!config && !account) return { options: opts };
 
   const next: StartOptions = { ...opts };
   if (next.model === undefined) {
@@ -124,10 +138,12 @@ export function applyProviderDefaults(
     if (model !== undefined) next.model = model;
   }
   if (account) {
-    next.config = { ...next.config, ...accountConfigBundle(account) };
+    const resolved = accountConfigBundle(account, opts.kind);
+    if ('unavailable' in resolved) return { options: next, unavailable: resolved.unavailable };
+    next.config = { ...next.config, ...resolved.bundle };
   } else if (config?.apiKey !== undefined) {
     // Legacy: no account bound — fall back to the provider's bare api key.
     next.config = { ...next.config, apiKey: config.apiKey };
   }
-  return next;
+  return { options: next };
 }
diff --git a/packages/host/engine/src/agent/request-handler.ts b/packages/host/engine/src/agent/request-handler.ts
index 5fc22b664..76a1d2238 100644
--- a/packages/host/engine/src/agent/request-handler.ts
+++ b/packages/host/engine/src/agent/request-handler.ts
@@ -50,7 +50,9 @@ export class AgentRequestHandler {
           payload.clientReqId,
           Effect.tryPromise({
             try: async () => {
-              const startOptions = applyProviderDefaults(
+              // A pre-session read: an account the agent cannot bind still names the model list
+              // worth showing, so `unavailable` is deliberately not fatal here.
+              const { options: startOptions } = applyProviderDefaults(
                 { kind: payload.agentKind, cwd: payload.cwd ?? '.' },
                 this.providers.get(),
                 this.providers.getAccounts(),
diff --git a/packages/host/engine/src/session/start-options-resolver.ts b/packages/host/engine/src/session/start-options-resolver.ts
index 3524c6e04..91566d020 100644
--- a/packages/host/engine/src/session/start-options-resolver.ts
+++ b/packages/host/engine/src/session/start-options-resolver.ts
@@ -41,7 +41,17 @@ export class SessionStartOptionsResolver {
     const withCustomMcpServers = this.withCustomMcpServers.bind(this);
     const withSimulatorMcp = this.withSimulatorMcp.bind(this);
     return Effect.gen(function* () {
-      const custom = yield* withCustomMcpServers(defaults);
+      if (defaults.unavailable) {
+        // Starting anyway would point the agent at an endpoint it cannot speak, which surfaces
+        // much later as an opaque 404 from the provider.
+        return yield* Effect.fail(
+          new RequestError({
+            code: 'unsupported',
+            message: `The bound account cannot back ${options.kind} (${defaults.unavailable})`,
+          }),
+        );
+      }
+      const custom = yield* withCustomMcpServers(defaults.options);
       const resolved = withSimulatorMcp(custom.options, sessionId);
       const upstream = translationUpstream(resolved);
       if (!upstream) return { options: resolved, warnings: custom.warnings };
diff --git a/packages/presentation/i18n/src/locales/en.ts b/packages/presentation/i18n/src/locales/en.ts
index 4f58424ff..9ddcecb96 100644
--- a/packages/presentation/i18n/src/locales/en.ts
+++ b/packages/presentation/i18n/src/locales/en.ts
@@ -1024,6 +1024,7 @@ export const en = {
       hideSecret: 'Hide',
       copySecret: 'Copy',
       endpoint: 'Endpoint',
+      protocols: 'Protocol shapes',
       accountModel: 'Default model',
       loginState: 'Login',
       loggedIn: 'Signed in',
@@ -1038,7 +1039,7 @@ export const en = {
       translateNote: 'A local gateway translates Anthropic wire to OpenAI Chat',
       unavailableOauth: 'Only connects to {agent}',
       unavailableProtocol: 'The endpoint protocol is incompatible with this agent',
-      unavailableTranslationEndpoint: 'Translated routing needs an endpoint URL',
+      unavailableEndpointIncomplete: 'Endpoint details are incomplete — finish the account setup',
       modelDefault: 'Default',
       configPreview: 'config.json snippet · what this account writes',
       configPreviewEmpty: '// not connected to any agent yet',
@@ -1060,9 +1061,11 @@ export const en = {
         'anthropic-api': 'Anthropic API',
         'openai-api': 'OpenAI API',
         xai: 'xAI (Grok)',
+        deepseek: 'DeepSeek',
         openrouter: 'OpenRouter',
         'vercel-gateway': 'Vercel AI Gateway',
         'cloudflare-gateway': 'Cloudflare AI Gateway',
+        'cloudflare-anthropic': 'Cloudflare AI Gateway (Anthropic)',
         custom: 'Custom endpoint',
       },
       serviceHint: {
@@ -1070,27 +1073,19 @@ export const en = {
         'chatgpt-sub': 'Codex login, Plus / Pro plans',
         'anthropic-api': 'A key from console.anthropic.com',
         'openai-api': 'A key from platform.openai.com',
-        xai: 'A key from console.x.ai, OpenAI-compatible',
-        openrouter: 'Aggregation gateway, both protocol shapes',
-        'vercel-gateway': 'Server-side translation, both protocol shapes',
-        'cloudflare-gateway': 'Pass-through gateway, needs Account / Gateway ID',
+        xai: 'A key from console.x.ai',
+        deepseek: 'A key from platform.deepseek.com',
+        openrouter: 'Aggregation gateway',
+        'vercel-gateway': 'Server-side translating gateway',
+        'cloudflare-gateway': 'Compatibility gateway, needs Account / Gateway ID',
+        'cloudflare-anthropic':
+          'Pass-through gateway, needs an Anthropic key and Account / Gateway ID',
         custom: 'Any base URL + protocol',
       },
-      variantName: {
-        anthropic: 'Anthropic endpoint',
-        'openai-chat': 'OpenAI endpoint',
-        'openai-responses': 'OpenAI Responses endpoint',
-      },
-      variantNote: {
-        anthropic: 'Native for Claude Code',
-        'openai-chat': 'Native for Codex / OpenCode; Claude Code via local translation',
-        'openai-responses': 'Native for Codex',
-      },
       oauthEditHint:
         'Subscription credentials follow the CLI login; only the account name can be changed here.',
       form: {
         label: 'Name',
-        variant: 'Protocol shape',
         model: 'Default model (optional)',
         submit: 'Add account',
         save: 'Save changes',
diff --git a/packages/presentation/i18n/src/locales/zh-cn.ts b/packages/presentation/i18n/src/locales/zh-cn.ts
index 59cf01fd2..6978c1234 100644
--- a/packages/presentation/i18n/src/locales/zh-cn.ts
+++ b/packages/presentation/i18n/src/locales/zh-cn.ts
@@ -998,6 +998,7 @@ export const zhCN = {
       hideSecret: '隐藏',
       copySecret: '复制',
       endpoint: '端点',
+      protocols: '协议形态',
       accountModel: '默认模型',
       loginState: '登录状态',
       loggedIn: '已登录',
@@ -1012,7 +1013,7 @@ export const zhCN = {
       translateNote: '本地网关将 Anthropic 协议转为 OpenAI Chat',
       unavailableOauth: '仅可接入 {agent}',
       unavailableProtocol: '端点协议与此智能体不兼容',
-      unavailableTranslationEndpoint: '经转换接入需要端点 URL',
+      unavailableEndpointIncomplete: '端点信息不完整,请补全账号设置',
       modelDefault: '默认',
       configPreview: 'config.json 片段 · 此账号写入的内容',
       configPreviewEmpty: '// 尚未接入任何智能体',
@@ -1034,9 +1035,11 @@ export const zhCN = {
         'anthropic-api': 'Anthropic API',
         'openai-api': 'OpenAI API',
         xai: 'xAI(Grok)',
+        deepseek: 'DeepSeek',
         openrouter: 'OpenRouter',
         'vercel-gateway': 'Vercel AI Gateway',
         'cloudflare-gateway': 'Cloudflare AI Gateway',
+        'cloudflare-anthropic': 'Cloudflare AI Gateway(Anthropic)',
         custom: '自定义端点',
       },
       serviceHint: {
@@ -1044,26 +1047,17 @@ export const zhCN = {
         'chatgpt-sub': 'Codex 登录,Plus / Pro 计划',
         'anthropic-api': 'console.anthropic.com 的密钥',
         'openai-api': 'platform.openai.com 的密钥',
-        xai: 'console.x.ai 的密钥,OpenAI 兼容',
-        openrouter: '聚合网关,双协议形态',
-        'vercel-gateway': '服务端翻译,双协议形态',
-        'cloudflare-gateway': '透传网关,需 Account / Gateway ID',
+        xai: 'console.x.ai 的密钥',
+        deepseek: 'platform.deepseek.com 的密钥',
+        openrouter: '聚合网关',
+        'vercel-gateway': '服务端翻译网关',
+        'cloudflare-gateway': '兼容网关,需 Account / Gateway ID',
+        'cloudflare-anthropic': '透传网关,需 Anthropic 密钥与 Account / Gateway ID',
         custom: '任意 Base URL + 协议',
       },
-      variantName: {
-        anthropic: 'Anthropic 端点',
-        'openai-chat': 'OpenAI 端点',
-        'openai-responses': 'OpenAI Responses 端点',
-      },
-      variantNote: {
-        anthropic: 'Claude Code 原生直连',
-        'openai-chat': 'Codex / OpenCode 原生;Claude Code 经本地转换',
-        'openai-responses': 'Codex 原生',
-      },
       oauthEditHint: '订阅凭证跟随 CLI 登录;这里只能修改账号名称。',
       form: {
         label: '名称',
-        variant: '协议形态',
         model: '默认模型(可选)',
         submit: '添加账号',
         save: '保存更改',
diff --git a/packages/presentation/ui/src/shell/index.ts b/packages/presentation/ui/src/shell/index.ts
index 0d8592db6..a89b8c917 100644
--- a/packages/presentation/ui/src/shell/index.ts
+++ b/packages/presentation/ui/src/shell/index.ts
@@ -19,6 +19,7 @@ export * from './notifications-settings-panel';
 export * from './plugins';
 export * from './providers/account-detail';
 export * from './providers/account-master-list';
+export * from './providers/routing';
 export * from './service-icon';
 export * from './session-sidebar';
 export * from './session-title-menu';
diff --git a/packages/presentation/ui/src/shell/providers/account-detail.tsx b/packages/presentation/ui/src/shell/providers/account-detail.tsx
index daaf86c5a..ed280183a 100644
--- a/packages/presentation/ui/src/shell/providers/account-detail.tsx
+++ b/packages/presentation/ui/src/shell/providers/account-detail.tsx
@@ -36,10 +36,11 @@ import { useTranslations } from 'use-intl';
 import { AgentIcon } from '../../chat/agent-icon';
 import { AGENT_MODEL_OPTIONS } from '../agent-models';
 import { ServiceIcon } from '../service-icon';
+import type { ProviderAccountRouting } from './routing';
 
 export type ProviderBindingStatus =
   | { kind: 'unavailable-oauth'; agent: AgentKind }
-  | { kind: 'unavailable-translation-endpoint' }
+  | { kind: 'unavailable-endpoint-incomplete' }
   | { kind: 'unavailable-protocol' }
   | { kind: 'bound' }
   | { kind: 'no-provider' }
@@ -72,7 +73,7 @@ export interface ProviderAccountDetailViewModel {
   serviceLabel?: string;
   label: string;
   credential: ProviderCredentialViewModel;
-  endpoint?: { baseUrl: string; protocol: string };
+  routing?: ProviderAccountRouting;
   accountModel?: string;
   bindings: ProviderBindingViewModel[];
   boundAgents: AgentKind[];
@@ -184,10 +185,16 @@ export function AccountDetail({
               </Button>
             </DetailRow>
           )}
-          {account.endpoint ? (
+          {account.routing?.kind === 'pinned' ? (
             <DetailRow label={t('endpoint')}>
               <span className="min-w-0 flex-1 truncate font-mono text-muted-foreground text-xs">
-                {account.endpoint.baseUrl} · {account.endpoint.protocol}
+                {account.routing.baseUrl} · {account.routing.protocol}
+              </span>
+            </DetailRow>
+          ) : account.routing?.kind === 'catalog' ? (
+            <DetailRow label={t('protocols')}>
+              <span className="min-w-0 flex-1 truncate font-mono text-muted-foreground text-xs">
+                {account.routing.protocols.join(' · ')}
               </span>
             </DetailRow>
           ) : null}
@@ -311,8 +318,8 @@ function bindingStatusLabel(
   switch (status.kind) {
     case 'unavailable-oauth':
       return t('unavailableOauth', { agent: tAgent(status.agent) });
-    case 'unavailable-translation-endpoint':
-      return t('unavailableTranslationEndpoint');
+    case 'unavailable-endpoint-incomplete':
+      return t('unavailableEndpointIncomplete');
     case 'unavailable-protocol':
       return t('unavailableProtocol');
     case 'bound':
diff --git a/packages/presentation/ui/src/shell/providers/account-master-list.tsx b/packages/presentation/ui/src/shell/providers/account-master-list.tsx
index 101ef3b42..aadef5611 100644
--- a/packages/presentation/ui/src/shell/providers/account-master-list.tsx
+++ b/packages/presentation/ui/src/shell/providers/account-master-list.tsx
@@ -8,14 +8,14 @@ import { ChevronRightIcon, PlusIcon } from 'lucide-react';
 import { useState } from 'react';
 import { useTranslations } from 'use-intl';
 import { ServiceIcon } from '../service-icon';
+import type { ProviderAccountRouting } from './routing';
 
 export interface ProviderAccountListItem {
   id: string;
   service?: string;
   label: string;
   serviceLabel?: string;
-  endpoint?: string;
-  protocol?: string;
+  routing?: ProviderAccountRouting;
   credentialType: 'api-key' | 'auth-token' | 'oauth';
   auth?: { loggedIn: boolean; email?: string };
   boundAgents: AgentKind[];
@@ -61,16 +61,26 @@ export function AccountList({
     return t('credentialAuthToken');
   };
 
-  const accountDetailLine = (account: ProviderAccountListItem): string => {
+  /** Undefined means the row has no second line — the sole decision, so no separate render gate
+   * can disagree with it. Catalog accounts deliberately show nothing: their wire shapes are an
+   * implementation detail the add flow stopped asking about, and this slot has no label to give
+   * bare protocol names any meaning (the detail pane shows them under `t('protocols')`). */
+  const accountDetailLine = (account: ProviderAccountListItem): string | undefined => {
     if (account.auth?.loggedIn === true) return account.auth.email ?? t('loggedIn');
     if (account.auth) return t('loggedOut');
-    return [account.endpoint, account.protocol].filter(Boolean).join(' · ');
+    return account.routing?.kind === 'pinned'
+      ? `${account.routing.baseUrl} · ${account.routing.protocol}`
+      : undefined;
   };
 
   const needle = query.trim().toLowerCase();
   const rows = needle
     ? accounts.filter((account) =>
-        [account.label, account.serviceLabel ?? '', account.endpoint ?? '']
+        [
+          account.label,
+          account.serviceLabel ?? '',
+          account.routing?.kind === 'pinned' ? account.routing.baseUrl : '',
+        ]
           .join(' ')
           .toLowerCase()
           .includes(needle),
@@ -114,46 +124,53 @@ export function AccountList({
               </li>
             </>
           ) : null}
-          {rows.map((account) => (
-            <li key={account.id}>
-              <button
-                type="button"
-                className="flex w-full items-center gap-3 px-4 py-3.5 text-left transition-colors hover:bg-muted/50"
-                onClick={() => onSelect(account.id)}
-              >
-                <ServiceIcon service={account.service} label={account.label} className="size-10" />
-                <span className="min-w-0 flex-1">
-                  <span className="block truncate font-medium text-sm">{account.label}</span>
-                  <span className="block truncate text-muted-foreground text-xs">
-                    {account.serviceLabel ?? t('customService')} · {credentialLabel(account)}
-                  </span>
-                  {account.auth !== undefined || account.endpoint !== undefined ? (
+          {rows.map((account) => {
+            const detailLine = accountDetailLine(account);
+            return (
+              <li key={account.id}>
+                <button
+                  type="button"
+                  className="flex w-full items-center gap-3 px-4 py-3.5 text-left transition-colors hover:bg-muted/50"
+                  onClick={() => onSelect(account.id)}
+                >
+                  <ServiceIcon
+                    service={account.service}
+                    label={account.label}
+                    className="size-10"
+                  />
+                  <span className="min-w-0 flex-1">
+                    <span className="block truncate font-medium text-sm">{account.label}</span>
                     <span className="block truncate text-muted-foreground text-xs">
-                      {accountDetailLine(account)}
+                      {account.serviceLabel ?? t('customService')} · {credentialLabel(account)}
                     </span>
-                  ) : null}
-                </span>
-                <span className="hidden max-w-60 flex-wrap justify-end gap-1 sm:flex">
-                  {account.boundAgents.length === 0 ? (
-                    <Badge
-                      variant="outline"
-                      size="sm"
-                      className="rounded-full border-dashed text-muted-foreground"
-                    >
-                      {t('unbound')}
-                    </Badge>
-                  ) : (
-                    account.boundAgents.map((kind) => (
-                      <Badge key={kind} variant="outline" size="sm" className="rounded-full">
-                        {tAgent(kind)}
+                    {detailLine ? (
+                      <span className="block truncate text-muted-foreground text-xs">
+                        {detailLine}
+                      </span>
+                    ) : null}
+                  </span>
+                  <span className="hidden max-w-60 flex-wrap justify-end gap-1 sm:flex">
+                    {account.boundAgents.length === 0 ? (
+                      <Badge
+                        variant="outline"
+                        size="sm"
+                        className="rounded-full border-dashed text-muted-foreground"
+                      >
+                        {t('unbound')}
                       </Badge>
-                    ))
-                  )}
-                </span>
-                <ChevronRightIcon className="size-4 shrink-0 text-muted-foreground" />
-              </button>
-            </li>
-          ))}
+                    ) : (
+                      account.boundAgents.map((kind) => (
+                        <Badge key={kind} variant="outline" size="sm" className="rounded-full">
+                          {tAgent(kind)}
+                        </Badge>
+                      ))
+                    )}
+                  </span>
+                  <ChevronRightIcon className="size-4 shrink-0 text-muted-foreground" />
+                </button>
+              </li>
+            );
+          })}
           {!loading && needle && rows.length === 0 ? (
             <li className="px-4 py-12 text-center text-muted-foreground text-sm">
               {t('noMatches')}
diff --git a/packages/presentation/ui/src/shell/providers/routing.ts b/packages/presentation/ui/src/shell/providers/routing.ts
new file mode 100644
index 000000000..42c25a04a
--- /dev/null
+++ b/packages/presentation/ui/src/shell/providers/routing.ts
@@ -0,0 +1,9 @@
+/**
+ * How an account reaches a provider, as one exhaustive axis rather than a set of optional fields
+ * that can contradict each other. An account either pins one endpoint the user named, or leaves
+ * the endpoint to be resolved per agent from the service catalog. Absent covers the accounts that
+ * name no endpoint at all: a CLI login, or a pre-catalog bare key.
+ */
+export type ProviderAccountRouting =
+  | { kind: 'pinned'; baseUrl: string; protocol: string }
+  | { kind: 'catalog'; protocols: string[] };
diff --git a/packages/presentation/ui/src/shell/service-icon.tsx b/packages/presentation/ui/src/shell/service-icon.tsx
index b05459e85..e5f40bafd 100644
--- a/packages/presentation/ui/src/shell/service-icon.tsx
+++ b/packages/presentation/ui/src/shell/service-icon.tsx
@@ -2,6 +2,7 @@
 import AnthropicGlyph from '~icons/lobe-icons/anthropic';
 import ClaudeColorGlyph from '~icons/lobe-icons/claude-color';
 import CloudflareColorGlyph from '~icons/lobe-icons/cloudflare-color';
+import DeepSeekColorGlyph from '~icons/lobe-icons/deepseek-color';
 import OpenAiGlyph from '~icons/lobe-icons/openai';
 import OpenRouterGlyph from '~icons/lobe-icons/openrouter';
 import VercelGlyph from '~icons/lobe-icons/vercel';
@@ -17,9 +18,11 @@ const SERVICE_GLYPHS: Record<string, typeof AnthropicGlyph> = {
   'anthropic-api': AnthropicGlyph,
   'openai-api': OpenAiGlyph,
   xai: XaiGlyph,
+  deepseek: DeepSeekColorGlyph,
   openrouter: OpenRouterGlyph,
   'vercel-gateway': VercelGlyph,
   'cloudflare-gateway': CloudflareColorGlyph,
+  'cloudflare-anthropic': CloudflareColorGlyph,
 };
 
 const WHITESPACE = /\s+/;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1658a9cc1..277d2c132 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -798,6 +798,9 @@ importers:
       '@linkcode/i18n':
         specifier: workspace:*
         version: link:../../presentation/i18n
+      '@linkcode/providers':
+        specifier: workspace:*
+        version: link:../../foundation/providers
       '@linkcode/schema':
         specifier: workspace:*
         version: link:../../foundation/schema
@@ -897,6 +900,15 @@ importers:
         specifier: 'catalog:'
         version: 26.1.1
 
+  packages/foundation/providers:
+    dependencies:
+      '@linkcode/schema':
+        specifier: workspace:*
+        version: link:../schema
+      foxts:
+        specifier: ^5.8.1
+        version: 5.8.1
+
   packages/foundation/schema:
     dependencies:
       canonicalize:
@@ -1053,6 +1065,9 @@ importers:
       '@linkcode/common':
         specifier: workspace:*
         version: link:../../foundation/common
+      '@linkcode/providers':
+        specifier: workspace:*
+        version: link:../../foundation/providers
       '@linkcode/schema':
         specifier: workspace:*
         version: link:../../foundation/schema
@@ -8360,9 +8375,6 @@ packages:
     resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
     hasBin: true
 
-  jose@6.2.4:
-    resolution: {integrity: sha512-N8acGzVsQy6M/fjFcxtysNc4Q379TcM5dM/qKkNtsHFji88yANnXTr7BLeP75iPnFwBfQzM/jg2BZ9+HZrHCZA==}
-
   jose@6.2.7:
     resolution: {integrity: sha512-hq1OB1bALKfydZNoViyg6hPVGV4i93ny9Op+n4zP5RSf7SCZEXa/TsG2O3IEr7+WlHRTPnpqDmHfMH6qXAD60w==}
 
@@ -13952,7 +13964,7 @@ snapshots:
       express: 5.2.1
       express-rate-limit: 8.6.1(express@5.2.1)
       hono: 4.12.32
-      jose: 6.2.4
+      jose: 6.2.7
       json-schema-typed: 8.0.2
       pkce-challenge: 5.0.1
       raw-body: 3.0.2
@@ -18987,8 +18999,6 @@ snapshots:
 
   jiti@2.7.0: {}
 
-  jose@6.2.4: {}
-
   jose@6.2.7: {}
 
   joycon@3.1.1: {}
diff --git a/tsconfig.json b/tsconfig.json
index a0d8412af..e8b7e410c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,6 +19,7 @@
     { "path": "packages/client/workbench" },
     { "path": "packages/client/workbench/tests" },
     { "path": "packages/foundation/common" },
+    { "path": "packages/foundation/providers" },
     { "path": "packages/foundation/schema" },
     { "path": "packages/foundation/schema/tests" },
     { "path": "packages/foundation/transport" },