@vellumai/assistant 0.11.7 → 0.11.8-staging.1

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

@@ -45,6 +45,10 @@ import {
   recordLiveVoiceSessionStarted,
 } from "../onboarding/onboarding-events-store.js";
 import { isInstalledStaticSkillLoad } from "../permissions/checker.js";
+import {
+  attachmentExists,
+  deleteOrphanAttachments,
+} from "../persistence/attachments-store.js";
 import { ensureConversationExists } from "../persistence/conversation-crud.js";
 import {
   listProviderIds,
@@ -60,6 +64,7 @@ import {
   voteDominantLanguage,
 } from "../stt/language-metadata.js";
 import { sttCatalogKeyForRole } from "../stt/roles.js";
+import { RoomNoiseFloor } from "../stt/room-noise-floor.js";
 import {
   DEFAULT_SPEECH_ENERGY_THRESHOLD,
   pcm16MaxNormalizedCorrelation,
@@ -106,7 +111,10 @@ import {
   type VoiceEndpointAction,
   type VoiceEndpointSource,
 } from "./live-voice-metrics.js";
-import { persistLiveVoicePhoto } from "./live-voice-photo.js";
+import {
+  persistLiveVoicePhoto,
+  persistLiveVoiceSightFrame,
+} from "./live-voice-photo.js";
 import {
   type LiveVoiceSession as LiveVoiceSessionContract,
   type LiveVoiceSessionCloseReason,
@@ -130,8 +138,10 @@ import {
   PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
 } from "./progress-phrases.js";
 import {
+  type LiveVoiceClientAttachFrameFrame,
   type LiveVoiceClientAttachImageFrame,
   type LiveVoiceClientFrame,
+  type LiveVoiceClientSightFrameFrame,
   type LiveVoiceClientTextTurnFrame,
   type LiveVoiceClientUpdateConfigFrame,
   LiveVoiceProtocolErrorCode,
@@ -200,6 +210,18 @@ const ECHO_ONSET_ELIGIBILITY_MS = 300;
 // Client buffering makes audible playback trail the server's send-time
 // estimate. Keep the echo window open briefly past that estimate.
 const DEFAULT_ECHO_DRAIN_SLACK_MS = 300;
+// The speech gate's base threshold is raised to this multiple of the room's
+// measured noise floor. Speech has to stand clear of the room it is spoken in,
+// and roughly 3x (about 10dB) is the separation an ordinary talking voice keeps
+// over its own background. Mirrors the liveVoice.vad.noiseFloorMargin default.
+const DEFAULT_NOISE_FLOOR_MARGIN = 3;
+// Ceiling on the adaptive base, as a multiple of the configured threshold. The
+// floor estimate is derived from the microphone, so a pathological room (or a
+// stuck input) could in principle drive it high enough that nothing counts as
+// speech and the user cannot interrupt at all. Barge-in getting harder is a
+// nuisance; barge-in becoming impossible is a broken product, so the adaptation
+// is bounded even though the bound should never be reached.
+const NOISE_FLOOR_MAX_BASE_MULTIPLE = 4;
 // Mirrors MediaTurnDetector's DEFAULT_SILENCE_THRESHOLD_MS: the session
 // tracks the effective trailing-silence threshold (the detector keeps its own
 // copy private) so the endpoint decider can report the pause length.
@@ -329,6 +351,14 @@ export interface LiveVoiceSessionOptions {
    * `DEFAULT_SPEECH_ENERGY_THRESHOLD`.
    */
   speechEnergyThreshold?: number;
+  /**
+   * Multiple of the room's measured noise floor that the speech gate's base
+   * threshold is raised to. The production factory seeds this from
+   * `liveVoice.vad.noiseFloorMargin` config when unset; defaults to
+   * `DEFAULT_NOISE_FLOOR_MARGIN`. Values at or below 0 disable the adaptation,
+   * pinning the gate to `speechEnergyThreshold` (used by fixed-gate tests).
+   */
+  noiseFloorMargin?: number;
   /**
    * Sustained speech (ms) required before speech during assistant playback
    * interrupts it (barge-in); 0 disables the guard. The production factory
@@ -716,6 +746,14 @@ interface ActiveAssistantTurn {
   // that request's transcript, so the model can tell the user the work is
   // still running instead of appearing to have dropped it.
   handedOffRequest: string | null;
+  // The parked camera frame this turn claimed, hung on the turn's own
+  // persisted user message. Held here so a rolled-back dispatch can hand it
+  // back to the session (see restorePendingTurnContext).
+  turnAttachmentId: string | null;
+  // The frame the rollback could NOT hand back, because a newer one took the
+  // slot while this turn was in flight. Nothing will ever send it, so it is
+  // collected once the discard has removed the row still linking it.
+  staleFrameId: string | null;
   // The queued announcement this turn consumed alongside `continuationResult`
   // — the two are routes for one answer, so launching consumes both. Held here
   // so a rolled-back speculative dispatch can re-arm it (see
@@ -1176,6 +1214,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // Base energy gate for server-VAD speech classification. During estimated
   // playback, classifyVadEnergy raises this above the learned echo level.
   private readonly speechEnergyThreshold: number | undefined;
+  private readonly noiseFloorMargin: number;
+  // Quietest recent second of microphone audio, learned only while the
+  // assistant is silent (during playback the microphone hears echo, which is
+  // what echoEnergyEma is for). Raises the base gate in a noisy room so the
+  // room itself stops reading as speech.
+  private readonly roomNoiseFloor = new RoomNoiseFloor();
   private readonly echoBargeInMargin: number;
   private readonly echoEmaHalfLifeMs: number;
   private readonly echoDrainSlackMs: number;
@@ -1255,6 +1299,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // turn; cleared when the continuation finishes (by then the result note
   // takes over and "still running" would be stale).
   private pendingHandoffRequest: string | null = null;
+  // The camera frame a client parked with `attach_frame`, waiting for the next
+  // turn to ride. One slot, latest wins: the frame is ambient context, so an
+  // older one is simply out of date. Consumed (and cleared) when a turn
+  // launches, handed back if that turn is rolled back, and cleared on close.
+  private pendingTurnAttachmentId: 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.
@@ -1388,6 +1437,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       ...(options.metricsClock ? { clock: options.metricsClock } : {}),
     });
     this.speechEnergyThreshold = options.speechEnergyThreshold;
+    this.noiseFloorMargin =
+      options.noiseFloorMargin ?? DEFAULT_NOISE_FLOOR_MARGIN;
     // 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.
@@ -1526,6 +1577,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       case "attach_image":
         this.persistPhoto(frame);
         return;
+      case "attach_frame":
+        this.parkTurnFrame(frame);
+        return;
+      case "sight_frame":
+        this.persistSightFrame(frame);
+        return;
       case "text":
         await this.handleTextTurn(frame);
         return;
@@ -1618,6 +1675,138 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     );
   }
 
+  /**
+   * Persist a kept camera frame into the conversation, running no turn.
+   *
+   * Fire-and-forget for the same reason the photo is: the persist waits out any
+   * in-flight turn, and the socket must keep pumping audio meanwhile. Waiting
+   * is also what keeps a frame that lands mid-reply from splitting that reply's
+   * own rows.
+   *
+   * The frame becomes its own tagged user message rather than riding a turn, so
+   * the transcript is the record of what the assistant saw and the model
+   * correlates a frame with speech by adjacency. See `live-voice-photo.ts`.
+   *
+   * An id the attachment store cannot resolve is refused there, before the
+   * persist waits on anything, so a bad frame is answered while the client can
+   * still act on it rather than a turn's length later. That resolve is the only
+   * existence check: a second one here would read the same row to learn the
+   * same fact.
+   */
+  private persistSightFrame(frame: LiveVoiceClientSightFrameFrame): void {
+    void persistLiveVoiceSightFrame(
+      this.conversationId,
+      frame.attachmentId,
+    ).then((result) => {
+      if (!result.ok && !this.isClosed) {
+        void this.sendFrame({
+          type: "error",
+          code: LiveVoiceProtocolErrorCode.InvalidFrame,
+          message: "Could not attach that camera frame to the conversation.",
+          // Names the frame as the casualty so the client can retract the
+          // preview it already showed, rather than filing this with the
+          // transient transcriber and TTS blips that share `recoverable`.
+          frameType: "sight_frame",
+          // The session is fine; only this frame failed.
+          recoverable: true,
+        });
+      }
+    });
+  }
+
+  /**
+   * Park a camera frame for the next turn to carry, or give up the parked one.
+   *
+   * Nothing is persisted and no turn runs: the frame is ambient context, and
+   * on its own it says nothing the user asked to say. It rides the next turn's
+   * own user message instead, so the picture and the words about it are one
+   * message. A frame that arrives while a turn is already running belongs to
+   * the turn after it, which the drain at launch takes care of.
+   *
+   * A null id unparks: the client's camera is off, so the slot must stop
+   * answering for a view nobody can see any more. The frame goes with it, and
+   * unparking an empty slot is a no-op.
+   *
+   * The id is checked against the attachment store here rather than at the
+   * turn, for the same reason a failed photo is reported: an id that resolves
+   * to nothing would otherwise leave the user believing the assistant can see
+   * something it never received, one turn later and with nothing said.
+   */
+  private parkTurnFrame(frame: LiveVoiceClientAttachFrameFrame): void {
+    if (frame.attachmentId === null) {
+      const parked = this.pendingTurnAttachmentId;
+      this.pendingTurnAttachmentId = null;
+      this.reclaimParkedFrame(parked);
+      return;
+    }
+
+    let exists = false;
+    try {
+      exists = attachmentExists(frame.attachmentId);
+    } catch (err) {
+      log.warn(
+        { err, attachmentId: frame.attachmentId },
+        "Live-voice camera frame lookup failed",
+      );
+    }
+    if (!exists) {
+      void this.sendFrame({
+        type: "error",
+        code: LiveVoiceProtocolErrorCode.InvalidFrame,
+        message: "Could not attach that camera frame to the conversation.",
+        frameType: "attach_frame",
+        // The session is fine; only this frame failed.
+        recoverable: true,
+      });
+      return;
+    }
+    const displaced = this.pendingTurnAttachmentId;
+    this.pendingTurnAttachmentId = frame.attachmentId;
+    if (displaced !== null && displaced !== frame.attachmentId) {
+      this.reclaimParkedFrame(displaced);
+    }
+  }
+
+  /**
+   * Give up a parked camera frame no turn will ever carry: one a newer frame
+   * displaced, one the session end leaves behind, one a rollback could not
+   * hand back. A client shooting the camera on a timer parks one every few
+   * seconds, and attachment collection is scoped to message deletion with no
+   * global sweep, so an id dropped without this leaves its row and its bytes
+   * behind for good.
+   *
+   * Safe because `deleteOrphanAttachments` is link-aware: it removes only ids
+   * with no message link, so a frame that already rode a turn is kept and one
+   * that never left this slot is collected. Nothing waits on the result and a
+   * store that cannot be reached must not take the call down, so a failure is
+   * logged and dropped.
+   */
+  private reclaimParkedFrame(attachmentId: string | null): void {
+    if (attachmentId === null) {
+      return;
+    }
+    try {
+      deleteOrphanAttachments([attachmentId]);
+    } catch (err) {
+      log.warn(
+        { err, attachmentId },
+        "Could not reclaim a parked live-voice camera frame",
+      );
+    }
+  }
+
+  /**
+   * Collect the frame a turn's rollback could not hand back, once the discard
+   * that owns the turn's row has finished. Ordering is the whole point: the
+   * reclaim is link-aware, so running it while the doomed row still links the
+   * frame finds the link, keeps the frame, and leaks it.
+   */
+  private reclaimStaleTurnFrame(turn: ActiveAssistantTurn): void {
+    const staleFrameId = turn.staleFrameId;
+    turn.staleFrameId = null;
+    this.reclaimParkedFrame(staleFrameId);
+  }
+
   /**
    * Apply a mid-session `update_config` frame: retune the live turn detector's
    * pause ("pause before reply") and/or the barge-in guard ("interrupt
@@ -1681,6 +1870,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     this.turnDetector?.dispose();
     this.clearEndpointExtensionTimer();
     this.clearProviderTurnEndTimer();
+    // No turn will ever carry it now, and the frame is the client's to shoot
+    // again on its next session, so the staged row and bytes go with the call.
+    this.reclaimParkedFrame(this.pendingTurnAttachmentId);
+    this.pendingTurnAttachmentId = null;
     // There is no longer anyone on the call to speak to, so a queued
     // announcement cannot be spoken — but the answer behind it is finished
     // work the user asked for, so it takes the same conversation route a
@@ -2166,18 +2359,28 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * confirmed echo while speech above the learned margin remains frozen out.
    */
   private classifyVadEnergy(chunk: Buffer): VadClassifiedChunk[] {
-    const baseThreshold =
-      this.speechEnergyThreshold ?? DEFAULT_SPEECH_ENERGY_THRESHOLD;
     const meanAmplitude = pcm16MeanAmplitude(chunk);
+    const chunkMs = pcm16DurationMs(
+      chunk.byteLength,
+      this.context.startFrame.audio.sampleRate,
+    );
+    const baseThreshold = this.effectiveBaseThreshold();
     if (
       this.echoBargeInMargin <= 1 ||
       !this.isAssistantPlaybackEchoPossible()
     ) {
       this.resetEchoReference();
+      // Only learn the room while the assistant is silent. The floor is a
+      // minimum over completed blocks, so this chunk cannot lower the
+      // threshold that is about to judge it.
+      this.roomNoiseFloor.observe(meanAmplitude, chunkMs);
       return [
         this.classifyAtFixedThreshold(chunk, baseThreshold, meanAmplitude),
       ];
     }
+    // Playback is starting or ongoing: stop measuring the room, and drop the
+    // partial block rather than let it straddle the silence and the echo.
+    this.roomNoiseFloor.interrupt();
 
     if (this.echoWindowTotalAudioMs === 0) {
       this.echoWindowGuardCarryover =
@@ -2186,10 +2389,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       this.echoWindowGuardCarryover = false;
     }
 
-    const chunkMs = pcm16DurationMs(
-      chunk.byteLength,
-      this.context.startFrame.audio.sampleRate,
-    );
     const onsetWasEligible =
       !this.echoOnsetLapsed &&
       this.echoWindowTotalAudioMs < ECHO_ONSET_ELIGIBILITY_MS;
@@ -2296,6 +2495,34 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       alpha * meanAmplitude + (1 - alpha) * this.echoEnergyEma;
   }
 
+  /**
+   * The gate a chunk is judged against before any playback-echo adjustment.
+   *
+   * The configured `speechEnergyThreshold` is a floor, never a ceiling: the
+   * adaptation can only make speech classification *stricter*. That asymmetry
+   * is deliberate. A gate that could drop below the configured value would be
+   * able to invent new self-interruption in a room quieter than the one the
+   * constant was chosen for, which is the failure this whole change exists to
+   * remove; a gate that only rises can, at worst, make a soft barge-in need
+   * repeating. The result is bounded so it can never rise far enough to make
+   * interrupting impossible.
+   */
+  private effectiveBaseThreshold(): number {
+    const configured =
+      this.speechEnergyThreshold ?? DEFAULT_SPEECH_ENERGY_THRESHOLD;
+    if (this.noiseFloorMargin <= 0) {
+      return configured;
+    }
+    const floor = this.roomNoiseFloor.floor;
+    if (floor === null) {
+      return configured;
+    }
+    return Math.min(
+      Math.max(configured, floor * this.noiseFloorMargin),
+      configured * NOISE_FLOOR_MAX_BASE_MULTIPLE,
+    );
+  }
+
   private classifyAtFixedThreshold(
     chunk: Buffer,
     baseThreshold: number,
@@ -3852,9 +4079,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   ): void {
     turn.speculativePending = false;
     // The dispatch is being unwound, so the barge-in merge note, the finished
-    // continuation's answer, its queued announcement, and any photos it claimed
-    // all go back to the session. The turn that would have delivered them is
-    // gone, and the utterance they belong to is about to be sent by another.
+    // continuation's answer, its queued announcement, and any camera frame it
+    // claimed all go back to the session. The turn that would have delivered
+    // them is gone, and the utterance they belong to is about to be sent by
+    // another.
     this.restorePendingTurnContext(turn);
     // Latched before the handle check: when the discard beats the bridge
     // handle's resolution (startVoiceTurn still persisting), the handle's
@@ -3869,12 +4097,19 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     );
     const handle = turn.handle;
     turn.handle = null;
-    void handle?.discard?.().catch((err: unknown) => {
-      log.warn(
-        { err, turnId: turn.turnId, reason },
-        "Speculative voice turn discard failed",
-      );
-    });
+    void handle
+      ?.discard?.()
+      .catch((err: unknown) => {
+        log.warn(
+          { err, turnId: turn.turnId, reason },
+          "Speculative voice turn discard failed",
+        );
+      })
+      // Only once the discard has deleted the row: until then the row still
+      // links a displaced frame, and the reclaim would keep it forever.
+      .finally(() => {
+        this.reclaimStaleTurnFrame(turn);
+      });
     turn.utterance.assistantTurnStarted = false;
     log.info(
       { turnId: turn.turnId, reason },
@@ -4622,10 +4857,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Take the barge-in merge context, the completed-continuation context, and
-   * the handoff note for the turn being launched — each feeds exactly the next
-   * launched turn — and cancel the queued announcement, because the turn this
-   * context rides delivers the same answer and would otherwise say it twice.
+   * Take the barge-in merge context, the completed-continuation context, the
+   * handoff note, and the parked camera frame for the turn being launched
+   * (each feeds exactly the next launched turn) and cancel the queued
+   * announcement, because the turn this context rides delivers the same answer
+   * and would otherwise say it twice.
    *
    * Every real user turn consumes here, speculative or not: a speculative
    * dispatch latches `assistantTurnStarted`, so a turn that skipped this would
@@ -4637,16 +4873,19 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     continuationResult: string | null;
     handedOffRequest: string | null;
     announcement: ContinuationDelivery | null;
+    turnAttachmentId: string | null;
   } {
     const consumed = {
       interruptedRequest: this.pendingInterruptedRequest,
       continuationResult: this.pendingContinuationResult,
       handedOffRequest: this.pendingHandoffRequest,
       announcement: this.pendingAnnouncement,
+      turnAttachmentId: this.pendingTurnAttachmentId,
     };
     this.pendingInterruptedRequest = null;
     this.pendingContinuationResult = null;
     this.pendingHandoffRequest = null;
+    this.pendingTurnAttachmentId = null;
     this.clearContinuationAnnouncement();
     return consumed;
   }
@@ -4668,21 +4907,43 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     const continuationResult = turn.continuationResult;
     const handedOffRequest = turn.handedOffRequest;
     const announcement = turn.consumedAnnouncement;
+    const turnAttachmentId = turn.turnAttachmentId;
     // One restore per turn: the rollback paths overlap (a discarded turn whose
     // leg start also fails), and the second pass must be a no-op.
     turn.interruptedRequest = null;
     turn.continuationResult = null;
     turn.handedOffRequest = null;
     turn.consumedAnnouncement = null;
+    turn.turnAttachmentId = null;
+    // Nobody's to send unless the slot already holds it. A client that
+    // retransmits the id this turn claimed parked the SAME frame rather than a
+    // newer one, and collecting it would leave the slot pointing at a row that
+    // is gone: the discard keeps the bytes alive precisely so the replay can
+    // still send them.
+    const orphanedFrameId =
+      turnAttachmentId !== null &&
+      this.pendingTurnAttachmentId !== turnAttachmentId
+        ? turnAttachmentId
+        : null;
     if (
       this.isClosed ||
       this.detachStopGeneration !== turn.pendingContextStopGeneration
     ) {
+      // The drop is deliberate, so the frame it drops is nobody's to send.
+      turn.staleFrameId = orphanedFrameId;
       return;
     }
     if (this.pendingInterruptedRequest === null) {
       this.pendingInterruptedRequest = interruptedRequest;
     }
+    // A frame parked since this turn launched is newer, so it wins outright
+    // and the one being handed back is the stale one: collect it rather than
+    // leave it staged for a turn that will never ask for it.
+    if (this.pendingTurnAttachmentId === null) {
+      this.pendingTurnAttachmentId = turnAttachmentId;
+    } else {
+      turn.staleFrameId = orphanedFrameId;
+    }
     if (this.pendingContinuationResult === null) {
       this.pendingContinuationResult = continuationResult;
     }
@@ -4779,6 +5040,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       interruptedRequest: pending?.interruptedRequest ?? null,
       continuationResult: pending?.continuationResult ?? null,
       handedOffRequest: pending?.handedOffRequest ?? null,
+      turnAttachmentId: pending?.turnAttachmentId ?? null,
+      staleFrameId: null,
       consumedAnnouncement: pending?.announcement ?? null,
       pendingContextStopGeneration: this.detachStopGeneration,
       continuationDelivery: opts?.continuationDelivery ?? null,
@@ -4803,6 +5066,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       await this.sendFrame({ type: "thinking", turnId });
       if (!this.isActiveAssistantTurn(token)) {
         this.restorePendingTurnContext(activeTurn);
+        // Nothing was persisted, so a frame the restore could not hand back
+        // links to no row and is collectible right here.
+        this.reclaimStaleTurnFrame(activeTurn);
         return false;
       }
     } else {
@@ -4853,11 +5119,19 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       content,
       routingLeg: "front-door",
       frontDoor: true,
+      // Only this leg: an escalated leg persists its own continuation row, and
+      // the frame belongs to the row carrying the user's words.
+      ...(activeTurn.turnAttachmentId
+        ? { attachments: [activeTurn.turnAttachmentId] }
+        : {}),
     });
     if (!started) {
       // Nothing was persisted or spoken, so the context this turn consumed goes
-      // back to the session rather than dying with the failed dispatch.
+      // back to the session rather than dying with the failed dispatch. A frame
+      // a newer one displaced meanwhile links to no row, so it is collected
+      // here rather than left staged.
       this.restorePendingTurnContext(activeTurn);
+      this.reclaimStaleTurnFrame(activeTurn);
     }
     return started;
   }
@@ -4890,6 +5164,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       routingLeg?: VoiceRoutingLeg;
       frontDoor?: boolean;
       spokenEscalationBridge?: string;
+      attachments?: readonly string[];
     },
   ): Promise<boolean> {
     if (!this.startVoiceTurn) {
@@ -4994,6 +5269,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           this.clearAwaitingApproval(activeTurn);
         },
         content: leg.content,
+        ...(leg.attachments ? { attachments: leg.attachments } : {}),
         isInbound: true,
         launchedAtMs: activeTurn.launchedAtMs,
         signal: activeTurn.abortController.signal,
@@ -5310,12 +5586,19 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         // rollback: a plain abort would leave the discarded pause's user
         // row in history.
         if (activeTurn.discardRequested && handle.discard) {
-          void handle.discard().catch((err: unknown) => {
-            log.warn(
-              { err, turnId: activeTurn.turnId },
-              "Late speculative voice turn discard failed",
-            );
-          });
+          void handle
+            .discard()
+            .catch((err: unknown) => {
+              log.warn(
+                { err, turnId: activeTurn.turnId },
+                "Late speculative voice turn discard failed",
+              );
+            })
+            // This discard owns the row, so it owns the reclaim of any frame
+            // the rollback could not hand back (see reclaimStaleTurnFrame).
+            .finally(() => {
+              this.reclaimStaleTurnFrame(activeTurn);
+            });
         } else {
           handle.abort();
         }
@@ -6657,6 +6940,7 @@ export function createLiveVoiceSession(
         : {}),
     speechEnergyThreshold:
       options.speechEnergyThreshold ?? vadConfig?.speechEnergyThreshold,
+    noiseFloorMargin: options.noiseFloorMargin ?? vadConfig?.noiseFloorMargin,
     bargeInMinSpeechMs:
       options.bargeInMinSpeechMs ?? vadConfig?.bargeInMinSpeechMs,
     echoBargeInMargin: