@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/tool-result-spool.test.ts

@@ -49,7 +49,7 @@ const SHORT = "y".repeat(100);
 
 describe("spoolAndStubOversizedToolResults", () => {
   let convDir: string;
-  const noName = () => undefined;
+  const noCall = () => undefined;
 
   beforeEach(() => {
     convDir = mkdtempSync(join(tmpdir(), "tool-result-spool-"));
@@ -64,7 +64,7 @@ describe("spoolAndStubOversizedToolResults", () => {
 
     const count = spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
-      toolNameById: noName,
+      toolCallById: noCall,
     });
 
     expect(count).toBe(1);
@@ -81,7 +81,7 @@ describe("spoolAndStubOversizedToolResults", () => {
     const blocks = [makeToolResult(LONG, "tu_big")];
     spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
-      toolNameById: noName,
+      toolCallById: noCall,
     });
 
     const { messages: postTurn } = postTurnTruncateToolResults(
@@ -98,7 +98,7 @@ describe("spoolAndStubOversizedToolResults", () => {
     const blocks = [makeToolResult(LONG, "tu_big")];
     spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
-      toolNameById: noName,
+      toolCallById: noCall,
     });
 
     const history: Message[] = [{ role: "user", content: [...blocks] }];
@@ -110,13 +110,11 @@ describe("spoolAndStubOversizedToolResults", () => {
     expect(messages).toBe(history);
   });
 
-  test("skips below-threshold, error, exempt, file_read, host_file_read, web_fetch, marked, and ax-tree results", () => {
+  test("skips below-threshold, error, exempt, web_fetch, marked, and ax-tree results", () => {
     const blocks = [
       makeToolResult(SHORT, "tu_short"),
       makeToolResult(LONG, "tu_err", true),
       makeToolResult(LONG, "tu_skill"),
-      makeToolResult(LONG, "tu_read"),
-      makeToolResult(LONG, "tu_host_read"),
       makeToolResult(LONG, "tu_web_fetch"),
       makeToolResult(`${LONG}${TRUNCATION_MARKER}`, "tu_marked"),
       makeToolResult(`<ax-tree>${LONG}</ax-tree>`, "tu_ax"),
@@ -126,18 +124,12 @@ describe("spoolAndStubOversizedToolResults", () => {
 
     const count = spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
-      toolNameById: (id) => {
+      toolCallById: (id) => {
         if (id === "tu_skill") {
-          return "skill_load";
-        }
-        if (id === "tu_read") {
-          return "file_read";
-        }
-        if (id === "tu_host_read") {
-          return "host_file_read";
+          return { name: "skill_load", input: {} };
         }
         if (id === "tu_web_fetch") {
-          return "web_fetch";
+          return { name: "web_fetch", input: {} };
         }
         return undefined;
       },
@@ -148,6 +140,70 @@ describe("spoolAndStubOversizedToolResults", () => {
     expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
   });
 
+  test("spools an oversized file read of an ordinary path", () => {
+    const blocks = [
+      makeToolResult(LONG, "tu_read"),
+      makeToolResult(LONG, "tu_host_read"),
+    ];
+
+    const count = spoolAndStubOversizedToolResults(blocks, {
+      conversationDir: convDir,
+      toolCallById: (id) =>
+        id === "tu_read"
+          ? { name: "file_read", input: { path: "/workspace/src/big.ts" } }
+          : { name: "host_file_read", input: { path: "/Users/me/notes.md" } },
+    });
+
+    expect(count).toBe(2);
+    expect((blocks[0] as { content: string }).content).toContain(
+      TRUNCATION_MARKER,
+    );
+    expect((blocks[1] as { content: string }).content).toContain(
+      TRUNCATION_MARKER,
+    );
+  });
+
+  test("leaves a file read of a spooled .tool-results path inline", () => {
+    // Stubbing this read would write a fresh copy and hand back another stub,
+    // so the spooled content could never be paged back into context.
+    const spooledPath = getToolResultFilePath(convDir, "tu_earlier");
+    const blocks = [
+      makeToolResult(LONG, "tu_read"),
+      makeToolResult(LONG, "tu_host_read"),
+    ];
+    const originals = blocks.map((b) => b);
+
+    const count = spoolAndStubOversizedToolResults(blocks, {
+      conversationDir: convDir,
+      toolCallById: (id) =>
+        id === "tu_read"
+          ? { name: "file_read", input: { path: spooledPath } }
+          : { name: "host_file_read", input: { file_path: spooledPath } },
+    });
+
+    expect(count).toBe(0);
+    expect(blocks).toEqual(originals);
+  });
+
+  test("recognizes a backslash-separated spooled path", () => {
+    // `getToolResultFilePath` builds the stub path with `join`, so on Windows
+    // it is backslash-separated. Missing that match would stub the read and
+    // put the saved content out of reach.
+    const blocks = [makeToolResult(LONG, "tu_read")];
+    const originals = blocks.map((b) => b);
+
+    const count = spoolAndStubOversizedToolResults(blocks, {
+      conversationDir: convDir,
+      toolCallById: () => ({
+        name: "file_read",
+        input: { path: `C:\\conv\\${TOOL_RESULT_DIR}\\abc123.txt` },
+      }),
+    });
+
+    expect(count).toBe(0);
+    expect(blocks).toEqual(originals);
+  });
+
   test("spools each eligible block in a mixed batch", () => {
     const blocks = [
       makeToolResult(LONG, "tu_a"),
@@ -157,7 +213,7 @@ describe("spoolAndStubOversizedToolResults", () => {
 
     const count = spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
-      toolNameById: noName,
+      toolCallById: noCall,
     });
 
     expect(count).toBe(2);
@@ -184,7 +240,7 @@ describe("spoolAndStubOversizedToolResults", () => {
     expect(() =>
       spoolAndStubOversizedToolResults(blocks, {
         conversationDir: fileAsDir,
-        toolNameById: noName,
+        toolCallById: noCall,
       }),
     ).toThrow();
     expect((blocks[0] as { content: string }).content).toBe(LONG);

package/src/__tests__/tool-side-effects-documents.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Tests for the document post-execution hooks that publish a documents-changed
+ * broadcast so client asset lists and the Library refresh after a mutation.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  DOCUMENT_EDIT_TOOL_NAMES,
+  DOCUMENT_MUTATION_TOOL_NAMES,
+  REOPENABLE_DOCUMENT_MUTATION_TOOL_NAMES,
+} from "../api/constants/document-tools.js";
+import { createMockLoggerModule } from "./helpers/mock-logger.js";
+
+// ---------------------------------------------------------------------------
+// Mocks. Must be set up before importing the module under test.
+// ---------------------------------------------------------------------------
+
+const mockPublishDocumentsChanged = mock(() => {});
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishAppsChanged: mock(() => {}),
+  publishDocumentsChanged: mockPublishDocumentsChanged,
+}));
+
+mock.module("../util/logger.js", () => createMockLoggerModule());
+
+// Stub the transitive imports so the module graph under test stops at
+// tool-side-effects.ts and never reaches the real sync publisher.
+mock.module("../media/app-icon-generator.js", () => ({
+  generateAppIcon: mock(() => Promise.resolve()),
+}));
+mock.module("../apps/app-store.js", () => ({
+  getApp: mock(() => null),
+  getAppDirPath: mock(() => ""),
+  getAppsDir: mock(() => ""),
+  resolveAppIdFromPath: mock(() => null),
+  resolveAppIdByDirName: mock(() => null),
+  resolveAppDir: mock(() => ({ dirName: "", dirPath: "" })),
+  slugify: mock((s: string) => s),
+  validateDirName: mock(() => {}),
+  generateAppDirName: mock(() => ""),
+  listApps: mock(() => []),
+  createApp: mock(() => ({})),
+  updateApp: mock(() => {}),
+  deleteApp: mock(() => {}),
+  getAppPreview: mock(() => null),
+  createAppRecord: mock(() => ({})),
+  getAppRecord: mock(() => null),
+  queryAppRecords: mock(() => []),
+  updateAppRecord: mock(() => {}),
+  deleteAppRecord: mock(() => {}),
+  listAppFiles: mock(() => []),
+  appFileExists: mock(() => false),
+  readAppFile: mock(() => ""),
+  writeAppFile: mock(() => {}),
+  editAppFile: mock(() => ({})),
+  inlineDistAssets: mock((_: unknown, html: string) => html),
+  addAppConversationId: mock(() => false),
+  linkAppToConversationLineage: mock(() => {}),
+}));
+mock.module("../bundler/app-compiler.js", () => ({
+  compileApp: mock(() => Promise.resolve({ ok: true })),
+}));
+mock.module("../services/published-app-updater.js", () => ({
+  updatePublishedAppDeployment: mock(() => Promise.resolve()),
+}));
+mock.module("../daemon/conversation-surfaces.js", () => ({
+  refreshSurfacesForApp: mock(() => {}),
+}));
+mock.module("../daemon/doordash-steps.js", () => ({
+  isDoordashCommand: mock(() => false),
+  updateDoordashProgress: mock(() => {}),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks. The dynamic import ensures the mock.module() calls above
+// are registered before tool-side-effects.ts evaluates its top-level imports.
+// ---------------------------------------------------------------------------
+
+import type { SideEffectContext } from "../daemon/tool-side-effects.js";
+
+const { runPostExecutionSideEffects } =
+  await import("../daemon/tool-side-effects.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const dummySideEffectCtx = {
+  ctx: {} as SideEffectContext["ctx"],
+} satisfies SideEffectContext;
+
+const READ_ONLY_TOOLS = [
+  "document_read",
+  "document_list",
+  "document_find",
+  "document_open",
+];
+
+// The content is deliberately not JSON: the hook fires on the executed tool
+// name alone and must never depend on the shape of the LLM-facing result.
+async function runTool(name: string, isError = false): Promise<void> {
+  await runPostExecutionSideEffects(
+    name,
+    { surface_id: "doc-1" },
+    { content: "Document saved.", isError },
+    dummySideEffectCtx,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("document hooks: documents-changed broadcast", () => {
+  beforeEach(() => {
+    mockPublishDocumentsChanged.mockReset();
+  });
+
+  for (const toolName of DOCUMENT_MUTATION_TOOL_NAMES) {
+    test(`${toolName} publishes exactly one documents change`, async () => {
+      await runTool(toolName);
+      expect(mockPublishDocumentsChanged).toHaveBeenCalledTimes(1);
+    });
+  }
+
+  for (const toolName of READ_ONLY_TOOLS) {
+    test(`${toolName} publishes no documents change`, async () => {
+      await runTool(toolName);
+      expect(mockPublishDocumentsChanged).not.toHaveBeenCalled();
+    });
+  }
+
+  test("a failed mutation publishes no documents change", async () => {
+    await runTool("document_update", true);
+    expect(mockPublishDocumentsChanged).not.toHaveBeenCalled();
+  });
+
+  test("two mutations in one turn publish once each", async () => {
+    await runTool("document_update");
+    await runTool("document_replace_text");
+    expect(mockPublishDocumentsChanged).toHaveBeenCalledTimes(2);
+  });
+});
+
+// The daemon hooks every mutating tool, while the web transcript anchors its
+// changed-document chips on the reopenable subset and its inline-preview
+// bookkeeping on the edit subset. Pinning all three keeps a new entry in
+// `DOCUMENT_MUTATION_TOOLS` from silently landing in the wrong subsets.
+describe("document mutation tool metadata", () => {
+  test("the daemon hooks every mutating document tool", () => {
+    expect([...DOCUMENT_MUTATION_TOOL_NAMES]).toEqual([
+      "document_create",
+      "document_update",
+      "document_replace_text",
+      "document_delete",
+    ]);
+  });
+
+  test("the reopenable subset drops document_delete and keeps the rest", () => {
+    expect([...REOPENABLE_DOCUMENT_MUTATION_TOOL_NAMES]).toEqual([
+      "document_create",
+      "document_update",
+      "document_replace_text",
+    ]);
+  });
+
+  test("the edit subset is exactly the two write-into-existing tools", () => {
+    expect([...DOCUMENT_EDIT_TOOL_NAMES]).toEqual([
+      "document_update",
+      "document_replace_text",
+    ]);
+  });
+});

package/src/__tests__/tool-side-effects-hook-failures.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tool post-execution side effects: failures in a hook must not surface to the
+ * caller.
+ *
+ * `runPostExecutionSideEffects` runs observation-and-notification work after a
+ * tool executor returns, so a hook that throws must be swallowed and logged
+ * rather than turning a successful tool call into a failed one.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks: must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+// Stub out transitive dependencies to prevent import errors
+mock.module("../bundler/app-compiler.js", () => ({
+  compileApp: mock(() => Promise.resolve({ ok: true })),
+}));
+mock.module("../media/app-icon-generator.js", () => ({
+  generateAppIcon: mock(() => Promise.resolve()),
+}));
+mock.module("../apps/app-store.js", () => ({
+  getApp: mock(() => null),
+  getAppDirPath: mock(() => ""),
+  getAppsDir: mock(() => ""),
+  resolveAppIdFromPath: mock(() => null),
+  resolveAppIdByDirName: mock(() => null),
+  resolveAppDir: mock(() => ({ dirName: "", dirPath: "" })),
+  slugify: mock((s: string) => s),
+  validateDirName: mock(() => {}),
+  generateAppDirName: mock(() => ""),
+  listApps: mock(() => []),
+  createApp: mock(() => ({})),
+  updateApp: mock(() => {}),
+  deleteApp: mock(() => {}),
+  getAppPreview: mock(() => null),
+  createAppRecord: mock(() => ({})),
+  getAppRecord: mock(() => null),
+  queryAppRecords: mock(() => []),
+  updateAppRecord: mock(() => {}),
+  deleteAppRecord: mock(() => {}),
+  listAppFiles: mock(() => []),
+  appFileExists: mock(() => false),
+  readAppFile: mock(() => ""),
+  writeAppFile: mock(() => {}),
+  editAppFile: mock(() => ({})),
+  inlineDistAssets: mock((_, html: string) => html),
+  addAppConversationId: mock(() => false),
+  linkAppToConversationLineage: mock(() => {}),
+}));
+mock.module("../services/published-app-updater.js", () => ({
+  updatePublishedAppDeployment: mock(() => Promise.resolve()),
+}));
+mock.module("../daemon/conversation-surfaces.js", () => ({
+  refreshSurfacesForApp: mock(() => {}),
+}));
+const mockIsDoordashCommand = mock(() => false);
+const mockUpdateDoordashProgress = mock(() => {});
+mock.module("../daemon/doordash-steps.js", () => ({
+  isDoordashCommand: mockIsDoordashCommand,
+  updateDoordashProgress: mockUpdateDoordashProgress,
+}));
+
+const mockLogWarn = mock((_obj: unknown, _msg: string) => {});
+const mockLogInfo = mock((_obj: unknown, _msg: string) => {});
+const mockLogError = mock((_obj: unknown, _msg: string) => {});
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    warn: mockLogWarn,
+    info: mockLogInfo,
+    error: mockLogError,
+    debug: () => {},
+    trace: () => {},
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks: dynamic import ensures mock.module() calls above
+// are registered before tool-side-effects.ts evaluates its top-level
+// `const log = getLogger(...)`.
+// ---------------------------------------------------------------------------
+
+import type { SideEffectContext } from "../daemon/tool-side-effects.js";
+
+const { runPostExecutionSideEffects } =
+  await import("../daemon/tool-side-effects.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const dummySideEffectCtx = {
+  ctx: {} as SideEffectContext["ctx"],
+} satisfies SideEffectContext;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("doordash progress side effect", () => {
+  beforeEach(() => {
+    mockIsDoordashCommand.mockReset();
+    mockUpdateDoordashProgress.mockReset();
+    mockLogError.mockReset();
+  });
+
+  test("throwing updateDoordashProgress is swallowed and logged", async () => {
+    mockIsDoordashCommand.mockReturnValue(true);
+    mockUpdateDoordashProgress.mockImplementation(() => {
+      throw new Error("doordash boom");
+    });
+
+    await expect(
+      runPostExecutionSideEffects(
+        "bash",
+        { command: "order food" },
+        { content: "{}", isError: false },
+        dummySideEffectCtx,
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(mockUpdateDoordashProgress).toHaveBeenCalledTimes(1);
+    expect(mockLogError).toHaveBeenCalledWith(
+      expect.objectContaining({ toolName: "bash" }),
+      expect.stringContaining("DoorDash progress update failed"),
+    );
+  });
+});

package/src/__tests__/tools-audio-read.test.ts

@@ -23,12 +23,12 @@ afterAll(() => {
 });
 
 describe("readAudioFile", () => {
-  test("reads an mp3 into a base64 file block with audio/mpeg", () => {
+  test("reads an mp3 into a base64 file block with audio/mpeg", async () => {
     const p = join(dir, "clip.mp3");
     const bytes = Buffer.from("fake-audio-bytes");
     writeFileSync(p, bytes);
 
-    const result = readAudioFile(p);
+    const result = await readAudioFile(p);
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Audio loaded");
@@ -45,7 +45,7 @@ describe("readAudioFile", () => {
     ]);
   });
 
-  test("maps each extension to the canonical MIME (matches migration 191)", () => {
+  test("maps each extension to the canonical MIME (matches migration 191)", async () => {
     const cases: Record<string, string> = {
       "a.mp3": "audio/mpeg",
       "a.wav": "audio/wav",
@@ -58,7 +58,7 @@ describe("readAudioFile", () => {
     for (const [name, mime] of Object.entries(cases)) {
       const p = join(dir, name);
       writeFileSync(p, Buffer.from("x"));
-      const result = readAudioFile(p);
+      const result = await readAudioFile(p);
       expect(result.isError).toBe(false);
       const block = result.contentBlocks?.[0] as {
         source: { media_type: string };
@@ -67,28 +67,28 @@ describe("readAudioFile", () => {
     }
   });
 
-  test("rejects audio larger than the 12 MB inline cap", () => {
+  test("rejects audio larger than the 12 MB inline cap", async () => {
     const p = join(dir, "big.mp3");
     writeFileSync(p, "");
     truncateSync(p, 13 * 1024 * 1024); // sparse — no 13 MB allocation
 
-    const result = readAudioFile(p);
+    const result = await readAudioFile(p);
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("too large");
     expect(result.contentBlocks).toBeUndefined();
   });
 
-  test("errors on a missing file", () => {
-    const result = readAudioFile(join(dir, "nope.mp3"));
+  test("errors on a missing file", async () => {
+    const result = await readAudioFile(join(dir, "nope.mp3"));
     expect(result.isError).toBe(true);
     expect(result.content).toContain("not found");
   });
 
-  test("errors when the path is a directory", () => {
+  test("errors when the path is a directory", async () => {
     const p = join(dir, "adir.mp3");
     mkdirSync(p);
-    const result = readAudioFile(p);
+    const result = await readAudioFile(p);
     expect(result.isError).toBe(true);
     expect(result.content).toContain("not a file");
   });

package/src/__tests__/tools-get-route.test.ts

@@ -25,6 +25,7 @@ import {
   registerPluginTools,
   registerSkillTools,
   registerTool,
+  registerWorkspaceTools,
 } from "../tools/registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
@@ -41,6 +42,12 @@ interface ToolsGetResponse {
   names: string[];
   schemas: Record<string, unknown>;
   tools: ToolListEntry[];
+  agent?: {
+    requested: string;
+    role: string;
+    alias?: string;
+    persona?: string;
+  };
 }
 
 function makeFakeTool(name: string, extras: Partial<Tool> = {}): Tool {
@@ -277,31 +284,34 @@ describe("GET /tools", () => {
     expect(names).not.toContain("file_edit");
   });
 
-  test("with agent=general, returns all tools (no allowlist filter)", async () => {
-    // GIVEN core tools
+  test("with agent=builder, returns the whole tool surface, not a fixed list", async () => {
+    // GIVEN core tools plus one no fixed builder list would think to name
     registerTool(makeFakeTool("web_search"));
     registerTool(makeFakeTool("bash"));
     registerTool(makeFakeTool("notify_parent"));
+    registerTool(makeFakeTool("send_email"));
 
-    // WHEN the handler runs with agent=general (allowedTools: undefined)
+    // WHEN the handler runs with agent=builder
     const { names } = (await handler({
-      queryParams: { agent: "general" },
+      queryParams: { agent: "builder" },
     })) as ToolsGetResponse;
 
-    // THEN all registered tools are visible — the general role has no
-    // allowlist, so nothing is filtered
+    // THEN nothing is filtered out: a builder, and so every spawn that names
+    // no role, reaches connectors, MCP tools, and everything else the parent
+    // can reach.
     expect(names).toContain("web_search");
     expect(names).toContain("bash");
     expect(names).toContain("notify_parent");
+    expect(names).toContain("send_email");
   });
 
   test("with agent=role, notify_parent is visible (subagent-only gating works)", async () => {
     // GIVEN notify_parent registered as a core tool
     registerTool(makeFakeTool("notify_parent"));
 
-    // WHEN the handler runs with agent=coder
+    // WHEN the handler runs with agent=researcher
     const { names, tools } = (await handler({
-      queryParams: { agent: "coder" },
+      queryParams: { agent: "researcher" },
     })) as ToolsGetResponse;
 
     // THEN notify_parent appears because isSubagent=true satisfies
@@ -310,9 +320,72 @@ describe("GET /tools", () => {
     expect(tools.some((t) => t.name === "notify_parent")).toBe(true);
   });
 
-  test("with an unknown agent, throws a 404 RouteError", () => {
-    expect(() =>
-      handler({ queryParams: { agent: "nonexistent_role" } }),
-    ).toThrow(/Unknown agent "nonexistent_role"/);
+  test("with agent=role, reports the type it listed", async () => {
+    registerTool(makeFakeTool("file_read"));
+
+    const { agent } = (await handler({
+      queryParams: { agent: "researcher" },
+    })) as ToolsGetResponse;
+
+    expect(agent).toEqual({ requested: "researcher", role: "researcher" });
+  });
+
+  test("a legacy role name lists its successor type and names the alias", async () => {
+    // GIVEN tools on both sides of the researcher allowlist
+    registerTool(makeFakeTool("file_read"));
+    registerTool(makeFakeTool("bash"));
+
+    // WHEN the handler runs with an older role name a spawn still accepts
+    const { names, agent } = (await handler({
+      queryParams: { agent: "coder" },
+    })) as ToolsGetResponse;
+
+    // THEN it previews the type that name resolves to, and says which alias
+    // produced it rather than 404ing on a name spawns still take.
+    expect(agent).toEqual({
+      requested: "coder",
+      role: "builder",
+      alias: "coder",
+    });
+    expect(names).toContain("bash");
+  });
+
+  test("free text previews the persona fallback surface instead of 404ing", async () => {
+    registerTool(makeFakeTool("file_read"));
+    registerTool(makeFakeTool("bash"));
+
+    const { names, agent } = (await handler({
+      queryParams: { agent: "a skeptical security reviewer" },
+    })) as ToolsGetResponse;
+
+    // A role naming no type runs as a researcher carrying the text as a
+    // persona, so the preview is the read-only surface, reported as such.
+    expect(agent).toEqual({
+      requested: "a skeptical security reviewer",
+      role: "researcher",
+      persona: "a skeptical security reviewer",
+    });
+    expect(names).toContain("file_read");
+    expect(names).not.toContain("bash");
+  });
+
+  test("agent=advisor hides a workspace tool that claims an allowed name", async () => {
+    registerTool(makeFakeTool("file_read"));
+    registerTool(makeFakeTool("file_list"));
+    // A workspace tool may register under a name the advisor allows. The
+    // advisor's guarantee is provenance, not the name, so the preview has to
+    // drop it exactly as a live consult does; otherwise the diagnostic
+    // advertises a tool the advisor refuses at dispatch.
+    registerWorkspaceTools([
+      { tool: makeFakeTool("file_read"), workspacePath: "/ws/file_read.ts" },
+    ]);
+
+    const { names, agent } = (await handler({
+      queryParams: { agent: "advisor" },
+    })) as ToolsGetResponse;
+
+    expect(agent?.role).toBe("advisor");
+    expect(names).not.toContain("file_read");
+    expect(names).toContain("file_list");
   });
 });