@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/calls/voice-progress-cadence.ts

@@ -0,0 +1,423 @@
+/**
+ * Progress narration cadence for one voice turn, shared by the live-voice
+ * session and the phone call controller.
+ *
+ * A voice turn that runs tools is silent while they run. The cadence speaks
+ * short audio-only progress updates into that dead air: a generated
+ * sentence about what the turn is doing (see `progress-narration.ts`), or a
+ * static fallback phrase when generation yields nothing. It follows the
+ * turn's tool activity rather than the clock: an "ops" burst, a long
+ * operation completing, or a full interval of audible silence with news
+ * since the last update, with `maxSilenceMs` as the heartbeat ceiling.
+ *
+ * The cadence owns the per-turn state (the tool-activity log, epochs,
+ * spacing, the self-re-arming idle timer). Everything transport-specific
+ * comes in through {@link ProgressCadenceHost}: whether the turn's audio is
+ * idle, when it last reached the listener, and how to speak a phrase.
+ */
+
+import type { VoiceProgressConfig } from "../config/schemas/voice.js";
+import { fixedPhraseLanguage } from "../util/language-subtag.js";
+import { getLogger } from "../util/logger.js";
+import type {
+  VoiceProgressNarrator,
+  VoiceProgressTextInput,
+} from "./progress-narration.js";
+import {
+  pickProgressPhrase,
+  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+} from "./progress-phrases.js";
+
+const log = getLogger("voice-progress-cadence");
+
+/**
+ * One tool operation observed on a turn, fed by the bridge's structured tool
+ * callbacks. `completedAtMs`/`isError`/`resultPreview` land with tool_result.
+ */
+export interface TurnProgressOp {
+  toolName: string;
+  toolUseId?: string;
+  startedAtMs: number;
+  completedAtMs?: number;
+  isError?: boolean;
+  resultPreview?: string;
+}
+
+/** What prompted a narration attempt. */
+export type ProgressNarrationTrigger = "ops" | "idle" | "op_complete";
+
+/** A tool completion as the bridge reports it. */
+export interface ProgressToolResult {
+  toolName: string;
+  toolUseId?: string;
+  isError?: boolean;
+  resultPreview?: string;
+}
+
+/**
+ * Newest incomplete op, optionally restricted to a tool name (the
+ * tool_result fallback match when no toolUseId correlates).
+ */
+export function findLastIncompleteOp(
+  ops: readonly TurnProgressOp[],
+  toolName?: string,
+): TurnProgressOp | undefined {
+  for (let i = ops.length - 1; i >= 0; i -= 1) {
+    const op = ops[i];
+    if (
+      op.completedAtMs === undefined &&
+      (toolName === undefined || op.toolName === toolName)
+    ) {
+      return op;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The transport-specific half of progress narration, supplied by the driver
+ * that owns the turn's audio.
+ */
+export interface ProgressCadenceHost {
+  /** Identifies the turn in logs. */
+  turnId: string;
+  /** Dispatch timestamp of the turn (`Date.now()` at launch). */
+  launchedAtMs: number;
+  /** Aborts an in-flight narration generation with the turn. */
+  signal: AbortSignal;
+  /**
+   * Whether the turn may still be narrated: it is the live turn, it has not
+   * completed, and it is not waiting on a decision (a turn waiting on an
+   * approval says so once and is quiet after that).
+   */
+  canNarrate(): boolean;
+  /**
+   * No assistant audio is buffered, queued, in flight, or (estimatedly)
+   * still playing to the listener.
+   */
+  isAudioIdle(): boolean;
+  /**
+   * Wall-clock estimate of when audio already handed to the transport
+   * finishes reaching the listener, 0 when nothing is playing. Together with
+   * the cadence's own last-emitted stamp this anchors the dead-air countdown
+   * to when the listener last heard something.
+   */
+  playbackTailUntilMs(): number;
+  /** The caller's words this turn answers, for the narrator. */
+  transcriptSoFar(): string;
+  /** The turn's spoken language, when known. */
+  language(): string | undefined;
+  /**
+   * Bumped on every assistant text delta. A narration generated while the
+   * model was already speaking is stale and is dropped.
+   */
+  deltaEpoch(): number;
+  /**
+   * Speak one sanitized phrase, audio-only. `language` is the TTS hint the
+   * phrase must carry ("en" for a static fallback the localized table lacks
+   * in the turn's language); undefined rides the turn's language. Returns
+   * false when nothing was spoken.
+   */
+  speak(phrase: string, language: string | undefined): boolean;
+  /** Called after a narration was actually enqueued (metrics). */
+  onNarrationSpoken?(): void;
+}
+
+export interface ProgressCadenceOptions {
+  config: VoiceProgressConfig;
+  /** Null disables narration for the turn (no TTS, or narration off). */
+  narrator: VoiceProgressNarrator | null;
+  host: ProgressCadenceHost;
+  /**
+   * Rotates the static fallback phrase across turns so a session with
+   * repeated dead air does not repeat one sentence.
+   */
+  nextFallbackPhraseIndex: () => number;
+}
+
+export interface ProgressCadence {
+  /** Tool operations this turn, in start order. */
+  readonly ops: readonly TurnProgressOp[];
+  /** Narrations actually spoken this turn. */
+  readonly updatesSpoken: number;
+  /** A tool started: counts toward the "ops" trigger and is news for idle. */
+  toolStarted(toolName: string, toolUseId?: string): void;
+  /**
+   * A tool finished. A long operation completing narrates on its own beat;
+   * a quick one only counts as news.
+   */
+  toolFinished(event: ProgressToolResult): void;
+  /** The turn's audio last finished emitting now: restarts the dead-air clock. */
+  noteAudioSettled(): void;
+  /**
+   * Something else held the floor now (a spoken approval line, a bridge):
+   * narration keeps `minGapMs` from it.
+   */
+  noteFloorHolder(): void;
+  /**
+   * Arm (or re-arm) the dead-air timer. A no-op when narration is off for
+   * the turn.
+   */
+  arm(): void;
+  /** Stop the dead-air timer; the turn ended, was cancelled, or handed off. */
+  clear(): void;
+}
+
+export function createProgressCadence(
+  options: ProgressCadenceOptions,
+): ProgressCadence {
+  const { config, narrator, host, nextFallbackPhraseIndex } = options;
+  const ops: TurnProgressOp[] = [];
+  // Ops accumulated toward the next ops-triggered narration. Counted once
+  // per op, on start (not completion), so a burst of slow tools still trips
+  // the threshold while they run.
+  let opsSinceNarration = 0;
+  // Bumped by every observable change to the turn's tool activity. The idle
+  // trigger compares it against `narratedEpoch` so a tick with nothing new
+  // to report stays silent.
+  let stateEpoch = 0;
+  let narratedEpoch = 0;
+  let updatesSpoken = 0;
+  // When the last spoken floor-holder enqueued; gates `minGapMs`.
+  let lastFloorHolderAtMs: number | null = null;
+  // When the turn's audio last finished emitting (turn launch until anything
+  // speaks). Idle time is measured from when the listener last heard
+  // something, not from when the turn started.
+  let lastAudibleAtMs = Date.now();
+  let idleTimer: ReturnType<typeof setTimeout> | null = null;
+  // A narration generation is awaiting the narrator; serializes narrations.
+  let narrationInFlight = false;
+
+  const enabled = config.enabled && narrator !== null;
+
+  // When the turn's current audible silence began: the latest of the last
+  // emitted segment, the estimated playback end, and the last floor holder.
+  const silenceSinceMs = (): number =>
+    Math.max(
+      lastAudibleAtMs,
+      host.playbackTailUntilMs(),
+      lastFloorHolderAtMs ?? 0,
+    );
+
+  const canNarrate = (): boolean => host.canNarrate() && host.isAudioIdle();
+
+  const withinMinGap = (): boolean =>
+    lastFloorHolderAtMs !== null &&
+    Date.now() - lastFloorHolderAtMs < config.minGapMs;
+
+  // The idle tick has something worth saying when the turn's tool activity
+  // has moved since the last narration described it, or when the silence has
+  // run past `maxSilenceMs`, the heartbeat ceiling that proves the assistant
+  // is still alive on a turn with no observable activity at all.
+  const idleHasSomethingToSay = (): boolean => {
+    if (stateEpoch !== narratedEpoch) {
+      return true;
+    }
+    const silentForMs = Date.now() - silenceSinceMs();
+    if (silentForMs >= config.maxSilenceMs) {
+      return true;
+    }
+    log.debug(
+      { turnId: host.turnId, silentForMs },
+      "Voice progress narration held: nothing new since the last update",
+    );
+    return false;
+  };
+
+  const clearTimer = (): void => {
+    if (idleTimer !== null) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  };
+
+  // Arms the dead-air timer. The countdown measures audible silence, not
+  // time since launch, so it covers mid-turn silences for the whole turn. On
+  // expiry with audio still pending, or with the silence not yet a full
+  // interval old, it re-arms for the remainder; only a full interval of
+  // audible silence reaches the gatekeeper. The interval is a polling
+  // cadence, not a speaking cadence: most ticks find nothing new and stay
+  // quiet.
+  const armTimer = (delayMs?: number): void => {
+    clearTimer();
+    idleTimer = setTimeout(() => {
+      idleTimer = null;
+      if (!host.canNarrate()) {
+        return;
+      }
+      if (!host.isAudioIdle()) {
+        armTimer();
+        return;
+      }
+      const remaining = silenceSinceMs() + config.idleIntervalMs - Date.now();
+      if (remaining > 0) {
+        armTimer(remaining);
+        return;
+      }
+      maybeNarrate("idle");
+      armTimer();
+    }, delayMs ?? config.idleIntervalMs);
+  };
+
+  // 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.
+  const speakUpdate = async (
+    activeNarrator: VoiceProgressNarrator,
+    trigger: ProgressNarrationTrigger,
+  ): Promise<void> => {
+    narrationInFlight = true;
+    const deltaEpochAtLaunch = host.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 trigger armed rather than count as already narrated.
+    const stateEpochAtLaunch = stateEpoch;
+    try {
+      const now = Date.now();
+      const currentOp = findLastIncompleteOp(ops);
+      const language = host.language();
+      const input: VoiceProgressTextInput = {
+        transcriptSoFar: host.transcriptSoFar(),
+        completedOps: ops
+          .filter(
+            (op): op is TurnProgressOp & { completedAtMs: number } =>
+              op.completedAtMs !== undefined,
+          )
+          // `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) => ({
+            toolName: op.toolName,
+            ...(op.isError !== undefined ? { isError: op.isError } : {}),
+            ...(op.resultPreview !== undefined
+              ? { resultPreview: op.resultPreview }
+              : {}),
+          })),
+        currentOp: currentOp
+          ? {
+              toolName: currentOp.toolName,
+              elapsedMs: now - currentOp.startedAtMs,
+            }
+          : null,
+        turnElapsedMs: now - host.launchedAtMs,
+        updateIndex: updatesSpoken + 1,
+        ...(language !== undefined ? { languageHint: language } : {}),
+      };
+      const generated = await activeNarrator
+        .generateProgressText(input, host.signal)
+        // The narrator contract never rejects. Keep test stubs fail-soft too.
+        .catch(() => null);
+      // Re-check liveness and staleness after the provider call.
+      if (
+        !canNarrate() ||
+        host.deltaEpoch() !== deltaEpochAtLaunch ||
+        withinMinGap()
+      ) {
+        return;
+      }
+      let raw = generated;
+      // 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) {
+        if (trigger !== "idle") {
+          return;
+        }
+        raw = pickProgressPhrase(nextFallbackPhraseIndex(), language);
+        fillerLanguage = fixedPhraseLanguage(
+          PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+          language,
+        );
+      }
+      if (!host.speak(raw, fillerLanguage)) {
+        return;
+      }
+      lastFloorHolderAtMs = Date.now();
+      opsSinceNarration = 0;
+      narratedEpoch = stateEpochAtLaunch;
+      updatesSpoken += 1;
+      host.onNarrationSpoken?.();
+      // Restart the dead-air countdown from this narration.
+      armTimer();
+    } finally {
+      narrationInFlight = false;
+    }
+  };
+
+  // Gatekeeper. Speaks only while the turn is audibly silent, with one
+  // generation at a time and the configured spacing.
+  const maybeNarrate = (trigger: ProgressNarrationTrigger): void => {
+    if (
+      !enabled ||
+      narrator === null ||
+      !canNarrate() ||
+      narrationInFlight ||
+      withinMinGap() ||
+      (trigger === "ops" && opsSinceNarration < config.opsThreshold) ||
+      (trigger === "idle" && !idleHasSomethingToSay())
+    ) {
+      return;
+    }
+    void speakUpdate(narrator, trigger);
+  };
+
+  return {
+    get ops() {
+      return ops;
+    },
+    get updatesSpoken() {
+      return updatesSpoken;
+    },
+    toolStarted(toolName, toolUseId) {
+      ops.push({
+        toolName,
+        ...(toolUseId !== undefined ? { toolUseId } : {}),
+        startedAtMs: Date.now(),
+      });
+      opsSinceNarration += 1;
+      stateEpoch += 1;
+      maybeNarrate("ops");
+    },
+    toolFinished(event) {
+      // Match by toolUseId when present; otherwise the last-started
+      // incomplete op with the same name (parallel same-name ops resolve
+      // newest-first).
+      const op =
+        (event.toolUseId !== undefined
+          ? ops.find((o) => o.toolUseId === event.toolUseId)
+          : undefined) ?? findLastIncompleteOp(ops, event.toolName);
+      // A long-running op finishing is the beat the listener has been
+      // waiting through: it narrates immediately rather than waiting for
+      // `opsThreshold` more ops, which on a one-slow-tool turn never arrive.
+      // Short ops stay on the ops trigger.
+      let trigger: ProgressNarrationTrigger = "ops";
+      if (op) {
+        op.completedAtMs = Date.now();
+        if (event.isError !== undefined) {
+          op.isError = event.isError;
+        }
+        if (event.resultPreview !== undefined) {
+          op.resultPreview = event.resultPreview;
+        }
+        if (op.completedAtMs - op.startedAtMs >= config.longOpMs) {
+          trigger = "op_complete";
+        }
+      }
+      stateEpoch += 1;
+      maybeNarrate(trigger);
+    },
+    noteAudioSettled() {
+      lastAudibleAtMs = Date.now();
+    },
+    noteFloorHolder() {
+      lastFloorHolderAtMs = Date.now();
+    },
+    arm() {
+      if (!enabled) {
+        return;
+      }
+      armTimer();
+    },
+    clear: clearTimer,
+  };
+}

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

