talon-agent 1.6.1 → 1.7.0

package/README.md

@@ -209,7 +209,7 @@ Config file: `~/.talon/config.json`
 | `frontend` | `"telegram"` | `"telegram"`, `"terminal"`, `"teams"`, or an array |
 | `backend` | `"claude"` | `"claude"` or `"opencode"` |
 | `botToken` | --- | Telegram bot token |
-| `model` | `"claude-sonnet-4-6"` | Default model (discovered from SDK at startup) |
+| `model` | `"default"` | Default Claude model. Legacy `claude-*` aliases are still accepted. |
 | `concurrency` | `1` | Max concurrent AI queries (1--20) |
 | `pulse` | `true` | Periodic group engagement |
 | `heartbeat` | `false` | Background maintenance agent |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -51,7 +51,7 @@
     "format:check": "prettier --check src/ prompts/"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.104",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.108",
     "@brave/brave-search-mcp-server": "^2.0.75",
     "@clack/prompts": "^1.2.0",
     "@grammyjs/auto-retry": "^2.0.2",

package/src/__tests__/chat-settings.test.ts

@@ -38,6 +38,12 @@ const { registerClaudeModelsStatic, CLAUDE_MODELS_STATIC } =
   await import("../backend/claude-sdk/models.js");
 registerClaudeModelsStatic(CLAUDE_MODELS_STATIC);
 
