@vellumai/assistant 0.7.3 → 0.8.0

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.0.0
 info:
   title: Vellum Assistant API
-  version: 0.7.3
+  version: 0.8.0
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -7635,6 +7635,26 @@ paths:
                 - k
                 - sample
               additionalProperties: false
+  /v1/memory/v2/list-concept-pages:
+    post:
+      operationId: memory_v2_listconceptpages_post
+      summary: List all memory v2 concept pages with metadata
+      description:
+        Returns slugs, body sizes, edge counts, and last-modified timestamps for every concept page on disk.
+        Read-only; used by the desktop About → Memories surface to render a browse-able list.
+      tags:
+        - memory
+      responses:
+        "200":
+          description: Successful response
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties: {}
+              additionalProperties: false
   /v1/memory/v2/rebuild-corpus-stats:
     post:
       operationId: memory_v2_rebuildcorpusstats_post
@@ -7661,9 +7681,7 @@ paths:
     post:
       operationId: memory_v2_reembedskills_post
       summary: Re-seed v2 skill entries from the current skill catalog
-      description:
-        Synchronously re-runs seedV2SkillEntries against the current skill catalog. Gated on memory-v2-enabled flag
-        and config.memory.v2.enabled.
+      description: Synchronously re-runs seedV2SkillEntries against the current skill catalog. Gated on config.memory.v2.enabled.
       tags:
         - memory
       responses:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -44,6 +44,7 @@
     "@vellumai/credential-storage": "file:../packages/credential-storage",
     "@vellumai/egress-proxy": "file:../packages/egress-proxy",
     "@vellumai/gateway-client": "file:../packages/gateway-client",
+    "@vellumai/ipc-server-utils": "file:../packages/ipc-server-utils",
     "@vellumai/service-contracts": "file:../packages/service-contracts",
     "@vellumai/skill-host-contracts": "file:../packages/skill-host-contracts",
     "@vellumai/slack-text": "file:../packages/slack-text",
@@ -78,6 +79,7 @@
     "@vellumai/service-contracts",
     "@vellumai/egress-proxy",
     "@vellumai/gateway-client",
+    "@vellumai/ipc-server-utils",
     "@vellumai/skill-host-contracts",
     "@vellumai/slack-text",
     "@vellumai/twilio-client"

