@vellumai/assistant 0.11.5 → 0.11.6-staging.1

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

@@ -19,6 +19,7 @@
  *
  *     const connection = createLiveVoiceConnection({
  *       send: (frame) => socket.send(JSON.stringify(frame)),
+ *       close: () => socket.close(),
  *     });
  *     socket.on("message", (msg) => void connection.handleMessage(msg));
  *     socket.on("close", () => connection.release());
@@ -26,8 +27,11 @@
 
 import { getLogger } from "../util/logger.js";
 import { getLiveVoiceSessionManager } from "./live-voice-manager.js";
-import type { LiveVoiceSessionManager } from "./live-voice-session-manager.js";
-import type { LiveVoiceSessionCloseReason } from "./live-voice-session-manager.js";
+import type {
+  LiveVoiceSessionCloseReason,
+  LiveVoiceSessionManager,
+  LiveVoiceStartSessionResult,
+} from "./live-voice-session-manager.js";
 import {
   type LiveVoiceClientFrame,
   type LiveVoiceProtocolError,
@@ -66,23 +70,39 @@ export interface LiveVoiceConnection {
   release(reason?: LiveVoiceSessionCloseReason): void;
 }
 
-/** Create a live voice connection bound to the caller's `send` transport. */
+/**
+ * Create a live voice connection bound to the caller's `send` transport.
+ *
+ * `close` is how the daemon hangs up. It is optional only because a transport
+ * may not be able to (an in-process pipe), but a real one should always pass
+ * it: without it, a session the daemon reclaims from an absent client leaves
+ * the transport open behind it.
+ */
 export function createLiveVoiceConnection(options: {
   send: LiveVoiceFrameSender;
+  close?: () => void;
 }): LiveVoiceConnection {
   return new LiveVoiceConnectionImpl(
     options.send,
     getLiveVoiceSessionManager(),
+    options.close,
   );
 }
 
 class LiveVoiceConnectionImpl implements LiveVoiceConnection {
   private activeSessionId: string | undefined;
   private lastSeq = 0;
+  /**
+   * A `start` still waiting on the manager. It holds no session id yet, so
+   * without this handle a transport that closes mid-wait has nothing to
+   * release and the start would go on to build a session for a dead socket.
+   */
+  private pendingStart: AbortController | null = null;
 
   constructor(
     private readonly send: LiveVoiceFrameSender,
     private readonly manager: LiveVoiceSessionManager,
+    private readonly closeTransport?: () => void,
   ) {}
 
   get sessionId(): string | undefined {
@@ -136,6 +156,8 @@ class LiveVoiceConnectionImpl implements LiveVoiceConnection {
   }
 
   release(reason: LiveVoiceSessionCloseReason = "transport_closed"): void {
+    this.pendingStart?.abort();
+    this.pendingStart = null;
     const sessionId = this.activeSessionId;
     this.activeSessionId = undefined;
     if (!sessionId) {
@@ -168,11 +190,27 @@ class LiveVoiceConnectionImpl implements LiveVoiceConnection {
         this.activeSessionId = undefined;
       }
 
-      const result = await this.manager.startSession(frame, {
-        sendFrame: (serverFrame) => {
-          this.sendFrame(serverFrame);
-        },
-      });
+      const pending = new AbortController();
+      this.pendingStart = pending;
+      let result: LiveVoiceStartSessionResult;
+      try {
+        result = await this.manager.startSession(
+          frame,
+          {
+            sendFrame: (serverFrame) => {
+              this.sendFrame(serverFrame);
+            },
+            ...(this.closeTransport
+              ? { closeTransport: this.closeTransport }
+              : {}),
+          },
+          { signal: pending.signal },
+        );
+      } finally {
+        if (this.pendingStart === pending) {
+          this.pendingStart = null;
+        }
+      }
       if (result.status === "accepted") {
         this.activeSessionId = result.sessionId;
       }

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

@@ -11,10 +11,13 @@
 
 import { createRequire } from "node:module";
 
+import { getLogger } from "../util/logger.js";
 import { LiveVoiceSessionManager } from "./live-voice-session-manager.js";
 
 const require = createRequire(import.meta.url);
 
+const log = getLogger("live-voice-manager");
+
 type LiveVoiceSessionFactory =
   typeof import("./live-voice-session.js").createLiveVoiceSession;
 
@@ -49,6 +52,28 @@ export function getLiveVoiceSessionManager(): LiveVoiceSessionManager {
           ).createLiveVoiceSession;
         return createSession(context);
       },
+      // The manager reclaims a slot on its own only when a session stopped
+      // behaving: either its teardown overran the close budget, or its client
+      // went silent on a mode that streams continuously. Both end somebody's
+      // call without them asking, and neither leaves a trace anywhere else, so
+      // they are logged at warn.
+      onSlotEvent: (event) => {
+        if (event.kind === "close_timed_out") {
+          log.warn(
+            {
+              sessionId: event.sessionId,
+              reason: event.reason,
+              timeoutMs: event.timeoutMs,
+            },
+            "Live voice session close overran its budget, freeing the slot anyway",
+          );
+          return;
+        }
+        log.warn(
+          { sessionId: event.sessionId, timeoutMs: event.timeoutMs },
+          "Live voice client went silent, releasing the session",
+        );
+      },
     });
   }
   return manager;

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

@@ -15,8 +15,37 @@ export type LiveVoiceSessionCloseReason =
   | "error"
   | "websocket_close"
   | "transport_closed"
+  | "client_timeout"
+  | "forced_end"
   | "manager_shutdown";
 
+/**
+ * How long a session's own teardown may run before the manager stops waiting
+ * on it and frees the slot anyway.
+ *
+ * `close()` is not a formality: it delivers a pending continuation into the
+ * conversation, aborts an in-flight assistant turn, and flushes metrics, all
+ * of which reach the network. Awaiting it unbounded is what turned a single
+ * wedged teardown into a daemon that could never run live voice again, because
+ * a closing session still reads as the active one to the busy check while
+ * being un-releasable by any retry (LUM-3440).
+ */
+export const DEFAULT_LIVE_VOICE_CLOSE_TIMEOUT_MS = 10_000;
+
+/**
+ * How long a `server_vad` session may go without a single inbound frame
+ * before the manager assumes its client is gone and releases the slot.
+ *
+ * The daemon's WebSocket peer is the gateway, not the client. A half-open
+ * transport anywhere further out (a phone that left the network mid-call, a
+ * dropped velay tunnel) delivers no close event here, so transport liveness
+ * proves nothing about whether anyone is still on the call. Inbound frames do:
+ * a `server_vad` client streams PCM continuously by construction (muted turns
+ * send silence rather than nothing, so the server VAD is never starved), so a
+ * full minute of wire silence means the client is gone, not quiet.
+ */
+export const DEFAULT_LIVE_VOICE_CLIENT_SILENCE_TIMEOUT_MS = 60_000;
+
 export interface LiveVoiceSession {
   start(): MaybePromise<void>;
   handleClientFrame(frame: LiveVoiceClientFrame): MaybePromise<void>;
@@ -26,6 +55,14 @@ export interface LiveVoiceSession {
 
 export interface LiveVoiceServerFrameSink {
   sendFrame(frame: LiveVoiceServerFrame): MaybePromise<void>;
+  /**
+   * Hang up the transport this session runs on. Optional, and called when the
+   * slot is taken back rather than given up (the silence watchdog, or a forced
+   * end). Reclaiming without hanging up leaves a client streaming into a
+   * session that no longer exists, still showing an active call, with every
+   * socket in the chain out to it open and nothing behind them.
+   */
+  closeTransport?(): void;
 }
 
 export interface LiveVoiceSessionFactoryContext {
@@ -45,9 +82,79 @@ export type LiveVoiceSessionFactory = (
   context: LiveVoiceSessionFactoryContext,
 ) => LiveVoiceSession;
 
+/**
+ * A slot the manager reclaimed on the session's behalf rather than at its
+ * owner's request. Both mean a live voice session ended without anyone asking
+ * it to, so both are worth a log line and a metric: they are the only evidence
+ * that would explain a user who suddenly could not talk, and (for
+ * `close_timed_out`) the only warning that a teardown path has started
+ * hanging.
+ */
+export type LiveVoiceSlotEvent =
+  | {
+      kind: "close_timed_out";
+      sessionId: string;
+      reason: LiveVoiceSessionCloseReason;
+      timeoutMs: number;
+    }
+  | {
+      kind: "client_silence_timeout";
+      sessionId: string;
+      timeoutMs: number;
+    };
+
 export interface LiveVoiceSessionManagerOptions {
   createSession: LiveVoiceSessionFactory;
   createSessionId?: () => string;
+  /** Overrides {@link DEFAULT_LIVE_VOICE_CLOSE_TIMEOUT_MS}; `0` disables. */
+  closeTimeoutMs?: number;
+  /**
+   * Overrides {@link DEFAULT_LIVE_VOICE_CLIENT_SILENCE_TIMEOUT_MS}; `0`
+   * disables the watchdog.
+   */
+  clientSilenceTimeoutMs?: number;
+  /** Reports a slot the manager reclaimed itself. */
+  onSlotEvent?: (event: LiveVoiceSlotEvent) => void;
+}
+
+/**
+ * Close reasons where the manager took the slot back rather than its owner
+ * handing it over. Only these hang up the transport: a session that ended
+ * because its own socket closed has no transport left to close, and one that
+ * failed post-`ready` deliberately keeps the socket so the client can start
+ * again on it.
+ */
+const RECLAIMED_CLOSE_REASONS: ReadonlySet<LiveVoiceSessionCloseReason> =
+  new Set(["client_timeout", "forced_end"]);
+
+/**
+ * Read through a call so the check is not narrowed away: an abort that lands
+ * while the manager awaits the outgoing slot is exactly the one that matters,
+ * and it happens after the first read.
+ */
+function isAborted(signal?: AbortSignal): boolean {
+  return signal?.aborted === true;
+}
+
+/**
+ * Resolve when the closing session lets go of the slot, or as soon as the
+ * waiting transport aborts, whichever happens first.
+ */
+function waitForSlotRelease(
+  released: Promise<void>,
+  signal?: AbortSignal,
+): Promise<void> {
+  if (signal === undefined) {
+    return released;
+  }
+  return new Promise<void>((resolve) => {
+    const settle = () => {
+      signal.removeEventListener("abort", settle);
+      resolve();
+    };
+    signal.addEventListener("abort", settle, { once: true });
+    void released.then(settle, settle);
+  });
 }
 
 export class LiveVoiceSessionStartupError extends Error {
@@ -62,6 +169,13 @@ export type LiveVoiceStartSessionResult =
       status: "accepted";
       sessionId: string;
     }
+  | {
+      /**
+       * The transport that asked went away before the session could be
+       * created. Nothing was started and nothing needs releasing.
+       */
+      status: "aborted";
+    }
   | {
       status: "failed";
       sessionId: string;
@@ -93,17 +207,31 @@ export type LiveVoiceSessionReleaseResult =
 interface ActiveLiveVoiceSession {
   sessionId: string;
   session: LiveVoiceSession;
+  sink: LiveVoiceServerFrameSink;
   closing: boolean;
+  silenceTimer: ReturnType<typeof setTimeout> | null;
+  /** Resolves once this session has let go of the slot, however it went. */
+  readonly released: Promise<void>;
+  resolveReleased: () => void;
 }
 
 export class LiveVoiceSessionManager {
   private readonly createSession: LiveVoiceSessionFactory;
   private readonly createSessionId: () => string;
+  private readonly closeTimeoutMs: number;
+  private readonly clientSilenceTimeoutMs: number;
+  private readonly onSlotEvent: (event: LiveVoiceSlotEvent) => void;
   private activeSession: ActiveLiveVoiceSession | null = null;
 
   constructor(options: LiveVoiceSessionManagerOptions) {
     this.createSession = options.createSession;
     this.createSessionId = options.createSessionId ?? randomUUID;
+    this.closeTimeoutMs =
+      options.closeTimeoutMs ?? DEFAULT_LIVE_VOICE_CLOSE_TIMEOUT_MS;
+    this.clientSilenceTimeoutMs =
+      options.clientSilenceTimeoutMs ??
+      DEFAULT_LIVE_VOICE_CLIENT_SILENCE_TIMEOUT_MS;
+    this.onSlotEvent = options.onSlotEvent ?? (() => {});
   }
 
   get activeSessionId(): string | null {
@@ -113,7 +241,37 @@ export class LiveVoiceSessionManager {
   async startSession(
     startFrame: LiveVoiceClientStartFrame,
     sink: LiveVoiceServerFrameSink,
+    options: { signal?: AbortSignal } = {},
   ): Promise<LiveVoiceStartSessionResult> {
+    const signal = options.signal;
+    if (isAborted(signal)) {
+      return { status: "aborted" };
+    }
+
+    // A slot that is already tearing down is not a reason to turn a client
+    // away, it is a reason to wait: the client asking is usually the same one
+    // whose transport just died, reconnecting a second or two later, and its
+    // old session's close can easily outlast that gap (it delivers a pending
+    // continuation and unwinds an in-flight turn). Answering `busy` there is
+    // what turned a recoverable blip into "Another live-voice session is
+    // active." with nothing behind it (LUM-3440). Waiting keeps the invariant
+    // that matters (one session's audio devices are never live alongside the
+    // next one's), and the wait is bounded by the close budget.
+    const closingSession = this.activeSession?.closing
+      ? this.activeSession
+      : null;
+    if (closingSession !== null) {
+      await waitForSlotRelease(closingSession.released, signal);
+      // The wait can outlive the transport that asked (its own connect
+      // timeout is the same order as the close budget, and the user can give
+      // up sooner). Building a session for a socket that is gone would hand
+      // the slot to nobody, which is the failure this change exists to
+      // remove, so the caller aborts and the start is abandoned here.
+      if (isAborted(signal)) {
+        return { status: "aborted" };
+      }
+    }
+
     const existingSessionId = this.activeSessionId;
     if (existingSessionId !== null) {
       const busySequencer = createLiveVoiceServerFrameSequencer();
@@ -144,7 +302,27 @@ export class LiveVoiceSessionManager {
       },
     };
     const session = this.createSession(context);
-    this.activeSession = { sessionId, session, closing: false };
+    let resolveReleased = (): void => {};
+    const released = new Promise<void>((resolve) => {
+      resolveReleased = resolve;
+    });
+    const active: ActiveLiveVoiceSession = {
+      sessionId,
+      session,
+      sink,
+      closing: false,
+      silenceTimer: null,
+      released,
+      resolveReleased,
+    };
+    this.activeSession = active;
+    // Armed before `start()` rather than after it, so the watchdog also covers
+    // a startup that hangs: a provider dial with no timeout of its own would
+    // otherwise hold the slot with no session to release and no frame to
+    // explain it. Nothing refreshes the deadline during startup, since the
+    // transport rejects client audio until `start` resolves, so the first
+    // window is startup plus the client's first frame.
+    this.armClientSilenceWatchdog(active, startFrame);
 
     try {
       await session.start();
@@ -167,6 +345,7 @@ export class LiveVoiceSessionManager {
     if (active === null) {
       return { status: "not_found" };
     }
+    this.noteClientActivity(active);
 
     try {
       await active.session.handleClientFrame(frame);
@@ -190,6 +369,7 @@ export class LiveVoiceSessionManager {
     if (active === null) {
       return { status: "not_found" };
     }
+    this.noteClientActivity(active);
 
     try {
       await active.session.handleBinaryAudio(chunk);
@@ -211,16 +391,40 @@ export class LiveVoiceSessionManager {
     }
 
     active.closing = true;
+    this.clearClientSilenceWatchdog(active);
+    if (RECLAIMED_CLOSE_REASONS.has(reason)) {
+      this.hangUpTransport(active);
+    }
     try {
-      await active.session.close(reason);
+      await this.closeWithinBudget(active, reason);
     } finally {
       if (this.activeSession === active) {
         this.activeSession = null;
       }
+      active.resolveReleased();
     }
     return { released: true, sessionId };
   }
 
+  /**
+   * Release whatever session currently holds the slot, whoever owns it.
+   *
+   * The recovery path for a client that has no other way back: its own
+   * transport is gone (so `end` cannot be sent) but the slot is still claimed,
+   * which is the "Another live-voice session is active." dead end. Reports
+   * `released: false` when nothing holds the slot, including when the holder
+   * is already closing, since that teardown frees the slot on its own budget.
+   */
+  async endActiveSession(
+    reason: LiveVoiceSessionCloseReason = "forced_end",
+  ): Promise<LiveVoiceSessionReleaseResult> {
+    const sessionId = this.activeSessionId;
+    if (sessionId === null) {
+      return { released: false };
+    }
+    return await this.releaseSession(sessionId, reason);
+  }
+
   /**
    * Whether the given session still holds the manager slot. Transports use
    * this to heal a stale per-connection binding: a session that failed
@@ -246,4 +450,116 @@ export class LiveVoiceSessionManager {
       // The original session error is more useful to callers than a cleanup error.
     }
   }
+
+  /**
+   * Await the session's teardown, but only for as long as the close budget.
+   *
+   * A teardown that overruns is abandoned rather than cancelled: it keeps
+   * unwinding in the background (the session has already marked itself closed,
+   * so it cannot resurrect), while the caller (and the next client) stop
+   * waiting on it. Freeing the slot early can leave the outgoing session's
+   * providers briefly overlapping the next one's, which is a degraded call;
+   * holding it forever is no call at all, ever again, until the daemon
+   * restarts.
+   */
+  private async closeWithinBudget(
+    active: ActiveLiveVoiceSession,
+    reason: LiveVoiceSessionCloseReason,
+  ): Promise<void> {
+    const closed = Promise.resolve(active.session.close(reason));
+    // The race below stops awaiting `closed` on a timeout, so anchor a handler
+    // now: an abandoned teardown that rejects later must not surface as an
+    // unhandled rejection.
+    closed.catch(() => {});
+
+    if (this.closeTimeoutMs <= 0) {
+      await closed;
+      return;
+    }
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const budget = new Promise<"timed_out">((resolve) => {
+      timer = setTimeout(() => resolve("timed_out"), this.closeTimeoutMs);
+      timer.unref?.();
+    });
+    try {
+      const outcome = await Promise.race([
+        closed.then(() => "closed" as const),
+        budget,
+      ]);
+      if (outcome === "timed_out") {
+        this.onSlotEvent({
+          kind: "close_timed_out",
+          sessionId: active.sessionId,
+          reason,
+          timeoutMs: this.closeTimeoutMs,
+        });
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /**
+   * Start the client-silence watchdog for a session whose mode guarantees a
+   * continuous inbound stream. A `manual` session legitimately sits idle
+   * between push-to-talk segments, so wire silence says nothing about its
+   * client and it gets no watchdog.
+   */
+  private armClientSilenceWatchdog(
+    active: ActiveLiveVoiceSession,
+    startFrame: LiveVoiceClientStartFrame,
+  ): void {
+    if (
+      this.clientSilenceTimeoutMs <= 0 ||
+      startFrame.turnDetection !== "server_vad"
+    ) {
+      return;
+    }
+    this.scheduleClientSilenceWatchdog(active);
+  }
+
+  private scheduleClientSilenceWatchdog(active: ActiveLiveVoiceSession): void {
+    const timer = setTimeout(() => {
+      active.silenceTimer = null;
+      if (this.activeSession !== active || active.closing) {
+        return;
+      }
+      this.onSlotEvent({
+        kind: "client_silence_timeout",
+        sessionId: active.sessionId,
+        timeoutMs: this.clientSilenceTimeoutMs,
+      });
+      void this.releaseSession(active.sessionId, "client_timeout").catch(() => {
+        // Best-effort reclamation; the slot is dropped either way.
+      });
+    }, this.clientSilenceTimeoutMs);
+    timer.unref?.();
+    active.silenceTimer = timer;
+  }
+
+  /** Push the watchdog deadline out: the client is demonstrably still there. */
+  private noteClientActivity(active: ActiveLiveVoiceSession): void {
+    if (active.silenceTimer === null) {
+      return;
+    }
+    clearTimeout(active.silenceTimer);
+    this.scheduleClientSilenceWatchdog(active);
+  }
+
+  private hangUpTransport(active: ActiveLiveVoiceSession): void {
+    try {
+      active.sink.closeTransport?.();
+    } catch {
+      // A transport that cannot be hung up is exactly the case the watchdog
+      // exists for. Reclaiming the slot still has to happen.
+    }
+  }
+
+  private clearClientSilenceWatchdog(active: ActiveLiveVoiceSession): void {
+    if (active.silenceTimer !== null) {
+      clearTimeout(active.silenceTimer);
+      active.silenceTimer = null;
+    }
+  }
 }

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

@@ -71,7 +71,10 @@ import type {
   SttStreamServerEvent,
 } from "../stt/types.js";
 import { getSubagentManager } from "../subagent/index.js";
-import { liveVoiceEndScreen } from "../telemetry/live-voice-funnel.js";
+import {
+  liveVoiceEndScreen,
+  liveVoiceSilenceReason,
+} from "../telemetry/live-voice-funnel.js";
 import { getToolOwner } from "../tools/registry.js";
 import {
   createReasoningTagFilter,
@@ -1126,6 +1129,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
    * session that never failed.
    */
   private failureCode: LiveVoiceProtocolErrorCode | null = null;
+  /**
+   * How far a session that never produced a turn actually got. Latched rather
+   * than derived at close, because every one of these is a transient the
+   * teardown has already destroyed by then: `state` has moved on, the current
+   * utterance is gone, and the turn detector is disposed.
+   *
+   * A quarter of sessions end with no turn at all, and these three booleans are
+   * what separate a microphone that never opened from one that was muted from a
+   * user who simply left. See `telemetry/live-voice-funnel.ts`.
+   */
+  private reachedActive = false;
+  private receivedAudio = false;
+  private detectedSpeech = false;
+  private dispatchedTurn = false;
   // Non-null iff the start frame requested turnDetection "server_vad".
   private readonly turnDetector: MediaTurnDetector | null;
   // Base energy gate for server-VAD speech classification. During estimated
@@ -1419,6 +1436,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // through the pending/pre-roll paths and flushes on arm. An arm failure
     // surfaces as a non-recoverable error frame instead of a start rejection.
     this.state = "active";
+    this.reachedActive = true;
     void this.armUtterance().catch(() => {});
     this.metrics.markReady();
     await this.sendFrame({
@@ -1522,9 +1540,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // `recorded_at` minus the started row's, so it must be written before the
     // teardown below, which awaits a pending continuation and can run long.
     const failed = this.state === "failed";
+    // Only a session that never dispatched a turn gets a silence reason; for
+    // every other session the question is meaningless.
+    const silenceReason = this.dispatchedTurn
+      ? null
+      : liveVoiceSilenceReason({
+          reachedActive: this.reachedActive,
+          receivedAudio: this.receivedAudio,
+          detectedSpeech: this.detectedSpeech,
+        });
     recordLiveVoiceSessionEnded({
       sessionId: this.context.sessionId,
-      screen: liveVoiceEndScreen(reason, failed ? this.failureCode : null),
+      screen: liveVoiceEndScreen(
+        reason,
+        failed ? this.failureCode : null,
+        silenceReason,
+      ),
       outcome: failed ? "failed" : "completed",
     });
 
@@ -1831,6 +1862,11 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   private async handleAudio(chunk: Buffer): Promise<void> {
+    // Both transports funnel through here, and this runs before any of the
+    // early returns below. The question it answers is "did the microphone ever
+    // open", which a chunk arriving at all settles regardless of what the
+    // session then does with it.
+    this.receivedAudio = true;
     if (this.turnDetector) {
       await this.handleServerVadAudio(this.turnDetector, chunk);
       return;
@@ -1849,6 +1885,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // The chunk belongs to an utterance the user is still holding the button
     // for, whether or not the transcriber has produced any text for it yet.
     utterance.manualAudioCaptured = true;
+    // Manual sessions have no VAD, so the user holding the talk button is
+    // the only speech signal available. Without this every abandoned manual
+    // session would be misfiled as `no_turn` instead of `no_speech`.
+    this.detectedSpeech = true;
     this.collectUserAudio(utterance, chunk);
     if (utterance.phase === "pending") {
       // The transcriber is still arming (session start overlaps the STT
@@ -1968,6 +2008,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // resets it.
     if (hasSpeech || this.vadPreRollHasSpeech) {
       utterance.speechRouted = true;
+      this.detectedSpeech = true;
     }
     for (const preRollChunk of this.takeVadPreRoll()) {
       await this.routeVadAudio(utterance, preRollChunk);
@@ -2221,6 +2262,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
     if (preRollHadSpeech) {
       utterance.speechRouted = true;
+      this.detectedSpeech = true;
     }
   }
 
@@ -4725,6 +4767,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     };
 
     try {
+      // Latched before the await, not after: this flag only decides whether the
+      // end event carries a silence classification, and the dashboard decides
+      // silence from persisted turn rows instead. Setting it after would let a
+      // dispatch that persisted a turn and then threw stamp "this session was
+      // silent" onto a session that has turns, a contradictory row. Setting it
+      // before can at worst leave a silent session unexplained, which is a gap
+      // rather than a false statement.
+      this.dispatchedTurn = true;
       const handle = await this.startVoiceTurn({
         conversationId: this.conversationId,
         voiceSessionId: this.context.sessionId,