@stigmer/cli 3.3.0 → 3.4.1

package/src/commands/setup.ts

@@ -1,9 +1,11 @@
 // `stigmer setup` — configure the LLM provider used for agent execution.
 //
 // Two paths share one decision core (local/setup/wizard.ts): a non-interactive
-// flag path (`--provider`, `--api-key`, …) for scripts and CI, and an
-// interactive menu when no provider flag is given. Both write to
-// backend.local.llm, preserving every other config field.
+// flag path (`--provider`, `--api-key`, `--model`) for scripts and CI, and an
+// interactive API-key prompt when no provider flag is given. Both write to
+// backend.local.llm, preserving every other config field. The valid provider
+// set is owned by wizard.ts's PROVIDER_CHOICES (Anthropic-only + skip — the
+// only story the native runner serves).
 
 import type { Command } from "commander";
 import { homedir } from "node:os";
@@ -14,51 +16,42 @@ interface SetupFlags extends OutputFlags {
   provider?: string;
   model?: string;
   apiKey?: string;
-  baseUrl?: string;
 }
 
-const PROVIDERS = ["anthropic", "openai", "ollama", "skip"] as const;
-
 export function registerSetup(program: Command): void {
   const setup = program
     .command("setup")
     .description("configure the LLM provider for agent execution")
-    .option("--provider <name>", "provider: anthropic, openai, ollama, or skip (non-interactive)")
-    .option("--model <name>", "model name (defaults per provider)")
-    .option("--api-key <key>", "API key for a cloud provider")
-    .option("--base-url <url>", "custom base URL (e.g. an Ollama endpoint)")
+    .option("--provider <name>", "provider: anthropic, or skip to clear (non-interactive)")
+    .option("--model <name>", "pin a specific model (defaults to the platform-selected model)")
+    .option("--api-key <key>", "Anthropic API key")
     .action((options: SetupFlags) => runSetup(options));
   addResultFlags(setup);
 }
 
 async function runSetup(options: SetupFlags): Promise<void> {
   const { load, save } = await import("../config/config.js");
-  const { applyChoice, runInteractiveWizard } = await import("../local/setup/wizard.js");
+  const { PROVIDER_CHOICES, applyChoice, runInteractiveWizard } = await import("../local/setup/wizard.js");
   const { isRunning } = await import("../local/daemon/launch.js");
   const { CliExitError } = await import("../errors/cli-exit-error.js");
   const { ExitCode } = await import("../errors/exit-codes.js");
 
   const config = load();
 
-  let updated: typeof config | null;
+  let updated: typeof config;
   if (options.provider !== undefined) {
     const provider = options.provider.toLowerCase();
-    if (!PROVIDERS.includes(provider as (typeof PROVIDERS)[number])) {
+    if (!(PROVIDER_CHOICES as readonly string[]).includes(provider)) {
       throw new CliExitError(`unknown provider: ${options.provider}`, ExitCode.Usage, [
-        `Valid providers: ${PROVIDERS.join(", ")}`,
+        `Valid providers: ${PROVIDER_CHOICES.join(", ")}`,
       ]);
     }
-    updated = applyChoice(config, provider as (typeof PROVIDERS)[number], {
+    updated = applyChoice(config, provider as (typeof PROVIDER_CHOICES)[number], {
       model: options.model,
       apiKey: options.apiKey,
-      baseUrl: options.baseUrl,
     });
   } else {
     updated = await runInteractiveWizard(config);
-    if (updated === null) {
-      renderResult(CommandResult.warning("Setup cancelled"), resultFormat(options));
-      return;
-    }
   }
 
   save(updated);

package/src/local/daemon/components.test.ts

@@ -47,10 +47,9 @@ describe("buildRunnerEnv", () => {
     expect(withKey.STIGMER_ACTIVITY_ROUTING).toBe("session");
   });
 
-  it("forwards LLM provider keys only when set, resolved value winning over the base env", () => {
+  it("forwards the Anthropic key only when set, resolved value winning over the base env", () => {
     const bare = buildRunnerEnv(config, {});
     expect(bare.ANTHROPIC_API_KEY).toBeUndefined();
-    expect(bare.OPENAI_API_KEY).toBeUndefined();
 
     // The contract value is authoritative: the launcher already applied the
     // env > config precedence, so whatever sits in the child's base env must
@@ -62,6 +61,13 @@ describe("buildRunnerEnv", () => {
     expect(env.ANTHROPIC_API_KEY).toBe("sk-ant-resolved");
   });
 
+  // Anthropic is the only key with a contract slot; other provider keys (for
+  // advanced per-agent overrides) flow through shell-env inheritance untouched.
+  it("passes other shell-exported provider keys through via the base env spread", () => {
+    const env = buildRunnerEnv(config, { OPENAI_API_KEY: "sk-oai-shell" });
+    expect(env.OPENAI_API_KEY).toBe("sk-oai-shell");
+  });
+
   // The regression guard for the queue bug: the server dispatches to, and the
   // runner polls, the exact same queue.
   it("pins the runner's poll queue to the server's dispatch queue", () => {

package/src/local/daemon/components.ts

@@ -53,8 +53,10 @@ export function buildRunnerEnv(config: DaemonConfig, base: NodeJS.ProcessEnv = p
   if (config.cursorApiKey !== undefined) env.CURSOR_API_KEY = config.cursorApiKey;
   // Explicit set (after the base spread) so the launcher-resolved key wins over any
   // stale inherited value — the delivery path for a `stigmer setup`-persisted key.
+  // Anthropic only: it is the sole provider local execution supports. Other keys
+  // (e.g. a shell-exported OPENAI_API_KEY for advanced per-agent gpt-* overrides)
+  // still reach the runner through the base env spread above.
   if (config.anthropicApiKey !== undefined) env.ANTHROPIC_API_KEY = config.anthropicApiKey;
-  if (config.openaiApiKey !== undefined) env.OPENAI_API_KEY = config.openaiApiKey;
   if (config.activityRouting !== undefined) env.STIGMER_ACTIVITY_ROUTING = config.activityRouting;
   return env;
 }

package/src/local/daemon/env.test.ts

@@ -27,7 +27,6 @@ describe("buildDaemonEnv + readDaemonConfig", () => {
       runner: { nodeBin: "/usr/bin/node", entryPath: "/repo/runner/dist/main.js", appDir: "/repo/runner" },
       cursorApiKey: undefined,
       anthropicApiKey: undefined,
-      openaiApiKey: undefined,
       activityRouting: undefined,
     });
   });
@@ -48,18 +47,26 @@ describe("buildDaemonEnv + readDaemonConfig", () => {
 
   // The config-file-only delivery path: a key from `stigmer setup` is not in the
   // shell env, so the launcher must write it into the contract explicitly.
-  it("delivers a launcher-resolved LLM key with no help from the base env", () => {
+  // Anthropic is the only provider with this path — the local stack executes
+  // on Anthropic only.
+  it("delivers a launcher-resolved Anthropic key with no help from the base env", () => {
     const env = buildDaemonEnv({ ...baseInputs, anthropicApiKey: "sk-ant-cfg" }, {});
     const config = readDaemonConfig(env);
     expect(config.anthropicApiKey).toBe("sk-ant-cfg");
-    expect(config.openaiApiKey).toBeUndefined();
   });
 
-  it("passes shell-exported LLM keys through from the base env", () => {
-    const env = buildDaemonEnv(baseInputs, { ANTHROPIC_API_KEY: "sk-ant-env", OPENAI_API_KEY: "sk-oai-env" });
+  it("passes a shell-exported Anthropic key through from the base env", () => {
+    const env = buildDaemonEnv(baseInputs, { ANTHROPIC_API_KEY: "sk-ant-env" });
     const config = readDaemonConfig(env);
     expect(config.anthropicApiKey).toBe("sk-ant-env");
-    expect(config.openaiApiKey).toBe("sk-oai-env");
+  });
+
+  // Other provider keys have no contract slot; they reach the runner solely via
+  // shell-env inheritance (the child env spreads the base env).
+  it("leaves shell-exported non-Anthropic keys in the env without parsing them", () => {
+    const env = buildDaemonEnv(baseInputs, { OPENAI_API_KEY: "sk-oai-env" });
+    expect(env.OPENAI_API_KEY).toBe("sk-oai-env");
+    expect(readDaemonConfig(env)).not.toHaveProperty("openaiApiKey");
   });
 
   it("requires the data dir and server binary", () => {

package/src/local/daemon/env.ts

@@ -1,8 +1,8 @@
 // The foreground launcher hands the supervised daemon everything it needs to
-// run through the environment — the same mechanism the Go CLI uses. Centralizing
-// the variable names and the (de)serialization here keeps that contract in one
-// place: the launcher writes it with buildDaemonEnv, the daemon reads it with
-// readDaemonConfig, and nothing in between guesses at string keys.
+// run through the environment. Centralizing the variable names and the
+// (de)serialization here keeps that contract in one place: the launcher writes
+// it with buildDaemonEnv, the daemon reads it with readDaemonConfig, and
+// nothing in between guesses at string keys.
 
 /** Environment variable names that make up the launcher -> daemon contract. */
 export const DaemonEnvVar = {
@@ -18,7 +18,6 @@ export const DaemonEnvVar = {
   RunnerAppDir: "STIGMER_RUNNER_APP_DIR",
   CursorApiKey: "CURSOR_API_KEY",
   AnthropicApiKey: "ANTHROPIC_API_KEY",
-  OpenAiApiKey: "OPENAI_API_KEY",
   ActivityRouting: "STIGMER_ACTIVITY_ROUTING",
 } as const;
 
@@ -41,7 +40,6 @@ export interface DaemonConfig {
   runner?: RunnerLaunch;
   cursorApiKey?: string;
   anthropicApiKey?: string;
-  openaiApiKey?: string;
   activityRouting?: string;
 }
 
@@ -55,12 +53,13 @@ export interface DaemonEnvInputs {
   noWeb: boolean;
   serverBin: string;
   runner?: RunnerLaunch;
-  // LLM provider key resolved by the launcher (env > config file). Must be written
-  // into the daemon env explicitly: unlike a shell-exported key, a key persisted by
-  // `stigmer setup` exists only in the config file and would otherwise never reach
-  // the runner. Only the effective provider's key is set.
+  // Anthropic API key resolved by the launcher (env > config file). Must be
+  // written into the daemon env explicitly: unlike a shell-exported key, a key
+  // persisted by `stigmer setup` exists only in the config file and would
+  // otherwise never reach the runner. Anthropic is the only provider with a
+  // persisted delivery path — other keys (OPENAI_API_KEY, CURSOR_API_KEY)
+  // reach the runner solely via shell-env inheritance.
   anthropicApiKey?: string;
-  openaiApiKey?: string;
 }
 
 /**
@@ -83,7 +82,6 @@ export function buildDaemonEnv(inputs: DaemonEnvInputs, base: NodeJS.ProcessEnv
     env[DaemonEnvVar.RunnerAppDir] = inputs.runner.appDir;
   }
   if (inputs.anthropicApiKey !== undefined) env[DaemonEnvVar.AnthropicApiKey] = inputs.anthropicApiKey;
-  if (inputs.openaiApiKey !== undefined) env[DaemonEnvVar.OpenAiApiKey] = inputs.openaiApiKey;
   return env;
 }
 
@@ -106,7 +104,6 @@ export function readDaemonConfig(env: NodeJS.ProcessEnv = process.env): DaemonCo
     runner: serverOnly ? undefined : runner,
     cursorApiKey: nonEmpty(env[DaemonEnvVar.CursorApiKey]),
     anthropicApiKey: nonEmpty(env[DaemonEnvVar.AnthropicApiKey]),
-    openaiApiKey: nonEmpty(env[DaemonEnvVar.OpenAiApiKey]),
     activityRouting: nonEmpty(env[DaemonEnvVar.ActivityRouting]),
   };
 }

package/src/local/daemon/launch.ts

@@ -99,9 +99,8 @@ export async function up(options: UpOptions = {}, home: string = homedir()): Pro
 }
 
 /**
- * Bootstrap the system seedpack into the freshly-started local backend (the TS
- * equivalent of the Go daemon's EnsureSeedpackBootstrapped). Idempotent via a
- * content-hash marker, so repeated `up`s are cheap. Best-effort: the stack is
+ * Bootstrap the system seedpack into the freshly-started local backend.
+ * Idempotent via a content-hash marker, so repeated `up`s are cheap. Best-effort: the stack is
  * already serving by this point, so a seedpack failure is surfaced as a warning
  * with a retry hint rather than tearing the stack down.
  */
@@ -228,23 +227,16 @@ async function stopManagedTemporal(home: string): Promise<void> {
 // the config file, so the launcher must write it into the daemon contract explicitly
 // — unlike a shell-exported key, it cannot flow by env inheritance. resolveApiKey's
 // precedence (env var > config file) makes both cases one code path; when the env
-// var is set this re-writes the same value. Only the effective provider's key is
-// passed: the config file stores a single key, keyed to the chosen provider.
-function resolveLlmKeyInputs(config: Config): Pick<DaemonEnvInputs, "anthropicApiKey" | "openaiApiKey"> {
+// var is set this re-writes the same value. Anthropic is the only provider the
+// local stack executes on, so it is the only key with a persisted delivery path.
+function resolveLlmKeyInputs(config: Config): Pick<DaemonEnvInputs, "anthropicApiKey"> {
+  if (resolveProvider(config) !== "anthropic") return {};
   const key = resolveApiKey(config);
-  if (key === "") return {};
-  switch (resolveProvider(config)) {
-    case "anthropic":
-      return { anthropicApiKey: key };
-    case "openai":
-      return { openaiApiKey: key };
-    default:
-      return {};
-  }
+  return key === "" ? {} : { anthropicApiKey: key };
 }
 
-// Default to managed Temporal unless the opaque local config explicitly opts out
-// (Go parity: managed is the default). Wave 4's `setup` models this section.
+// Default to managed Temporal unless the opaque local config explicitly opts
+// out — zero-config `stigmer up` must work on a fresh machine.
 function isTemporalManaged(config: Config): boolean {
   const local = config.backend.local as { temporal?: { managed?: boolean } } | undefined;
   return local?.temporal?.managed !== false;

package/src/local/llm-config.test.ts

@@ -7,7 +7,6 @@ import {
   resolveModel,
   resolveProvider,
   setLlm,
-  withProviderDefaults,
 } from "./llm-config.js";
 
 function config(local?: unknown): Config {
@@ -15,60 +14,50 @@ function config(local?: unknown): Config {
 }
 
 describe("detectProviderFromEnv", () => {
-  it("prefers Anthropic, then OpenAI, else empty", () => {
-    expect(detectProviderFromEnv({ ANTHROPIC_API_KEY: "a", OPENAI_API_KEY: "b" })).toBe("anthropic");
-    expect(detectProviderFromEnv({ OPENAI_API_KEY: "b" })).toBe("openai");
+  it("detects Anthropic only — the sole provider local execution supports", () => {
+    expect(detectProviderFromEnv({ ANTHROPIC_API_KEY: "a" })).toBe("anthropic");
+    // Other provider keys in the shell must not flip the local story.
+    expect(detectProviderFromEnv({ OPENAI_API_KEY: "b" })).toBe("");
     expect(detectProviderFromEnv({})).toBe("");
   });
 });
 
 describe("resolveProvider", () => {
   it("honors env override > config > autodetect", () => {
-    const cfg = config({ llm: { provider: "ollama" } });
-    expect(resolveProvider(cfg, { STIGMER_LLM_PROVIDER: "openai" })).toBe("openai");
-    expect(resolveProvider(cfg, {})).toBe("ollama");
+    const cfg = config({ llm: { provider: "anthropic" } });
+    expect(resolveProvider(cfg, { STIGMER_LLM_PROVIDER: "other" })).toBe("other");
+    expect(resolveProvider(cfg, {})).toBe("anthropic");
     expect(resolveProvider(config(), { ANTHROPIC_API_KEY: "x" })).toBe("anthropic");
     expect(resolveProvider(config(), {})).toBe("");
   });
 });
 
 describe("resolveModel", () => {
-  it("falls back to the provider default", () => {
-    expect(resolveModel(config({ llm: { provider: "anthropic" } }), {})).toBe("claude-sonnet-4.5");
-    expect(resolveModel(config({ llm: { provider: "openai" } }), {})).toBe("gpt-4");
-    expect(resolveModel(config({ llm: { provider: "ollama" } }), {})).toBe("qwen2.5-coder:7b");
+  it("returns the explicit override, else empty — the registry owns the default", () => {
+    // No hardcoded model version anywhere in the CLI: unset means "platform
+    // default", resolved by the runner from the model registry.
+    expect(resolveModel(config({ llm: { provider: "anthropic" } }), {})).toBe("");
+    expect(resolveModel(config(), {})).toBe("");
     expect(resolveModel(config({ llm: { provider: "anthropic", model: "claude-x" } }), {})).toBe("claude-x");
     expect(resolveModel(config({ llm: { provider: "anthropic" } }), { STIGMER_LLM_MODEL: "envm" })).toBe("envm");
   });
 });
 
 describe("resolveApiKey", () => {
-  it("uses the provider-specific env var, then config", () => {
+  it("uses ANTHROPIC_API_KEY, then config", () => {
     const cfg = config({ llm: { provider: "anthropic", api_key: "cfgkey" } });
     expect(resolveApiKey(cfg, { ANTHROPIC_API_KEY: "envkey" })).toBe("envkey");
     expect(resolveApiKey(cfg, {})).toBe("cfgkey");
   });
-});
 
-describe("withProviderDefaults", () => {
-  it("fills model and base URL per provider, keeping api_key only when set", () => {
-    expect(withProviderDefaults({ provider: "anthropic" })).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5" });
-    expect(withProviderDefaults({ provider: "ollama" })).toEqual({
-      provider: "ollama",
-      model: "qwen2.5-coder:7b",
-      base_url: "http://localhost:11434",
-    });
-    expect(withProviderDefaults({ provider: "openai", api_key: "k" })).toEqual({
-      provider: "openai",
-      model: "gpt-4",
-      api_key: "k",
-    });
+  it("returns empty for non-anthropic providers (e.g. hand-edited config)", () => {
+    expect(resolveApiKey(config({ llm: { provider: "other", api_key: "k" } }), {})).toBe("");
   });
 });
 
 describe("setLlm", () => {
   it("preserves sibling local keys and can clear the section", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "openai" } });
+    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic" } });
     const updated = setLlm(cfg, { provider: "anthropic", model: "m" });
     expect(readLlm(updated)).toEqual({ provider: "anthropic", model: "m" });
     expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });

package/src/local/llm-config.ts

@@ -2,12 +2,23 @@
 // the LLM settings `setup` writes and `status` reads.
 //
 // The config module (config/config.ts) carries `backend.local` through verbatim
-// so the TS CLI never drops fields it does not model. This module adds a *typed
-// lens* for the one sub-tree T05 owns — `local.llm` — and ports the Go CLI's
-// `ResolveLLM*` precedence (env override > config file > provider default) so the
-// two CLIs agree on which provider/model is effectively in force. Writes merge
-// into a shallow copy of `local`, preserving every sibling key (temporal,
-// execution, …).
+// so the CLI never drops fields it does not model. This module adds a *typed
+// lens* for the one sub-tree setup owns — `local.llm` — and resolves the
+// effective provider/model with env-override precedence (env > config file >
+// API-key autodetect). Writes merge into a shallow copy of `local`, preserving
+// every sibling key (temporal, execution, …).
+//
+// Local agent execution is Anthropic-only: the native runner constructs
+// Anthropic clients, and the platform model registry's native-harness entries
+// are all Anthropic models. Two invariants follow:
+//
+//   1. The model registry — not this config — owns the default execution model.
+//      The runner resolves it from the registry at execution time, so this
+//      module never hardcodes a model version (hardcoded versions here drifted
+//      from the registry repeatedly). An unset model means "platform default".
+//   2. `provider` exists to route the right API key to the runner, not to
+//      select an execution backend; "anthropic" is the only provider the local
+//      stack can serve.
 
 import type { Config } from "../config/config.js";
 
@@ -16,7 +27,6 @@ export interface LlmSettings {
   provider?: string;
   model?: string;
   api_key?: string;
-  base_url?: string;
 }
 
 interface LocalSection {
@@ -24,18 +34,6 @@ interface LocalSection {
   [key: string]: unknown;
 }
 
-/** Default model per provider, matching the Go setup wizard's choices. */
-const DEFAULT_MODEL: Record<string, string> = {
-  ollama: "qwen2.5-coder:7b",
-  anthropic: "claude-sonnet-4.5",
-  openai: "gpt-4",
-};
-
-/** Default base URL per provider (only Ollama needs one). */
-const DEFAULT_BASE_URL: Record<string, string> = {
-  ollama: "http://localhost:11434",
-};
-
 function localSection(config: Config): LocalSection {
   const local = config.backend.local;
   return local !== null && typeof local === "object" ? (local as LocalSection) : {};
@@ -47,12 +45,11 @@ export function readLlm(config: Config): LlmSettings | undefined {
 }
 
 /**
- * Detect a provider from API keys present in the environment (Anthropic first,
- * then OpenAI), matching the Go CLI's `DetectProviderFromAPIKeys`.
+ * Detect a provider from API keys present in the environment. Anthropic is the
+ * only provider local execution supports, so only ANTHROPIC_API_KEY counts.
  */
 export function detectProviderFromEnv(env: NodeJS.ProcessEnv = process.env): string {
   if (env.ANTHROPIC_API_KEY) return "anthropic";
-  if (env.OPENAI_API_KEY) return "openai";
   return "";
 }
 
@@ -64,33 +61,22 @@ export function resolveProvider(config: Config, env: NodeJS.ProcessEnv = process
   return detectProviderFromEnv(env);
 }
 
-/** Effective model: env override > config > provider default. */
+/**
+ * Effective model override: env override > config. Empty string means "no
+ * override" — the runner picks the default from the platform model registry.
+ */
 export function resolveModel(config: Config, env: NodeJS.ProcessEnv = process.env): string {
   if (env.STIGMER_LLM_MODEL) return env.STIGMER_LLM_MODEL;
-  const llm = readLlm(config);
-  if (llm?.model) return llm.model;
-  return DEFAULT_MODEL[resolveProvider(config, env)] ?? "";
+  return readLlm(config)?.model ?? "";
 }
 
-/** Effective API key: provider-specific env var > config. */
+/** Effective API key: ANTHROPIC_API_KEY env var > config. */
 export function resolveApiKey(config: Config, env: NodeJS.ProcessEnv = process.env): string {
-  const provider = resolveProvider(config, env);
-  const envKey = provider === "anthropic" ? env.ANTHROPIC_API_KEY : provider === "openai" ? env.OPENAI_API_KEY : "";
-  if (envKey) return envKey;
+  if (resolveProvider(config, env) !== "anthropic") return "";
+  if (env.ANTHROPIC_API_KEY) return env.ANTHROPIC_API_KEY;
   return readLlm(config)?.api_key ?? "";
 }
 
-/** Fill in provider-appropriate defaults for a partial selection. */
-export function withProviderDefaults(settings: LlmSettings): LlmSettings {
-  const provider = settings.provider ?? "";
-  const out: LlmSettings = { provider };
-  out.model = settings.model ?? DEFAULT_MODEL[provider];
-  if (settings.api_key) out.api_key = settings.api_key;
-  const baseUrl = settings.base_url ?? DEFAULT_BASE_URL[provider];
-  if (baseUrl) out.base_url = baseUrl;
-  return out;
-}
-
 /**
  * Return a copy of `config` with the LLM section replaced, preserving every
  * other key under `backend.local`. Passing `undefined` clears the LLM section

package/src/local/setup/wizard.test.ts

@@ -1,25 +1,33 @@
 import { describe, expect, it } from "vitest";
 import type { Config } from "../../config/config.js";
 import { readLlm } from "../llm-config.js";
-import { applyChoice, buildLlmForChoice } from "./wizard.js";
+import { PROVIDER_CHOICES, applyChoice, buildLlmForChoice } from "./wizard.js";
 
 function config(local?: unknown): Config {
   return { backend: { type: "local", local } };
 }
 
+// Regression pin: every provider offered by `stigmer setup` promises an
+// execution path the native runner must actually serve. The runner constructs
+// Anthropic clients only and the registry's native-harness entries are all
+// Anthropic — so this list is anthropic + skip, full stop. If this test fails
+// because a provider was added, the native runner and model registry must gain
+// real support for it first (see sdk/react DISABLED_PROVIDERS for the same
+// decision on the UI side).
+describe("PROVIDER_CHOICES", () => {
+  it("offers exactly anthropic and skip", () => {
+    expect([...PROVIDER_CHOICES]).toEqual(["anthropic", "skip"]);
+  });
+});
+
 describe("buildLlmForChoice", () => {
-  it("applies provider defaults and overrides", () => {
-    expect(buildLlmForChoice("anthropic")).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5" });
+  it("persists no model unless explicitly overridden — the registry owns the default", () => {
+    expect(buildLlmForChoice("anthropic")).toEqual({ provider: "anthropic" });
     expect(buildLlmForChoice("anthropic", { apiKey: "k", model: "m" })).toEqual({
       provider: "anthropic",
       model: "m",
       api_key: "k",
     });
-    expect(buildLlmForChoice("ollama", { baseUrl: "http://host:1" })).toEqual({
-      provider: "ollama",
-      model: "qwen2.5-coder:7b",
-      base_url: "http://host:1",
-    });
   });
 
   it("returns undefined for skip (clears config)", () => {
@@ -29,14 +37,14 @@ describe("buildLlmForChoice", () => {
 
 describe("applyChoice", () => {
   it("writes the selection while preserving siblings", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "openai" } });
+    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic", model: "stale" } });
     const updated = applyChoice(cfg, "anthropic", { apiKey: "k" });
-    expect(readLlm(updated)).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5", api_key: "k" });
+    expect(readLlm(updated)).toEqual({ provider: "anthropic", api_key: "k" });
     expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
   });
 
   it("skip clears the llm section", () => {
-    const updated = applyChoice(config({ llm: { provider: "openai" } }), "skip");
+    const updated = applyChoice(config({ llm: { provider: "anthropic" } }), "skip");
     expect(readLlm(updated)).toBeUndefined();
   });
 });