@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/calls/voice-control-protocol.ts

@@ -29,11 +29,11 @@ export const HOLD_VERDICT_TOKEN = "[0]";
 export const ESCALATE_VERDICT_TOKEN = "[1]";
 
 /**
- * Room-minimize token, kept in the marker table so it is stripped from
- * speech and from persisted rows. No prompt teaches it: the live-voice
- * session decides a minimize from whether a ui-surface tool ran during the
- * turn (`revealsUiSurface` on `tool_result`) and sends the `minimize_room`
- * frame itself, so a model that emits this token regardless moves nothing.
+ * Emitted inline by the main/escalated voice leg to ask the live-voice
+ * client to minimize the voice room and reveal the screen behind it
+ * (e.g. after creating an app worth showing). Advisory: the daemon
+ * translates it into a `minimize_room` server frame after the turn's TTS
+ * drains; it is never spoken and never persisted.
  */
 export const MINIMIZE_ROOM_MARKER = "[-1]";
 
@@ -192,9 +192,9 @@ export function stripInternalSpeechMarkers(text: string): string {
 // ---------------------------------------------------------------------------
 
 /**
- * All known control marker prefixes. Used by isIncompleteControlMarkerTail to
- * detect whether a buffer that starts with `[` might be the beginning of a
- * control marker (and should therefore be held rather than flushed to TTS).
+ * All known control marker prefixes. Used by couldBeControlMarker to detect
+ * whether a buffer that starts with `[` might be the beginning of a control
+ * marker (and should therefore be held rather than flushed to TTS).
  */
 const CONTROL_MARKER_STRINGS = [
   "[ASK_GUARDIAN_APPROVAL:",
@@ -211,6 +211,19 @@ const CONTROL_MARKER_STRINGS = [
   "[GUARDIAN_UNAVAILABLE]",
 ];
 
+/**
+ * Check whether `text` could be a partial or complete control marker.
+ *
+ * Returns true if any known marker string is a prefix of `text`
+ * (text starts with the marker) or `text` is a prefix of a marker
+ * (the marker starts with text — i.e. text is still being streamed).
+ */
+export function couldBeControlMarker(text: string): boolean {
+  return CONTROL_MARKER_STRINGS.some(
+    (marker) => marker.startsWith(text) || text.startsWith(marker),
+  );
+}
+
 // Colon-style markers whose bodies terminate at the first "]" — their strip
 // regexes are non-greedy (`.+?\]`), so the first bracket IS the terminator.
 // ASK_GUARDIAN_APPROVAL is deliberately absent: its balanced-JSON body may
@@ -254,48 +267,3 @@ export function isIncompleteControlMarkerTail(tail: string): boolean {
   }
   return false;
 }
-
-/**
- * Control-marker hygiene for one model leg's streamed text, shared by the
- * phone call controller and the live-voice session. The returned flush is
- * called with the leg's cumulative raw text so far and forwards, through
- * `emit`, the stripped ({@link stripInternalSpeechMarkers}) prefix that has
- * not been emitted yet and cannot contain a still-streaming control marker:
- * the flush stops at the first "[" whose tail is an incomplete marker
- * ({@link isIncompleteControlMarkerTail}) and holds from there until a later
- * delta completes or disproves it. `force` (leg completion) emits the held
- * tail so real text that merely resembles a marker prefix is not dropped.
- *
- * The scan runs forward from the emitted boundary, not from the last "[", so
- * brackets INSIDE a streaming marker body (a JSON array or "]"-bearing string
- * in ASK_GUARDIAN_APPROVAL) can neither mask the marker's start nor pass as
- * its terminator. Markers are stripped, never acted on: a consumer that acts
- * on a marker reads the leg's full raw text for it separately.
- */
-export function createControlMarkerHoldback(
-  emit: (chunk: string) => void,
-): (raw: string, opts?: { force?: boolean }) => void {
-  let emitted = 0;
-  return (raw, opts) => {
-    let safeEnd = raw.length;
-    if (opts?.force !== true) {
-      for (
-        let i = raw.indexOf("[", emitted);
-        i !== -1;
-        i = raw.indexOf("[", i + 1)
-      ) {
-        if (isIncompleteControlMarkerTail(raw.slice(i))) {
-          safeEnd = i;
-          break;
-        }
-      }
-    }
-    if (safeEnd > emitted) {
-      const chunk = stripInternalSpeechMarkers(raw.slice(emitted, safeEnd));
-      emitted = safeEnd;
-      if (chunk.length > 0) {
-        emit(chunk);
-      }
-    }
-  };
-}

package/src/calls/voice-session-bridge.ts

@@ -188,34 +188,6 @@ function frontDoorRuleWithDigest(
   });
 }
 