package/src/__tests__/annotate-risk-options.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for `annotatePersistedAssistantMessage` persisting the 3 risk-option
+ * arrays alongside the existing `_risk*` scalars.
+ *
+ * Phase B of the conflation track. Without these annotations, the Rule Editor
+ * Modal's chip ladder loses its scope/allowlist/directory options on chat-
+ * history reload and falls back to the synthesized `*` allowlist.
+ *
+ * The test exercises the full populate → annotate → persist round-trip:
+ *   handleToolResult(event with 3 arrays)
+ *     → state.toolRiskOutcomes captures them
+ *     → annotatePersistedAssistantMessage writes _risk*Options onto the row
+ *     → updateMessageContent receives the JSON-serialized output
+ *
+ * Read-side coverage (renderHistoryContent in handlers/shared.ts) lives in
+ * server-history-render.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+let mockedRowContent = "";
+const updates: Array<{ id: string; content: string }> = [];
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: (id: string) =>
+    mockedRowContent ? { id, content: mockedRowContent } : null,
+  updateMessageContent: (id: string, content: string) => {
+    updates.push({ id, content });
+  },
+  provenanceFromTrustContext: () => ({}),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleToolResult,
+} from "../daemon/conversation-agent-loop-handlers.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: "test-conv",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "test-req",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as unknown as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    } as unknown as EventHandlerDeps["turnInterfaceContext"],
+  };
+}
+
+function setupState(toolUseId: string): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "msg-1";
+  state.toolUseIdToName.set(toolUseId, "bash");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: Date.now() });
+  state.currentTurnToolUseIds.push(toolUseId);
+  return state;
+}
+
+function findPersistedToolUse(
+  rawContent: string,
+  toolUseId: string,
+): Record<string, unknown> {
+  const parsed = JSON.parse(rawContent) as Array<Record<string, unknown>>;
+  const block = parsed.find(
+    (b) => b.type === "tool_use" && b.id === toolUseId,
+  );
+  if (!block) throw new Error(`tool_use block ${toolUseId} not found`);
+  return block;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("annotatePersistedAssistantMessage — risk-option arrays (Phase B)", () => {
+  beforeEach(() => {
+    updates.length = 0;
+    mockedRowContent = "";
+  });
+
+  test("persists all 3 risk-option arrays from the live tool_result event", () => {
+    const toolUseId = "tu_persist_full";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "bash",
+        input: { command: "rm -rf /tmp" },
+      },
+    ]);
+
+    const scopeOptions = [
+      { pattern: "exact", label: "exact: rm -rf /tmp" },
+      { pattern: "by-program", label: "All rm" },
+    ];
+    const allowlistOptions = [
+      { label: "exact", description: "exact match", pattern: "rm -rf /tmp" },
+      { label: "All rm", description: "All rm commands", pattern: "rm *" },
+    ];
+    const directoryScopeOptions = [
+      { scope: "/Users/me/code", label: "in code/" },
+      { scope: "everywhere", label: "Everywhere" },
+    ];
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "high",
+      riskReason: "Modifies state",
+      matchedTrustRuleId: "rule_42",
+      riskScopeOptions: scopeOptions,
+      riskAllowlistOptions: allowlistOptions,
+      riskDirectoryScopeOptions: directoryScopeOptions,
+      approvalMode: "prompted",
+      approvalReason: "user_approved",
+      riskThreshold: "relaxed",
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    // Existing scalars still flow through.
+    expect(block._riskLevel).toBe("high");
+    expect(block._riskReason).toBe("Modifies state");
+    expect(block._matchedTrustRuleId).toBe("rule_42");
+    expect(block._approvalMode).toBe("prompted");
+    expect(block._approvalReason).toBe("user_approved");
+    expect(block._riskThreshold).toBe("relaxed");
+    // New: 3 risk-option arrays persisted verbatim.
+    expect(block._riskScopeOptions).toEqual(scopeOptions);
+    expect(block._riskAllowlistOptions).toEqual(allowlistOptions);
+    expect(block._riskDirectoryScopeOptions).toEqual(directoryScopeOptions);
+  });
+
+  test("omits empty arrays from the persisted block (saves DB space)", () => {
+    const toolUseId = "tu_persist_empty";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "bash",
+        input: { command: "ls" },
+      },
+    ]);
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "low",
+      riskScopeOptions: [],
+      riskAllowlistOptions: [],
+      riskDirectoryScopeOptions: [],
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("low");
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskAllowlistOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+
+  test("omits absent (undefined) arrays from the persisted block", () => {
+    // Mirrors classic bash/file tools that don't always emit all 3 arrays —
+    // e.g. recall, file_read with riskLevel=low and no allowlist coverage.
+    const toolUseId = "tu_persist_absent";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "recall",
+        input: { query: "anything" },
+      },
+    ]);
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "low",
+      // No risk-option arrays passed at all.
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("low");
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskAllowlistOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+
+  test("partial coverage — only allowlist options present (e.g. tools with classifier but no scope ladder)", () => {
+    const toolUseId = "tu_partial";
+    const state = setupState(toolUseId);
+
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "file_write",
+        input: { path: "/tmp/foo.txt" },
+      },
+    ]);
+
+    const allowlistOptions = [
+      { label: "exact", description: "exact match", pattern: "/tmp/foo.txt" },
+    ];
+
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+      riskLevel: "medium",
+      riskAllowlistOptions: allowlistOptions,
+    });
+
+    expect(updates).toHaveLength(1);
+    const block = findPersistedToolUse(updates[0].content, toolUseId);
+    expect(block._riskLevel).toBe("medium");
+    expect(block._riskAllowlistOptions).toEqual(allowlistOptions);
+    expect(block._riskScopeOptions).toBeUndefined();
+    expect(block._riskDirectoryScopeOptions).toBeUndefined();
+  });
+});

package/src/__tests__/approval-cascade.test.ts

