@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/gateway-flag-listener.test.ts

@@ -0,0 +1,237 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer, type Server, type Socket } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach,beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Isolated temp directory for the IPC socket
+// ---------------------------------------------------------------------------
+const testRoot = mkdtempSync(join(tmpdir(), "flag-listener-test-"));
+const socketPath = join(testRoot, "gateway.sock");
+
+// ---------------------------------------------------------------------------
+// Mock socket-path resolution to use our test socket
+// ---------------------------------------------------------------------------
+mock.module("../ipc/socket-path.js", () => ({
+  resolveIpcSocketPath: (_name: string) => ({
+    path: socketPath,
+    source: "workspace" as const,
+  }),
+  getAssistantSocketPath: () => join(testRoot, "assistant.sock"),
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to refreshOverridesFromGateway
+// ---------------------------------------------------------------------------
+let refreshCallCount = 0;
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  refreshOverridesFromGateway: async () => {
+    refreshCallCount++;
+  },
+  initFeatureFlagOverrides: async () => {},
+  clearFeatureFlagOverridesCache: () => {},
+  isAssistantFeatureFlagEnabled: () => true,
+  _setOverridesForTesting: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to publishSyncInvalidation so we can assert the listener
+// fans flag changes out onto the SSE hub.
+// ---------------------------------------------------------------------------
+let publishedTagSets: string[][] = [];
+
+mock.module("../runtime/sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: async (tags: string[]) => {
+    publishedTagSets.push([...tags]);
+    return { type: "sync_changed", tags };
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic imports (after mock.module)
+// ---------------------------------------------------------------------------
+const { startGatewayFlagListener, stopGatewayFlagListener } = await import(
+  "../ipc/gateway-flag-listener.js"
+);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTestServer(): {
+  server: Server;
+  clients: Set<Socket>;
+  emit: (event: string, data?: unknown) => void;
+  waitForClient: () => Promise<Socket>;
+} {
+  const clients = new Set<Socket>();
+  const clientWaiters: Array<(socket: Socket) => void> = [];
+
+  const server = createServer((socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+    const waiter = clientWaiters.shift();
+    if (waiter) waiter(socket);
+  });
+
+  return {
+    server,
+    clients,
+    emit: (event: string, data?: unknown) => {
+      const payload = JSON.stringify({ event, data }) + "\n";
+      for (const client of clients) {
+        if (!client.destroyed) client.write(payload);
+      }
+    },
+    waitForClient: () =>
+      new Promise((resolve) => {
+        if (clients.size > 0) {
+          resolve(clients.values().next().value!);
+          return;
+        }
+        clientWaiters.push(resolve);
+      }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("gateway-flag-listener", () => {
+  let testServer: ReturnType<typeof createTestServer>;
+
+  beforeEach(() => {
+    mkdirSync(testRoot, { recursive: true });
+    refreshCallCount = 0;
+    publishedTagSets = [];
+    testServer = createTestServer();
+  });
+
+  afterEach(async () => {
+    stopGatewayFlagListener();
+    await new Promise<void>((resolve) => {
+      for (const client of testServer.clients) {
+        if (!client.destroyed) client.destroy();
+      }
+      testServer.server.close(() => resolve());
+    });
+    try {
+      rmSync(socketPath, { force: true });
+    } catch {
+      // best effort
+    }
+  });
+
+  test("refreshes flag cache on connect and on feature_flags_changed event", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(1);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(2);
+  });
+
+  test("broadcasts feature-flags sync_changed when flags change", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Connect refresh should not broadcast — only an actual change does.
+    expect(publishedTagSets.length).toBe(0);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(publishedTagSets.length).toBe(1);
+    expect(publishedTagSets[0]).toEqual([
+      "feature-flags:client",
+      "feature-flags:assistant",
+    ]);
+  });
+
+  test("ignores non-flag events", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    const countAfterConnect = refreshCallCount;
+
+    testServer.emit("some_other_event");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(countAfterConnect);
+  });
+
+  test("reconnects on disconnect and handles events on new connection", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    const firstClient = await testServer.waitForClient();
+
+    // Wait for the close event to propagate back to the server before
+    // setting up the next waitForClient — otherwise waitForClient might
+    // resolve with the old (now-destroyed) socket that is still in the set.
+    await new Promise<void>((resolve) => {
+      firstClient.on("close", resolve);
+      firstClient.destroy();
+    });
+
+    // Wait for reconnect (initial backoff is 1s)
+    const secondClient = await Promise.race([
+      testServer.waitForClient(),
+      new Promise<null>((r) => setTimeout(() => r(null), 3000)),
+    ]);
+
+    expect(secondClient).not.toBeNull();
+
+    await new Promise((r) => setTimeout(r, 100));
+    const countAfterReconnect = refreshCallCount;
+    expect(countAfterReconnect).toBeGreaterThan(0);
+
+    const payload =
+      JSON.stringify({ event: "feature_flags_changed" }) + "\n";
+    secondClient!.write(payload);
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(refreshCallCount).toBe(countAfterReconnect + 1);
+  });
+
+  test("stopGatewayFlagListener cleans up and does not reconnect", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+
+    stopGatewayFlagListener();
+    await new Promise((r) => setTimeout(r, 50));
+
+    const initialClientCount = testServer.clients.size;
+
+    // Wait past reconnect backoff — should not reconnect
+    await new Promise((r) => setTimeout(r, 1500));
+
+    expect(testServer.clients.size).toBeLessThanOrEqual(initialClientCount);
+  });
+});

package/src/__tests__/gemini-provider.test.ts

@@ -75,6 +75,12 @@ mock.module("@google/genai", () => ({
     };
   },
   ApiError: FakeApiError,
+  ThinkingLevel: {
+    MINIMAL: "MINIMAL",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+    HIGH: "HIGH",
+  },
 }));
 
 // Import after mocking
