@vellumai/assistant 0.4.43 → 0.4.45

package/scripts/generate-bundled-tool-registry.ts

@@ -0,0 +1,223 @@
+#!/usr/bin/env bun
+/**
+ * Generates `src/config/bundled-tool-registry.ts` by reading every
+ * `TOOLS.json` under `src/config/bundled-skills/`.
+ *
+ * Usage:
+ *   cd assistant && bun run scripts/generate-bundled-tool-registry.ts
+ */
+
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+
+const ROOT = resolve(import.meta.dir, "../src/config/bundled-skills");
+const OUTPUT = resolve(
+  import.meta.dir,
+  "../src/config/bundled-tool-registry.ts",
+);
+
+interface ToolEntry {
+  executor: string;
+  [key: string]: unknown;
+}
+
+interface ToolsJson {
+  version: number;
+  tools: ToolEntry[];
+}
+
+/** Convert a kebab-case filename stem to camelCase. */
+function toCamelCase(kebab: string): string {
+  return kebab.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+
+/** Build the section separator comment (e.g. `// ── browser ──…`). */
+function sectionComment(skillName: string): string {
+  const inner = ` ${skillName} `;
+  // Target total line width of ~80 chars
+  const remaining = 80 - 3 - inner.length; // 3 for "// "
+  const suffix = "─".repeat(Math.max(1, remaining));
+  return `// ──${inner}${"─".repeat(0)}${suffix}`;
+}
+
+async function main() {
+  const entries = await readdir(ROOT, { withFileTypes: true });
+  const skillDirs = entries
+    .filter((e) => e.isDirectory() && e.name !== "_shared")
+    .map((e) => e.name)
+    .sort();
+
+  // First pass: collect all executors and detect alias collisions.
+  const skills: {
+    name: string;
+    tools: {
+      executor: string;
+      registryKey: string;
+      importPath: string;
+      alias: string;
+    }[];
+  }[] = [];
+
+  // Map from alias → skill that first claimed it (for collision detection).
+  const claimedAliases = new Map<string, string>();
+  // Track which aliases need collision-prefixing.
+  const collidedAliases = new Set<string>();
+
+  for (const skillDir of skillDirs) {
+    const toolsJsonPath = join(ROOT, skillDir, "TOOLS.json");
+    let raw: string;
+    try {
+      raw = await readFile(toolsJsonPath, "utf-8");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        // No TOOLS.json — skip this skill.
+        continue;
+      }
+      throw err;
+    }
+
+    const toolsJson: ToolsJson = JSON.parse(raw);
+    const toolEntries: (typeof skills)[number]["tools"] = [];
+
+    for (const tool of toolsJson.tools) {
+      const executor = tool.executor;
+      const registryKey = `${skillDir}:${executor}`;
+      const importPath = `./bundled-skills/${skillDir}/${executor.replace(".ts", ".js")}`;
+      const stem = basename(executor, ".ts");
+      const baseAlias = toCamelCase(stem);
+
+      const existingSkill = claimedAliases.get(baseAlias);
+      if (existingSkill !== undefined && existingSkill !== skillDir) {
+        collidedAliases.add(baseAlias);
+      }
+      claimedAliases.set(baseAlias, skillDir);
+
+      toolEntries.push({ executor, registryKey, importPath, alias: baseAlias });
+    }
+
+    if (toolEntries.length > 0) {
+      skills.push({ name: skillDir, tools: toolEntries });
+    }
+  }
+
+  // Second pass: resolve collided aliases by adding skill prefix.
+  for (const skill of skills) {
+    for (const tool of skill.tools) {
+      if (collidedAliases.has(tool.alias)) {
+        const prefix = toCamelCase(skill.name);
+        tool.alias = `${prefix}_${tool.alias}`;
+      }
+    }
+  }
+
+  // Check for remaining duplicates within same skill (shouldn't happen but be safe).
+  const finalAliases = new Set<string>();
+  for (const skill of skills) {
+    for (const tool of skill.tools) {
+      if (finalAliases.has(tool.alias)) {
+        // Append skill prefix if not already present.
+        const prefix = toCamelCase(skill.name);
+        if (!tool.alias.startsWith(prefix)) {
+          tool.alias = `${prefix}${tool.alias.charAt(0).toUpperCase()}${tool.alias.slice(1)}`;
+        }
+      }
+      finalAliases.add(tool.alias);
+    }
+  }
+
+  // Generate output.
+  const lines: string[] = [];
+
+  // File header.
+  lines.push(`/**`);
+  lines.push(` * Auto-generated registry of bundled skill tool scripts.`);
+  lines.push(` *`);
+  lines.push(
+    ` * In compiled Bun binaries, bundled tool scripts can't be dynamically`,
+  );
+  lines.push(
+    ` * imported from the filesystem because their relative imports point to`,
+  );
+  lines.push(
+    ` * modules that only exist inside the binary's virtual /$bunfs/ filesystem.`,
+  );
+  lines.push(` *`);
+  lines.push(
+    ` * This registry eagerly imports every bundled tool script so it becomes`,
+  );
+  lines.push(
+    ` * part of the compiled binary.  At runtime, the skill-script-runner`,
+  );
+  lines.push(` * checks this map before falling back to a dynamic import.`);
+  lines.push(` *`);
+  lines.push(` * Regenerate with:`);
+  lines.push(` *   bun run scripts/generate-bundled-tool-registry.ts`);
+  lines.push(` */`);
+  lines.push(
+    `import type { SkillToolScript } from "../tools/skills/script-contract.js";`,
+  );
+
+  // Import statements grouped by skill, sorted by import path within each
+  // group so the output satisfies eslint simple-import-sort.
+  for (const skill of skills) {
+    // Strip `.js` before comparing so `browser-wait-for` sorts before
+    // `browser-wait-for-download`, matching simple-import-sort's order.
+    const sorted = [...skill.tools].sort((a, b) =>
+      a.importPath
+        .replace(/\.js$/, "")
+        .localeCompare(b.importPath.replace(/\.js$/, "")),
+    );
+    lines.push(sectionComment(skill.name));
+    for (const tool of sorted) {
+      lines.push(`import * as ${tool.alias} from "${tool.importPath}";`);
+    }
+  }
+
+  // Registry map.
+  lines.push(``);
+  lines.push(
+    `// ─── Registry ────────────────────────────────────────────────────────────────`,
+  );
+  lines.push(``);
+  lines.push(
+    `/** Key format: \`skillDirBasename:executorPath\` (e.g. \`schedule:tools/schedule-list.ts\`). */`,
+  );
+  lines.push(
+    `export const bundledToolRegistry = new Map<string, SkillToolScript>([`,
+  );
+
+  for (let i = 0; i < skills.length; i++) {
+    const skill = skills[i];
+    lines.push(`  // ${skill.name}`);
+    for (const tool of skill.tools) {
+      const entry = `["${tool.registryKey}", ${tool.alias}]`;
+      // Wrap long lines.
+      if (`  ${entry},`.length > 80) {
+        lines.push(`  [`);
+        lines.push(`    "${tool.registryKey}",`);
+        lines.push(`    ${tool.alias},`);
+        lines.push(`  ],`);
+      } else {
+        lines.push(`  ${entry},`);
+      }
+    }
+
+    if (i < skills.length - 1) {
+      lines.push(``);
+    }
+  }
+
+  lines.push(`]);`);
+  lines.push(``); // trailing newline
+
+  await writeFile(OUTPUT, lines.join("\n"), "utf-8");
+  console.log(`✓ Generated ${OUTPUT}`);
+  console.log(
+    `  ${skills.length} skills, ${skills.reduce((n, s) => n + s.tools.length, 0)} tools`,
+  );
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/__tests__/access-request-decision.test.ts

@@ -25,7 +25,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/actor-token-service.test.ts

@@ -23,7 +23,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
@@ -64,8 +63,8 @@ import {
 } from "../runtime/auth/token-service.js";
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import {
-  resolveLocalIpcAuthContext,
-  resolveLocalIpcTrustContext,
+  resolveLocalAuthContext,
+  resolveLocalTrustContext,
 } from "../runtime/local-actor-identity.js";
 
 // ---------------------------------------------------------------------------
@@ -358,20 +357,20 @@ describe("bootstrap endpoint idempotency", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Local IPC identity resolution
+// Local identity resolution
 // ---------------------------------------------------------------------------
 
-describe("resolveLocalIpcTrustContext", () => {
+describe("resolveLocalTrustContext", () => {
   test("returns guardian context when vellum binding exists", () => {
     ensureVellumGuardianBinding("self");
 
-    const ctx = resolveLocalIpcTrustContext();
+    const ctx = resolveLocalTrustContext();
     expect(ctx.trustClass).toBe("guardian");
     expect(ctx.sourceChannel).toBe("vellum");
   });
 
   test("returns guardian context with principal when no vellum binding exists (pre-bootstrap self-heal)", () => {
-    const ctx = resolveLocalIpcTrustContext();
+    const ctx = resolveLocalTrustContext();
     expect(ctx.trustClass).toBe("guardian");
     expect(ctx.sourceChannel).toBe("vellum");
     expect(ctx.guardianPrincipalId).toBeDefined();
@@ -379,35 +378,35 @@ describe("resolveLocalIpcTrustContext", () => {
 
   test("respects custom sourceChannel parameter", () => {
     ensureVellumGuardianBinding("self");
-    const ctx = resolveLocalIpcTrustContext("vellum");
+    const ctx = resolveLocalTrustContext("vellum");
     expect(ctx.sourceChannel).toBe("vellum");
   });
 });
 
 // ---------------------------------------------------------------------------
-// Local IPC AuthContext resolution
+// Local AuthContext resolution
 // ---------------------------------------------------------------------------
 
-describe("resolveLocalIpcAuthContext", () => {
-  test("returns AuthContext with ipc principal type", () => {
-    const ctx = resolveLocalIpcAuthContext("session-123");
-    expect(ctx.principalType).toBe("ipc");
+describe("resolveLocalAuthContext", () => {
+  test("returns AuthContext with local principal type", () => {
+    const ctx = resolveLocalAuthContext("session-123");
+    expect(ctx.principalType).toBe("local");
   });
 
-  test("subject follows ipc:self:<sessionId> pattern", () => {
-    const ctx = resolveLocalIpcAuthContext("session-abc");
-    expect(ctx.subject).toBe("ipc:self:session-abc");
+  test("subject follows local:self:<sessionId> pattern", () => {
+    const ctx = resolveLocalAuthContext("session-abc");
+    expect(ctx.subject).toBe("local:self:session-abc");
   });
 
   test("assistantId is always self", () => {
-    const ctx = resolveLocalIpcAuthContext("session-123");
+    const ctx = resolveLocalAuthContext("session-123");
     expect(ctx.assistantId).toBe("self");
   });
 
-  test("uses ipc_v1 scope profile with ipc.all scope", () => {
-    const ctx = resolveLocalIpcAuthContext("session-123");
-    expect(ctx.scopeProfile).toBe("ipc_v1");
-    expect(ctx.scopes.has("ipc.all")).toBe(true);
+  test("uses local_v1 scope profile with local.all scope", () => {
+    const ctx = resolveLocalAuthContext("session-123");
+    expect(ctx.scopeProfile).toBe("local_v1");
+    expect(ctx.scopes.has("local.all")).toBe(true);
   });
 
   test("enriches actorPrincipalId from vellum guardian binding when present", () => {
@@ -415,7 +414,7 @@ describe("resolveLocalIpcAuthContext", () => {
     const guardianResult = findGuardianForChannel("vellum");
     expect(guardianResult).toBeTruthy();
 
-    const ctx = resolveLocalIpcAuthContext("session-123");
+    const ctx = resolveLocalAuthContext("session-123");
     expect(ctx.actorPrincipalId).toBe(
       guardianResult!.contact.principalId ?? undefined,
     );
@@ -426,14 +425,14 @@ describe("resolveLocalIpcAuthContext", () => {
     resetDb();
     initializeDb();
 
-    const ctx = resolveLocalIpcAuthContext("session-123");
+    const ctx = resolveLocalAuthContext("session-123");
     // Self-heal creates a vellum guardian binding automatically
     expect(ctx.actorPrincipalId).toBeDefined();
     expect(ctx.actorPrincipalId).toMatch(/^vellum-principal-/);
   });
 
   test("sessionId matches the provided argument", () => {
-    const ctx = resolveLocalIpcAuthContext("my-session");
+    const ctx = resolveLocalAuthContext("my-session");
     expect(ctx.sessionId).toBe("my-session");
   });
 });

package/src/__tests__/agent-loop.test.ts

@@ -501,137 +501,6 @@ describe("AgentLoop", () => {
     expect(reminderBlock).toBeDefined();
   });
 
-  test("stops after configured maxToolUseTurns to prevent runaway loops", async () => {
-    const responses: ProviderResponse[] = [
-      toolUseResponse("t1", "read_file", { path: "/one.txt" }),
-      toolUseResponse("t2", "read_file", { path: "/two.txt" }),
-      toolUseResponse("t3", "read_file", { path: "/three.txt" }),
-      textResponse("Should never be requested"),
-    ];
-    const { provider, calls } = createMockProvider(responses);
-    const toolExecutor = async () => ({ content: "data", isError: false });
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      { maxToolUseTurns: 3 },
-      dummyTools,
-      toolExecutor,
-    );
-
-    const events: AgentEvent[] = [];
-    const history = await loop.run([userMessage], collectEvents(events));
-
-    // The loop should stop immediately after the 3rd tool-use turn, before the next provider call.
-    expect(calls).toHaveLength(3);
-
-    const errorEvents = events.filter(
-      (e): e is Extract<AgentEvent, { type: "error" }> => e.type === "error",
-    );
-    expect(errorEvents).toHaveLength(1);
-    expect(errorEvents[0].error.message).toContain(
-      "Tool-use turn limit reached (3)",
-    );
-
-    const lastMessage = history[history.length - 1];
-    expect(lastMessage.role).toBe("user");
-    const limitText = lastMessage.content.find(
-      (b): b is Extract<ContentBlock, { type: "text" }> =>
-        b.type === "text" && b.text.includes("Tool-use turn limit reached (3)"),
-    );
-    expect(limitText).toBeDefined();
-  });
-
-  test("injects approaching-limit warning before the hard stop", async () => {
-    // maxToolUseTurns: 8, soft warning at turn 3 (8 - 5 = 3)
-    const responses: ProviderResponse[] = [];
-    for (let i = 0; i < 8; i++) {
-      responses.push(
-        toolUseResponse(`t${i}`, "read_file", { path: `/${i}.txt` }),
-      );
-    }
-    responses.push(textResponse("done"));
-    const { provider, calls } = createMockProvider(responses);
-    const toolExecutor = async () => ({ content: "data", isError: false });
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      { maxToolUseTurns: 8 },
-      dummyTools,
-      toolExecutor,
-    );
-
-    const events: AgentEvent[] = [];
-    await loop.run([userMessage], collectEvents(events));
-
-    // Should have stopped at turn 8 (hard limit)
-    expect(calls).toHaveLength(8);
-
-    // Check that the approaching-limit warning was injected at turn 3 (8 - 5 = 3)
-    // The warning would appear in the messages sent to the provider on turn 4 (the call after turn 3)
-    const turn4Messages = calls[3].messages;
-    const lastMsg = turn4Messages[turn4Messages.length - 1];
-    const warningBlock = lastMsg.content.find(
-      (b): b is Extract<ContentBlock, { type: "text" }> =>
-        b.type === "text" &&
-        b.text.includes("approaching the tool-use turn limit"),
-    );
-    expect(warningBlock).toBeDefined();
-  });
-
-  test("runs without limit when maxToolUseTurns is 0", async () => {
-    // Use 20 turns (beyond old default of 8 used in other tests) to verify no cap
-    const turnCount = 20;
-    const responses: ProviderResponse[] = [];
-    for (let i = 0; i < turnCount; i++) {
-      responses.push(
-        toolUseResponse(`t${i}`, "read_file", { path: `/${i}.txt` }),
-      );
-    }
-    responses.push(textResponse("done"));
-    const { provider, calls } = createMockProvider(responses);
-    const toolExecutor = async () => ({ content: "data", isError: false });
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      { maxToolUseTurns: 0, minTurnIntervalMs: 0 },
-      dummyTools,
-      toolExecutor,
-    );
-
-    const events: AgentEvent[] = [];
-    await loop.run([userMessage], collectEvents(events));
-
-    // All 20 tool turns + 1 final text response = 21 provider calls
-    expect(calls).toHaveLength(turnCount + 1);
-
-    // No hard-limit error events should have been emitted
-    const errorEvents = events.filter(
-      (e): e is Extract<AgentEvent, { type: "error" }> => e.type === "error",
-    );
-    expect(errorEvents).toHaveLength(0);
-
-    // Progress check reminders should still fire every 5 turns
-    const progressChecks = calls.filter((call) => {
-      const lastMsg = call.messages[call.messages.length - 1];
-      return lastMsg.content.some(
-        (b): b is Extract<ContentBlock, { type: "text" }> =>
-          b.type === "text" && b.text.includes("making meaningful progress"),
-      );
-    });
-    expect(progressChecks.length).toBeGreaterThanOrEqual(3);
-
-    // No approaching-limit warnings should appear
-    const limitWarnings = calls.filter((call) => {
-      const lastMsg = call.messages[call.messages.length - 1];
-      return lastMsg.content.some(
-        (b): b is Extract<ContentBlock, { type: "text" }> =>
-          b.type === "text" &&
-          b.text.includes("approaching the tool-use turn limit"),
-      );
-    });
-    expect(limitWarnings).toHaveLength(0);
-  });
-
   // 9. Tool executor error results are forwarded correctly
   test("forwards tool error results to provider", async () => {
     const { provider, calls } = createMockProvider([

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Guard test: always-loaded tool count
+ *
+ * This test asserts the exact set of tools that are active when no client is
+ * connected, no host proxy is available, no attachments are present, and no
+ * special channel capabilities exist. This represents the minimal "always-loaded"
+ * baseline that is sent to the LLM on every turn.
+ *
+ * Adding a tool to this set increases token cost for every request. If this test
+ * fails because a new tool was added, update the assertion below and justify
+ * the token cost increase in the PR description.
+ */
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import {
+  buildToolDefinitions,
+  isToolActiveForContext,
+  type SkillProjectionContext,
+} from "../daemon/session-tool-setup.js";
+import {
+  __resetRegistryForTesting,
+  initializeTools,
+} from "../tools/registry.js";
+
+afterAll(() => {
+  __resetRegistryForTesting();
+});
+
+describe("always-loaded tool count", () => {
+  test("should be exactly 11 (no-client baseline excludes host tools)", async () => {
+    await initializeTools();
+    const allDefs = buildToolDefinitions();
+
+    // Minimal context: no client, no attachments, no capabilities
+    const minimalContext: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(),
+      toolsDisabledDepth: 0,
+      hasNoClient: true,
+      hasAttachments: false,
+      channelCapabilities: undefined,
+    };
+
+    const activeTools = allDefs.filter((def) =>
+      isToolActiveForContext(def.name, minimalContext),
+    );
+    const activeNames = activeTools.map((t) => t.name).sort();
+
+    // Host tools (host_bash, host_file_*) are excluded when no client is
+    // connected — without a human in the loop, the guardian auto-approve
+    // path would allow unchecked host command execution.
+    const expectedNames = [
+      "bash",
+      "credential_store",
+      "file_edit",
+      "file_read",
+      "file_write",
+      "memory_manage",
+      "memory_recall",
+      "skill_execute",
+      "skill_load",
+      "web_fetch",
+      "web_search",
+    ].sort();
+
+    expect(activeNames).toEqual(expectedNames);
+    expect(activeTools.length).toBe(11);
+  });
+});

package/src/__tests__/amazon-cdp-integration.test.ts

@@ -1,7 +1,7 @@
 /**
- * Verify that the Amazon CLI does NOT define its own CDP launch/window logic.
+ * Verify that the Amazon skill scripts do NOT define their own CDP launch/window logic.
  *
- * The Amazon CLI now uses browser extension relay instead of CDP for session
+ * The Amazon skill now uses browser extension relay instead of CDP for session
  * management, so we only verify that old inline CDP patterns are absent.
  */
 
@@ -9,21 +9,23 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-const AMAZON_CLI_DIR = join(
+const AMAZON_SCRIPTS_DIR = join(
   import.meta.dirname ?? __dirname,
   "..",
-  "cli",
-  "commands",
+  "..",
+  "..",
+  "skills",
   "amazon",
+  "scripts",
 );
 
-// Read all .ts files in the amazon/ directory and concatenate their source
-const amazonSource = readdirSync(AMAZON_CLI_DIR)
+// Read all .ts files in the amazon/scripts/ directory and concatenate their source
+const amazonSource = readdirSync(AMAZON_SCRIPTS_DIR)
   .filter((f) => f.endsWith(".ts"))
-  .map((f) => readFileSync(join(AMAZON_CLI_DIR, f), "utf-8"))
+  .map((f) => readFileSync(join(AMAZON_SCRIPTS_DIR, f), "utf-8"))
   .join("\n");
 
-describe("Amazon CLI CDP integration", () => {
+describe("Amazon skill CDP integration", () => {
   test("does not define its own CDP_BASE constant", () => {
     // The old inline constant was: const CDP_BASE = "http://localhost:9222";
     expect(amazonSource).not.toMatch(/const\s+CDP_BASE\s*=/);

package/src/__tests__/approval-primitive.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/approval-routes-http.test.ts

@@ -22,7 +22,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -47,6 +46,7 @@ mock.module("../config/loader.js", () => ({
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     secretDetection: { enabled: false },
     sandbox: { enabled: false },
+    contextWindow: { maxInputTokens: 200000 },
   }),
 }));
 
@@ -112,8 +112,12 @@ function makeIdleSession(opts?: {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
+    ensureActorScopedHistory: async () => {},
+    getMessages: () => [],
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
     hasAnyPendingConfirmation: () => false,
     runAgentLoop: async (
@@ -171,8 +175,12 @@ function makeConfirmationEmittingSession(opts?: {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
+    ensureActorScopedHistory: async () => {},
+    getMessages: () => [],
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
     hasAnyPendingConfirmation: () => false,
     runAgentLoop: async (

package/src/__tests__/asset-materialize-tool.test.ts

@@ -13,7 +13,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/asset-search-tool.test.ts

@@ -12,7 +12,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/assistant-attachment-directive.test.ts

@@ -423,7 +423,7 @@ describe("resolveHostDirective", () => {
     writeFileSync(join(TEST_DIR, "doc.txt"), "content");
 
     const failApprove = async () => {
-      throw new Error("IPC disconnected");
+      throw new Error("connection lost");
     };
     const result = await resolveHostDirective(makeHostDirective(), failApprove);