@vellumai/assistant 0.12.0-dev.202609111819.3dcbf21 → 0.12.0-dev.202609111913.15f1f50

package/ARCHITECTURE.md

@@ -609,7 +609,7 @@ Every phone call connects over Twilio Media Streams: the voice webhook emits `<C
 
 Transcription mode is selected once per session in `media-stream-stt-session.ts`:
 
-- **Streaming** (default): when `calls.voice.telephonyStreaming` is enabled and the `telephony` role resolves a streaming transcriber (`resolveStreamingTranscriber({ role: "telephony" })`), inbound audio is decoded (mu-law → PCM16, resampled 8 kHz → 16 kHz) and fed to the provider's realtime adapter. Replies trigger only on utterance-boundary finals (for Deepgram, `speech_final`/`UtteranceEnd`, never mid-sentence `is_final` segments), and barge-in fires from local energy VAD, never from transcriber partials.
+- **Streaming** (default): when `calls.voice.telephonyStreaming` is enabled and the `telephony` role resolves a streaming transcriber (`resolveStreamingTranscriber({ role: "telephony" })`), inbound audio is decoded (mu-law → PCM16, resampled 8 kHz → 16 kHz) and fed to the provider's realtime adapter. Replies trigger only on utterance-boundary finals (for Deepgram, `speech_final`/`UtteranceEnd`, never mid-sentence `is_final` segments), and barge-in fires from local energy VAD, never from transcriber partials. While something is interruptible (an assistant turn in flight, thinking or speaking, or a completed turn's tail still playing from Twilio's buffer), caller speech arms the shared sustained-speech barge-in guard (`src/calls/barge-in-guard.ts`, the same accounting live voice uses: speech accumulates toward 250 ms, short gaps are tolerated, a run that is mostly silence resets) and every inbound frame feeds it; outside that window the guard is dropped, so the caller's own utterance never carries into a turn that starts before the local VAD ends it. Only a fired guard reaches `CallController.handleBargeIn`, which interrupts a turn in either phase and ignores an idle controller (the playing tail is cleared instead).
 - **Batch fallback**: otherwise the session segments turns with the energy-based `MediaTurnDetector` and transcribes each completed turn via the same role's batch API. Both halves of a call read the `telephony` role, which is why a role names its consumer rather than a boundary.
 
 Every phone turn runs the same two-leg triage as live voice through `startVoiceTurn` (`src/calls/voice-session-bridge.ts`): `call-controller.ts` opens on a toolless front-door leg (`routingLeg: "front-door"`, the `voiceFrontDoor` call site) and drives it through the shared `createFrontDoorLegCoordinator` (`src/calls/voice-leg-coordinator.ts`), which reads the stream through the verdict machine and sequences the hand-off (pause narration, abort the leg, resolve and speak the bridge, mark it as the floor holder, start the escalated leg pinned to the conversation's own model, re-arm narration); each driver supplies only a host for how text and the bridge are spoken, how a leg is started or aborted, and (live voice only) the speculative hold and commit. Phone has no partial transcripts, so the hold verdict is never taught and routing is escalate-only. The controller also passes the bridge's turn callbacks (tool activity is recorded as `tool_use_started` / `tool_use_completed` call events, persisted row ids ride the `assistant_spoke` event), `launchedAtMs` for dispatch timing, and a `voiceTelemetry` bag keyed by the call session with a `phone_inbound` / `phone_outbound` entry. Both drivers share the spoken progress narration cadence (`src/calls/voice-progress-cadence.ts`, tuned by `voice.frontModel.progress`): the cadence owns the tool-activity log, the triggers (an ops burst, a long operation completing, a full interval of audible silence with news, the `maxSilenceMs` heartbeat) and the generated or static phrase, while each driver supplies its own view of audible silence (live voice from its TTS queue and playback-tail estimate; the media-stream transport from `isPlaybackIdle()` and a running sum of sent frame durations) and how to speak a phrase.

package/openapi.yaml

@@ -596,6 +596,16 @@ paths:
                     type: string
                   agent:
                     type: string
+                  requestedModel:
+                    anyOf:
+                      - type: string
+                      - type: "null"
+                    description: The model explicitly requested for this spawn, if any.
+                  effectiveModel:
+                    anyOf:
+                      - type: string
+                      - type: "null"
+                    description: The top-level session model reported by the ACP adapter, if any.
                   modelWarning:
                     description: Why the requested model was not applied. The session is running on the agent's own model.
                     type: string
@@ -603,6 +613,8 @@ paths:
                   - acpSessionId
                   - protocolSessionId
                   - agent
+                  - requestedModel
+                  - effectiveModel
                 additionalProperties: false
   /v1/activation/dismiss:
     post:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.0-dev.202609111819.3dcbf21",
+  "version": "0.12.0-dev.202609111913.15f1f50",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -26,7 +26,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 with recall occupying the existing slot", async () => {
+  test("should be exactly 14 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = getAllToolDefinitions();
 
@@ -48,10 +48,11 @@ describe("always-loaded tool count", () => {
     // connected — without a human in the loop, the guardian auto-approve
     // path would allow unchecked host command execution.
     //
-    // `watch_retro_report` is here for the same reason the ui_surface tools are
-    // NOT: a watch retrospective runs clientless, so it can only report through
-    // a tool that survives this baseline. Its description and schema are kept
-    // deliberately terse because that is the cost of the slot.
+    // `watch_retro_report` survives this baseline for the same reason the
+    // ui_* tools do: a watch retrospective runs clientless, so it can only
+    // report through a tool that survives this baseline. The ui_* tools are
+    // here because background UI surfaces persist and return instead of
+    // awaiting action, so they no longer need a connected client.
     const expectedNames = [
       "bash",
       "file_edit",
@@ -61,6 +62,9 @@ describe("always-loaded tool count", () => {
       "remember",
       "skill_execute",
       "skill_load",
+      "ui_dismiss",
+      "ui_show",
+      "ui_update",
       "watch_retro_report",
       "web_fetch",
       "web_search",
@@ -68,6 +72,6 @@ describe("always-loaded tool count", () => {
 
     expect(activeNames).toEqual(expectedNames);
     expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
-    expect(activeTools.length).toBe(11);
+    expect(activeTools.length).toBe(14);
   });
 });

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -21,6 +21,7 @@ import {
 function makeContext(
   sent: AssistantEvent[] = [],
   channelCapabilities?: { channel: string; supportsDynamicUi: boolean },
+  opts?: { hasNoClient?: boolean },
 ): Conversation {
   return asConversation({
     conversationId: "session-1",
@@ -37,6 +38,7 @@ function makeContext(
     accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
+    hasNoClient: opts?.hasNoClient ?? false,
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
     getQueueDepth: () => 0,
@@ -65,6 +67,71 @@ describe("task_progress surface compatibility", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test("persists a clientless choice from a non-rendering channel without waiting", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(
+      sent,
+      {
+        channel: "phone",
+        supportsDynamicUi: false,
+      },
+      { hasNoClient: true },
+    );
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "choice",
+      title: "Choose a focus",
+      data: {
+        options: [
+          { id: "inbox", title: "Inbox" },
+          { id: "calendar", title: "Calendar" },
+        ],
+      },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+    const { surfaceId } = JSON.parse(result.content) as { surfaceId: string };
+    expect(ctx.currentTurnSurfaces.some((s) => s.surfaceId === surfaceId)).toBe(
+      true,
+    );
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+    expect(sent.some((msg) => msg.type === "ui_surface_show")).toBe(true);
+  });
+
+  test("persists a clientless update in the current-turn surface snapshot", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(
+      sent,
+      {
+        channel: "phone",
+        supportsDynamicUi: false,
+      },
+      { hasNoClient: true },
+    );
+    const shown = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Background work",
+      data: {
+        template: "task_progress",
+        templateData: { status: "in_progress", steps: [] },
+      },
+    });
+    const { surfaceId } = JSON.parse(shown.content) as { surfaceId: string };
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: surfaceId,
+      data: { templateData: { status: "completed" } },
+    });
+
+    expect(result.isError).toBe(false);
+    const data = ctx.currentTurnSurfaces.find((s) => s.surfaceId === surfaceId)
+      ?.data as CardSurfaceData;
+    expect((data.templateData as Record<string, unknown>).status).toBe(
+      "completed",
+    );
+  });
+
   test("blocks ui_update when channel lacks dynamic UI support", async () => {
     const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent, {

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

@@ -249,14 +249,19 @@ describe("createResolveToolsCallback — toolContextPin", () => {
     });
   }
 
-  test("control: without a pin, a clientless fork drops every client-gated tool from the wire", () => {
+  test("control: without a pin, a clientless fork drops every client-gated tool but ui_show", () => {
     projectedSkillToolNames = [];
     const resolve = createResolveToolsCallback(
       CLIENT_GATED_DEFS,
       clientlessExecutionCtx(),
     )!;
 
-    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
+    // ui_show stays on the wire: background UI surfaces persist and return
+    // instead of awaiting action, so they no longer need a connected client.
+    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual([
+      "remember",
+      "ui_show",
+    ]);
   });
 
   test("a desktop-source pin restores the host/UI/client tool defs on the wire", () => {
@@ -291,7 +296,11 @@ describe("createResolveToolsCallback — toolContextPin", () => {
       }),
     )!;
 
-    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual(["remember"]);
+    // ui_show survives the clientless pin: it persists and returns.
+    expect(resolve(EMPTY_HISTORY).map((t) => t.name)).toEqual([
+      "remember",
+      "ui_show",
+    ]);
   });
 
   test("invariant: a pinned-in tool is on the wire but can never execute", async () => {

package/src/__tests__/watch-retro-tool-availability.test.ts

@@ -1,13 +1,10 @@
 /**
  * The gate that decides whether a watch retrospective can report at all.
  *
- * A retrospective runs as a `clientless` wake, which pins the turn
- * non-interactive. `conversation-tool-setup` gates the whole `ui_surface`
- * family on a client being present, so in that turn `ui_show` is not denied,
- * it is absent: a retrospective told to call it can only tell the user it
- * cannot. Nothing about the card's schema, its renderer, or the prompt's
- * wording reveals that, which is why it is asserted here against the real
- * registry rather than assumed anywhere else.
+ * A retrospective runs as a `clientless` wake, but its report continues to
+ * use the post-turn renderer so the report lands after its tool call has been
+ * persisted. The core UI tools remain available on that turn for other
+ * background work, so this file pins both contracts against the real registry.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -54,20 +51,14 @@ describe("watch retrospective tool availability", () => {
     ).toBe(true);
   });
 
-  test("ui_show is absent from a clientless turn", async () => {
+  test("core UI tools stay available on a clientless turn", async () => {
     await initializeTools();
     const ctx = clientlessContext();
 
-    // The reason the report does not go through `ui_show`. If this ever flips
-    // to true, the extra tool above can be reconsidered; while it is false,
-    // routing the retrospective's card through `ui_show` produces a turn that
-    // cannot report at all.
-    expect(isToolActiveForContext("ui_show", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_update", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_dismiss", ctx)).toBe(false);
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(isToolActiveForContext(name, ctx)).toBe(true);
+    }
 
-    // And the gate really is about the client, not about the tools being
-    // unregistered: with one attached, the same names are active.
     const withClient = clientfulContext();
     expect(isToolActiveForContext("ui_show", withClient)).toBe(true);
   });

package/src/acp/__tests__/session-manager.test.ts

@@ -246,22 +246,27 @@ describe("AcpSessionManager: model selection at spawn", () => {
   }): Promise<{
     state: AcpSessionState;
     sent: AssistantEvent[];
+    requestedModel?: string;
+    effectiveModel?: string;
     modelWarning?: string;
   }> {
     const manager = new AcpSessionManager(5);
     const sent: AssistantEvent[] = [];
-    const { acpSessionId, modelWarning } = await manager.spawn(
-      opts.agentId ?? "agent-model",
-      { command: "echo", args: ["hi"], model: opts.agentModel },
-      "task",
-      "/tmp",
-      opts.conversationId,
-      (msg) => sent.push(msg),
-      opts.requestedModel ? { model: opts.requestedModel } : {},
-    );
+    const { acpSessionId, requestedModel, effectiveModel, modelWarning } =
+      await manager.spawn(
+        opts.agentId ?? "agent-model",
+        { command: "echo", args: ["hi"], model: opts.agentModel },
+        "task",
+        "/tmp",
+        opts.conversationId,
+        (msg) => sent.push(msg),
+        opts.requestedModel ? { model: opts.requestedModel } : {},
+      );
     return {
       state: manager.getStatus(acpSessionId) as AcpSessionState,
       sent,
+      requestedModel,
+      effectiveModel,
       modelWarning,
     };
   }
@@ -274,15 +279,36 @@ describe("AcpSessionManager: model selection at spawn", () => {
   test("state carries the model and options the adapter reported", async () => {
     scriptedConfigOptions = [[modelOption("opus")]];
 
-    const { state } = await spawnWithModel({ conversationId: "conv-report" });
+    const { effectiveModel, state } = await spawnWithModel({
+      conversationId: "conv-report",
+    });
 
     expect(state.model).toBe("opus");
+    expect(effectiveModel).toBe("opus");
     expect(state.availableModels).toEqual(MODEL_OPTION_MODELS);
     // Nothing was requested and the adapter is already on a model, so it was
     // never asked to change.
     expect(setConfigOptionCalls).toEqual([]);
   });
 
+  test("the spawn result owns requested-model normalization", async () => {
+    scriptedConfigOptions = [[modelOption("default")]];
+
+    const manager = new AcpSessionManager(5);
+    const result = await manager.spawn(
+      "agent-model",
+      { command: "echo", args: ["hi"] },
+      "task",
+      "/tmp",
+      "conv-normalized-request",
+      () => {},
+      { model: "  opus  " },
+    );
+
+    expect(result.requestedModel).toBe("opus");
+    expect(selectedValue()).toBe("opus");
+  });
+
   test("the model event follows the spawned event", async () => {
     scriptedConfigOptions = [[modelOption("opus")]];
 
@@ -372,12 +398,13 @@ describe("AcpSessionManager: model selection at spawn", () => {
     // The adapter resolves the alias it was handed to a full model id.
     setConfigOptionResult = [modelOption("claude-opus-4-5")];
 
-    const { state } = await spawnWithModel({
+    const { effectiveModel, state } = await spawnWithModel({
       conversationId: "conv-pin",
       requestedModel: "opus",
     });
 
     expect(state.model).toBe("claude-opus-4-5");
+    expect(effectiveModel).toBe("claude-opus-4-5");
   });
 
   test("an inherited model the adapter refuses warns nobody", async () => {
@@ -417,6 +444,7 @@ describe("AcpSessionManager: model selection at spawn", () => {
     expect(result.modelWarning).toBe(
       "Invalid value for config option model: nope",
     );
+    expect(result.effectiveModel).toBe("opus");
     const state = manager.getStatus(result.acpSessionId) as AcpSessionState;
     // The run is live on whatever the adapter chose for itself.
     expect(state.status).toBe("running");

package/src/acp/session-manager.ts

@@ -284,9 +284,11 @@ export class AcpSessionManager {
    * The prompt is fired in the background — results stream via sessionUpdate
    * callbacks and completion/error messages are sent when the prompt finishes.
    *
+   * `requestedModel` is the normalized explicit request this spawn acted on.
+   * `effectiveModel` is the model the adapter reports for the live session.
    * `modelWarning` comes back when the adapter refused the model the session
-   * was asked for: the run is live on the adapter's own default, and the
-   * caller relays the reason rather than treating the spawn as failed.
+   * was asked for: the caller relays the reason rather than treating the spawn
+   * as failed.
    */
   async spawn(
     agentId: string,
@@ -300,6 +302,8 @@ export class AcpSessionManager {
   ): Promise<{
     acpSessionId: string;
     protocolSessionId: string;
+    requestedModel?: string;
+    effectiveModel?: string;
     modelWarning?: string;
   }> {
     this.assertCapacity();
@@ -429,6 +433,8 @@ export class AcpSessionManager {
     return {
       acpSessionId,
       protocolSessionId: state.acpSessionId,
+      requestedModel,
+      effectiveModel: state.model,
       ...(modelWarning ? { modelWarning } : {}),
     };
   }

package/src/calls/__tests__/barge-in-guard.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  BARGE_IN_GAP_TOLERANCE_MS,
+  BARGE_IN_MAX_TOLERATED_SILENCE_RATIO,
+  createBargeInGuard,
+} from "../barge-in-guard.js";
+
+describe("createBargeInGuard", () => {
+  test("speech shorter than the threshold stays pending", () => {
+    const guard = createBargeInGuard(250);
+    expect(guard.track("speech", 100)).toBe("pending");
+    expect(guard.track("speech", 100)).toBe("pending");
+    expect(guard.speechMs).toBe(200);
+  });
+
+  test("sustained speech reaching the threshold fires once and stays fired", () => {
+    const guard = createBargeInGuard(250);
+    guard.track("speech", 200);
+    expect(guard.track("speech", 50)).toBe("fired");
+    expect(guard.track("silence", 1_000)).toBe("fired");
+  });
+
+  test("a brief sub-threshold gap does not reset the run", () => {
+    const guard = createBargeInGuard(250);
+    guard.track("speech", 150);
+    expect(guard.track("silence", 100)).toBe("pending");
+    expect(guard.speechMs).toBe(150);
+    expect(guard.track("speech", 100)).toBe("fired");
+  });
+
+  test("a gap of exactly the tolerance is still inside the run", () => {
+    const guard = createBargeInGuard(250);
+    guard.track("speech", 150);
+    expect(guard.track("silence", BARGE_IN_GAP_TOLERANCE_MS)).toBe("pending");
+    expect(guard.speechMs).toBe(150);
+  });
+
+  test("a gap longer than the tolerance resets the run", () => {
+    const guard = createBargeInGuard(250);
+    guard.track("speech", 150);
+    guard.track("silence", 150);
+    expect(guard.track("silence", 100)).toBe("reset");
+    expect(guard.speechMs).toBe(0);
+    expect(guard.track("speech", 200)).toBe("pending");
+  });
+
+  test("sparse periodic blips separated by boundary gaps never accumulate", () => {
+    const guard = createBargeInGuard(250);
+    // 10 ms blips every 200 ms: each gap is tolerated on its own, but the
+    // run's total silence outweighs the speech by the duty-cycle ceiling.
+    const cap = 250 * BARGE_IN_MAX_TOLERATED_SILENCE_RATIO;
+    let steps = 0;
+    let sawReset = false;
+    while (steps < 60) {
+      guard.track("speech", 10);
+      if (guard.track("silence", 200) === "reset") {
+        sawReset = true;
+        break;
+      }
+      steps += 1;
+    }
+    expect(sawReset).toBe(true);
+    expect(steps * 200).toBeLessThanOrEqual(cap + 200);
+    expect(guard.speechMs).toBe(0);
+  });
+
+  test("classified echo resets a partial run immediately", () => {
+    const guard = createBargeInGuard(250);
+    guard.track("speech", 200);
+    expect(guard.track("echo", 10)).toBe("reset");
+    expect(guard.speechMs).toBe(0);
+  });
+
+  test("a zero threshold fires on the first speech chunk", () => {
+    const guard = createBargeInGuard(0);
+    // With no speech required, any silence already outweighs it.
+    expect(guard.track("silence", 20)).toBe("reset");
+    expect(guard.track("speech", 20)).toBe("fired");
+  });
+});

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

@@ -3101,7 +3101,7 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
-  test("synthesized provider: stays 'processing' during synthesis latency, so barge-in cannot abort an inaudible turn", async () => {
+  test("synthesized provider: stays 'processing' during synthesis latency until the play URL is sent", async () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "fish-audio";
     cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-123";
@@ -3142,11 +3142,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` — a barge-in here would abort a turn the caller
-    // cannot hear. See JARVIS-1232.
+    // 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.
     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?.();