@@ -223,6 +229,78 @@ describe("GeminiProvider", () => {
     expect(config.systemInstruction).toBe("You are a helpful assistant.");
   });
 
+  // -----------------------------------------------------------------------
+  // Thinking config
+  // -----------------------------------------------------------------------
+  test("omits thinkingConfig when no thinking config is supplied", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
+  test("maps wire { type: 'adaptive', level, streamThinking } to Gemini thinkingConfig", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      {
+        config: {
+          thinking: {
+            type: "adaptive",
+            level: "high",
+            streamThinking: false,
+          },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "HIGH",
+      includeThoughts: false,
+    });
+  });
+
+  test("maps wire { type: 'disabled' } to MINIMAL thinking level", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "disabled" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "MINIMAL",
+      includeThoughts: false,
+    });
+  });
+
+  test("omits thinkingConfig when wire shape is adaptive with no extras", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "adaptive" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    // No level/streamThinking → omit so Google's per-model default applies
+    // (Gemini 3.x defaults to "medium" with dynamic thinking).
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
   // -----------------------------------------------------------------------
   // Tool definitions
   // -----------------------------------------------------------------------

package/src/__tests__/guardian-dispatch.test.ts

@@ -56,7 +56,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     }
     return mockEmitResult;
   },
-  registerBroadcastFn: () => {},
 }));
 
 import {

package/src/__tests__/guardian-outbound-http.test.ts

@@ -280,11 +280,13 @@ describe("startOutbound", () => {
     expect(voiceCallInitCalls.length).toBe(1);
   });
 
-  test("unsupported channel returns unsupported_channel", async () => {
-    // Cast to bypass type checking for test purposes
-    const result = await startOutbound({ channel: "email" as never });
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("unsupported_channel");
+  test("email channel creates outbound session", async () => {
+    const result = await startOutbound({
+      channel: "email",
+      destination: "user@example.com",
+    });
+    expect(result.success).toBe(true);
+    expect(result.channel).toBe("email");
   });
 });
 

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -193,6 +193,6 @@ describe("handleConfirmationResponse canonical status sync", () => {
     // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
     // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
     expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
-    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
+    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow", "approved");
   });
 });

package/src/__tests__/headless-browser-navigate.test.ts

@@ -27,6 +27,7 @@ let cdpSendHandler: (
   params?: Record<string, unknown>,
 ) => unknown = () => ({});
 let cdpDisposed = false;
