@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/subagent-notify-parent.test.ts

@@ -41,18 +41,12 @@ const capturedMessages: string[] = [];
 /** Parent conversation ids that a notification was routed to (findConversation). */
 const capturedParentIds: string[] = [];
 
-/**
- * Cron attribution seen by each delivery path. The queued path hands it to
- * `enqueueMessage` (the drain applies it later); the immediate path hands it
- * straight to `runAgentLoop`.
- */
 const capturedEnqueueCronRunIds: (string | null | undefined)[] = [];
-const capturedLoopCronRunIds: (string | null | undefined)[] = [];
-
-/**
- * Whether the stub parent accepts an enqueue. `false` sends
- * `injectMessageIntoParent` down its immediate persist-and-run path.
- */
+const capturedQueueOptions: {
+  queueWhenIdle: boolean;
+  metadata?: Record<string, unknown>;
+}[] = [];
+const drainedParents: string[] = [];
 let parentAcceptsEnqueue = true;
 
 // Live subagent conversations, keyed by conversationId. notifyParentFromChild
@@ -74,19 +68,17 @@ mock.module("../daemon/conversation-registry.js", () => ({
       hasInFlightWork: () => false,
       enqueueMessage: (options: {
         content: string;
+        queueWhenIdle: boolean;
+        metadata?: Record<string, unknown>;
         cronRunId?: string | null;
       }) => {
         capturedMessages.push(options.content);
+        capturedQueueOptions.push(options);
         capturedEnqueueCronRunIds.push(options.cronRunId);
         return { queued: parentAcceptsEnqueue };
       },
-      persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-      runAgentLoop: async (
-        _message: string,
-        _messageId: string,
-        options?: { cronRunId?: string | null },
-      ) => {
-        capturedLoopCronRunIds.push(options?.cronRunId);
+      kickDrainQueue: async () => {
+        drainedParents.push(id);
       },
     };
   },
@@ -111,11 +103,15 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 
 import type { Conversation } from "../daemon/conversation.js";
 import { isToolActiveForContext } from "../daemon/conversation-tool-setup.js";
+import { beginTurnFinalization } from "../daemon/turn-finalization.js";
+import { setLiveVoiceSessionManagerForTesting } from "../live-voice/live-voice-manager.js";
+import { LiveVoiceSessionManager } from "../live-voice/live-voice-session-manager.js";
 import type { SubagentRecord } from "../persistence/subagent-store.js";
 import {
   injectMessageIntoParent,
   notifyParentFromChild,
 } from "../subagent/notify.js";
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
 import {
   executeSubagentNotifyParent,
   notifyParentTool,
@@ -183,12 +179,108 @@ function lastCapturedMessage(): string {
 function clearCaptured(): void {
   capturedMessages.length = 0;
   capturedEnqueueCronRunIds.length = 0;
-  capturedLoopCronRunIds.length = 0;
+  capturedQueueOptions.length = 0;
+  drainedParents.length = 0;
   parentAcceptsEnqueue = true;
 }
 
 // ── Tool definition ────────────────────────────────────────────────
 
+describe("voice parent notification routing", () => {
+  test("only the matching active call claims task updates, without starting a generic parent turn", async () => {
+    clearCaptured();
+    const received: SubagentParentNotification[] = [];
+    let finishClose: (() => void) | undefined;
+    const manager = new LiveVoiceSessionManager({
+      createSession: (context) => ({
+        start: async () => {
+          await context.sendFrame({
+            type: "ready",
+            sessionId: context.sessionId,
+            conversationId: "parent-voice",
+          });
+        },
+        handleClientFrame: () => {},
+        handleBinaryAudio: () => {},
+        close: () =>
+          new Promise<void>((resolve) => {
+            finishClose = resolve;
+          }),
+        receiveSubagentNotification: (notification) => {
+          received.push(notification);
+          return true;
+        },
+      }),
+    });
+    setLiveVoiceSessionManagerForTesting(manager);
+    const metadata = {
+      subagentNotification: {
+        subagentId: "task-1",
+        status: "completed",
+        conversationId: "child-1",
+      },
+    };
+    try {
+      await manager.startSession(
+        {
+          type: "start",
+          audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
+        },
+        { sendFrame: () => {} },
+      );
+      injectMessageIntoParent("parent-voice", "Task completed", metadata, {
+        cronRunId: "run-123",
+      });
+      expect(received).toEqual([
+        {
+          taskId: "child-1",
+          message: "Task completed",
+          metadata,
+          cronRunId: "run-123",
+        },
+      ]);
+      expect(capturedMessages).toEqual([]);
+      expect(drainedParents).toEqual([]);
+
+      injectMessageIntoParent("parent-other", "Other task completed", metadata);
+      injectMessageIntoParent("parent-voice", "Generic event");
+      injectMessageIntoParent("parent-voice", "Hang-up fallback", metadata, {
+        bypassLiveVoice: true,
+        cronRunId: "run-123",
+      });
+      expect(received).toHaveLength(1);
+      expect(capturedMessages).toEqual([
+        "Other task completed",
+        "Generic event",
+        "Hang-up fallback",
+      ]);
+      expect(capturedEnqueueCronRunIds.at(-1)).toBe("run-123");
+
+      const closing = manager.endActiveSession("manager_shutdown");
+      injectMessageIntoParent(
+        "parent-voice",
+        "Finished during hang-up",
+        metadata,
+      );
+      expect(received.at(-1)?.message).toBe("Finished during hang-up");
+      expect(capturedMessages).not.toContain("Finished during hang-up");
+      finishClose?.();
+      await closing;
+      injectMessageIntoParent(
+        "parent-voice",
+        "Finished after hang-up",
+        metadata,
+      );
+      expect(capturedMessages.at(-1)).toBe("Finished after hang-up");
+    } finally {
+      finishClose?.();
+      await manager.endActiveSession("manager_shutdown");
+      setLiveVoiceSessionManagerForTesting(null);
+      clearCaptured();
+    }
+  });
+});
+
 describe("notify_parent tool definition", () => {
   test("has correct core tool definition", () => {
     const def = notifyParentTool;
@@ -443,31 +535,46 @@ describe("injectMessageIntoParent cron attribution", () => {
     expect(capturedEnqueueCronRunIds).toEqual(["cron-run-7"]);
   });
 
-  test("the immediate delivery path carries the firing's run id", async () => {
+  test("queues simultaneous idle-parent deliveries until turn finalization", async () => {
     clearCaptured();
-    // A parent that is not processing rejects the enqueue, so the injection
-    // persists and runs the turn itself.
-    parentAcceptsEnqueue = false;
-
-    injectMessageIntoParent("parent-cron", "notification", undefined, {
-      cronRunId: "cron-run-7",
-    });
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(capturedLoopCronRunIds).toEqual(["cron-run-7"]);
+    const finalize = beginTurnFinalization("parent-handoff");
+    try {
+      injectMessageIntoParent("parent-handoff", "first result", undefined, {
+        bypassLiveVoice: true,
+      });
+      injectMessageIntoParent("parent-handoff", "second result", undefined, {
+        bypassLiveVoice: true,
+      });
+      expect(capturedMessages).toEqual(["first result", "second result"]);
+      expect(capturedQueueOptions).toEqual([
+        expect.objectContaining({
+          queueWhenIdle: true,
+          metadata: { scripted: true },
+        }),
+        expect.objectContaining({
+          queueWhenIdle: true,
+          metadata: { scripted: true },
+        }),
+      ]);
+      expect(drainedParents).toEqual([]);
+    } finally {
+      finalize();
+    }
+    await Promise.resolve();
+    expect(drainedParents).toEqual(["parent-handoff", "parent-handoff"]);
   });
 
-  test("an unscheduled notification carries no run id on either path", async () => {
+  test("does not start an unqueued turn when the parent queue rejects delivery", () => {
     clearCaptured();
-
-    injectMessageIntoParent("parent-plain", "notification");
     parentAcceptsEnqueue = false;
-    injectMessageIntoParent("parent-plain", "notification");
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    injectMessageIntoParent("parent-full", "notification");
+    expect(drainedParents).toEqual([]);
+  });
 
-    // Not merely falsy: the option is absent, so nothing downstream reads an
-    // attribution no firing produced.
-    expect(capturedEnqueueCronRunIds).toEqual([undefined, undefined]);
-    expect(capturedLoopCronRunIds).toEqual([undefined]);
+  test("an unscheduled notification carries no run id", () => {
+    clearCaptured();
+    injectMessageIntoParent("parent-plain", "notification");
+    expect(capturedEnqueueCronRunIds).toEqual([undefined]);
+    expect(drainedParents).toEqual(["parent-plain"]);
   });
 });

package/src/__tests__/subagent-notify-stale-rebuild.test.ts

@@ -22,8 +22,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
         delivered.push(options.content);
         return { queued: true };
       },
-      persistUserMessage: async () => ({ id: "mock-msg" }),
-      runAgentLoop: async () => {},
+      kickDrainQueue: async () => {},
     };
   },
 }));
@@ -36,8 +35,7 @@ mock.module("../daemon/conversation-store.js", () => ({
         delivered.push(`rebuilt:${options.content}`);
         return { queued: true };
       },
-      persistUserMessage: async () => ({ id: "rebuilt-msg" }),
-      runAgentLoop: async () => {},
+      kickDrainQueue: async () => {},
     };
   },
 }));

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -66,6 +66,40 @@ mock.module("../daemon/conversation-skill-tools.js", () => ({
   })),
 }));
 