@@ -291,21 +291,13 @@ function seedPendingConfirmation(
   conversation: Conversation,
   requestId: string,
 ): void {
+  // Access private ownedIds so denyAllPending/dispose can find this request.
+  // promptResolve/promptReject callbacks are stored in pendingInteractions via
+  // registerPendingInteraction, which is called separately in each test.
   const prompter = conversation["prompter"] as unknown as {
-    pending: Map<
-      string,
-      {
-        resolve: (...args: unknown[]) => void;
-        reject: (...args: unknown[]) => void;
-        timer: ReturnType<typeof setTimeout>;
-      }
-    >;
+    ownedIds: Set<string>;
   };
-  prompter.pending.set(requestId, {
-    resolve: () => {},
-    reject: () => {},
-    timer: setTimeout(() => {}, 60_000),
-  });
+  prompter.ownedIds.add(requestId);
 }
 
 /**
@@ -439,12 +431,12 @@ describe("approval cascading", () => {
       makeConfirmationDetails(["bash:echo stale"]),
     );
 
-    // Remove req-stale from the prompter's pending map (simulating it was
+    // Remove req-stale from the prompter's ownedIds (simulating it was
     // already resolved by another path before cascade reaches it)
     const prompter = conversationObj["prompter"] as unknown as {
-      pending: Map<string, unknown>;
+      ownedIds: Set<string>;
     };
-    prompter.pending.delete("req-stale");
+    prompter.ownedIds.delete("req-stale");
 
     // This should not throw — cascade should skip req-stale gracefully
     expect(() => {

package/src/__tests__/approval-routes-http.test.ts

@@ -192,6 +192,8 @@ function makeIdleSession(opts?: {
       processing = false;
     },
     handleConfirmationResponse: (requestId: string, decision: string) => {
+      // Simulate PermissionPrompter.resolveConfirmation(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onConfirmation?.(requestId, decision);
     },
     handleSecretResponse: (
@@ -199,6 +201,8 @@ function makeIdleSession(opts?: {
       value?: string,
       delivery?: string,
     ) => {
+      // Simulate SecretPrompter.resolveSecret(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onSecret?.(requestId, value, delivery);
     },
   } as unknown as Conversation;
@@ -285,6 +289,8 @@ function makeConfirmationEmittingSession(opts?: {
       await new Promise<void>(() => {});
     },
     handleConfirmationResponse: (requestId: string, decision: string) => {
+      // Simulate PermissionPrompter.resolveConfirmation(): prompter owns deregistration.
+      pendingInteractions.resolve(requestId);
       opts?.onConfirmation?.(requestId, decision);
     },
     handleSecretResponse: () => {},

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -389,18 +389,19 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
   const originalExtractionBatch = TEST_CONFIG.memory.extraction.batchSize;
   const originalAnalysisBatch = TEST_CONFIG.analysis.batchSize;
 
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
   beforeEach(() => {
-    // memory-v2-enabled gates v1 graph_extract enqueue; force off so
+    _setOverridesForTesting({ "auto-analyze": true });
+    // memory.v2.enabled gates v1 graph_extract enqueue; force off so
     // these cadence tests can observe the v1 path.
-    _setOverridesForTesting({
-      "auto-analyze": true,
-      "memory-v2-enabled": false,
-    });
+    TEST_CONFIG.memory.v2.enabled = false;
     TEST_CONFIG.memory.extraction.batchSize = 2;
     TEST_CONFIG.analysis.batchSize = 5;
   });
 
   afterEach(() => {
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
     TEST_CONFIG.memory.extraction.batchSize = originalExtractionBatch;
     TEST_CONFIG.analysis.batchSize = originalAnalysisBatch;
   });
@@ -544,10 +545,10 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
 });
 
 // ─────────────────────────────────────────────────────────────────
-// Indexer v1/v2 mutual exclusion: when memory-v2-enabled is on AND
-// memory.v2.enabled is on, the v1 graph_extract enqueue is suppressed
-// (v2 reads from buffer.md, so v1 graph data is unread). When either
-// gate is off, v1 graph_extract fires.
+// Indexer v1/v2 mutual exclusion: when memory.v2.enabled is on, the
+// v1 graph_extract enqueue is suppressed (v2 reads from buffer.md,
+// so v1 graph data is unread). When v2 is disabled, v1 graph_extract
+// fires.
 // ─────────────────────────────────────────────────────────────────
 
 describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
@@ -564,8 +565,7 @@ describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
     TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
   });
 
-  test("v2 active (flag on + config on) → graph_extract not enqueued", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("v2 active (config on) → graph_extract not enqueued", async () => {
     TEST_CONFIG.memory.v2.enabled = true;
 
     const source = createConversation("v2-active");
@@ -574,20 +574,7 @@ describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
     expect(countJobsOfType("graph_extract", source.id)).toBe(0);
   });
 
-  test("flag off → graph_extract enqueued", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    TEST_CONFIG.memory.v2.enabled = true;
-
-    const source = createConversation("v2-flag-off");
-    await indexMessages(source.id, 2);
-
-    expect(countJobsOfType("graph_extract", source.id)).toBeGreaterThanOrEqual(
-      1,
-    );
-  });
-
-  test("config gate off (flag on) → graph_extract enqueued", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("config gate off → graph_extract enqueued", async () => {
     TEST_CONFIG.memory.v2.enabled = false;
 
     const source = createConversation("v2-config-off");

package/src/__tests__/call-constants.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { isDeniedNumber } from "../calls/call-constants.js";
+import {
+  getEndCallListenWindowMs,
+  isDeniedNumber,
+} from "../calls/call-constants.js";
 
 describe("isDeniedNumber", () => {
   // Numbers that MUST be blocked
@@ -39,3 +42,9 @@ describe("isDeniedNumber", () => {
     });
   }
 });
+
+describe("getEndCallListenWindowMs", () => {
+  test("leaves a brief response window before task-complete hangup", () => {
+    expect(getEndCallListenWindowMs()).toBe(15_000);
+  });
+});

package/src/__tests__/call-controller.test.ts

@@ -105,11 +105,13 @@ mock.module("../security/credential-key.js", () => ({
 
 let mockConsultationTimeoutMs = 90_000;
 let mockSilenceTimeoutMs = 30_000;
+let mockEndCallListenWindowMs = 0;
 
 mock.module("../calls/call-constants.js", () => ({
   getMaxCallDurationMs: () => 12 * 60 * 1000,
   getUserConsultationTimeoutMs: () => mockConsultationTimeoutMs,
   getSilenceTimeoutMs: () => mockSilenceTimeoutMs,
+  getEndCallListenWindowMs: () => mockEndCallListenWindowMs,
 }));
 
 // ── Voice session bridge mock ────────────────────────────────────────
@@ -467,6 +469,7 @@ describe("call-controller", () => {
     // Reset consultation timeout to the default (long) value
     mockConsultationTimeoutMs = 90_000;
     mockSilenceTimeoutMs = 30_000;
+    mockEndCallListenWindowMs = 0;
     // Reset TTS config to defaults so per-test mutations don't leak.
     const cfg = loadConfig();
     cfg.services.tts.provider = "elevenlabs";
@@ -755,6 +758,130 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("END_CALL waits through the listen window before completing", async () => {
+    mockEndCallListenWindowMs = 25;
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Thank you for calling, goodbye! ", "[END_CALL]"]),
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+
+    await new Promise((r) => setTimeout(r, 35));
+
+    expect(relay.endCalled).toBe(true);
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe("completed");
+    expect(updatedSession!.endedAt).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  test("delayed END_CALL completion skips side effects when session is already terminal", async () => {
+    mockEndCallListenWindowMs = 25;
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Thank you for calling, goodbye! ", "[END_CALL]"]),
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+
+    const externalEndedAt = Date.now();
+    updateCallSession(session.id, {
+      status: "completed",
+      endedAt: externalEndedAt,
+    });
+
+    await new Promise((r) => setTimeout(r, 35));
+
+    expect(relay.endCalled).toBe(false);
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe("completed");
+    expect(updatedSession!.endedAt).toBe(externalEndedAt);
+
+    controller.destroy();
+  });
+
+  test("callee speech during END_CALL listen window cancels pending completion", async () => {
+    mockEndCallListenWindowMs = 30;
+    const turnContents: string[] = [];
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        content: string;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        turnContents.push(opts.content);
+        if (turnContents.length === 1) {
+          opts.onTextDelta("Goodbye! [END_CALL]");
+        } else {
+          opts.onTextDelta("Of course. I'm still here.");
+        }
+        opts.onComplete();
+        return { turnId: `run-${turnContents.length}`, abort: () => {} };
+      },
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+    expect(relay.endCalled).toBe(false);
+
+    await controller.handleCallerUtterance("Wait, one more thing");
+    await new Promise((r) => setTimeout(r, 40));
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+    expect(turnContents).toContain("Wait, one more thing");
+    const allText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allText).toContain("I'm still here.");
+
+    controller.destroy();
+  });
+
+  test("END_CALL listen window restores in_progress after clearing pending guardian input", async () => {
+    mockEndCallListenWindowMs = 30;
+    const turnContents: string[] = [];
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        content: string;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        turnContents.push(opts.content);
+        if (turnContents.length === 1) {
+          opts.onTextDelta("Let me check. [ASK_GUARDIAN: Is this okay?]");
+        } else if (turnContents.length === 2) {
+          opts.onTextDelta("Never mind, goodbye. [END_CALL]");
+        } else {
+          opts.onTextDelta("I'm still here.");
+        }
+        opts.onComplete();
+        return { turnId: `run-${turnContents.length}`, abort: () => {} };
+      },
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Can you ask?");
+    expect(controller.getPendingConsultationQuestionId()).not.toBeNull();
+    expect(getCallSession(session.id)!.status).toBe("waiting_on_user");
+
+    await controller.handleCallerUtterance("Actually never mind");
+    expect(controller.getPendingConsultationQuestionId()).toBeNull();
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+    expect(relay.endCalled).toBe(false);
+
+    await controller.handleCallerUtterance("Wait, one more thing");
+    await new Promise((r) => setTimeout(r, 40));
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+
+    controller.destroy();
+  });
+
   // ── handleUserAnswer ──────────────────────────────────────────────
 
   test("handleUserAnswer: returns true immediately and fires LLM asynchronously", async () => {