@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/live-voice/live-voice-session.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
 
 import {
   type BargeInGuard,
@@ -26,17 +27,29 @@ import { sanitizeForTts } from "../calls/tts-text-sanitizer.js";
 import {
   createControlMarkerHoldback,
   TASK_STOP_MARKER,
+  TASK_UPDATE_SILENT_MARKER,
 } from "../calls/voice-control-protocol.js";
+import type { VoiceEscalationTarget } from "../calls/voice-escalation-target.js";
 import {
   createFrontDoorLegCoordinator,
   type FrontDoorLegCoordinator,
   type SpokenEscalationBridge,
 } from "../calls/voice-leg-coordinator.js";
+import {
+  getVoiceMetricsAggregateFields,
+  type VoiceEndpointAction,
+  type VoiceEndpointSource,
+  type VoiceMetricsClock,
+  VoiceMetricsCollector,
+  type VoiceMetricsEvent,
+  type VoiceTurnSeedMarks,
+} from "../calls/voice-metrics.js";
 import {
   createProgressCadence,
   type ProgressCadence,
 } from "../calls/voice-progress-cadence.js";
 import type {
+  VoiceTurnCallbacks,
   VoiceTurnHandle,
   VoiceTurnOptions,
 } from "../calls/voice-session-bridge.js";
@@ -56,6 +69,10 @@ import {
   VoiceFrontModelConfigSchema,
 } from "../config/schemas/voice.js";
 import { ABORT_WATCHDOG_MS } from "../daemon/abort-watchdog.js";
+import type {
+  ConversationModeSessionCoordinator,
+  ModeSessionSourceHandle,
+} from "../daemon/conversation-mode-session.js";
 import { isRefusedInReadOnlyPass } from "../daemon/conversation-tool-setup.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
@@ -95,6 +112,7 @@ import type {
   SttStreamServerEvent,
 } from "../stt/types.js";
 import { getSubagentManager } from "../subagent/index.js";
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
 import {
   liveVoiceEndScreen,
   liveVoiceSilenceReason,
@@ -116,6 +134,12 @@ import {
   dismissesUiSurface,
   revealsUiSurface,
 } from "./activity-label.js";
+import { CameraModeSessionProducer } from "./camera-mode-session.js";
+import {
+  type ContinuationJudgement,
+  createContinuationJudge,
+  type LiveVoiceContinuationJudge,
+} from "./continuation-judge.js";
 import {
   buildDuplexContinuationLabel,
   createContinuationLabeler,
@@ -128,15 +152,7 @@ import type {
 } from "./live-voice-archive.js";
 import type { LiveVoiceCredentialReadiness } from "./live-voice-credential-preflight.js";
 import {
-  getLiveVoiceMetricsAggregateFields,
-  type LiveVoiceMetricsClock,
-  LiveVoiceMetricsCollector,
-  type LiveVoiceMetricsEvent,
-  type LiveVoiceTurnSeedMarks,
-  type VoiceEndpointAction,
-  type VoiceEndpointSource,
-} from "./live-voice-metrics.js";
-import {
+  type LiveVoicePhotoResult,
   persistAmbientSightFrame,
   persistLiveVoicePhoto,
 } from "./live-voice-photo.js";
@@ -151,6 +167,7 @@ import type {
   LiveVoiceTtsOptions,
   LiveVoiceTtsResult,
 } from "./live-voice-tts.js";
+import { MicrophoneIdleGate } from "./microphone-idle-gate.js";
 import {
   type LiveVoiceClientAttachFrameFrame,
   type LiveVoiceClientAttachImageFrame,
@@ -167,12 +184,15 @@ import {
   isLookSessionControl,
   LOOK_FOLLOW_UP_CONTENT,
   LOOK_FRAME_REASON,
+  type LookFollowUp,
   lookFollowUpNote,
   type LookSessionControl,
   progressConfigForCadence,
   requestedSessionControl,
   sessionControlTeaching,
 } from "./session-controls.js";
+import { type VoiceTaskOutcome, VoiceTaskOutcomes } from "./task-outcomes.js";
+import { VoiceInputDiagnostics } from "./voice-input-diagnostics.js";
 
 const log = getLogger("live-voice-session");
 
@@ -263,25 +283,22 @@ const PROVIDER_TURN_END_FALLBACK_MARGIN_MS = 1_000;
 // a segment is at most ~180 chars of speech (~10 s of 24 kHz mono PCM
 // ≈ 480 KB), so one buffered segment is an acceptable bound.
 const TTS_MAX_OPEN_SYNTHESIS_JOBS = 2;
+const TTS_MAX_PLAYBACK_LEAD_MS = 500;
 // Audible silence required before a finished background continuation's result
 // is spoken into a live call. Long enough that the announcement lands in a real
 // lull rather than on the heels of the turn that just ended; short enough that
 // the user is not left wondering whether the work survived.
 const CONTINUATION_ANNOUNCE_SILENCE_MS = 1_500;
-// How many times a pending announcement re-arms itself against a client
-// playback tail that outlasted its timer. Each re-arm waits out the whole
-// remaining tail, so one covers a reply of any length; the rest cover a fresh
-// reply's audio landing between two checks. Beyond the cap the announcement
-// falls back to the stash rather than chasing a call that keeps talking.
-const CONTINUATION_ANNOUNCE_MAX_DRAIN_REARMS = 3;
+// How long a barge-in's continuation waits for the interrupting words before
+// the continuation judge gives up on them and the continuation proceeds.
+// Covers the caller finishing the sentence and the utterance releasing.
+const BARGE_IN_INTERRUPTION_WAIT_MS = 4_000;
 const FOREGROUND_TASK_RESUME_SILENCE_MS = 1_500;
 const FOREGROUND_TASK_MAX_SUSPENDED_MS = 120_000;
 const FOREGROUND_TASK_MAX_INTERVENING_TURNS = 3;
-// `content` of an announcement turn. The answer never rides here — it goes in
-// the model-facing control prompt (buildLiveDeliveryNote), so the only thing
-// persisted on the user side is this marker, and it persists hidden.
+// Hidden content for continuation announcements; findings travel in the control prompt.
 export const CONTINUATION_DELIVERY_CONTENT =
-  "(background work finished — deliver it now)";
+  "(background work finished: deliver it now)";
 // How long a look control waits for the fresh frame the client takes for it.
 // Long enough for a camera that has to open and warm up before its first keep;
 // past it the look is dropped rather than answered into a later, unrelated
@@ -364,10 +381,14 @@ export interface LiveVoiceSessionOptions {
    */
   resolveCredentialReadiness?: LiveVoiceCredentialReadinessResolver | null;
   startVoiceTurn?: LiveVoiceTurnStarter;
+  acquireModeSessionResidency?: (conversationId: string) => Promise<{
+    coordinator: ConversationModeSessionCoordinator;
+    release: () => void;
+  }>;
   streamTtsAudio?: LiveVoiceTtsStreamer | null;
   archiveAudio?: LiveVoiceSessionAudioArchiver | null;
   emitMetrics?: boolean;
-  metricsClock?: LiveVoiceMetricsClock;
+  metricsClock?: VoiceMetricsClock;
   /**
    * Mirrors phase changes to the iOS Live Activity. Injectable so tests can
    * assert what a session reports without reaching the platform.
@@ -448,6 +469,13 @@ export interface LiveVoiceSessionOptions {
    * Absent, the continuation carries the deterministic transcript label.
    */
   labelBackgroundContinuation?: LiveVoiceContinuationLabeler;
+  /**
+   * Decides from the caller's interruption whether the interrupted request
+   * should still continue in the background. The factory wires the
+   * TypeSafe-backed judge; tests inject a stub. Absent, every eligible
+   * barge-in continues, as it does without a TypeSafe profile.
+   */
+  judgeBackgroundContinuation?: LiveVoiceContinuationJudge;
   /**
    * Returns the pending teardown promise for a conversation's most recent
    * turn. The barge-in path awaits it before forking the background
@@ -493,6 +521,7 @@ type LiveVoiceUtterancePhase =
 // manual mode and a session-shared instance in persistent server-VAD mode.
 interface UtteranceCycle {
   phase: LiveVoiceUtterancePhase;
+  preDialBargeInGuard: BargeInGuard | null;
   released: boolean;
   assistantTurnStarted: boolean;
   // The whole cycle (turn included) finalized; the record can no longer
@@ -510,12 +539,8 @@ interface UtteranceCycle {
   // server_vad has the turn detector for the same question, and never sets
   // this — its ingress is handleServerVadAudio.
   manualAudioCaptured: boolean;
-  // server_vad capture routed speech (not just pre-roll silence) into this
-  // cycle. Distinguishes an eagerly re-armed cycle holding only leading
-  // silence from one already carrying the user's utterance: the
-  // stale-language interception in handleServerVadAudio may retire the
-  // former, never the latter. turnId cannot answer this, because a
-  // silence-only pre-roll flush assigns it too.
+  // Local VAD or the provider detected speech. A language change may retire
+  // only a silence-only cycle; pre-roll can assign turnId before speech.
   speechRouted: boolean;
   pendingAudioChunks: Buffer[];
   pendingAudioBytes: number;
@@ -601,6 +626,8 @@ type UtteranceStartResult =
 // client in job-list order.
 interface TtsSegmentJob {
   readonly text: string;
+  readonly isReply: boolean;
+  audioSent: boolean;
   // Per-segment language-hint override, preferred over the turn's language.
   // Set on fixed phrases whose localized table lacks the turn's language:
   // the English fallback text carries "en" so an enforcing provider never
@@ -635,6 +662,9 @@ interface ActiveAssistantTurn {
   language: string | undefined;
   abortController: AbortController;
   handle: VoiceTurnHandle | null;
+  modeSessionSource: ModeSessionSourceHandle | undefined;
+  modeSessionRequestIds: string[];
+  modeSessionDeliveryTurnId: string | null;
   // When the turn launched, for narration's turnElapsedMs.
   launchedAtMs: number;
   // Tool-activity log and spoken progress narration for the turn
@@ -659,6 +689,10 @@ interface ActiveAssistantTurn {
   // whole frame rather than its wording. What the CLIENT believes, as against
   // `pendingApproval`, which is what is true.
   publishedApprovalRequestId: string | null;
+  // Structured activity the client most recently received. TTS can
+  // temporarily move system surfaces to speaking without changing this
+  // logical activity, while a tool or approval frame clears it.
+  publishedActivityKind: "escalation" | null;
   // Set while the turn is blocked on a decision the user has to make, and null
   // when it is not. Suppresses progress narration, whose entire vocabulary
   // ("still on it", "almost there") describes work in flight and would be
@@ -681,6 +715,7 @@ interface ActiveAssistantTurn {
   // A tts_audio frame actually went out to the client — latches on the first
   // forwarded chunk so the firstTtsAudio metric is marked exactly once per turn.
   ttsAudioStarted: boolean;
+  ttsFailed: boolean;
   finalized: boolean;
   // Unified front-door speculative dispatch: the leg is in flight but its
   // leading verdict (hold vs commit) has not arrived. The thinking
@@ -718,19 +753,12 @@ interface ActiveAssistantTurn {
   // merges it with this turn's utterance instead of treating that utterance as
   // a fresh follow-up. Null for an ordinary (non-barge-in) turn.
   interruptedRequest: string | null;
-  // The completed background continuation's answer, folded into this turn's
-  // control prompt as context so the model can deliver or reference it in reply
-  // to the user's own utterance. Null when no continuation result is pending.
-  continuationResult: string | null;
-  // Set only on an announcement turn: the interrupted request and the
-  // continuation's answer, which the turn exists solely to deliver. The turn has
-  // no user utterance behind it — `content` is CONTINUATION_DELIVERY_CONTENT and
-  // the answer rides the control prompt (buildLiveDeliveryNote).
-  continuationDelivery: ContinuationDelivery | null;
-  // Set only on the turn that answers a look: which look it answers. The turn
-  // has no user utterance behind it; the instruction rides the control prompt
-  // (lookFollowUpNote).
-  lookFollowUp: LookSessionControl | null;
+  contextOutcomes: VoiceTaskOutcome[];
+  taskOutcome: VoiceTaskOutcome | null;
+  taskDeliveryContext: string | null;
+  notificationHandledSilently: boolean;
+  // The fresh view and original caller request this hidden turn resumes.
+  lookFollowUp: LookFollowUp | null;
   // The turn's content is an internal instruction rather than user speech (the
   // greeting that opens a session, say). The row still persists and the model
   // still sees it; `hiddenSyntheticPrompt` keeps it out of the transcript.
@@ -754,15 +782,8 @@ interface ActiveAssistantTurn {
   // slot while this turn was in flight. Nothing will ever send it, so it is
   // collected once the discard has removed the row still linking it.
   staleFrameId: string | null;
-  // The queued announcement this turn consumed alongside `continuationResult`
-  // — the two are routes for one answer, so launching consumes both. Held here
-  // so a rolled-back speculative dispatch can re-arm it (see
-  // restorePendingTurnContext). Null on the announcement turn itself, which
-  // owns its delivery outright.
-  consumedAnnouncement: ContinuationDelivery | null;
   // `detachStopGeneration` at the moment this turn consumed the pending
-  // context. A bump since then means a stop/interrupt/supersede deliberately
-  // dropped the continuation, so a rollback must not resurrect it.
+  // context. A stop invalidates that context so a rollback cannot restore it.
   pendingContextStopGeneration: number;
   // Counts assistant text deltas seen this turn. A narration generation
   // captures it at launch and discards its result if it moved: text the model
@@ -777,6 +798,9 @@ interface ActiveAssistantTurn {
   // The front-door leg's coordinator: whether it handed the turn off to the
   // escalated leg. Null until the front-door leg starts.
   frontDoor: FrontDoorLegCoordinator | null;
+  // Final post-hook inference target for an escalated leg. Retained so the
+  // neutral waiting phase can be restored after bridge audio drains.
+  escalationTarget: VoiceEscalationTarget | null;
   ttsBuffer: string;
   // What the caller actually hears this turn, summed over the model's own
   // segments (acks and progress narration do not count). Logged at tts_done
@@ -802,6 +826,19 @@ interface ActiveAssistantTurn {
   assistantAudioSampleRate?: number;
 }
 
+function sameModeSessionSource(
+  a: ModeSessionSourceHandle | undefined,
+  b: ModeSessionSourceHandle,
+): boolean {
+  return (
+    a?.id === b.id &&
+    a.mode === b.mode &&
+    a.sourceId === b.sourceId &&
+    a.generation === b.generation &&
+    a.activation === b.activation
+  );
+}
+
 // Base control prompt for every live-voice turn. Opens with the spoken-reply
 // rules shared with the phone path (spoken-reply-rules.ts): this is the only
 // place the model learns that its text is spoken, since the system prompt has
@@ -849,14 +886,10 @@ function buildInterruptionMergeNote(interruptedRequest: string): string {
   return `The user interrupted your previous, unfinished reply. Their earlier request was: "${interruptedRequest}". Treat their current message as a continuation of that request and address both together. If they corrected or redirected the unfinished work, continue executing it with that correction instead of merely acknowledging it. If they clearly want the unfinished task abandoned, use the task-stop control.`;
 }
 
-// System-level guidance appended to the NEXT turn's control prompt after a
-// background continuation finished the reply the user interrupted. Folds the
-// completed answer in as context so the model can deliver or reference it in
-// its reply to whatever the user just said — this turn answers the user, so the
-// result is offered only if it fits. Reaches the model only; it is not a user
-// message and never renders as a transcript bubble.
-function buildResurfaceContextNote(continuationResult: string): string {
-  return `Earlier the user interrupted you, and in the background you finished the reply they cut off. What you worked out was: "${continuationResult}". If their current message relates to it, use it to answer; otherwise you may briefly offer it or leave it aside, and do not repeat it verbatim if it no longer fits.`;
+function buildResurfaceContextNote(
+  outcomes: readonly VoiceTaskOutcome[],
+): string {
+  return `Answer the user's current message. These pending background reports are context, not new requests. Use their findings if relevant; otherwise leave them for a separate announcement. Reading them does not acknowledge delivery. Pending results:\n${outcomes.map((outcome) => outcome.message).join("\n\n")}`;
 }
 
 // Appended to the turn that follows a barge-in whose interrupted work was
@@ -879,19 +912,11 @@ function describeInterruptedRequest(request: string): string {
     : "their earlier request";
 }
 
-// A look control waiting on its fresh frame: which look, when it was asked
-// for, and the wait's bound.
-interface PendingLook {
-  action: LookSessionControl;
+// A bounded wait to resume the caller request from a fresh view.
+interface PendingLook extends LookFollowUp {
   armedAtMs: number;
   timer: ReturnType<typeof setTimeout>;
-}
-
-// A finished background continuation waiting to be delivered: the request it
-// took over and the answer it produced.
-interface ContinuationDelivery {
-  request: string;
-  answer: string;
+  frameLanded: boolean;
 }
 
 interface OwnedForegroundTask {
@@ -914,17 +939,6 @@ interface SuspendedForegroundTask {
 
 type ForegroundTaskState = OwnedForegroundTask | SuspendedForegroundTask;
 
-// Appended to an announcement turn's control prompt: the turn the session
-// starts on its own when a background continuation finishes while the call is
-// live and nobody is speaking. There is no user utterance behind it, so this
-// note is the whole instruction and the answer rides here rather than in the
-// turn's `content`. Reaches the model only; it is not a user message and never
-// renders as a transcript bubble.
-function buildLiveDeliveryNote(request: string, answer: string): string {
-  const what = describeInterruptedRequest(request);
-  return `The user interrupted you earlier, and in the background you finished ${what}. The call is still live and nobody is speaking, so tell them briefly that it is done and give them the result. Do not re-run any tool calls; the work is already complete, and do not repeat it verbatim if it no longer fits. What you produced was:\n\n${answer}`;
-}
-
 function buildForegroundTaskResumePrompt(request: string): string {
   const task =
     request.length > 0 ? JSON.stringify(request) : "the unfinished task";
@@ -934,9 +948,8 @@ function buildForegroundTaskResumePrompt(request: string): string {
 // Assemble a leg's model-facing control prompt: the base live-voice rules, the
 // screen-reveal and setup-flow teaching (both withheld from the front-door leg,
 // see LIVE_VOICE_SCREEN_REVEAL_TEACHING), plus any pending barge-in merge
-// context, completed-continuation context, and/or the announcement instruction.
-// A turn can carry several (a barge-in follow-up that also has a continuation
-// result waiting); the notes are model-only and never render as user bubbles.
+// context, pending task outcomes, and the announcement instruction. These
+// notes are model-only and never render as user bubbles.
 function buildVoiceControlPrompt(
   turn: ActiveAssistantTurn,
   leg: { frontDoor?: boolean },
@@ -961,8 +974,8 @@ function buildVoiceControlPrompt(
   if (turn.interruptedRequest) {
     prompt = `${prompt}\n\n${buildInterruptionMergeNote(turn.interruptedRequest)}`;
   }
-  if (turn.continuationResult) {
-    prompt = `${prompt}\n\n${buildResurfaceContextNote(turn.continuationResult)}`;
+  if (turn.contextOutcomes.length > 0) {
+    prompt = `${prompt}\n\n${buildResurfaceContextNote(turn.contextOutcomes)}`;
   }
   if (turn.handedOffRequest) {
     prompt = `${prompt}\n\n${buildHandoffAnnouncementNote(turn.handedOffRequest)}`;
@@ -970,32 +983,24 @@ function buildVoiceControlPrompt(
   if (turn.lookFollowUp !== null) {
     prompt = `${prompt}\n\n${lookFollowUpNote(turn.lookFollowUp)}`;
   }
-  if (turn.continuationDelivery) {
-    prompt = `${prompt}\n\n${buildLiveDeliveryNote(
-      turn.continuationDelivery.request,
-      turn.continuationDelivery.answer,
-    )}`;
+  if (turn.taskOutcome !== null) {
+    prompt += `\n\nThis turn is an internal background task update, not new words from the user. ${turn.taskDeliveryContext} Use the latest conversation context to decide what is useful now. For routine progress, findings covered by completed playback, cancelled work, or findings meant only for internal use, output only ${TASK_UPDATE_SILENT_MARKER}. An interrupted announcement or a displayed card does not establish delivery. Otherwise briefly speak the useful outcome or blocker first, before optional tool calls or a visual summary. Do not just announce completion, read raw worker status, or repeat completed actions.`;
+    if (turn.taskOutcome.source === "continuation") {
+      prompt += `\n\n${turn.taskOutcome.message}`;
+    }
   }
   return prompt;
 }
 
-// Delivered into the conversation when a continuation finishes AFTER the voice
-// session ended. There is no next voice turn to fold into, so this lands as a
-// normal turn in the thread — where the user actually goes looking for the
-// work. Framed as a system-style report rather than a user request so the
-// reply reads as "here is what I finished", not a fresh instruction.
-function buildClosedSessionDeliveryPrompt(
-  interruptedRequest: string,
-  answer: string,
-): string {
-  const what = describeInterruptedRequest(interruptedRequest);
-  return `[Background work finished] The voice call ended before the completed result for ${what} could be delivered. Tell the user briefly that it is done and give them the result. Do not re-run any tool calls; the work is already complete. What you produced was:\n\n${answer}`;
+function buildContinuationResult(request: string, answer: string): string {
+  return `[Background work finished] The completed result for ${describeInterruptedRequest(request)} is ready. Give the user the useful findings without re-running the work. Result:\n\n${answer}`;
 }
 
 // A fresh cycle: nothing captured, nothing released, no metrics turn open.
 function createUtteranceCycle(): UtteranceCycle {
   return {
     phase: "pending",
+    preDialBargeInGuard: null,
     released: false,
     assistantTurnStarted: false,
     completed: false,
@@ -1160,6 +1165,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private readonly archiveAudio: LiveVoiceSessionAudioArchiver | null;
   private readonly spawnBackgroundContinuation: LiveVoiceBackgroundContinuationSpawner | null;
   private readonly labelBackgroundContinuation: LiveVoiceContinuationLabeler | null;
+  private readonly judgeBackgroundContinuation: LiveVoiceContinuationJudge | null;
+  // The latest barge-in's interrupting words, resolved when the turn that
+  // carries them dispatches (or null past BARGE_IN_INTERRUPTION_WAIT_MS). The
+  // continuation judge reads it; a newer barge-in settles the older one null.
+  private bargeInInterruption: {
+    detachSeq: number;
+    promise: Promise<string | null>;
+    settle: (words: string | null) => void;
+  } | null = null;
+  // The continuation judge's pending verdict on a foreground task a barge-in
+  // suspended. The resume waits on it, so a task the caller called off is
+  // cleared instead of resumed.
+  private foregroundTaskJudgement: {
+    epoch: number;
+    settled: Promise<void>;
+  } | null = null;
   // Reads the interrupted turn's teardown promise so the barge-in path can wait
   // for it to settle before forking the continuation.
   private readonly getTurnTeardown:
@@ -1184,9 +1205,18 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // continuation completing (before OR after it) can't surface a stale answer.
   private detachSequence = 0;
   private readonly emitMetrics: boolean;
-  private readonly metrics: LiveVoiceMetricsCollector;
+  private readonly metrics: VoiceMetricsCollector;
   private readonly createTurnId: () => string;
   private readonly conversationId: string;
+  private readonly acquireModeSessionResidency?: (
+    conversationId: string,
+  ) => Promise<{
+    coordinator: ConversationModeSessionCoordinator;
+    release: () => void;
+  }>;
+  private releaseModeSessionResidency?: () => void;
+  private cameraModeSessions?: CameraModeSessionProducer;
+  private sightFrameSequence: Promise<void> = Promise.resolve();
   /**
    * Mirrors phase changes to the iOS Live Activity through the platform, for
    * the case the client cannot cover: an app backgrounded long enough for iOS
@@ -1197,6 +1227,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private currentUtterance: UtteranceCycle | null = null;
   private outboundFrames: Promise<void> = Promise.resolve();
   private activeAssistantTurn: ActiveAssistantTurn | null = null;
+  private readonly pendingAssistantStarts = new Set<Promise<void>>();
   private sessionEndMetricsEmitted = false;
   /**
    * Protocol error code of the failure that killed the session, latched by
@@ -1256,6 +1287,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // what echoEnergyEma is for). Raises the base gate in a noisy room so the
   // room itself stops reading as speech.
   private readonly roomNoiseFloor = new RoomNoiseFloor();
+  private readonly inputDiagnostics = new VoiceInputDiagnostics();
+  private readonly microphoneIdleGate: MicrophoneIdleGate;
+  private diagnosticEchoCorrelation: number | null = null;
+  private diagnosticTtsSampleRate: number | null = null;
   private readonly echoBargeInMargin: number;
   private readonly echoEmaHalfLifeMs: number;
   private readonly echoDrainSlackMs: number;
@@ -1294,6 +1329,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // The shared sustained-speech accounting (gap tolerance, duty-cycle
     // ceiling, threshold).
     guard: BargeInGuard;
+    armedAtMs: number;
+    resets: number;
   } | null = null;
   // Estimated wall-clock ms until the client finishes draining the
   // assistant audio sent so far. The server clears the turn right after
@@ -1308,23 +1345,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // Consumed (and cleared) when that turn launches; cleared if the barge-in
   // utterance is discarded, so it can never attach to a later, unrelated turn.
   private pendingInterruptedRequest: string | null = null;
-  // Set when a background continuation finishes the reply a barge-in cut off:
-  // its final answer, folded into the next turn the user starts as context.
-  // Consumed (and cleared) when that turn launches; cleared on a hard stop
-  // (abortDetachedRuns) so a stale result never surfaces later, and cleared by
-  // an announcement that delivers the same answer itself — an announcement the
-  // user cuts short hands it straight back.
-  private pendingContinuationResult: string | null = null;
-  // The same finished continuation, queued for an announcement turn: the
-  // session speaks the result on its own once the call has been quiet for
-  // `continuationAnnounceSilenceMs`. This and `pendingContinuationResult` are
-  // armed together and are two routes for ONE answer — whichever fires first
-  // clears the other, so the user hears it exactly once. An announcement whose
-  // turn fails to start, or whose turn a barge-in cuts short, hands the answer
-  // back to the stash, so a lost delivery costs the announcement, not the
-  // answer.
-  private pendingAnnouncement: ContinuationDelivery | null = null;
-  private announcementTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly taskOutcomes = new VoiceTaskOutcomes();
+  private taskAnnouncementTimer: ReturnType<typeof setTimeout> | null = null;
+  private taskAnnouncementsDeferred = false;
+  private taskOutcomesClosing = false;
   // Host-backed work stays on the parent conversation across barge-ins. An
   // owned task belongs to the tool-capable turn doing the work; a suspended
   // task is waiting for either a merged escalation or a synthetic resume.
@@ -1338,8 +1362,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // A look control sent to a client that declared `lookFrames`, waiting for
   // the fresh frame the client takes for it. The session answers the look on a
   // turn of its own once that frame is in the conversation (see
-  // answerLookWhenFloorIsFree). Cleared when the frame lands, when the wait
-  // runs out, and when the session closes.
+  // answerLookWhenFloorIsFree). Retained through the floor wait so committed
+  // caller clarifications can join the request until the follow-up launches.
   private pendingLook: PendingLook | null = null;
   private lookFollowUpTimer: ReturnType<typeof setTimeout> | null = null;
   // Set when a continuation actually spawns: the request it took over, so the
@@ -1370,10 +1394,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // The ring holds speech parked during the release→turn-start window;
   // protected from silent-chunk eviction until it flushes.
   private vadPreRollHasSpeech = false;
+  private vadPreRollBargeInGuard: BargeInGuard | null = null;
   // Detector turn-end that fired while its speech sat parked in the ring;
   // replayed once the parked speech flushes into the next armed utterance.
   private vadPendingTurnEnd: "silence" | "max-duration" | null = null;
-  private readonly metricsClock: LiveVoiceMetricsClock;
+  private readonly metricsClock: VoiceMetricsClock;
   // Persistent mode: a server-VAD session keeps one streaming transcriber for
   // the whole session when the stream can be sealed per utterance without
   // closing it. Either the provider is finalize-capable (release flushes via
@@ -1406,6 +1431,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private readonly finalizeGraceMs: number;
   // Rotates through the progress fallback phrases across the session's turns.
   private progressPhraseCounter = 0;
+  private modeSessionDeliveryCounter = 0;
   // Progress-only phrasing service. It never makes routing decisions and
   // never emits an answer.
   private readonly progressNarrator: VoiceProgressNarrator | null;
@@ -1416,17 +1442,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // Complete Flux tunables (the constructor schema-parses the partial option
   // once, so every field carries its `liveVoice.flux` schema default).
   private readonly fluxConfig: LiveVoiceFluxConfig;
-  /**
-   * Per-session latch: the provider's committed end-of-turn owns the turn
-   * boundary instead of the silence boundary's front-door hold verdict. Set
-   * when the config flag is on AND the resolved streaming provider declares
-   * `turnDetection: "provider"` in the STT catalog AND the session runs server
-   * VAD. Push-to-talk is excluded deliberately: there the client's release IS
-   * the boundary, and answering while the caller still holds the button is not
-   * turn detection, it is a bug. False leaves every other code path exactly as
-   * it is, with no provider turn detection in the picture.
-   */
-  private providerTurnEndActive = false;
+  // Provider turn starts own hands-free interruption independently of the
+  // end-of-turn setting. Manual sessions keep their client-owned boundaries.
+  private providerTurnStartActive = false;
+  private latestProviderTurnStartIndex: number | null = null;
+
+  private get providerTurnEndActive(): boolean {
+    return this.providerTurnStartActive && this.fluxConfig.turnEnd.enabled;
+  }
   // Wall-clock of the newest above-gate audio chunk, tracked in every
   // server-VAD session. It is the local VAD's speech-stop mark: the one anchor
   // the reported end-of-turn latency is measured from whichever decider
@@ -1464,6 +1487,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     options: LiveVoiceSessionOptions = {},
   ) {
     this.context = context;
+    this.microphoneIdleGate = new MicrophoneIdleGate(
+      context.startFrame.audio.sampleRate,
+    );
     this.resolveTranscriber =
       options.resolveTranscriber ?? defaultResolveStreamingTranscriber;
     this.resolveCredentialReadiness =
@@ -1475,6 +1501,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       options.spawnBackgroundContinuation ?? null;
     this.labelBackgroundContinuation =
       options.labelBackgroundContinuation ?? null;
+    this.judgeBackgroundContinuation =
+      options.judgeBackgroundContinuation ?? null;
     this.getTurnTeardown = options.getTurnTeardown ?? null;
     this.detachTeardownSettleTimeoutMs =
       options.detachTeardownSettleTimeoutMs ??
@@ -1493,11 +1521,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.createTurnId = options.createTurnId ?? randomUUID;
     this.conversationId =
       context.startFrame.conversationId ?? context.sessionId;
+    this.acquireModeSessionResidency = options.acquireModeSessionResidency;
     this.liveActivityReporter =
       options.liveActivityReporter ??
       new LiveActivityReporter(this.conversationId);
     this.metricsClock = options.metricsClock ?? Date.now;
-    this.metrics = new LiveVoiceMetricsCollector({
+    this.metrics = new VoiceMetricsCollector({
       sessionId: context.sessionId,
       conversationId: this.conversationId,
       ...(options.metricsClock ? { clock: options.metricsClock } : {}),
@@ -1611,6 +1640,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // surfaces as a non-recoverable error frame instead of a start rejection.
     this.state = "active";
     this.reachedActive = true;
+    if (this.turnDetector) {
+      this.logInputDiagnostic("voice_input_started");
+    }
     void this.armUtterance().catch(() => {});
     this.metrics.markReady();
     await this.sendFrame({
@@ -1622,8 +1654,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // is a property of the daemon and not of what this client asked for.
       // A client reading it back absent is talking to one that predates it.
       textInput: true,
+      ...(this.acquireModeSessionResidency ? { sightSessions: true } : {}),
       ...(this.audioInput ? {} : { audioInput: false }),
     });
+    this.scheduleTaskAnnouncement();
   }
 
   async handleClientFrame(frame: LiveVoiceClientFrame): Promise<void> {
@@ -1654,8 +1688,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       case "attach_frame":
         this.parkTurnFrame(frame);
         return;
+      case "sight_start":
+        await this.sequenceSightFrame(frame);
+        return;
+      case "sight_end":
+        await this.sequenceSightFrame(frame);
+        return;
       case "sight_frame":
-        this.persistSightFrame(frame);
+        await this.sequenceSightFrame(frame);
         return;
       case "text":
         await this.handleTextTurn(frame);
@@ -1663,6 +1703,35 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
+  private sequenceSightFrame(
+    frame: Extract<
+      LiveVoiceClientFrame,
+      { type: "sight_start" | "sight_end" | "sight_frame" }
+    >,
+  ): Promise<void> {
+    const operation = this.sightFrameSequence.then(async () => {
+      if (this.isClosed || this.state === "failed") {
+        if (frame.type === "sight_frame") {
+          this.reclaimParkedFrame(frame.attachmentId);
+        }
+        return;
+      }
+      switch (frame.type) {
+        case "sight_start":
+          await this.startSightSession(frame.cameraEpoch, frame.source);
+          return;
+        case "sight_end":
+          this.endSightSession(frame.cameraEpoch);
+          return;
+        case "sight_frame":
+          this.persistSightFrame(frame);
+          return;
+      }
+    });
+    this.sightFrameSequence = operation.catch(() => {});
+    return operation;
+  }
+
   /**
    * Run a turn the user typed instead of spoke.
    *
@@ -1769,6 +1838,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    */
   private persistSightFrame(frame: LiveVoiceClientSightFrameFrame): void {
     const receivedAtMs = Date.now();
+    const cameraToken =
+      frame.cameraEpoch === undefined
+        ? undefined
+        : this.cameraModeSessions?.beginFrame(frame.cameraEpoch, frame.source);
+    if (frame.cameraEpoch !== undefined && !cameraToken) {
+      deleteOrphanAttachments([frame.attachmentId]);
+      if (!this.isClosed) {
+        void this.sendFrame({
+          type: "error",
+          code: LiveVoiceProtocolErrorCode.InvalidFrame,
+          message: "That camera run is no longer active.",
+          frameType: "sight_frame",
+          attachmentId: frame.attachmentId,
+          recoverable: true,
+        });
+      }
+      return;
+    }
     // One line per keep, written when the row lands, carrying the whole
     // timeline: the client leg the frame reported, the daemon leg the persist
     // measured, and the distance from the speech onset the frame may have
@@ -1778,11 +1865,29 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.lastSpeechStartedAtMs === null
         ? null
         : receivedAtMs - this.lastSpeechStartedAtMs;
-    void persistAmbientSightFrame(
-      this.conversationId,
-      frame.attachmentId,
-      "voice",
-    ).then((result) => {
+    const settleFrame = (
+      result: LiveVoicePhotoResult,
+      rejection?: unknown,
+    ): void => {
+      if (rejection !== undefined) {
+        log.warn(
+          { err: rejection, attachmentId: frame.attachmentId },
+          "Sight frame persistence rejected unexpectedly",
+        );
+      }
+      try {
+        this.cameraModeSessions?.finishFrame(
+          cameraToken,
+          result.ok && result.messageId
+            ? { messageId: result.messageId, at: receivedAtMs }
+            : undefined,
+        );
+      } catch (err) {
+        log.warn(
+          { err, attachmentId: frame.attachmentId },
+          "Could not record camera session ownership",
+        );
+      }
       log.info(
         {
           attachmentId: frame.attachmentId,
@@ -1815,9 +1920,76 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           recoverable: true,
         });
       }
+    };
+    void persistAmbientSightFrame(
+      this.conversationId,
+      frame.attachmentId,
+      "voice",
+      undefined,
+      undefined,
+      cameraToken?.owner,
+    ).then(
+      (result) => settleFrame(result),
+      (err) => settleFrame({ ok: false }, err),
+    );
+  }
+
+  private async startSightSession(
+    cameraEpoch: number,
+    source: "live" | "ambient" | undefined,
+  ): Promise<void> {
+    let acquiredProducer = false;
+    if (!this.cameraModeSessions && this.acquireModeSessionResidency) {
+      try {
+        const residency = await this.acquireModeSessionResidency(
+          this.conversationId,
+        );
+        if (this.isClosed || this.state === "failed") {
+          residency.release();
+          return;
+        }
+        this.cameraModeSessions = new CameraModeSessionProducer(
+          residency.coordinator,
+          this.context.sessionId,
+        );
+        this.releaseModeSessionResidency = residency.release;
+        acquiredProducer = true;
+      } catch (err) {
+        log.warn({ err, cameraEpoch }, "Could not prepare camera session");
+      }
+    }
+    let handle: ModeSessionSourceHandle | undefined;
+    try {
+      handle = this.cameraModeSessions?.start(cameraEpoch, source ?? "live");
+    } catch (err) {
+      log.warn({ err, cameraEpoch }, "Could not start camera session");
+    }
+    if (!handle && acquiredProducer) {
+      this.cameraModeSessions = undefined;
+      const release = this.releaseModeSessionResidency;
+      this.releaseModeSessionResidency = undefined;
+      release?.();
+    }
+    if (handle || this.isClosed) {
+      return;
+    }
+    void this.sendFrame({
+      type: "error",
+      code: LiveVoiceProtocolErrorCode.InvalidFrame,
+      message: "Could not start that camera run.",
+      frameType: "sight_start",
+      recoverable: true,
     });
   }
 
+  private endSightSession(cameraEpoch: number): void {
+    try {
+      this.cameraModeSessions?.end(cameraEpoch);
+    } catch (err) {
+      log.warn({ err, cameraEpoch }, "Could not end camera session");
+    }
+  }
+
   /**
    * Park a camera frame for the next turn to carry, or give up the parked one.
    *
@@ -1926,6 +2098,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (frame.bargeInMinSpeechMs !== undefined) {
       this.bargeInMinSpeechMs = frame.bargeInMinSpeechMs;
     }
+    this.logInputDiagnostic("voice_input_config_updated");
   }
 
   async handleBinaryAudio(chunk: Uint8Array): Promise<void> {
@@ -1937,12 +2110,31 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
+    try {
+      this.cameraModeSessions?.close(
+        reason === "client_end"
+          ? { status: "completed", endReason: "camera_session_ended" }
+          : { status: "interrupted", endReason: `camera_${reason}` },
+      );
+    } catch (err) {
+      log.warn({ err, reason }, "Could not close camera session");
+    }
+    this.releaseModeSessionResidency?.();
+    this.releaseModeSessionResidency = undefined;
+
+    if (this.turnDetector) {
+      this.logInputDiagnostic("voice_input_closed", {
+        reason,
+        summary: this.inputDiagnostics.flush(),
+      });
+    }
+
     // Recorded first, and independently of `shouldEmitSessionEndMetrics`
     // below: that flag governs the client-facing `metrics` frame, and a
     // failed session (which suppresses the frame) is the one whose end
     // telemetry matters most. Session duration downstream is this row's
     // `recorded_at` minus the started row's, so it must be written before the
-    // teardown below, which awaits a pending continuation and can run long.
+    // teardown below, which waits for the active turn and can run long.
     const failed = this.state === "failed";
     // Only a session that never dispatched a turn gets a silence reason; for
     // every other session the question is meaningless.
@@ -1985,9 +2177,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     const shouldEmitSessionEndMetrics = this.state !== "failed";
     this.state = "closed";
+    this.taskOutcomesClosing = true;
+    this.taskOutcomes.interruptPlayback(Date.now());
+    const turnTeardown = this.getTurnTeardown?.(this.conversationId);
     this.clearForegroundTask("session_closed");
     // Retire the island before the teardown below starts awaiting things. A
-    // close can take a while (a pending continuation is delivered first), and
+    // close can take a while waiting for turn teardown, and
     // an activity left asserting "Speaking…" through it is exactly the stale
     // claim this reporter exists to prevent.
     this.liveActivityReporter.end();
@@ -1998,13 +2193,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // again on its next session, so the staged row and bytes go with the call.
     this.reclaimParkedFrame(this.pendingTurnAttachmentId);
     this.pendingTurnAttachmentId = null;
-    // There is no longer anyone on the call to speak to, so a queued
-    // announcement cannot be spoken — but the answer behind it is finished
-    // work the user asked for, so it takes the same conversation route a
-    // continuation finishing after this point takes. Then the queue is
-    // cleared: the announcement is dead either way.
-    await this.deliverPendingContinuationToConversation();
-    this.clearContinuationAnnouncement();
     this.clearPendingLook();
     this.stopSessionTranscriber();
     // Detached continuations outlive the call. A deliberate `interrupt()`
@@ -2012,6 +2200,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // turn to fold into, a continuation that finishes after this point delivers
     // into the conversation instead (see detachInterruptedTurn).
     await this.cancelAssistantTurn("session_closed");
+    await this.deliverTaskOutcomesToConversation(turnTeardown);
     if (shouldEmitSessionEndMetrics) {
       await this.emitSessionEndMetrics();
     }
@@ -2073,11 +2262,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // in exactly the configuration roles exist for (live voice on flux,
       // global on base deepgram), which reinstates the race this seed
       // prevents.
-      this.setProviderTurnEndActive(
-        this.fluxConfig.turnEnd.enabled &&
-          supportsProviderTurnDetection(
-            sttCatalogKeyForRole(stt, "liveVoice"),
-          ) &&
+      this.latestProviderTurnStartIndex = null;
+      this.setProviderTurnDetectionActive(
+        supportsProviderTurnDetection(sttCatalogKeyForRole(stt, "liveVoice")) &&
           this.turnDetector !== null,
       );
       const transcriber = await this.resolveTranscriber({
@@ -2093,7 +2280,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       if (!transcriber) {
         // No stream answered, so no end-of-turn ever will: the guess above
         // must not outlive the dial that disproved it.
-        this.setProviderTurnEndActive(false);
+        this.setProviderTurnDetectionActive(false);
         return {
           status: "unavailable",
           message: unavailableTranscriberMessage(),
@@ -2107,11 +2294,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // change under a live session, so this normally confirms the guess; it
       // clears it when the dial fell back to another provider or resolved
       // one the config did not name.
-      this.setProviderTurnEndActive(
-        this.fluxConfig.turnEnd.enabled &&
-          supportsProviderTurnDetection(transcriber.providerId) &&
+      const expectedProviderSpeechStart = this.providerTurnStartActive;
+      this.setProviderTurnDetectionActive(
+        supportsProviderTurnDetection(transcriber.providerId) &&
           this.turnDetector !== null,
       );
+      // A non-Flux fallback cannot confirm the onset suppressed during the
+      // dial. Preserve its guard result even if local silence already released.
+      const preDialBargeInGuard = utterance.preDialBargeInGuard;
+      utterance.preDialBargeInGuard = null;
+      if (
+        expectedProviderSpeechStart &&
+        !this.providerTurnStartActive &&
+        utterance.speechRouted &&
+        !utterance.completed
+      ) {
+        this.handleSpeechStart("local", preDialBargeInGuard);
+      }
       if (
         this.turnDetector &&
         (typeof transcriber.finalizeUtterance === "function" ||
@@ -2155,7 +2354,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       }
       // The dial threw, so the pre-dial guess is disproved the same way the
       // unavailable case disproves it: nothing will send an end-of-turn.
-      this.setProviderTurnEndActive(false);
+      this.setProviderTurnDetectionActive(false);
       return {
         status: "error",
         message: `Live voice transcription could not be started: ${errorMessage(
@@ -2194,6 +2393,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (transcriber && this.sharedTranscriber === transcriber) {
       this.sharedTranscriber = null;
       this.sharedTranscriberLanguage = undefined;
+      this.microphoneIdleGate.reset();
     }
   }
 
@@ -2254,6 +2454,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // server_vad capability; manual sessions keep single-utterance semantics
   // (no speculative post-turn transcriber).
   private scheduleRearmAfterTurn(): void {
+    this.scheduleTaskAnnouncement();
     if (!this.turnDetector) {
       return;
     }
@@ -2372,16 +2573,112 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
-    for (const classified of this.classifyVadEnergy(chunk)) {
+    const receivedAtMs = Date.now();
+    const sampleRate = this.context.startFrame.audio.sampleRate;
+    const meanAmplitude = pcm16MeanAmplitude(chunk);
+    const before = {
+      baseThreshold: this.effectiveBaseThreshold(),
+      roomNoiseFloor: this.roomNoiseFloor.floor,
+      echoEnergy: this.echoEnergyEma,
+      echoOnsetLapsed: this.echoOnsetLapsed,
+      echoWindowMs: this.echoWindowTotalAudioMs,
+      echoGuardCarryover: this.echoWindowGuardCarryover,
+      echoReferenceMs: pcm16DurationMs(
+        this.echoReferenceAudio.byteLength,
+        sampleRate,
+      ),
+      playbackRemainingMs: Math.max(
+        0,
+        this.assistantPlaybackTailUntilMs - receivedAtMs,
+      ),
+      playbackEchoPossible: this.isAssistantPlaybackEchoPossible(),
+    };
+    this.diagnosticEchoCorrelation = null;
+    const classifiedChunks = this.classifyVadEnergy(chunk, meanAmplitude);
+    const durations = { speechMs: 0, silenceMs: 0, echoMs: 0 };
+    for (const classified of classifiedChunks) {
+      durations[`${classified.classification}Ms`] += pcm16DurationMs(
+        classified.chunk.byteLength,
+        sampleRate,
+      );
+    }
+    const summary = this.inputDiagnostics.observe({
+      receivedAtMs,
+      chunkMs: pcm16DurationMs(chunk.byteLength, sampleRate),
+      meanAmplitude,
+      ...before,
+      ...durations,
+      echoProbeMs: pcm16DurationMs(
+        this.echoProbeChunks.reduce(
+          (bytes, entry) => bytes + entry.byteLength,
+          0,
+        ),
+        sampleRate,
+      ),
+      echoCorrelation: this.diagnosticEchoCorrelation,
+    });
+    if (summary) {
+      this.logInputDiagnostic("voice_input_window", { summary });
+    }
+
+    for (const classified of classifiedChunks) {
       await this.handleClassifiedVadAudio(detector, classified);
     }
   }
 
+  private logInputDiagnostic(
+    event: string,
+    details: Record<string, unknown> = {},
+  ): void {
+    if (!this.turnDetector) {
+      return;
+    }
+    const turn = this.activeAssistantTurn;
+    const task = this.foregroundTaskState;
+    log.info(
+      {
+        event,
+        sessionId: this.context.sessionId,
+        conversationId: this.conversationId,
+        speechGeneration: this.vadSpeechGeneration,
+        inputTurnId: this.currentUtterance?.turnId ?? null,
+        assistantTurnId: turn?.turnId ?? null,
+        assistantCompleted: turn?.assistantCompleted ?? null,
+        ttsAudioStarted: turn?.ttsAudioStarted ?? false,
+        foregroundTaskPhase: task?.phase ?? null,
+        hostToolStarted: task?.hostToolStarted ?? null,
+        inputSampleRate: this.context.startFrame.audio.sampleRate,
+        ttsSampleRate: this.diagnosticTtsSampleRate,
+        configuredThreshold:
+          this.speechEnergyThreshold ?? DEFAULT_SPEECH_ENERGY_THRESHOLD,
+        effectiveThreshold: this.effectiveBaseThreshold(),
+        roomNoiseFloor: this.roomNoiseFloor.floor,
+        noiseFloorMargin: this.noiseFloorMargin,
+        echoMargin: this.echoBargeInMargin,
+        echoEnergy: this.echoEnergyEma,
+        echoOnsetLapsed: this.echoOnsetLapsed,
+        playbackRemainingMs: Math.max(
+          0,
+          this.assistantPlaybackTailUntilMs - Date.now(),
+        ),
+        echoDrainSlackMs: this.echoDrainSlackMs,
+        bargeInMinSpeechMs: this.bargeInMinSpeechMs,
+        microphoneGateClosed:
+          this.providerTurnEndActive && this.microphoneIdleGate.closed,
+        ...details,
+      },
+      "Live voice input diagnostics",
+    );
+  }
+
   private async handleClassifiedVadAudio(
     detector: MediaTurnDetector,
     classified: VadClassifiedChunk,
   ): Promise<void> {
-    const { chunk, classification: energyClassification } = classified;
+    const { classification: energyClassification } = classified;
+    let { chunk } = classified;
+    const inputCycle = this.currentUtterance;
+    this.trackPreDialBargeInGuard(inputCycle, classified);
     const hasSpeech = energyClassification === "speech";
     detector.onMediaChunk(hasSpeech);
     this.trackBargeInGuard(energyClassification, chunk);
@@ -2389,11 +2686,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.localSpeechStopAtMs = Date.now();
     }
 
-    // Playback echo is neither user audio nor useful pre-roll. Dropping it
-    // prevents the assistant's reply from reaching transcription as a ghost
-    // follow-up turn.
+    // Flux needs elapsed audio through pauses. Confirmed playback echo keeps
+    // its duration but carries no speaker content into transcription.
     if (energyClassification === "echo") {
-      return;
+      if (!this.providerTurnEndActive) {
+        return;
+      }
+      chunk = Buffer.alloc(chunk.byteLength);
     }
     // Measured past the echo gate, so a greeting heard through the speaker
     // cannot stand in for the user on a silent close.
@@ -2402,11 +2701,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.peakChunkAmplitude = meanAmplitude;
     }
 
-    // Idle mic: hold silent chunks in the bounded pre-roll instead of
-    // collecting or streaming them; flushed on speech onset so the
-    // transcriber still gets leading context ahead of the first syllable.
-    if (!hasSpeech && !detector.isActive) {
-      this.pushVadPreRoll(chunk, false);
+    if (this.providerTurnEndActive) {
+      const wasClosed = this.microphoneIdleGate.closed;
+      chunk = this.microphoneIdleGate.process(chunk, hasSpeech);
+      if (wasClosed !== this.microphoneIdleGate.closed) {
+        this.logInputDiagnostic("voice_input_microphone_gate_changed");
+      }
+      if (chunk.byteLength === 0) {
+        return;
+      }
+    }
+
+    // Locally endpointed streams keep idle audio in pre-roll.
+    if (!hasSpeech && !detector.isActive && !this.providerTurnEndActive) {
+      this.pushVadPreRoll(chunk, "silence");
       return;
     }
 
@@ -2437,7 +2745,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // keeps its old-language stream and the language change applies from
       // the following utterance.
       utterance.finalTranscriptSegments.length === 0 &&
-      utterance.latestPartialText === null &&
+      (utterance.latestPartialText?.trim() ?? "").length === 0 &&
       this.sharedStreamLanguageIsStale()
     ) {
       this.retireSharedTranscriberForRedial(sharedForLanguage);
@@ -2448,13 +2756,17 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (utterance.released || utterance.completed) {
       // Parked speech makes silent chunks arm-worthy too: the parked
       // utterance must flush without requiring more speech.
-      if (!hasSpeech && !this.vadPreRollHasSpeech) {
+      if (
+        !hasSpeech &&
+        !this.vadPreRollHasSpeech &&
+        !this.providerTurnEndActive
+      ) {
         return;
       }
       if (!this.canArmNextUtterance(utterance)) {
         // Speech in the release→turn-start window: hold it in the pre-roll
         // ring so it flushes into the next utterance once it arms.
-        this.pushVadPreRoll(chunk, hasSpeech);
+        this.pushVadPreRoll(chunk, energyClassification);
         return;
       }
       // Sets currentUtterance synchronously; the transcriber resolves async
@@ -2466,6 +2778,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       }
     }
 
+    if (utterance !== inputCycle) {
+      this.trackPreDialBargeInGuard(utterance, classified);
+    }
+
     // Speech is now reaching the cycle, either in this chunk or parked in
     // the pre-roll about to flush; read the flag before takeVadPreRoll
     // resets it.
@@ -2489,8 +2805,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * onset is neither learned as echo nor lost. Once seeded, the EMA follows
    * confirmed echo while speech above the learned margin remains frozen out.
    */
-  private classifyVadEnergy(chunk: Buffer): VadClassifiedChunk[] {
-    const meanAmplitude = pcm16MeanAmplitude(chunk);
+  private classifyVadEnergy(
+    chunk: Buffer,
+    meanAmplitude: number,
+  ): VadClassifiedChunk[] {
     const chunkMs = pcm16DurationMs(
       chunk.byteLength,
       this.context.startFrame.audio.sampleRate,
@@ -2612,12 +2930,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       chunk.byteLength,
       Math.ceil((sampleRate * ECHO_CORRELATION_PROBE_MS * 2) / 1_000),
     );
-    return (
-      pcm16MaxNormalizedCorrelation(
-        chunk.subarray(0, probeByteLength),
-        this.echoReferenceAudio,
-      ) >= ECHO_CORRELATION_THRESHOLD
+    const correlation = pcm16MaxNormalizedCorrelation(
+      chunk.subarray(0, probeByteLength),
+      this.echoReferenceAudio,
     );
+    this.diagnosticEchoCorrelation = correlation;
+    return correlation >= ECHO_CORRELATION_THRESHOLD;
   }
 
   private updateEchoEnergy(meanAmplitude: number, chunkMs: number): void {
@@ -2682,6 +3000,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private appendEchoReference(chunk: LiveVoiceTtsAudioChunk): void {
+    this.diagnosticTtsSampleRate = chunk.sampleRate ?? null;
     if (
       chunk.contentType.split(";", 1)[0]?.trim().toLowerCase() !==
         "audio/pcm" ||
@@ -2704,7 +3023,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     utterance: UtteranceCycle,
     chunk: Buffer,
   ): Promise<void> {
-    this.collectUserAudio(utterance, chunk);
+    // Continuous idle input belongs to the STT stream, not an unbounded
+    // recording of the room before the caller starts a request.
+    if (utterance.speechRouted) {
+      this.collectUserAudio(utterance, chunk);
+    }
     if (this.vadSpeechStartPending) {
       this.vadSpeechStartPending = false;
       this.markSpeechStart(utterance);
@@ -2724,7 +3047,21 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     return utterance.completed || utterance.assistantTurnStarted;
   }
 
-  private pushVadPreRoll(chunk: Buffer, hasSpeech: boolean): void {
+  private pushVadPreRoll(
+    chunk: Buffer,
+    classification: VadEnergyClassification,
+  ): void {
+    const hasSpeech = classification === "speech";
+    if (hasSpeech && !this.vadPreRollBargeInGuard) {
+      this.vadPreRollBargeInGuard = createBargeInGuard(this.bargeInMinSpeechMs);
+    }
+    this.vadPreRollBargeInGuard?.track(
+      classification,
+      pcm16DurationMs(
+        chunk.byteLength,
+        this.context.startFrame.audio.sampleRate,
+      ),
+    );
     // A full ring never lets idle silence evict parked speech.
     if (
       !hasSpeech &&
@@ -2744,6 +3081,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
   private takeVadPreRoll(): Buffer[] {
     this.vadPreRollHasSpeech = false;
+    this.vadPreRollBargeInGuard = null;
     return this.vadPreRollChunks.splice(0);
   }
 
@@ -2753,11 +3091,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // Read before takeVadPreRoll resets it: a ring holding parked speech
     // makes this cycle speech-bearing, a silence-only ring does not.
     const preRollHadSpeech = this.vadPreRollHasSpeech;
+    const preRollBargeInGuard = this.vadPreRollBargeInGuard;
     for (const chunk of this.takeVadPreRoll()) {
       this.collectUserAudio(utterance, chunk);
       this.bufferPendingUtteranceAudio(utterance, chunk);
     }
     if (preRollHadSpeech) {
+      utterance.preDialBargeInGuard = preRollBargeInGuard;
       utterance.speechRouted = true;
       this.detectedSpeech = true;
     }
@@ -2783,10 +3123,19 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     chunk: Buffer,
   ): Promise<void> {
     try {
-      utterance.transcriber?.sendAudio(
-        chunk,
-        this.context.startFrame.audio.mimeType,
-      );
+      if (utterance.transcriber) {
+        utterance.transcriber.sendAudio(
+          chunk,
+          this.context.startFrame.audio.mimeType,
+        );
+        this.inputDiagnostics.recordSttSubmission(
+          Date.now(),
+          pcm16DurationMs(
+            chunk.byteLength,
+            this.context.startFrame.audio.sampleRate,
+          ),
+        );
+      }
       await this.drainOutboundFrames();
     } catch (err) {
       await this.sendFrame({
@@ -2810,15 +3159,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
-  // VAD speech onset. Contract: speech_started tells the client to flush
-  // tail playback immediately; barge-in then cancels any in-flight,
-  // non-finalized turn — including a pre-TTS "thinking" turn whose reply is
-  // still being generated, so a user can cut in before the assistant starts
-  // talking (JARVIS-1266). Speaking over a thinking or audibly speaking turn
-  // is deferred behind the same sustained-speech guard, so a cough or noise
-  // blip cannot kill an unspoken reply or clip a spoken one; sustained speech
-  // aborts the turn. Onset while listening keeps the instant speech_started
-  // (turn-taking latency is untouched).
+  // Local onset tracks audio routing and silence-boundary freshness even
+  // when the provider owns the decision to interrupt playback.
   private handleVadSpeechStart(): void {
     if (this.isClosed || this.state === "failed") {
       return;
@@ -2826,7 +3168,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     this.vadSpeechStartPending = true;
     // Speech resumed: an endpoint decision still in flight is stale (the
-    // generation bump defers it), and a pending hold replay is moot — the
+    // generation bump defers it), and a pending hold replay is moot: the
     // utterance keeps accumulating and the detector fires a fresh turn-end.
     this.vadSpeechGeneration += 1;
     this.clearEndpointExtensionTimer();
@@ -2834,9 +3176,18 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // spoke through. The next silence boundary arms a fresh one.
     this.clearProviderTurnEndTimer();
 
+    if (!this.providerTurnStartActive) {
+      this.handleSpeechStart("local");
+    }
+  }
+
+  private handleSpeechStart(
+    source: "local" | "provider",
+    preDialGuard: BargeInGuard | null = null,
+  ): void {
     // Speech resumed while a speculative leg was awaiting its verdict: the
     // pause was mid-thought after all. Discard silently (no frames were ever
-    // sent for it) and let the utterance keep accumulating — this is the
+    // sent for it) and let the utterance keep accumulating. This is the
     // hold outcome decided by the caller's own voice instead of the model.
     const speculative = this.activeAssistantTurn;
     if (speculative?.speculativePending) {
@@ -2849,20 +3200,37 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // assistant starts talking.
     const bargeableTurn = turn && !turn.finalized ? turn : null;
     // The client can still be draining audible playback after tts_done
-    // (the turn is already cleared server-side) — that tail deserves the
-    // same guard, or a noise blip clips the reply's last words.
+    // (the turn is already cleared server-side). Local onset still needs
+    // the guard, or a noise blip clips the reply's last words.
     const drainingPlayback = this.isAssistantPlaybackEchoPossible();
 
-    if ((bargeableTurn || drainingPlayback) && this.bargeInMinSpeechMs > 0) {
-      // Onset audio keeps flowing into the cycle/pre-roll while the guard
-      // accumulates (trackBargeInGuard), so no speech is lost either way.
-      this.pendingBargeIn = {
-        turn: bargeableTurn,
-        guard: createBargeInGuard(this.bargeInMinSpeechMs),
-      };
-      return;
+    if (
+      source === "local" &&
+      (bargeableTurn || drainingPlayback) &&
+      this.bargeInMinSpeechMs > 0
+    ) {
+      const guard = preDialGuard ?? createBargeInGuard(this.bargeInMinSpeechMs);
+      if (!guard.fired) {
+        // A released pre-dial run below the threshold has already expired.
+        if (preDialGuard && this.currentUtterance?.released) {
+          return;
+        }
+        this.pendingBargeIn = {
+          turn: bargeableTurn,
+          guard,
+          armedAtMs: Date.now(),
+          resets: 0,
+        };
+        this.logInputDiagnostic("voice_input_barge_in_armed");
+        return;
+      }
     }
 
+    this.logInputDiagnostic("voice_input_speech_started", {
+      source,
+      interruptsTurn: bargeableTurn !== null,
+      trace: this.inputDiagnostics.snapshot(Date.now()),
+    });
     this.pendingBargeIn = null;
     this.assistantPlaybackTailUntilMs = 0;
     this.sendSpeechStarted();
@@ -2871,11 +3239,36 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
+  private trackPreDialBargeInGuard(
+    utterance: UtteranceCycle | null,
+    { chunk, classification }: VadClassifiedChunk,
+  ): void {
+    if (
+      !this.providerTurnStartActive ||
+      utterance?.phase !== "pending" ||
+      utterance.released ||
+      utterance.transcriber !== null
+    ) {
+      return;
+    }
+    const guard = (utterance.preDialBargeInGuard ??= createBargeInGuard(
+      this.bargeInMinSpeechMs,
+    ));
+    guard.track(
+      classification,
+      pcm16DurationMs(
+        chunk.byteLength,
+        this.context.startFrame.audio.sampleRate,
+      ),
+    );
+  }
+
   /**
    * Tell the client the caller started speaking, and remember when, so a
    * camera frame that follows can be logged against the onset it answers.
    */
   private sendSpeechStarted(): void {
+    this.taskOutcomes.interruptPlayback(Date.now());
     this.lastSpeechStartedAtMs = Date.now();
     void this.sendFrame({ type: "speech_started" });
   }
@@ -2899,6 +3292,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     );
     const step = pending.guard.track(classification, chunkMs);
     if (step === "reset") {
+      pending.resets += 1;
       if (this.echoWindowGuardCarryover) {
         this.echoWindowGuardCarryover = false;
         this.echoEnergyEma = 0;
@@ -2909,6 +3303,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (step !== "fired") {
       return;
     }
+    this.logInputDiagnostic("voice_input_barge_in_fired", {
+      armedAtMs: pending.armedAtMs,
+      guardResets: pending.resets,
+      accumulatedSpeechMs: pending.guard.speechMs,
+      trace: this.inputDiagnostics.snapshot(Date.now()),
+    });
     this.pendingBargeIn = null;
     this.assistantPlaybackTailUntilMs = 0;
     this.sendSpeechStarted();
@@ -2919,6 +3319,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private bargeIn(turn: ActiveAssistantTurn): void {
+    this.taskOutcomes.interruptPlayback(Date.now());
     // Abort synchronously so no tts_audio frame can follow turn_cancelled,
     // and settle the cancelled turn's metrics so the next utterance's marks
     // do not collide with it in the collector. turn_cancelled flushes
@@ -2933,38 +3334,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       .trim();
     this.pendingInterruptedRequest =
       interruptedRequest.length > 0 ? interruptedRequest : null;
-    // A fresh interruption supersedes every earlier detached run, not just its
-    // stashed result: abort still-running continuations (and skip pending
-    // detaches) before this barge-in's own continuation can launch, so two
-    // full-ability background writers never share the workspace. The stashed
-    // result is dropped with them so the barge-in follow-up (or any later)
-    // turn can't consume an older answer before this barge-in's own
-    // continuation completes. This barge-in's detach snapshots the stop
-    // generation AFTER this bump (below), so it is unaffected. The abort is
-    // signal-level, with the same accepted residual as the foreground-wins
-    // gate (see the tool_use_start handler): a tool call already executing in
-    // the superseded run is not awaited. The replacement's detach still waits
-    // out the interrupted TURN's teardown before forking, which bounds the
-    // overlap to that one abandoned call.
+    // Supersede running continuations before starting another writer. Finished
+    // outcomes stay in the delivery queue. Signal cancellation does not await
+    // a tool call already executing in the superseded run.
     this.abortDetachedRuns({ reason: "superseded_by_new_barge_in" });
-    // An announcement turn is the one interruption with nothing to continue:
-    // the work is already finished, which is why detachInterruptedTurn skips it
-    // as `announcement_turn`. The analog of "the interrupted work survives" is
-    // therefore the stash — the answer goes back into it so the user's next real
-    // turn still carries it, and the announcement (cut short, at best partly
-    // spoken) is not the delivery it was supposed to be. The restore sits after
-    // the abort above, which clears the stash, so nothing in this sequence
-    // re-drops it. Only a barge-in restores: interrupt/close/a superseding new
-    // continuation are resets the user asked for, and their answer stays gone.
-    if (turn.continuationDelivery !== null) {
-      this.pendingContinuationResult = turn.continuationDelivery.answer;
-    }
     // Order this barge-in among concurrent detaches SYNCHRONOUSLY, in barge
     // order — the actual detach runs after an async teardown chain, and those
     // chains can interleave, so bumping there could assign sequences out of
     // order and let an older continuation re-stash. A higher sequence here
     // immediately invalidates every earlier still-running continuation.
     const detachSeq = ++this.detachSequence;
+    this.openBargeInInterruption(detachSeq);
+    if (keepForegroundTaskOnParent) {
+      this.judgeSuspendedForegroundTask(detachSeq);
+    }
     this.clearFillerTimers(turn);
     // Tagged reason: provider catch-sites classify untagged caller aborts as
     // retryable transport failures (ERROR log + futile retry against the
@@ -3052,14 +3435,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
     const skipReason = this.isClosed
       ? "session_closed"
-      : // Barging in over an announcement means the user is answering it, not
-        // asking for it to be finished in the background — there is no pending
-        // request behind an announcement turn to continue. Its answer is
-        // already finished, so bargeIn returns it to the stash instead.
-        turn.continuationDelivery !== null
+      : // Announcement work is finished; only its delivery remains pending.
+        turn.taskOutcome !== null
         ? "announcement_turn"
-        : // Nor over the answer to a look: there is no request behind it
-          // either, and the user talking over it is them moving on.
+        : // Look follow-ups use a transient view; a barge-in leaves any
+          // unfinished host work with the parent conversation.
           turn.lookFollowUp !== null
           ? "look_follow_up"
           : // The model already finished generating (barge-in during TTS playback
@@ -3100,6 +3480,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       interruptedRequest,
       AbortSignal.any([controller.signal, labelAbort.signal]),
     );
+    // Judge, in parallel with the teardown wait and the label, whether the
+    // caller's interruption still wants this request finished.
+    const judgementPromise = this.requestContinuationJudgement(
+      interruptedRequest,
+      detachSeq,
+      AbortSignal.any([controller.signal, labelAbort.signal]),
+    );
     void (async () => {
       try {
         // Wait for the interrupted turn's teardown to settle its partial into
@@ -3141,6 +3528,29 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             return;
           }
         }
+        const judgement = await judgementPromise;
+        if (judgement !== null && judgement.outcome !== "unavailable") {
+          log.info(
+            {
+              turnId: turn.turnId,
+              outcome: judgement.outcome,
+              noul: judgement.noul,
+              latencyMs: judgement.latencyMs,
+            },
+            "Voice duplex continuation judged",
+          );
+        }
+        if (judgement !== null && !judgement.keep) {
+          log.info(
+            {
+              turnId: turn.turnId,
+              skipReason: "caller_moved_on",
+              waitedMs: Date.now() - detachStartedAtMs,
+            },
+            "Voice duplex continuation skipped",
+          );
+          return;
+        }
         // A closed session is NOT a reason to skip: the work outlives the
         // call, and its result is delivered into the conversation below.
         // Only an explicit invalidation (stop/interrupt/supersede) stops it.
@@ -3192,48 +3602,40 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           !controller.signal.aborted &&
           this.detachStopGeneration === stopGeneration &&
           detachSeq === this.detachSequence;
-        // Two destinations, decided by whether a next voice turn still exists.
-        // Live session: stash for the next turn the user starts, AND queue an
-        // announcement that speaks it into audible silence if the user says
-        // nothing — the two are routes for one answer and cancel each other,
-        // so it is delivered exactly once. Session closed: there is no next
-        // turn and nobody to speak to, so deliver into the conversation — the
-        // thread is exactly where the user goes looking for the work.
-        const deliverToConversation =
-          notInvalidated && this.isClosed && answer.length > 0;
-        if (notInvalidated && !this.isClosed) {
-          this.pendingContinuationResult = answer.length > 0 ? answer : null;
-          if (answer.length > 0) {
-            this.pendingAnnouncement = { request: interruptedRequest, answer };
-            this.scheduleContinuationAnnouncement();
+        let accepted = false;
+        if (notInvalidated && answer.length > 0) {
+          const outcome: VoiceTaskOutcome = {
+            taskId: `voice-continuation:${turn.turnId}`,
+            message: buildContinuationResult(interruptedRequest, answer),
+            metadata: {},
+            source: "continuation",
+          };
+          accepted = this.receiveTaskOutcome(outcome);
+          if (!accepted) {
+            await Promise.allSettled(this.pendingAssistantStarts);
+            await this.getTurnTeardown?.(this.conversationId);
+            const { injectMessageIntoParent } =
+              await import("../subagent/notify.js");
+            injectMessageIntoParent(
+              this.conversationId,
+              outcome.message,
+              outcome.metadata,
+              { bypassLiveVoice: true },
+            );
           }
         }
-        if (deliverToConversation) {
-          const { injectMessageIntoParent } =
-            await import("../subagent/notify.js");
-          injectMessageIntoParent(
-            this.conversationId,
-            buildClosedSessionDeliveryPrompt(interruptedRequest, answer),
-          );
-        }
         log.info(
           {
             turnId: turn.turnId,
             ranMs: Date.now() - detachStartedAtMs,
             resultChars: answer.length,
-            // Where the answer went. "stashed" = queued for the next voice
-            // turn and for an announcement into silence, whichever comes first
-            // (the announcement logs "announced" when it wins);
-            // "conversation" = the call had ended, so it was delivered into the
-            // thread; "dropped" = a stop/interrupt or a newer barge-in landed
-            // while it ran.
             resultDestination: !notInvalidated
               ? "dropped"
               : answer.length === 0
                 ? "empty"
-                : this.isClosed
-                  ? "conversation"
-                  : "stashed",
+                : accepted
+                  ? "queued"
+                  : "conversation",
           },
           "Voice duplex continuation finished",
         );
@@ -3259,6 +3661,105 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     })();
   }
 
+  // Opens the wait for this barge-in's interrupting words, settling any older
+  // barge-in's wait with null: its continuation was already superseded.
+  private openBargeInInterruption(detachSeq: number): void {
+    this.bargeInInterruption?.settle(null);
+    let settle!: (words: string | null) => void;
+    const promise = new Promise<string | null>((resolve) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        finish(null);
+      }, BARGE_IN_INTERRUPTION_WAIT_MS);
+      const finish = (words: string | null): void => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        if (this.bargeInInterruption?.detachSeq === detachSeq) {
+          this.bargeInInterruption = null;
+        }
+        resolve(words);
+      };
+      settle = finish;
+    });
+    this.bargeInInterruption = { detachSeq, promise, settle };
+  }
+
+  // Asks the continuation judge whether the foreground task this barge-in
+  // suspended should still be finished. A drop clears the task, so the
+  // automatic resume never fires; a keep leaves the resume as it was. The
+  // interrupting turn may claim the task first, in which case it owns the
+  // outcome and the verdict is only logged.
+  private judgeSuspendedForegroundTask(detachSeq: number): void {
+    const task = this.foregroundTaskState;
+    if (task?.phase !== "suspended" || !this.judgeBackgroundContinuation) {
+      return;
+    }
+    const epoch = task.epoch;
+    const entry: { epoch: number; settled: Promise<void> } = {
+      epoch,
+      settled: Promise.resolve(),
+    };
+    entry.settled = this.requestContinuationJudgement(
+      task.request,
+      detachSeq,
+      new AbortController().signal,
+    ).then((judgement) => {
+      if (this.foregroundTaskJudgement === entry) {
+        this.foregroundTaskJudgement = null;
+      }
+      if (judgement === null || judgement.outcome === "unavailable") {
+        return;
+      }
+      log.info(
+        {
+          epoch,
+          outcome: judgement.outcome,
+          noul: judgement.noul,
+          latencyMs: judgement.latencyMs,
+        },
+        "Voice foreground task judged",
+      );
+      const current = this.foregroundTaskState;
+      if (
+        !judgement.keep &&
+        current?.phase === "suspended" &&
+        current.epoch === epoch
+      ) {
+        this.clearForegroundTask("caller_moved_on");
+      }
+    });
+    this.foregroundTaskJudgement = entry;
+  }
+
+  // The continuation judge's verdict for one barge-in, or null when no judge
+  // is wired. The judge only waits on the interruption when it can run.
+  private async requestContinuationJudgement(
+    interruptedRequest: string,
+    detachSeq: number,
+    signal: AbortSignal,
+  ): Promise<ContinuationJudgement | null> {
+    const judge = this.judgeBackgroundContinuation;
+    if (!judge) {
+      return null;
+    }
+    const waiter = this.bargeInInterruption;
+    const interruption =
+      waiter?.detachSeq === detachSeq ? waiter.promise : Promise.resolve(null);
+    try {
+      return await judge({
+        parentConversationId: this.conversationId,
+        interruptedRequest,
+        interruption,
+        signal,
+      });
+    } catch {
+      return null;
+    }
+  }
+
   // Resolves the model-phrased label for a continuation, or null when there
   // is nothing to name it from, no labeler is wired, or the call missed
   // (timeout, abort, provider error, model declined). Never rejects: the
@@ -3294,7 +3795,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     const currentRequest = turn.utterance.finalTranscriptSegments
       .join(" ")
       .trim();
-    return currentRequest || turn.interruptedRequest || "";
+    return (
+      currentRequest ||
+      turn.lookFollowUp?.callerUtterance ||
+      turn.interruptedRequest ||
+      ""
+    );
   }
 
   private createForegroundTaskOwnership(
@@ -3315,6 +3821,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
   private noteEscalatedForegroundTask(turn: ActiveAssistantTurn): void {
     if (
+      turn.taskOutcome !== null ||
       this.activeAssistantTurn?.token !== turn.token ||
       turn.discardRequested ||
       turn.abortController.signal.aborted
@@ -3339,6 +3846,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     turn: ActiveAssistantTurn,
     effectiveToolName: string,
   ): void {
+    if (turn.taskOutcome !== null) {
+      return;
+    }
     const current = this.foregroundTaskState;
     if (current?.phase === "owned" && current.ownerToken === turn.token) {
       if (!current.hostToolStarted) {
@@ -3608,6 +4118,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private async resumeForegroundTask(
     task: SuspendedForegroundTask,
   ): Promise<void> {
+    // A verdict still out on this task decides whether it resumes at all.
+    const judgement = this.foregroundTaskJudgement;
+    if (judgement?.epoch === task.epoch) {
+      await judgement.settled;
+    }
     const current = this.foregroundTaskState;
     if (
       current?.phase !== "suspended" ||
@@ -3635,178 +4150,139 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   // Abort every background continuation this session started and drop its
-  // handle. Called on a hard stop (client interrupt / session close), when a
-  // newer barge-in supersedes the detached runs, and on a foreground-wins
-  // abort; the continuation's own `.finally` removes it from the set too.
-  // `keepPendingResult` is the foreground-wins variant: the foreground turn is
-  // claiming the workspace, so running continuations must die (and pending
-  // detaches must be skipped), but an already-completed continuation's stashed
-  // answer stays — it cannot race anything, and the next turn's "use only if
-  // relevant" framing makes a stale one harmless.
+  // handle. Finished outcomes have independent delivery state.
   private abortDetachedRuns(opts?: {
-    keepPendingResult?: boolean;
-    // Why the runs are being invalidated, for the log line below. Every
-    // caller passes one: an unexplained dead continuation is the single
-    // hardest thing to debug about this feature.
     reason?: string;
-    // The foreground tool whose start tripped the contention gate, if any.
     toolName?: string;
   }): void {
     const aborted = this.detachControllers.size;
-    const hadPendingResult = this.pendingContinuationResult !== null;
-    if (aborted > 0 || hadPendingResult) {
+    if (aborted > 0) {
       log.debug(
         {
           conversationId: this.conversationId,
           reason: opts?.reason ?? "unspecified",
           ...(opts?.toolName ? { toolName: opts.toolName } : {}),
           abortedRuns: aborted,
-          droppedPendingResult: hadPendingResult && !opts?.keepPendingResult,
         },
         "Voice duplex continuations invalidated",
       );
     }
-    // Bump the generation so a barge-in whose async teardown is still in flight
-    // (its detach not yet spawned) sees the stop and skips the continuation.
     this.detachStopGeneration += 1;
     for (const controller of this.detachControllers) {
       controller.abort();
     }
     this.detachControllers.clear();
-    // A hard stop also drops any completed continuation's result still waiting
-    // to fold into the next turn, so it can't surface after the user reset.
-    if (!opts?.keepPendingResult) {
-      this.pendingContinuationResult = null;
+  }
+
+  receiveSubagentNotification(
+    notification: SubagentParentNotification,
+  ): boolean {
+    return this.receiveTaskOutcome({ ...notification, source: "subagent" });
+  }
+
+  private receiveTaskOutcome(notification: VoiceTaskOutcome): boolean {
+    if (this.isClosed && this.taskOutcomesClosing) {
+      this.taskOutcomes.enqueue(notification);
+      return true;
+    }
+    if (this.isClosed || this.state === "failed" || !this.startVoiceTurn) {
+      return false;
     }
-    // The announcement dies either way: even the foreground-wins variant (which
-    // keeps the stash) has a foreground turn claiming the floor, so speaking up
-    // on our own is exactly what must not happen.
-    this.clearContinuationAnnouncement();
+    this.taskOutcomes.acknowledgePlayback(Date.now());
+    this.taskOutcomes.enqueue(notification);
+    this.taskAnnouncementsDeferred = false;
+    this.scheduleTaskAnnouncement();
+    return true;
   }
 
-  private clearContinuationAnnouncement(): void {
-    this.pendingAnnouncement = null;
-    if (this.announcementTimer) {
-      clearTimeout(this.announcementTimer);
-      this.announcementTimer = null;
+  private clearTaskAnnouncementTimer(): void {
+    if (this.taskAnnouncementTimer !== null) {
+      clearTimeout(this.taskAnnouncementTimer);
+      this.taskAnnouncementTimer = null;
     }
   }
 
-  /**
-   * Hang-up delivery for a continuation that already finished: the call is
-   * ending, so neither route that was armed for its answer can still run — the
-   * announcement has nobody to speak to and the stash has no next voice turn to
-   * fold into. Deliver it into the conversation instead, exactly as a
-   * continuation finishing after the close does, because that thread is where
-   * the user goes looking for the work ("barge in, hear the answer, close the
-   * room, go look for the result").
-   *
-   * Best-effort and consume-once: the fields are emptied whether or not the
-   * injection lands, so a close cannot deliver twice.
-   */
-  private async deliverPendingContinuationToConversation(): Promise<void> {
-    const activeTurn = this.activeAssistantTurn;
-    const activeAnnouncement = activeTurn?.continuationDelivery ?? null;
-    const announcement = this.pendingAnnouncement ?? activeAnnouncement;
-    const answer = announcement?.answer ?? this.pendingContinuationResult;
-    const request = announcement?.request ?? "";
-    this.pendingAnnouncement = null;
-    this.pendingContinuationResult = null;
-    if (activeTurn !== null) {
-      activeTurn.continuationDelivery = null;
-    }
-    if (answer === null || answer.length === 0) {
+  private scheduleTaskAnnouncement(): void {
+    this.taskOutcomes.acknowledgePlayback(Date.now());
+    if (
+      !this.taskOutcomes.hasPending ||
+      this.taskAnnouncementsDeferred ||
+      this.state === "initializing" ||
+      this.isClosed ||
+      this.state === "failed" ||
+      this.activeAssistantTurn !== null
+    ) {
+      this.clearTaskAnnouncementTimer();
+      return;
+    }
+    this.taskAnnouncementTimer = this.scheduleFloorCheck(
+      this.taskAnnouncementTimer,
+      this.continuationAnnounceSilenceMs,
+      (blockedBy) => {
+        this.taskAnnouncementTimer = null;
+        this.taskOutcomes.acknowledgePlayback(Date.now());
+        if (blockedBy === null) {
+          void this.announceTaskOutcome();
+        } else if (
+          blockedBy !== "turn_active" &&
+          blockedBy !== "session_unavailable"
+        ) {
+          this.scheduleTaskAnnouncement();
+        }
+      },
+    );
+  }
+
+  private async announceTaskOutcome(): Promise<void> {
+    const notification = this.taskOutcomes.next();
+    if (notification === undefined) {
       return;
     }
+    let started = false;
     try {
-      const { injectMessageIntoParent } = await import("../subagent/notify.js");
-      injectMessageIntoParent(
-        this.conversationId,
-        buildClosedSessionDeliveryPrompt(request, answer),
-      );
-      log.info(
+      started = await this.launchAssistantTurn(
+        createSyntheticUtterance(),
+        notification.source === "continuation"
+          ? CONTINUATION_DELIVERY_CONTENT
+          : notification.message,
         {
-          conversationId: this.conversationId,
-          resultChars: answer.length,
-          resultDestination: "conversation",
+          taskOutcome: notification,
+          hiddenPrompt: true,
+          initialLeg: "escalated",
         },
-        "Voice duplex continuation delivered on session close",
       );
     } catch (err) {
       log.warn(
-        { err, conversationId: this.conversationId },
-        "Voice duplex continuation delivery on session close failed",
+        { err, taskId: notification.taskId },
+        "Voice task announcement failed to start",
       );
     }
+    if (!started) {
+      // A failed launch waits for the next user turn or update before retrying.
+      this.taskAnnouncementsDeferred = true;
+      this.clearTaskAnnouncementTimer();
+    }
   }
 
-  /**
-   * Live-voice is non-interactive (JARVIS-1291) and the session never starts a
-   * turn on its own — with one narrow exception, this: a background
-   * continuation the user asked for has finished, the call is still live, and
-   * nobody is speaking. Arms the silence timer that decides whether that
-   * exception applies. Re-arming resets the wait, so a run of arms collapses
-   * into one announcement.
-   *
-   * The silence the timer waits out starts when the audio the client already
-   * has queued runs out, so a continuation finishing at the tail end of a long
-   * spoken reply waits for that reply to actually finish playing.
-   *
-   * `retry` marks the single re-arm a user-speech blocker gets. An active
-   * assistant turn keeps the announcement queued without polling; releasing
-   * the turn re-arms the timer against the actual playback tail.
-   */
-  private scheduleContinuationAnnouncement(
-    retry = false,
-    drainRearms = 0,
-  ): void {
-    this.announcementTimer = this.scheduleFloorCheck(
-      this.announcementTimer,
-      this.continuationAnnounceSilenceMs,
-      () => {
-        this.announcementTimer = null;
-        const blockedBy = this.continuationAnnouncementBlocker();
-        if (blockedBy === null) {
-          void this.announceContinuation().catch((err: unknown) => {
-            log.warn({ err }, "Voice duplex continuation announcement failed");
-          });
-          return;
-        }
-        log.debug(
-          {
-            conversationId: this.conversationId,
-            blockedBy,
-            retry,
-            drainRearms,
-          },
-          "Voice duplex continuation announcement deferred",
-        );
-        // A tail that grew while the timer ran (the reply was still streaming
-        // TTS when it was armed) is a wait of known length rather than a busy
-        // call, so it re-arms against the new deadline without spending the
-        // single retry the busy-call blockers get. Otherwise a long reply's
-        // playback alone outlasts the budget and the announcement is dropped
-        // even though the call goes idle right after. The tail only extends
-        // while a turn is active, which blocks earlier, so the re-arms converge;
-        // the cap bounds the interleaving where a fresh turn's audio lands
-        // between two checks.
-        if (
-          blockedBy === "playback_draining" &&
-          drainRearms < CONTINUATION_ANNOUNCE_MAX_DRAIN_REARMS
-        ) {
-          this.scheduleContinuationAnnouncement(retry, drainRearms + 1);
-          return;
-        }
-        if (blockedBy === "turn_active") {
-          return;
-        }
-        if (retry || this.pendingAnnouncement === null) {
-          this.pendingAnnouncement = null;
-          return;
-        }
-        this.scheduleContinuationAnnouncement(true, drainRearms);
-      },
-    );
+  private async deliverTaskOutcomesToConversation(
+    turnTeardown?: Promise<void>,
+  ): Promise<void> {
+    this.clearTaskAnnouncementTimer();
+    // Voice aborts discard the parent queue. Deliver only after its turn settles.
+    await Promise.allSettled(this.pendingAssistantStarts);
+    await turnTeardown;
+    await this.getTurnTeardown?.(this.conversationId);
+    const { injectMessageIntoParent } = await import("../subagent/notify.js");
+    const notifications = this.taskOutcomes.drain(Date.now());
+    this.taskOutcomesClosing = false;
+    for (const notification of notifications) {
+      injectMessageIntoParent(
+        this.conversationId,
+        notification.message,
+        notification.metadata,
+        { cronRunId: notification.cronRunId, bypassLiveVoice: true },
+      );
+    }
   }
 
   /**
@@ -3853,9 +4329,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Publish whatever the turn's activity line should be right now: the
-   * decision it is waiting on if it is waiting, and its newest running tool if
-   * it is not.
+   * Publish whatever the turn's activity should be right now: the decision it
+   * is waiting on, its newest running tool, or the structured escalation state
+   * underneath those temporary overlays.
    *
    * The single entry point for every caller that would otherwise reach for
    * `currentActivityLabel` directly. A turn can start and finish other ops
@@ -3873,7 +4349,18 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       );
       return;
     }
-    this.publishActivity(turn, this.currentActivityLabel(turn));
+    const label = this.currentActivityLabel(turn);
+    if (
+      label.length === 0 &&
+      turn.escalationTarget !== null &&
+      !turn.assistantCompleted
+    ) {
+      if (turn.publishedActivityKind !== "escalation") {
+        this.publishEscalationActivity(turn, turn.escalationTarget);
+      }
+      return;
+    }
+    this.publishActivity(turn, label);
   }
 
   /**
@@ -3951,14 +4438,17 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * conversation may wait on one.
    *
    * Callers whose line depends on turn state go through
-   * {@link refreshActivity}; this is called directly only to clear the line
-   * outright, which a cancelled or finished turn does regardless of what it
-   * was waiting on.
+   * {@link refreshActivity}. Structured transition events call this directly
+   * because their meaning is not captured by the label alone.
    */
   private publishActivity(
     turn: ActiveAssistantTurn,
     label: string,
     approvalRequestId?: string,
+    detail?: Pick<
+      Extract<LiveVoiceServerFramePayload, { type: "activity" }>,
+      "kind" | "profile" | "profileSource"
+    >,
   ): void {
     // De-duplicated on the request id as well as the wording. The two move
     // independently: a wait can be entered and left without the tool line
@@ -3966,6 +4456,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // retires the approval — leaving the island's buttons up with nothing
     // behind them.
     if (
+      detail === undefined &&
+      turn.publishedActivityKind === null &&
       turn.activityLabel === label &&
       turn.publishedApprovalRequestId === (approvalRequestId ?? null)
     ) {
@@ -3973,29 +4465,36 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
     turn.activityLabel = label;
     turn.publishedApprovalRequestId = approvalRequestId ?? null;
+    turn.publishedActivityKind = detail?.kind ?? null;
     void this.sendFrame(
       {
         type: "activity",
         turnId: turn.turnId,
         label,
         ...(approvalRequestId !== undefined ? { approvalRequestId } : {}),
+        ...detail,
       },
       () => !this.isClosed,
     );
   }
 
+  private publishEscalationActivity(
+    turn: ActiveAssistantTurn,
+    target: VoiceEscalationTarget,
+  ): void {
+    this.publishActivity(turn, "", undefined, {
+      kind: "escalation",
+      profile: target.profile,
+      profileSource: target.source,
+    });
+  }
+
   private clearActiveAssistantTurn(token: symbol): void {
     if (this.activeAssistantTurn?.token !== token) {
       return;
     }
     this.activeAssistantTurn = null;
-    if (
-      this.pendingAnnouncement !== null &&
-      !this.isClosed &&
-      this.state !== "failed"
-    ) {
-      this.scheduleContinuationAnnouncement();
-    }
+    this.scheduleTaskAnnouncement();
     if (
       this.foregroundTaskState?.phase === "suspended" &&
       this.foregroundTaskState.resumePending &&
@@ -4006,18 +4505,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
-  // Why the session must not speak up right now, or null when the call is
-  // genuinely idle: live, no turn running, and no user speech anywhere in
-  // flight (onset latch, barge-in guard, detector, or a cycle that has already
-  // captured something). The server-VAD re-arm keeps an empty cycle armed
-  // between turns, so an untouched `currentUtterance` IS the idle state.
-  private continuationAnnouncementBlocker(): string | null {
-    if (this.pendingAnnouncement === null) {
-      return "nothing_pending";
-    }
-    return this.sessionTurnFloorBlocker();
-  }
-
   /**
    * Why the session may not start a turn of its own right now, or null when it
    * may.
@@ -4101,7 +4588,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * that would not open, a share the desktop refused) cannot turn up minutes
    * later as a reply to nothing.
    */
-  private awaitLookFrame(action: LookSessionControl): void {
+  private awaitLookFrame(
+    action: LookSessionControl,
+    turn: ActiveAssistantTurn,
+  ): void {
     if (!this.lookFrames) {
       return;
     }
@@ -4116,7 +4606,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         "Live voice look dropped: no frame arrived",
       );
     }, LOOK_FRAME_WAIT_MS);
-    this.pendingLook = { action, armedAtMs: Date.now(), timer };
+    this.pendingLook = {
+      action,
+      callerUtterance: this.foregroundTaskRequestForTurn(turn),
+      armedAtMs: Date.now(),
+      timer,
+      frameLanded: false,
+    };
+  }
+
+  private appendPendingLookRequest(content: string): void {
+    if (this.pendingLook !== null && content.trim().length > 0) {
+      this.pendingLook.callerUtterance =
+        `${this.pendingLook.callerUtterance}\n${content}`.trim();
+    }
   }
 
   private clearPendingLook(): void {
@@ -4138,11 +4641,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    */
   private lookFrameLanded(): void {
     const pending = this.pendingLook;
-    if (pending === null || this.isClosed) {
+    if (pending === null || pending.frameLanded || this.isClosed) {
       return;
     }
     clearTimeout(pending.timer);
-    this.pendingLook = null;
+    pending.frameLanded = true;
     this.answerLookWhenFloorIsFree(pending, this.turnsLaunched, 0);
   }
 
@@ -4163,11 +4666,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     turnsAtFrame: number,
     rearms: number,
   ): void {
+    if (this.pendingLook !== look) {
+      return;
+    }
     if (this.lookFollowUpTimer !== null) {
       clearTimeout(this.lookFollowUpTimer);
       this.lookFollowUpTimer = null;
     }
-    const { action, armedAtMs } = look;
+    const { action, callerUtterance, armedAtMs } = look;
     // A turn launched since the frame landed read it already. Speech that
     // never became a turn (a cough, noise that transcribed to nothing) is only
     // waited out.
@@ -4176,10 +4682,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         ? "turn_since_look"
         : this.sessionTurnFloorBlocker();
     if (blockedBy === null) {
+      this.clearPendingLook();
       void this.launchAssistantTurn(
         createSyntheticUtterance(),
         LOOK_FOLLOW_UP_CONTENT,
-        { lookFollowUp: action, hiddenPrompt: true },
+        { lookFollowUp: { action, callerUtterance }, hiddenPrompt: true },
       ).catch((err: unknown) => {
         log.warn(
           { err, conversationId: this.conversationId, action },
@@ -4191,6 +4698,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     const waitable =
       blockedBy !== "turn_since_look" && blockedBy !== "session_unavailable";
     if (!waitable || Date.now() - armedAtMs >= LOOK_ANSWER_DEADLINE_MS) {
+      this.clearPendingLook();
       log.info(
         { conversationId: this.conversationId, action, blockedBy, rearms },
         "Live voice look follow-up skipped",
@@ -4207,77 +4715,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     );
   }
 
-  // Speak the finished continuation's result on a turn the session starts
-  // itself. The turn rides a synthetic cycle rather than the armed VAD one —
-  // `currentUtterance` belongs to the capture loop, and overwriting it would
-  // collide with the user's next real utterance.
-  private async announceContinuation(): Promise<void> {
-    const pending = this.pendingAnnouncement;
-    if (!pending) {
-      return;
-    }
-    this.pendingAnnouncement = null;
-    // The two routes for one answer are mutually exclusive: while this turn is
-    // in flight the stash must not deliver the same answer again. It comes back
-    // only if this turn provably never started (below) or a barge-in cuts it
-    // short before it delivers (see bargeIn).
-    this.pendingContinuationResult = null;
-    // Pins the invalidation state this hand-off was decided in: a hard stop
-    // landing while the turn starts owns the drop, and must not be undone by
-    // the restore below.
-    const stopGeneration = this.detachStopGeneration;
-    let started: boolean;
-    try {
-      started = await this.launchAssistantTurn(
-        createSyntheticUtterance(),
-        CONTINUATION_DELIVERY_CONTENT,
-        { continuationDelivery: pending },
-      );
-    } catch (err) {
-      // A throw before the leg's own error handling (an outbound frame write
-      // rejecting, say) leaves the same state a false return does: nothing
-      // persisted, nothing spoken, and the stash already emptied above. Take
-      // the identical fallback rather than letting the answer die with the
-      // rejection.
-      started = false;
-      log.warn(
-        { err, conversationId: this.conversationId },
-        "Voice duplex continuation announcement threw while starting",
-      );
-    }
-    if (started) {
-      log.info(
-        {
-          conversationId: this.conversationId,
-          resultChars: pending.answer.length,
-          resultDestination: "announced",
-        },
-        "Voice duplex continuation announced",
-      );
-      return;
-    }
-    // The turn never reached the bridge (the conversation is busy from another
-    // surface, or the bridge threw), so nothing was persisted or spoken. Hand
-    // the answer back to the stash — the user's next turn is the fallback route
-    // that exists for exactly this. A newer continuation's answer already in
-    // the stash wins over this older one rather than being overwritten.
-    const restashed =
-      !this.isClosed &&
-      this.detachStopGeneration === stopGeneration &&
-      this.pendingContinuationResult === null;
-    if (restashed) {
-      this.pendingContinuationResult = pending.answer;
-    }
-    log.warn(
-      {
-        conversationId: this.conversationId,
-        resultChars: pending.answer.length,
-        resultDestination: restashed ? "stashed" : "dropped",
-      },
-      "Voice duplex continuation announcement could not start",
-    );
-  }
-
   // VAD closed the utterance — the analog of ptt_release: emit
   // utterance_end, then run the standard release path.
   private handleVadUtteranceEnd(reason: "silence" | "max-duration"): void {
@@ -4294,6 +4731,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.vadSpeechStartPending = false;
       // The detector turn is over: an untripped guard was noise, not
       // barge-in — leave playback untouched.
+      if (this.pendingBargeIn) {
+        this.logInputDiagnostic("voice_input_barge_in_expired", {
+          reason,
+          armedAtMs: this.pendingBargeIn.armedAtMs,
+          guardResets: this.pendingBargeIn.resets,
+          accumulatedSpeechMs: this.pendingBargeIn.guard.speechMs,
+        });
+      }
       this.pendingBargeIn = null;
       if (reason === "max-duration") {
         // A max-duration boundary always releases: drop any pending hold
@@ -4372,7 +4817,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // end-of-turn is coming and the utterance replays this boundary on the
   // silence path.
   // `waitMsOverride` collapses that wait when the caller already knows no
-  // end-of-turn is coming (see setProviderTurnEndActive).
+  // end-of-turn is coming (see setProviderTurnDetectionActive).
   private armProviderTurnEndFallbackTimer(
     utterance: UtteranceCycle,
     waitMsOverride?: number,
@@ -4405,32 +4850,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Flips the provider end-of-turn latch, unwinding an optimistic arm.
-   *
-   * `beginUtterance` arms the latch from the configured provider before the
-   * dial resolves, so a silence boundary can already have deferred to the
-   * provider by the time the resolved one says otherwise. That deferred
-   * boundary is parked on the fail-open deadline, a whole end-of-turn budget
-   * away, waiting for an event that will now never arrive. Collapse the wait to
-   * zero rather than burn the budget: the deadline body re-checks the cycle
-   * and replays the silence boundary, which with the latch down takes the
-   * ordinary hold path. Replaying through the deadline instead of calling
-   * `handleVadUtteranceEnd` directly keeps the release off the arming
-   * caller's stack, which is still mid-dial.
-   *
-   * A cleared latch with no deadline armed needs no unwind: either no
-   * boundary ever deferred, or the caller resumed speaking and
-   * `handleVadSpeechStart` already dropped the deadline, leaving the detector
-   * owning the next boundary. The cycle's `turnBoundaryGeneration` stamp is
-   * left as it is: `isStaleProviderTurnEnd` is only ever consulted from
-   * `handleProviderTurnEnd`, which returns immediately once the latch is down.
+   * The pre-dial configuration can defer a silence boundary to a provider
+   * that resolves without turn detection. Collapse its fallback deadline
+   * rather than wait for an event that cannot arrive. Replaying through the
+   * timer keeps release off the resolver's stack and rechecks cycle ownership.
    */
-  private setProviderTurnEndActive(active: boolean): void {
-    if (active === this.providerTurnEndActive) {
+  private setProviderTurnDetectionActive(active: boolean): void {
+    const wasEndActive = this.providerTurnEndActive;
+    this.providerTurnStartActive = active;
+    if (active) {
+      this.pendingBargeIn = null;
+    }
+    if (wasEndActive === this.providerTurnEndActive) {
       return;
     }
-    this.providerTurnEndActive = active;
-    if (active || this.providerTurnEndTimer === null) {
+    this.microphoneIdleGate.reset();
+    if (this.providerTurnEndActive || this.providerTurnEndTimer === null) {
       return;
     }
     const utterance = this.currentUtterance;
@@ -4441,18 +4876,40 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Record the provider turn a cycle is currently inside. Providers without
-   * turn numbering send no index, which leaves the cycle on the local speech
-   * generation as its only staleness signal (see isStaleProviderTurnEnd).
+   * Turn indices belong to the stream, so duplicates cannot interrupt the
+   * reply to an earlier cycle. The cycle also keeps its own index for matching
+   * end-of-turn events; unnumbered events use local speech generation there.
    */
-  private recordProviderTurnStart(
+  private handleProviderTurnStart(
     utterance: UtteranceCycle,
     turnIndex: number | undefined,
   ): void {
-    if (turnIndex === undefined) {
+    this.logInputDiagnostic("voice_input_provider_turn_start", {
+      inputTurnId: this.ensureTurnId(utterance),
+      turnIndex: turnIndex ?? null,
+      sttProvider: utterance.dialedSttProvider,
+      localDetectorActive: this.turnDetector?.isActive ?? false,
+    });
+    if (
+      this.currentUtterance !== utterance ||
+      (utterance.released && utterance.assistantTurnStarted) ||
+      utterance.completed ||
+      (turnIndex !== undefined &&
+        this.latestProviderTurnStartIndex !== null &&
+        turnIndex <= this.latestProviderTurnStartIndex)
+    ) {
       return;
     }
-    utterance.openProviderTurnIndex = turnIndex;
+    if (turnIndex !== undefined) {
+      this.latestProviderTurnStartIndex = turnIndex;
+      utterance.openProviderTurnIndex = turnIndex;
+    }
+    if (this.providerTurnStartActive) {
+      utterance.speechRouted = true;
+      this.detectedSpeech = true;
+      this.markSpeechStart(utterance);
+      this.handleSpeechStart("provider");
+    }
   }
 
   /**
@@ -4520,8 +4977,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    */
   private async handleProviderTurnEnd(
     utterance: UtteranceCycle,
-    turnIndex: number | undefined,
+    event: Extract<SttStreamServerEvent, { type: "turn-end" }>,
   ): Promise<void> {
+    const { turnIndex } = event;
+    this.logInputDiagnostic("voice_input_provider_turn_end", {
+      inputTurnId: utterance.turnId,
+      sttProvider: utterance.dialedSttProvider,
+      turnIndex: turnIndex ?? null,
+      confidence: event.confidence ?? null,
+      trigger: event.trigger ?? null,
+      audioWindowEndSeconds: event.audioWindowEndSeconds ?? null,
+      transcriptChars: event.text.length,
+      localDetectorActive: this.turnDetector?.isActive ?? false,
+      msSinceLocalSpeechStop:
+        this.localSpeechStopAtMs === null
+          ? null
+          : this.msSinceLocalSpeechStop(),
+      providerTurnEndActive: this.providerTurnEndActive,
+      providerTurnEndTimedOut: utterance.providerTurnEndTimedOut,
+    });
     if (
       !this.providerTurnEndActive ||
       this.currentUtterance !== utterance ||
@@ -4572,12 +5046,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // closing the stream.
     utterance.providerClosedTurn = true;
     await this.releaseUtterance();
-    // Leave the local detector idle, which is where every other commit path
-    // leaves it. A provider can close a turn while the trailing-silence
-    // countdown is still running, and barge-in fires from the detector's speech
-    // ONSET: a detector left mid-turn reports no onset, so the caller could
-    // not interrupt the reply they just triggered. The forced boundary
-    // reaches an already-released utterance and returns.
+    // The provider can commit before the local silence countdown expires.
+    // Reset the detector so the next speech run gets its own local boundary.
+    // This forced boundary reaches an already-released utterance and returns.
     this.turnDetector?.forceEnd();
   }
 
@@ -4642,6 +5113,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // are skipped; the thinking frame and timers still apply.
     const alreadyReleased = utterance.released;
     turn.speculativePending = false;
+    // Caller context is final once the speculative turn commits.
+    if (!turn.hiddenPrompt && turn.speculativeContent !== null) {
+      this.appendPendingLookRequest(turn.speculativeContent);
+      if (turn.interruptedRequest !== null) {
+        this.bargeInInterruption?.settle(turn.speculativeContent);
+      }
+    }
     // Finals can land between the speculative dispatch and this verdict.
     // Fill the language only when dispatch had none: the model request was
     // already issued with the dispatch language, so overwriting here would
@@ -4723,11 +5201,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     reason: string,
   ): void {
     turn.speculativePending = false;
-    // The dispatch is being unwound, so the barge-in merge note, the finished
-    // continuation's answer, its queued announcement, and any camera frame it
-    // claimed all go back to the session. The turn that would have delivered
-    // them is gone, and the utterance they belong to is about to be sent by
-    // another.
+    // Return claimed user context and camera frames for the replay.
     this.restorePendingTurnContext(turn);
     // Latched before the handle check: when the discard beats the bridge
     // handle's resolution (startVoiceTurn still persisting), the handle's
@@ -4737,6 +5211,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.activeAssistantTurn = null;
     }
     this.clearFillerTimers(turn);
+    this.releaseModeSessionRequests(turn);
+    this.releaseModeSessionDelivery(turn);
     turn.abortController.abort(
       createAbortReason("voice_session_aborted", `live-voice-${reason}`),
     );
@@ -5037,12 +5513,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // completion signal has no cycle to advance here.
         return;
       case "turn-start":
-        // Barge-in is deliberately untouched: local VAD still owns it,
-        // because a provider roundtrip cannot beat a local energy gate on an
-        // interrupt during playback (see DEFAULT_BARGE_IN_MIN_SPEECH_MS). The
-        // index is recorded so a later end-of-turn can be told apart from one
-        // this turn superseded (see isStaleProviderTurnEnd).
-        this.recordProviderTurnStart(utterance, event.turnIndex);
+        this.handleProviderTurnStart(utterance, event.turnIndex);
         return;
       case "eager-turn-end":
       case "turn-resumed":
@@ -5052,7 +5523,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // follow-up.
         return;
       case "turn-end":
-        await this.handleProviderTurnEnd(utterance, event.turnIndex);
+        await this.handleProviderTurnEnd(utterance, event);
         return;
       case "error":
         await this.sendTranscriberErrorFrame(event);
@@ -5183,14 +5654,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         return;
       }
       case "turn-start": {
-        // Barge-in is deliberately untouched: local VAD still owns it,
-        // because a provider roundtrip cannot beat a local energy gate on an
-        // interrupt during playback (see DEFAULT_BARGE_IN_MIN_SPEECH_MS). The
-        // index is recorded so a later end-of-turn can be told apart from one
-        // this turn superseded (see isStaleProviderTurnEnd).
         const target = this.pendingTranscriptCycle();
         if (target) {
-          this.recordProviderTurnStart(target, event.turnIndex);
+          this.handleProviderTurnStart(target, event.turnIndex);
         }
         return;
       }
@@ -5206,7 +5672,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // transcript owns the turn the provider just closed.
         const target = this.pendingTranscriptCycle();
         if (target) {
-          await this.handleProviderTurnEnd(target, event.turnIndex);
+          await this.handleProviderTurnEnd(target, event);
         }
         return;
       }
@@ -5224,8 +5690,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         }
         // The shared stream closed under the session: fall back to the
         // per-cycle path — the next arm resolves a fresh transcriber.
-        this.sharedTranscriber = null;
-        this.sharedTranscriberLanguage = undefined;
+        this.releaseSharedTranscriber(transcriber);
         const drained = this.drainFinalizeQueueFor(transcriber);
         const current = this.currentUtterance;
         if (
@@ -5378,6 +5843,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private async interrupt(): Promise<void> {
+    this.taskOutcomes.interruptPlayback(Date.now());
+    this.taskAnnouncementsDeferred = true;
+    this.clearTaskAnnouncementTimer();
     if (this.isClosed || this.state === "failed") {
       return;
     }
@@ -5421,6 +5889,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // per-cycle) and clears the finalize bookkeeping. Used by interrupt() and
   // close(); persistent mode re-establishes itself on the next arm.
   private stopSessionTranscriber(): void {
+    this.microphoneIdleGate.reset();
     this.clearFinalizeGraceTimer();
     this.finalizeQueue = [];
     const shared = this.sharedTranscriber;
@@ -5505,64 +5974,32 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     await this.launchAssistantTurn(utterance, content);
   }
 
-  /**
-   * Take the barge-in merge context, the completed-continuation context, the
-   * handoff note, and the parked camera frame for the turn being launched
-   * (each feeds exactly the next launched turn) and cancel the queued
-   * announcement, because the turn this context rides delivers the same answer
-   * and would otherwise say it twice.
-   *
-   * Every real user turn consumes here, speculative or not: a speculative
-   * dispatch latches `assistantTurnStarted`, so a turn that skipped this would
-   * never pick the context up on any later pass. A rolled-back dispatch hands
-   * it all back (restorePendingTurnContext).
-   */
+  // User-turn context is consumable; finished outcomes are only peeked.
   private consumePendingTurnContext(): {
     interruptedRequest: string | null;
-    continuationResult: string | null;
     handedOffRequest: string | null;
-    announcement: ContinuationDelivery | null;
     turnAttachmentId: string | null;
   } {
     const consumed = {
       interruptedRequest: this.pendingInterruptedRequest,
-      continuationResult: this.pendingContinuationResult,
       handedOffRequest: this.pendingHandoffRequest,
-      announcement: this.pendingAnnouncement,
       turnAttachmentId: this.pendingTurnAttachmentId,
     };
     this.pendingInterruptedRequest = null;
-    this.pendingContinuationResult = null;
     this.pendingHandoffRequest = null;
     this.pendingTurnAttachmentId = null;
-    this.clearContinuationAnnouncement();
     return consumed;
   }
 
-  /**
-   * Hand a turn's consumed pending context back to the session because the
-   * turn never happened: a speculative dispatch was discarded or held, or the
-   * launch never reached the bridge. Without this a hold verdict would destroy
-   * a finished continuation's answer outright — the stash was already emptied
-   * and no later turn would ever see it.
-   *
-   * Restores are conservative. A hard stop (interrupt/close/supersede) bumps
-   * `detachStopGeneration`, and that drop is deliberate — never undone here.
-   * Anything newer already sitting in a slot wins over the older value being
-   * returned to it.
-   */
+  // Rollbacks return consumed context without changing queued outcome delivery.
   private restorePendingTurnContext(turn: ActiveAssistantTurn): void {
     const interruptedRequest = turn.interruptedRequest;
-    const continuationResult = turn.continuationResult;
     const handedOffRequest = turn.handedOffRequest;
-    const announcement = turn.consumedAnnouncement;
     const turnAttachmentId = turn.turnAttachmentId;
     // One restore per turn: the rollback paths overlap (a discarded turn whose
     // leg start also fails), and the second pass must be a no-op.
     turn.interruptedRequest = null;
-    turn.continuationResult = null;
     turn.handedOffRequest = null;
-    turn.consumedAnnouncement = null;
     turn.turnAttachmentId = null;
     // Nobody's to send unless the slot already holds it. A client that
     // retransmits the id this turn claimed parked the SAME frame rather than a
@@ -5593,39 +6030,26 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     } else {
       turn.staleFrameId = orphanedFrameId;
     }
-    if (this.pendingContinuationResult === null) {
-      this.pendingContinuationResult = continuationResult;
-    }
-    // "Still running" is stale the moment a result exists, which is why the
-    // detach clears the handoff note when it finishes — don't reinstate it
-    // against a continuation that has since completed.
     if (
       this.pendingHandoffRequest === null &&
-      this.pendingContinuationResult === null
+      this.detachControllers.size > 0
     ) {
       this.pendingHandoffRequest = handedOffRequest;
     }
-    if (announcement !== null && this.pendingAnnouncement === null) {
-      this.pendingAnnouncement = announcement;
-      this.scheduleContinuationAnnouncement();
-    }
   }
 
   // Build the ActiveAssistantTurn for a released utterance and drive its model
   // leg. Resolves true once the leg has a live turn handle, false when the
-  // dispatch never reached the bridge — the signal a caller with a fallback
-  // route (announceContinuation) needs, since a failed start is otherwise
+  // dispatch never reached the bridge: the signal a caller with a fallback
+  // route (announceTaskOutcome) needs, since a failed start is otherwise
   // handled entirely inside startAssistantLeg.
   private async launchAssistantTurn(
     utterance: UtteranceCycle,
     content: string,
     opts?: {
-      // Set on an announcement turn: the finished continuation this turn exists
-      // to deliver. Its answer goes in the control prompt, not in `content`.
-      continuationDelivery?: ContinuationDelivery | null;
-      // Set on the turn that answers a look: which look. Its instruction goes
-      // in the control prompt, not in `content`.
-      lookFollowUp?: LookSessionControl;
+      taskOutcome?: VoiceTaskOutcome;
+      // The original request accompanies the fresh view in the control prompt.
+      lookFollowUp?: LookFollowUp;
       // Unified front-door: dispatch without releasing the utterance. The
       // thinking frame and floor-holding timers are deferred until the leg's
       // leading verdict commits the turn (see commitSpeculativeTurn); a hold
@@ -5642,16 +6066,70 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       foregroundTaskEpoch?: number;
     },
   ): Promise<boolean> {
+    if (opts?.hiddenPrompt !== true) {
+      this.taskOutcomes.acknowledgePlayback(Date.now());
+      this.taskAnnouncementsDeferred = false;
+    }
     utterance.assistantTurnStarted = true;
-    // The announcement turn IS the delivery of the pending continuation, so it
-    // must not also consume the stash — feeding it both would deliver the same
-    // answer twice. Every other turn is a real user turn and takes the context.
+    // Task announcements own their updates. Pending user-turn context stays
+    // available for the next user turn instead of being consumed by an update.
     const pending =
-      opts?.continuationDelivery == null
-        ? this.consumePendingTurnContext()
-        : null;
+      opts?.taskOutcome == null ? this.consumePendingTurnContext() : null;
+    // A speculative dispatch may hold only the start of the interruption
+    // ("Actually..."): its words reach the continuation judge when it
+    // commits (commitSpeculativeTurn), and a discard restores the wait for
+    // the redispatch.
+    if (
+      pending?.interruptedRequest != null &&
+      opts?.hiddenPrompt !== true &&
+      opts?.speculative !== true
+    ) {
+      this.bargeInInterruption?.settle(content);
+    }
     const token = Symbol("live-voice-assistant-turn");
     const turnId = this.ensureTurnId(utterance);
+    const initialLeg = opts?.initialLeg ?? "front-door";
+    const modeSessionRequestId = randomUUID();
+    const attemptedModeSessionRequestIds: string[] = [modeSessionRequestId];
+    let modeSessionSource: ModeSessionSourceHandle | undefined;
+    let modeSessionRequestIds: string[] = [];
+    let modeSessionDeliveryTurnId: string | null = null;
+    try {
+      modeSessionSource =
+        this.cameraModeSessions?.holdDelivery(modeSessionRequestId);
+      if (!modeSessionSource) {
+        this.releaseModeSessionTurnId(modeSessionRequestId);
+      } else {
+        modeSessionRequestIds.push(modeSessionRequestId);
+        if (initialLeg === "front-door") {
+          const escalatedRequestId = randomUUID();
+          attemptedModeSessionRequestIds.push(escalatedRequestId);
+          const escalatedSource =
+            this.cameraModeSessions?.holdDelivery(escalatedRequestId);
+          if (!sameModeSessionSource(escalatedSource, modeSessionSource)) {
+            throw new Error("Camera session changed during voice admission");
+          }
+          modeSessionRequestIds.push(escalatedRequestId);
+        }
+        const deliveryTurnId = `live-voice-delivery:${this.context.sessionId}:${++this.modeSessionDeliveryCounter}`;
+        attemptedModeSessionRequestIds.push(deliveryTurnId);
+        const deliverySource =
+          this.cameraModeSessions?.holdDelivery(deliveryTurnId);
+        if (!sameModeSessionSource(deliverySource, modeSessionSource)) {
+          throw new Error("Camera session changed during voice admission");
+        }
+        modeSessionDeliveryTurnId = deliveryTurnId;
+      }
+    } catch (err) {
+      log.warn(
+        { err, turnId },
+        "Could not attach camera session ownership to voice turn",
+      );
+      this.releaseModeSessionTurnIds(attemptedModeSessionRequestIds);
+      modeSessionSource = undefined;
+      modeSessionRequestIds = [];
+      modeSessionDeliveryTurnId = null;
+    }
     this.startMetricsTurnIfNeeded(utterance, turnId);
     this.markAssistantDispatch(utterance, turnId);
     const abortController = new AbortController();
@@ -5671,6 +6149,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       language: this.turnLanguageFor(utterance),
       abortController,
       handle: null,
+      modeSessionSource,
+      modeSessionRequestIds,
+      modeSessionDeliveryTurnId: modeSessionSource
+        ? modeSessionDeliveryTurnId
+        : null,
       launchedAtMs: Date.now(),
       progress: createProgressCadence({
         config: progressConfigForCadence(
@@ -5714,8 +6197,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       sessionControlRequested: null,
       activityLabel: "",
       publishedApprovalRequestId: null,
+      publishedActivityKind: null,
       pendingApproval: null,
       ttsAudioStarted: false,
+      ttsFailed: false,
       finalized: false,
       speculativePending: opts?.speculative === true,
       speculativeGeneration: this.vadSpeechGeneration,
@@ -5727,13 +6212,16 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       discardRequested: false,
       speculativeBuffer: "",
       interruptedRequest: pending?.interruptedRequest ?? null,
-      continuationResult: pending?.continuationResult ?? null,
+      contextOutcomes: pending ? this.taskOutcomes.pendingOutcomes() : [],
       handedOffRequest: pending?.handedOffRequest ?? null,
       turnAttachmentId: pending?.turnAttachmentId ?? null,
       staleFrameId: null,
-      consumedAnnouncement: pending?.announcement ?? null,
       pendingContextStopGeneration: this.detachStopGeneration,
-      continuationDelivery: opts?.continuationDelivery ?? null,
+      taskOutcome: opts?.taskOutcome ?? null,
+      taskDeliveryContext: opts?.taskOutcome
+        ? this.taskOutcomes.deliveryContext(opts.taskOutcome)
+        : null,
+      notificationHandledSilently: false,
       lookFollowUp: opts?.lookFollowUp ?? null,
       hiddenPrompt: opts?.hiddenPrompt === true,
       foregroundTaskEpoch,
@@ -5743,6 +6231,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           : null,
       deltaEpoch: 0,
       frontDoor: null,
+      escalationTarget: null,
       ttsBuffer: "",
       spokenSegments: 0,
       spokenChars: 0,
@@ -5756,6 +6245,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     };
     this.activeAssistantTurn = activeTurn;
     this.turnsLaunched += 1;
+    if (!activeTurn.hiddenPrompt && !activeTurn.speculativePending) {
+      this.appendPendingLookRequest(content);
+    }
 
     // A speculative turn defers the thinking frame and both floor-holding
     // timers to commitSpeculativeTurn: until the verdict arrives, the pause
@@ -5763,6 +6255,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (!opts?.speculative) {
       await this.sendFrame({ type: "thinking", turnId });
       if (!this.isActiveAssistantTurn(token)) {
+        this.releaseModeSessionRequests(activeTurn);
+        this.releaseModeSessionDelivery(activeTurn);
         this.restorePendingTurnContext(activeTurn);
         // Nothing was persisted, so a frame the restore could not hand back
         // links to no row and is collectible right here.
@@ -5805,7 +6299,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       activeTurn.progress.arm();
     }
 
-    const initialLeg = opts?.initialLeg ?? "front-door";
     const started = await this.startAssistantLeg(activeTurn, {
       content,
       routingLeg: initialLeg,
@@ -5819,6 +6312,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         : {}),
     });
     if (!started) {
+      this.releaseModeSessionRequests(activeTurn);
+      this.releaseModeSessionDelivery(activeTurn);
       // Nothing was persisted or spoken, so the context this turn consumed goes
       // back to the session rather than dying with the failed dispatch. A frame
       // a newer one displaced meanwhile links to no row, so it is collected
@@ -5861,10 +6356,15 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       attachments?: readonly string[];
     },
   ): Promise<boolean> {
-    if (!this.startVoiceTurn) {
+    if (
+      !this.startVoiceTurn ||
+      this.isClosed ||
+      activeTurn.abortController.signal.aborted
+    ) {
       return false;
     }
     const { token, utterance, turnId } = activeTurn;
+    const modeSessionRequestId = activeTurn.modeSessionRequestIds.shift();
 
     // `rawText` accumulates this leg's spoken stream. A front-door leg runs
     // through the shared coordinator, which reads its stream through the
@@ -5934,6 +6434,15 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
               activeTurn.handle?.abort();
               activeTurn.handle = null;
             },
+            overruleLeg: () => {
+              const handle = activeTurn.handle;
+              activeTurn.handle = null;
+              if (handle?.overrule) {
+                handle.overrule();
+              } else {
+                handle?.abort();
+              }
+            },
             speakBridge: (bridge) =>
               this.speakEscalationBridge(activeTurn, bridge),
             startEscalatedLeg: (escalated) => {
@@ -5947,6 +6456,107 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       activeTurn.frontDoor = coordinator;
     }
 
+    // The leg's completion. A front-door answer held for the escalation judge
+    // is spoken or overruled first, so the turn never closes its TTS buffer
+    // under text that has not been released yet.
+    const completeLeg = (
+      msg: Parameters<NonNullable<VoiceTurnCallbacks["message_complete"]>>[0],
+    ): void => {
+      if (
+        coordinator?.awaitingJudge === true &&
+        msg.type === "message_complete"
+      ) {
+        void coordinator.settled().then(() => completeLeg(msg));
+        return;
+      }
+      const current = this.activeAssistantTurn;
+      if (
+        current?.token !== token ||
+        current.assistantCompleted ||
+        // A barged-in turn finalizes through cancelAssistantTurn.
+        current.abortController.signal.aborted ||
+        this.isClosed
+      ) {
+        return;
+      }
+      if (!leg.frontDoor) {
+        this.claimSuspendedForegroundTask(current);
+      }
+      // A speculative leg that finished without a single delta (empty
+      // output, provider hiccup) carries no verdict, so fail open to a
+      // committed turn so the utterance releases and finalizes like a
+      // normal empty completion instead of dangling un-released.
+      if (current.speculativePending) {
+        this.commitSpeculativeTurn(current);
+      }
+      // A front-door leg that stopped mid-bridge hands off now with
+      // whatever arrived. A cancellation mid-bridge falls through to
+      // normal cancelled finalization instead: a dead turn must not
+      // spawn an escalated leg. A front-door leg that handed off is
+      // finished; the escalated leg drives completion, so this leg's
+      // own trailing completion (including the generation_cancelled
+      // from its abort) is a no-op.
+      if (coordinator !== null) {
+        if (msg.type === "message_complete") {
+          coordinator.complete();
+        }
+        if (coordinator.handedOff) {
+          return;
+        }
+      }
+      // A held "[…"-tail that never completed a marker is real text:
+      // force-flush it before assistantCompleted closes the TTS buffer
+      // and completeTtsForTurn signals the drain, so it is spoken and
+      // emitted rather than dropped.
+      if (!leg.frontDoor && msg.type === "message_complete") {
+        flushLegText(rawText, { force: true });
+      }
+      // Read off the leg that finished the reply: a front-door answer
+      // or the escalated leg. A handed-off front-door leg returned
+      // above, so its holding phrase can never end a call.
+      if (msg.type === "message_complete") {
+        current.notificationHandledSilently =
+          current.taskOutcome !== null &&
+          rawText.trim() === TASK_UPDATE_SILENT_MARKER;
+        const request = requestedSessionControl(rawText, this.sessionControls);
+        if (request?.action === "updates") {
+          // The session's own control: nothing to send, and nothing to
+          // wait for, since it shapes turns that have not started yet.
+          this.progressCadence = request.cadence;
+          log.info(
+            { turnId, cadence: request.cadence },
+            "Live voice progress cadence changed",
+          );
+        } else if (request?.action === "task_stop") {
+          this.stopOutstandingInterruptedWork("spoken_task_stop");
+        } else {
+          if (request?.action === "end") {
+            this.clearForegroundTask("call_end_requested");
+          }
+          current.sessionControlRequested = request;
+        }
+      }
+      if (leg.frontDoor) {
+        this.queueForegroundTaskResume(current);
+      }
+      current.assistantCompleted = true;
+      if (msg.type === "generation_cancelled") {
+        void this.finalizeAssistantTurn(
+          current,
+          "cancelled",
+          "generation_cancelled",
+        );
+        return;
+      }
+      current.assistantMessageId = msg.messageId ?? null;
+      this.completeTtsForTurn(token);
+    };
+
+    let finishStart!: () => void;
+    const startup = new Promise<void>((resolve) => {
+      finishStart = resolve;
+    });
+    this.pendingAssistantStarts.add(startup);
     try {
       // Latched before the await, not after: this flag only decides whether the
       // end event carries a silence classification, and the dashboard decides
@@ -5969,7 +6579,18 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       const handle = await this.startVoiceTurn({
         conversationId: this.conversationId,
         voiceSessionId: this.context.sessionId,
+        ...(activeTurn.modeSessionSource && modeSessionRequestId
+          ? {
+              preacceptedModeSession: {
+                requestId: modeSessionRequestId,
+                source: activeTurn.modeSessionSource,
+              },
+            }
+          : {}),
         ...(activeTurn.hiddenPrompt ? { hiddenSyntheticPrompt: true } : {}),
+        ...(activeTurn.lookFollowUp !== null
+          ? { routingUtterance: activeTurn.lookFollowUp.callerUtterance }
+          : {}),
         userMessageChannel: "vellum",
         assistantMessageChannel: "vellum",
         // Fixed, and NOT the originating client: this pair resolves the turn's
@@ -6008,16 +6629,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         onApprovalsResolved: () => {
           this.clearAwaitingApproval(activeTurn);
         },
+        ...(leg.routingLeg === "escalated"
+          ? {
+              onEscalationTargetResolved: (target) => {
+                if (!this.isActiveAssistantTurn(token)) {
+                  return;
+                }
+                activeTurn.escalationTarget = target;
+                this.publishEscalationActivity(activeTurn, target);
+              },
+            }
+          : {}),
         content: leg.content,
         ...(leg.attachments ? { attachments: leg.attachments } : {}),
         isInbound: true,
         launchedAtMs: activeTurn.launchedAtMs,
         signal: activeTurn.abortController.signal,
-        // An announcement turn's content is a fixed marker, not user speech:
-        // persist it hidden and suppress its echo so nothing renders as a user
-        // bubble for a turn the user never started.
-        ...(activeTurn.continuationDelivery !== null
-          ? { hiddenSyntheticPrompt: true }
+        ...(activeTurn.taskOutcome !== null &&
+        activeTurn.taskOutcome.source === "subagent"
+          ? { subagentNotification: activeTurn.taskOutcome }
           : {}),
         ...(leg.overrideProfile != null
           ? { overrideProfile: leg.overrideProfile }
@@ -6070,90 +6700,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             rawText += msg.text;
             flushLegText(rawText);
           },
-          message_complete: (msg) => {
-            const current = this.activeAssistantTurn;
-            if (
-              current?.token !== token ||
-              current.assistantCompleted ||
-              // A barged-in turn finalizes through cancelAssistantTurn.
-              current.abortController.signal.aborted ||
-              this.isClosed
-            ) {
-              return;
-            }
-            if (!leg.frontDoor) {
-              this.claimSuspendedForegroundTask(current);
-            }
-            // A speculative leg that finished without a single delta (empty
-            // output, provider hiccup) carries no verdict — fail open to a
-            // committed turn so the utterance releases and finalizes like a
-            // normal empty completion instead of dangling un-released.
-            if (current.speculativePending) {
-              this.commitSpeculativeTurn(current);
-            }
-            // A front-door leg that stopped mid-bridge hands off now with
-            // whatever arrived. A cancellation mid-bridge falls through to
-            // normal cancelled finalization instead: a dead turn must not
-            // spawn an escalated leg. A front-door leg that handed off is
-            // finished; the escalated leg drives completion, so this leg's
-            // own trailing completion (including the generation_cancelled
-            // from its abort) is a no-op.
-            if (coordinator !== null) {
-              if (msg.type === "message_complete") {
-                coordinator.complete();
-              }
-              if (coordinator.handedOff) {
-                return;
-              }
-            }
-            // A held "[…"-tail that never completed a marker is real text —
-            // force-flush it before assistantCompleted closes the TTS buffer
-            // and completeTtsForTurn signals the drain, so it is spoken and
-            // emitted rather than dropped.
-            if (!leg.frontDoor && msg.type === "message_complete") {
-              flushLegText(rawText, { force: true });
-            }
-            // Read off the leg that finished the reply: a front-door answer
-            // or the escalated leg. A handed-off front-door leg returned
-            // above, so its holding phrase can never end a call.
-            if (msg.type === "message_complete") {
-              const request = requestedSessionControl(
-                rawText,
-                this.sessionControls,
-              );
-              if (request?.action === "updates") {
-                // The session's own control: nothing to send, and nothing to
-                // wait for, since it shapes turns that have not started yet.
-                this.progressCadence = request.cadence;
-                log.info(
-                  { turnId, cadence: request.cadence },
-                  "Live voice progress cadence changed",
-                );
-              } else if (request?.action === "task_stop") {
-                this.stopOutstandingInterruptedWork("spoken_task_stop");
-              } else {
-                if (request?.action === "end") {
-                  this.clearForegroundTask("call_end_requested");
-                }
-                current.sessionControlRequested = request;
-              }
-            }
-            if (leg.frontDoor) {
-              this.queueForegroundTaskResume(current);
-            }
-            current.assistantCompleted = true;
-            if (msg.type === "generation_cancelled") {
-              void this.finalizeAssistantTurn(
-                current,
-                "cancelled",
-                "generation_cancelled",
-              );
-              return;
-            }
-            current.assistantMessageId = msg.messageId ?? null;
-            current.continuationDelivery = null;
-            this.completeTtsForTurn(token);
-          },
+          message_complete: completeLeg,
           persisted_user_message_id: (messageId) => {
             const current = this.activeAssistantTurn;
             // Only the first leg's user row is the real caller utterance; the
@@ -6212,7 +6759,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
               foregroundToolContendsWithContinuation(toolName, detail?.input)
             ) {
               this.abortDetachedRuns({
-                keepPendingResult: true,
                 reason: "foreground_tool_contends",
                 toolName,
               });
@@ -6281,7 +6827,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           })();
         },
       });
-
       const current = this.activeAssistantTurn;
       if (current?.token !== token) {
         // A discard that beat this handle's resolution still owes the
@@ -6324,8 +6869,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       }
 
       current.handle = handle;
+      if (coordinator !== null && handle.escalationJudgement) {
+        coordinator.attachEscalationJudge(handle.escalationJudgement);
+      }
       return true;
     } catch (err) {
+      if (modeSessionRequestId) {
+        this.releaseModeSessionTurnId(modeSessionRequestId);
+      }
       if (!this.isActiveAssistantTurn(token)) {
         return false;
       }
@@ -6338,6 +6889,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         this.rearmForegroundTaskAfterLegFailure(activeTurn);
       this.clearFillerTimers(activeTurn);
       this.clearActiveAssistantTurn(token);
+      this.releaseModeSessionRequests(activeTurn);
+      this.releaseModeSessionDelivery(activeTurn);
       if (foregroundTaskResumeRearmed) {
         this.scheduleForegroundTaskResume();
       }
@@ -6351,6 +6904,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       await this.finalizePendingUtterance(utterance, "assistant_start_error");
       this.scheduleRearmAfterTurn();
       return false;
+    } finally {
+      this.pendingAssistantStarts.delete(startup);
+      finishStart();
     }
   }
 
@@ -6377,15 +6933,40 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // otherwise sit buffered until a sentence boundary and leave the
       // caller in silence during the escalated model's call.
       this.flushTtsBuffer(activeTurn.token, true);
-      return;
-    }
-    // The canned bridge is a fixed localized-table phrase, enqueued
-    // directly (it is already one complete sentence) so the segment can
-    // carry the "en" override when the table lacks the turn's language.
-    const speakable = sanitizeForTts(spokenBridge).trim();
-    if (speakable.length > 0) {
-      this.enqueueTtsSegment(activeTurn.token, speakable, { language });
+    } else {
+      // The canned bridge is a fixed localized-table phrase, enqueued
+      // directly (it is already one complete sentence) so the segment can
+      // carry the "en" override when the table lacks the turn's language.
+      const speakable = sanitizeForTts(spokenBridge).trim();
+      if (speakable.length > 0) {
+        this.enqueueTtsSegment(activeTurn.token, speakable, { language });
+      }
     }
+
+    // Target resolution can land before the bridge's queued audio finishes.
+    // Its activity frame moves the system surface to thinking, then a late
+    // bridge tts_audio frame moves it back to speaking. Restore the neutral
+    // waiting phase at the bridge's emission boundary, ahead of any answer
+    // audio queued behind it.
+    const bridgeDrain = activeTurn.ttsQueue;
+    void bridgeDrain.then(
+      () => {
+        const target = activeTurn.escalationTarget;
+        if (
+          target === null ||
+          !this.isActiveAssistantTurn(activeTurn.token) ||
+          activeTurn.assistantCompleted
+        ) {
+          return;
+        }
+        if (activeTurn.publishedActivityKind === "escalation") {
+          this.publishEscalationActivity(activeTurn, target);
+          return;
+        }
+        this.liveActivityReporter.restoreThinkingPhase();
+      },
+      () => undefined,
+    );
   }
 
   private async cancelAssistantTurn(reason: string): Promise<void> {
@@ -6607,7 +7188,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             isLookSessionControl(sessionControl.action) &&
             currentTurn.lookFollowUp === null
           ) {
-            this.awaitLookFrame(sessionControl.action);
+            this.awaitLookFrame(sessionControl.action, currentTurn);
           }
           await this.sendFrame(
             {
@@ -6643,6 +7224,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         if (!currentTurn.abortController.signal.aborted) {
           this.scheduleRearmAfterTurn();
         }
+      })
+      .finally(() => {
+        this.releaseModeSessionDelivery(activeTurn);
       });
   }
 
@@ -6696,6 +7280,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
     const job: TtsSegmentJob = {
       text: segment,
+      isReply: options.countsAsFirstSegment ?? true,
+      audioSent: false,
       language: options.language,
       started: false,
       settled: false,
@@ -6813,6 +7399,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       await job.frames;
 
       if (failed && this.isForwardingTts(token)) {
+        currentTurn.ttsFailed = true;
         // Per-segment failure: the turn (and session) continue, so the
         // error is recoverable for the client.
         await this.sendFrame(
@@ -6825,6 +7412,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           () => this.isForwardingTts(token),
         );
       }
+    } catch (err) {
+      const turn = this.activeAssistantTurn;
+      if (turn?.token === token) {
+        turn.ttsFailed = true;
+      }
+      throw err;
     } finally {
       job.settled = true;
       const settledTurn = this.activeAssistantTurn;
@@ -6849,16 +7442,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (activeTurn?.token !== token) {
       return;
     }
-    // Only retain the assistant TTS audio when it will be archived (see
-    // collectUserAudio); the mime/sample-rate are cheap and left unconditional.
-    if (this.archiveAudio) {
-      activeTurn.assistantAudioChunks.push(
-        Buffer.from(chunk.dataBase64, "base64"),
-      );
-    }
-    activeTurn.assistantAudioMimeType = chunk.contentType;
-    activeTurn.assistantAudioSampleRate = chunk.sampleRate;
     job.frames = job.frames.then(async () => {
+      // Pace audio before entering the shared outbound queue so control frames
+      // and cancellation remain immediate while prefetched speech waits.
+      const leadMs = this.assistantPlaybackTailUntilMs - Date.now();
+      if (
+        leadMs > TTS_MAX_PLAYBACK_LEAD_MS &&
+        !activeTurn.abortController.signal.aborted
+      ) {
+        try {
+          await delay(leadMs - TTS_MAX_PLAYBACK_LEAD_MS, undefined, {
+            signal: activeTurn.abortController.signal,
+          });
+        } catch (error) {
+          if (activeTurn.abortController.signal.aborted) {
+            return;
+          }
+          throw error;
+        }
+      }
       const sent = await this.sendFrame(
         {
           type: "tts_audio",
@@ -6868,13 +7470,21 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         },
         () => this.isForwardingTts(token),
       );
-      // Skip a frame that wasn't actually written — a backed-up outbound
+      // Skip a frame that wasn't actually written. A backed-up outbound
       // queue hasn't reached the client, so it must not extend the
       // playback-tail estimate or latch first-audio state. Token match keeps
       // a stale turn's late send from latching a newer turn.
       if (!sent) {
         return;
       }
+      if (this.archiveAudio) {
+        activeTurn.assistantAudioChunks.push(
+          Buffer.from(chunk.dataBase64, "base64"),
+        );
+      }
+      activeTurn.assistantAudioMimeType = chunk.contentType;
+      activeTurn.assistantAudioSampleRate = chunk.sampleRate;
+      job.audioSent = true;
       // Extend the client playback-tail estimate by this chunk's PCM
       // duration (chunks queue gaplessly client-side, so the tail grows
       // from whichever is later: now or the current estimate).
@@ -6914,6 +7524,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.markUtteranceMetric(utterance, "speechStartAtMs", (turnId) =>
       this.metrics.markSpeechStart(turnId),
     );
+    this.logInputDiagnostic("voice_input_speech_routed", {
+      inputTurnId: utterance.turnId,
+    });
   }
 
   /**
@@ -6956,6 +7569,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private markFirstPartial(utterance: UtteranceCycle): void {
+    if ((utterance.latestPartialText?.trim() ?? "").length === 0) {
+      return;
+    }
     this.markUtteranceMetric(utterance, "firstPartialAtMs", (turnId) =>
       this.metrics.markFirstPartial(turnId),
     );
@@ -6965,6 +7581,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.markUtteranceMetric(utterance, "finalTranscriptAtMs", (turnId) =>
       this.metrics.markFinalTranscript(turnId),
     );
+    this.logInputDiagnostic("voice_input_transcript", {
+      inputTurnId: utterance.turnId,
+      sttProvider: utterance.dialedSttProvider,
+      transcriptChars: utterance.finalTranscriptSegments.join(" ").trim()
+        .length,
+    });
   }
 
   // Records the mark on the utterance's metrics turn, or — while a previous
@@ -7105,6 +7727,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     utterance: UtteranceCycle,
     reason: string,
   ): Promise<void> {
+    this.logInputDiagnostic("voice_input_utterance_discarded", {
+      inputTurnId: utterance.turnId,
+      reason,
+      sttProvider: utterance.dialedSttProvider,
+      transcriptChars: utterance.finalTranscriptSegments.join(" ").trim()
+        .length,
+      hasPartialAtDiscard: utterance.latestPartialText !== null,
+    });
     // An utterance that finalizes here never became a turn (empty transcript,
     // client interrupt, transcriber close, error), so it ends the window a
     // barge-in's merge context was waiting to attach to. Drop that context so
@@ -7112,13 +7742,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // finalizes through finalizeAssistantTurn, not here, so this never clears a
     // request that the barge-in follow-up turn is still about to consume.
     this.pendingInterruptedRequest = null;
-    // `pendingContinuationResult` is deliberately NOT cleared here. Unlike the
-    // merge context (bound to the immediate barge-in follow-up), a completed
-    // continuation's answer targets the next REAL turn, and hands-free server-VAD
-    // routinely discards noise/empty-transcript utterances between turns; wiping
-    // it on each such discard would frequently drop a valid result before the
-    // user's next question. It is bounded instead by consume-once, the hard-stop
-    // clear (abortDetachedRuns), and the model's "use only if relevant" framing.
     utterance.completed = true;
     const turnId = utterance.turnId;
     if (!turnId) {
@@ -7147,6 +7770,42 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
 
     turn.finalized = true;
+    const reply = turn.ttsJobs
+      .filter((job) => job.isReply && job.audioSent)
+      .map((job) => job.text)
+      .join(" ");
+    if (turn.taskOutcome !== null) {
+      if (
+        status === "completed" &&
+        !turn.ttsFailed &&
+        (turn.notificationHandledSilently || reply.length > 0)
+      ) {
+        this.taskOutcomes.finish(
+          turn.taskOutcome,
+          turn.notificationHandledSilently
+            ? Date.now()
+            : this.assistantPlaybackTailUntilMs,
+          turn.notificationHandledSilently ? "" : reply,
+        );
+      } else {
+        if (
+          reason === "barge_in" ||
+          reason === "interrupt" ||
+          reason === "session_closed"
+        ) {
+          this.taskOutcomes.interrupt(turn.taskOutcome);
+        }
+        if (reason !== "barge_in") {
+          this.taskAnnouncementsDeferred = true;
+        }
+      }
+    } else if (status === "completed" && !turn.ttsFailed && reply.length > 0) {
+      this.taskOutcomes.finishContextReply(
+        turn.contextOutcomes,
+        this.assistantPlaybackTailUntilMs,
+        reply,
+      );
+    }
     this.clearFillerTimers(turn);
     if (
       this.foregroundTaskState?.phase === "owned" &&
@@ -7169,6 +7828,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         : {}),
     });
     await this.finishMetricsTurn(turn.utterance, status, reason, turn.turnId);
+    this.releaseModeSessionRequests(turn);
+
+    if (status === "cancelled") {
+      this.releaseModeSessionDelivery(turn);
+    }
 
     if (
       (options.clearActive ?? true) &&
@@ -7183,6 +7847,36 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
+  private releaseModeSessionDelivery(turn: ActiveAssistantTurn): void {
+    const turnId = turn.modeSessionDeliveryTurnId;
+    if (turnId === null) {
+      return;
+    }
+    turn.modeSessionDeliveryTurnId = null;
+    this.releaseModeSessionTurnId(turnId);
+  }
+
+  private releaseModeSessionRequests(turn: ActiveAssistantTurn): void {
+    this.releaseModeSessionTurnIds(turn.modeSessionRequestIds.splice(0));
+  }
+
+  private releaseModeSessionTurnIds(turnIds: readonly string[]): void {
+    for (const turnId of turnIds) {
+      this.releaseModeSessionTurnId(turnId);
+    }
+  }
+
+  private releaseModeSessionTurnId(turnId: string): void {
+    try {
+      this.cameraModeSessions?.releaseDelivery(turnId);
+    } catch (err) {
+      log.warn(
+        { err, turnId },
+        "Could not release camera session ownership from voice turn",
+      );
+    }
+  }
+
   private async archiveBufferedAudio(input: {
     turnId: string;
     userMessageId: string | null;
@@ -7330,7 +8024,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private async emitMetricsFrame(
-    event: LiveVoiceMetricsEvent,
+    event: VoiceMetricsEvent,
     turnId = this.currentUtterance?.turnId ?? this.context.sessionId,
   ): Promise<void> {
     const metrics = this.metrics.getSnapshot();
@@ -7341,7 +8035,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       conversationId: this.conversationId,
       turnId,
       metrics,
-      ...getLiveVoiceMetricsAggregateFields(metrics, turnId),
+      ...getVoiceMetricsAggregateFields(metrics, turnId),
     });
   }
 
@@ -7473,6 +8167,8 @@ export function createLiveVoiceSession(
       options.spawnBackgroundContinuation ?? defaultSpawnBackgroundContinuation,
     labelBackgroundContinuation:
       options.labelBackgroundContinuation ?? createContinuationLabeler(),
+    judgeBackgroundContinuation:
+      options.judgeBackgroundContinuation ?? createContinuationJudge(),
     getTurnTeardown: options.getTurnTeardown ?? getConversationTurnTeardown,
     // Off by default (see the `liveVoice.archiveAudio` schema): voice turns
     // persist only their transcribed text, so the recorded audio never lands
@@ -7802,7 +8498,7 @@ async function defaultArchiveLiveVoiceAudio(
     : linkLiveVoiceAssistantResponseAudioToMessage(input);
 }
 
-function toSeedMarks(stashed: StashedMetricsMarks): LiveVoiceTurnSeedMarks {
+function toSeedMarks(stashed: StashedMetricsMarks): VoiceTurnSeedMarks {
   return {
     ...(stashed.firstAudioAtMs !== null
       ? { firstAudioAtMs: stashed.firstAudioAtMs }