+// Records every wire tool surface the resolver persists (conversation id +
+// tool names + the hash it already knew), and lets a test make the write fail.
+type RecordedSurface = {
+  tools: ToolDefinition[];
+  delegateIndependentTasks: boolean | null;
+};
+let recordedSurfaces: Array<{
+  conversationId: string;
+  toolNames: string[];
+  delegateIndependentTasks: boolean | null;
+  knownHash: string | undefined;
+}> = [];
+let recordSurfaceThrows: Error | null = null;
+mock.module("../persistence/conversation-tool-surface.js", () => ({
+  recordConversationToolSurface: (
+    conversationId: string,
+    surface: RecordedSurface,
+    knownHash?: string,
+  ) => {
+    recordedSurfaces.push({
+      conversationId,
+      toolNames: surface.tools.map((t) => t.name),
+      delegateIndependentTasks: surface.delegateIndependentTasks,
+      knownHash,
+    });
+    if (recordSurfaceThrows) {
+      throw recordSurfaceThrows;
+    }
+    return `hash:${surface.tools.map((t) => t.name).join(",")}`;
+  },
+  hashConversationToolSurface: (surface: RecordedSurface) =>
+    `hash:${surface.tools.map((t) => t.name).join(",")}`,
+}));
+
 // ---------------------------------------------------------------------------
 // Imports after mocks are in place
 // ---------------------------------------------------------------------------
