talon-agent 1.8.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

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

@@ -38,9 +38,13 @@ const { registerClaudeModelsStatic, CLAUDE_MODELS_STATIC } =
   await import("../backend/claude-sdk/models.js");
 registerClaudeModelsStatic(CLAUDE_MODELS_STATIC);
 
+// convertSdkModels collapses base + 1M variants into a single canonical ID
+// per family+version, preferring the 1M variant (and "default" when the SDK
+// marks one canonical). So sonnet/sonnet[1m] → "default", opus/opus[1m] →
+// "opus[1m]", and plain "haiku" stays.
 const SDK_MODEL_IDS = {
   sonnet: "default",
-  opus: "opus",
+  opus: "opus[1m]",
   haiku: "haiku",
 } as const;
 

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

@@ -58,36 +58,40 @@ describe("registerClaudeModels", () => {
     clearModels();
   });
 
-  it("keeps SDK IDs/display names and collapses duplicates", async () => {
+  it("collapses family+version duplicates (base + 1M + claude-*) into a single canonical entry", async () => {
     const { registerClaudeModels } =
       await import("../backend/claude-sdk/models.js");
     const { getModels, resolveModelId } = await import("../core/models.js");
 
     await registerClaudeModels({ model: "default" });
 
+    // sonnet, sonnet[1m], claude-sonnet-4-6 all share family+version and
+    // collapse into "default" (the SDK's recommended canonical). opus/opus[1m]
+    // collapse into opus[1m] (1M-preferred since no "default" exists for that
+    // family). haiku stands alone.
     const anthropicModels = getModels("anthropic");
     expect(anthropicModels.map((model) => model.id)).toEqual([
       "default",
-      "sonnet[1m]",
-      "opus",
       "opus[1m]",
       "haiku",
     ]);
 
     expect(
       anthropicModels.find((model) => model.id === "default")?.displayName,
-    ).toBe("Default (recommended)");
+    ).toBe("Sonnet 4.6");
     expect(
-      anthropicModels.find((model) => model.id === "sonnet[1m]")?.displayName,
-    ).toBe("Sonnet (1M context)");
-    // claude-sonnet-4-6 collapsed into "default" as alias
+      anthropicModels.find((model) => model.id === "opus[1m]")?.displayName,
+    ).toBe("Opus 4.6");
     expect(
-      anthropicModels.some((model) => model.id === "claude-sonnet-4-6"),
-    ).toBe(false);
+      anthropicModels.find((model) => model.id === "haiku")?.displayName,
+    ).toBe("Haiku 4.5");
 
+    expect(resolveModelId("sonnet")).toBe("default");
+    expect(resolveModelId("sonnet[1m]")).toBe("default");
     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(resolveModelId("claude-sonnet-4-6[1m]")).toBe("default");
+    expect(resolveModelId("opus")).toBe("opus[1m]");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus[1m]");
   });
 
   it("derives compatibility aliases from SDK metadata instead of hardcoded versions", async () => {
@@ -134,8 +138,8 @@ describe("registerClaudeModels", () => {
 
     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-opus-5-0")).toBe("opus[1m]");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus[1m]");
     expect(resolveModelId("claude-haiku-5-0")).toBe("haiku");
     expect(resolveModelId("claude-haiku-4-5")).toBe("haiku");
   });

package/src/__tests__/fuzz.test.ts

@@ -327,13 +327,13 @@ describe("fuzz: resolveModelName()", () => {
   it("known aliases resolve to the expected SDK model IDs", () => {
     const aliasMappings = [
       ["sonnet", "default"],
-      ["opus", "opus"],
+      ["opus", "opus[1m]"],
       ["haiku", "haiku"],
       ["sonnet-4.6", "default"],
-      ["opus-4.6", "opus"],
+      ["opus-4.6", "opus[1m]"],
       ["haiku-4.5", "haiku"],
       ["sonnet-4-6", "default"],
-      ["opus-4-6", "opus"],
+      ["opus-4-6", "opus[1m]"],
       ["haiku-4-5", "haiku"],
     ] as const;
     fc.assert(

package/src/__tests__/handlers.test.ts

@@ -1917,6 +1917,61 @@ describe("sendHtml — falls back to plain text on HTML send failure", () => {
     // Restore sendMessage mock for other tests
     mockBot.api.sendMessage = vi.fn(async () => ({ message_id: 1 }));
   }, 3000);
+
+  it("fallback iterates to strip nested tag sequences", async () => {
+    executeMock.mockResolvedValue({
+      text: "",
+      durationMs: 10,
+      inputTokens: 1,
+      outputTokens: 1,
+      cacheRead: 0,
+      cacheWrite: 0,
+      bridgeMessageCount: 0,
+    });
+
+    let callCount = 0;
+    mockBot.api.sendMessage = vi.fn(async () => {
+      callCount++;
+      if (callCount === 1) throw new Error("Bad Request: can't parse entities");
+      return { message_id: callCount };
+    });
+
+    const { classify, friendlyMessage } = await import("../core/errors.js");
+    executeMock.mockRejectedValueOnce(new Error("some error"));
+    (classify as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      reason: "error",
+      message: "some error",
+      retryable: false,
+    });
+    // A single-pass regex leaves a `<script>` survivor after one removal
+    // of the inner placeholder — the iterative loop must keep going.
+    (friendlyMessage as ReturnType<typeof vi.fn>).mockReturnValueOnce(
+      "<scr<script>ipt>alert(1)</script> tail",
+    );
+
+    const ctx = {
+      chat: { id: 97002, type: "private" },
+      message: {
+        text: "nested tag fallback",
+        message_id: 961,
+        reply_to_message: null,
+      },
+      me: { id: 999, username: "testbot" },
+      from: { id: 95, first_name: "Zoe" },
+    } as any;
+
+    await handleTextMessage(ctx, mockBot, mockConfig);
+    await new Promise((r) => setTimeout(r, 700));
+
+    expect(mockBot.api.sendMessage).toHaveBeenCalledTimes(2);
+    const plain = (mockBot.api.sendMessage as ReturnType<typeof vi.fn>).mock
+      .calls[1][1];
+    expect(plain).not.toMatch(/<[^<>]*>/); // no complete tag remains
+    expect(plain).not.toContain("<");
+    expect(plain).toContain("alert(1)");
+
+    mockBot.api.sendMessage = vi.fn(async () => ({ message_id: 1 }));
+  }, 3000);
 });
 
 describe("createStreamCallbacks — onStreamDelta streaming path", () => {

package/src/__tests__/teams-frontend.test.ts

@@ -520,6 +520,34 @@ describe("teams formatting — default token type", () => {
     const result = stripHtmlFresh("<p>Hello <b>world</b></p>");
     expect(result).toBe("Hello world");
   });
+
+  it("stripHtml fallback iterates to remove nested tag sequences", async () => {
+    vi.resetModules();
+    vi.doMock("cheerio", () => ({
+      default: {},
+      load: vi.fn(() => {
+        throw new Error("cheerio unavailable");
+      }),
+    }));
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+      logDebug: vi.fn(),
+    }));
+
+    const { stripHtml: stripHtmlFresh } =
+      await import("../frontend/teams/formatting.js");
+    // Nested sequences must not leave any surviving `<...>` tag after the
+    // fallback runs. The iterative loop is what guarantees that — with a
+    // non-iterating single pass, certain crafted inputs can reconstruct a
+    // tag after the first removal.
+    const nested = "<scr<script>ipt>alert(1)</script>";
+    const result = stripHtmlFresh(nested);
+    expect(result).not.toMatch(/<[^<>]*>/); // no complete tag remains
+    expect(result).not.toContain("<");
+    expect(result).toContain("alert(1)");
+  });
 });
 
 // ── teams actions branch coverage ─────────────────────────────────────────