-/**
- * The triage-and-escalate rule a turn's leg adds to its control prompt: the
- * front-door leg decides and may hand off, the escalated leg continues the
- * answer after a holding phrase was already spoken. Null when routing is off.
- * One rule for both prompt shapes, the auto-built phone prompt and a
- * caller-supplied one, so the front-door model is anchored to the same
- * caller words on every transport.
- */
-function routingLegRuleFor(
-  opts: Pick<
-    VoiceTurnOptions,
-    "routingLeg" | "unifiedVerdict" | "spokenEscalationBridge"
-  >,
-  callerUtterance: string,
-): string | null {
-  switch (opts.routingLeg) {
-    case "front-door":
-      return frontDoorRuleWithDigest(
-        opts.unifiedVerdict === true,
-        callerUtterance,
-      );
-    case "escalated":
-      return escalatedContinuationRule(opts.spokenEscalationBridge);
-    default:
-      return null;
-  }
-}
-
 /**
  * Exact message thrown when `opts.signal` aborts while the turn is waiting
  * for the conversation to become available. The call controller's abort
@@ -401,9 +373,8 @@ export interface VoiceTurnOptions {
    *
    * Deliberately separate from {@link userMessageInterface}: that field feeds
    * `resolveChannelCapabilities` and decides what the turn may do, so it is not
-   * free to carry attribution. A phone call passes its call session id and a
-   * `phone_*` entry naming the call's direction, with no client. Absent for
-   * clients that send no identity on the start frame.
+   * free to carry attribution. Absent for phone calls and for clients that send
+   * no identity on the start frame.
    */
   voiceTelemetry?: {
     sessionId: string;
@@ -476,7 +447,7 @@ export interface VoiceTurnOptions {
   onComplete?: () => void;
   /** Called when the agent loop encounters an error. */
   onError?: (message: string) => void;
-  /** Event-name callbacks: tool activity, persisted row ids, raw stream. */
+  /** Event-name callbacks used by non-phone voice clients. */
   callbacks?: VoiceTurnCallbacks;
   /**
    * Called when this turn leaves a confirmation for the user to answer instead
@@ -511,9 +482,10 @@ export interface VoiceTurnOptions {
    */
   overrideProfile?: string;
   /**
-   * Which leg of a triaged turn this is, so the control prompt (auto-built or
-   * caller-supplied) carries the front-door triage rule or the escalated
-   * continuation rule. Undefined = routing off; no routing rules are added.
+   * Which leg of a triaged turn this is, so the auto-built phone control prompt
+   * can add the front-door triage rule or the escalated continuation rule.
+   * Undefined = routing off; no routing rules are added. Ignored when a caller
+   * supplies its own `voiceControlPrompt`.
    */
   routingLeg?: VoiceRoutingLeg;
   /**
@@ -639,8 +611,9 @@ function buildVoiceCallControlPrompt(opts: {
   task?: string | null;
   isCallerGuardian?: boolean;
   skipDisclosure?: boolean;
-  /** The turn's routing-leg rule (see {@link routingLegRuleFor}), if any. */
-  routingLegRule?: string | null;
+  routingLeg?: VoiceRoutingLeg;
+  spokenEscalationBridge?: string;
+  unifiedVerdict?: boolean;
 }): string {
   const config = getConfig();
   const disclosureEnabled =
@@ -692,18 +665,22 @@ function buildVoiceCallControlPrompt(opts: {
     );
   }
 
+  lines.push(
+    '6. When caller text includes [SPEAKER id="..." label="..."], treat each speaker as a distinct person and personalize responses using that speaker\'s prior context in this call.',
+  );
+
   if (opts.isInbound) {
     if (opts.isCallerGuardian) {
       lines.push(
-        '6. If the latest user turn is "(call connected — deliver opening greeting)", this is your user calling you. Answer casually and briefly, like picking up a call from someone you know well. For example: "Hey!" or "What\'s up?" Do NOT introduce yourself, do NOT say you are calling on behalf of anyone, and do NOT ask how you can help in a formal way. Keep it short and natural.',
+        '7. If the latest user turn is "(call connected — deliver opening greeting)", this is your user calling you. Answer casually and briefly, like picking up a call from someone you know well. For example: "Hey!" or "What\'s up?" Do NOT introduce yourself, do NOT say you are calling on behalf of anyone, and do NOT ask how you can help in a formal way. Keep it short and natural.',
       );
     } else {
       lines.push(
-        '6. If the latest user turn is "(call connected — deliver opening greeting)", this is an inbound call you are answering (not a call you initiated). Greet the caller warmly and ask how you can help. Introduce yourself once at the start using your assistant name if you know it (for example: "Hey there, this is Ava, Sam\'s assistant. How can I help?"). If your assistant name is not known, skip the name and just identify yourself as the guardian\'s assistant. Never use a UUID-shaped internal assistant ID as your spoken name. Do NOT say "I\'m calling" or "I\'m calling on behalf of". Vary the wording; do not use a fixed template.',
+        '7. If the latest user turn is "(call connected — deliver opening greeting)", this is an inbound call you are answering (not a call you initiated). Greet the caller warmly and ask how you can help. Introduce yourself once at the start using your assistant name if you know it (for example: "Hey there, this is Ava, Sam\'s assistant. How can I help?"). If your assistant name is not known, skip the name and just identify yourself as the guardian\'s assistant. Never use a UUID-shaped internal assistant ID as your spoken name. Do NOT say "I\'m calling" or "I\'m calling on behalf of". Vary the wording; do not use a fixed template.',
       );
     }
     lines.push(
-      "7. If the latest user turn includes [CALL_OPENING_ACK], treat it as the caller acknowledging your greeting and continue the conversation naturally.",
+      "8. If the latest user turn includes [CALL_OPENING_ACK], treat it as the caller acknowledging your greeting and continue the conversation naturally.",
     );
   } else {
     const disclosureReminder =
@@ -711,22 +688,27 @@ function buildVoiceCallControlPrompt(opts: {
         ? " However, the disclosure text from rule 0 is separate from self-introduction and must always be included in your opening greeting, even if the Task does not mention introducing yourself."
         : "";
     lines.push(
-      '6. If the latest user turn is "(verification completed — transitioning into conversation)", the caller just completed a phone verification code challenge on this call. Greet them naturally and ask if there is anything you can help with. Keep it casual and brief.',
-      `If the latest user turn is "(call connected — deliver opening greeting)", deliver your opening greeting based solely on the Task context above. The Task already describes how to open the call, so follow it directly without adding any extra introduction on top. If the Task says to introduce yourself, do so once. If the Task does not mention introducing yourself, skip the introduction.${disclosureReminder} Vary the wording naturally; do not use a fixed template.`,
-      "7. If the latest user turn includes [CALL_OPENING_ACK], treat it as the callee acknowledging your opener and continue the conversation naturally without re-introducing yourself or repeating the initial check-in question.",
+      '7. If the latest user turn is "(verification completed — transitioning into conversation)", the caller just completed a phone verification code challenge on this call. Greet them naturally and ask if there is anything you can help with. Keep it casual and brief.',
+      `If the latest user turn is "(call connected — deliver opening greeting)", deliver your opening greeting based solely on the Task context above. The Task already describes how to open the call — follow it directly without adding any extra introduction on top. If the Task says to introduce yourself, do so once. If the Task does not mention introducing yourself, skip the introduction.${disclosureReminder} Vary the wording naturally; do not use a fixed template.`,
+      "8. If the latest user turn includes [CALL_OPENING_ACK], treat it as the callee acknowledging your opener and continue the conversation naturally without re-introducing yourself or repeating the initial check-in question.",
     );
   }
 
   lines.push(
-    "8. After the opening greeting turn, treat the Task field as background context only. Do not re-execute its instructions on subsequent turns.",
-    '9. Do not make up information. If you are unsure, use [ASK_GUARDIAN: your question] to consult your guardian. For tool permission requests, use [ASK_GUARDIAN_APPROVAL: {"question":"...","toolName":"...","input":{...}}].',
-    `10. ${SPOKEN_REPLY_PLAIN_TEXT_RULE} Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
-    `11. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, ${preSpeechLanguageRuleFragment(config.services.stt.language, sttCatalogKeyForRole(config.services.stt, "telephony"))}.`,
-    `12. ${PHONE_NO_SETUP_FLOWS_RULE}`,
+    "9. After the opening greeting turn, treat the Task field as background context only — do not re-execute its instructions on subsequent turns.",
+    '10. Do not make up information. If you are unsure, use [ASK_GUARDIAN: your question] to consult your guardian. For tool permission requests, use [ASK_GUARDIAN_APPROVAL: {"question":"...","toolName":"...","input":{...}}].',
+    `11. ${SPOKEN_REPLY_PLAIN_TEXT_RULE} Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
+    `12. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, ${preSpeechLanguageRuleFragment(config.services.stt.language, sttCatalogKeyForRole(config.services.stt, "telephony"))}.`,
+    `13. ${PHONE_NO_SETUP_FLOWS_RULE}`,
   );
 
-  if (opts.routingLegRule) {
-    lines.push(`13. ${opts.routingLegRule}`);
+  // Triage-and-escalate routing rules. The front-door leg decides and may
+  // hand off; the escalated leg continues the answer after a holding phrase
+  // was already spoken.
+  if (opts.routingLeg === "front-door") {
+    lines.push(`14. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
+  } else if (opts.routingLeg === "escalated") {
+    lines.push(`14. ${escalatedContinuationRule(opts.spokenEscalationBridge)}`);
   }
 
   lines.push("</voice_call_control>");
@@ -974,10 +956,6 @@ export async function startVoiceTurn(
   // control markers (ASK_GUARDIAN, END_CALL, etc.) and recognize opener turns.
   const isCallerGuardian = opts.trustContext?.trustClass === "guardian";
 
-  // The front-door rule anchors on the words the model sees as the user
-  // turn, which for a phone sentinel is its neutral persisted form rather
-  // than the marker itself.
-  const routingLegRule = routingLegRuleFor(opts, persistedContent);
   let voiceCallControlPrompt: string | null;
   if (opts.voiceControlPrompt === undefined) {
     voiceCallControlPrompt = buildVoiceCallControlPrompt({
@@ -985,14 +963,23 @@ export async function startVoiceTurn(
       task: opts.task,
       isCallerGuardian,
       skipDisclosure: opts.skipDisclosure,
-      routingLegRule,
+      routingLeg: opts.routingLeg,
+      spokenEscalationBridge: opts.spokenEscalationBridge,
+      unifiedVerdict: opts.unifiedVerdict,
     });
   } else {
-    // A caller-supplied prompt (live voice) replaces the phone prompt, so the
-    // routing-leg rule is appended to it here. Without it the front-door leg
-    // would run on the fast profile but never learn the verdict protocol, so
-    // it could not hold or hand off to the escalated leg.
+    // A caller-supplied prompt (e.g. live-voice) bypasses
+    // buildVoiceCallControlPrompt, which is where the triage-and-escalate rule
+    // is normally injected from `routingLeg`. Append it here too — without it
+    // the front-door leg would run on the fast profile but never learn the
+    // verdict protocol, so it could not hold or hand off to the escalated leg.
     voiceCallControlPrompt = opts.voiceControlPrompt;
+    const routingLegRule =
+      opts.routingLeg === "front-door"
+        ? frontDoorRuleWithDigest(opts.unifiedVerdict === true, opts.content)
+        : opts.routingLeg === "escalated"
+          ? escalatedContinuationRule(opts.spokenEscalationBridge)
+          : null;
     if (voiceCallControlPrompt != null && routingLegRule) {
       voiceCallControlPrompt = `${voiceCallControlPrompt}\n\n${routingLegRule}`;
     }

package/src/calls/voice-triage-escalate.ts

@@ -27,10 +27,7 @@
  */
 
 import { NON_LATIN_SENTENCE_ENDING_PUNCTUATION } from "../tts/speakable-segments.js";
-import {
-  fixedPhraseLanguage,
-  localizedOrDefault,
-} from "../util/language-subtag.js";
+import { localizedOrDefault } from "../util/language-subtag.js";
 import {
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
@@ -106,36 +103,6 @@ export function fallbackEscalationBridgeFor(language?: string): string {
  */
 export const MIN_SPOKEN_BRIDGE_CHARS = 3;
 
-/**
- * The phrase spoken across an escalation hand-off, for both voice drivers:
- * the front-door leg's own capped bridge when it is a real bridge, else the
- * canned fallback in the caller's language. `usesFallback` marks the canned
- * phrase as audio-only: the model never produced it, so no transcript row
- * carries it (the bridge's hygiene pass deletes the leg's row), and the
- * driver keeps it out of the turn's recorded text. `language` is the TTS
- * hint the phrase must carry: "en" when the canned table has no entry for
- * the caller's language (the phrase is English text then), undefined when
- * the phrase rides the turn's own language.
- */
-export function resolveSpokenEscalationBridge(
-  cappedBridge: string,
-  language?: string,
-): { spokenBridge: string; usesFallback: boolean; language?: string } {
-  const usesFallback = cappedBridge.length < MIN_SPOKEN_BRIDGE_CHARS;
-  if (!usesFallback) {
-    return { spokenBridge: cappedBridge, usesFallback };
-  }
-  const fixedLanguage = fixedPhraseLanguage(
-    FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
-    language,
-  );
-  return {
-    spokenBridge: fallbackEscalationBridgeFor(language),
-    usesFallback,
-    ...(fixedLanguage !== undefined ? { language: fixedLanguage } : {}),
-  };
-}
-
 /**
  * Hard cap on the spoken escalation bridge. The bridge is supposed to be a
  * single short sentence; the cap bounds the hand-off delay (and the audio)
@@ -192,20 +159,14 @@ export function isEscalationBridgeComplete(rawBridge: string): boolean {
  * output leads with {@link ESCALATE_VERDICT_TOKEN} (a stray token later in
  * an answer is not an escalation under the verdict-first protocol), else
  * the capped bridge that followed the token. Used by transcript hygiene to
- * reconstruct what the caller heard from a persisted row, by running the
- * same verdict machine the live stream ran through.
+ * reconstruct what the caller heard from a persisted row.
  */
 export function spokenBridgeText(frontDoorText: string): string {
-  const machine = createFrontDoorVerdictMachine(false);
-  const step = machine.push(frontDoorText);
-  if (step.kind !== "escalate") {
+  const leading = frontDoorText.trimStart();
+  if (!leading.startsWith(ESCALATE_VERDICT_TOKEN)) {
     return "";
   }
-  if (step.bridge !== null) {
-    return step.bridge;
-  }
-  const finished = machine.finish();
-  return finished.kind === "bridge" ? finished.bridge : "";
+  return capEscalationBridge(leading.slice(ESCALATE_VERDICT_TOKEN.length));
 }
 
 /**
@@ -263,187 +224,107 @@ export function classifyFrontDoorLeading(
 }
 
 /**
- * One step of a front-door leg's stream under the verdict-first protocol,
- * as returned by {@link FrontDoorVerdictMachine.push}.
- */
-export type FrontDoorStep =
-  /** The leading tokens could still become a verdict token: keep buffering. */
-  | { readonly kind: "pending" }
-  /** Hold verdict: the leg is discarded and listening continues. */
-  | { readonly kind: "hold" }
-  /**
-   * The leg's output is the answer. `text` is the raw text this delta
-   * released; on the transition it includes the leading text held while the
-   * verdict was pending.
-   */
-  | { readonly kind: "answer"; readonly text: string }
-  /**
-   * Escalate verdict, decided by this delta. `bridge` is the capped holding
-   * phrase when this delta already completed it, else null while the phrase
-   * keeps streaming.
-   */
-  | { readonly kind: "escalate"; readonly bridge: string | null }
-  /** Post-verdict text still buffering toward the capped bridge. */
-  | { readonly kind: "bridging" }
-  /** The capped bridge is complete: hand off to the escalated leg. */
-  | { readonly kind: "bridge"; readonly bridge: string }
-  /** The leg already held, handed off, or finished; nothing more happens. */
-  | { readonly kind: "done" };
-
-/**
- * The verdict-first state machine over a front-door leg's delta stream. One
- * implementation drives every consumer of that stream: the live-voice
- * session (which acts on the steps), the conversation-hub stream gate
- * (which releases only the text the caller hears), and transcript hygiene
- * (which replays a persisted row through it).
+ * Verdict-first gate over a front-door leg's delta stream: given the leg's
+ * raw deltas in order, it releases only the text the caller actually hears.
+ * A front-door leg's raw stream is a control plane, not assistant speech,
+ * until its leading tokens classify, so anything downstream of the model
+ * that shows text to a person reads the stream through this gate.
  *
- * `push` feeds one delta and reports what it decided. `finish` is called
- * when the leg completes normally: a bridge that stopped short of a
- * sentence terminator hands off with what arrived. A leg that is cancelled
- * instead never calls `finish`.
+ * `push` returns the text released by that delta (empty while the gate is
+ * holding). `finish` is called when the leg completes normally and releases
+ * a bridge that stopped short of a sentence terminator. A leg that is
+ * cancelled instead spoke nothing past what `push` already released, so it
+ * simply never calls `finish`.
  */
-export interface FrontDoorVerdictMachine {
-  push(deltaText: string): FrontDoorStep;
-  finish(): FrontDoorStep;
+export interface FrontDoorStreamGate {
+  push(deltaText: string): string;
+  finish(): string;
 }
 
-const PENDING_STEP: FrontDoorStep = { kind: "pending" };
-const HOLD_STEP: FrontDoorStep = { kind: "hold" };
-const BRIDGING_STEP: FrontDoorStep = { kind: "bridging" };
-const DONE_STEP: FrontDoorStep = { kind: "done" };
-
 /**
- * Build a {@link FrontDoorVerdictMachine}. `holdEnabled` mirrors
+ * Build a {@link FrontDoorStreamGate}. `holdEnabled` mirrors
  * {@link classifyFrontDoorLeading}: true only for speculative (unified
  * front-door) legs, whose decision rule is the only one that teaches the
  * hold token.
  *
- * The bridge handed off is exactly what {@link capEscalationBridge} yields,
- * so the audio, the released text, the persisted row, and the phrase quoted
- * to the escalated leg all agree. The verdict token and anything streamed
- * past the cap are never released.
+ * The three verdicts release differently, matching what the caller hears:
+ *
+ * - `hold`: the leg is discarded and its row deleted, so nothing is ever
+ *   released.
+ * - `escalate`: the only spoken text is the capped holding phrase, released
+ *   in one piece once the bridge is complete (exactly what
+ *   {@link capEscalationBridge} yields, so the released text, the audio, and
+ *   the persisted row agree). The verdict token and anything streamed past
+ *   the cap are dropped. A bridge shorter than
+ *   {@link MIN_SPOKEN_BRIDGE_CHARS} releases nothing at all: the session
+ *   substitutes an audio-only canned fallback for it, so there is no
+ *   displayed text for the gate to agree with.
+ * - `answer`: the leg's output IS the reply, so every delta passes through,
+ *   including the leading text held back while the verdict was pending.
  */
-export function createFrontDoorVerdictMachine(
+export function createFrontDoorStreamGate(
   holdEnabled: boolean,
-): FrontDoorVerdictMachine {
+): FrontDoorStreamGate {
   let raw = "";
   let stage: "deciding" | "answer" | "bridging" | "done" = "deciding";
   let bridgeRaw = "";
   let releasedChars = 0;
 
-  const completeBridge = (): Extract<FrontDoorStep, { kind: "bridge" }> => {
+  const releaseBridge = (): string => {
     stage = "done";
-    return { kind: "bridge", bridge: capEscalationBridge(bridgeRaw) };
+    const capped = capEscalationBridge(bridgeRaw);
+    // Below the spoken threshold the session throws the model's bridge away
+    // and plays a canned fallback that is audio-only, deleting the row rather
+    // than persisting a phrase the model never really produced (see
+    // `usesFallbackBridge` in `live-voice-session.ts`). Releasing the capped
+    // text here would put words on a subscriber's screen that the caller never
+    // heard, which is the same spoken/displayed divergence this gate exists to
+    // prevent.
+    return capped.length < MIN_SPOKEN_BRIDGE_CHARS ? "" : capped;
   };
 
   return {
-    push(deltaText: string): FrontDoorStep {
+    push(deltaText: string): string {
       raw += deltaText;
       if (stage === "done") {
-        return DONE_STEP;
+        return "";
       }
       if (stage === "bridging") {
         bridgeRaw += deltaText;
-        return isEscalationBridgeComplete(bridgeRaw)
-          ? completeBridge()
-          : BRIDGING_STEP;
+        return isEscalationBridgeComplete(bridgeRaw) ? releaseBridge() : "";
       }
       if (stage === "deciding") {
         const verdict = classifyFrontDoorLeading(raw.trimStart(), holdEnabled);
         if (verdict === "pending") {
-          return PENDING_STEP;
+          return "";
         }
         if (verdict === "hold") {
           stage = "done";
-          return HOLD_STEP;
+          return "";
         }
         if (verdict === "escalate") {
           stage = "bridging";
           bridgeRaw = raw.trimStart().slice(ESCALATE_VERDICT_TOKEN.length);
-          return {
-            kind: "escalate",
-            bridge: isEscalationBridgeComplete(bridgeRaw)
-              ? completeBridge().bridge
-              : null,
-          };
+          return isEscalationBridgeComplete(bridgeRaw) ? releaseBridge() : "";
         }
         stage = "answer";
       }
       // Answer stage: release everything not yet released, which on the
       // transition includes the leading text the pending verdict held.
-      const text = raw.slice(releasedChars);
+      const chunk = raw.slice(releasedChars);
       releasedChars = raw.length;
-      return { kind: "answer", text };
+      return chunk;
     },
-    finish(): FrontDoorStep {
+    finish(): string {
       if (stage === "bridging") {
-        return completeBridge();
+        return releaseBridge();
       }
       stage = "done";
-      return DONE_STEP;
+      return "";
     },
   };
 }
 
-/**
- * Verdict-first gate over a front-door leg's delta stream: given the leg's
- * raw deltas in order, it releases only the text the caller actually hears.
- * A front-door leg's raw stream is a control plane, not assistant speech,
- * until its leading tokens classify, so anything downstream of the model
- * that shows text to a person reads the stream through this gate.
- *
- * `push` returns the text released by that delta (empty while the gate is
- * holding). `finish` is called when the leg completes normally and releases
- * a bridge that stopped short of a sentence terminator. A leg that is
- * cancelled instead spoke nothing past what `push` already released, so it
- * simply never calls `finish`.
- */
-export interface FrontDoorStreamGate {
-  push(deltaText: string): string;
-  finish(): string;
-}
-
-/**
- * Build a {@link FrontDoorStreamGate} over a {@link FrontDoorVerdictMachine}.
- *
- * The three verdicts release differently, matching what the caller hears:
- *
- * - `hold`: the leg is discarded and its row deleted, so nothing is ever
- *   released.
- * - `escalate`: the only spoken text is the capped holding phrase, released
- *   in one piece once the bridge is complete. A bridge shorter than
- *   {@link MIN_SPOKEN_BRIDGE_CHARS} releases nothing at all: the session
- *   substitutes an audio-only canned fallback for it (see
- *   `usesFallbackBridge` in `live-voice-session.ts`) and deletes the row
- *   rather than persisting a phrase the model never really produced, so
- *   there is no displayed text for the gate to agree with.
- * - `answer`: the leg's output IS the reply, so every delta passes through,
- *   including the leading text held back while the verdict was pending.
- */
-export function createFrontDoorStreamGate(
-  holdEnabled: boolean,
-): FrontDoorStreamGate {
-  const machine = createFrontDoorVerdictMachine(holdEnabled);
-  const releasable = (bridge: string): string =>
-    bridge.length < MIN_SPOKEN_BRIDGE_CHARS ? "" : bridge;
-  const release = (step: FrontDoorStep): string => {
-    switch (step.kind) {
-      case "answer":
-        return step.text;
-      case "escalate":
-        return step.bridge === null ? "" : releasable(step.bridge);
-      case "bridge":
-        return releasable(step.bridge);
-      default:
-        return "";
-    }
-  };
-  return {
-    push: (deltaText) => release(machine.push(deltaText)),
-    finish: () => release(machine.finish()),
-  };
-}
-
 /**
  * The escalated leg runs as its own voice turn. Rather than re-persist the
  * caller's utterance (it is already in history from the front-door leg), the