@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/{calls/__tests__ → __tests__}/call-controller.test.ts

@@ -8,17 +8,17 @@ import {
   test,
 } from "bun:test";
 
-mock.module("../../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 // Guardian requests/deliveries are created through the gateway client; serve
 // that surface from the in-memory sim so dispatch never opens IPC.
 import {
   bridgeState,
   gatewayGuardianRequestsStoreBridge,
-} from "../../__tests__/helpers/gateway-guardian-requests-store-bridge.js";
+} from "./helpers/gateway-guardian-requests-store-bridge.js";
 
 mock.module(
-  "../../channels/gateway-guardian-requests.js",
+  "../channels/gateway-guardian-requests.js",
   () => gatewayGuardianRequestsStoreBridge,
 );
 
@@ -36,7 +36,7 @@ mock.module(
 let mockResolvableProviderKeys: ((service: string) => string | null) | null =
   null;
 
-mock.module("../../security/secure-keys.js", () => ({
+mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async () => null,
   getSecureKey: () => null,
   getProviderKeyAsync: async (service: string) =>
@@ -45,19 +45,7 @@ mock.module("../../security/secure-keys.js", () => ({
       : "test-key",
 }));
 
-// Managed-speech defaulting reaches the platform client and the credential
-// store. The controller tests drive the bridge mock on a microtask budget, so
-// the configured providers stand as the effective ones here.
-mock.module("../../config/managed-speech-defaults.js", () => ({
-  resolveEffectiveSpeechProviders: async (config?: {
-    services: { stt: { provider: string }; tts: { provider: string } };
-  }) => {
-    const services = (config ?? loadConfig()).services;
-    return { stt: services.stt.provider, tts: services.tts.provider };
-  },
-}));
-
-mock.module("../../security/credential-key.js", () => ({
+mock.module("../security/credential-key.js", () => ({
   credentialKey: (...args: string[]) => args.join("/"),
 }));
 
@@ -68,10 +56,7 @@ let mockSilenceTimeoutMs = 30_000;
 let mockEndCallListenWindowMs = 0;
 let mockEndCallDrainMaxWaitMs = 15_000;
 
-import * as realCallConstants from "../call-constants.js";
-
-mock.module("../call-constants.js", () => ({
-  ...realCallConstants,
+mock.module("../calls/call-constants.js", () => ({
   getMaxCallDurationMs: () => 12 * 60 * 1000,
   getUserConsultationTimeoutMs: () => mockConsultationTimeoutMs,
   getSilenceTimeoutMs: () => mockSilenceTimeoutMs,
@@ -125,7 +110,7 @@ let mockStartVoiceTurn: Mock<any>;
 
 // ── Notification pipeline mock (prevent async handle leaks from fire-and-forget dispatches) ──
 
-mock.module("../../notifications/emit-signal.js", () => ({
+mock.module("../notifications/emit-signal.js", () => ({
   emitNotificationSignal: async () => ({
     signalId: "mock-signal",
     deduplicated: false,
@@ -137,7 +122,7 @@ mock.module("../../notifications/emit-signal.js", () => ({
 
 // Guardian principalId is resolved from the gateway binding reader. Mirror the
 // vellum binding seeded by resetTables so guardian dispatch can resolve it.
-mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
   getGuardianDelivery: async () => [
     {
       channelType: "vellum",
@@ -154,7 +139,7 @@ mock.module("../../contacts/guardian-delivery-reader.js", () => ({
   anyGuardian: (list: unknown[]) => list[0],
 }));
 
-mock.module("../voice-session-bridge.js", () => {
+mock.module("../calls/voice-session-bridge.js", () => {
   mockStartVoiceTurn = mock(createMockVoiceTurn(["Hello", " there"]));
   return {
     startVoiceTurn: (...args: unknown[]) => mockStartVoiceTurn(...args),
@@ -170,8 +155,8 @@ mock.module("../voice-session-bridge.js", () => {
 import {
   _resetTtsProviderOverridesForTests,
   _setTtsProviderForTests,
-} from "../../tts/provider-catalog.js";
-import type { TtsProvider } from "../../tts/types.js";
+} from "../tts/provider-catalog.js";
+import type { TtsProvider } from "../tts/types.js";
 
 function registerTestTtsProviders(): void {
   _resetTtsProviderOverridesForTests();
@@ -221,33 +206,26 @@ registerTestTtsProviders();
 
 // ── Import source modules after all mocks are registered ────────────
 
-import { resetDbForTesting } from "../../__tests__/db-test-helpers.js";
-import { createGuardianBinding } from "../../__tests__/helpers/create-guardian-binding.js";
-import { setConfig } from "../../__tests__/helpers/set-config.js";
-import { loadConfig } from "../../config/loader.js";
-import type { VoiceProgressConfig } from "../../config/schemas/voice.js";
-import { getMessages } from "../../persistence/conversation-crud.js";
-import { getDb } from "../../persistence/db-connection.js";
-import { initializeDb } from "../../persistence/db-init.js";
-import { resetTestTables } from "../../persistence/raw-query.js";
-import { conversations } from "../../persistence/schema/index.js";
-import { CallController } from "../call-controller.js";
-import { getCallController } from "../call-state.js";
+import { CallController } from "../calls/call-controller.js";
+import { getCallController } from "../calls/call-state.js";
 import {
   createCallSession,
   getCallEvents,
   getCallSession,
   getPendingQuestion,
   updateCallSession,
-} from "../call-store.js";
-import type { CallTransport } from "../call-transport.js";
-import type { VoiceProgressNarrator } from "../progress-narration.js";
-import { resolveCallTtsProvider } from "../resolve-call-tts-provider.js";
-import {
-  ESCALATION_CONTINUATION_CONTENT,
-  FALLBACK_ESCALATION_BRIDGE,
-  FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
-} from "../voice-triage-escalate.js";
+} from "../calls/call-store.js";
+import type { CallTransport } from "../calls/call-transport.js";
+import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
+import { loadConfig } from "../config/loader.js";
+import { getMessages } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { resetTestTables } from "../persistence/raw-query.js";
+import { conversations } from "../persistence/schema/index.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // Disable memory so persisted call messages skip background indexing, and
 // seed the ingress base URL used for synthesized-audio play URLs.
@@ -267,8 +245,6 @@ afterAll(() => {
 
 interface MockTransport extends CallTransport {
   sentTokens: Array<{ token: string; last: boolean }>;
-  /** Tokens sent with the system-copy flag (no caller-language hint). */
-  systemCopyTokens: string[];
   sentPlayUrls: string[];
   endCalled: boolean;
   endReason: string | undefined;
@@ -278,7 +254,6 @@ interface MockTransport extends CallTransport {
 function createMockTransport(): MockTransport {
   const state = {
     sentTokens: [] as Array<{ token: string; last: boolean }>,
-    systemCopyTokens: [] as string[],
     sentPlayUrls: [] as string[],
     _endCalled: false,
     _endReason: undefined as string | undefined,
@@ -289,9 +264,6 @@ function createMockTransport(): MockTransport {
     get sentTokens() {
       return state.sentTokens;
     },
-    get systemCopyTokens() {
-      return state.systemCopyTokens;
-    },
     get sentPlayUrls() {
       return state.sentPlayUrls;
     },
@@ -304,15 +276,8 @@ function createMockTransport(): MockTransport {
     get cancelPendingSpeechCount() {
       return state._cancelPendingSpeechCount;
     },
-    sendTextToken(
-      token: string,
-      last: boolean,
-      opts?: { systemCopy?: boolean },
-    ) {
+    sendTextToken(token: string, last: boolean) {
       state.sentTokens.push({ token, last });
-      if (opts?.systemCopy === true) {
-        state.systemCopyTokens.push(token);
-      }
     },
     sendPlayUrl(url: string) {
       state.sentPlayUrls.push(url);
@@ -407,16 +372,13 @@ function setupController(
   task?: string,
   opts?: {
     assistantId?: string;
-    trustContext?: import("../../daemon/trust-context-types.js").TrustContext;
+    trustContext?: import("../daemon/trust-context-types.js").TrustContext;
     /** Simulate the media-stream transport's PCM requirement. */
     requiresPcmAudio?: boolean;
     /** Simulate a transport that gates teardown on playback drain. */
     awaitPlaybackDrained?: () => Promise<void>;
     /** Synthesis-language resolver, as the media-stream server wires it. */
     resolveSynthesisLanguage?: () => string | undefined;
-    /** Progress narration seam; an explicit null keeps the call silent. */
-    progressNarrator?: VoiceProgressNarrator | null;
-    progressConfig?: VoiceProgressConfig;
   },
 ) {
   ensureConversation("conv-ctrl-test");
@@ -441,11 +403,6 @@ function setupController(
     assistantId: opts?.assistantId,
     trustContext: opts?.trustContext,
     resolveSynthesisLanguage: opts?.resolveSynthesisLanguage,
-    // Tests that do not exercise narration keep the default narrator out of
-    // the way: a null narrator never generates or speaks.
-    progressNarrator:
-      opts?.progressNarrator === undefined ? null : opts.progressNarrator,
-    progressConfig: opts?.progressConfig,
   });
   return { session, relay: transport, controller };
 }
@@ -549,6 +506,35 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("handleCallerUtterance: includes speaker context in voice turn content", async () => {
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        content: string;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        expect(opts.content).toContain(
+          '[SPEAKER id="speaker-1" label="Aaron" source="provider" confidence="0.91"]',
+        );
+        expect(opts.content).toContain("Can you summarize this meeting?");
+        opts.onTextDelta("Sure, here is a summary.");
+        opts.onComplete();
+        return { turnId: "run-1", abort: () => {} };
+      },
+    );
+
+    const { controller } = setupController();
+
+    await controller.handleCallerUtterance("Can you summarize this meeting?", {
+      speakerId: "speaker-1",
+      speakerLabel: "Aaron",
+      speakerConfidence: 0.91,
+      source: "provider",
+    });
+
+    controller.destroy();
+  });
+
   test("startInitialGreeting: sends CALL_OPENING content and strips control marker from speech", async () => {
     let turnCount = 0;
     mockStartVoiceTurn.mockImplementation(
@@ -2301,7 +2287,7 @@ describe("call-controller", () => {
 
     // Compute expected digest independently using the same utility
     const { computeToolApprovalDigest } =
-      await import("../../security/tool-approval-digest.js");
+      await import("../security/tool-approval-digest.js");
     const expectedDigest = computeToolApprovalDigest("send_email", {
       subject: "Hello",
       to: "bob@example.com",
@@ -3101,7 +3087,7 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
-  test("synthesized provider: stays 'processing' during synthesis latency until the play URL is sent", async () => {
+  test("synthesized provider: stays 'processing' during synthesis latency, so barge-in cannot abort an inaudible turn", async () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "fish-audio";
     cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-123";
@@ -3142,11 +3128,11 @@ describe("call-controller", () => {
     await new Promise((r) => setTimeout(r, 20));
 
     // No audio has reached the caller yet (play URL not sent), so the controller
-    // must stay in `processing`: the state tells the transport nothing is
-    // audible, and only sustained caller speech (the transport's guard) may
-    // cut the inaudible turn off. See JARVIS-1232.
+    // must stay in `processing` — a barge-in here would abort a turn the caller
+    // cannot hear. See JARVIS-1232.
     expect(relay.sentPlayUrls.length).toBe(0);
     expect(controller.getState()).toBe("processing");
+    expect(controller.handleBargeIn()).toBe(false);
 
     // Release audio → play URL sent → turn finishes and returns to idle.
     releaseChunk?.();
@@ -3418,7 +3404,7 @@ describe("call-controller", () => {
   function registerFishAudioSegmentRecorder(opts?: {
     onSynthesizeStream?: (
       text: string,
-      request: import("../../tts/types.js").TtsSynthesisRequest,
+      request: import("../tts/types.js").TtsSynthesisRequest,
       onChunk: (chunk: Buffer) => void,
     ) => Promise<void>;
   }): { synthesizedTexts: string[] } {
@@ -4234,415 +4220,6 @@ describe("call-controller", () => {
     });
   });
 
-  // ── Triage-and-escalate routing ─────────────────────────────────────
-
-  describe("triage-and-escalate routing", () => {
-    interface LegOpts {
-      content: string;
-      routingLeg?: string;
-      spokenEscalationBridge?: string;
-      launchedAtMs?: number;
-      voiceTelemetry?: { sessionId: string; entry?: string };
-      callbacks?: {
-        persisted_user_message_id?: (id: string) => void;
-        persisted_assistant_message_id?: (id: string) => void;
-        tool_use_start?: (
-          toolName: string,
-          detail?: { toolUseId?: string },
-        ) => void;
-        tool_result?: (event: {
-          toolName: string;
-          toolUseId?: string;
-          isError?: boolean;
-          resultPreview: string;
-        }) => void;
-      };
-      onTextDelta: (t: string) => void;
-      onComplete: () => void;
-      signal?: AbortSignal;
-    }
-
-    /**
-     * Script the bridge one leg per call: the front-door leg's tokens first,
-     * then the escalated leg's. Records every call's options and which legs
-     * the controller aborted.
-     */
-    function scriptLegs(
-      legs: string[][],
-      beforeComplete?: (opts: LegOpts, index: number) => void,
-    ) {
-      const calls: LegOpts[] = [];
-      const aborted: number[] = [];
-      mockStartVoiceTurn.mockImplementation(async (opts: LegOpts) => {
-        const index = calls.length;
-        calls.push(opts);
-        for (const token of legs[index] ?? []) {
-          opts.onTextDelta(token);
-        }
-        beforeComplete?.(opts, index);
-        opts.onComplete();
-        return { turnId: `run-${index}`, abort: () => aborted.push(index) };
-      });
-      return { calls, aborted };
-    }
-
-    function spokenText(relay: MockTransport): string {
-      return relay.sentTokens
-        .filter((t) => !t.last)
-        .map((t) => t.token)
-        .join("");
-    }
-
-    function assistantSpokePayload(sessionId: string): Record<string, unknown> {
-      const spoke = getCallEvents(sessionId).filter(
-        (e) => e.eventType === "assistant_spoke",
-      );
-      expect(spoke.length).toBe(1);
-      return JSON.parse(spoke[0].payloadJson) as Record<string, unknown>;
-    }
-
-    test("a front-door answer runs one leg and is spoken verbatim", async () => {
-      const { calls, aborted } = scriptLegs([["Hello", " there."]]);
-      const { session, relay, controller } = setupController();
-
-      await controller.handleCallerUtterance("Hi");
-
-      expect(calls.length).toBe(1);
-      expect(calls[0].routingLeg).toBe("front-door");
-      expect(calls[0].content).toBe("Hi");
-      expect(calls[0].spokenEscalationBridge).toBeUndefined();
-      expect(aborted).toEqual([]);
-      expect(spokenText(relay)).toContain("Hello there.");
-      expect(assistantSpokePayload(session.id).text).toBe("Hello there.");
-
-      controller.destroy();
-    });
-
-    test("an escalate verdict speaks the holding phrase, aborts the front-door leg, and continues on the escalated leg", async () => {
-      const { calls, aborted } = scriptLegs([
-        // The verdict token may arrive split across deltas; the leading
-        // "[" is held until it classifies.
-        ["[", "1] Let me check", " that.", " Ignored past the cap."],
-        ["The answer is 42."],
-      ]);
-      const { session, relay, controller } = setupController();
-
-      await controller.handleCallerUtterance("What is six times seven?");
-
-      expect(calls.length).toBe(2);
-      expect(calls[0].routingLeg).toBe("front-door");
-      expect(calls[1].routingLeg).toBe("escalated");
-      expect(calls[1].content).toBe(ESCALATION_CONTINUATION_CONTENT);
-      expect(calls[1].spokenEscalationBridge).toBe("Let me check that.");
-      expect(aborted).toEqual([0]);
-
-      const spoken = spokenText(relay);
-      expect(spoken).toContain("Let me check that.");
-      expect(spoken).toContain("The answer is 42.");
-      expect(spoken.indexOf("Let me check that.")).toBeLessThan(
-        spoken.indexOf("The answer is 42."),
-      );
-      expect(spoken).not.toContain("[1]");
-      expect(spoken).not.toContain("Ignored past the cap.");
-      expect(assistantSpokePayload(session.id).text).toBe(
-        "Let me check that. The answer is 42.",
-      );
-      // One end-of-turn signal for the whole turn, after the escalated leg.
-      expect(relay.sentTokens.filter((t) => t.last).length).toBe(1);
-
-      controller.destroy();
-    });
-
-    test("a bare escalate verdict speaks the canned bridge, audio-only", async () => {
-      const { calls } = scriptLegs([["[1]"], ["Forty-two."]]);
-      const { session, relay, controller } = setupController();
-
-      await controller.handleCallerUtterance("What is six times seven?");
-
-      expect(calls.length).toBe(2);
-      expect(calls[1].spokenEscalationBridge).toBe(FALLBACK_ESCALATION_BRIDGE);
-      expect(spokenText(relay)).toContain(FALLBACK_ESCALATION_BRIDGE);
-      // The canned bridge is not the model's speech: the turn's text (and the
-      // transcript row the bridge keeps) carry only the escalated answer.
-      expect(assistantSpokePayload(session.id).text).toBe("Forty-two.");
-
-      controller.destroy();
-    });
-
-    test("a leg cancelled mid-bridge never spawns the escalated leg", async () => {
-      const calls: LegOpts[] = [];
-      let releaseLeg: () => void = () => {};
-      mockStartVoiceTurn.mockImplementation(async (opts: LegOpts) => {
-        calls.push(opts);
-        opts.onTextDelta("[1] Let me");
-        await new Promise<void>((resolve) => {
-          releaseLeg = resolve;
-          opts.signal?.addEventListener("abort", () => resolve());
-        });
-        // The bridge reports a cancelled leg's completion too.
-        opts.onComplete();
-        return { turnId: "run-cancelled", abort: () => releaseLeg() };
-      });
-      const { relay, controller } = setupController();
-
-      const turnPromise = controller.handleCallerUtterance("Hi");
-      for (let i = 0; i < 10; i++) {
-        await Promise.resolve();
-      }
-      expect(calls.length).toBe(1);
-
-      controller.handleInterrupt();
-      await turnPromise;
-
-      expect(calls.length).toBe(1);
-      expect(spokenText(relay)).toBe("");
-
-      controller.destroy();
-    });
-
-    test("passes the launch time, phone telemetry, and callbacks to the bridge", async () => {
-      const before = Date.now();
-      const { calls } = scriptLegs([["Done."]], (opts) => {
-        opts.callbacks?.persisted_user_message_id?.("user-row-1");
-        opts.callbacks?.tool_use_start?.("web_search", { toolUseId: "tu-1" });
-        opts.callbacks?.tool_result?.({
-          toolName: "web_search",
-          toolUseId: "tu-1",
-          isError: false,
-          resultPreview: "three results",
-        });
-        opts.callbacks?.persisted_assistant_message_id?.("assistant-row-1");
-      });
-      const { session, controller } = setupController();
-
-      await controller.handleCallerUtterance("Look that up");
-
-      expect(calls.length).toBe(1);
-      expect(calls[0].launchedAtMs).toBeGreaterThanOrEqual(before);
-      expect(calls[0].launchedAtMs).toBeLessThanOrEqual(Date.now());
-      expect(calls[0].voiceTelemetry).toEqual({
-        sessionId: session.id,
-        entry: "phone_inbound",
-      });
-
-      const events = getCallEvents(session.id);
-      const started = events.filter((e) => e.eventType === "tool_use_started");
-      expect(started.length).toBe(1);
-      expect(JSON.parse(started[0].payloadJson)).toEqual({
-        toolName: "web_search",
-        toolUseId: "tu-1",
-      });
-      const completed = events.filter(
-        (e) => e.eventType === "tool_use_completed",
-      );
-      expect(completed.length).toBe(1);
-      expect(JSON.parse(completed[0].payloadJson)).toEqual({
-        toolName: "web_search",
-        toolUseId: "tu-1",
-        isError: false,
-        resultPreview: "three results",
-      });
-      expect(assistantSpokePayload(session.id)).toEqual({
-        text: "Done.",
-        userMessageId: "user-row-1",
-        assistantMessageId: "assistant-row-1",
-      });
-
-      controller.destroy();
-    });
-
-    test("the escalated leg's hidden continuation row is not the caller's utterance", async () => {
-      const { calls } = scriptLegs(
-        [["[1] One moment."], ["Here you go."]],
-        (opts, index) => {
-          opts.callbacks?.persisted_user_message_id?.(`user-row-${index}`);
-          opts.callbacks?.persisted_assistant_message_id?.(
-            `assistant-row-${index}`,
-          );
-        },
-      );
-      const { session, controller } = setupController();
-
-      await controller.handleCallerUtterance("Hi");
-
-      expect(calls.length).toBe(2);
-      expect(assistantSpokePayload(session.id)).toEqual({
-        text: "One moment. Here you go.",
-        userMessageId: "user-row-0",
-        assistantMessageId: "assistant-row-1",
-      });
-
-      controller.destroy();
-    });
-
-    test("native route: a canned bridge in a language the table lacks goes out as system copy", async () => {
-      scriptLegs([["[1]"], ["Forty-two."]]);
-      const { relay, controller } = setupController(undefined, {
-        resolveSynthesisLanguage: () => "ko",
-      });
-
-      await controller.handleCallerUtterance("What is six times seven?");
-
-      // The English fallback must not ride the caller's Korean hint.
-      expect(relay.systemCopyTokens).toEqual([
-        `${FALLBACK_ESCALATION_BRIDGE} `,
-      ]);
-      expect(spokenText(relay)).toContain("Forty-two.");
-
-      controller.destroy();
-    });
-
-    test("native route: a localized canned bridge rides the caller's language like model text", async () => {
-      scriptLegs([["[1]"], ["Cuarenta y dos."]]);
-      const { relay, controller } = setupController(undefined, {
-        resolveSynthesisLanguage: () => "es",
-      });
-
-      await controller.handleCallerUtterance("¿Cuánto es seis por siete?");
-
-      expect(relay.systemCopyTokens).toEqual([]);
-      expect(spokenText(relay)).toContain(
-        FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.es,
-      );
-
-      controller.destroy();
-    });
-
-    test("synthesized route: the canned bridge carries its own language hint, the answer the caller's", async () => {
-      const requests: Array<{ text: string; language: string | undefined }> =
-        [];
-      registerFishAudioSegmentRecorder({
-        onSynthesizeStream: async (text, request) => {
-          requests.push({ text, language: request.language });
-        },
-      });
-      scriptLegs([["[1]"], ["Forty-two."]]);
-      const { controller } = setupController(undefined, {
-        resolveSynthesisLanguage: () => "ko",
-      });
-
-      await controller.handleCallerUtterance("What is six times seven?");
-
-      expect(requests).toEqual([
-        { text: FALLBACK_ESCALATION_BRIDGE, language: "en" },
-        { text: "Forty-two.", language: "ko" },
-      ]);
-
-      controller.destroy();
-    });
-
-    test("progress narration speaks into the escalated leg's tool loop, audio-only", async () => {
-      const narrationConfig: VoiceProgressConfig = {
-        enabled: true,
-        opsThreshold: 1,
-        idleIntervalMs: 60_000,
-        maxSilenceMs: 60_000,
-        longOpMs: 15_000,
-        minGapMs: 10,
-        generationTimeoutMs: 1_500,
-      };
-      const narrator: VoiceProgressNarrator = {
-        generateProgressText: async (input) => {
-          expect(input.transcriptSoFar).toBe("What is on my calendar?");
-          expect(input.currentOp?.toolName).toBe("calendar_list");
-          return "Pulling up your calendar now.";
-        },
-      };
-      const { session, relay, controller } = setupController(undefined, {
-        progressNarrator: narrator,
-        progressConfig: narrationConfig,
-      });
-      const calls: LegOpts[] = [];
-      mockStartVoiceTurn.mockImplementation(async (opts: LegOpts) => {
-        const index = calls.length;
-        calls.push(opts);
-        if (index === 0) {
-          opts.onTextDelta("[1] One moment.");
-          opts.onComplete();
-          return { turnId: "run-front", abort: () => {} };
-        }
-        // The escalated leg runs a tool; narration must land while it runs.
-        // The bridge just spoken is a floor holder, so the tool starts after
-        // the (test-short) minimum gap.
-        await new Promise((r) => setTimeout(r, 25));
-        opts.callbacks?.tool_use_start?.("calendar_list", { toolUseId: "c1" });
-        await pollUntil(() =>
-          relay.sentTokens.some((t) =>
-            t.token.includes("Pulling up your calendar now."),
-          ),
-        );
-        opts.callbacks?.tool_result?.({
-          toolName: "calendar_list",
-          toolUseId: "c1",
-          resultPreview: "two events",
-        });
-        opts.onTextDelta("You have two events today.");
-        opts.onComplete();
-        return { turnId: "run-escalated", abort: () => {} };
-      });
-
-      await controller.handleCallerUtterance("What is on my calendar?");
-
-      const spoken = spokenText(relay);
-      expect(spoken.indexOf("One moment.")).toBeLessThan(
-        spoken.indexOf("Pulling up your calendar now."),
-      );
-      expect(spoken.indexOf("Pulling up your calendar now.")).toBeLessThan(
-        spoken.indexOf("You have two events today."),
-      );
-      // Narration is audio-only: the turn's recorded text is the model's.
-      expect(assistantSpokePayload(session.id).text).toBe(
-        "One moment. You have two events today.",
-      );
-
-      controller.destroy();
-    });
-
-    test("no narration without a narrator", async () => {
-      const { relay, controller } = setupController(undefined, {
-        progressNarrator: null,
-        progressConfig: {
-          enabled: true,
-          opsThreshold: 1,
-          idleIntervalMs: 60_000,
-          maxSilenceMs: 60_000,
-          longOpMs: 15_000,
-          minGapMs: 10,
-          generationTimeoutMs: 1_500,
-        },
-      });
-      scriptLegs([["Done."]], (opts) => {
-        opts.callbacks?.tool_use_start?.("web_search", { toolUseId: "t1" });
-        opts.callbacks?.tool_result?.({
-          toolName: "web_search",
-          toolUseId: "t1",
-          resultPreview: "ok",
-        });
-      });
-
-      await controller.handleCallerUtterance("Look it up");
-
-      expect(spokenText(relay)).toBe("Done.");
-
-      controller.destroy();
-    });
-
-    test("an outbound call reports the outbound entry", async () => {
-      const { calls } = scriptLegs([["Hello, this is Ava."]]);
-      const { session, controller } = setupController("Book a table for two");
-
-      await controller.startInitialGreeting();
-
-      expect(calls.length).toBe(1);
-      expect(calls[0].voiceTelemetry).toEqual({
-        sessionId: session.id,
-        entry: "phone_outbound",
-      });
-
-      controller.destroy();
-    });
-  });
-
   // ── handleBargeIn ───────────────────────────────────────────────────
 
   describe("handleBargeIn", () => {
@@ -4665,11 +4242,10 @@ describe("call-controller", () => {
       controller.destroy();
     });
 
-    test("handleBargeIn accepts a barge-in while still processing and aborts the silent turn", async () => {
+    test("handleBargeIn returns false and does not abort while still processing (no output yet)", async () => {
       // Simulate a turn stuck waiting for the processing lock: no tokens
-      // emitted, no completion. The controller stays in `processing`, and a
-      // sustained caller barge-in (the transport's guard has already
-      // vouched for it) cuts the thinking turn off before it speaks.
+      // emitted, no completion. The controller must stay in `processing` and
+      // NOT flip to `speaking`, so barge-in can't abort a silent turn.
       mockStartVoiceTurn.mockImplementation(
         async (opts: {
           onTextDelta: (t: string) => void;
@@ -4694,17 +4270,18 @@ describe("call-controller", () => {
 
       const onAccepted = mock(() => {});
       const bargeResult = controller.handleBargeIn(onAccepted);
-      expect(bargeResult).toBe(true);
-      expect(onAccepted).toHaveBeenCalledTimes(1);
-      // The turn is aborted; nothing was spoken, so no end-of-turn token.
-      expect(controller.getState()).toBe("idle");
+      expect(bargeResult).toBe(false);
+      expect(onAccepted).not.toHaveBeenCalled();
+      // Still processing (not aborted), and no interrupt/end-of-turn token sent.
+      expect(controller.getState()).toBe("processing");
       const endTokens = relay.sentTokens.filter(
         (t) => t.last === true && t.token === "",
       );
       expect(endTokens.length).toBe(0);
 
-      await turnPromise.catch(() => {});
+      // Cleanup: abort the pending turn
       controller.destroy();
+      await turnPromise.catch(() => {});
     });
 
     test("stays in processing until first token, then flips to speaking and barge-in is accepted", async () => {
@@ -4746,7 +4323,9 @@ describe("call-controller", () => {
         await Promise.resolve();
       }
 
-      // Before any token: processing (no audio out yet).
+      // Before any token: processing, barge-in ignored (turn not aborted).
+      expect(controller.getState()).toBe("processing");
+      expect(controller.handleBargeIn()).toBe(false);
       expect(controller.getState()).toBe("processing");
 
       // Release the first token → controller flips to speaking.
@@ -4764,7 +4343,7 @@ describe("call-controller", () => {
       await turnPromise.catch(() => {});
     });
 
-    test("buffering transport (media-stream): streamed tokens do not flip to speaking; a barge-in still cuts the thinking turn off", async () => {
+    test("buffering transport (media-stream): streamed tokens do not flip to speaking; barge-in is rejected and the turn still delivers", async () => {
       // Simulates the media-stream transport: sendTextToken(.., false)
       // only buffers; audio starts later. The controller must stay in
       // `processing` until the transport's audio-start signal fires, so
@@ -4808,17 +4387,17 @@ describe("call-controller", () => {
       expect(controller.getState()).toBe("processing");
       expect(audioStartCallback).not.toBeNull();
 
-      // Sustained caller speech mid-generation: the buffered, unspoken turn
-      // is cut off like a spoken one would be, and its text is discarded.
-      expect(controller.handleBargeIn()).toBe(true);
-      expect(controller.getState()).toBe("idle");
+      // VAD speech-start mid-generation → barge-in rejected, turn intact.
+      expect(controller.handleBargeIn()).toBe(false);
+      expect(controller.getState()).toBe("processing");
 
-      await turnPromise.catch(() => {});
-      // No end-of-turn token: nothing had been spoken.
+      // The turn completes and delivers its end-of-turn signal.
+      releaseTurn();
+      await turnPromise;
       const endTokens = relay.sentTokens.filter(
         (t) => t.last === true && t.token === "",
       );
-      expect(endTokens.length).toBe(0);
+      expect(endTokens.length).toBe(1);
 
       controller.destroy();
     });