@@ -188,6 +188,34 @@ 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
@@ -373,8 +401,9 @@ 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. Absent for phone calls and for clients that send
-   * no identity on the start frame.
+   * 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.
    */
   voiceTelemetry?: {
     sessionId: string;
@@ -447,7 +476,7 @@ export interface VoiceTurnOptions {
   onComplete?: () => void;
   /** Called when the agent loop encounters an error. */
   onError?: (message: string) => void;
-  /** Event-name callbacks used by non-phone voice clients. */
+  /** Event-name callbacks: tool activity, persisted row ids, raw stream. */
   callbacks?: VoiceTurnCallbacks;
   /**
    * Called when this turn leaves a confirmation for the user to answer instead
@@ -482,10 +511,9 @@ export interface VoiceTurnOptions {
    */
   overrideProfile?: string;
   /**
-   * 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`.
+   * 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.
    */
   routingLeg?: VoiceRoutingLeg;
   /**
@@ -611,9 +639,8 @@ function buildVoiceCallControlPrompt(opts: {
   task?: string | null;
   isCallerGuardian?: boolean;
   skipDisclosure?: boolean;
-  routingLeg?: VoiceRoutingLeg;
-  spokenEscalationBridge?: string;
-  unifiedVerdict?: boolean;
+  /** The turn's routing-leg rule (see {@link routingLegRuleFor}), if any. */
+  routingLegRule?: string | null;
 }): string {
   const config = getConfig();
   const disclosureEnabled =
@@ -665,22 +692,18 @@ 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(
-        '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.',
+        '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.',
       );
     } else {
       lines.push(
-        '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.',
+        '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.',
       );
     }
     lines.push(
-      "8. If the latest user turn includes [CALL_OPENING_ACK], treat it as the caller acknowledging your greeting and continue the conversation naturally.",
+      "7. 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 =
@@ -688,27 +711,22 @@ 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(
-      '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.",
+      '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.",
     );
   }
 
   lines.push(
-    "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}`,
+    "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}`,
   );
 
-  // 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)}`);
+  if (opts.routingLegRule) {
+    lines.push(`13. ${opts.routingLegRule}`);
   }
 
   lines.push("</voice_call_control>");
@@ -956,6 +974,10 @@ 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({
@@ -963,23 +985,14 @@ export async function startVoiceTurn(
       task: opts.task,
       isCallerGuardian,
       skipDisclosure: opts.skipDisclosure,
-      routingLeg: opts.routingLeg,
-      spokenEscalationBridge: opts.spokenEscalationBridge,
-      unifiedVerdict: opts.unifiedVerdict,
+      routingLegRule,
     });
   } else {
-    // 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.
+    // 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.
     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}`;
     }