@@ -75,6 +109,7 @@ import { createSurfaceMutex } from "../daemon/conversation-surfaces.js";
 import {
   createResolveToolsCallback,
   createToolExecutor,
+  createWireToolSurfaceRecorder,
   isRefusedInReadOnlyPass,
   type SubagentToolStats,
 } from "../daemon/conversation-tool-setup.js";
@@ -1117,3 +1152,194 @@ describe("createResolveToolsCallback — read-only hides dynamic MCP tools", ()
     expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toContain("srv_send");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Resolver: wire tool surface record + replay (fork cache parity)
+// ---------------------------------------------------------------------------
+
+describe("createResolveToolsCallback: wire tool surface record and replay", () => {
+  beforeEach(() => {
+    recordedSurfaces = [];
+    recordSurfaceThrows = null;
+    projectedSkillToolNames = [];
+  });
+
+  test("the resolver itself never records: out-of-band callers read it too", () => {
+    const toolDefs = [makeToolDef("remember"), makeToolDef("tool_b")];
+    const ctx = makeProjectionCtx({ conversationId: "conv-live" });
+    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
+
+    // The `/compact` token count resolves outside any turn, where presence
+    // reads clientless; recording here would overwrite the sent surface.
+    resolve(EMPTY_HISTORY);
+
+    expect(recordedSurfaces).toEqual([]);
+    expect(ctx.recordedToolSurfaceHash).toBeUndefined();
+  });
+
+  test("the send-boundary recorder records the sent array, keyed by conversation, and remembers its hash", () => {
+    const ctx = makeProjectionCtx({
+      conversationId: "conv-live",
+      renderedDelegateIndependentTasks: true,
+    });
+    const record = createWireToolSurfaceRecorder(ctx);
+    const sent = [makeToolDef("remember"), makeToolDef("web_search")];
+
+    record(sent);
+    record(sent);
+
+    // Every provider call records; the persistence layer dedupes on the hash
+    // handed back from the previous call.
+    expect(recordedSurfaces).toEqual([
+      {
+        conversationId: "conv-live",
+        toolNames: ["remember", "web_search"],
+        delegateIndependentTasks: true,
+        knownHash: undefined,
+      },
+      {
+        conversationId: "conv-live",
+        toolNames: ["remember", "web_search"],
+        delegateIndependentTasks: true,
+        knownHash: "hash:remember,web_search",
+      },
+    ]);
+    expect(ctx.recordedToolSurfaceHash).toBe("hash:remember,web_search");
+  });
+
+  test("the recorder records the state the prompt build captured, never a re-derivation", () => {
+    const sent = [makeToolDef("remember")];
+
+    // The loop sends the prompt built before the run, so the captured state
+    // is recorded as is even where the live scope would now derive the
+    // opposite: a spawn path excluded after the build (here, an allowlist
+    // with none) still records the section on...
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({
+        conversationId: "conv-captured-on",
+        subagentAllowedTools: new Set(["remember"]),
+        renderedDelegateIndependentTasks: true,
+      }),
+    )(sent);
+    // ...and a path restored after the build still records it off.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({
+        conversationId: "conv-captured-off",
+        renderedDelegateIndependentTasks: false,
+      }),
+    )(sent);
+    // A verbatim system-prompt override captures unknown.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({
+        conversationId: "conv-override",
+        renderedDelegateIndependentTasks: null,
+      }),
+    )(sent);
+    // No prompt built yet: unknown as well.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({ conversationId: "conv-unbuilt" }),
+    )(sent);
+
+    expect(
+      recordedSurfaces.map((r) => [
+        r.conversationId,
+        r.delegateIndependentTasks,
+      ]),
+    ).toEqual([
+      ["conv-captured-on", true],
+      ["conv-captured-off", false],
+      ["conv-override", null],
+      ["conv-unbuilt", null],
+    ]);
+  });
+
+  test("a failed record is swallowed and still counts as recorded", () => {
+    recordSurfaceThrows = new Error("no such table");
+    const record = createWireToolSurfaceRecorder(
+      makeProjectionCtx({ conversationId: "conv-live" }),
+    );
+
+    expect(() => record([makeToolDef("remember")])).not.toThrow();
+    record([makeToolDef("remember")]);
+
+    // The second call carries the hash from the failed first one, so a
+    // persistent failure is retried once per distinct surface, not per call.
+    expect(recordedSurfaces.map((r) => r.knownHash)).toEqual([
+      undefined,
+      "hash:remember",
+    ]);
+  });
+
+  test("the recorder skips arrays that are not the conversation's own surface", () => {
+    const tools = [makeToolDef("remember")];
+
+    // A replaying wake sends its source's array.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({ conversationId: "conv-fork", wireToolReplay: tools }),
+    )(tools);
+    // A tools-disabled call sends nothing; a fork replaying [] could never
+    // call remember.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({ conversationId: "conv-live" }),
+    )([]);
+    // Disk-pressure cleanup narrows the wire to cleanup tools.
+    createWireToolSurfaceRecorder(
+      makeProjectionCtx({
+        conversationId: "conv-live",
+        diskPressureCleanupModeActive: true,
+      }),
+    )(tools);
+
+    expect(recordedSurfaces).toEqual([]);
+  });
+
+  test("replays wireToolReplay verbatim on the wire while execution still derives from the fork's own context", () => {
+    projectedSkillToolNames = ["scaffold_managed_skill"];
+    const replay: ToolDefinition[] = [
+      makeToolDef("bash"),
+      makeToolDef("remember"),
+      makeToolDef("bell_jingle"),
+      {
+        type: "web_search_20250305",
+        name: "web_search",
+        max_uses: 5,
+      } as unknown as ToolDefinition,
+    ];
+    // The fork's own registry lacks bell_jingle (a user-plugin tool the
+    // worker never loads) and web_search (a server tool the loop appends).
+    const toolDefs = [makeToolDef("remember"), makeToolDef("bash")];
+    const ctx = makeProjectionCtx({
+      conversationId: "conv-fork",
+      subagentAllowedTools: new Set(["remember"]),
+      subagentToolGateMode: "execution",
+      wireToolReplay: replay,
+    });
+    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
+
+    const tools = resolve(EMPTY_HISTORY);
+
+    // Byte-identical to the source's recorded array, in the source's order,
+    // including definitions this process could never resolve.
+    expect(JSON.stringify(tools)).toBe(JSON.stringify(replay));
+    // Execution-side inventory is still the fork's own derivation (plus the
+    // preactivated skill tools), never widened by the replayed definitions.
+    expect(ctx.allowedToolNames).toEqual(
+      new Set(["remember", "bash", "scaffold_managed_skill"]),
+    );
+  });
+
+  test("replay returns a fresh array each call so the loop cannot mutate the recorded one", () => {
+    const replay = [makeToolDef("remember")];
+    const ctx = makeProjectionCtx({
+      conversationId: "conv-fork",
+      wireToolReplay: replay,
+    });
+    const resolve = createResolveToolsCallback([makeToolDef("remember")], ctx)!;
+
+    const first = resolve(EMPTY_HISTORY);
+    first.push(makeToolDef("injected"));
+
+    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
+    expect(replay.map((t) => t.name)).toEqual(["remember"]);
+  });
+});