+let cdpSetSessionIdCalls: Array<string | undefined> = [];
 
 function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
   return {
@@ -43,6 +44,12 @@ function makeFakeCdp(kind: "local" | "extension", conversationId: string) {
     dispose() {
       cdpDisposed = true;
     },
+    // Mirrors the optional method on the real CdpClient interface so
+    // the --new-tab path can be exercised end-to-end. Recorded for
+    // per-test assertions.
+    setCdpSessionId(cdpSessionId: string | undefined) {
+      cdpSetSessionIdCalls.push(cdpSessionId);
+    },
   };
 }
 
@@ -135,6 +142,7 @@ mock.module("../tools/network/url-safety.js", () => ({
 }));
 
 import { executeBrowserNavigate } from "../tools/browser/browser-execution.js";
+import { __resetPinnedTabsForTests } from "../tools/browser/pinned-tabs.js";
 import type { ToolContext } from "../tools/types.js";
 
 const ctx: ToolContext = {
@@ -212,6 +220,7 @@ function resetCdp() {
   cdpSendCalls = [];
   cdpDisposed = false;
   cdpSendHandler = defaultCdpHandler;
+  cdpSetSessionIdCalls = [];
 }
 
 describe("executeBrowserNavigate", () => {
@@ -223,6 +232,7 @@ describe("executeBrowserNavigate", () => {
     resolveResult = {};
     resetMockPage();
     resetCdp();
+    __resetPinnedTabsForTests();
   });
 
   // ── Input validation ───────────────────────────────────────────
@@ -664,6 +674,168 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
+  // ── --new-tab flag (extension path only) ──────────────────────
+
+  test("extension path with new_tab: true opens a fresh tab and pins it before Page.navigate", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return { tabId: "999" };
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+
+    // Vellum.createTab fired and fired BEFORE Page.navigate.
+    const createIdx = cdpSendCalls.findIndex(
+      (c) => c.method === "Vellum.createTab",
+    );
+    const navIdx = cdpSendCalls.findIndex((c) => c.method === "Page.navigate");
+    expect(createIdx).toBeGreaterThanOrEqual(0);
+    expect(navIdx).toBeGreaterThanOrEqual(0);
+    expect(createIdx).toBeLessThan(navIdx);
+
+    // setCdpSessionId was invoked with the returned tabId so the
+    // follow-on commands on this client route to the new tab.
+    expect(cdpSetSessionIdCalls).toContain("999");
+  });
+
+  test("new_tab: true on extension path with createTab failure aborts with a clear error", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        throw new Error("createTab returned no tabId");
+      }
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Failed to open a new tab");
+    // Page.navigate must NOT fire — that's exactly what --new-tab is
+    // supposed to prevent in the failure case (silent fallback to
+    // active-tab clobbering would defeat the purpose of the flag).
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(false);
+    // The createTab-failure path early-returns BEFORE the main
+    // try/finally that wraps the navigate flow, so the executor has to
+    // dispose the CDP client manually. Verifying here so future edits
+    // to that early-return don't silently regress the cleanup.
+    expect(cdpDisposed).toBe(true);
+  });
+
+  test("new_tab: true on extension path with no tabId in response clears live session and still continues", async () => {
+    // Defensive: dispatcher returns success but no tabId. The
+    // executor logs a warn, resets the live cdp session to undefined
+    // (so the follow-on Page.navigate routes to the active tab
+    // instead of any stale pin the cdp instance was constructed
+    // with), and proceeds. The navigate still runs (degraded
+    // behaviour but not a hard failure).
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No new pin was set, BUT the live session was reset to undefined
+    // so the follow-on Page.navigate falls back to active-tab routing
+    // instead of any stale pin the cdp instance held at construction.
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    // Page.navigate still ran.
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+  });
+
+  test("new_tab: true with no tabId in response clears a pre-existing stale pin AND live session (regression)", async () => {
+    // Regression for the Codex round-2 findings (P2 + round-3 P1):
+    // when Vellum.createTab returns a malformed response with no
+    // tabId, the executor falls back to active-tab routing — but
+    // (a) the pin store still held the stale pin (round-2 P2 fix
+    // added clearPinnedTab), and (b) the LIVE cdp instance was
+    // already constructed with that stale cdpSessionId, so the
+    // follow-on Page.navigate would still route to the dead tab
+    // unless we reset the session on the cdp instance too (round-3
+    // P1 fix added cdp.setCdpSessionId(undefined)).
+    const { setPinnedTab, getPinnedTab } = await import(
+      "../tools/browser/pinned-tabs.js"
+    );
+    setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
+    expect(getPinnedTab(ctx.conversationId)).toBe("stale-pinned-tab-id");
+
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return {}; // no tabId
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // (a) Pin store cleared.
+    expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
+    // (b) Live cdp session reset (the fake records every
+    // setCdpSessionId arg; expect exactly one call with undefined).
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+  });
+
+  test("new_tab: true on LOCAL path is a no-op (Playwright manages its own isolated browser)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = false; // local path
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // No Vellum.createTab was issued on the local path — the flag is
+    // silently ignored because Playwright opens its own browser and
+    // there's no user-tab to disturb.
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
+  test("absence of new_tab leaves extension path untouched (no Vellum.createTab)", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page" }, // no new_tab key at all
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(cdpSetSessionIdCalls).toEqual([]);
+  });
+
   // ── Defense-in-depth: post-navigation final URL check ─────────
 
   test("post-nav check blocks when final URL resolves to private target", async () => {

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -91,6 +91,10 @@ mock.module("../notifications/emit-signal.js", () => ({
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE: "# User Profile\n",
   resolveGuardianPersona: () => "# User Profile\n",
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 mock.module("../memory/conversation-title-service.js", () => ({

package/src/__tests__/heartbeat-service.test.ts

@@ -112,6 +112,10 @@ let mockGuardianPersona: string | null = null;
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE,
   resolveGuardianPersona: () => mockGuardianPersona,
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 // Mock conversation store

package/src/__tests__/host-bash-proxy.test.ts

@@ -31,6 +31,12 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
     _conversationId?: string,
     options?: unknown,
   ) => {
+    // `interaction_resolved` envelopes are emitted by the pending-interactions
+    // tracker for every resolution. They are orthogonal to the host-proxy
+    // wire messages these tests assert on, so swallow them here.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
     sentMessages.push(msg);
     sentMessageOptions.push(options);
   },

package/src/__tests__/host-browser-proxy.test.ts

@@ -31,6 +31,13 @@ let mockClients: MockClient[] = [];
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     publish: async (event: unknown, _options?: unknown) => {
+      // `interaction_resolved` envelopes are emitted by the
+      // pending-interactions tracker for every resolution. They are
+      // orthogonal to the host-browser wire messages these tests assert
+      // on, so swallow them here.
+      if ((event as { type?: string } | null)?.type === "interaction_resolved") {
+        return;
+      }
       publishedEvents.push(event);
     },
     getMostRecentClientByCapability: (cap: string) =>
@@ -41,6 +48,9 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       mockClients.find((c) => c.clientId === clientId)?.actorPrincipalId,
   },
   broadcastMessage: (msg: unknown) => {
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
     publishedEvents.push(msg);
   },
 }));

package/src/__tests__/host-cu-proxy.test.ts

@@ -10,7 +10,14 @@ type MockClient = {
 let mockClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,

package/src/__tests__/host-file-proxy.test.ts

@@ -12,7 +12,14 @@ interface MockClient {
 let mockClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  broadcastMessage: (msg: unknown) => {
+    // Skip `interaction_resolved` envelopes — pending-interactions emits one
+    // on every resolve and these tests assert on host-proxy wire messages.
+    if ((msg as { type?: string } | null)?.type === "interaction_resolved") {
+      return;
+    }
+    sentMessages.push(msg);
+  },
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) => {
       if (mockClients.length > 0) {

package/src/__tests__/host-shell-tool.test.ts

@@ -264,7 +264,7 @@ describe("host_bash — baseline: no sandbox isolation", () => {
 // These tests lock that boundary so any accidental addition is caught.
 
 describe("host_bash — regression: no proxied-mode additions", () => {
-  const definition = hostShellTool.getDefinition();
+  const definition = hostShellTool;
   const schemaProps = (definition.input_schema as Record<string, unknown>)
     .properties as Record<string, unknown>;