@vellumai/assistant 0.12.3-staging.1 → 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__/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__/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);

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -26,6 +26,7 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 import type { AssistantEvent } from "../api/index.js";
 import { toolImageFilename } from "../daemon/assistant-attachments.js";
 import type {
@@ -37,7 +38,7 @@ import {
   handleToolResult,
   handleToolUse,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
 
@@ -56,6 +57,7 @@ function createCollectorDeps(): {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId: "req-meta",

package/src/__tests__/tool-start-timestamp.test.ts

@@ -48,6 +48,7 @@ import {
   createEventHandlerState,
   handleToolUse,
 } from "../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -60,6 +61,7 @@ function makeDeps(onEvent: (event: AssistantEvent) => void): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent,
     reqId: "test-req",

package/src/__tests__/twilio-routes.test.ts

@@ -387,6 +387,7 @@ function createTestSession(
 ) {
   ensureConversation(convId);
   const session = createCallSession({
+    direction: "inbound",
     conversationId: convId,
     provider: "twilio",
     fromNumber: "+14155550111",

package/src/__tests__/web-search-backend-failure.test.ts

@@ -27,7 +27,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 
 // ---------------------------------------------------------------------------
 // Mock the daemon collaborators the handler module imports at load time so the

package/src/activation/progress-store.test.ts

@@ -25,6 +25,7 @@ import {
   beforeEach,
   describe,
   expect,
+  jest,
   mock,
   spyOn,
   test,
@@ -361,14 +362,18 @@ describe("activation progress store", () => {
       });
       publishedTags.length = 0;
 
-      for (let i = 0; i < 5; i++) {
-        await bumpActivationStepCount("conv-1");
-      }
+      jest.useFakeTimers();
+      try {
+        for (let i = 0; i < 5; i++) {
+          await bumpActivationStepCount("conv-1");
+        }
 
-      // The leading bump lands immediately; the rest coalesce behind the
-      // throttle window.
-      expect(readActivationProgress().tasks["draft-email"].stepCount).toBe(1);
-      expect(syncPublishCount()).toBe(1);
+        expect(readActivationProgress().tasks["draft-email"].stepCount).toBe(1);
+        expect(syncPublishCount()).toBe(1);
+        jest.advanceTimersByTime(THROTTLE_MS);
+      } finally {
+        jest.useRealTimers();
+      }
 
       await waitFor(
         () => readActivationProgress().tasks["draft-email"].stepCount === 5,