package/src/__tests__/surface-completion-in-flight-snapshot.test.ts

@@ -82,6 +82,7 @@ import type {
 import type { CurrentTurnSurface } from "../daemon/conversation-surface-state.js";
 import type { SurfaceStateEntry } from "../daemon/conversation-surface-state.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const CONVERSATION_ID = "conv-in-flight-surface-1";
 const SURFACE_ID = "surface-in-flight-1";
@@ -112,6 +113,7 @@ function makeContext(): Conversation {
     accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
+    modeSessions: mockUnownedModeSessions(),
     pendingStandaloneSurfaces: new Map(),
     recentlyCompletedStandaloneSurfaces: new Map(),
     isProcessing: () => false,

package/src/__tests__/terminal-tools.test.ts

@@ -44,6 +44,7 @@ import {
   formatShellOutput,
   MAX_OUTPUT_LENGTH,
   OUTPUT_TRUNCATED_TAG,
+  SHELL_DID_NOT_START_MESSAGE,
 } from "../tools/shared/shell-output.js";
 import {
   ALWAYS_INJECTED_ENV_VARS,
@@ -334,6 +335,13 @@ describe("formatShellOutput", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("a close with exit 0 and empty pipes is an error when the process never started", () => {
+    const result = formatShellOutput("", "", 0, false, 120, { started: false });
+    expect(result.content).toBe(SHELL_DID_NOT_START_MESSAGE);
+    expect(result.isError).toBe(true);
+    expect(result.content).not.toBe("<command_completed />");
+  });
+
   test("failed command with no output shows exit code tag and descriptive message", () => {
     const result = formatShellOutput("", "", 1, false, 120);
     expect(result.content).toContain('<command_exit code="1" />');

package/src/__tests__/thread-backfill.test.ts

@@ -90,6 +90,7 @@ mock.module("../messaging/providers/slack/adapter.js", () => ({
 
 import { v4 as uuid } from "uuid";
 
+import * as inboundTrustReader from "../calls/inbound-trust-reader.js";
 import {
   loadRawConfig,
   saveRawConfig,
@@ -142,10 +143,15 @@ installDefaultThreadPageMock();
 backfillThreadMock.mockResolvedValue([]);
 const backfillDmMock = spyOn(slackBackfill, "backfillDm");
 backfillDmMock.mockResolvedValue([]);
+// Backfilled senders are classified by the gateway verdict. With no gateway in
+// the test process the real read reports unreachable, so tests that need a
+// verdict stub it per call.
+const readInboundTrustSpy = spyOn(inboundTrustReader, "readInboundTrust");
 
 afterAll(() => {
   backfillThreadPageMock.mockRestore();
   backfillDmMock.mockRestore();
+  readInboundTrustSpy.mockRestore();
 });
 
 // ---------------------------------------------------------------------------
@@ -307,6 +313,7 @@ interface PersistedRow {
   provenanceSourceChannel: string | undefined;
   provenanceGuardianExternalUserId: string | undefined;
   provenanceRequesterIdentifier: string | undefined;
+  provenanceContactId: string | undefined;
 }
 
 const EXTERNAL_CONTENT_WRAPPER =
@@ -340,6 +347,7 @@ function readPersistedSlackRows(conversationId: string): PersistedRow[] {
       provenanceSourceChannel: undefined,
       provenanceGuardianExternalUserId: undefined,
       provenanceRequesterIdentifier: undefined,
+      provenanceContactId: undefined,
     };
     if (!row.metadata) {
       out.push(blank);
@@ -402,6 +410,10 @@ function readPersistedSlackRows(conversationId: string): PersistedRow[] {
         typeof envelope.provenanceRequesterIdentifier === "string"
           ? envelope.provenanceRequesterIdentifier
           : undefined,
+      provenanceContactId:
+        typeof envelope.provenanceContactId === "string"
+          ? envelope.provenanceContactId
+          : undefined,
     });
   }
   return out;
@@ -1149,6 +1161,47 @@ describe("triggerSlackThreadBackfillIfNeeded — gap detection and persistence",
     expect(persisted.provenanceRequesterIdentifier).toBe("U_ANITA");
   });
 
+  test("backfilled thread rows record the sender's gateway trust class and contact id", async () => {
+    const conv = createTestConversation();
+    readInboundTrustSpy.mockImplementationOnce(async () => ({
+      ok: true,
+      verdict: {
+        trustClass: "trusted_contact",
+        canonicalSenderId: "U_ANITA",
+        contactId: "contact-anita",
+        channelId: "channel-anita",
+        status: "active",
+        policy: "allow",
+      },
+      admissionPolicy: null,
+    }));
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.0",
+        text: "the export endpoint needs a scoped token",
+        threadId: undefined,
+        sender: { id: "U_ANITA", name: "Anita" },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+      guardianExternalUserId: "U_GUARDIAN",
+    });
+
+    const [persisted] = readPersistedSlackRows(conv.id).filter(
+      (p) => p.channelTs === "1234.0",
+    );
+    expect(persisted?.provenanceTrustClass).toBe("trusted_contact");
+    expect(persisted?.provenanceContactId).toBe("contact-anita");
+    expect(readInboundTrustSpy).toHaveBeenLastCalledWith({
+      channelType: "slack",
+      actorExternalId: "U_ANITA",
+    });
+  });
+
   test("backfilled Slack timezone metadata derives timestamp and speaker fields", async () => {
     const conv = createTestConversation();
     setConfiguredUserTimezone("America/Denver");

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -99,6 +99,7 @@ import {
   getCurrentSeq,
   stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -134,6 +135,7 @@ function createMockDeps(
       },
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => {
       emittedEvents.push(msg);