@vellumai/assistant 0.6.1 → 0.6.3

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

@@ -212,7 +212,7 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
 }));
 
 mock.module("../daemon/date-context.js", () => ({
-  formatTurnTimestamp: () => "2026-01-01 (Thu) 00:00:00 +00:00 (UTC)",
+  formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
 }));
 
 mock.module("../daemon/history-repair.js", () => ({

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

@@ -201,7 +201,7 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
 }));
 
 mock.module("../daemon/date-context.js", () => ({
-  formatTurnTimestamp: () => "2026-01-01 (Thu) 00:00:00 +00:00 (UTC)",
+  formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
 }));
 
 mock.module("../daemon/history-repair.js", () => ({

package/src/__tests__/conversation-analysis-routes.test.ts

@@ -0,0 +1,169 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const mockResolveConversationId = mock((id: string) => id);
+const mockGetConversation = mock(() => ({
+  id: "conv-1",
+  title: "Source",
+  conversationType: "normal",
+}));
+const mockGetMessages = mock(() => [{ id: "m-source" }]);
+const mockCreateConversation = mock(() => ({ id: "analysis-1" }));
+const mockAddMessage = mock(async () => ({ id: "msg-1" }));
+
+mock.module("../memory/conversation-key-store.js", () => ({
+  resolveConversationId: mockResolveConversationId,
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: mockGetConversation,
+  getMessages: mockGetMessages,
+  createConversation: mockCreateConversation,
+  addMessage: mockAddMessage,
+}));
+
+mock.module("../export/transcript-formatter.js", () => ({
+  buildAnalysisTranscript: () => "user: hi",
+}));
+
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import type { SendMessageDeps } from "../runtime/http-types.js";
+import { conversationAnalysisRouteDefinitions } from "../runtime/routes/conversation-analysis-routes.js";
+
+beforeEach(() => {
+  mockResolveConversationId.mockClear();
+  mockGetConversation.mockClear();
+  mockGetMessages.mockClear();
+  mockCreateConversation.mockClear();
+  mockAddMessage.mockClear();
+});
+
+function makeConversation() {
+  return {
+    setTrustContext: mock(() => {}),
+    ensureActorScopedHistory: mock(() => Promise.resolve()),
+    setSubagentAllowedTools: mock(() => {}),
+    updateClient: mock(() => {}),
+    processing: false,
+    abortController: null as AbortController | null,
+    currentRequestId: null as string | null,
+    runAgentLoop: mock(() => Promise.resolve()),
+  };
+}
+
+describe("POST /v1/conversations/:id/analyze", () => {
+  test("runs headless analysis with unknown trust and no tools when no subscriber is present", async () => {
+    const conversation = makeConversation();
+    const assistantEventHub = new AssistantEventHub();
+    const sendMessageDeps = {
+      getOrCreateConversation: mock(async () => conversation),
+      assistantEventHub,
+      resolveAttachments: () => [],
+    } as unknown as SendMessageDeps;
+
+    const routes = conversationAnalysisRouteDefinitions({
+      sendMessageDeps,
+      buildConversationDetailResponse: () => ({ id: "analysis-1" }),
+    });
+    const route = routes.find(
+      (r) => r.method === "POST" && r.endpoint === "conversations/:id/analyze",
+    );
+    if (!route) throw new Error("analyze route missing");
+
+    const req = new Request("http://localhost/v1/conversations/conv-1/analyze", {
+      method: "POST",
+    });
+
+    const res = await route.handler({
+      req,
+      url: new URL(req.url),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: "conv-1" },
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockAddMessage).toHaveBeenCalledWith(
+      "analysis-1",
+      "user",
+      expect.any(String),
+      { provenanceTrustClass: "unknown" },
+    );
+    expect(conversation.setTrustContext).toHaveBeenCalledWith({
+      trustClass: "unknown",
+      sourceChannel: "vellum",
+    });
+    expect(conversation.ensureActorScopedHistory).toHaveBeenCalledTimes(1);
+    expect(conversation.setSubagentAllowedTools).toHaveBeenCalledTimes(1);
+    const allowedTools = (
+      conversation.setSubagentAllowedTools.mock.calls as unknown as Array<
+        [Set<string> | undefined]
+      >
+    )[0]?.[0];
+    expect(allowedTools).toBeInstanceOf(Set);
+    expect(allowedTools?.size).toBe(0);
+    expect(conversation.updateClient).toHaveBeenCalledWith(
+      expect.any(Function),
+      true,
+    );
+    expect(conversation.runAgentLoop).toHaveBeenCalledWith(
+      expect.any(String),
+      "msg-1",
+      expect.any(Function),
+      expect.objectContaining({ isInteractive: false, isUserMessage: true }),
+    );
+  });
+
+  test("keeps analysis non-interactive even when a matching subscriber is connected", async () => {
+    const conversation = makeConversation();
+    const assistantEventHub = new AssistantEventHub();
+    assistantEventHub.subscribe(
+      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
+      () => {},
+    );
+    const sendMessageDeps = {
+      getOrCreateConversation: mock(async () => conversation),
+      assistantEventHub,
+      resolveAttachments: () => [],
+    } as unknown as SendMessageDeps;
+
+    const routes = conversationAnalysisRouteDefinitions({
+      sendMessageDeps,
+      buildConversationDetailResponse: () => ({ id: "analysis-1" }),
+    });
+    const route = routes.find(
+      (r) => r.method === "POST" && r.endpoint === "conversations/:id/analyze",
+    );
+    if (!route) throw new Error("analyze route missing");
+
+    const req = new Request("http://localhost/v1/conversations/conv-1/analyze", {
+      method: "POST",
+    });
+
+    await route.handler({
+      req,
+      url: new URL(req.url),
+      server: null as never,
+      authContext: {} as never,
+      params: { id: "conv-1" },
+    });
+
+    expect(conversation.updateClient).toHaveBeenCalledWith(
+      expect.any(Function),
+      false,
+    );
+    expect(conversation.runAgentLoop).toHaveBeenCalledWith(
+      expect.any(String),
+      "msg-1",
+      expect.any(Function),
+      expect.objectContaining({ isInteractive: false, isUserMessage: true }),
+    );
+  });
+});

package/src/__tests__/conversation-attachments.test.ts

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -25,15 +27,18 @@ mock.module("../daemon/video-thumbnail.js", () => ({
 }));
 
 // Stub out permission checker / trust store
+const checkSpy = mock(() => Promise.resolve({ decision: "allow" }));
+const addRuleSpy = mock(() => {});
+
 mock.module("../permissions/checker.js", () => ({
-  check: () => Promise.resolve({ decision: "allow" }),
+  check: checkSpy,
   classifyRisk: () => Promise.resolve("low"),
   generateAllowlistOptions: () => Promise.resolve([]),
   generateScopeOptions: () => [],
 }));
 
 mock.module("../permissions/trust-store.js", () => ({
-  addRule: () => {},
+  addRule: addRuleSpy,
 }));
 
 mock.module("../permissions/types.js", () => ({
@@ -47,7 +52,11 @@ mock.module("../permissions/types.js", () => ({
 
 import type { AssistantAttachmentDraft } from "../daemon/assistant-attachments.js";
 import { getFilePathForAttachment } from "../memory/attachments-store.js";
-import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import {
+  addMessage,
+  createConversation,
+  updateConversationHostAccess,
+} from "../memory/conversation-crud.js";
 import { getDb, initializeDb } from "../memory/db.js";
 
 initializeDb();
@@ -73,7 +82,12 @@ function makeBase64(bytes: number): string {
 // ---------------------------------------------------------------------------
 
 describe("resolveAssistantAttachments", () => {
-  beforeEach(resetTables);
+  beforeEach(() => {
+    resetTables();
+    _setOverridesForTesting({});
+    checkSpy.mockClear();
+    addRuleSpy.mockClear();
+  });
 
   test("small attachments are stored on disk via uploadAttachment", async () => {
     const conv = createConversation("test-conv");
@@ -196,3 +210,65 @@ describe("resolveAssistantAttachments", () => {
     expect(emitted.fileBacked).toBe(true);
   });
 });
+
+describe("approveHostAttachmentRead", () => {
+  beforeEach(() => {
+    resetTables();
+    _setOverridesForTesting({});
+    checkSpy.mockClear();
+    addRuleSpy.mockClear();
+  });
+
+  test("uses the conversation-scoped host-access prompt under v2", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    const conversation = createConversation("attachment-host-gate");
+    const promptSpy = mock(() =>
+      Promise.resolve({ decision: "allow" as const }),
+    );
+
+    const { approveHostAttachmentRead } =
+      await import("../daemon/conversation-attachments.js");
+
+    const allowed = await approveHostAttachmentRead(
+      "/tmp/example.txt",
+      "/tmp",
+      { prompt: promptSpy } as never,
+      conversation.id,
+      false,
+    );
+
+    expect(allowed).toBe(true);
+    expect(checkSpy).not.toHaveBeenCalled();
+    expect(addRuleSpy).not.toHaveBeenCalled();
+    const call = promptSpy.mock.calls[0] as unknown as unknown[];
+    expect(call[3]).toEqual([]);
+    expect(call[4]).toEqual([]);
+    expect(call[8]).toBe(false);
+    expect(call[10]).toBeUndefined();
+    expect(call[12]).toBe(true);
+  });
+
+  test("auto-allows host attachment reads when the conversation already has host access", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    const conversation = createConversation("attachment-host-allowed");
+    updateConversationHostAccess(conversation.id, true);
+    const promptSpy = mock(() =>
+      Promise.resolve({ decision: "deny" as const }),
+    );
+
+    const { approveHostAttachmentRead } =
+      await import("../daemon/conversation-attachments.js");
+
+    const allowed = await approveHostAttachmentRead(
+      "/tmp/example.txt",
+      "/tmp",
+      { prompt: promptSpy } as never,
+      conversation.id,
+      false,
+    );
+
+    expect(allowed).toBe(true);
+    expect(promptSpy).not.toHaveBeenCalled();
+    expect(checkSpy).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -214,6 +214,8 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { Conversation } from "../daemon/conversation.js";
+import { HostBashProxy } from "../daemon/host-bash-proxy.js";
+import { HostBrowserProxy } from "../daemon/host-browser-proxy.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -558,3 +560,156 @@ describe("sendToClient receives state signals", () => {
     });
   });
 });
+
+describe("restoreBrowserProxyAvailability", () => {
+  test("re-enables only the host browser proxy after clearProxyAvailability", () => {
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    const bashProxy = new HostBashProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+    conversation.setHostBashProxy(bashProxy);
+
+    // Mark as having a connected client (interactive desktop path).
+    conversation.updateClient(() => {}, false);
+    expect(browserProxy.isAvailable()).toBe(true);
+    expect(bashProxy.isAvailable()).toBe(true);
+
+    // The drain queue clears all proxies for non-interactive turns.
+    conversation.clearProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(bashProxy.isAvailable()).toBe(false);
+
+    // restoreBrowserProxyAvailability should bring back ONLY the browser proxy.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    expect(bashProxy.isAvailable()).toBe(false);
+  });
+
+  test("re-enables the browser proxy even when hasNoClient is true (chrome-extension)", () => {
+    // Regression: chrome-extension is non-interactive (hasNoClient stays
+    // true so host_bash/host_file tools remain gated), but we still need
+    // to provision the hostBrowserProxy so it can service CDP commands.
+    // The helper must NOT gate on hasNoClient.
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // updateClient with hasNoClient=true emulates the non-interactive
+    // chrome-extension turn. Host proxies start disabled because
+    // updateClient propagates hasNoClient through to updateSender.
+    conversation.updateClient(() => {}, true);
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(conversation["hasNoClient"]).toBe(true);
+
+    // The targeted helper bypasses the hasNoClient gate so the
+    // single-capability chrome-extension turn can drive the browser
+    // via CDP without flipping hasNoClient (which would also enable
+    // host_bash/host_file gating downstream).
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    // hasNoClient itself MUST remain true so that
+    // isToolActiveForContext keeps host_bash/host_file/host_cu gated.
+    expect(conversation["hasNoClient"]).toBe(true);
+  });
+
+  test("leaves bash/file/cu proxies disabled when called for chrome-extension", () => {
+    // Regression: the targeted helper must not accidentally re-enable
+    // proxies other than host_browser, even when called from a path that
+    // owns multiple proxies (e.g. macOS holdover state with hasNoClient
+    // forced true for an explicit non-interactive run).
+    const conversation = makeConversation();
+    const browserProxy = new HostBrowserProxy(() => {});
+    const bashProxy = new HostBashProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+    conversation.setHostBashProxy(bashProxy);
+
+    conversation.updateClient(() => {}, true);
+    expect(browserProxy.isAvailable()).toBe(false);
+    expect(bashProxy.isAvailable()).toBe(false);
+
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+    // Crucial: bash proxy stays disabled. The helper must touch ONLY the
+    // browser proxy.
+    expect(bashProxy.isAvailable()).toBe(false);
+  });
+
+  test("uses hostBrowserSenderOverride when set so drain-queue restores preserve the registry-routed sender", () => {
+    // Regression (PR #24129 cycle 2): the queue-drain path calls
+    // `restoreBrowserProxyAvailability()` on dequeue, which used to pass
+    // `this.sendToClient` (the SSE hub emitter) to the proxy, clobbering the
+    // chrome-extension registry-routed sender established by the POST
+    // /messages handler. The override field lets the HTTP handler pin the
+    // registry-routed sender so the drain path preserves it.
+    const sseHub: ServerMessage[] = [];
+    const registry: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // Simulate updateClient setting sendToClient to the SSE hub and
+    // marking the conversation as client-less (chrome-extension is
+    // non-interactive).
+    conversation.updateClient((msg) => sseHub.push(msg), true);
+    expect(browserProxy.isAvailable()).toBe(false);
+
+    // The HTTP handler stashes the registry-routed sender as the override.
+    const registrySender = (msg: ServerMessage) => registry.push(msg);
+    conversation.hostBrowserSenderOverride = registrySender;
+
+    // Drain-queue path calls restoreBrowserProxyAvailability — it must now
+    // prefer the override over sendToClient.
+    conversation.restoreBrowserProxyAvailability();
+    expect(browserProxy.isAvailable()).toBe(true);
+
+    // Send a frame through the proxy and verify it flows through the
+    // registry sender, not the SSE hub.
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-1",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(registry).toHaveLength(1);
+    expect(sseHub.some((m) => m === probe)).toBe(false);
+  });
+
+  test("falls back to sendToClient when hostBrowserSenderOverride is cleared", () => {
+    // When a non-chrome-extension turn takes over, the HTTP handler clears
+    // the override and restoreBrowserProxyAvailability must fall back to
+    // sendToClient (the SSE hub), otherwise macOS turns would route their
+    // host_browser frames through the stale chrome-extension registry.
+    const sseHub: ServerMessage[] = [];
+    const conversation = makeConversation((msg) => sseHub.push(msg));
+    const browserProxy = new HostBrowserProxy(() => {});
+    conversation.setHostBrowserProxy(browserProxy);
+
+    // First the chrome-extension path pins the override.
+    const registry: ServerMessage[] = [];
+    conversation.hostBrowserSenderOverride = (msg) => registry.push(msg);
+    conversation.updateClient((msg) => sseHub.push(msg), true);
+    conversation.restoreBrowserProxyAvailability();
+
+    // Then a macOS handoff clears the override.
+    conversation.hostBrowserSenderOverride = undefined;
+    conversation.updateClient((msg) => sseHub.push(msg), false);
+    conversation.restoreBrowserProxyAvailability();
+
+    const internalSend = (
+      browserProxy as unknown as {
+        sendToClient: (msg: ServerMessage) => void;
+      }
+    ).sendToClient;
+    const probe: ServerMessage = {
+      type: "host_browser_cancel",
+      requestId: "probe-2",
+    } as ServerMessage;
+    internalSend(probe);
+    expect(sseHub).toContain(probe);
+    expect(registry).not.toContain(probe);
+  });
+});

package/src/__tests__/conversation-directories-parse.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getConversationDirName,
+  parseConversationDirName,
+} from "../memory/conversation-directories.js";
+
+describe("parseConversationDirName", () => {
+  describe("round-trip with getConversationDirName", () => {
+    test("round-trips a UUID-shaped id", () => {
+      const id = "4ae7ea90-86e4-446a-8673-7bba94ecfea1";
+      const createdAtMs = Date.parse("2026-04-07T10:47:23.075Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+
+    test("round-trips an id with embedded hyphens", () => {
+      const id = "conv-with-hyphens-123";
+      const createdAtMs = Date.parse("2024-01-15T00:00:00.000Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+
+    test("round-trips an id with embedded underscores", () => {
+      const id = "foo_bar_baz";
+      const createdAtMs = Date.parse("2025-12-31T23:59:59.999Z");
+      const name = getConversationDirName(id, createdAtMs);
+      const parsed = parseConversationDirName(name);
+      expect(parsed).toEqual({ conversationId: id, createdAtMs });
+    });
+  });
+
+  describe("exact parsing against literal example", () => {
+    test("parses the canonical example from the spec", () => {
+      const name =
+        "2026-04-07T10-47-23.075Z_4ae7ea90-86e4-446a-8673-7bba94ecfea1";
+      const parsed = parseConversationDirName(name);
+      expect(parsed).not.toBeNull();
+      expect(parsed?.conversationId).toBe(
+        "4ae7ea90-86e4-446a-8673-7bba94ecfea1",
+      );
+      expect(parsed?.createdAtMs).toBe(Date.parse("2026-04-07T10:47:23.075Z"));
+    });
+  });
+
+  describe("returns null for malformed input", () => {
+    test("returns null for empty string", () => {
+      expect(parseConversationDirName("")).toBeNull();
+    });
+
+    test("returns null for missing underscore", () => {
+      expect(parseConversationDirName("2026-04-07T10-47-23.075Z")).toBeNull();
+    });
+
+    test("returns null for legacy format (id first, timestamp second)", () => {
+      expect(
+        parseConversationDirName(
+          "4ae7ea90-86e4-446a-8673-7bba94ecfea1_2026-04-07T10-47-23.075Z",
+        ),
+      ).toBeNull();
+    });
+
+    test("returns null for non-ISO prefix", () => {
+      expect(parseConversationDirName("hello_world")).toBeNull();
+    });
+
+    test("returns null for random garbage", () => {
+      expect(parseConversationDirName("drafts/foo")).toBeNull();
+    });
+
+    test("returns null when the conversation id is '.'", () => {
+      expect(parseConversationDirName("2025-01-15T00-00-00.000Z_.")).toBeNull();
+    });
+
+    test("returns null when the conversation id is '..'", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_.."),
+      ).toBeNull();
+    });
+
+    test("returns null when the conversation id contains a forward slash", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_foo/bar"),
+      ).toBeNull();
+    });
+
+    test("returns null when the conversation id contains a backslash", () => {
+      expect(
+        parseConversationDirName("2025-01-15T00-00-00.000Z_foo\\bar"),
+      ).toBeNull();
+    });
+  });
+
+  describe("ids containing underscores", () => {
+    test("captures everything after the timestamp as the conversationId", () => {
+      const name = "2026-04-07T10-47-23.075Z_my_test_id";
+      const parsed = parseConversationDirName(name);
+      expect(parsed).not.toBeNull();
+      expect(parsed?.conversationId).toBe("my_test_id");
+      expect(parsed?.createdAtMs).toBe(Date.parse("2026-04-07T10:47:23.075Z"));
+    });
+  });
+});

package/src/__tests__/conversation-fork-crud.test.ts

@@ -35,6 +35,7 @@ import {
   addMessage,
   createConversation,
   forkConversation,
+  getConversationHostAccess,
   getMessages,
   PRIVATE_CONVERSATION_FORK_ERROR,
 } from "../memory/conversation-crud.js";
@@ -138,6 +139,22 @@ describe("forkConversation", () => {
     ).toBe(true);
   });
 
+  test("forked conversations start with host access disabled", async () => {
+    const source = createConversation({
+      title: "Computer-enabled thread",
+      hostAccess: true,
+    });
+    await addMessage(source.id, "user", "Use the computer", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(getConversationHostAccess(source.id)).toBe(true);
+    expect(getConversationHostAccess(fork.id)).toBe(false);
+    expect(fork.hostAccess).toBe(0);
+  });
+
   test("preserves source order when source messages share a timestamp", () => {
     const source = createConversation("Equal timestamp thread");
     const db = getDb();

package/src/__tests__/conversation-history-web-search.test.ts

@@ -747,6 +747,7 @@ describe("web_search_tool_result structural guard", () => {
     // web_search_tool_result has a structurally different content format
     // (array of web_search_result objects) and is not truncated this way.
     "context/tool-result-truncation.ts",
+    "context/post-turn-tool-result-truncation.ts",
 
     // Anthropic provider type guards define API-specific discriminants.
     // It has a separate isWebSearchToolResultBlock for the other type.