@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/assistant-events-sse-shed.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for SSE subscriber shed-on-backpressure observability.
+ *
+ * Verifies that when `controller.desiredSize <= 0`, the SSE route invokes
+ * the injected shed reporter with the correct reason and per-subscriber
+ * context. Both shed sites are covered: the event-callback path (slow
+ * subscriber + publishes filling the queue) and the heartbeat-timer path
+ * (slow subscriber with no published events). The healthy path asserts
+ * no shed report fires.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  buildSseShedSentryContext,
+  handleSubscribeAssistantEvents,
+  type SseShedReason,
+  type SseSubscriberInstrumentation,
+} from "../runtime/routes/events-routes.js";
+
+initializeDb();
+
+function clearTables() {
+  const db = getDb();
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+interface ShedReport {
+  reason: SseShedReason;
+  events_delivered: number;
+  heartbeats_sent: number;
+  client_id: string | null;
+  interface_id: string | null;
+  conversation_key: string | null;
+  subscription_age_ms: number;
+}
+
+function makeReporterCaptor(): {
+  reports: ShedReport[];
+  reporter: (reason: SseShedReason, inst: SseSubscriberInstrumentation) => void;
+} {
+  const reports: ShedReport[] = [];
+  return {
+    reports,
+    reporter: (reason, inst) => {
+      reports.push({
+        reason,
+        events_delivered: inst.eventsDelivered,
+        heartbeats_sent: inst.heartbeatsSent,
+        client_id: inst.clientId,
+        interface_id: inst.interfaceId,
+        conversation_key: inst.conversationKey,
+        subscription_age_ms: Date.now() - inst.subscribedAtMs,
+      });
+    },
+  };
+}
+
+const SSE_HIGH_WATER_MARK = 16;
+
+describe("SSE route — backpressure shed observability", () => {
+  beforeEach(clearTables);
+
+  test("invokes shedReporter with reason=callback_backpressure when publishes saturate the queue", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-cb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Saturate the stream's bounded queue without reading from it.
+    // start() already enqueued the immediate heartbeat (queue=1), so
+    // publishing `SSE_HIGH_WATER_MARK` events triggers the shed on the
+    // final publish when desiredSize hits 0.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(hub.subscriberCount()).toBe(0);
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("callback_backpressure");
+    expect(reports[0]?.events_delivered).toBe(SSE_HIGH_WATER_MARK - 1);
+    // The initial heartbeat enqueued by start() must be counted so the
+    // reported queue depth matches what was actually pushed.
+    expect(reports[0]?.heartbeats_sent).toBe(1);
+    expect(reports[0]?.conversation_key).toBe("shed-cb-test");
+    expect(typeof reports[0]?.subscription_age_ms).toBe("number");
+
+    ac.abort();
+  });
+
+  test("invokes shedReporter with reason=heartbeat_backpressure when the heartbeat tick finds desiredSize<=0", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-hb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 20, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Fill the queue up to its limit without sending the publish that
+    // would shed via the callback path.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK - 1; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+    expect(reports.length).toBe(0);
+
+    await new Promise((r) => setTimeout(r, 60));
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("heartbeat_backpressure");
+    expect(reports[0]?.conversation_key).toBe("shed-hb-test");
+
+    ac.abort();
+  });
+
+  test("does not invoke shedReporter when a reader drains the stream", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-healthy-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 1_000, shedReporter: reporter },
+    );
+
+    const reader = stream.getReader();
+    void reader.read();
+
+    for (let i = 0; i < 32; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+      void reader.read();
+    }
+
+    expect(reports.length).toBe(0);
+
+    ac.abort();
+    void reader.cancel();
+  });
+
+  test("captures client identity in the shed instrumentation context", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-client-test" },
+        headers: {
+          "x-vellum-client-id": "client-abc",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.client_id).toBe("client-abc");
+    expect(reports[0]?.interface_id).toBe("macos");
+
+    ac.abort();
+  });
+});
+
+describe("buildSseShedSentryContext", () => {
+  const inst: SseSubscriberInstrumentation = {
+    subscribedAtMs: 1_000,
+    eventsDelivered: 7,
+    heartbeatsSent: 3,
+    clientId: "client-xyz",
+    interfaceId: "macos",
+    // Channel-backed conversation key embedding a phone number.
+    conversationKey: "asst:self:whatsapp:447123456789",
+  };
+  const elDelay = { mean_ms: 1.2, p99_ms: 3.4, max_ms: 5.6 };
+
+  test("omits conversation_key so Sentry contexts do not leak PII", () => {
+    const ctx = buildSseShedSentryContext(
+      "callback_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).not.toHaveProperty("conversation_key");
+    expect(ctx).not.toHaveProperty("conversationKey");
+    expect(JSON.stringify(ctx)).not.toContain("447123456789");
+  });
+
+  test("preserves non-PII per-subscriber and runtime fields", () => {
+    const ctx = buildSseShedSentryContext(
+      "heartbeat_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).toMatchObject({
+      reason: "heartbeat_backpressure",
+      subscription_age_ms: 1_500,
+      events_delivered: 7,
+      heartbeats_sent: 3,
+      client_id: "client-xyz",
+      interface_id: "macos",
+      event_loop_delay_mean_ms: 1.2,
+      event_loop_delay_p99_ms: 3.4,
+      event_loop_delay_max_ms: 5.6,
+    });
+  });
+});

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__/avatar-identity-sync.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
+import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for avatar/identity sync event");
+}
+
+describe("avatar and identity sync events", () => {
+  test("notify_avatar_updated emits legacy avatar event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const route = AVATAR_ROUTES.find(
+        (candidate) => candidate.operationId === "notify_avatar_updated",
+      );
+      expect(route).toBeDefined();
+
+      await route!.handler({});
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "avatar_updated",
+        "sync_changed",
+      ]);
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("identity changes emit legacy identity event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishIdentityChanged({
+        name: "Sage",
+        role: "Assistant",
+        personality: "Calm",
+        emoji: ":sparkles:",
+        home: "San Francisco",
+      });
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "identity_changed",
+        "sync_changed",
+      ]);
+      expect(received[0].message).toMatchObject({
+        type: "identity_changed",
+        name: "Sage",
+      });
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantIdentity],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+});

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Default the warm-pool gate to OPEN — these tests probe background-job
+// disk-pressure behavior, not the pre-first-message guard.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -107,11 +114,13 @@ mock.module("../memory/conversation-crud.js", () => ({
     return { id: "conv-1", ...opts };
   },
   countConversationsByScheduleJobId: mock(() => 0),