@@ -4665,10 +4665,11 @@ describe("call-controller", () => {
       controller.destroy();
     });
 
-    test("handleBargeIn returns false and does not abort while still processing (no output yet)", async () => {
+    test("handleBargeIn accepts a barge-in while still processing and aborts the silent turn", async () => {
       // Simulate a turn stuck waiting for the processing lock: no tokens
-      // emitted, no completion. The controller must stay in `processing` and
-      // NOT flip to `speaking`, so barge-in can't abort a silent turn.
+      // 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.
       mockStartVoiceTurn.mockImplementation(
         async (opts: {
           onTextDelta: (t: string) => void;
@@ -4693,18 +4694,17 @@ describe("call-controller", () => {
 
       const onAccepted = mock(() => {});
       const bargeResult = controller.handleBargeIn(onAccepted);
-      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");
+      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");
       const endTokens = relay.sentTokens.filter(
         (t) => t.last === true && t.token === "",
       );
       expect(endTokens.length).toBe(0);
 
-      // Cleanup: abort the pending turn
-      controller.destroy();
       await turnPromise.catch(() => {});
+      controller.destroy();
     });
 
     test("stays in processing until first token, then flips to speaking and barge-in is accepted", async () => {
@@ -4746,9 +4746,7 @@ describe("call-controller", () => {
         await Promise.resolve();
       }
 
-      // Before any token: processing, barge-in ignored (turn not aborted).
-      expect(controller.getState()).toBe("processing");
-      expect(controller.handleBargeIn()).toBe(false);
+      // Before any token: processing (no audio out yet).
       expect(controller.getState()).toBe("processing");
 
       // Release the first token → controller flips to speaking.
@@ -4766,7 +4764,7 @@ describe("call-controller", () => {
       await turnPromise.catch(() => {});
     });
 
-    test("buffering transport (media-stream): streamed tokens do not flip to speaking; barge-in is rejected and the turn still delivers", async () => {
+    test("buffering transport (media-stream): streamed tokens do not flip to speaking; a barge-in still cuts the thinking turn off", 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
@@ -4810,17 +4808,17 @@ describe("call-controller", () => {
       expect(controller.getState()).toBe("processing");
       expect(audioStartCallback).not.toBeNull();
 
-      // VAD speech-start mid-generation → barge-in rejected, turn intact.
-      expect(controller.handleBargeIn()).toBe(false);
-      expect(controller.getState()).toBe("processing");
+      // 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");
 
-      // The turn completes and delivers its end-of-turn signal.
-      releaseTurn();
-      await turnPromise;
+      await turnPromise.catch(() => {});
+      // No end-of-turn token: nothing had been spoken.
       const endTokens = relay.sentTokens.filter(
         (t) => t.last === true && t.token === "",
       );
-      expect(endTokens.length).toBe(1);
+      expect(endTokens.length).toBe(0);
 
       controller.destroy();
     });