package/src/__tests__/telegram-formatting.test.ts

@@ -76,6 +76,10 @@ describe("escapeHtml", () => {
     expect(escapeHtml("<>&")).toBe("&lt;&gt;&amp;");
   });
 
+  it("escapes quotes so output is safe in attribute contexts", () => {
+    expect(escapeHtml(`"'`)).toBe("&quot;&#39;");
+  });
+
   it("passes through plain text unchanged", () => {
     expect(escapeHtml("hello world")).toBe("hello world");
   });

package/src/__tests__/telegram-helpers.test.ts

@@ -14,44 +14,34 @@ import {
 describe("telegram helpers", () => {
   beforeEach(() => {
     clearModels();
+    // Post-merge state: convertSdkModels collapses base/1M/claude-* variants
+    // of the same family+version into a single canonical entry. This fixture
+    // is what the registry looks like after that merge.
     registerModels([
       {
         id: "default",
-        displayName: "Default (recommended)",
+        displayName: "Sonnet 4.6",
         description: "Sonnet 4.6 · Best for everyday tasks",
-        aliases: ["sonnet", "claude-sonnet-4-6"],
+        aliases: [
+          "sonnet",
+          "sonnet[1m]",
+          "claude-sonnet-4-6",
+          "claude-sonnet-4-6[1m]",
+        ],
         provider: "anthropic",
         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",
-        fallback: "haiku",
-      },
-      {
-        id: "opus",
-        displayName: "Opus",
-        description: "Opus 4.6 · Most capable for complex work",
-        aliases: ["claude-opus-4-6"],
-        provider: "anthropic",
-        fallback: "default",
-      },
       {
         id: "opus[1m]",
-        displayName: "Opus (1M context)",
-        description:
-          "Opus 4.6 with 1M context · Billed as extra usage · $5/$25 per Mtok",
-        aliases: ["claude-opus-4-6[1m]"],
+        displayName: "Opus 4.6",
+        description: "Opus 4.6 with 1M context · Large context window",
+        aliases: ["opus", "claude-opus-4-6", "claude-opus-4-6[1m]"],
         provider: "anthropic",
         fallback: "default",
       },
       {
         id: "haiku",
-        displayName: "Haiku",
+        displayName: "Haiku 4.5",
         description: "Haiku 4.5 · Fastest for quick answers",
         aliases: ["claude-haiku-4-5"],
         provider: "anthropic",
@@ -59,16 +49,21 @@ describe("telegram helpers", () => {
     ]);
   });
 
-  it("matches legacy aliases to the canonical selected model", () => {
+  it("matches legacy aliases and 1M variants to the canonical selected model", () => {
     expect(isSelectedModel("claude-sonnet-4-6", "default")).toBe(true);
+    // sonnet[1m] is merged into "default" — same canonical model.
     expect(isSelectedModel("sonnet[1m]", "default")).toBe(true);
+    expect(isSelectedModel("claude-sonnet-4-6[1m]", "default")).toBe(true);
     expect(isSelectedModel("claude-sonnet-4-6", "haiku")).toBe(false);
   });
 
-  it("formats clean model labels for telegram users", () => {
+  it("formats labels using backend-registered displayName", () => {
     expect(formatModelLabel("default")).toBe("Sonnet 4.6");
     expect(formatModelLabel("claude-sonnet-4-6")).toBe("Sonnet 4.6");
+    // 1M variants collapse into the same entry — same clean label.
     expect(formatModelLabel("sonnet[1m]")).toBe("Sonnet 4.6");
+    expect(formatModelLabel("opus[1m]")).toBe("Opus 4.6");
+    expect(formatModelLabel("claude-opus-4-6")).toBe("Opus 4.6");
     expect(formatModelOptionLabel(getTelegramModelOptions()[0]!)).toBe(
       "Sonnet 4.6",
     );
@@ -77,10 +72,10 @@ describe("telegram helpers", () => {
     );
   });
 
-  it("shows a single clean option per model family", () => {
+  it("shows one option per family+version (base/1M variants merged)", () => {
     expect(getTelegramModelOptions().map((model) => model.id)).toEqual([
       "default",
-      "opus",
+      "opus[1m]",
       "haiku",
     ]);
   });

package/src/__tests__/telegram.test.ts

@@ -26,7 +26,7 @@ describe("markdownToTelegramHtml", () => {
     const input = "```python\nprint('hello')\n```";
     const result = markdownToTelegramHtml(input);
     expect(result).toContain('<code class="language-python">');
-    expect(result).toContain("print('hello')");
+    expect(result).toContain("print(&#39;hello&#39;)");
     expect(result).toContain("<pre>");
     expect(result).toContain("</pre>");
   });
@@ -46,9 +46,8 @@ describe("markdownToTelegramHtml", () => {
   });
 
   it("escapes HTML special characters in plain text", () => {
-    // escapeHtml handles &, <, > — single quotes are passed through
     expect(markdownToTelegramHtml("<script>alert('xss')</script>")).toBe(
-      "&lt;script&gt;alert('xss')&lt;/script&gt;",
+      "&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;",
     );
   });
 

package/src/__tests__/terminal-commands.test.ts

@@ -90,48 +90,6 @@ vi.mock("../core/plugin.js", () => ({
   getLoadedPlugins: () => mockGetLoadedPlugins(),
 }));
 
-const mockGetOpenCodeModelCatalog = vi.fn(async () => ({
-  generatedAt: Date.now(),
-  providers: [],
-  models: [],
-  connectedProviders: [],
-  loginProviders: [],
-  connectedModels: [],
-  connectedFreeModels: [],
-}));
-const mockGetOpenCodeModelInfo = vi.fn<
-  (modelId: string) => Promise<Record<string, unknown> | undefined>
->(async (_modelId: string) => undefined);
-const mockGetOpenCodeQuickPickModels = vi.fn<
-  (catalog: unknown, currentModelId?: string) => Array<unknown>
->(() => []);
-const mockResolveOpenCodeModelInput = vi.fn<
-  (query: string, catalog: unknown) => Record<string, unknown>
->((_query: string) => ({
-  kind: "missing",
-  matches: [],
-}));
-const mockGetOpenCodeSessionSnapshot = vi.fn<
-  (sessionId: string) => Promise<Record<string, unknown> | undefined>
->(async (_sessionId: string) => undefined);
-const mockGetOpenCodeModelSelectionValue = vi.fn<
-  (model: Record<string, unknown>, catalog: unknown) => string
->((model: Record<string, unknown>) => String(model.id ?? ""));
-vi.mock("../backend/opencode/index.js", () => ({
-  getOpenCodeModelCatalog: () => mockGetOpenCodeModelCatalog(),
-  getOpenCodeModelInfo: (modelId: string) => mockGetOpenCodeModelInfo(modelId),
-  getOpenCodeModelSelectionValue: (
-    model: Record<string, unknown>,
-    catalog: unknown,
-  ) => mockGetOpenCodeModelSelectionValue(model, catalog),
-  getOpenCodeQuickPickModels: (catalog: unknown, currentModelId?: string) =>
-    mockGetOpenCodeQuickPickModels(catalog, currentModelId),
-  resolveOpenCodeModelInput: (query: string, catalog: unknown) =>
-    mockResolveOpenCodeModelInput(query, catalog),
-  getOpenCodeSessionSnapshot: (sessionId: string) =>
-    mockGetOpenCodeSessionSnapshot(sessionId),
-}));
-
 import {
   registerCommand,
   tryRunCommand,
@@ -257,9 +215,6 @@ describe("built-in commands", () => {
     clearCommands();
     registerBuiltinCommands();
     vi.clearAllMocks();
-    mockGetOpenCodeModelSelectionValue.mockImplementation(
-      (model: Record<string, unknown>) => String(model.id ?? ""),
-    );
   });
 
   it("registers all expected commands", () => {
@@ -328,35 +283,25 @@ describe("built-in commands", () => {
       );
     });
 
-    it("stores provider-qualified OpenCode model selections when needed", async () => {
-      mockGetOpenCodeModelCatalog.mockResolvedValueOnce({
-        generatedAt: Date.now(),
-        providers: [],
-        models: [],
-        connectedProviders: [],
-        loginProviders: [],
-        connectedModels: [],
-        connectedFreeModels: [],
-      });
-      mockResolveOpenCodeModelInput.mockReturnValueOnce({
-        kind: "exact",
-        model: {
-          id: "gpt-5",
-          providerID: "github-copilot",
-          providerName: "GitHub Copilot",
-          free: false,
-          selectable: true,
-          loginRequired: false,
-          envRequired: false,
-          authMethods: [],
-        },
-      });
-      mockGetOpenCodeModelSelectionValue.mockReturnValueOnce(
-        "github-copilot/gpt-5",
-      );
-
+    it("stores provider-qualified model selections via backend.resolveModel", async () => {
       const ctx = makeMockContext({
-        config: { model: "nemotron-3-super-free", backend: "opencode" } as any,
+        config: { model: "nemotron-3-super-free" } as any,
+        backend: {
+          query: vi.fn() as any,
+          resolveModel: vi.fn().mockResolvedValue({
+            kind: "exact",
+            model: {
+              id: "gpt-5",
+              displayName: "GPT-5",
+              provider: "github-copilot",
+              providerName: "GitHub Copilot",
+              free: false,
+              selectable: true,
+            },
+            storedValue: "github-copilot/gpt-5",
+          }),
+          formatModelError: vi.fn(),
+        },
       });
 
       await tryRunCommand("/model github-copilot/gpt-5", ctx);
@@ -366,7 +311,7 @@ describe("built-in commands", () => {
         "github-copilot/gpt-5",
       );
       expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
-        expect.stringContaining("github-copilot/gpt-5"),
+        expect.stringContaining("GPT-5"),
       );
     });
   });
@@ -593,7 +538,7 @@ describe("/status command", () => {
     expect(calls.join(" ")).toContain("actions only");
   });
 
-  it("/status uses live OpenCode usage totals when backend is opencode", async () => {
+  it("/status uses live backend usage totals via getSessionSnapshot", async () => {
     mockGetSessionInfo.mockReturnValueOnce({
       turns: 14,
       sessionId: "ses_live",
@@ -612,58 +557,31 @@ describe("/status command", () => {
       },
     });
     mockGetChatSettings.mockReturnValueOnce({ model: "big-pickle" });
-    mockGetOpenCodeModelInfo.mockResolvedValueOnce({
-      id: "big-pickle",
-      name: "Big Pickle",
-      providerID: "opencode",
-      providerName: "OpenCode Zen",
-      providerSource: "builtin",
-      connected: true,
-      selectable: true,
-      loginRequired: false,
-      envRequired: false,
-      authMethods: [],
-      free: true,
-      status: "active",
-      contextWindow: 204800,
-      outputWindow: 128000,
-      reasoning: true,
-      attachment: false,
-      toolcall: true,
-      costInput: 0,
-      costOutput: 0,
-      costCacheRead: 0,
-      costCacheWrite: 0,
-    });
-    mockGetOpenCodeSessionSnapshot.mockResolvedValueOnce({
-      sessionId: "ses_live",
-      assistant: {
-        modelID: "big-pickle",
-        providerID: "opencode",
-        inputTokens: 42200,
-        outputTokens: 20,
-        reasoningTokens: 10,
-        cacheRead: 0,
-        cacheWrite: 0,
-        costUsd: 0,
-        totalTokens: 42220,
-      },
-      usage: {
-        assistantMessages: 42,
-        totalInputTokens: 1389045,
-        totalOutputTokens: 3675,
-        totalReasoningTokens: 4717,
-        totalCacheRead: 0,
-        totalCacheWrite: 0,
-        totalCostUsd: 0,
-      },
-    });
 
     const ctx = makeMockContext({
       config: {
         model: "big-pickle",
-        backend: "opencode",
       } as CommandContext["config"],
+      backend: {
+        query: vi.fn() as any,
+        getModelInfo: vi.fn().mockResolvedValue({
+          id: "big-pickle",
+          displayName: "Big Pickle",
+          provider: "opencode",
+          providerName: "OpenCode Zen",
+          free: true,
+          contextWindow: 204800,
+          selectable: true,
+        }),
+        getSessionSnapshot: vi.fn().mockResolvedValue({
+          inputTokens: 1389045,
+          outputTokens: 3675,
+          cacheRead: 0,
+          cacheWrite: 0,
+          contextModelId: "big-pickle",
+        }),
+        backendLabel: "OpenCode",
+      },
     });
     await tryRunCommand("/status", ctx);
 

package/src/__tests__/workspace.test.ts

@@ -6,10 +6,44 @@ import {
   existsSync,
   readdirSync,
   symlinkSync,
+  unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
+// Probe whether this platform/user can create symlinks (Windows requires
+// Developer Mode or admin). Declaration-time gate via it.runIf avoids any
+// runtime skip call in tests.
+const canSymlink = (() => {
+  const probeDir = join(tmpdir(), `talon-ws-symlink-probe-${Date.now()}`);
+  const target = join(probeDir, "target");
+  const link = join(probeDir, "link");
+  try {
+    mkdirSync(probeDir, { recursive: true });
+    writeFileSync(target, "x");
+    symlinkSync(target, link);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      unlinkSync(link);
+    } catch {
+      /* ignore */
+    }
+    try {
+      unlinkSync(target);
+    } catch {
+      /* ignore */
+    }
+    try {
+      rmSync(probeDir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+})();
+
 // Mock log to prevent pino initialization issues
 vi.mock("../util/log.js", () => ({
   log: vi.fn(),
@@ -216,15 +250,20 @@ describe("getWorkspaceDiskUsage — edge cases", () => {
     expect(usage).toBe(8);
   });
 
-  it("skips symlinks — entry.isFile() FALSE branch (L147)", () => {
-    mkdirSync(TEST_ROOT, { recursive: true });
-    writeFileSync(join(TEST_ROOT, "real.txt"), "hello"); // 5 bytes
-    // symlink: isDirectory()=false, isFile()=false → skipped by walk
-    symlinkSync(join(TEST_ROOT, "real.txt"), join(TEST_ROOT, "link.txt"));
-    const usage = getWorkspaceDiskUsage(TEST_ROOT);
-    // Only real.txt counts (5 bytes); symlink is not counted
-    expect(usage).toBe(5);
-  });
+  // Gated at declaration time via it.runIf — Windows without Developer
+  // Mode / admin throws EPERM on symlinkSync, so the test only runs where
+  // the platform actually supports the primitive.
+  it.runIf(canSymlink)(
+    "skips symlinks — entry.isFile() FALSE branch (L147)",
+    () => {
+      mkdirSync(TEST_ROOT, { recursive: true });
+      writeFileSync(join(TEST_ROOT, "real.txt"), "hello"); // 5 bytes
+      symlinkSync(join(TEST_ROOT, "real.txt"), join(TEST_ROOT, "link.txt"));
+      const usage = getWorkspaceDiskUsage(TEST_ROOT);
+      // Only real.txt counts (5 bytes); symlink is not counted
+      expect(usage).toBe(5);
+    },
+  );
 });
 
 describe("startUploadCleanup — setInterval callback (function coverage)", () => {

package/src/backend/claude-sdk/constants.ts

@@ -1,32 +1,17 @@
 /**
- * Shared constants for Claude SDK backend and background agents.
+ * Claude SDK backend constants — thinking effort, streaming, and
+ * chat-specific tool restrictions.
  *
- * Single source of truth for disallowed tool lists, thinking effort
- * configuration, and streaming parameters.
+ * Core disallowed-tool lists live in core/constants.ts (backend-agnostic).
  */
 
-// ── Disallowed tool lists ──────────────────────────────────────────────────
+import {
+  DISALLOWED_TOOLS_CORE,
+  DISALLOWED_TOOLS_BACKGROUND,
+} from "../../core/constants.js";
 
-/**
- * Core tools disallowed in all SDK query contexts (chat, heartbeat, dream).
- * These are interactive or planning-only tools that make no sense in a
- * headless agent context.
- */
-export const DISALLOWED_TOOLS_CORE = [
-  "EnterPlanMode",
-  "ExitPlanMode",
-  "EnterWorktree",
-  "ExitWorktree",
-  "TodoWrite",
-  "TodoRead",
-  "TaskCreate",
-  "TaskUpdate",
-  "TaskGet",
-  "TaskList",
-  "TaskOutput",
-  "TaskStop",
-  "AskUserQuestion",
-] as const;
+// Re-export so existing backend imports keep working
+export { DISALLOWED_TOOLS_CORE, DISALLOWED_TOOLS_BACKGROUND };
 
 /** Disallowed tools for the main chat handler (core + web tools replaced by Brave MCP). */
 export const DISALLOWED_TOOLS_CHAT = [
@@ -35,12 +20,6 @@ export const DISALLOWED_TOOLS_CHAT = [
   "WebFetch",
 ] as const;
 
-/** Disallowed tools for background agents — heartbeat and dream (core + Agent). */
-export const DISALLOWED_TOOLS_BACKGROUND = [
-  ...DISALLOWED_TOOLS_CORE,
-  "Agent",
-] as const;
-
 // ── Thinking / effort configuration ────────────────────────────────────────
 
 export const EFFORT_MAP: Record<