+  countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
   clearAll: mock(() => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
+  findMostRecentRetrospectiveFor: mock(() => null),
   forkConversation: mock(() => ({ id: "conv-fork" })),
   getConversationOverrideProfile: () => undefined,
   getConversationOverrideProfileFromRow: () => undefined,
@@ -126,6 +135,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => null,
   getMessageById: () => null,
   getMessages: () => [],
+  getMessagesAfter: () => [],
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getTurnTimeBounds: () => null,
   getConversation: () => null,
@@ -175,6 +185,7 @@ mock.module("../memory/jobs-store.js", () => ({
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),
   upsertDebouncedJob: mock(() => "job-debounced"),
+  upsertMemoryRetrospectiveJob: mock(() => "job-memory-retrospective"),
 }));
 
 const mockMaybeRunDbMaintenance = mock(() => {});
@@ -187,7 +198,6 @@ mock.module("../memory/cleanup-schedule-state.js", () => ({
   markScheduledCleanupEnqueued: mock(() => {}),
 }));
 
-const { startFeedScheduler } = await import("../home/feed-scheduler.js");
 const { runMemoryJobsOnce } = await import("../memory/jobs-worker.js");
 const { FilingService } = await import("../filing/filing-service.js");
 const { WorkspaceHeartbeatService } =
@@ -202,27 +212,6 @@ describe("background workers disk pressure gate", () => {
     mockMaybeRunDbMaintenance.mockClear();
   });
 
-  test("home feed scheduler skips producers while locked", async () => {
-    const gmailDigestRunner = mock(async () => null);
-    const rollupRunner = mock(async () => ({
-      wroteCount: 1,
-      skippedReason: "empty_items" as const,
-    }));
-    const handle = startFeedScheduler({
-      runOnStart: false,
-      gmailCountSource: async () => 0,
-      gmailDigestRunner,
-      rollupRunner,
-    });
-
-    const summary = await handle.runOnce(new Date("2026-05-05T12:00:00.000Z"));
-    handle.stop();
-
-    expect(summary).toEqual({ gmailDigestRan: false, rollupRan: false });
-    expect(gmailDigestRunner).not.toHaveBeenCalled();
-    expect(rollupRunner).not.toHaveBeenCalled();
-  });
-
   test("memory jobs worker skips before claiming or maintenance writes", async () => {
     const processed = await runMemoryJobsOnce({ enableScheduledCleanup: true });
 

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

@@ -320,6 +320,7 @@ describe("POST /v1/btw", () => {
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
       channelPersona: null,
       excludeBootstrap: true,
+      excludeCustomPrefix: true,
       userPersona: null,
       userSlug: null,
     });

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 () => {