@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/tool-executor.test.ts

@@ -51,6 +51,9 @@ let lastCheckArgs:
 /** Optional override for getTool — lets tests supply skill-origin tools. */
 let getToolOverride: ((name: string) => Tool | undefined) | undefined;
 
+/** Optional override for getAllTools — lets tests supply a registry snapshot. */
+let getAllToolsOverride: (() => Tool[]) | undefined;
+
 /** Override the check() result for tests that need to trigger prompting. */
 let checkResultOverride: { decision: string; reason: string } | undefined;
 
@@ -144,7 +147,7 @@ mock.module("../tools/registry.js", () => ({
       execute: async () => fakeToolResult,
     };
   },
-  getAllTools: () => [],
+  getAllTools: () => (getAllToolsOverride ? getAllToolsOverride() : []),
 }));
 
 mock.module("../tools/shared/filesystem/path-policy.js", () => ({
@@ -179,6 +182,7 @@ describe("ToolExecutor allowedToolNames gating", () => {
     fakeToolResult = { content: "ok", isError: false };
     lastCheckArgs = undefined;
     getToolOverride = undefined;
+    getAllToolsOverride = undefined;
     checkResultOverride = undefined;
     checkFnOverride = undefined;
     cachedAssessmentOverride = undefined;
@@ -271,6 +275,89 @@ describe("ToolExecutor allowedToolNames gating", () => {
     expect(result.content).toContain("file_read");
     expect(result.content).toContain("not currently active");
   });
+
+  test("unknown tool suggestion list is scoped to allowedToolNames", async () => {
+    // Surfacing every globally registered tool would leak tools active in
+    // other sessions and misdirect the model to tools it cannot invoke.
+    const makeTool = (name: string): Tool =>
+      ({
+        name,
+        description: "test tool",
+        category: "test",
+        defaultRiskLevel: RiskLevel.Low,
+        getDefinition: () => ({
+          name,
+          description: "test tool",
+          input_schema: { type: "object" as const, properties: {} },
+        }),
+        execute: async () => fakeToolResult,
+      }) as unknown as Tool;
+    getAllToolsOverride = () => [
+      makeTool("file_read"),
+      makeTool("file_write"),
+      makeTool("secret_skill_tool"),
+    ];
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["file_read", "file_write"]);
+    const result = await executor.execute(
+      "unknown_tool",
+      { foo: "bar" },
+      makeContext({ allowedToolNames: allowed }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(
+      "Unknown tool: unknown_tool. Available tools: file_read, file_write",
+    );
+    expect(result.content).not.toContain("secret_skill_tool");
+  });
+
+  test("unknown tool name reports 'Unknown tool' even when allowedToolNames is set", async () => {
+    // Regression: a hallucinated tool name with allowedToolNames set used to
+    // hit the "not currently active. Load the skill that provides this tool
+    // first." gate, which sent the model chasing a nonexistent skill. The
+    // registry-lookup gate runs first now so the model sees the real list.
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["file_read"]);
+    const result = await executor.execute(
+      "unknown_tool",
+      { foo: "bar" },
+      makeContext({ allowedToolNames: allowed }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Unknown tool: unknown_tool");
+    expect(result.content).not.toContain("not currently active");
+  });
+
+  test("inactive skill tool names the owning skill in the load hint", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    getToolOverride = (name: string) => {
+      if (name !== "skill_tool_x") return undefined;
+      return {
+        name,
+        description: "tool from a skill",
+        category: "skill",
+        defaultRiskLevel: RiskLevel.Low,
+        origin: "skill" as const,
+        ownerSkillId: "my-skill",
+        getDefinition: () => ({
+          name,
+          description: "tool from a skill",
+          input_schema: { type: "object" as const, properties: {} },
+        }),
+        execute: async () => fakeToolResult,
+      };
+    };
+    const allowed = new Set(["file_read"]);
+    const result = await executor.execute(
+      "skill_tool_x",
+      {},
+      makeContext({ allowedToolNames: allowed }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(
+      'Tool "skill_tool_x" is not currently active. Load the "my-skill" skill that provides this tool first.',
+    );
+  });
 });
 
 describe("ToolExecutor policy context plumbing", () => {
@@ -846,6 +933,7 @@ describe("ToolExecutor forcePromptSideEffects enforcement", () => {
 // Import the real buildSanitizedEnv (not mocked) for baseline credential tests
 const {
   buildSanitizedEnv,
+  KATA_INJECTED_ENV_VARS,
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
   ALWAYS_INJECTED_ENV_VARS,
@@ -910,6 +998,7 @@ describe("buildSanitizedEnv — baseline: credential exclusion", () => {
     const allowed: string[] = [
       ...SAFE_ENV_VARS,
       ...KATA_SAFE_ENV_VARS,
+      ...KATA_INJECTED_ENV_VARS,
       ...ALWAYS_INJECTED_ENV_VARS,
     ];
     const env = buildSanitizedEnv();

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Tests that `ToolExecutionResult.activityMetadata` plumbs through to the
+ * emitted `tool_result` server event via `handleToolResult`. The forward path
+ * is: ToolExecutionResult (set by the tool executor) → AgentEvent tool_result
+ * (emitted by the agent loop) → tool_result server message (emitted by
+ * handleToolResult to the SSE sink).
+ *
+ * Mirrors the mocked-dependency pattern used in tool-preview-lifecycle.test.ts
+ * and annotate-risk-options.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleToolResult,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+
+type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function createCollectorDeps(): {
+  deps: EventHandlerDeps;
+  events: ServerMessage[];
+} {
+  const events: ServerMessage[] = [];
+  const deps = {
+    ctx: {
+      conversationId: "conv-meta",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (msg: ServerMessage) => events.push(msg),
+    reqId: "req-meta",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+  return { deps, events };
+}
+
+function primeState(state: EventHandlerState, toolUseId: string): void {
+  state.toolUseIdToName.set(toolUseId, "web_search");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: Date.now() });
+  state.currentTurnToolUseIds.push(toolUseId);
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("tool_result activityMetadata plumbing", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    state = createEventHandlerState();
+  });
+
+  test("forwards activityMetadata to the emitted tool_result event", () => {
+    const { deps, events } = createCollectorDeps();
+    const toolUseId = "toolu_meta_present";
+    primeState(state, toolUseId);
+
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "x",
+        provider: "tavily",
+        resultCount: 0,
+        durationMs: 1,
+        results: [],
+      },
+    };
+
+    handleToolResult(state, deps, {
+      type: "tool_result",
+      toolUseId,
+      content: "",
+      isError: false,
+      activityMetadata,
+    });
+
+    const toolResultEvent = events.find(
+      (e): e is ToolResultEvent => e.type === "tool_result",
+    );
+    expect(toolResultEvent).toBeDefined();
+    expect(toolResultEvent?.activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("omits activityMetadata when the executor did not populate it", () => {
+    const { deps, events } = createCollectorDeps();
+    const toolUseId = "toolu_meta_absent";
+    primeState(state, toolUseId);
+
+    handleToolResult(state, deps, {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+    });
+
+    const toolResultEvent = events.find(
+      (e): e is ToolResultEvent => e.type === "tool_result",
+    );
+    expect(toolResultEvent).toBeDefined();
+    expect(toolResultEvent?.activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/twilio-routes.test.ts

@@ -311,7 +311,7 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 }));
 
 mock.module("../providers/registry.js", () => ({
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 import {

package/src/__tests__/web-fetch.test.ts

@@ -1622,8 +1622,8 @@ describe("web_fetch tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("Extracted text content is very short");
-    expect(result.content).toContain("JavaScript rendering");
+    expect(result.content).toContain("Extracted only");
+    expect(result.content).toContain("JavaScript-rendered");
   });
 
   test("does not suggest browser skill when HTML page has substantial content", async () => {

package/src/__tests__/workspace-git-service.test.ts

@@ -5,6 +5,7 @@ import {
   mkdirSync,
   readFileSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -87,6 +88,58 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("installs branch guard hook that blocks non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+
+      const hookPath = join(testDir, ".githooks", "reference-transaction");
+      expect(existsSync(hookPath)).toBe(true);
+      expect(statSync(hookPath).mode & 0o111).not.toBe(0);
+
+      const hookContent = readFileSync(hookPath, "utf-8");
+      expect(hookContent).toContain(
+        "assistant workspace git branches are disabled",
+      );
+
+      expect(() =>
+        execFileSync("git", ["branch", "apollo/test-branch"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
+    test("branch guard allows deleting old non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      execFileSync(
+        "git",
+        ["-c", "core.hooksPath=/dev/null", "branch", "old-branch"],
+        {
+          cwd: testDir,
+        },
+      );
+
+      execFileSync("git", ["branch", "-D", "old-branch"], { cwd: testDir });
+
+      const branches = execFileSync(
+        "git",
+        ["branch", "--format=%(refname:short)"],
+        {
+          cwd: testDir,
+          encoding: "utf-8",
+        },
+      );
+      expect(branches).not.toContain("old-branch");
+    });
+
     test("multiple ensureInitialized calls are idempotent", async () => {
       const service = new WorkspaceGitService(testDir);
 
@@ -487,7 +540,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo on a feature branch
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -527,7 +580,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo then detach HEAD
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -571,7 +624,7 @@ describe("WorkspaceGitService", () => {
       // This exercises the --discard-changes fallback in ensureOnMainLocked().
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "original content");
@@ -619,7 +672,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo without our gitignore rules
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, ".gitignore"), "node_modules/\n");
@@ -648,7 +701,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo with the OLD broad data/ rule
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       const oldGitignore =
@@ -711,6 +764,36 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("existing repo gets branch guard installed on init", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      writeFileSync(join(testDir, "file.txt"), "content");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+      expect(
+        existsSync(join(testDir, ".githooks", "reference-transaction")),
+      ).toBe(true);
+
+      expect(() =>
+        execFileSync("git", ["branch", "feature-after-init"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
     test("existing repo with correct config is idempotent", async () => {
       // Set up a repo that already has everything configured correctly
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });

package/src/__tests__/workspace-migration-087-memory-router-balanced-profile.test.ts

@@ -0,0 +1,228 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { memoryRouterBalancedProfileMigration } from "../workspace/migrations/087-memory-router-balanced-profile.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-087-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("087-memory-router-balanced-profile migration", () => {
+  test("has correct migration id", () => {
+    expect(memoryRouterBalancedProfileMigration.id).toBe(
+      "087-memory-router-balanced-profile",
+    );
+  });
+
+  test("replaces seeded Sonnet 4.6 + 1M context with balanced profile", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("creates the call site when missing", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("writes a fresh starter config when config.json is absent", () => {
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("skips BYOK / non-Anthropic workspaces to avoid breaking memoryRouter", () => {
+    // `balanced` resolves to the managed Anthropic connection, which BYOK
+    // installs disable. Rewriting to `balanced` there would silently disable
+    // memory injection (getConfiguredProvider returns null). Preserve whatever
+    // memoryRouter config the workspace already has — including absence.
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        callSites: {
+          memoryRouter: { model: "gpt-5.4" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({ model: "gpt-5.4" });
+  });
+
+  test("skips BYOK workspaces with no existing memoryRouter entry", () => {
+    writeConfig({
+      llm: { default: { provider: "gemini" } },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites?.memoryRouter).toBeUndefined();
+  });
+
+  test("preserves user customizations on memoryRouter (non-077-seeded shape)", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-haiku-4-5-20251001",
+            effort: "low",
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+    });
+  });
+
+  test("is idempotent — second run does not change the call site", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          memoryRouter: { model: "claude-sonnet-4-6" },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.memoryRouter).toEqual({
+      model: "claude-sonnet-4-6",
+    });
+  });
+
+  test("preserves sibling call-site entries", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+          memoryRouter: {
+            model: "claude-sonnet-4-6",
+            contextWindow: { maxInputTokens: 1_000_000 },
+          },
+        },
+      },
+    });
+
+    memoryRouterBalancedProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+    expect(config.llm.callSites.memoryRouter).toEqual({ profile: "balanced" });
+  });
+});