@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

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

@@ -6,11 +6,27 @@ import {
   type TurnDetectorConfig,
 } from "../calls/media-turn-detector.js";
 import { sanitizeForTts } from "../calls/tts-text-sanitizer.js";
+import {
+  couldBeControlMarker,
+  ESCALATE_MARKER,
+  stripInternalSpeechMarkers,
+} from "../calls/voice-control-protocol.js";
 import type {
   VoiceTurnHandle,
   VoiceTurnOptions,
 } from "../calls/voice-session-bridge.js";
+import {
+  ESCALATION_CONTINUATION_CONTENT,
+  ESCALATION_PROFILE,
+  FALLBACK_ESCALATION_BRIDGE,
+  FRONT_DOOR_PROFILE,
+  isVoiceTriageEscalateEnabled,
+  needsFallbackBridge,
+  type VoiceRoutingLeg,
+} from "../calls/voice-triage-escalate.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { ensureConversationExists } from "../persistence/conversation-crud.js";
 import {
   listProviderIds,
@@ -38,6 +54,12 @@ import {
   type LiveVoiceMetricsEvent,
   type LiveVoiceTurnSeedMarks,
 } from "./live-voice-metrics.js";
+import {
+  registerVoiceResumeHandler,
+  unregisterVoiceResumeHandler,
+  type VoiceResumeHandler,
+  type VoiceResumeOptions,
+} from "./live-voice-resume-registry.js";
 import {
   type LiveVoiceSession as LiveVoiceSessionContract,
   type LiveVoiceSessionCloseReason,
@@ -51,6 +73,7 @@ import type {
 } from "./live-voice-tts.js";
 import {
   type LiveVoiceClientFrame,
+  type LiveVoiceClientUpdateConfigFrame,
   LiveVoiceProtocolErrorCode,
   type LiveVoiceServerFramePayload,
 } from "./protocol.js";
@@ -77,10 +100,12 @@ const SERVER_VAD_PRE_ROLL_MAX_CHUNKS = 25;
 // provider keeps its own, longer, finalize fallback).
 const FINALIZE_GRACE_MS = 1_000;
 // Consecutive speech (ms) required before speech during assistant playback
-// flushes it (speech_started) and cancels the turn, so a cough or noise blip
-// cannot kill a reply mid-sentence. Mirrors the liveVoice.vad.bargeInMinSpeechMs
-// schema default; 0 disables the guard for instant barge-in.
-const DEFAULT_BARGE_IN_MIN_SPEECH_MS = 60;
+// flushes it (speech_started) and cancels the turn, so a cough, a filler word,
+// or the assistant's own TTS bleeding through imperfect browser echo
+// cancellation cannot kill a reply mid-sentence. Mirrors the
+// liveVoice.vad.bargeInMinSpeechMs schema default; 0 disables the guard for
+// instant barge-in.
+const DEFAULT_BARGE_IN_MIN_SPEECH_MS = 250;
 // At most this many TTS segment jobs are open (provider stream started,
 // frames not yet fully emitted) per turn: the emitting job plus one
 // prefetching job. The prefetch buffers its chunks in memory until promoted;
@@ -244,10 +269,20 @@ interface ActiveAssistantTurn {
   handle: VoiceTurnHandle | null;
   assistantCompleted: boolean;
   ttsDone: boolean;
-  // A tts_audio frame actually went out to the client — the barge-in gate:
-  // speech only cancels a turn that has audibly started speaking.
+  // 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;
   finalized: boolean;
+  // When this turn started from a barge-in, the interrupted request's
+  // transcript. Appended to the turn's control prompt (both legs) so the model
+  // 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;
+  // Triage-and-escalate (Voice Mode): the front-door leg emitted [ESCALATE]
+  // and the strong "escalated" leg has taken over this same turn. Guards the
+  // front-door leg's trailing completion from finalizing the turn, and makes
+  // the hand-off idempotent.
+  escalationHandedOff: boolean;
   ttsBuffer: string;
   // A non-empty speakable segment reached the TTS queue — gates the eager
   // first-segment flush that trades clause quality for speech onset.
@@ -264,6 +299,21 @@ interface ActiveAssistantTurn {
   assistantAudioSampleRate?: number;
 }
 
+// Base control prompt for every live-voice turn. When a turn starts from a
+// barge-in, the interruption merge note is appended to it (see
+// buildInterruptionMergeNote) so the model reconciles the interrupted request
+// with the new utterance.
+const LIVE_VOICE_CONTROL_PROMPT =
+  "You are speaking in a local live voice session. Keep replies brief and conversational.";
+
+// System-level guidance appended to a barge-in turn's control prompt so the
+// model treats the new utterance as a continuation of the request it was cut
+// off answering, rather than a fresh follow-up. Reaches the model only; it is
+// not a user message and never renders as a transcript bubble.
+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, or stay silent if they only want you to stop.`;
+}
+
 export class LiveVoiceSession implements LiveVoiceSessionContract {
   private readonly context: LiveVoiceSessionFactoryContext;
   private readonly resolveTranscriber: LiveVoiceStreamingTranscriberResolver;
@@ -285,7 +335,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // Energy gate for server-VAD speech classification; undefined defers to
   // DEFAULT_SPEECH_ENERGY_THRESHOLD.
   private readonly speechEnergyThreshold: number | undefined;
-  private readonly bargeInMinSpeechMs: number;
+  // Mutable so a mid-session `update_config` frame can retune "interrupt
+  // sensitivity" live (see applyConfigUpdate).
+  private bargeInMinSpeechMs: number;
   // Sustained-speech barge-in guard, armed at speech onset while the
   // assistant turn is audibly speaking: consecutive speech-chunk duration
   // accumulates until it reaches bargeInMinSpeechMs, then the deferred
@@ -305,6 +357,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // the chunk's PCM duration; zeroed whenever the client flushes playback
   // (speech_started, turn_cancelled, interrupt, close).
   private assistantPlaybackTailUntilMs = 0;
+  // Set when barge-in cancels an in-flight turn: the interrupted request's
+  // transcript, carried into the next turn so the model merges the two.
+  // 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;
   private readonly maxPendingAudioBytes: number;
   // Set on VAD speech onset; consumed when the first speech chunk is routed
   // to an utterance so the metric lands on the right turn.
@@ -341,6 +398,15 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   /** The cycle whose grace timer is armed (only the newest release has one). */
   private finalizeGraceCycle: UtteranceCycle | null = null;
   private readonly finalizeGraceMs: number;
+  // Registered in the registry so the HTTP surface-action path can resume a
+  // yielded interactive surface as a SPOKEN turn on this session (JARVIS-1287).
+  private readonly voiceResumeHandler: VoiceResumeHandler;
+  // A resume requested while an assistant turn was still in flight; dispatched
+  // once the active turn settles (see flushPendingResume).
+  private pendingResume: {
+    content: string;
+    opts?: VoiceResumeOptions;
+  } | null = null;
 
   constructor(
     context: LiveVoiceSessionFactoryContext,
@@ -358,6 +424,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.createTurnId = options.createTurnId ?? randomUUID;
     this.conversationId =
       context.startFrame.conversationId ?? context.sessionId;
+    this.voiceResumeHandler = {
+      resumeWithText: (content, opts) => this.resumeWithText(content, opts),
+    };
+    registerVoiceResumeHandler(this.conversationId, this.voiceResumeHandler);
     this.metricsClock = options.metricsClock ?? Date.now;
     this.metrics = new LiveVoiceMetricsCollector({
       sessionId: context.sessionId,
@@ -365,12 +435,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ...(options.metricsClock ? { clock: options.metricsClock } : {}),
     });
     this.speechEnergyThreshold = options.speechEnergyThreshold;
+    // Precedence for the two sensitivity knobs: per-session start-frame
+    // override (the client's user setting) > daemon `liveVoice.vad` config
+    // (seeded into `options` by the factory) > in-code default.
     this.bargeInMinSpeechMs =
-      options.bargeInMinSpeechMs ?? DEFAULT_BARGE_IN_MIN_SPEECH_MS;
+      context.startFrame.bargeInMinSpeechMs ??
+      options.bargeInMinSpeechMs ??
+      DEFAULT_BARGE_IN_MIN_SPEECH_MS;
     this.finalizeGraceMs = options.finalizeGraceMs ?? FINALIZE_GRACE_MS;
+    const turnDetectorConfig: TurnDetectorConfig = {
+      ...(options.turnDetectorConfig ?? {}),
+      ...(context.startFrame.silenceThresholdMs !== undefined
+        ? { silenceThresholdMs: context.startFrame.silenceThresholdMs }
+        : {}),
+    };
     this.turnDetector =
       context.startFrame.turnDetection === "server_vad"
-        ? new MediaTurnDetector(options.turnDetectorConfig ?? {}, {
+        ? new MediaTurnDetector(turnDetectorConfig, {
             onTurnStart: () => this.handleVadSpeechStart(),
             onTurnEnd: (reason) => this.handleVadUtteranceEnd(reason),
           })
@@ -440,6 +521,25 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         return;
       case "start":
         return;
+      case "update_config":
+        this.applyConfigUpdate(frame);
+        return;
+    }
+  }
+
+  /**
+   * Apply a mid-session `update_config` frame: retune the live turn detector's
+   * pause ("pause before reply") and/or the barge-in guard ("interrupt
+   * sensitivity") without reconnecting. Each field is optional and independent;
+   * changes take effect from the next utterance. A no-op on manual (non-
+   * server_vad) sessions, which have no turn detector.
+   */
+  private applyConfigUpdate(frame: LiveVoiceClientUpdateConfigFrame): void {
+    if (frame.silenceThresholdMs !== undefined) {
+      this.turnDetector?.setSilenceThresholdMs(frame.silenceThresholdMs);
+    }
+    if (frame.bargeInMinSpeechMs !== undefined) {
+      this.bargeInMinSpeechMs = frame.bargeInMinSpeechMs;
     }
   }
 
@@ -454,6 +554,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     const shouldEmitSessionEndMetrics = this.state !== "failed";
     this.state = "closed";
+    unregisterVoiceResumeHandler(this.conversationId, this.voiceResumeHandler);
     this.turnDetector?.dispose();
     this.stopSessionTranscriber();
     await this.cancelAssistantTurn("session_closed");
@@ -622,6 +723,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
+    // A resume deferred behind the finished turn takes the freed slot before a
+    // fresh utterance is armed (no-op when there's nothing pending).
+    this.flushPendingResume();
+
     const current = this.currentUtterance;
     if (current && !current.completed) {
       // server_vad armed the next utterance during the finished turn; it may
@@ -846,12 +951,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   // VAD speech onset. Contract: speech_started tells the client to flush
-  // tail playback immediately; barge-in then cancels the active turn only
-  // once its first tts_audio chunk was forwarded — speech during a pre-TTS
-  // "thinking" turn never kills the unspoken reply. While a turn is audibly
-  // speaking, both are deferred behind the sustained-speech guard so a
-  // cough or noise blip cannot kill the reply; onset while listening keeps
-  // the instant speech_started (turn-taking latency is untouched).
+  // 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).
   private handleVadSpeechStart(): void {
     if (this.isClosed || this.state === "failed") {
       return;
@@ -860,25 +967,27 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.vadSpeechStartPending = true;
 
     const turn = this.activeAssistantTurn;
-    const speakingTurn =
-      turn && !turn.finalized && turn.ttsAudioStarted ? turn : null;
+    // Any in-flight, non-finalized turn is interruptible, whether it is still
+    // "thinking" (pre-TTS) or audibly speaking, so a user can cut in before the
+    // 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.
     const drainingPlayback = Date.now() < this.assistantPlaybackTailUntilMs;
 
-    if ((speakingTurn || drainingPlayback) && this.bargeInMinSpeechMs > 0) {
+    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: speakingTurn, speechMs: 0 };
+      this.pendingBargeIn = { turn: bargeableTurn, speechMs: 0 };
       return;
     }
 
     this.pendingBargeIn = null;
     this.assistantPlaybackTailUntilMs = 0;
     void this.sendFrame({ type: "speech_started" });
-    if (speakingTurn) {
-      this.bargeIn(speakingTurn);
+    if (bargeableTurn) {
+      this.bargeIn(bargeableTurn);
     }
   }
 
@@ -917,6 +1026,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // do not collide with it in the collector. turn_cancelled flushes
     // client playback, so the drain estimate resets with it.
     this.assistantPlaybackTailUntilMs = 0;
+    // Carry the interrupted request into the next turn so it merges with the
+    // barge-in utterance rather than being answered as a fresh follow-up.
+    const interruptedRequest = turn.utterance.finalTranscriptSegments
+      .join(" ")
+      .trim();
+    this.pendingInterruptedRequest =
+      interruptedRequest.length > 0 ? interruptedRequest : null;
     turn.abortController.abort();
     this.metrics.markBargeIn(turn.turnId);
     void (async () => {
@@ -1363,6 +1479,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.assistantPlaybackTailUntilMs = 0;
     this.takeVadPreRoll();
     this.vadPendingTurnEnd = null;
+    // A client interrupt is a hard reset: any barge-in merge context waiting for
+    // the next turn is now stale (the interrupted utterance may be discarded
+    // without ever reaching finalizePendingUtterance).
+    this.pendingInterruptedRequest = null;
     const utterance = this.currentUtterance;
     this.stopSessionTranscriber();
     if (utterance) {
@@ -1435,12 +1555,34 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
+    // Consume any pending barge-in merge context for this turn (one barge-in
+    // feeds exactly the next launched turn).
+    const interruptedRequest = this.pendingInterruptedRequest;
+    this.pendingInterruptedRequest = null;
+    await this.launchAssistantTurn(utterance, content, { interruptedRequest });
+  }
+
+  // Build the ActiveAssistantTurn for a released utterance and drive its model
+  // leg. Shared by the STT path (startAssistantTurnIfReady) and the spoken
+  // surface-resume path (startResumeTurn) so both run identical turn machinery.
+  private async launchAssistantTurn(
+    utterance: UtteranceCycle,
+    content: string,
+    opts?: {
+      // Only set on the surface-resume path; the STT path leaves it undefined
+      // so no active-surface context is injected into an ordinary spoken turn.
+      activeSurfaceId?: string;
+      // Set on a barge-in follow-up turn: the interrupted request's transcript,
+      // appended to the turn's control prompt so the model merges the two.
+      interruptedRequest?: string | null;
+    },
+  ): Promise<void> {
     utterance.assistantTurnStarted = true;
     const token = Symbol("live-voice-assistant-turn");
     const turnId = this.ensureTurnId(utterance);
     this.startMetricsTurnIfNeeded(utterance, turnId);
     const abortController = new AbortController();
-    this.activeAssistantTurn = {
+    const activeTurn: ActiveAssistantTurn = {
       token,
       turnId,
       utterance,
@@ -1450,6 +1592,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ttsDone: false,
       ttsAudioStarted: false,
       finalized: false,
+      interruptedRequest: opts?.interruptedRequest ?? null,
+      escalationHandedOff: false,
       ttsBuffer: "",
       ttsSegmentEnqueued: false,
       ttsJobs: [],
@@ -1458,12 +1602,234 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       assistantAudioChunks: [],
       assistantAudioMimeType: "audio/pcm",
     };
+    this.activeAssistantTurn = activeTurn;
 
     await this.sendFrame({ type: "thinking", turnId });
     if (!this.isActiveAssistantTurn(token)) {
       return;
     }
 
+    // Triage-and-escalate (Voice Mode): active only when BOTH the voice-mode
+    // surface flag and the voice-triage-escalate routing flag are on. A
+    // live-voice session already implies voice-mode client-side; the explicit
+    // check keeps the "gated behind both flags" contract true server-side.
+    const cfg = getConfig();
+    const escalateEnabled =
+      isAssistantFeatureFlagEnabled("voice-mode", cfg) &&
+      isVoiceTriageEscalateEnabled(cfg);
+
+    // Front-door leg: with routing on, a fast profile fronts the turn and may
+    // hand off to the strong profile on [ESCALATE]; with it off, a single leg
+    // runs on the call-site default — byte-for-byte the prior behavior.
+    await this.startAssistantLeg(
+      activeTurn,
+      escalateEnabled
+        ? {
+            content,
+            overrideProfile: FRONT_DOOR_PROFILE,
+            routingLeg: "front-door",
+            frontDoor: true,
+            ...(opts?.activeSurfaceId !== undefined
+              ? { activeSurfaceId: opts.activeSurfaceId }
+              : {}),
+          }
+        : {
+            content,
+            ...(opts?.activeSurfaceId !== undefined
+              ? { activeSurfaceId: opts.activeSurfaceId }
+              : {}),
+          },
+    );
+  }
+
+  /**
+   * Resume a yielded interactive surface as a SPOKEN turn. The HTTP surface-
+   * action path calls this (via the resume registry) once the user completes a
+   * surface the voice turn raised, so the follow-up reply is synthesized to
+   * audio through this session's TTS pipeline instead of running silently
+   * through the text pipeline (JARVIS-1287).
+   *
+   * If a turn is still in flight the resume is deferred (pendingResume) and
+   * dispatched once that turn settles — never rejected with CONVERSATION_BUSY.
+   */
+  resumeWithText(content: string, opts?: VoiceResumeOptions): void {
+    const trimmed = content.trim();
+    if (
+      this.isClosed ||
+      this.state === "failed" ||
+      !this.startVoiceTurn ||
+      trimmed.length === 0
+    ) {
+      return;
+    }
+    if (this.activeAssistantTurn) {
+      this.pendingResume = { content: trimmed, opts };
+      return;
+    }
+    void this.startResumeTurn(trimmed, opts).catch((err) => {
+      log.error(
+        { err, conversationId: this.conversationId },
+        "live-voice resume turn failed",
+      );
+    });
+  }
+
+  private async startResumeTurn(
+    content: string,
+    opts?: VoiceResumeOptions,
+  ): Promise<void> {
+    if (this.isClosed || this.state === "failed" || !this.startVoiceTurn) {
+      return;
+    }
+    if (this.activeAssistantTurn) {
+      this.pendingResume = { content, opts };
+      return;
+    }
+    // A synthetic utterance carrying only the resume text: it is not
+    // this.currentUtterance (which holds the server-VAD armed next utterance),
+    // so the armed transcriber is untouched. finalizeAssistantTurn works on
+    // turn.utterance and tolerates the empty audio buffers.
+    const utterance: UtteranceCycle = {
+      phase: "transcriber_closed",
+      released: true,
+      assistantTurnStarted: false,
+      completed: false,
+      finalizeRequested: false,
+      transcriber: null,
+      pendingAudioChunks: [],
+      pendingAudioBytes: 0,
+      finalTranscriptSegments: [content],
+      turnId: null,
+      userMessageId: null,
+      userAudioChunks: [],
+      metricsTurnStarted: false,
+      metricsTurnFinished: false,
+      stashedMetricsMarks: {
+        firstAudioAtMs: null,
+        firstPartialAtMs: null,
+        speechStartAtMs: null,
+        utteranceEndAtMs: null,
+        finalTranscriptAtMs: null,
+      },
+    };
+    await this.launchAssistantTurn(utterance, content, {
+      activeSurfaceId: opts?.activeSurfaceId,
+    });
+  }
+
+  // Dispatch a resume deferred behind an in-flight turn, once that turn has
+  // settled. Null out pendingResume before dispatch so a re-entrant settle
+  // cannot double-fire the same resume.
+  private flushPendingResume(): void {
+    const deferred = this.pendingResume;
+    this.pendingResume = null;
+    if (
+      deferred &&
+      !this.activeAssistantTurn &&
+      !this.isClosed &&
+      this.state !== "failed"
+    ) {
+      void this.startResumeTurn(deferred.content, deferred.opts).catch(
+        (err) => {
+          log.error(
+            { err, conversationId: this.conversationId },
+            "live-voice deferred resume turn failed",
+          );
+        },
+      );
+    } else if (deferred) {
+      // Could not dispatch now (turn still active / session gone); keep it for
+      // the next settle point rather than dropping it.
+      this.pendingResume = deferred;
+    }
+  }
+
+  /**
+   * Drive one model leg of an assistant turn through the session bridge,
+   * streaming its deltas to the live-voice client and TTS. Returns once the
+   * leg's turn handle is acquired (or the start fails) — turn completion stays
+   * callback-driven via message_complete, exactly as the single-leg path did.
+   *
+   * A turn runs one leg normally. Under triage-and-escalate the front-door leg
+   * (`frontDoor: true`) may emit [ESCALATE]; the marker and everything after it
+   * are held back from the live-voice transcript and TTS here at the source,
+   * and `escalateTurn` starts a second "escalated" leg that shares this same
+   * ActiveAssistantTurn. (The shared conversation-hub broadcast and persisted
+   * assistant message still carry the raw marker — see issue #37850.)
+   */
+  private async startAssistantLeg(
+    activeTurn: ActiveAssistantTurn,
+    leg: {
+      content: string;
+      overrideProfile?: string;
+      routingLeg?: VoiceRoutingLeg;
+      frontDoor?: boolean;
+      // Present only on the primary surface-resume leg — never on the escalated
+      // continuation leg, so the active-surface context stays turn-scoped.
+      activeSurfaceId?: string;
+    },
+  ): Promise<void> {
+    if (!this.startVoiceTurn) {
+      return;
+    }
+    const { token, utterance, turnId } = activeTurn;
+
+    // Front-door marker gate. `rawText` accumulates this leg's full stream (for
+    // marker detection and the fallback-bridge decision); `frontDoorEmitted`
+    // tracks how much of it has been forwarded, so a trailing partial marker
+    // held back on one delta is released once a later delta disproves it.
+    let rawText = "";
+    let frontDoorEmitted = 0;
+
+    const emitFrontDoor = (chunk: string): void => {
+      if (chunk.length === 0) {
+        return;
+      }
+      this.markFirstAssistantDelta(utterance, turnId);
+      // Same send-time abort gate as the default-leg delta path: a front-door
+      // delta queued behind a backed-up outbound frame must not be written
+      // once barge-in aborts the turn. Escalation aborts the front-door handle,
+      // not this turn's controller, so legitimate front-door text still sends.
+      void this.sendFrame(
+        { type: "assistant_text_delta", text: chunk },
+        () => !activeTurn.abortController.signal.aborted && !this.isClosed,
+      );
+      this.bufferAssistantTextForTts(token, chunk);
+    };
+
+    // Forward the marker-free, non-partial-marker prefix that has not been
+    // emitted yet. Returns true once the complete [ESCALATE] marker arrives.
+    const flushFrontDoor = (): boolean => {
+      const markerIdx = rawText.indexOf(ESCALATE_MARKER, frontDoorEmitted);
+      if (markerIdx !== -1) {
+        emitFrontDoor(
+          stripInternalSpeechMarkers(
+            rawText.slice(frontDoorEmitted, markerIdx),
+          ),
+        );
+        // Suppress the marker and anything the model streams after it.
+        frontDoorEmitted = rawText.length;
+        return true;
+      }
+      let safeEnd = rawText.length;
+      const lastOpen = rawText.lastIndexOf("[");
+      if (lastOpen >= frontDoorEmitted) {
+        const tail = rawText.slice(lastOpen);
+        // Hold back a trailing "[…" that could still become a control marker;
+        // a real partial that never completes is simply never spoken.
+        if (!tail.includes("]") && couldBeControlMarker(tail)) {
+          safeEnd = lastOpen;
+        }
+      }
+      if (safeEnd > frontDoorEmitted) {
+        emitFrontDoor(
+          stripInternalSpeechMarkers(rawText.slice(frontDoorEmitted, safeEnd)),
+        );
+        frontDoorEmitted = safeEnd;
+      }
+      return false;
+    };
+
     try {
       const handle = await this.startVoiceTurn({
         conversationId: this.conversationId,
@@ -1472,67 +1838,106 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         assistantMessageChannel: "vellum",
         userMessageInterface: "macos",
         assistantMessageInterface: "macos",
-        voiceControlPrompt:
-          "You are speaking in a local live voice session. Keep replies brief and conversational.",
+        voiceControlPrompt: activeTurn.interruptedRequest
+          ? `${LIVE_VOICE_CONTROL_PROMPT}\n\n${buildInterruptionMergeNote(
+              activeTurn.interruptedRequest,
+            )}`
+          : LIVE_VOICE_CONTROL_PROMPT,
         approvalMode: "local-live-voice",
-        content,
+        content: leg.content,
         isInbound: true,
-        signal: abortController.signal,
+        signal: activeTurn.abortController.signal,
+        ...(leg.overrideProfile != null
+          ? { overrideProfile: leg.overrideProfile }
+          : {}),
+        ...(leg.routingLeg != null ? { routingLeg: leg.routingLeg } : {}),
+        ...(leg.activeSurfaceId != null
+          ? { activeSurfaceId: leg.activeSurfaceId }
+          : {}),
         callbacks: {
           assistant_text_delta: (msg) => {
             if (!this.isForwardingAssistantText(token)) {
               return;
             }
+            if (leg.frontDoor) {
+              rawText += msg.text;
+              if (activeTurn.escalationHandedOff) {
+                return;
+              }
+              if (flushFrontDoor()) {
+                this.escalateTurn(activeTurn, rawText);
+              }
+              return;
+            }
             this.markFirstAssistantDelta(utterance, turnId);
-            void this.sendFrame({
-              type: "assistant_text_delta",
-              text: msg.text,
-            });
+            void this.sendFrame(
+              {
+                type: "assistant_text_delta",
+                text: msg.text,
+              },
+              // Re-check at send time (mirrors the tts_audio path): a delta
+              // already queued behind a backed-up outbound frame must not be
+              // written once barge-in has aborted the turn, or the cancelled
+              // reply's text leaks ahead of turn_cancelled. Key off this turn's
+              // own abort signal — a normal message_complete finalizes and
+              // clears activeAssistantTurn while trailing deltas may still be
+              // draining, so an activeAssistantTurn-based guard would drop them.
+              () =>
+                !activeTurn.abortController.signal.aborted && !this.isClosed,
+            );
             this.bufferAssistantTextForTts(token, msg.text);
           },
           message_complete: (msg) => {
-            const activeTurn = this.activeAssistantTurn;
+            const current = this.activeAssistantTurn;
             if (
-              activeTurn?.token !== token ||
-              activeTurn.assistantCompleted ||
+              current?.token !== token ||
+              current.assistantCompleted ||
               // A barged-in turn finalizes through cancelAssistantTurn.
-              activeTurn.abortController.signal.aborted ||
+              current.abortController.signal.aborted ||
               this.isClosed
             ) {
               return;
             }
-            activeTurn.assistantCompleted = true;
+            // A front-door leg that handed off is finished; the escalated leg
+            // drives completion. The front-door leg's own trailing completion
+            // (including the generation_cancelled from its abort) is a no-op.
+            if (leg.frontDoor && current.escalationHandedOff) {
+              return;
+            }
+            current.assistantCompleted = true;
             if (msg.type === "generation_cancelled") {
               void this.finalizeAssistantTurn(
-                activeTurn,
+                current,
                 "cancelled",
                 "generation_cancelled",
               );
               return;
             }
-            activeTurn.assistantMessageId = msg.messageId ?? null;
+            current.assistantMessageId = msg.messageId ?? null;
             this.completeTtsForTurn(token);
           },
           persisted_user_message_id: (messageId) => {
-            const activeTurn = this.activeAssistantTurn;
-            if (activeTurn?.token !== token) {
+            const current = this.activeAssistantTurn;
+            // Only the first leg's user row is the real caller utterance; the
+            // escalated leg persists a hidden synthetic continuation prompt.
+            if (current?.token !== token || leg.routingLeg === "escalated") {
               return;
             }
-            activeTurn.utterance.userMessageId = messageId;
+            current.utterance.userMessageId = messageId;
           },
           persisted_assistant_message_id: (messageId) => {
-            const activeTurn = this.activeAssistantTurn;
-            if (activeTurn?.token !== token) {
+            const current = this.activeAssistantTurn;
+            if (current?.token !== token) {
               return;
             }
-            activeTurn.assistantMessageId = messageId;
+            current.assistantMessageId = messageId;
           },
         },
         onError: (message) => {
-          const activeTurn = this.activeAssistantTurn;
+          const current = this.activeAssistantTurn;
           if (
             !this.isActiveAssistantTurn(token) ||
-            activeTurn?.assistantCompleted
+            current?.assistantCompleted
           ) {
             return;
           }
@@ -1551,17 +1956,23 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         },
       });
 
-      const activeTurn = this.activeAssistantTurn;
-      if (activeTurn?.token !== token) {
+      const current = this.activeAssistantTurn;
+      if (current?.token !== token) {
         handle.abort();
         return;
       }
-      if (activeTurn.finalized) {
+      if (current.finalized) {
         this.activeAssistantTurn = null;
         return;
       }
+      // The front-door leg may have handed off before its handle resolved;
+      // abort it rather than exposing it as the turn's live handle.
+      if (leg.frontDoor && current.escalationHandedOff) {
+        handle.abort();
+        return;
+      }
 
-      activeTurn.handle = handle;
+      current.handle = handle;
     } catch (err) {
       if (!this.isActiveAssistantTurn(token)) {
         return;
@@ -1580,6 +1991,47 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
+  /**
+   * Hand the turn from the front-door leg to the strong "escalated" leg after
+   * [ESCALATE]. Speaks a holding phrase (the front-door leg's own pre-marker
+   * text, or a canned fallback when that was too short) and force-flushes it so
+   * it plays during the strong-model call, then starts the escalated leg on the
+   * same ActiveAssistantTurn. Idempotent.
+   */
+  private escalateTurn(
+    activeTurn: ActiveAssistantTurn,
+    frontDoorText: string,
+  ): void {
+    if (activeTurn.escalationHandedOff || activeTurn.finalized) {
+      return;
+    }
+    activeTurn.escalationHandedOff = true;
+    // Abort the front-door leg so a model that keeps generating past the marker
+    // adds no latency before the escalated leg starts.
+    activeTurn.handle?.abort();
+    activeTurn.handle = null;
+
+    // Speak a bridge so the strong-model call has no dead air. Fall back to a
+    // canned phrase only when the front-door leg spoke too little before the
+    // marker (measured pre-marker, so suppressed post-marker text can't count).
+    if (needsFallbackBridge(frontDoorText)) {
+      this.bufferAssistantTextForTts(
+        activeTurn.token,
+        `${FALLBACK_ESCALATION_BRIDGE} `,
+      );
+    }
+    // Force-flush now: on the TTS path an unpunctuated bridge would otherwise
+    // sit buffered until a sentence boundary and leave the caller in silence
+    // during the escalated model's call.
+    this.flushTtsBuffer(activeTurn.token, true);
+
+    void this.startAssistantLeg(activeTurn, {
+      content: ESCALATION_CONTINUATION_CONTENT,
+      overrideProfile: ESCALATION_PROFILE,
+      routingLeg: "escalated",
+    });
+  }
+
   private async cancelAssistantTurn(reason: string): Promise<void> {
     const turn = this.activeAssistantTurn;
     this.activeAssistantTurn = null;
@@ -1605,7 +2057,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private isActiveAssistantTurn(token: symbol): boolean {
     const activeTurn = this.activeAssistantTurn;
     return (
-      activeTurn?.token === token && !activeTurn.finalized && !this.isClosed
+      activeTurn?.token === token &&
+      !activeTurn.finalized &&
+      // Barge-in aborts synchronously but finalizes through an async
+      // cancelAssistantTurn chain; the abort makes the turn dead at once so a
+      // rejected startVoiceTurn or a trailing onError in that window does not
+      // treat it as live (and emit a stray error frame or double-finalize).
+      !activeTurn.abortController.signal.aborted &&
+      !this.isClosed
     );
   }
 
@@ -1615,6 +2074,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       activeTurn?.token === token &&
       !activeTurn.assistantCompleted &&
       !activeTurn.finalized &&
+      // Fence a late first assistant_text_delta once barge-in aborts a pre-TTS
+      // turn, before its async teardown finalizes — mirrors isForwardingTts so
+      // no cancelled-turn text leaks after turn_cancelled.
+      !activeTurn.abortController.signal.aborted &&
       !this.isClosed
     );
   }
@@ -1688,6 +2151,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           }
         }
 
+        // Now that the active turn is actually cleared, dispatch a resume that
+        // arrived mid-turn. `finalizeAssistantTurn` runs its own flush too, but
+        // this path finalizes with `clearActive: false`, so at that point the
+        // slot was still taken and the flush re-stashed. `scheduleRearmAfterTurn`
+        // below no-ops in manual (no-`turnDetector`) sessions, so without this
+        // flush the deferred resume would never start there (JARVIS-1287).
+        this.flushPendingResume();
+
         // Re-arm only after the terminal tts_done frame so a slow or failing
         // next transcriber cannot block or precede turn completion. A
         // cancelled turn re-arms through cancelAssistantTurn instead.
@@ -1879,9 +2350,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (activeTurn?.token !== token) {
       return;
     }
-    activeTurn.assistantAudioChunks.push(
-      Buffer.from(chunk.dataBase64, "base64"),
-    );
+    // 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 () => {
@@ -1894,10 +2369,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         },
         () => this.isForwardingTts(token),
       );
-      // Arm the barge-in gate only once a tts_audio frame was actually
-      // written — a backed-up outbound queue must not let speech cancel a
-      // still-unspoken reply. Token match keeps a stale turn's late send
-      // from arming a newer turn.
+      // 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;
       }
@@ -1921,7 +2396,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private collectUserAudio(utterance: UtteranceCycle, chunk: Buffer): void {
-    utterance.userAudioChunks.push(Buffer.from(chunk));
+    // Only retain the raw audio when it will actually be archived — otherwise
+    // buffering a whole turn's PCM is dead memory. The first-audio metric is
+    // independent of archiving, so it stays unconditional.
+    if (this.archiveAudio) {
+      utterance.userAudioChunks.push(Buffer.from(chunk));
+    }
     this.markUtteranceMetric(utterance, "firstAudioAtMs", (turnId) =>
       this.metrics.markFirstAudio(turnId),
     );
@@ -2036,6 +2516,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     utterance: UtteranceCycle,
     reason: string,
   ): Promise<void> {
+    // 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
+    // it can't leak into a later, unrelated turn. The barged turn itself
+    // 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;
     utterance.completed = true;
     const turnId = utterance.turnId;
     if (!turnId) {
@@ -2089,6 +2576,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (options.rearm ?? true) {
       this.scheduleRearmAfterTurn();
     }
+
+    // A surface-resume that arrived mid-turn waits here: the just-cleared
+    // active turn frees the slot, so dispatch it now. rearmAfterTurn also
+    // flushes (covers the manual path where scheduleRearmAfterTurn no-ops).
+    this.flushPendingResume();
   }
 
   private async archiveBufferedAudio(input: {
@@ -2316,7 +2808,8 @@ export function createLiveVoiceSession(
   // unchanged. Optional-chained
   // because hand-built test configs may predate the liveVoice namespace;
   // absent config falls through to the in-code defaults.
-  const vadConfig = getConfig().liveVoice?.vad;
+  const liveVoiceConfig = getConfig().liveVoice;
+  const vadConfig = liveVoiceConfig?.vad;
   return new LiveVoiceSession(context, {
     ...options,
     turnDetectorConfig:
@@ -2340,9 +2833,16 @@ export function createLiveVoiceSession(
       options.streamTtsAudio === undefined
         ? defaultStreamLiveVoiceTtsAudio
         : options.streamTtsAudio,
+    // Off by default (see the `liveVoice.archiveAudio` schema): voice turns
+    // persist only their transcribed text, so the recorded audio never lands
+    // as an attachment on the conversation messages. Enable via config for
+    // playback/debugging. An explicit option (incl. `null`) always wins — the
+    // test seam and any future caller override.
     archiveAudio:
       options.archiveAudio === undefined
-        ? defaultArchiveLiveVoiceAudio
+        ? liveVoiceConfig?.archiveAudio
+          ? defaultArchiveLiveVoiceAudio
+          : null
         : options.archiveAudio,
     emitMetrics: options.emitMetrics ?? true,
   });
@@ -2383,8 +2883,49 @@ async function defaultStartVoiceTurn(
       options.conversationId,
     );
   }
+  // Stamp the turn with the guardian's trust context — the same resolution the
+  // text-send route runs for a local vellum principal. A local live-voice
+  // session only exists for the guardian's own authenticated client (the
+  // gateway pins the `/v1/live-voice` upgrade to the bound guardian), but the
+  // live-voice ingress bypasses the send-message route, so without this stamp
+  // the turn resolved to the fail-closed `unknown` trust class and every
+  // sensitive tool was denied. Resolution stays fail-closed: a gateway miss /
+  // missing binding leaves the context unset (`unknown`), never a blind grant.
+  const trustContext = await resolveLocalLiveVoiceTrustContext(
+    options.conversationId,
+  );
   const { startVoiceTurn } = await import("../calls/voice-session-bridge.js");
-  return startVoiceTurn(options);
+  return startVoiceTurn({
+    ...options,
+    ...(trustContext ? { trustContext } : {}),
+  });
+}
+
+/**
+ * Resolve the local guardian's {@link TrustContext} for a live-voice turn, or
+ * `undefined` when it cannot be established (no vellum guardian binding, or
+ * the gateway is unreachable) — the turn then runs under the fail-closed
+ * `unknown` capability set, exactly as an unstamped turn does.
+ */
+async function resolveLocalLiveVoiceTrustContext(
+  conversationId: string,
+): Promise<TrustContext | undefined> {
+  const { findLocalGuardianPrincipalId } =
+    await import("../runtime/local-actor-identity.js");
+  const { resolveLocalPrincipalTrustContext } =
+    await import("../runtime/local-principal-trust.js");
+  const guardianPrincipalId = await findLocalGuardianPrincipalId();
+  if (!guardianPrincipalId) {
+    return undefined;
+  }
+  const trustContext = await resolveLocalPrincipalTrustContext({
+    actorPrincipalId: guardianPrincipalId,
+    sourceChannel: "vellum",
+    conversationExternalId: conversationId,
+  });
+  // Only stamp a positive guardian resolution; the resolver's own
+  // fail-closed `unknown` carries no more information than no stamp.
+  return trustContext.trustClass === "guardian" ? trustContext : undefined;
 }
 
 async function defaultStreamLiveVoiceTtsAudio(