+const SDK_MODEL_IDS = {
+  sonnet: "default",
+  opus: "opus",
+  haiku: "haiku",
+} as const;
+
 describe("chat-settings", () => {
   describe("getChatSettings", () => {
     it("returns empty object for unknown chat", () => {
@@ -85,62 +91,67 @@ describe("chat-settings", () => {
   });
 
   describe("resolveModelName", () => {
-    it("resolves 'sonnet' to claude-sonnet-4-6", () => {
-      expect(resolveModelName("sonnet")).toBe("claude-sonnet-4-6");
+    it("resolves 'sonnet' to the SDK default model ID", () => {
+      expect(resolveModelName("sonnet")).toBe(SDK_MODEL_IDS.sonnet);
     });
 
-    it("resolves 'opus' to claude-opus-4-6", () => {
-      expect(resolveModelName("opus")).toBe("claude-opus-4-6");
+    it("resolves 'opus' to the SDK Opus model ID", () => {
+      expect(resolveModelName("opus")).toBe(SDK_MODEL_IDS.opus);
     });
 
-    it("resolves 'haiku' to claude-haiku-4-5", () => {
-      expect(resolveModelName("haiku")).toBe("claude-haiku-4-5");
+    it("resolves 'haiku' to the SDK Haiku model ID", () => {
+      expect(resolveModelName("haiku")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("resolves versioned aliases", () => {
-      expect(resolveModelName("sonnet-4.6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus-4.6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku-4.5")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet-4.6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus-4.6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku-4.5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("resolves dash-separated aliases", () => {
-      expect(resolveModelName("sonnet-4-6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus-4-6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku-4-5")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet-4-6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus-4-6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku-4-5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("is case-insensitive", () => {
-      expect(resolveModelName("Sonnet")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("OPUS")).toBe("claude-opus-4-6");
+      expect(resolveModelName("Sonnet")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("OPUS")).toBe(SDK_MODEL_IDS.opus);
     });
 
     it("trims whitespace", () => {
-      expect(resolveModelName("  sonnet  ")).toBe("claude-sonnet-4-6");
+      expect(resolveModelName("  sonnet  ")).toBe(SDK_MODEL_IDS.sonnet);
     });
 
     it("passes through unknown model names unchanged", () => {
       expect(resolveModelName("gpt-4")).toBe("gpt-4");
-      expect(resolveModelName("claude-sonnet-4-6")).toBe("claude-sonnet-4-6");
+    });
+
+    it("resolves legacy claude-* aliases to the current SDK IDs", () => {
+      expect(resolveModelName("claude-sonnet-4-6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("claude-opus-4-6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("claude-haiku-4-5")).toBe(SDK_MODEL_IDS.haiku);
     });
   });
 
   describe("resolveModelName — exhaustive alias coverage", () => {
     it("resolves all base aliases correctly", () => {
-      expect(resolveModelName("sonnet")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("resolves all dot-separated version aliases", () => {
-      expect(resolveModelName("sonnet-4.6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus-4.6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku-4.5")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet-4.6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus-4.6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku-4.5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("resolves all dash-separated version aliases", () => {
-      expect(resolveModelName("sonnet-4-6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus-4-6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku-4-5")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet-4-6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus-4-6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku-4-5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("passes through completely unknown model names unchanged", () => {
@@ -149,10 +160,10 @@ describe("chat-settings", () => {
       expect(resolveModelName("mistral-large")).toBe("mistral-large");
     });
 
-    it("passes through full claude model names unchanged (not aliases)", () => {
-      expect(resolveModelName("claude-sonnet-4-6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("claude-opus-4-6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("claude-haiku-4-5")).toBe("claude-haiku-4-5");
+    it("maps full claude compatibility aliases to the current SDK IDs", () => {
+      expect(resolveModelName("claude-sonnet-4-6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("claude-opus-4-6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("claude-haiku-4-5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("preserves original casing for unknown models", () => {
@@ -171,16 +182,16 @@ describe("chat-settings", () => {
   });
 
   describe("model alias resolution (via registry)", () => {
-    it("resolves short aliases to full model IDs", () => {
-      expect(resolveModelName("sonnet")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku")).toBe("claude-haiku-4-5");
+    it("resolves short aliases to SDK model IDs", () => {
+      expect(resolveModelName("sonnet")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("resolves versioned aliases", () => {
-      expect(resolveModelName("sonnet-4-6")).toBe("claude-sonnet-4-6");
-      expect(resolveModelName("opus-4.6")).toBe("claude-opus-4-6");
-      expect(resolveModelName("haiku-4.5")).toBe("claude-haiku-4-5");
+      expect(resolveModelName("sonnet-4-6")).toBe(SDK_MODEL_IDS.sonnet);
+      expect(resolveModelName("opus-4.6")).toBe(SDK_MODEL_IDS.opus);
+      expect(resolveModelName("haiku-4.5")).toBe(SDK_MODEL_IDS.haiku);
     });
 
     it("passes through unknown names unchanged", () => {

package/src/__tests__/claude-sdk-models.test.ts

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockSupportedModels = vi.fn();
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: vi.fn(() => ({
+    supportedModels: mockSupportedModels,
+    [Symbol.asyncIterator]() {
+      return {
+        next: async () => ({ done: true, value: undefined }),
+      };
+    },
+  })),
+}));
+
+const sdkModels = [
+  {
+    value: "default",
+    displayName: "Default (recommended)",
+    description: "Sonnet 4.6 · Best for everyday tasks",
+  },
+  {
+    value: "sonnet[1m]",
+    displayName: "Sonnet (1M context)",
+    description:
+      "Sonnet 4.6 with 1M context · Billed as extra usage · $3/$15 per Mtok",
+  },
+  {
+    value: "opus",
+    displayName: "Opus",
+    description: "Opus 4.6 · Most capable for complex work",
+  },
+  {
+    value: "opus[1m]",
+    displayName: "Opus (1M context)",
+    description:
+      "Opus 4.6 with 1M context · Billed as extra usage · $5/$25 per Mtok",
+  },
+  {
+    value: "haiku",
+    displayName: "Haiku",
+    description: "Haiku 4.5 · Fastest for quick answers",
+  },
+  {
+    value: "claude-sonnet-4-6",
+    displayName: "Sonnet 4.6",
+    description: "claude-sonnet-4-6",
+  },
+];
+
+describe("registerClaudeModels", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    mockSupportedModels.mockResolvedValue(sdkModels);
+
+    const { clearModels } = await import("../core/models.js");
+    clearModels();
+  });
+
+  it("keeps SDK IDs/display names and maps 1M upgrades explicitly", async () => {
+    const { registerClaudeModels } =
+      await import("../backend/claude-sdk/models.js");
+    const {
+      get1mContextModelId,
+      getModels,
+      resolveModelId,
+      supports1mContext,
+    } = await import("../core/models.js");
+
+    await registerClaudeModels({ model: "default" });
+
+    const anthropicModels = getModels("anthropic");
+    expect(anthropicModels.map((model) => model.id)).toEqual([
+      "opus",
+      "opus[1m]",
+      "default",
+      "sonnet[1m]",
+      "haiku",
+    ]);
+
+    expect(
+      anthropicModels.find((model) => model.id === "default")?.displayName,
+    ).toBe("Default (recommended)");
+    expect(
+      anthropicModels.find((model) => model.id === "sonnet[1m]")?.displayName,
+    ).toBe("Sonnet (1M context)");
+    expect(
+      anthropicModels.some((model) => model.id === "claude-sonnet-4-6"),
+    ).toBe(false);
+
+    expect(resolveModelId("claude-sonnet-4-6")).toBe("default");
+    expect(resolveModelId("claude-sonnet-4-6[1m]")).toBe("sonnet[1m]");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus");
+
+    expect(get1mContextModelId("default")).toBe("sonnet[1m]");
+    expect(get1mContextModelId("claude-sonnet-4-6")).toBe("sonnet[1m]");
+    expect(get1mContextModelId("opus")).toBe("opus[1m]");
+    expect(get1mContextModelId("haiku")).toBeNull();
+
+    expect(supports1mContext("claude-sonnet-4-6")).toBe(true);
+    expect(supports1mContext("haiku")).toBe(false);
+  });
+
+  it("derives compatibility aliases from SDK metadata instead of hardcoded versions", async () => {
+    mockSupportedModels.mockResolvedValue([
+      {
+        value: "default",
+        displayName: "Default (recommended)",
+        description: "Sonnet 5.0 · Best for everyday tasks",
+      },
+      {
+        value: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description:
+          "Sonnet 5.0 with 1M context · Billed as extra usage · $3/$15 per Mtok",
+      },
+      {
+        value: "opus",
+        displayName: "Opus",
+        description: "Opus 5.0 · Most capable for complex work",
+      },
+      {
+        value: "opus[1m]",
+        displayName: "Opus (1M context)",
+        description:
+          "Opus 5.0 with 1M context · Billed as extra usage · $5/$25 per Mtok",
+      },
+      {
+        value: "haiku",
+        displayName: "Haiku",
+        description: "Haiku 5.0 · Fastest for quick answers",
+      },
+      {
+        value: "claude-sonnet-5-0",
+        displayName: "Sonnet 5.0",
+        description: "claude-sonnet-5-0",
+      },
+    ]);
+
+    const { registerClaudeModels } =
+      await import("../backend/claude-sdk/models.js");
+    const { get1mContextModelId, resolveModelId } =
+      await import("../core/models.js");
+
+    await registerClaudeModels({ model: "default" });
+
+    expect(resolveModelId("claude-sonnet-5-0")).toBe("default");
+    expect(resolveModelId("claude-sonnet-4-6")).toBe("default");
+    expect(resolveModelId("claude-opus-5-0")).toBe("opus");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus");
+    expect(resolveModelId("claude-haiku-5-0")).toBe("haiku");
+    expect(resolveModelId("claude-haiku-4-5")).toBe("haiku");
+    expect(get1mContextModelId("claude-sonnet-4-6")).toBe("sonnet[1m]");
+    expect(get1mContextModelId("claude-sonnet-5-0")).toBe("sonnet[1m]");
+  });
+});

package/src/__tests__/claude-sdk-options.test.ts

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockGetSession = vi.fn();
+const mockGetChatSettings = vi.fn();
+const mockGetPluginMcpServers = vi.fn();
+const mockGetConfig = vi.fn();
+const mockGetBridgePort = vi.fn();
+
+vi.mock("../storage/sessions.js", () => ({
+  getSession: (...args: unknown[]) =>
+    mockGetSession(...(args as Parameters<typeof mockGetSession>)),
+}));
+
+vi.mock("../storage/chat-settings.js", () => ({
+  getChatSettings: (...args: unknown[]) =>
+    mockGetChatSettings(...(args as Parameters<typeof mockGetChatSettings>)),
+}));
+
+vi.mock("../core/plugin.js", () => ({
+  getPluginMcpServers: (...args: unknown[]) =>
+    mockGetPluginMcpServers(
+      ...(args as Parameters<typeof mockGetPluginMcpServers>),
+    ),
+}));
+
+vi.mock("../backend/claude-sdk/state.js", () => ({
+  getConfig: (...args: unknown[]) =>
+    mockGetConfig(...(args as Parameters<typeof mockGetConfig>)),
+  getBridgePort: (...args: unknown[]) =>
+    mockGetBridgePort(...(args as Parameters<typeof mockGetBridgePort>)),
+}));
+
+describe("buildSdkOptions", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    mockGetSession.mockReturnValue({ sessionId: null });
+    mockGetChatSettings.mockReturnValue({});
+    mockGetPluginMcpServers.mockReturnValue({});
+    mockGetConfig.mockReturnValue({
+      model: "claude-sonnet-4-6",
+      frontend: "terminal",
+      systemPrompt: "test prompt",
+      workspace: "/tmp/workspace",
+    });
+    mockGetBridgePort.mockReturnValue(19876);
+
+    const { clearModels, registerModels } = await import("../core/models.js");
+    clearModels();
+    registerModels([
+      {
+        id: "default",
+        displayName: "Default (recommended)",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+        aliases: ["claude-sonnet-4-6"],
+        provider: "anthropic",
+        capabilities: {
+          supports1mContext: true,
+          oneMillionContextModelId: "sonnet[1m]",
+        },
+        tier: "balanced",
+        fallback: "haiku",
+      },
+      {
+        id: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description:
+          "Sonnet 4.6 with 1M context · Billed as extra usage · $3/$15 per Mtok",
+        aliases: ["claude-sonnet-4-6[1m]"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: true },
+        tier: "balanced",
+        fallback: "haiku",
+      },
+      {
+        id: "haiku",
+        displayName: "Haiku",
+        description: "Haiku 4.5 · Fastest for quick answers",
+        aliases: ["claude-haiku-4-5"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: false },
+        tier: "economy",
+      },
+    ]);
+  });
+
+  it("uses the exact mapped 1M SDK model for legacy Sonnet IDs", async () => {
+    const { buildSdkOptions } =
+      await import("../backend/claude-sdk/options.js");
+
+    const { activeModel, options } = buildSdkOptions("chat-1");
+
+    expect(activeModel).toBe("claude-sonnet-4-6");
+    expect(options.model).toBe("sonnet[1m]");
+  });
+
+  it("leaves models without a mapped 1M variant unchanged", async () => {
+    mockGetChatSettings.mockReturnValue({ model: "haiku" });
+
+    const { buildSdkOptions } =
+      await import("../backend/claude-sdk/options.js");
+    const { options } = buildSdkOptions("chat-2");
+
+    expect(options.model).toBe("haiku");
+  });
+
+  it("resolves legacy 1M aliases to canonical SDK model IDs", async () => {
+    mockGetChatSettings.mockReturnValue({ model: "claude-sonnet-4-6[1m]" });
+
+    const { buildSdkOptions } =
+      await import("../backend/claude-sdk/options.js");
+    const { activeModel, options } = buildSdkOptions("chat-3");
+
+    expect(activeModel).toBe("claude-sonnet-4-6[1m]");
+    expect(options.model).toBe("sonnet[1m]");
+  });
+});

package/src/__tests__/config.test.ts

@@ -94,7 +94,7 @@ describe("config", () => {
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
       expect(config.frontend).toBe("terminal");
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
     });
 
     it("throws when telegram frontend has no botToken", async () => {
@@ -118,7 +118,7 @@ describe("config", () => {
 
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
       expect(config.maxMessageLength).toBe(4000);
       expect(config.concurrency).toBe(1);
       expect(config.pulse).toBe(true);
@@ -195,10 +195,91 @@ describe("config", () => {
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
       expect(config.plugins).toHaveLength(2);
-      expect(config.plugins[0].path).toBe("./plugins/my-plugin");
-      expect(config.plugins[0].config).toEqual({ key: "value" });
-      expect(config.plugins[1].path).toBe("./plugins/another");
-      expect(config.plugins[1].config).toBeUndefined();
+      const [firstPlugin, secondPlugin] = config.plugins;
+
+      expect("path" in firstPlugin).toBe(true);
+      if ("path" in firstPlugin) {
+        expect(firstPlugin.path).toBe("./plugins/my-plugin");
+        expect(firstPlugin.config).toEqual({ key: "value" });
+      }
+
+      expect("path" in secondPlugin).toBe(true);
+      if ("path" in secondPlugin) {
+        expect(secondPlugin.path).toBe("./plugins/another");
+        expect(secondPlugin.config).toBeUndefined();
+      }
+    });
+
+    it("parses standalone MCP plugins in config", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            name: "polymarket",
+            command: "node",
+            args: ["/tmp/polymarket.js"],
+            env: { POLYMARKET_PRIVATE_KEY: "0x123" },
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      const config = loadConfig();
+
+      expect(config.plugins).toEqual([
+        {
+          name: "polymarket",
+          command: "node",
+          args: ["/tmp/polymarket.js"],
+          env: { POLYMARKET_PRIVATE_KEY: "0x123" },
+        },
+      ]);
+    });
+
+    it("rejects plugin entries that mix path and standalone MCP fields", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            path: "./plugins/extras",
+            name: "extras",
+            command: "node",
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow("exactly one format");
+    });
+
+    it("rejects standalone MCP entries missing required fields", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [{ name: "polymarket" }],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow(
+        "MCP plugin entries must include 'command'",
+      );
+    });
+
+    it("rejects standalone MCP entries with config blocks", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            name: "polymarket",
+            command: "node",
+            config: { market: "crypto" },
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow(
+        "MCP plugin entries cannot include 'config'",
+      );
     });
 
     it("defaults plugins to empty array", async () => {
@@ -235,6 +316,29 @@ describe("config", () => {
       const config = loadConfig();
       expect(config.frontend).toEqual(["terminal"]);
     });
+
+    it("preserves Playwright endpoint settings from config", async () => {
+      mockFs({
+        frontend: "terminal",
+        playwright: {
+          enabled: true,
+          browser: "firefox",
+          endpoint: "ws://127.0.0.1:9222/devtools/browser/test",
+          endpointFile: "/tmp/camoufox-endpoint.txt",
+        },
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      const config = loadConfig();
+
+      expect(config.playwright).toEqual({
+        enabled: true,
+        browser: "firefox",
+        headless: true,
+        endpoint: "ws://127.0.0.1:9222/devtools/browser/test",
+        endpointFile: "/tmp/camoufox-endpoint.txt",
+      });
+    });
   });
 
   describe("system prompt", () => {
@@ -533,12 +637,12 @@ describe("config", () => {
       expect(() => loadConfig()).toThrow();
     });
 
-    it("default model is exactly claude-sonnet-4-6", async () => {
+    it("defaults the canonical Claude model to default", async () => {
       mockFs({ frontend: "terminal" });
 
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
     });
 
     it("default pulse is exactly true", async () => {

package/src/__tests__/dream.test.ts

@@ -881,7 +881,7 @@ describe("dream error paths", () => {
     );
   });
 
-  it("model defaults to 'claude-sonnet-4-6' when neither dreamModel nor model set (line 135 FALSE??FALSE branch)", async () => {
+  it("model defaults to 'default' when neither dreamModel nor model set (line 135 FALSE??FALSE branch)", async () => {
     vi.doMock("node:fs", () => ({
       existsSync: vi.fn(() => false),
       readFileSync: vi.fn(() => "dream prompt"),
@@ -913,14 +913,14 @@ describe("dream error paths", () => {
     vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({ query: queryMock }));
 
     const mod = await import("../core/dream.js");
-    // No model or dreamModel → falls through to "claude-sonnet-4-6" literal default
+    // No model or dreamModel → falls through to the canonical SDK default model
     mod.initDream({ workspace: "/fake/ws" });
     await mod.forceDream();
 
     const callArgs = (queryMock.mock.calls[0] as unknown[])[0] as {
       options: Record<string, unknown>;
     };
-    expect(callArgs.options).toHaveProperty("model", "claude-sonnet-4-6");
+    expect(callArgs.options).toHaveProperty("model", "default");
   });
 });
 

package/src/__tests__/fuzz.test.ts

@@ -324,25 +324,25 @@ describe("fuzz: resolveModelName()", () => {
     );
   });
 
-  it("known aliases always resolve to claude model names", () => {
-    const aliases = [
-      "sonnet",
-      "opus",
-      "haiku",
-      "sonnet-4.6",
-      "opus-4.6",
-      "haiku-4.5",
-      "sonnet-4-6",
-      "opus-4-6",
-      "haiku-4-5",
-    ];
+  it("known aliases resolve to the expected SDK model IDs", () => {
+    const aliasMappings = [
+      ["sonnet", "default"],
+      ["opus", "opus"],
+      ["haiku", "haiku"],
+      ["sonnet-4.6", "default"],
+      ["opus-4.6", "opus"],
+      ["haiku-4.5", "haiku"],
+      ["sonnet-4-6", "default"],
+      ["opus-4-6", "opus"],
+      ["haiku-4-5", "haiku"],
+    ] as const;
     fc.assert(
       fc.property(
-        fc.constantFrom(...aliases),
+        fc.constantFrom(...aliasMappings),
         fc.constantFrom("", " ", "  "),
-        (alias, padding) => {
+        ([alias, expectedModelId], padding) => {
           const result = resolveModelName(padding + alias + padding);
-          expect(result).toMatch(/^claude-/);
+          expect(result).toBe(expectedModelId);
         },
       ),
       fcParams,