@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/live-voice/__tests__/live-voice-vad.test.ts

@@ -1,14 +1,12 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeAll, describe, expect, mock, test } from "bun:test";
 
 import type { TurnDetectorConfig } from "../../calls/media-turn-detector.js";
 import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import {
-  clearCachedOverrides,
-  setCachedOverrides,
-} from "../../config/feature-flag-cache.js";
 import {
   getConfig,
   loadRawConfig,
@@ -19,12 +17,12 @@ import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import type {
-  VoiceEndpointDecisionInput,
-  VoiceFrontDecider,
-} from "../front-decision.js";
+import { __resetRegistryForTesting } from "../../tools/registry.js";
+import { getWorkspaceSkillsDir } from "../../util/platform.js";
+import type { VoiceFrontDecider } from "../front-decision.js";
 import type { LiveVoiceAudioArchiveResult } from "../live-voice-archive.js";
 import {
+  CONTINUATION_DELIVERY_CONTENT,
   createLiveVoiceSession,
   type LiveVoiceBackgroundContinuationSpawner,
   LiveVoiceSession,
@@ -44,6 +42,20 @@ import {
   type LiveVoiceServerFrame,
 } from "../protocol.js";
 
+// The closed-session delivery route writes into the parent conversation, which
+// needs a live conversation store. Stub the seam so the assertion is about
+// where the answer went, not about conversation plumbing.
+//
+// `mock.module` is process-global in Bun and leaks into sibling files that run
+// in the same process — run this file on its own (`bun test <path>`).
+const injectMessageIntoParentMock = mock(
+  (_parentConversationId: string, _message: string) => {},
+);
+mock.module("../../subagent/notify.js", () => ({
+  injectMessageIntoParent: injectMessageIntoParentMock,
+  notifyParentFromChild: mock(async () => {}),
+}));
+
 const SAMPLE_RATE = 24_000;
 
 const VAD_START_FRAME = {
@@ -154,6 +166,7 @@ function createHarness(options: {
   spawnBackgroundContinuation?: LiveVoiceBackgroundContinuationSpawner;
   getTurnTeardown?: (conversationId: string) => Promise<void> | undefined;
   detachTeardownSettleTimeoutMs?: number;
+  continuationAnnounceSilenceMs?: number;
 }) {
   const sequencer = createLiveVoiceServerFrameSequencer();
   const frames: LiveVoiceServerFrame[] = [];
@@ -217,6 +230,11 @@ function createHarness(options: {
     ...(options.detachTeardownSettleTimeoutMs !== undefined
       ? { detachTeardownSettleTimeoutMs: options.detachTeardownSettleTimeoutMs }
       : {}),
+    ...(options.continuationAnnounceSilenceMs !== undefined
+      ? {
+          continuationAnnounceSilenceMs: options.continuationAnnounceSilenceMs,
+        }
+      : {}),
   };
   const session = options.viaFactory
     ? createLiveVoiceSession(context, {
@@ -313,10 +331,79 @@ async function flushAsyncCallbacks(): Promise<void> {
   await new Promise((resolve) => setTimeout(resolve, 10));
 }
 
+/**
+ * Write a skill into the (per-process temp) workspace skills dir so the
+ * `skill_load` contention gate resolves it from the real on-disk catalog.
+ */
+function installSkillFixture(id: string, body: string): void {
+  const directory = join(getWorkspaceSkillsDir(), id);
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(
+    join(directory, "SKILL.md"),
+    `---\nname: ${id}\ndescription: Fixture skill for the contention gate\n---\n\n${body}\n`,
+  );
+}
+
+/**
+ * Barge in during thinking so the interrupted turn detaches a continuation,
+ * then hand back the follow-up turn's options plus the continuation's abort
+ * signal — the two handles every foreground-wins assertion needs. The
+ * continuation hangs until its signal aborts, so it is still in flight while
+ * the follow-up turn starts tools.
+ */
+async function startForegroundWinsScenario(): Promise<{
+  followUp: VoiceTurnOptions | undefined;
+  signal: AbortSignal | undefined;
+}> {
+  const spawnBackgroundContinuation = mock(
+    (args: {
+      parentConversationId: string;
+      objective: string;
+      label: string;
+      signal: AbortSignal;
+    }): Promise<string> =>
+      new Promise<string>((resolve) => {
+        args.signal.addEventListener("abort", () => resolve(""), {
+          once: true,
+        });
+      }),
+  );
+  const calls: VoiceTurnOptions[] = [];
+  const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+    calls.push(options);
+    return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+  });
+  const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+    options.onAudioChunk(makeTtsChunk("assistant audio"));
+    return makeTtsResult("assistant audio");
+  });
+  const { frames, session } = createHarness({
+    finals: ["first question", "second question"],
+    startVoiceTurn,
+    streamTtsAudio,
+    spawnBackgroundContinuation,
+  });
+
+  await session.start();
+  await session.handleBinaryAudio(LOUD_CHUNK);
+  await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+  await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+  await waitFor(() => spawnBackgroundContinuation.mock.calls.length === 1);
+  await waitFor(() => calls.some((c) => c.content === "second question"));
+
+  const signal = spawnBackgroundContinuation.mock.calls[0]?.[0]?.signal;
+  expect(signal?.aborted).toBe(false);
+  return {
+    followUp: calls.find((c) => c.content === "second question"),
+    signal,
+  };
+}
+
 describe("LiveVoiceSession server VAD", () => {
-  // The voice-duplex-handoff flag is toggled via the override cache in a few
-  // tests below; reset it so it never leaks into the flag-off default cases.
-  afterEach(() => clearCachedOverrides());
+  // The foreground-wins classification consults the tool registry's owner map
+  // (a tool is only provably read-only when it is the trusted built-in);
+  // register the core baseline so built-in names resolve like in the daemon.
+  beforeAll(() => __resetRegistryForTesting());
 
   test("ready echoes turnDetection server_vad", async () => {
     const { frames, session } = createHarness({});
@@ -679,8 +766,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(laterTurn?.voiceControlPrompt).not.toContain("first question");
   });
 
-  test("voice-duplex-handoff on: a thinking barge-in spawns a background continuation", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a thinking barge-in spawns a background continuation", async () => {
     const spawnBackgroundContinuation = mock(
       async (_args: {
         parentConversationId: string;
@@ -716,8 +802,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(spawnArgs?.objective).toContain("first question");
   });
 
-  test("voice-duplex-handoff on: a client interrupt aborts an in-flight continuation", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a client interrupt aborts an in-flight continuation", async () => {
     // Hang the continuation so it is still in flight when the interrupt lands;
     // resolve it when its signal aborts.
     const spawnBackgroundContinuation = mock(
@@ -758,8 +843,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(signal?.aborted).toBe(true);
   });
 
-  test("voice-duplex-handoff on: a client interrupt during barge-in cleanup skips the continuation", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a client interrupt during barge-in cleanup skips the continuation", async () => {
     const spawnBackgroundContinuation = mock(
       async (_args: {
         parentConversationId: string;
@@ -809,38 +893,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(spawnBackgroundContinuation).not.toHaveBeenCalled();
   });
 
-  test("voice-duplex-handoff off (default): a thinking barge-in spawns no continuation", async () => {
-    const spawnBackgroundContinuation = mock(
-      async (_args: {
-        parentConversationId: string;
-        objective: string;
-        label: string;
-        signal: AbortSignal;
-      }): Promise<string> => "",
-    );
-    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
-      options.onAudioChunk(makeTtsChunk("assistant audio"));
-      return makeTtsResult("assistant audio");
-    });
-    const { frames, session } = createHarness({
-      finals: ["first question", "second question"],
-      streamTtsAudio,
-      spawnBackgroundContinuation,
-    });
-
-    await session.start();
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
-    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
-    await waitFor(() =>
-      frames.some((frame) => frame.type === "turn_cancelled"),
-    );
-    await flushAsyncCallbacks();
-    expect(spawnBackgroundContinuation).not.toHaveBeenCalled();
-  });
-
-  test("voice-duplex-handoff on: no continuation when the model already completed", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("no continuation when the model already completed", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const spawnBackgroundContinuation = mock(
       async (_args: {
@@ -892,8 +945,7 @@ describe("LiveVoiceSession server VAD", () => {
     releaseTts?.();
   });
 
-  test("voice-duplex-handoff on: the continuation fork waits for the interrupted turn's teardown to settle", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("the continuation fork waits for the interrupted turn's teardown to settle", async () => {
     const spawnBackgroundContinuation = mock(
       async (_args: {
         parentConversationId: string;
@@ -941,8 +993,7 @@ describe("LiveVoiceSession server VAD", () => {
     await waitFor(() => spawnBackgroundContinuation.mock.calls.length === 1);
   });
 
-  test("voice-duplex-handoff on: the continuation is skipped when the teardown wait times out", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("the continuation is skipped when the teardown wait times out", async () => {
     const spawnBackgroundContinuation = mock(
       async (_args: {
         parentConversationId: string;
@@ -983,8 +1034,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(spawnBackgroundContinuation).not.toHaveBeenCalled();
   });
 
-  test("voice-duplex-handoff on: a client interrupt during the teardown wait skips the continuation", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a client interrupt during the teardown wait skips the continuation", async () => {
     const spawnBackgroundContinuation = mock(
       async (_args: {
         parentConversationId: string;
@@ -1048,8 +1098,21 @@ describe("LiveVoiceSession server VAD", () => {
     return { startVoiceTurn, calls };
   }
 
-  test("voice-duplex-handoff on: a completed continuation's result folds into the next turn's control prompt", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  // Records every turn's options and completes none of them, so every turn
+  // stays "thinking" and a barge-in always lands on a live one.
+  function makeNeverCompletingTurnStarter(): {
+    startVoiceTurn: LiveVoiceTurnStarter;
+    calls: VoiceTurnOptions[];
+  } {
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    return { startVoiceTurn, calls };
+  }
+
+  test("a completed continuation's result folds into the next turn's control prompt", async () => {
     // Control the continuation's resolution so we know exactly when its result
     // is stashed relative to the turns we inspect.
     let resolveContinuation: ((result: string) => void) | undefined;
@@ -1114,8 +1177,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(later?.voiceControlPrompt).not.toContain("THE_RESULT");
   });
 
-  test("voice-duplex-handoff on: a client interrupt drops a stashed continuation result", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a client interrupt drops a stashed continuation result", async () => {
     let resolveContinuation: ((result: string) => void) | undefined;
     const spawnBackgroundContinuation = mock(
       (_args: {
@@ -1163,8 +1225,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(later?.voiceControlPrompt).not.toContain("THE_RESULT");
   });
 
-  test("voice-duplex-handoff on: an empty continuation result adds no context to the next turn", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("an empty continuation result adds no context to the next turn", async () => {
     // Continuation ends with no answer text (e.g. it stopped on a tool call):
     // there is nothing to fold in.
     const spawnBackgroundContinuation = mock(
@@ -1203,8 +1264,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(later?.voiceControlPrompt).not.toContain("background you finished");
   });
 
-  test("voice-duplex-handoff on: a newer continuation's result survives an older one finishing later", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a newer continuation's result survives an older one finishing later", async () => {
     // Capture each continuation's resolver in spawn (detach) order.
     const resolvers: Array<(result: string) => void> = [];
     const spawnBackgroundContinuation = mock(
@@ -1273,8 +1333,7 @@ describe("LiveVoiceSession server VAD", () => {
     expect(resurfaced?.voiceControlPrompt).not.toContain("OLDER_RESULT");
   });
 
-  test("voice-duplex-handoff on: a rapid second barge-in invalidates a first continuation that finishes after it", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a rapid second barge-in invalidates a first continuation that finishes after it", async () => {
     const resolvers: Array<(result: string) => void> = [];
     const spawnBackgroundContinuation = mock(
       (_args: {
@@ -1325,8 +1384,13 @@ describe("LiveVoiceSession server VAD", () => {
     await waitFor(() => calls.some((c) => c.content === "second question"));
     // Barge #2 is a rapid second interruption: it bumps the sequence
     // synchronously, so A is invalidated even before barge #2's own async detach
-    // runs.
+    // runs — and A's run itself is ABORTED, so a still-writing older
+    // continuation can never overlap the newer full-ability one.
     await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () =>
+        spawnBackgroundContinuation.mock.calls[0]?.[0]?.signal.aborted === true,
+    );
     // A finishes AFTER barge #2 and must be rejected. The newer continuation is
     // left pending so it can't mask the bug by superseding A itself.
     resolvers[0]?.("OLDER_RESULT");
@@ -1342,13 +1406,16 @@ describe("LiveVoiceSession server VAD", () => {
       "background you finished",
     );
 
-    // Cleanup the still-pending newer continuation.
+    // The newer continuation was not collateral damage of superseding A.
     await waitFor(() => resolvers.length === 2);
+    expect(spawnBackgroundContinuation.mock.calls[1]?.[0]?.signal.aborted).toBe(
+      false,
+    );
+    // Cleanup the still-pending newer continuation.
     resolvers[1]?.("");
   });
 
-  test("voice-duplex-handoff on: a new barge-in drops an already-stashed continuation result", async () => {
-    setCachedOverrides({ "voice-duplex-handoff": true }, { fromGateway: true });
+  test("a new barge-in drops an already-stashed continuation result", async () => {
     const resolvers: Array<(result: string) => void> = [];
     const spawnBackgroundContinuation = mock(
       (_args: {
@@ -1415,191 +1482,1050 @@ describe("LiveVoiceSession server VAD", () => {
     resolvers[1]?.("");
   });
 
-  test("a late assistant_text_delta after a thinking barge-in never reaches the client", async () => {
-    let callbacks: VoiceTurnCallbacks | undefined;
-    const abort = mock();
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      callbacks ??= options.callbacks;
-      return { turnId: "bridge-turn", abort };
-    });
-    let releaseTurnCancelled: (() => void) | undefined;
-    const { frames, session } = createHarness({
-      finals: ["first question", "second question"],
-      startVoiceTurn,
-      // Suspend the async barge-in teardown at the turn_cancelled send so the
-      // aborted turn stays non-finalized — the exact window a late model delta
-      // could race into before cancelAssistantTurn finishes.
-      holdSendFrame: (payload) => {
-        if (payload.type !== "turn_cancelled" || releaseTurnCancelled) {
-          return null;
-        }
-        return new Promise<void>((resolve) => {
-          releaseTurnCancelled = resolve;
-        });
-      },
+  test("a foreground consequential tool start aborts an in-flight continuation", async () => {
+    const { followUp, signal } = await startForegroundWinsScenario();
+
+    // The follow-up turn starts a consequential tool: foreground wins the
+    // workspace, so the still-running continuation is aborted before the two
+    // can race on writes. `remember` is deliberately NOT on the core
+    // side-effect name list — the classification must fail closed on any
+    // tool that is not provably read-only, not just named writers.
+    followUp?.callbacks?.tool_use_start?.("remember", {
+      toolUseId: "tool-1",
     });
+    expect(signal?.aborted).toBe(true);
+  });
 
-    await session.start();
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => callbacks !== undefined);
+  test("a read-only built-in leaves the continuation running; an unclassified tool fails closed", async () => {
+    const { followUp, signal } = await startForegroundWinsScenario();
 
-    // Barge in while thinking; teardown blocks on the held turn_cancelled, so
-    // the turn is aborted but not yet finalized.
-    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
-    await waitFor(() => releaseTurnCancelled !== undefined);
+    // A provably read-only built-in cannot contend on the workspace: the
+    // continuation survives (this is the topic-change case the handoff
+    // exists for).
+    followUp?.callbacks?.tool_use_start?.("file_read", { toolUseId: "tool-1" });
+    expect(signal?.aborted).toBe(false);
 
-    // A first assistant_text_delta lands in that window — fenced on the abort
-    // signal, it must not be forwarded to the client.
-    callbacks?.assistant_text_delta?.(makeTextDelta("stale thinking reply"));
-    await flushAsyncCallbacks();
-    expect(countType(frames, "assistant_text_delta")).toBe(0);
+    // web_fetch is a network read: it cannot corrupt local state, so it does
+    // not contend even though it is on the core SIDE_EFFECT_TOOLS list (which
+    // exists for a permission question, not a contention one). This is the
+    // canonical topic-change case — "what's the weather?" over a running
+    // build — and it is exactly what the handoff exists to keep alive.
+    followUp?.callbacks?.tool_use_start?.("web_fetch", {
+      toolUseId: "tool-3",
+    });
+    expect(signal?.aborted).toBe(false);
 
-    releaseTurnCancelled?.();
-    await waitFor(() =>
-      frames.some((frame) => frame.type === "turn_cancelled"),
-    );
-    expect(countType(frames, "assistant_text_delta")).toBe(0);
+    // A tool the registry does not know (e.g. an MCP or plugin tool) is not
+    // provably non-contending: fail closed and abort.
+    followUp?.callbacks?.tool_use_start?.("calendar_lookup", {
+      toolUseId: "tool-4",
+    });
+    expect(signal?.aborted).toBe(true);
   });
 
-  test("a queued assistant_text_delta is dropped at send time once a thinking barge-in aborts", async () => {
-    let callbacks: VoiceTurnCallbacks | undefined;
-    const abort = mock();
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      callbacks ??= options.callbacks;
-      return { turnId: "bridge-turn", abort };
-    });
-    let releaseFirstDelta: (() => void) | undefined;
-    // No TTS streamer: the turn emits text but never leaves the pre-TTS phase.
-    const { frames, session } = createHarness({
-      finals: ["first question", "second question"],
-      startVoiceTurn,
-      streamTtsAudio: null,
-      // Hold the first assistant_text_delta's transport write so the second
-      // one sits queued behind it (a backed-up outbound queue).
-      holdSendFrame: (payload) => {
-        if (
-          payload.type !== "assistant_text_delta" ||
-          releaseFirstDelta !== undefined
-        ) {
-          return null;
-        }
-        return new Promise<void>((resolve) => {
-          releaseFirstDelta = resolve;
-        });
-      },
-    });
+  test("an installed static skill_load leaves the continuation running", async () => {
+    installSkillFixture("static-fixture-skill", "Plain instructions.");
+    const { followUp, signal } = await startForegroundWinsScenario();
 
-    await session.start();
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => callbacks !== undefined);
+    // Re-entering a skill that is installed locally and renders no inline
+    // commands is a pure read — and it is the first call of nearly every
+    // barge-in follow-up, so it must not kill the continuation.
+    followUp?.callbacks?.tool_use_start?.("skill_load", {
+      toolUseId: "tool-1",
+      input: { skill: "static-fixture-skill" },
+    });
+    expect(signal?.aborted).toBe(false);
 
-    // First delta passes shouldSend, then blocks in the transport; the second
-    // is enqueued behind it and has not yet been send-time checked.
-    callbacks?.assistant_text_delta?.(makeTextDelta("early reply"));
-    await waitFor(() => releaseFirstDelta !== undefined);
-    callbacks?.assistant_text_delta?.(makeTextDelta("leaked tail"));
+    // web_fetch is exempt by name regardless of input.
+    followUp?.callbacks?.tool_use_start?.("web_fetch", {
+      toolUseId: "tool-2",
+      input: { url: "https://example.com" },
+    });
+    expect(signal?.aborted).toBe(false);
 
-    // Barge in while both deltas are queued: the turn aborts before the second
-    // delta drains.
-    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
-    await flushAsyncCallbacks();
+    // skill_execute is a dispatcher whose resolved inner tool can mutate.
+    followUp?.callbacks?.tool_use_start?.("skill_execute", {
+      toolUseId: "tool-3",
+      input: { skill: "static-fixture-skill" },
+    });
+    expect(signal?.aborted).toBe(true);
+  });
 
-    // Release the queue: the first (already-committed) delta writes, but the
-    // second must be dropped by the send-time guard — no cancelled-reply text
-    // leaks after the abort.
-    releaseFirstDelta?.();
-    await waitFor(() =>
-      frames.some((frame) => frame.type === "turn_cancelled"),
+  test("a skill_load with inline command expansions aborts the continuation", async () => {
+    installSkillFixture(
+      "dynamic-fixture-skill",
+      "Current status: !`git status --short`",
     );
-    expect(countType(frames, "assistant_text_delta")).toBe(1);
-    expect(
-      frames.some(
-        (frame) =>
-          frame.type === "assistant_text_delta" && frame.text === "leaked tail",
-      ),
-    ).toBe(false);
-  });
+    const { followUp, signal } = await startForegroundWinsScenario();
 
-  test("a thinking barge-in that rejects the pending turn start emits no error frame", async () => {
-    // startVoiceTurn hangs like a real turn waiting for the conversation lock
-    // and rejects when the turn's signal aborts (the waitForIdle behavior), so
-    // the turn is still "thinking" with no handle when barge-in hits.
-    const startVoiceTurn: LiveVoiceTurnStarter = async (options) => {
-      await new Promise<void>((_resolve, reject) => {
-        const fail = () =>
-          reject(new Error("turn aborted while waiting for the lock"));
-        if (options.signal?.aborted) {
-          fail();
-          return;
-        }
-        options.signal?.addEventListener("abort", fail, { once: true });
-      });
-      return { turnId: "bridge-turn", abort: mock() };
-    };
-    let releaseTurnCancelled: (() => void) | undefined;
-    const { frames, session } = createHarness({
-      finals: ["first question", "second question"],
-      startVoiceTurn,
-      holdSendFrame: (payload) => {
-        if (payload.type !== "turn_cancelled" || releaseTurnCancelled) {
-          return null;
-        }
-        return new Promise<void>((resolve) => {
-          releaseTurnCancelled = resolve;
-        });
-      },
+    // Inline expansions run shell at load time, so this load writes to the
+    // host and contends like any other mutator.
+    followUp?.callbacks?.tool_use_start?.("skill_load", {
+      toolUseId: "tool-1",
+      input: { skill: "dynamic-fixture-skill" },
     });
+    expect(signal?.aborted).toBe(true);
+  });
 
-    await session.start();
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
-
-    // Barge in while the turn's start is still pending on the lock: the abort
-    // rejects startVoiceTurn, whose catch must treat the aborted turn as dead
-    // rather than surface a stray error frame while teardown is in flight.
-    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
-    await waitFor(() => releaseTurnCancelled !== undefined);
-    await flushAsyncCallbacks();
-    expect(countType(frames, "error")).toBe(0);
+  test("a skill_load with no input aborts the continuation", async () => {
+    const { followUp, signal } = await startForegroundWinsScenario();
 
-    releaseTurnCancelled?.();
-    await waitFor(() =>
-      frames.some((frame) => frame.type === "turn_cancelled"),
-    );
-    expect(countType(frames, "error")).toBe(0);
+    // Without the input there is no way to tell a pure read from an
+    // auto-installing load: fail closed.
+    followUp?.callbacks?.tool_use_start?.("skill_load", {
+      toolUseId: "tool-1",
+    });
+    expect(signal?.aborted).toBe(true);
   });
 
-  test("a brief blip while thinking arms the guard but does not cancel", async () => {
-    let callbacks: VoiceTurnCallbacks | undefined;
-    const abort = mock();
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      callbacks ??= options.callbacks;
-      return { turnId: "bridge-turn", abort };
-    });
+  test("a foreground-wins abort keeps an already-stashed continuation result", async () => {
+    let resolveContinuation: ((result: string) => void) | undefined;
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolveContinuation = resolve;
+        }),
+    );
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
     const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
       options.onAudioChunk(makeTtsChunk("assistant audio"));
       return makeTtsResult("assistant audio");
     });
     const { frames, session } = createHarness({
-      finals: ["first question", "second question"],
+      finals: ["first question", "second question", "third question"],
       startVoiceTurn,
       streamTtsAudio,
+      spawnBackgroundContinuation,
     });
 
     await session.start();
     await session.handleBinaryAudio(LOUD_CHUNK);
     await waitFor(() => frames.some((frame) => frame.type === "thinking"));
 
-    // A short blip (well under bargeInMinSpeechMs) while the turn is still
-    // "thinking": the sustained-speech guard arms but does not trip, so a
-    // cough or noise cannot kill the in-flight agent loop.
-    await session.handleBinaryAudio(LOUD_CHUNK);
+    // Barge in; the follow-up turn launches, then the continuation finishes
+    // and stashes its answer for the NEXT turn while the follow-up still runs.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => resolveContinuation !== undefined);
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+    resolveContinuation?.("THE_RESULT");
     await flushAsyncCallbacks();
 
-    expect(countType(frames, "turn_cancelled")).toBe(0);
-    expect(abort).not.toHaveBeenCalled();
+    // The follow-up turn starts writing: the foreground-wins abort fires, but
+    // a completed continuation's stashed answer cannot race anything and is
+    // kept.
+    const followUp = calls.find((c) => c.content === "second question");
+    followUp?.callbacks?.tool_use_start?.("file_write", {
+      toolUseId: "tool-1",
+    });
+    followUp?.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+    followUp?.callbacks?.message_complete?.(makeMessageComplete());
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
 
-    // The unspoken reply still completes normally.
+    // The next turn still folds the stashed answer in as context.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const resurfaced = calls.find((c) => c.content === "third question");
+    expect(resurfaced?.voiceControlPrompt).toContain("THE_RESULT");
+  });
+
+  // A continuation spawner whose run resolves only when the test says so, so
+  // the finished-continuation moment is exact.
+  function makeControlledContinuation() {
+    let resolveContinuation: ((result: string) => void) | undefined;
+    const spawnBackgroundContinuation = mock(
+      (_args: {
+        parentConversationId: string;
+        objective: string;
+        label: string;
+        signal: AbortSignal;
+      }): Promise<string> =>
+        new Promise<string>((resolve) => {
+          resolveContinuation = resolve;
+        }),
+    );
+    return {
+      spawnBackgroundContinuation,
+      finish: (result: string) => resolveContinuation?.(result),
+    };
+  }
+
+  function makeImmediateTts(): LiveVoiceTtsStreamer {
+    return mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+  }
+
+  // ~600 ms of 24 kHz mono PCM in a single chunk, so the client-side playback
+  // tail estimate outlives the turn that produced it by a wide margin.
+  function makeLongTailTts(): LiveVoiceTtsStreamer {
+    const audio = "x".repeat(28_800);
+    return mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk(audio));
+      return makeTtsResult(audio);
+    });
+  }
+
+  function announcementOf(
+    calls: VoiceTurnOptions[],
+  ): VoiceTurnOptions | undefined {
+    return calls.find((c) => c.content === CONTINUATION_DELIVERY_CONTENT);
+  }
+
+  function announcementCount(calls: VoiceTurnOptions[]): number {
+    return calls.filter((c) => c.content === CONTINUATION_DELIVERY_CONTENT)
+      .length;
+  }
+
+  test("a continuation finishing on an idle live call is announced", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      // The barge-in utterance transcribes to nothing, so no follow-up turn
+      // runs and the call goes quiet.
+      finals: ["first question", ""],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    // Nobody is speaking, so the session starts the delivery turn itself.
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+    const announcement = announcementOf(calls);
+    expect(announcement?.voiceControlPrompt).toContain("THE_RESULT");
+    expect(announcement?.voiceControlPrompt).toContain("first question");
+  });
+
+  test("an announcement persists hidden and is never delivered twice", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+    const announcement = announcementOf(calls);
+    // The turn the user never started persists as an internal instruction, so
+    // nothing renders as a user bubble; the answer rides the control prompt.
+    expect(announcement?.content).toBe(CONTINUATION_DELIVERY_CONTENT);
+    expect(announcement?.hiddenSyntheticPrompt).toBe(true);
+
+    // Announced, so the stash must not repeat it on the user's next turn.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const later = calls.find((c) => c.content === "third question");
+    expect(later?.voiceControlPrompt).not.toContain("THE_RESULT");
+  });
+
+  test("a user utterance before the silence elapses cancels the announcement", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      // Long enough that the user always speaks first.
+      continuationAnnounceSilenceMs: 5_000,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    // The user speaks first: their turn delivers the answer through the stash,
+    // and the announcement is dropped rather than repeating it after.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const spoken = calls.find((c) => c.content === "third question");
+    expect(spoken?.voiceControlPrompt).toContain("THE_RESULT");
+    await flushAsyncCallbacks();
+    expect(announcementOf(calls)).toBeUndefined();
+  });
+
+  test("an active turn at fire time announces after the turn becomes idle", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
+    const { frames, session } = createHarness({
+      // The barge-in utterance transcribes, so a follow-up turn holds the floor
+      // for the whole announcement window.
+      finals: ["first question", "second question", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+
+    // The continuation finishes while the follow-up turn is still running, so
+    // it remains queued instead of speaking over the assistant.
+    continuation.finish("THE_RESULT");
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(announcementOf(calls)).toBeUndefined();
+
+    // Completing the active turn re-arms the silence window and announces the
+    // result without requiring another user turn.
+    const followUp = calls.find((c) => c.content === "second question");
+    followUp?.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+    followUp?.callbacks?.message_complete?.(makeMessageComplete());
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+    await waitFor(() => announcementOf(calls) !== undefined);
+    expect(announcementOf(calls)?.voiceControlPrompt).toContain("THE_RESULT");
+  });
+
+  test("a client interrupt between finish and fire cancels the announcement", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", ""],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 300,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+    await session.handleClientFrame({ type: "interrupt" });
+    await new Promise((resolve) => setTimeout(resolve, 600));
+    expect(announcementOf(calls)).toBeUndefined();
+  });
+
+  test("closing the session between finish and fire cancels the announcement", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", ""],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 300,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+    await session.close("client_end");
+    await new Promise((resolve) => setTimeout(resolve, 600));
+    expect(announcementOf(calls)).toBeUndefined();
+  });
+
+  test("a barge-in over an announcement spawns no continuation", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+
+    // Cutting in over an announcement means the user is answering it, not
+    // asking for it to be finished in the background — the skip reason is
+    // `announcement_turn` and nothing new is forked.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => countType(frames, "turn_cancelled") === 2);
+    await flushAsyncCallbacks();
+    expect(continuation.spawnBackgroundContinuation.mock.calls.length).toBe(1);
+  });
+
+  test("a barge-in over an announcement returns the answer to the stash", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+
+    // The user cuts in while the announcement turn is still in flight, so it
+    // never delivers. Nothing is forked to replace it (the work is finished),
+    // so the stash is the only route left for the answer.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => countType(frames, "turn_cancelled") === 2);
+
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const later = calls.find((c) => c.content === "third question");
+    expect(later?.voiceControlPrompt).toContain("THE_RESULT");
+    // One announcement, and no second one racing the real turn: the answer is
+    // recoverable, not duplicated.
+    await flushAsyncCallbacks();
+    expect(announcementCount(calls)).toBe(1);
+  });
+
+  test("an announcement turn that cannot start hands the answer back to the stash", async () => {
+    const continuation = makeControlledContinuation();
+    const calls: VoiceTurnOptions[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      calls.push(options);
+      // The announcement turn cannot start — the conversation is busy from
+      // another surface. Real user turns still start normally.
+      if (options.content === CONTINUATION_DELIVERY_CONTENT) {
+        throw new Error("conversation is busy");
+      }
+      if (options.content !== "first question") {
+        options.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+        options.callbacks?.message_complete?.(makeMessageComplete());
+      }
+      return { turnId: `bridge-turn-${calls.length}`, abort: mock() };
+    });
+    const { frames, session } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+    await waitFor(() => frames.some((frame) => frame.type === "error"));
+    await flushAsyncCallbacks();
+    // The failed attempt is not retried; the stash is the fallback route.
+    expect(announcementCount(calls)).toBe(1);
+
+    // Nothing was spoken, so the answer is still there for the user's next turn
+    // rather than being dropped with the announcement.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const later = calls.find((c) => c.content === "third question");
+    expect(later?.voiceControlPrompt).toContain("THE_RESULT");
+  });
+
+  test("an announcement whose launch throws hands the answer back to the stash", async () => {
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { session } = createHarness({
+      finals: ["stashed question"],
+      startVoiceTurn,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await flushAsyncCallbacks();
+
+    const internals = session as unknown as {
+      pendingContinuationResult: string | null;
+      pendingAnnouncement: { request: string; answer: string } | null;
+      scheduleContinuationAnnouncement: () => void;
+      launchAssistantTurn: (
+        utterance: unknown,
+        content: string,
+        opts?: unknown,
+      ) => Promise<boolean>;
+    };
+    // The announcement's launch REJECTS rather than returning false — a frame
+    // write failing ahead of the leg's own error handling. The `started ===
+    // false` re-stash never runs on that path, so only the catch can save the
+    // answer.
+    const launch = internals.launchAssistantTurn.bind(session);
+    internals.launchAssistantTurn = async (utterance, content, opts) => {
+      if (content === CONTINUATION_DELIVERY_CONTENT) {
+        throw new Error("thinking frame write failed");
+      }
+      return launch(utterance, content, opts);
+    };
+    internals.pendingContinuationResult = "THE_RESULT";
+    internals.pendingAnnouncement = {
+      request: "the first question",
+      answer: "THE_RESULT",
+    };
+    internals.scheduleContinuationAnnouncement();
+
+    // The attempt runs (the queue empties) and throws.
+    await waitFor(() => internals.pendingAnnouncement === null);
+    await flushAsyncCallbacks();
+    expect(announcementOf(calls)).toBeUndefined();
+    expect(internals.pendingContinuationResult).toBe("THE_RESULT");
+
+    // ...so the user's next turn still carries it.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => calls.some((c) => c.content === "stashed question"));
+    expect(
+      calls.find((c) => c.content === "stashed question")?.voiceControlPrompt,
+    ).toContain("THE_RESULT");
+  });
+
+  test("closing the room delivers a queued announcement into the conversation", async () => {
+    injectMessageIntoParentMock.mockClear();
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn } = makeResurfaceTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", ""],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      // Long enough that the announcement is still queued when the room closes.
+      continuationAnnounceSilenceMs: 5_000,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+    expect(injectMessageIntoParentMock).not.toHaveBeenCalled();
+
+    // The user hangs up before the silence elapses. Neither armed route can
+    // still run, so the finished answer takes the closed-session route into the
+    // thread instead of being dropped.
+    await session.close("client_end");
+    expect(injectMessageIntoParentMock).toHaveBeenCalledTimes(1);
+    const [conversationId, message] =
+      injectMessageIntoParentMock.mock.calls[0] ?? [];
+    expect(conversationId).toBe("conversation-123");
+    expect(message).toContain("THE_RESULT");
+    expect(message).toContain("[Background work finished]");
+    expect(message).toContain("first question");
+  });
+
+  test("closing during an active announcement delivers the result into the conversation", async () => {
+    injectMessageIntoParentMock.mockClear();
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", ""],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await waitFor(() => announcementOf(calls) !== undefined);
+    expect(injectMessageIntoParentMock).not.toHaveBeenCalled();
+
+    await session.close("client_end");
+    expect(injectMessageIntoParentMock).toHaveBeenCalledTimes(1);
+    const [conversationId, message] =
+      injectMessageIntoParentMock.mock.calls[0] ?? [];
+    expect(conversationId).toBe("conversation-123");
+    expect(message).toContain("THE_RESULT");
+    expect(message).toContain("[Background work finished]");
+    expect(message).toContain("first question");
+  });
+
+  test("a speculatively dispatched turn carries the stashed answer and cancels the announcement", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { frames, session, transcribers } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      // Long enough for the speculative turn below to launch first, short
+      // enough that an announcement that survived it would fire inside the
+      // test's own wait.
+      continuationAnnounceSilenceMs: 250,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    // The continuation finishes on an idle call: stash and announcement are
+    // both armed for the one answer.
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    // The user speaks again with a partial already in hand, so the silence
+    // boundary dispatches the turn SPECULATIVELY — the default hands-free path
+    // (endpointMaxExtensions defaults to 2) rather than the release path.
+    await waitFor(() => transcribers.length === 3);
+    transcribers[2]?.emit({ type: "partial", text: "third question" });
+    await session.handleBinaryAudio(LOUD_CHUNK);
+
+    await waitFor(() => calls.some((c) => c.content === "third question"));
+    const speculative = calls.find((c) => c.content === "third question");
+    // The verdict rule is the proof this leg was dispatched speculatively.
+    expect(speculative?.unifiedVerdict).toBe(true);
+    expect(speculative?.voiceControlPrompt).toContain("THE_RESULT");
+
+    // The user's own turn is the delivery, so the queued announcement is
+    // cancelled rather than speaking the same answer again afterwards.
+    await new Promise((resolve) => setTimeout(resolve, 600));
+    expect(announcementCount(calls)).toBe(0);
+  });
+
+  test("a held speculative turn hands the stashed answer back for the replay", async () => {
+    const continuation = makeControlledContinuation();
+    const calls: VoiceTurnOptions[] = [];
+    const discard = mock(async () => {});
+    // The first turn stays thinking so the barge-in lands on it. Every
+    // speculative leg afterwards answers with the hold token while it is
+    // offered one (`unifiedVerdict`), and answers for real on the replay.
+    const startVoiceTurn: LiveVoiceTurnStarter = async (options) => {
+      calls.push(options);
+      const index = calls.length;
+      if (options.content !== "first question") {
+        const reply = options.unifiedVerdict === true ? "[0]" : "Sure thing.";
+        setTimeout(() => {
+          options.callbacks?.assistant_text_delta?.(makeTextDelta(reply));
+          if (reply !== "[0]") {
+            options.callbacks?.message_complete?.(makeMessageComplete());
+          }
+        }, 0);
+      }
+      return { turnId: `bridge-turn-${index}`, abort: mock(), discard };
+    };
+    const { frames, session, transcribers } = createHarness({
+      finals: ["first question", "", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeImmediateTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      frontModelConfig: { endpointExtensionMs: 30 },
+      // The announcement must not fire during the hold window — the replay
+      // turn is the delivery this test is about.
+      continuationAnnounceSilenceMs: 5_000,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "utterance_discarded"),
+    );
+
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    await waitFor(() => transcribers.length === 3);
+    transcribers[2]?.emit({ type: "partial", text: "third question" });
+    await session.handleBinaryAudio(LOUD_CHUNK);
+
+    // The speculative leg holds: it is rolled back, taking nothing with it.
+    await waitFor(() => discard.mock.calls.length === 1);
+
+    // The extension replays the boundary and the replay leg answers. It is a
+    // different dispatch, so it only carries the answer if the rollback gave
+    // it back.
+    await waitFor(
+      () => calls.filter((c) => c.content === "third question").length === 2,
+    );
+    const replay = calls.filter((c) => c.content === "third question")[1];
+    expect(replay?.unifiedVerdict).toBeUndefined();
+    expect(replay?.voiceControlPrompt).toContain("THE_RESULT");
+  });
+
+  test("an announcement waits out the client's queued playback", async () => {
+    const continuation = makeControlledContinuation();
+    const { startVoiceTurn, calls } = makeNeverCompletingTurnStarter();
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question", "third question"],
+      startVoiceTurn,
+      streamTtsAudio: makeLongTailTts(),
+      spawnBackgroundContinuation: continuation.spawnBackgroundContinuation,
+      continuationAnnounceSilenceMs: 200,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(
+      () => continuation.spawnBackgroundContinuation.mock.calls.length === 1,
+    );
+    await waitFor(() => calls.some((c) => c.content === "second question"));
+
+    // The continuation finishes while the follow-up turn still holds the floor.
+    continuation.finish("THE_RESULT");
+    await flushAsyncCallbacks();
+
+    // That reply completes: the turn is cleared server-side, but the client
+    // still has ~600 ms of its audio queued.
+    const followUp = calls.find((c) => c.content === "second question");
+    followUp?.callbacks?.assistant_text_delta?.(makeTextDelta("ok"));
+    followUp?.callbacks?.message_complete?.(makeMessageComplete());
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    // The silence timer elapses mid-tail: the call looks idle but the previous
+    // reply is still audible, so the announcement holds.
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    expect(announcementOf(calls)).toBeUndefined();
+
+    // Once the queued audio has drained it lands, instead of being dropped for
+    // having been blocked.
+    await waitFor(() => announcementOf(calls) !== undefined);
+    expect(announcementOf(calls)?.voiceControlPrompt).toContain("THE_RESULT");
+  });
+
+  test("captured push-to-talk audio with no transcript yet defers the announcement", async () => {
+    const { startVoiceTurn, calls } = makeResurfaceTurnStarter();
+    const { session } = createHarness({
+      startFrame: MANUAL_START_FRAME,
+      finals: ["ptt question"],
+      startVoiceTurn,
+      continuationAnnounceSilenceMs: 20,
+    });
+
+    await session.start();
+    // Settle the arm so the cycle is streaming: from here audio goes straight
+    // to the transcriber and never lands in the pending buffer.
+    await flushAsyncCallbacks();
+
+    // The user is holding the button and talking. The transcriber emits
+    // nothing until the release, so the cycle has no partial and no final —
+    // every transcript-derived idle signal still reads "nobody is speaking".
+    await session.handleBinaryAudio(LOUD_CHUNK);
+
+    // A manual session reaches the announcement path only through machinery a
+    // server_vad barge-in owns, so the state a finished continuation leaves
+    // behind is staged directly: the stashed answer plus its queued
+    // announcement.
+    const internals = session as unknown as {
+      pendingContinuationResult: string | null;
+      pendingAnnouncement: { request: string; answer: string } | null;
+      scheduleContinuationAnnouncement: () => void;
+    };
+    internals.pendingContinuationResult = "THE_RESULT";
+    internals.pendingAnnouncement = {
+      request: "the first question",
+      answer: "THE_RESULT",
+    };
+    internals.scheduleContinuationAnnouncement();
+
+    // The silence timer and the single retry both find the utterance in
+    // flight, so the session never speaks over the in-progress utterance.
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(announcementOf(calls)).toBeUndefined();
+
+    // ...and the answer is still stashed for the turn the user does start.
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => calls.some((c) => c.content === "ptt question"));
+    expect(
+      calls.find((c) => c.content === "ptt question")?.voiceControlPrompt,
+    ).toContain("THE_RESULT");
+  });
+
+  test("a late assistant_text_delta after a thinking barge-in never reaches the client", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const abort = mock();
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks ??= options.callbacks;
+      return { turnId: "bridge-turn", abort };
+    });
+    let releaseTurnCancelled: (() => void) | undefined;
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question"],
+      startVoiceTurn,
+      // Suspend the async barge-in teardown at the turn_cancelled send so the
+      // aborted turn stays non-finalized — the exact window a late model delta
+      // could race into before cancelAssistantTurn finishes.
+      holdSendFrame: (payload) => {
+        if (payload.type !== "turn_cancelled" || releaseTurnCancelled) {
+          return null;
+        }
+        return new Promise<void>((resolve) => {
+          releaseTurnCancelled = resolve;
+        });
+      },
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => callbacks !== undefined);
+
+    // Barge in while thinking; teardown blocks on the held turn_cancelled, so
+    // the turn is aborted but not yet finalized.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => releaseTurnCancelled !== undefined);
+
+    // A first assistant_text_delta lands in that window — fenced on the abort
+    // signal, it must not be forwarded to the client.
+    callbacks?.assistant_text_delta?.(makeTextDelta("stale thinking reply"));
+    await flushAsyncCallbacks();
+    expect(countType(frames, "assistant_text_delta")).toBe(0);
+
+    releaseTurnCancelled?.();
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "turn_cancelled"),
+    );
+    expect(countType(frames, "assistant_text_delta")).toBe(0);
+  });
+
+  test("a queued assistant_text_delta is dropped at send time once a thinking barge-in aborts", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const abort = mock();
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks ??= options.callbacks;
+      return { turnId: "bridge-turn", abort };
+    });
+    let releaseFirstDelta: (() => void) | undefined;
+    // No TTS streamer: the turn emits text but never leaves the pre-TTS phase.
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question"],
+      startVoiceTurn,
+      streamTtsAudio: null,
+      // Hold the first assistant_text_delta's transport write so the second
+      // one sits queued behind it (a backed-up outbound queue).
+      holdSendFrame: (payload) => {
+        if (
+          payload.type !== "assistant_text_delta" ||
+          releaseFirstDelta !== undefined
+        ) {
+          return null;
+        }
+        return new Promise<void>((resolve) => {
+          releaseFirstDelta = resolve;
+        });
+      },
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => callbacks !== undefined);
+
+    // First delta passes shouldSend, then blocks in the transport; the second
+    // is enqueued behind it and has not yet been send-time checked.
+    callbacks?.assistant_text_delta?.(makeTextDelta("early reply"));
+    await waitFor(() => releaseFirstDelta !== undefined);
+    callbacks?.assistant_text_delta?.(makeTextDelta("leaked tail"));
+
+    // Barge in while both deltas are queued: the turn aborts before the second
+    // delta drains.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await flushAsyncCallbacks();
+
+    // Release the queue: the first (already-committed) delta writes, but the
+    // second must be dropped by the send-time guard — no cancelled-reply text
+    // leaks after the abort.
+    releaseFirstDelta?.();
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "turn_cancelled"),
+    );
+    expect(countType(frames, "assistant_text_delta")).toBe(1);
+    expect(
+      frames.some(
+        (frame) =>
+          frame.type === "assistant_text_delta" && frame.text === "leaked tail",
+      ),
+    ).toBe(false);
+  });
+
+  test("a thinking barge-in that rejects the pending turn start emits no error frame", async () => {
+    // startVoiceTurn hangs like a real turn waiting for the conversation lock
+    // and rejects when the turn's signal aborts (the waitForIdle behavior), so
+    // the turn is still "thinking" with no handle when barge-in hits.
+    const startVoiceTurn: LiveVoiceTurnStarter = async (options) => {
+      await new Promise<void>((_resolve, reject) => {
+        const fail = () =>
+          reject(new Error("turn aborted while waiting for the lock"));
+        if (options.signal?.aborted) {
+          fail();
+          return;
+        }
+        options.signal?.addEventListener("abort", fail, { once: true });
+      });
+      return { turnId: "bridge-turn", abort: mock() };
+    };
+    let releaseTurnCancelled: (() => void) | undefined;
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question"],
+      startVoiceTurn,
+      holdSendFrame: (payload) => {
+        if (payload.type !== "turn_cancelled" || releaseTurnCancelled) {
+          return null;
+        }
+        return new Promise<void>((resolve) => {
+          releaseTurnCancelled = resolve;
+        });
+      },
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    // Barge in while the turn's start is still pending on the lock: the abort
+    // rejects startVoiceTurn, whose catch must treat the aborted turn as dead
+    // rather than surface a stray error frame while teardown is in flight.
+    await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+    await waitFor(() => releaseTurnCancelled !== undefined);
+    await flushAsyncCallbacks();
+    expect(countType(frames, "error")).toBe(0);
+
+    releaseTurnCancelled?.();
+    await waitFor(() =>
+      frames.some((frame) => frame.type === "turn_cancelled"),
+    );
+    expect(countType(frames, "error")).toBe(0);
+  });
+
+  test("a brief blip while thinking arms the guard but does not cancel", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const abort = mock();
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks ??= options.callbacks;
+      return { turnId: "bridge-turn", abort };
+    });
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      options.onAudioChunk(makeTtsChunk("assistant audio"));
+      return makeTtsResult("assistant audio");
+    });
+    const { frames, session } = createHarness({
+      finals: ["first question", "second question"],
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => frames.some((frame) => frame.type === "thinking"));
+
+    // A short blip (well under bargeInMinSpeechMs) while the turn is still
+    // "thinking": the sustained-speech guard arms but does not trip, so a
+    // cough or noise cannot kill the in-flight agent loop.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await flushAsyncCallbacks();
+
+    expect(countType(frames, "turn_cancelled")).toBe(0);
+    expect(abort).not.toHaveBeenCalled();
+
+    // The unspoken reply still completes normally.
     callbacks?.assistant_text_delta?.(makeTextDelta("Here is the answer."));
     callbacks?.message_complete?.(makeMessageComplete());
     await waitFor(() =>
@@ -2691,395 +3617,7 @@ describe("LiveVoiceSession sustained-speech barge-in guard", () => {
   });
 });
 
-// Stub semantic-endpointing decider: scripted hold/release decisions consumed
-// in order, with every consulted input captured. Falls back to "release" once
-// the script is exhausted, mirroring the real decider's fail-open bias.
-function makeFrontDecider(decisions: Array<"hold" | "release">): {
-  decider: VoiceFrontDecider;
-  calls: VoiceEndpointDecisionInput[];
-} {
-  const calls: VoiceEndpointDecisionInput[] = [];
-  return {
-    calls,
-    decider: {
-      decideEndpoint: async (input) => {
-        calls.push(input);
-        return { action: decisions[calls.length - 1] ?? "release" };
-      },
-      generateAckText: async () => null,
-      generateProgressText: async () => null,
-    },
-  };
-}
-
-describe("LiveVoiceSession semantic endpointing", () => {
-  // Arms the harness session, waits for its transcriber, and seeds a partial
-  // so the silence boundary has transcript text for the decider to judge.
-  async function startWithPartial(
-    session: LiveVoiceSession,
-    transcribers: MockStreamingTranscriber[],
-    partialText = "hello wor",
-  ): Promise<void> {
-    await session.start();
-    await waitFor(() => transcribers.length === 1);
-    // Let the transcriber's start() wiring settle before emitting events.
-    await flushAsyncCallbacks();
-    transcribers[0]?.emit({ type: "partial", text: partialText });
-  }
-
-  test("a held silence boundary sends no utterance_end and replays after the extension", async () => {
-    const { decider, calls } = makeFrontDecider(["hold", "release"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      frontModelConfig: { endpointExtensionMs: 30 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-
-    // First silence boundary: the decider holds — no utterance_end, no turn.
-    await waitFor(() => calls.length === 1);
-    expect(calls[0]).toEqual({
-      transcriptSoFar: "",
-      latestPartial: "hello wor",
-      silenceThresholdMs: 40,
-      extensionCount: 0,
-    });
-    expect(countType(frames, "utterance_end")).toBe(0);
-    expect(countType(frames, "thinking")).toBe(0);
-
-    // The extension elapses in continued silence: the boundary replays, the
-    // decider releases, and the turn launches normally.
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(calls).toHaveLength(2);
-    expect(calls[1]).toMatchObject({ extensionCount: 1 });
-    expect(frameTypes(frames)).toEqual([
-      "ready",
-      "stt_partial",
-      "speech_started",
-      "utterance_end",
-      "stt_final",
-      "thinking",
-      "assistant_text_delta",
-      "tts_done",
-    ]);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "silence" });
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("ptt_release during a held pause still emits utterance_end", async () => {
-    const { decider, calls } = makeFrontDecider(["hold"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      // Long extension so the pending replay cannot race the manual release.
-      frontModelConfig: { endpointExtensionMs: 5_000 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => calls.length === 1);
-    expect(countType(frames, "utterance_end")).toBe(0);
-
-    // The detector's turn already ended (the hold suppressed its boundary),
-    // so this release takes the no-active-detector path — the client must
-    // still receive the utterance_end frame it uses to leave `listening`.
-    await session.handleClientFrame({ type: "ptt_release" });
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(countType(frames, "utterance_end")).toBe(1);
-    // Manual release never re-consults the decider.
-    expect(calls).toHaveLength(1);
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("speech resuming during a hold cancels the replay and the utterance keeps accumulating", async () => {
-    const { decider, calls } = makeFrontDecider(["hold", "release"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Okay."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello there world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      // Comfortably longer than the resumed speech's own silence boundary,
-      // so a leaked (uncancelled) replay would surface as a third decider
-      // consult / second utterance_end below.
-      frontModelConfig: { endpointExtensionMs: 200 },
-    });
-
-    await startWithPartial(session, transcribers, "hello");
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => calls.length === 1);
-    expect(countType(frames, "utterance_end")).toBe(0);
-
-    // Speech resumes during the hold; the fresh silence boundary after it —
-    // not the cancelled replay timer — drives the next decision.
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => calls.length === 2);
-    expect(calls[1]).toMatchObject({ extensionCount: 1 });
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    // Wait out the original extension window: the cancelled replay never
-    // re-fires the boundary.
-    await new Promise((resolve) => setTimeout(resolve, 250));
-    expect(calls).toHaveLength(2);
-    expect(countType(frames, "utterance_end")).toBe(1);
-    // Both speech bursts fed the same utterance's transcriber (the second
-    // resolves only when the completed turn re-arms), producing one released
-    // turn end-to-end.
-    expect(transcribers[0]?.received.length).toBeGreaterThanOrEqual(2);
-    expect(turnStarter.calls).toHaveLength(1);
-    expect(turnStarter.calls[0]).toMatchObject({
-      content: "hello there world",
-    });
-  });
-
-  test("a release decision produces the same frame sequence as the flag-off path", async () => {
-    const { decider, calls } = makeFrontDecider(["release"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    expect(calls).toHaveLength(1);
-    expect(frameTypes(frames)).toEqual([
-      "ready",
-      "stt_partial",
-      "speech_started",
-      "utterance_end",
-      "stt_final",
-      "thinking",
-      "assistant_text_delta",
-      "tts_done",
-    ]);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "silence" });
-  });
-
-  test("a rejecting decider still releases the boundary with the normal frame sequence", async () => {
-    // The decider contract never rejects, but a buggy injected stub (or a
-    // future regression) must not silently drop the silence boundary: the
-    // session's belt catches the rejection and releases.
-    const calls: VoiceEndpointDecisionInput[] = [];
-    const decider: VoiceFrontDecider = {
-      decideEndpoint: async (input) => {
-        calls.push(input);
-        throw new Error("stub decider boom");
-      },
-      generateAckText: async () => null,
-      generateProgressText: async () => null,
-    };
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    expect(calls).toHaveLength(1);
-    expect(frameTypes(frames)).toEqual([
-      "ready",
-      "stt_partial",
-      "speech_started",
-      "utterance_end",
-      "stt_final",
-      "thinking",
-      "assistant_text_delta",
-      "tts_done",
-    ]);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "silence" });
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("a slow decider adds only its own bounded delay and then releases normally", async () => {
-    // Resolves "release" only after a delay comfortably longer than every
-    // other timer in the flow — the boundary must wait it out and then run
-    // the unchanged release sequence.
-    const calls: VoiceEndpointDecisionInput[] = [];
-    const decider: VoiceFrontDecider = {
-      decideEndpoint: async (input) => {
-        calls.push(input);
-        await new Promise((resolve) => setTimeout(resolve, 150));
-        return { action: "release" };
-      },
-      generateAckText: async () => null,
-      generateProgressText: async () => null,
-    };
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-
-    // While the decision is pending, the boundary stays unreleased.
-    await waitFor(() => calls.length === 1);
-    expect(countType(frames, "utterance_end")).toBe(0);
-    expect(countType(frames, "thinking")).toBe(0);
-
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(calls).toHaveLength(1);
-    expect(frameTypes(frames)).toEqual([
-      "ready",
-      "stt_partial",
-      "speech_started",
-      "utterance_end",
-      "stt_final",
-      "thinking",
-      "assistant_text_delta",
-      "tts_done",
-    ]);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "silence" });
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("endpointMaxExtensions caps consecutive holds and forces the release", async () => {
-    const { decider, calls } = makeFrontDecider(["hold", "hold", "hold"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      frontModelConfig: { endpointExtensionMs: 20, endpointMaxExtensions: 1 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    // The single allowed hold consumed the decider's one consult; the replay
-    // hit the cap and released without asking again.
-    expect(calls).toHaveLength(1);
-    expect(countType(frames, "utterance_end")).toBe(1);
-    expect(turnStarter.calls).toHaveLength(1);
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("a max-duration boundary bypasses the decider entirely", async () => {
-    const { decider, calls } = makeFrontDecider(["hold"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      // Silence can never fire; the max-duration cap ends the turn instead.
-      turnDetectorConfig: { silenceThresholdMs: 10_000, maxTurnDurationMs: 40 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    expect(calls).toHaveLength(0);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "max-duration" });
-    expect(turnStarter.calls).toHaveLength(1);
-  });
-
-  test("a ptt_release forced boundary bypasses the decider and releases immediately", async () => {
-    // A hold-happy decider: if the manual release were routed through it,
-    // the boundary would be deferred and the frame sequence below would gain
-    // an extension delay (or stall entirely).
-    const { decider, calls } = makeFrontDecider(["hold", "hold"]);
-    const turnStarter = makeAutoCompletingTurnStarter(["Hi there."]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      startVoiceTurn: turnStarter.startVoiceTurn,
-      frontDecider: decider,
-      // A genuine silence boundary can never fire during the test; only the
-      // client's explicit release ends the turn.
-      turnDetectorConfig: { silenceThresholdMs: 10_000 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() =>
-      frames.some((frame) => frame.type === "speech_started"),
-    );
-
-    await session.handleClientFrame({ type: "ptt_release" });
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-
-    // The explicit release was never second-guessed: no decider consult, and
-    // the boundary produced the normal utterance_end → turn-launch sequence.
-    expect(calls).toHaveLength(0);
-    expect(frameTypes(frames)).toEqual([
-      "ready",
-      "stt_partial",
-      "speech_started",
-      "utterance_end",
-      "stt_final",
-      "thinking",
-      "assistant_text_delta",
-      "tts_done",
-    ]);
-    expect(
-      frames.find((frame) => frame.type === "utterance_end"),
-    ).toMatchObject({ reason: "silence" });
-    expect(turnStarter.calls).toHaveLength(1);
-    expect(turnStarter.calls[0]).toMatchObject({ content: "hello world" });
-  });
-
-  test("session close during a hold clears the extension timer", async () => {
-    const { decider, calls } = makeFrontDecider(["hold", "hold"]);
-    const { frames, session, transcribers } = createHarness({
-      finals: ["hello world"],
-      frontDecider: decider,
-      frontModelConfig: { endpointExtensionMs: 30 },
-    });
-
-    await startWithPartial(session, transcribers);
-    await session.handleBinaryAudio(LOUD_CHUNK);
-    await waitFor(() => calls.length === 1);
-    expect(countType(frames, "utterance_end")).toBe(0);
-
-    await session.close("client_end");
-    const framesAtClose = frames.length;
-
-    // Well past the extension window: the cleared timer never replays the
-    // boundary — no utterance_end, no second decider consult, no new frames.
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    expect(calls).toHaveLength(1);
-    expect(countType(frames, "utterance_end")).toBe(0);
-    expect(frames.length).toBe(framesAtClose);
-  });
-});
-
 describe("LiveVoiceSession unified front-door endpointing", () => {
-  const enableUnifiedFlags = () =>
-    setCachedOverrides(
-      {
-        "voice-mode": true,
-      },
-      { fromGateway: true },
-    );
-
-  afterEach(() => clearCachedOverrides());
-
   function spokenDeltaText(frames: LiveVoiceServerFrame[]): string {
     return frames
       .filter((frame) => frame.type === "assistant_text_delta")
@@ -3114,23 +3652,12 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
     return { startVoiceTurn, calls, discard };
   }
 
-  // A decider that must never be consulted once the unified flag owns
-  // endpointing.
-  function makeUntouchableDecider(): {
-    decider: VoiceFrontDecider;
-    endpointCalls: () => number;
-  } {
-    let count = 0;
+  // A decider that phrases nothing: the front-door leg IS the endpoint
+  // decision, so these tests only need the decider seam to exist.
+  function makeSilentDecider(): VoiceFrontDecider {
     return {
-      decider: {
-        decideEndpoint: async () => {
-          count += 1;
-          return { action: "release" as const };
-        },
-        generateAckText: async () => null,
-        generateProgressText: async () => null,
-      },
-      endpointCalls: () => count,
+      generateAckText: async () => null,
+      generateProgressText: async () => null,
     };
   }
 
@@ -3146,8 +3673,7 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   }
 
   test("a chatty answer commits: verdict leg replaces the decider, frames follow commit order", async () => {
-    enableUnifiedFlags();
-    const { decider, endpointCalls } = makeUntouchableDecider();
+    const decider = makeSilentDecider();
     const starter = makeVerdictTurnStarter([["Hey! Not much."]]);
     const { frames, session, transcribers } = createHarness({
       finals: ["hello world"],
@@ -3159,8 +3685,7 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
     await session.handleBinaryAudio(LOUD_CHUNK);
     await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
 
-    // The leg IS the endpoint decision: the decider was never consulted.
-    expect(endpointCalls()).toBe(0);
+    // The leg IS the endpoint decision.
     expect(starter.calls).toHaveLength(1);
     // Dispatched speculatively on the pre-finalize transcript, as the
     // front-door leg with the verdict rule requested.
@@ -3182,7 +3707,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a hold verdict discards the leg silently and the extension replays the boundary", async () => {
-    enableUnifiedFlags();
     const starter = makeVerdictTurnStarter([["[0]"], ["Sure thing."]]);
     const { frames, session, transcribers } = createHarness({
       finals: ["hello world"],
@@ -3215,7 +3739,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a verdict that misses the deadline commits the turn (fail-open)", async () => {
-    enableUnifiedFlags();
     // The leg never produces a verdict — a provider TTFT tail. The deadline
     // must commit the turn so the caller gets the thinking frame (and the
     // ack timer arms) instead of unbounded structural silence.
@@ -3240,7 +3763,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a final that extends the held transcript replays the boundary immediately", async () => {
-    enableUnifiedFlags();
     const starter = makeVerdictTurnStarter([["[0]"], ["Got it."]]);
     const { frames, session, transcribers } = createHarness({
       finals: ["hello world how are you"],
@@ -3265,7 +3787,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("speech resuming mid-verdict discards the leg and the utterance keeps accumulating", async () => {
-    enableUnifiedFlags();
     // First leg never produces a verdict (in flight); second answers.
     const starter = makeVerdictTurnStarter([[], ["Got it all."]]);
     const { frames, session, transcribers } = createHarness({
@@ -3294,7 +3815,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a discard that beats the bridge handle still rolls back the user row", async () => {
-    enableUnifiedFlags();
     const discard = mock(async () => {});
     const abort = mock();
     let resolveHandle: (() => void) | null = null;
@@ -3336,7 +3856,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a manual release during the verdict window commits the leg instead of discarding it", async () => {
-    enableUnifiedFlags();
     const discard = mock(async () => {});
     let callbacks: VoiceTurnCallbacks | undefined;
     const calls: VoiceTurnOptions[] = [];
@@ -3376,7 +3895,6 @@ describe("LiveVoiceSession unified front-door endpointing", () => {
   });
 
   test("a hold verdict after a manual release relaunches a fresh leg on the released utterance", async () => {
-    enableUnifiedFlags();
     const discard = mock(async () => {});
     let firstCallbacks: VoiceTurnCallbacks | undefined;
     const calls: VoiceTurnOptions[] = [];