@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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

@@ -17,7 +17,6 @@ import type {
 import {
   getConversationTurnTeardown,
   resolveProcessingWaitMs,
-  VOICE_NO_SETUP_FLOWS_RULE,
   waitForPriorTurnTeardown,
 } from "../calls/voice-session-bridge.js";
 import {
@@ -33,6 +32,8 @@ import {
 } from "../calls/voice-triage-escalate.js";
 import { getConfig } from "../config/loader.js";
 import {
+  type LiveVoiceFluxConfig,
+  LiveVoiceFluxConfigSchema,
   type LiveVoiceFrontModelConfig,
   LiveVoiceFrontModelConfigSchema,
 } from "../config/schemas/live-voice.js";
@@ -49,6 +50,7 @@ import {
   listProviderIds,
   pinnedListeningLanguage,
   supportsBoundary,
+  supportsProviderTurnDetection,
 } from "../providers/speech-to-text/provider-catalog.js";
 import type { ResolveStreamingTranscriberOptions } from "../providers/speech-to-text/resolve.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
@@ -71,6 +73,10 @@ import type {
 import { getSubagentManager } from "../subagent/index.js";
 import { liveVoiceEndScreen } from "../telemetry/live-voice-funnel.js";
 import { getToolOwner } from "../tools/registry.js";
+import {
+  createReasoningTagFilter,
+  type ReasoningTagFilter,
+} from "../tts/reasoning-tag-filter.js";
 import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { hasLocalizedEntry } from "../util/language-subtag.js";
@@ -81,11 +87,6 @@ import {
   dismissesUiSurface,
   revealsUiSurface,
 } from "./activity-label.js";
-import {
-  createVoiceFrontDecider,
-  type VoiceFrontDecider,
-  type VoiceProgressTextInput,
-} from "./front-decision.js";
 import { LiveActivityReporter } from "./live-activity-reporter.js";
 import type {
   LiveVoiceAudioArchiveResult,
@@ -97,9 +98,9 @@ import {
   type LiveVoiceMetricsClock,
   LiveVoiceMetricsCollector,
   type LiveVoiceMetricsEvent,
-  type LiveVoiceSpokenAckKind,
   type LiveVoiceTurnSeedMarks,
   type VoiceEndpointAction,
+  type VoiceEndpointSource,
 } from "./live-voice-metrics.js";
 import { persistLiveVoicePhoto } from "./live-voice-photo.js";
 import {
@@ -113,6 +114,11 @@ import type {
   LiveVoiceTtsOptions,
   LiveVoiceTtsResult,
 } from "./live-voice-tts.js";
+import {
+  createVoiceProgressNarrator,
+  type VoiceProgressNarrator,
+  type VoiceProgressTextInput,
+} from "./progress-narration.js";
 import {
   APPROVAL_PENDING_PHRASE_BY_LANGUAGE,
   approvalPendingPhraseFor,
@@ -161,6 +167,14 @@ const FINALIZE_GRACE_MS = 1_000;
 // cancellation cannot kill a reply mid-sentence. Mirrors the
 // liveVoice.vad.bargeInMinSpeechMs schema default; 0 disables the guard for
 // instant barge-in.
+//
+// Local energy detection owns barge-in in every mode, including when a
+// turn-detecting provider owns the turn boundary: an interrupt during TTS has
+// to feel instant, and no provider roundtrip beats a local gate on the audio
+// already in hand. The echo-adaptive part of this guard also has to stay
+// upstream of the provider, which hears only the microphone: it cannot tell
+// our own TTS bleeding through imperfect echo cancellation from the caller,
+// and would report a user turn nobody took.
 const DEFAULT_BARGE_IN_MIN_SPEECH_MS = 250;
 // The playback echo gate learns microphone energy while assistant audio is
 // expected at the speaker. Input must rise above the learned level by this
@@ -203,6 +217,12 @@ const BARGE_IN_GAP_TOLERANCE_MS = 200;
 // (1 / (1 + ratio) ≈ 20%): once the run is mostly silence it resets, so genuine
 // choppy speech still lands but periodic noise cannot accumulate into one.
 const BARGE_IN_MAX_TOLERATED_SILENCE_RATIO = 4;
+// Slack added to the configured end-of-turn timeout before the session stops
+// waiting for an event that is not coming and falls the utterance back onto
+// the silence-boundary path. A turn-detecting provider force-ends its own turn
+// at that timeout, so anything past it plus a frame's network and parse hop
+// means the stream is gone, not slow.
+const PROVIDER_TURN_END_FALLBACK_MARGIN_MS = 1_000;
 // 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;
@@ -328,19 +348,24 @@ export interface LiveVoiceSessionOptions {
    */
   finalizeGraceMs?: number;
   /**
-   * Front-model presence tuning (semantic endpointing + spoken acks). The
+   * Voice front-door endpointing and progress narration tuning. The
    * production factory seeds this from `liveVoice.frontModel` config when
    * unset; absent fields fall back to the schema defaults (the constructor
    * schema-parses the partial into a complete config).
    */
   frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
   /**
-   * Front-model phrasing service: spoken acks and progress narration. The
-   * production factory constructs it from `liveVoice.frontModel` config when
-   * unset; `null` disables front-model LLM calls, so no ack is ever spoken
-   * and narration falls back to its static phrases.
+   * Deepgram Flux turn-detection tuning. The production factory seeds this
+   * from `liveVoice.flux` config when unset; absent fields fall back to the
+   * schema defaults, which leave `turnEnd.enabled` false.
    */
-  frontDecider?: VoiceFrontDecider | null;
+  fluxConfig?: Partial<LiveVoiceFluxConfig>;
+  /**
+   * Progress narration service. The production factory constructs it from
+   * `liveVoice.frontModel.progress` config when unset. `null` disables
+   * generated narration, so progress updates use their static fallback.
+   */
+  progressNarrator?: VoiceProgressNarrator | null;
   /**
    * Spawns the background continuation for a barged-in turn. The factory wires
    * the real SubagentManager-backed implementation; tests inject a stub.
@@ -418,6 +443,29 @@ interface UtteranceCycle {
   // Consecutive semantic-endpointing "hold" extensions this utterance has
   // consumed, bounded by `endpointMaxExtensions`.
   endpointExtensionCount: number;
+  // The provider's end-of-turn never arrived for this cycle, so it fell back
+  // to the silence-boundary path and stays there: a late event must not
+  // commit a boundary the fallback already owns.
+  providerTurnEndTimedOut: boolean;
+  // The provider's own end-of-turn released this cycle, so its transcript is
+  // already complete. A provider that decides turn ends commits the transcript
+  // in the same event, so such a release needs no caller-side flush and must
+  // not tear the stream down. False on every caller-side release (the fail-open
+  // deadline, a max-duration force-end, barge-in), where a turn may still be
+  // open provider-side and only a stream close can make it answer.
+  providerClosedTurn: boolean;
+  // `vadSpeechGeneration` as of the local silence boundary that handed this
+  // cycle to the provider, or null while no boundary has fired yet (a turn
+  // model routinely beats the trailing-silence countdown, and that fast commit
+  // is the point).
+  // The staleness signal of last resort: it stands in for the provider's own
+  // turn numbering when the provider sends none (see isStaleProviderTurnEnd).
+  turnBoundaryGeneration: number | null;
+  // Index of the newest provider turn opened in this cycle, from the turn
+  // model's own numbering, or null when the provider does not number its
+  // turns. An end-of-turn closing an older index describes a turn the
+  // provider has already superseded (see isStaleProviderTurnEnd).
+  openProviderTurnIndex: number | null;
   // The transcript the most recent hold verdict judged (unified front-door).
   // A final segment arriving during the extension window that extends this
   // text replays the boundary immediately — the hold was judged on stale
@@ -668,27 +716,11 @@ interface ActiveAssistantTurn {
   // context. A bump since then means a stop/interrupt/supersede deliberately
   // dropped the continuation, so a rollback must not resurrect it.
   pendingContextStopGeneration: number;
-  // The agent run started a definitive tool use this turn — tool use implies
-  // a guaranteed-slow turn, so acknowledgment logic can key off this.
-  toolUseStarted: boolean;
-  // The model's first streamed delta reached this session — the spoken-ack
-  // timer is moot once real output is flowing.
-  firstDeltaSeen: boolean;
   // Counts assistant text deltas seen this turn. A narration generation
   // captures it at launch and discards its result if it moved: text the model
   // produced mid-generation makes the narration stale, and proves the model
   // is alive — which is exactly what narration exists to paper over.
   deltaEpoch: number;
-  // A spoken ack was enqueued this turn. Every ack trigger shares this
-  // one-per-turn budget so a slow turn never stacks fillers.
-  ackSpoken: boolean;
-  // An ack generation is awaiting the decider. While true, the ack has not
-  // yet stamped `lastFloorHolderAtMs`, so narration must treat it as a
-  // floor-holder-in-waiting and stand down —
-  // otherwise a progress phrase could land back-to-back with the ack.
-  ackGenerationPending: boolean;
-  // Pending slow-first-delta ack timer; null once cleared or fired.
-  ackTimer: ReturnType<typeof setTimeout> | null;
   // Triage-and-escalate (Voice Mode): the front-door leg gave the escalate
   // verdict and the strong "escalated" leg has taken over this same turn.
   // Guards the
@@ -696,6 +728,10 @@ interface ActiveAssistantTurn {
   // the hand-off idempotent.
   escalationHandedOff: boolean;
   ttsBuffer: string;
+  // Strips inline <think> reasoning spans from the spoken stream. Stateful
+  // per turn because spans and tags cross delta boundaries; display frames
+  // keep the raw text.
+  ttsReasoningFilter: ReasoningTagFilter;
   // A non-empty speakable segment reached the TTS queue — gates the eager
   // first-segment flush that trades clause quality for speech onset.
   ttsSegmentEnqueued: boolean;
@@ -783,6 +819,20 @@ const LIVE_VOICE_CONTROL_PROMPT_BASE =
 const LIVE_VOICE_SCREEN_REVEAL_TEACHING =
   "The call renders as a full-screen overlay covering the app. Whenever you put something on screen, the overlay minimizes by itself as soon as you finish speaking, and the user is looking at what you made. So speak as if you are showing it to them right now (for example, close with something like: take a look), and never say you cannot show it, that this is a voice call, or that they should check it later. Never emit bracketed markers of any kind. ";
 
+// The setup-flow case, spelled out because it is the one the model gets wrong
+// on its own: connecting an account reads as something a call cannot do, so it
+// declines and offers to do it later in text, which is the exact thing the base
+// prompt above forbids.
+//
+// It can do it. The connect card is a ui surface like any other, so showing it
+// minimizes the room on the same latch (`revealsUiSurface`), and the user is at
+// the screen the browser window opens on. Appended alongside the screen-reveal
+// teaching, to the same legs, for the same reason: the front-door leg is
+// toolless, so a setup flow is not its to run, and its capability digest
+// already tells it to escalate anything needing a tool rather than refuse.
+const LIVE_VOICE_SETUP_FLOW_TEACHING =
+  "This includes connecting accounts. If a task needs an account connected or a sign-in completed, put the connection up on screen and let the user do it now. Do not decline it, and do not defer it to text chat. Say what you are connecting and that it is in front of them. ";
+
 // 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
@@ -839,21 +889,21 @@ function buildLiveDeliveryNote(request: string, answer: string): string {
   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}`;
 }
 
-// Assemble a leg's model-facing control prompt: the base live-voice rules,
-// the screen-reveal teaching (withheld from the front-door leg, see
-// LIVE_VOICE_SCREEN_REVEAL_TEACHING), the shared no-setup-flows rule, 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.
+// 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.
 function buildVoiceControlPrompt(
   turn: ActiveAssistantTurn,
   leg: { frontDoor?: boolean },
 ): string {
   let prompt =
     LIVE_VOICE_CONTROL_PROMPT_BASE +
-    (leg.frontDoor === true ? "" : LIVE_VOICE_SCREEN_REVEAL_TEACHING) +
-    VOICE_NO_SETUP_FLOWS_RULE;
+    (leg.frontDoor === true
+      ? ""
+      : LIVE_VOICE_SCREEN_REVEAL_TEACHING + LIVE_VOICE_SETUP_FLOW_TEACHING);
   if (turn.language !== undefined) {
     prompt = `${prompt}\n\nThe caller has been speaking the language with code "${turn.language}" this turn. Reply in that language unless they clearly switch to another.`;
   }
@@ -904,6 +954,10 @@ function createUtteranceCycle(): UtteranceCycle {
     finalTranscriptSegments: [],
     latestPartialText: null,
     endpointExtensionCount: 0,
+    providerTurnEndTimedOut: false,
+    providerClosedTurn: false,
+    turnBoundaryGeneration: null,
+    openProviderTurnIndex: null,
     heldSpeculativeContent: null,
     languageTally: new Map(),
     latestPartialLanguages: null,
@@ -1170,12 +1224,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // replayed once the parked speech flushes into the next armed utterance.
   private vadPendingTurnEnd: "silence" | "max-duration" | null = null;
   private readonly metricsClock: LiveVoiceMetricsClock;
-  // Persistent mode: server-VAD sessions with a finalize-capable provider
-  // keep one streaming transcriber for the whole session. Utterance release
-  // flushes via finalizeUtterance() instead of tearing the stream down, and
-  // re-arm reuses this instance synchronously. Null in manual mode, for
-  // providers without finalizeUtterance, and after an unexpected stream
-  // close (the next arm resolves a fresh transcriber).
+  // 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
+  // finalizeUtterance()) or the provider decides turn ends itself (release is
+  // already sealed by the end-of-turn that triggered it). Re-arm reuses this
+  // instance synchronously. Null in manual mode, for a stream that offers
+  // neither seal, and after an unexpected stream close (the next arm resolves
+  // a fresh transcriber).
   private sharedTranscriber: StreamingTranscriber | null = null;
   // The `services.stt.language` value the shared stream was dialed with.
   // Providers pin the language per connection, so the persistent re-arm
@@ -1200,13 +1256,38 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private readonly finalizeGraceMs: number;
   // Rotates through the progress fallback phrases across the session's turns.
   private progressPhraseCounter = 0;
-  // Front-model service: phrases spoken acks and progress narration; null
-  // disables both (the turn then holds the floor with silence).
-  private readonly frontDecider: VoiceFrontDecider | null;
+  // Progress-only phrasing service. It never makes routing decisions and
+  // never emits an answer.
+  private readonly progressNarrator: VoiceProgressNarrator | null;
   // Complete front-model tunables: the constructor schema-parses the partial
   // option once, so every field carries its `liveVoice.frontModel` schema
   // default when unset.
   private readonly frontModelConfig: LiveVoiceFrontModelConfig;
+  // 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;
+  // 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
+  // commits the turn, and the anchor for the provider fallback deadline. Null
+  // in push-to-talk, where no local VAD runs.
+  private localSpeechStopAtMs: number | null = null;
+  // Fail-open deadline for a provider end-of-turn that never arrives. On
+  // expiry the utterance falls back to the silence-boundary path, so a dead
+  // provider stream degrades to the silence-path behavior instead of a hung
+  // turn.
+  private providerTurnEndTimer: ReturnType<typeof setTimeout> | null = null;
   // Effective trailing-silence threshold, mirroring the detector's private
   // copy (constructor seed + update_config), reported to the endpoint decider.
   private silenceThresholdMs: number;
@@ -1276,10 +1357,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.echoDrainSlackMs =
       options.echoDrainSlackMs ?? DEFAULT_ECHO_DRAIN_SLACK_MS;
     this.finalizeGraceMs = options.finalizeGraceMs ?? FINALIZE_GRACE_MS;
-    this.frontDecider = options.frontDecider ?? null;
+    this.progressNarrator = options.progressNarrator ?? null;
     this.frontModelConfig = LiveVoiceFrontModelConfigSchema.parse(
       options.frontModelConfig ?? {},
     );
+    this.fluxConfig = LiveVoiceFluxConfigSchema.parse(options.fluxConfig ?? {});
     const turnDetectorConfig: TurnDetectorConfig = {
       ...(options.turnDetectorConfig ?? {}),
       ...(context.startFrame.silenceThresholdMs !== undefined
@@ -1455,6 +1537,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.liveActivityReporter.end();
     this.turnDetector?.dispose();
     this.clearEndpointExtensionTimer();
+    this.clearProviderTurnEndTimer();
     // 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
@@ -1506,11 +1589,28 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
 
     try {
-      // One language snapshot serves both the dial and the re-arm
-      // comparison: passing it to the resolver keeps the stream's actual
-      // language and the recorded sharedTranscriberLanguage identical even
-      // when config changes while the resolver awaits credentials.
-      const sttLanguage = getConfig().services.stt.language;
+      // One config snapshot serves the dial, the re-arm comparison and the
+      // latch seed below: passing the language to the resolver keeps the
+      // stream's actual language and the recorded sharedTranscriberLanguage
+      // identical even when config changes while the resolver awaits
+      // credentials.
+      const stt = getConfig().services.stt;
+      const sttLanguage = stt.language;
+      // Seed the latch from the CONFIGURED provider before the dial, not
+      // only from the resolved one after it. `start()` sends `ready` without
+      // waiting on this resolve, so the caller can speak and close an entire
+      // silence boundary while the provider handshake is still in flight. A
+      // latch still on its default `false` at that boundary hands the first
+      // turn of the session to the silence path and then ignores the
+      // provider end-of-turn that follows, which is invisible from the
+      // outside: the session looks like a turn-detecting session while its
+      // opening turn is not one. The resolved provider reconciles this guess
+      // below.
+      this.setProviderTurnEndActive(
+        this.fluxConfig.turnEnd.enabled &&
+          supportsProviderTurnDetection(stt.provider as SttProviderId) &&
+          this.turnDetector !== null,
+      );
       const transcriber = await this.resolveTranscriber({
         sampleRate: this.context.startFrame.audio.sampleRate,
         ...(sttLanguage ? { language: sttLanguage } : {}),
@@ -1522,6 +1622,9 @@ 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);
         return {
           status: "unavailable",
           message: unavailableTranscriberMessage(),
@@ -1530,9 +1633,27 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
       utterance.transcriber = transcriber;
       utterance.dialedSttProvider = transcriber.providerId;
+      // Reconcile the pre-dial guess with the provider that actually
+      // answered. The resolver reads the provider from config, which cannot
+      // 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) &&
+          this.turnDetector !== null,
+      );
       if (
         this.turnDetector &&
-        typeof transcriber.finalizeUtterance === "function"
+        (typeof transcriber.finalizeUtterance === "function" ||
+          // A provider that owns the turn boundary needs no caller-side flush
+          // on the normal path: its end-of-turn IS the flush, and it commits
+          // the transcript in the same event. Gating persistence on
+          // `finalizeUtterance` alone asks "can the caller flush this stream"
+          // when the question is "will the caller ever have to", and answering
+          // it wrong costs a socket per utterance, which drops the audio that
+          // arrives while the next one dials.
+          this.providerTurnEndActive)
       ) {
         // Adopt persistent mode: this stream serves the whole session, so
         // its events route by cycle ownership instead of binding to this
@@ -1563,6 +1684,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       if (this.isUtteranceStale(utterance)) {
         return { status: "stale" };
       }
+      // 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);
       return {
         status: "error",
         message: `Live voice transcription could not be started: ${errorMessage(
@@ -1690,6 +1814,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     this.state = "failed";
     this.clearEndpointExtensionTimer();
+    this.clearProviderTurnEndTimer();
     await this.sendFrame({
       type: "error",
       code:
@@ -1763,6 +1888,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     const hasSpeech = energyClassification === "speech";
     detector.onMediaChunk(hasSpeech);
     this.trackBargeInGuard(energyClassification, chunk);
+    if (hasSpeech) {
+      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
@@ -2163,6 +2291,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // utterance keeps accumulating and the detector fires a fresh turn-end.
     this.vadSpeechGeneration += 1;
     this.clearEndpointExtensionTimer();
+    // ...and so is a fallback deadline armed for the boundary the caller just
+    // spoke through. The next silence boundary arms a fresh one.
+    this.clearProviderTurnEndTimer();
 
     // Speech resumed while a speculative leg was awaiting its verdict: the
     // pause was mid-thought after all. Discard silently (no frames were ever
@@ -2319,7 +2450,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // Tagged reason: provider catch-sites classify untagged caller aborts as
     // retryable transport failures (ERROR log + futile retry against the
     // aborted signal). This signal reaches the brain leg and any in-flight
-    // ack generation.
+    // progress narration.
     turn.abortController.abort(
       createAbortReason("voice_session_aborted", "live-voice-barge-in"),
     );
@@ -3072,8 +3203,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.pendingBargeIn = null;
       if (reason === "max-duration") {
         // A max-duration boundary always releases: drop any pending hold
-        // replay so it cannot re-fire a boundary this one already owns.
+        // replay (or provider fallback deadline) so it cannot re-fire a
+        // boundary this one already owns.
         this.clearEndpointExtensionTimer();
+        this.clearProviderTurnEndTimer();
       }
       const utterance = this.currentUtterance;
       if (!utterance || utterance.released || utterance.completed) {
@@ -3095,6 +3228,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // release (ptt_release forced the boundary) is the user saying "answer
       // now" — never second-guess it.
       if (reason === "silence" && !manualRelease) {
+        // The provider owns this boundary: its end-of-turn commits the
+        // utterance, so the silence timer only arms the fail-open deadline. An
+        // utterance whose deadline already elapsed falls through to the hold
+        // path below, which is the whole point of the fallback.
+        if (this.providerTurnEndActive && !utterance.providerTurnEndTimedOut) {
+          // Stamp the speech run this boundary closed. This is the staleness
+          // signal of last resort, used only for a provider that does not
+          // number its turns: where the provider's own turn index is on the
+          // wire it answers the question directly (see
+          // isStaleProviderTurnEnd).
+          utterance.turnBoundaryGeneration = this.vadSpeechGeneration;
+          this.armProviderTurnEndFallbackTimer(utterance);
+          return;
+        }
         if (await this.launchSpeculativeAssistantTurn(utterance)) {
           return;
         }
@@ -3125,6 +3272,221 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }, this.frontModelConfig.endpointExtensionMs);
   }
 
+  // Arms the fail-open deadline for a provider end-of-turn. A turn-detecting
+  // provider force-ends its own turn after `eotTimeoutMs` of silence, so once
+  // that budget plus a margin has passed since the caller stopped speaking, no
+  // 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).
+  private armProviderTurnEndFallbackTimer(
+    utterance: UtteranceCycle,
+    waitMsOverride?: number,
+  ): void {
+    this.clearProviderTurnEndTimer();
+    const budgetMs =
+      this.fluxConfig.eotTimeoutMs + PROVIDER_TURN_END_FALLBACK_MARGIN_MS;
+    const waitMs =
+      waitMsOverride ?? Math.max(0, budgetMs - this.msSinceLocalSpeechStop());
+    this.providerTurnEndTimer = setTimeout(() => {
+      this.providerTurnEndTimer = null;
+      if (
+        this.currentUtterance !== utterance ||
+        utterance.released ||
+        utterance.completed ||
+        utterance.assistantTurnStarted ||
+        // Speech resumed (the detector owns the next boundary). Onset also
+        // clears this timer, so this is a belt to that suspender.
+        this.turnDetector?.isActive
+      ) {
+        return;
+      }
+      utterance.providerTurnEndTimedOut = true;
+      log.warn(
+        { budgetMs, waitMs },
+        "No provider end-of-turn is coming; falling back to the silence boundary for this utterance",
+      );
+      this.handleVadUtteranceEnd("silence");
+    }, waitMs);
+  }
+
+  /**
+   * 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.
+   */
+  private setProviderTurnEndActive(active: boolean): void {
+    if (active === this.providerTurnEndActive) {
+      return;
+    }
+    this.providerTurnEndActive = active;
+    if (active || this.providerTurnEndTimer === null) {
+      return;
+    }
+    const utterance = this.currentUtterance;
+    this.clearProviderTurnEndTimer();
+    if (utterance && !utterance.released && !utterance.completed) {
+      this.armProviderTurnEndFallbackTimer(utterance, 0);
+    }
+  }
+
+  /**
+   * 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).
+   */
+  private recordProviderTurnStart(
+    utterance: UtteranceCycle,
+    turnIndex: number | undefined,
+  ): void {
+    if (turnIndex === undefined) {
+      return;
+    }
+    utterance.openProviderTurnIndex = turnIndex;
+  }
+
+  /**
+   * A provider end-of-turn that lost its race with the caller's next breath:
+   * it describes speech the caller has already spoken past. Acting on one
+   * would send utterance_end and stop the transcriber while local VAD is
+   * still routing the resumed speech into this same cycle, cutting off the
+   * next words or folding them into the wrong turn.
+   *
+   * The provider's own turn numbering answers this directly and is preferred
+   * wherever it is available: the cycle records the newest turn the provider
+   * has opened, so an end-of-turn for an older index closes a turn the
+   * provider itself has already superseded. An end-of-turn for the turn still
+   * in progress is never stale, however many times the caller drew breath
+   * inside it: the mid-thought pause is exactly the case a provider's turn
+   * model exists to judge, and its verdict covers the resumed speech too.
+   *
+   * With no turn numbering the local speech generation is the only signal
+   * left. The silence boundary stamps the cycle with the generation it
+   * closed and `handleVadSpeechStart` bumps that generation when the caller
+   * resumes, so a turn-end arriving on a newer generation is treated as
+   * stale. That is conservative: it also drops the fast end-of-turn this
+   * feature exists for, which the turn index would have committed. Before
+   * any boundary has fired the stamp is null and nothing is stale.
+   */
+  private isStaleProviderTurnEnd(
+    utterance: UtteranceCycle,
+    turnIndex: number | undefined,
+  ): boolean {
+    if (turnIndex !== undefined && utterance.openProviderTurnIndex !== null) {
+      return turnIndex < utterance.openProviderTurnIndex;
+    }
+    return (
+      utterance.turnBoundaryGeneration !== null &&
+      utterance.turnBoundaryGeneration !== this.vadSpeechGeneration
+    );
+  }
+
+  private clearProviderTurnEndTimer(): void {
+    if (this.providerTurnEndTimer !== null) {
+      clearTimeout(this.providerTurnEndTimer);
+      this.providerTurnEndTimer = null;
+    }
+  }
+
+  // Time since the local VAD last heard above-gate audio: the speech-stop
+  // mark both the fallback deadline and the reported end-of-turn latency are
+  // measured from. Zero when no speech has been heard at all.
+  private msSinceLocalSpeechStop(): number {
+    if (this.localSpeechStopAtMs === null) {
+      return 0;
+    }
+    return Math.max(0, Date.now() - this.localSpeechStopAtMs);
+  }
+
+  /**
+   * The provider committed an end of turn: the caller has finished, so the utterance
+   * commits now instead of waiting out the trailing-silence timer and asking
+   * the front door whether the pause was mid-thought. This runs the ordinary
+   * post-release path (utterance_end, then release), so the front-door leg it
+   * dispatches is non-speculative: `speculativeHoldAllowed` is false, its
+   * decision rule is built with `includeHold: false`, and the model is told
+   * the caller has finished. Escalation and progress narration are untouched;
+   * only the hold verdict is bypassed.
+   */
+  private async handleProviderTurnEnd(
+    utterance: UtteranceCycle,
+    turnIndex: number | undefined,
+  ): Promise<void> {
+    if (
+      !this.providerTurnEndActive ||
+      this.currentUtterance !== utterance ||
+      utterance.released ||
+      utterance.completed ||
+      utterance.assistantTurnStarted ||
+      // The fallback already took this utterance back to the silence path.
+      utterance.providerTurnEndTimedOut
+    ) {
+      return;
+    }
+    if (this.isStaleProviderTurnEnd(utterance, turnIndex)) {
+      // At `info`, not `debug`: a drop is rare and is the only signal of the
+      // one known latency-outlier mode, so an operator measuring the two
+      // paths has to be able to see it at the default log level.
+      log.info(
+        {
+          turnIndex,
+          openTurnIndex: utterance.openProviderTurnIndex,
+          boundaryGeneration: utterance.turnBoundaryGeneration,
+          speechGeneration: this.vadSpeechGeneration,
+        },
+        "Dropping a stale provider end-of-turn: the caller resumed speaking past the boundary it closed",
+      );
+      // The cycle stays open and local VAD keeps routing the resumed speech
+      // into it. The detector's next silence boundary re-stamps the
+      // generation and re-arms the fail-open deadline, so the turn still
+      // commits: on the end-of-turn for the resumed speech, or on that
+      // deadline. Re-arm here only if the detector has somehow already gone
+      // idle, so the deadline handleVadSpeechStart cleared can never strand
+      // the cycle with nothing left to close it.
+      if (this.turnDetector?.isActive !== true) {
+        utterance.turnBoundaryGeneration = this.vadSpeechGeneration;
+        this.armProviderTurnEndFallbackTimer(utterance);
+      }
+      return;
+    }
+    this.clearProviderTurnEndTimer();
+    this.markEndpointDecision(
+      utterance,
+      "release",
+      this.msSinceLocalSpeechStop(),
+      "provider",
+    );
+    await this.sendFrame({ type: "utterance_end", reason: "silence" });
+    // The provider committed this cycle's transcript in the event being
+    // handled, so the release below seals it in place instead of flushing or
+    // 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.
+    this.turnDetector?.forceEnd();
+  }
+
   /**
    * Unified front-door: dispatch the assistant turn speculatively at the
    * silence boundary, judging the transcript accumulated so far — the same
@@ -3204,13 +3566,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (!alreadyReleased) {
       void this.releaseUtterance();
     }
-    if (this.streamTtsAudio) {
-      this.armAckTimer(turn);
-    }
     if (
       this.frontModelConfig.progress.enabled &&
       this.streamTtsAudio &&
-      this.frontDecider
+      this.progressNarrator
     ) {
       this.armProgressIdleTimer(turn);
     }
@@ -3344,6 +3703,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       !utterance.completed
     ) {
       this.clearEndpointExtensionTimer();
+      this.clearProviderTurnEndTimer();
       await this.sendFrame({ type: "utterance_end", reason: "silence" });
     }
     await this.releaseUtterance();
@@ -3358,6 +3718,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (utterance.phase === "transcriber_closed") {
       utterance.released = true;
       this.markUtteranceReleased(utterance);
+      this.markEndpointCommit(utterance);
       await this.startAssistantTurnIfReady();
       await this.drainOutboundFrames();
       return;
@@ -3369,6 +3730,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
 
     utterance.released = true;
     this.markUtteranceReleased(utterance);
+    this.markEndpointCommit(utterance);
 
     if (utterance.phase === "pending") {
       // The transcriber is still starting; beginUtterance completes the release.
@@ -3383,8 +3745,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   ): Promise<void> {
     const shared = this.sharedTranscriber;
     if (shared && utterance.transcriber === shared) {
-      await this.finalizeUtteranceForRelease(utterance);
-      return;
+      if (typeof shared.finalizeUtterance === "function") {
+        await this.finalizeUtteranceForRelease(utterance);
+        return;
+      }
+      if (utterance.providerClosedTurn) {
+        await this.sealProviderClosedUtterance(utterance);
+        return;
+      }
+      // A caller-side boundary on a stream with no flush: only closing it can
+      // make the provider answer for a turn still open, so this one release
+      // costs the stream. The stream stays installed as the shared one across
+      // the close: its flush `final` and its `closed` both arrive after
+      // `stop()`, and the shared router drops events from a stream it no
+      // longer recognizes. `closed` is what retires it, seals this cycle and
+      // dispatches the turn, so clearing the reference here would strand the
+      // cycle in `released` with the flushed transcript discarded. Nothing can
+      // re-arm onto the closing stream in the meantime: the next arm waits on
+      // the assistant turn, which waits on that same `closed`.
     }
 
     utterance.phase = "released";
@@ -3404,6 +3782,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     await this.drainOutboundFrames();
   }
 
+  // Persistent-mode release for a provider-decided turn end: the event that
+  // released this cycle already carried its final transcript, so there is
+  // nothing to flush and no reason to close the stream. Sealing the phase is
+  // the whole of the teardown: the same "transcript complete, stream open"
+  // state the `finalized` path reaches, arrived at without a round trip.
+  private async sealProviderClosedUtterance(
+    utterance: UtteranceCycle,
+  ): Promise<void> {
+    if (utterance.phase === "transcriber_closed") {
+      return;
+    }
+    utterance.phase = "transcriber_closed";
+    await this.startAssistantTurnIfReady();
+    await this.drainOutboundFrames();
+  }
+
   // Persistent-mode release: flush the shared stream's buffered audio with
   // finalizeUtterance() instead of tearing the stream down. The assistant
   // turn starts on the `finalized` event; the grace timer bounds a flush
@@ -3546,6 +3940,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // Per-cycle transcribers are torn down with stop(); the finalize
         // 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);
+        return;
+      case "eager-turn-end":
+      case "turn-resumed":
+        // Speculative end-of-turn stays off (the config leaves
+        // `eagerEotThreshold` unset, so Deepgram never emits these). Wiring
+        // them onto the speculative dispatch machinery is a deferred
+        // follow-up.
+        return;
+      case "turn-end":
+        await this.handleProviderTurnEnd(utterance, event.turnIndex);
+        return;
       case "error":
         await this.sendTranscriberErrorFrame(event);
         return;
@@ -3567,6 +3979,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         }
         await this.startAssistantTurnIfReady();
         return;
+      default: {
+        const _exhaustive: never = event;
+        return;
+      }
     }
   }
 
@@ -3670,6 +4086,34 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         await this.startAssistantTurnIfReady();
         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);
+        }
+        return;
+      }
+      case "eager-turn-end":
+      case "turn-resumed":
+        // Speculative end-of-turn stays off (the config leaves
+        // `eagerEotThreshold` unset, so Deepgram never emits these). Wiring
+        // them onto the speculative dispatch machinery is a deferred
+        // follow-up.
+        return;
+      case "turn-end": {
+        // Same routing as transcript events: the cycle awaiting its
+        // transcript owns the turn the provider just closed.
+        const target = this.pendingTranscriptCycle();
+        if (target) {
+          await this.handleProviderTurnEnd(target, event.turnIndex);
+        }
+        return;
+      }
       case "error":
         await this.sendTranscriberErrorFrame(event);
         return;
@@ -3709,6 +4153,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         await this.startAssistantTurnIfReady();
         return;
       }
+      default: {
+        const _exhaustive: never = event;
+        return;
+      }
     }
   }
 
@@ -3844,8 +4292,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.assistantPlaybackTailUntilMs = 0;
     this.takeVadPreRoll();
     this.vadPendingTurnEnd = null;
-    // ...and abandons any semantic-endpointing hold still awaiting replay.
+    // ...and abandons any semantic-endpointing hold still awaiting replay,
+    // along with any provider end-of-turn the session was still waiting on.
     this.clearEndpointExtensionTimer();
+    this.clearProviderTurnEndTimer();
     // 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).
@@ -4112,14 +4562,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       consumedAnnouncement: pending?.announcement ?? null,
       pendingContextStopGeneration: this.detachStopGeneration,
       continuationDelivery: opts?.continuationDelivery ?? null,
-      toolUseStarted: false,
-      firstDeltaSeen: false,
       deltaEpoch: 0,
-      ackSpoken: false,
-      ackGenerationPending: false,
-      ackTimer: null,
       escalationHandedOff: false,
       ttsBuffer: "",
+      ttsReasoningFilter: createReasoningTagFilter(),
       ttsSegmentEnqueued: false,
       ttsJobs: [],
       ttsQueue: Promise.resolve(),
@@ -4142,8 +4588,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // Verdict-deadline fail-open: the deferred-everything window is only
       // safe while the verdict is fast. If the leg produces no verdict
       // within the endpoint budget (provider TTFT tail), commit anyway so
-      // the thinking frame shows and the ack timer arms — bounded dead air
-      // instead of unbounded structural silence. A verdict that arrives
+      // the thinking frame shows and progress narration can begin, bounding
+      // the structural silence. A verdict that arrives
       // after the commit still works: escalate hands off normally, and a
       // late hold token is stripped like any stray token (the utterance is
       // already released, so holding is no longer possible).
@@ -4166,22 +4612,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       }, this.frontModelConfig.endpointDecisionTimeoutMs);
     }
 
-    // Slow-first-delta spoken ack: if the model produces no delta within the
-    // budget, a short front-model-phrased sentence holds the floor. Only
-    // meaningful on TTS sessions — a text-only session has no audio gap to
-    // bridge.
-    if (this.streamTtsAudio && !opts?.speculative) {
-      this.armAckTimer(activeTurn);
-    }
-
     // Progress narration speaks into the turn's audible dead air on a
-    // cadence, wherever in the turn it occurs; without TTS or a decider there
+    // cadence, wherever in the turn it occurs; without TTS or a narrator there
     // is nothing to speak (the idle trigger's static fallback still needs a
     // generation attempt to fall back from).
     if (
       this.frontModelConfig.progress.enabled &&
       this.streamTtsAudio &&
-      this.frontDecider &&
+      this.progressNarrator &&
       !opts?.speculative
     ) {
       this.armProgressIdleTimer(activeTurn);
@@ -4218,9 +4656,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * escalate verdict the post-verdict stream buffers into the capped bridge
    * and `escalateTurn` starts a second "escalated" leg that shares this same
    * ActiveAssistantTurn. The persisted assistant row is reduced to the capped
-   * bridge by the bridge's teardown transcript-hygiene pass; the shared
-   * conversation-hub broadcast still streams the raw verdict deltas mid-turn
-   * until the turn-end resync (the remaining scope of issue #37850).
+   * bridge by the bridge's teardown transcript-hygiene pass, and the shared
+   * conversation-hub broadcast releases the same capped bridge through the
+   * bridge's front-door stream gate, so no verdict token reaches a hub
+   * subscriber mid-turn.
    */
   private async startAssistantLeg(
     activeTurn: ActiveAssistantTurn,
@@ -4254,7 +4693,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         return;
       }
       this.markFirstAssistantDelta(utterance, turnId);
-      this.markFirstDeltaForAck(activeTurn);
+      this.markAssistantDelta(activeTurn);
       // Send-time abort gate: a delta queued behind a backed-up outbound
       // frame must not be written once barge-in aborts the turn, or the
       // cancelled reply's text leaks ahead of turn_cancelled. Key off this
@@ -4492,7 +4931,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             if (current?.token !== token) {
               return;
             }
-            current.toolUseStarted = true;
             // Foreground wins the workspace: the continuation runs with full
             // subagent abilities (it can write files, run commands), so the
             // moment a live turn starts a consequential tool the two could
@@ -4541,21 +4979,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             current.progress.stateEpoch += 1;
             this.refreshActivity(current);
             log.debug({ turnId, toolName }, "Live voice turn started tool use");
-            // Definitive tool use means the turn is guaranteed slow: speak
-            // the floor-holding ack now instead of waiting out the
-            // first-delta timer (same one-ack-per-turn `ackSpoken` budget).
-            // Post-handoff the escalation bridge phrase holds the floor and
-            // front-door deltas never set firstDeltaSeen, so the escalated
-            // leg's tool starts must not stack another filler on the bridge.
-            if (
-              this.streamTtsAudio &&
-              !current.firstDeltaSeen &&
-              !current.ackSpoken &&
-              !current.escalationHandedOff
-            ) {
-              this.clearAckTimer(current);
-              this.speakAck(current, "tool_use", toolName);
-            }
             this.maybeNarrateProgress(current, "ops");
           },
           tool_result: (event) => {
@@ -4709,9 +5132,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
     activeTurn.escalationHandedOff = true;
-    // The escalation bridge below holds the floor, so a pending
-    // slow-first-delta ack or progress narration would only stack a second
-    // filler on top of it.
+    // The escalation bridge below holds the floor, so pending progress
+    // narration would only stack a second filler on top of it.
     this.clearFillerTimers(activeTurn);
     // Abort the front-door leg so a model that keeps generating past the
     // bridge cap adds no latency before the escalated leg starts.
@@ -4728,7 +5150,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       : cappedBridge;
     if (!usesFallbackBridge) {
       this.markFirstAssistantDelta(activeTurn.utterance, activeTurn.turnId);
-      this.markFirstDeltaForAck(activeTurn);
+      this.markAssistantDelta(activeTurn);
       void this.sendFrame(
         { type: "assistant_text_delta", text: spokenBridge },
         () => !activeTurn.abortController.signal.aborted && !this.isClosed,
@@ -4774,7 +5196,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     if (
       this.frontModelConfig.progress.enabled &&
       this.streamTtsAudio &&
-      this.frontDecider
+      this.progressNarrator
     ) {
       this.armProgressIdleTimer(activeTurn);
     }
@@ -4846,42 +5268,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     );
   }
 
-  // Arms the slow-first-delta ack timer for a just-launched turn: on expiry,
-  // if no assistant delta has arrived and the turn is still live, one short
-  // phrase is spoken to hold the floor.
-  private armAckTimer(activeTurn: ActiveAssistantTurn): void {
-    const { token } = activeTurn;
-    activeTurn.ackTimer = setTimeout(() => {
-      activeTurn.ackTimer = null;
-      if (
-        !this.isActiveAssistantTurn(token) ||
-        activeTurn.firstDeltaSeen ||
-        activeTurn.ackSpoken
-      ) {
-        return;
-      }
-      this.speakAck(activeTurn, "first_delta");
-    }, this.frontModelConfig.ackFirstDeltaTimeoutMs);
-  }
-
-  private clearAckTimer(turn: ActiveAssistantTurn): void {
-    if (turn.ackTimer !== null) {
-      clearTimeout(turn.ackTimer);
-      turn.ackTimer = null;
-    }
-  }
-
-  // The model produced real output for this turn: the pending slow-first-delta
-  // ack is moot, and any in-flight narration generation is stale (it captures
-  // deltaEpoch to notice). The narration idle timer stays armed — the dead air
-  // narration exists to fill is almost always MID-turn (between tool phases,
-  // during long silent LLM calls after the model's opening words), so it must
-  // keep watching after the model speaks and re-trigger once the audio drains
-  // and silence stretches again.
-  private markFirstDeltaForAck(turn: ActiveAssistantTurn): void {
-    turn.firstDeltaSeen = true;
+  // A real assistant delta makes any in-flight progress narration stale. The
+  // idle timer stays armed so it can detect a later stretch of mid-turn
+  // silence.
+  private markAssistantDelta(turn: ActiveAssistantTurn): void {
     turn.deltaEpoch += 1;
-    this.clearAckTimer(turn);
   }
 
   // Arms (or re-arms) the dead-air narration timer. The countdown measures
@@ -4957,14 +5348,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
-  // Clears the turn's filler timers (slow-first-delta ack, dead-air
-  // narration, verdict deadline) for events that end the current filler
-  // lifecycle: escalation hand-off (which then re-arms narration for the
-  // escalated leg), barge-in, cancellation, tts-completion, finalize. Real
-  // output moots only the ack (markFirstDeltaForAck) — the narration timer
-  // keeps watching for mid-turn dead air.
+  // Clears progress narration and verdict timers for events that end the
+  // current filler lifecycle.
   private clearFillerTimers(turn: ActiveAssistantTurn): void {
-    this.clearAckTimer(turn);
     this.clearProgressIdleTimer(turn);
     if (turn.verdictDeadlineTimer !== null) {
       clearTimeout(turn.verdictDeadlineTimer);
@@ -4972,26 +5358,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
-  // A spoken ack may only speak into a live turn's pre-first-delta dead air.
-  // Once the turn is stale, the brain's first delta has arrived, an
-  // escalation hand-off has enqueued its bridge phrase (which holds the floor
-  // itself), or the turn has completed outright — a tool-only/no-text turn
-  // completes with firstDeltaSeen still false — an ack is moot and must not
-  // speak over real output, stack on the escalation bridge, or voice a
-  // finished turn.
-  private turnCanSpeakFiller(turn: ActiveAssistantTurn): boolean {
-    return (
-      this.isActiveAssistantTurn(turn.token) &&
-      !turn.firstDeltaSeen &&
-      !turn.escalationHandedOff &&
-      !turn.assistantCompleted
-    );
-  }
-
-  // Narration, unlike the ack, is not confined to the pre-first-delta window:
-  // the dead air it exists to fill is almost always mid-turn, after the
-  // model's opening words. It may speak whenever the live turn is audibly
-  // silent right now — nothing streaming, queued, or still playing — and has
+  // Narration may speak whenever the live turn is audibly silent and has
   // not completed. Escalated turns qualify too: the bridge phrase holds the
   // floor only while its audio plays (covered by the audible-idle check),
   // and the strong leg's tool loops are the longest dead air in the system.
@@ -5028,31 +5395,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     return false;
   }
 
-  // Gatekeeper for spoken progress narration: it speaks only while the turn
-  // is audibly silent, spaced `minGapMs` from any spoken floor-holder (ack or
-  // narration), one generation at a time, and — per trigger — only once the
-  // ops trigger has `opsThreshold` ops accumulated or the idle trigger has
-  // something new to report. No per-turn count cap: the cadence guards bound
-  // the rate, and going quiet deep into a long turn is the failure mode
-  // narration exists to prevent. Every failing guard short-circuits silently;
-  // a skipped ops trigger keeps its accumulated count, so the next tool event
-  // or idle tick retries.
+  // Gatekeeper for progress narration. It speaks only while the turn is
+  // audibly silent, with one generation at a time and the configured spacing.
   private maybeNarrateProgress(
     turn: ActiveAssistantTurn,
     trigger: "ops" | "idle" | "op_complete",
   ): void {
     const cfg = this.frontModelConfig.progress;
     const { progress } = turn;
-    const frontDecider = this.frontDecider;
+    const progressNarrator = this.progressNarrator;
     if (
       !cfg.enabled ||
       !this.streamTtsAudio ||
-      !frontDecider ||
+      !progressNarrator ||
       !this.turnCanNarrateProgress(turn) ||
-      // A pending ack generation is a floor-holder-in-waiting: starting a
-      // narration generation now would only be discarded by the post-await
-      // re-check once the ack enqueues — a guaranteed wasted provider call.
-      turn.ackGenerationPending ||
       progress.narrationInFlight ||
       (progress.lastFloorHolderAtMs !== null &&
         Date.now() - progress.lastFloorHolderAtMs < cfg.minGapMs) ||
@@ -5061,25 +5417,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     ) {
       return;
     }
-    void this.speakProgressUpdate(turn, frontDecider, trigger);
+    void this.speakProgressUpdate(turn, progressNarrator, trigger);
   }
 
-  // Generate and speak one progress narration. Like the ack, it is audio-only
-  // — no assistant_text_delta frame — and enqueues as a standalone sentence
-  // on the turn's ordered TTS queue. The decider internally bounds the call
-  // by `progress.generationTimeoutMs` and resolves null on every failure
-  // mode; on null the idle trigger falls back to a static phrase (silence is
-  // actively harmful there) while the tool-activity triggers stay silent — a
-  // generic filler is not worth it when narration was merely opportunistic.
+  // Generate and speak one audio-only progress narration. On a null result,
+  // idle narration falls back to a static phrase while activity-triggered
+  // narration stays silent.
   private async speakProgressUpdate(
     turn: ActiveAssistantTurn,
-    frontDecider: VoiceFrontDecider,
+    progressNarrator: VoiceProgressNarrator,
     trigger: "ops" | "idle" | "op_complete",
   ): Promise<void> {
     const { progress } = turn;
     progress.narrationInFlight = true;
-    // Any delta that lands while the decider call is in flight makes the
-    // generated text stale — and proves the model is speaking again.
+    // Any delta that lands while generation is in flight makes the text stale.
     const deltaEpochAtLaunch = turn.deltaEpoch;
     // The activity this update describes. Tool events that land mid-generation
     // are news the generated text cannot carry, so they must leave the idle
@@ -5097,7 +5448,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             (op): op is TurnProgressOp & { completedAtMs: number } =>
               op.completedAtMs !== undefined,
           )
-          // `ops` is in start order; the decider contract wants completion
+          // `ops` is in start order; the narrator wants completion
           // order, which differs when parallel tools finish out of order.
           .sort((a, b) => a.completedAtMs - b.completedAtMs)
           .map((op) => ({
@@ -5117,26 +5468,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         updateIndex: progress.updatesSpoken + 1,
         ...(turn.language !== undefined ? { languageHint: turn.language } : {}),
       };
-      const generated = await frontDecider
+      const generated = await progressNarrator
         .generateProgressText(input, turn.abortController.signal)
-        // The decider contract never rejects; belt-and-braces for a stub.
+        // The narrator contract never rejects. Keep test stubs fail-soft too.
         .catch(() => null);
-      // Liveness re-check after the await: any turnCanNarrateProgress
-      // condition may have flipped while generating, and a delta that landed
-      // mid-generation (deltaEpoch moved) makes the text stale even when the
-      // resulting audio has already drained by now. The ack-generation and
-      // floor re-checks close the race with a generated ack that
-      // STARTED after this generation did — the entry guard rejects a
-      // narration while an ack generation is already pending, but cannot see
-      // one that begins mid-generation: while that ack is pending it has not
-      // yet stamped `lastFloorHolderAtMs`, and once it enqueues the minGapMs
-      // spacing must be re-applied from that stamp — either way, enqueueing
-      // now would stack back-to-back filler. A bail here is silent and keeps
-      // the update budget, exactly like the stale-turn bail.
+      // Re-check liveness and staleness after the provider call.
       if (
         !this.turnCanNarrateProgress(turn) ||
         turn.deltaEpoch !== deltaEpochAtLaunch ||
-        turn.ackGenerationPending ||
         (progress.lastFloorHolderAtMs !== null &&
           Date.now() - progress.lastFloorHolderAtMs <
             this.frontModelConfig.progress.minGapMs)
@@ -5144,7 +5483,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         return;
       }
       let raw = generated;
-      // Decider text is generated in the turn's language; only the static
+      // Generated text is in the turn's language; only the static
       // fallback comes from a localized table and may need the "en" override.
       let fillerLanguage: string | undefined;
       if (raw === null) {
@@ -5163,8 +5502,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       progress.opsSinceNarration = 0;
       progress.narratedEpoch = stateEpochAtLaunch;
       progress.updatesSpoken += 1;
-      // Like the ack mark, recorded only when narration audio actually
-      // enqueued (decider text or static fallback alike).
+      // Record only when narration audio actually enqueued.
       this.markProgressSpoken(turn);
       // Restart the dead-air countdown from this narration.
       this.armProgressIdleTimer(turn);
@@ -5173,93 +5511,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
   }
 
-  // Speak the turn's one floor-holding ack (every ack trigger shares the
-  // `ackSpoken` budget). The ack is audio-only — no assistant_text_delta frame
-  // — so captions and the persisted assistant message carry only the model's
-  // own output. It enqueues as a complete standalone sentence on the turn's
-  // ordered TTS queue, so the model's audio always follows it cleanly; it
-  // never consumes the eager first-clause flush reserved for the model's real
-  // first segment.
-  private speakAck(
-    activeTurn: ActiveAssistantTurn,
-    kind: LiveVoiceSpokenAckKind,
-    toolName?: string,
-  ): void {
-    if (!this.frontDecider) {
-      // No decider, no ack: a canned line is worse than the silence, which
-      // progress narration already covers once the turn runs long.
-      return;
-    }
-    activeTurn.ackSpoken = true;
-    // Optimistic ackSpoken above keeps the one-per-turn budget honest for
-    // any other ack trigger while the generation is in flight; the async
-    // path undoes it if the ack turns out moot.
-    void this.speakGeneratedAck(activeTurn, this.frontDecider, kind, toolName);
-  }
-
-  // Ask the front model for one short contextual sentence. The decider
-  // internally bounds the call by `ackGenerationTimeoutMs` and resolves null
-  // on every failure mode, so the enqueue never waits beyond that budget; a
-  // null generation speaks nothing.
-  private async speakGeneratedAck(
-    activeTurn: ActiveAssistantTurn,
-    frontDecider: VoiceFrontDecider,
-    kind: LiveVoiceSpokenAckKind,
-    toolName?: string,
-  ): Promise<void> {
-    activeTurn.ackGenerationPending = true;
-    try {
-      const transcript = activeTurn.utterance.finalTranscriptSegments
-        .join(" ")
-        .trim();
-      const generated = await frontDecider
-        .generateAckText(
-          {
-            transcriptSoFar: transcript,
-            toolName,
-            ...(activeTurn.language !== undefined
-              ? { languageHint: activeTurn.language }
-              : {}),
-          },
-          activeTurn.abortController.signal,
-        )
-        // The decider contract never rejects; belt-and-braces for a stub.
-        .catch(() => null);
-      // Liveness re-check after the await: any turnCanSpeakFiller condition
-      // may have flipped while generating, mooting the ack. A null generation
-      // (no provider, timeout, unusable output) speaks nothing. Either way,
-      // undo the optimistic ackSpoken so the flag reflects reality and a
-      // later trigger this turn can still hold the floor.
-      if (generated === null || !this.turnCanSpeakFiller(activeTurn)) {
-        activeTurn.ackSpoken = false;
-        return;
-      }
-      this.enqueueAckPhrase(activeTurn, generated, kind);
-    } finally {
-      activeTurn.ackGenerationPending = false;
-    }
-  }
-
-  // Records the ack-spoken metric only when a phrase actually enqueues; a
-  // phrase that sanitizes away releases the turn's ack budget again.
-  private enqueueAckPhrase(
-    activeTurn: ActiveAssistantTurn,
-    raw: string,
-    kind: LiveVoiceSpokenAckKind,
-  ): void {
-    if (this.enqueueFillerPhrase(activeTurn, raw)) {
-      this.markAckSpoken(activeTurn, kind);
-      return;
-    }
-    activeTurn.ackSpoken = false;
-  }
-
-  // Sanitize and enqueue one filler sentence (spoken ack or progress
-  // narration) on the turn's ordered TTS queue — the shared tail of every
-  // filler path. Returns whether a phrase actually enqueued; per-kind metric
-  // marks and bookkeeping are the caller's. `language` is a per-segment
-  // hint override (see fixedPhraseLanguage); omit it for generated text,
-  // which is already in the turn's language.
+  // Sanitize and enqueue one progress sentence on the ordered TTS queue.
   private enqueueFillerPhrase(
     turn: ActiveAssistantTurn,
     raw: string,
@@ -5303,7 +5555,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
-    activeTurn.ttsBuffer += text;
+    activeTurn.ttsBuffer += activeTurn.ttsReasoningFilter.push(text);
     this.flushTtsBuffer(token, false);
   }
 
@@ -5314,6 +5566,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
 
     this.clearFillerTimers(activeTurn);
+    activeTurn.ttsBuffer += activeTurn.ttsReasoningFilter.flush();
     this.flushTtsBuffer(token, true);
     activeTurn.ttsQueue = activeTurn.ttsQueue
       .catch(() => {})
@@ -5420,8 +5673,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
-    // A spoken ack (countsAsFirstSegment: false) leaves the eager
-    // first-clause flush available for the model's real first segment.
+    // Progress narration leaves the eager first-clause flush available for
+    // the model's real first segment.
     if (options.countsAsFirstSegment ?? true) {
       activeTurn.ttsSegmentEnqueued = true;
     }
@@ -5724,23 +5977,42 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     utterance: UtteranceCycle,
     action: VoiceEndpointAction,
     latencyMs: number,
+    // Absent means the front door decided, which is what the collector
+    // defaults to; the provider path names itself so one metrics frame can
+    // compare the two.
+    source?: VoiceEndpointSource,
   ): void {
     const turnId = this.ensureTurnId(utterance);
     if (!this.startMetricsTurnIfNeeded(utterance, turnId)) {
       return;
     }
-    this.metrics.markEndpointDecision(turnId, { action, latencyMs });
+    this.metrics.markEndpointDecision(turnId, {
+      action,
+      latencyMs,
+      ...(source ? { source } : {}),
+    });
   }
 
-  private markAckSpoken(
-    activeTurn: ActiveAssistantTurn,
-    kind: LiveVoiceSpokenAckKind,
-  ): void {
-    const { utterance } = activeTurn;
-    if (!this.startMetricsTurnIfNeeded(utterance, activeTurn.turnId)) {
+  /**
+   * The turn's end-of-turn latency, stamped at the moment it commits. Called
+   * from `releaseUtterance`, which every committed turn passes through
+   * whichever decider released it, so the front-door and provider samples span
+   * the same thing from the same anchor over the same population. That is
+   * what `endpointDecisionMaxLatencyMs` cannot offer, and why this exists
+   * alongside it.
+   *
+   * Skipped with no speech-stop mark, which is push-to-talk: there the
+   * client's release is the boundary and no local VAD runs.
+   */
+  private markEndpointCommit(utterance: UtteranceCycle): void {
+    if (this.localSpeechStopAtMs === null) {
+      return;
+    }
+    const turnId = this.ensureTurnId(utterance);
+    if (!this.startMetricsTurnIfNeeded(utterance, turnId)) {
       return;
     }
-    this.metrics.markAckSpoken(activeTurn.turnId, kind);
+    this.metrics.markEndpointCommit(turnId, this.msSinceLocalSpeechStop());
   }
 
   private markProgressSpoken(activeTurn: ActiveAssistantTurn): void {
@@ -6096,14 +6368,16 @@ export function createLiveVoiceSession(
   options: LiveVoiceSessionOptions = {},
 ): LiveVoiceSession {
   // Workspace-tunable server-VAD thresholds. The `liveVoice.vad` schema
-  // defaults match the code defaults (800 energy / 800 ms silence / 30 s max
-  // turn / 60 ms barge-in guard), so an unset config leaves behavior
-  // unchanged. Optional-chained
-  // because hand-built test configs may predate the liveVoice namespace;
-  // absent config falls through to the in-code defaults.
+  // defaults are 800 energy / 1200 ms silence / 30 s max turn / 250 ms
+  // barge-in guard. Three of the four match their in-code fallback; the
+  // trailing-silence threshold does not, so a session built with a
+  // `liveVoice` config waits 1200 ms and one built without waits the in-code
+  // DEFAULT_SILENCE_THRESHOLD_MS of 800. Optional-chained because hand-built
+  // test configs may predate the liveVoice namespace; absent config falls
+  // through to the in-code defaults.
   const liveVoiceConfig = getConfig().liveVoice;
   const vadConfig = liveVoiceConfig?.vad;
-  // Parsed once here into a complete config, shared by the decider and the
+  // Parsed once here into a complete config, shared by endpointing and the
   // session (the constructor's own parse is then a no-op re-validation).
   const frontModelConfig = LiveVoiceFrontModelConfigSchema.parse(
     options.frontModelConfig ?? liveVoiceConfig?.frontModel ?? {},
@@ -6128,13 +6402,14 @@ export function createLiveVoiceSession(
       options.echoEmaHalfLifeMs ?? vadConfig?.echoEmaHalfLifeMs,
     echoDrainSlackMs: options.echoDrainSlackMs ?? vadConfig?.echoDrainSlackMs,
     frontModelConfig,
-    // Eager construction is safe even when the `liveVoice.frontModel` config
-    // namespace is absent — schema defaults fill the tunables. An explicit
-    // option (incl. `null`) always wins — the test seam.
-    frontDecider:
-      options.frontDecider !== undefined
-        ? options.frontDecider
-        : createVoiceFrontDecider({ config: frontModelConfig }),
+    // Absent config leaves the schema defaults, which keep provider turn
+    // detection off.
+    fluxConfig: options.fluxConfig ?? liveVoiceConfig?.flux,
+    // An explicit option, including null, always wins for the test seam.
+    progressNarrator:
+      options.progressNarrator !== undefined
+        ? options.progressNarrator
+        : createVoiceProgressNarrator({ config: frontModelConfig.progress }),
     resolveCredentialReadiness:
       options.resolveCredentialReadiness === undefined
         ? defaultResolveLiveVoiceCredentialReadiness