@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/calls/guardian-dispatch.ts

@@ -7,20 +7,22 @@
  * 3. Records guardian_action_delivery rows from pipeline delivery results
  */
 
+import { v4 as uuid } from "uuid";
+
 import {
-  createCanonicalGuardianRequest,
-  listCanonicalGuardianDeliveries,
-  listCanonicalGuardianRequests,
-} from "../contacts/canonical-guardian-store.js";
+  createGuardianRequest,
+  listGuardianRequestDeliveriesOrEmpty,
+  listGuardianRequestsOrEmpty,
+} from "../channels/gateway-guardian-requests.js";
 import {
   getGuardianDelivery,
   guardianForChannel,
 } from "../contacts/guardian-delivery-reader.js";
+import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import {
   recordApprovalCardDelivery,
   recordGuardianRequestDeliveries,
-} from "../notifications/canonical-delivery-recorder.js";
-import { emitNotificationSignal } from "../notifications/emit-signal.js";
+} from "../notifications/guardian-delivery-recorder.js";
 import { getLogger } from "../util/logger.js";
 import { getUserConsultationTimeoutMs } from "./call-constants.js";
 import type { CallPendingQuestion } from "./types.js";
@@ -92,7 +94,7 @@ async function dispatchGuardianQuestionInner(
     // Resolve the request principal from the gateway guardian delivery — the
     // same source the submitting actor (guardian-action-routes /
     // actor-trust-resolver) resolves, so they cannot diverge.
-    // applyCanonicalGuardianDecision requires strict equality with
+    // applyGuardianDecision requires strict equality with
     // request.guardianPrincipalId; sharing this gateway source guarantees the
     // stamped principal == the submitting principal.
     const guardians = await getGuardianDelivery({ channelTypes: ["vellum"] });
@@ -108,12 +110,12 @@ async function dispatchGuardianQuestionInner(
       return;
     }
 
-    // Create the canonical guardian request as the primary record.
-    const request = createCanonicalGuardianRequest({
+    // Create the guardian request as the primary record.
+    const request = await createGuardianRequest({
+      id: uuid(),
       kind: "pending_question",
-      sourceType: "voice",
       sourceChannel: "phone",
-      conversationId,
+      sourceConversationId: conversationId,
       callSessionId,
       pendingQuestionId: pendingQuestion.id,
       questionText: pendingQuestion.questionText,
@@ -129,29 +131,36 @@ async function dispatchGuardianQuestionInner(
         requestCode: request.requestCode,
         callSessionId,
       },
-      "Created canonical guardian request for voice dispatch",
+      "Created guardian request for voice dispatch",
     );
 
-    // Count how many canonical guardian requests are already pending for
+    // Both affinity hints below read from one voice-request listing; a
+    // degraded (empty) read only weakens the hints.
+    const voiceRequests = await listGuardianRequestsOrEmpty({
+      sourceType: "voice",
+    });
+
+    // Count how many guardian requests are already pending for
     // this call session. Used as a candidate-affinity hint so the decision
     // engine prefers reusing an existing conversation.
-    const activeGuardianRequestCount = listCanonicalGuardianRequests({
-      status: "pending",
-      sourceType: "voice",
-    }).filter((r) => r.callSessionId === callSessionId).length;
+    const activeGuardianRequestCount = voiceRequests.filter(
+      (r) => r.status === "pending" && r.callSessionId === callSessionId,
+    ).length;
 
     // Look up the vellum conversation used for the first guardian question
     // delivery in this call session. When found, pass it as an affinity hint
     // so the notification pipeline deterministically routes to the same
     // conversation instead of letting the LLM choose a different conversation.
-    // Find earlier canonical requests for this call session and check their
+    // Find earlier guardian requests for this call session and check their
     // deliveries for a vellum destination conversation ID.
     let existingGuardianConversationId: string | null = null;
-    const priorRequests = listCanonicalGuardianRequests({
-      sourceType: "voice",
-    }).filter((r) => r.callSessionId === callSessionId && r.id !== request.id);
+    const priorRequests = voiceRequests.filter(
+      (r) => r.callSessionId === callSessionId && r.id !== request.id,
+    );
     for (const priorReq of priorRequests) {
-      const deliveries = listCanonicalGuardianDeliveries(priorReq.id);
+      const deliveries = await listGuardianRequestDeliveriesOrEmpty(
+        priorReq.id,
+      );
       const vellumDelivery = deliveries.find(
         (d) => d.destinationChannel === "vellum" && d.destinationConversationId,
       );
@@ -173,8 +182,8 @@ async function dispatchGuardianQuestionInner(
     }
 
     // Route through the canonical notification pipeline. The paired vellum
-    // conversation from this pipeline is the canonical guardian conversation.
-    let vellumDeliveryId: string | undefined;
+    // conversation from this pipeline is the guardian conversation.
+    let vellumDeliveryIdPromise: Promise<string | undefined> | undefined;
     const requestCode =
       request.requestCode ?? request.id.slice(0, 6).toUpperCase();
     const signalResult = await emitNotificationSignal({
@@ -200,25 +209,33 @@ async function dispatchGuardianQuestionInner(
       },
       conversationAffinityHint,
       dedupeKey: `guardian:${request.id}`,
+      // The broadcaster awaits the returned promise, so the delivery row is
+      // durable before the client can act on the conversation; the
+      // post-broadcast recording loop reuses its row id.
       onConversationCreated: (info) => {
-        if (info.sourceEventName !== "guardian.question" || vellumDeliveryId)
+        if (
+          info.sourceEventName !== "guardian.question" ||
+          vellumDeliveryIdPromise
+        ) {
           return;
-        vellumDeliveryId = recordApprovalCardDelivery({
+        }
+        vellumDeliveryIdPromise = recordApprovalCardDelivery({
           requestId: request.id,
           channel: "vellum",
           conversationId: info.conversationId,
-        })?.id;
+        }).then((delivery) => delivery?.id);
+        return vellumDeliveryIdPromise.then(() => undefined);
       },
     });
 
-    vellumDeliveryId = recordGuardianRequestDeliveries({
+    const vellumDeliveryId = await recordGuardianRequestDeliveries({
       requestId: request.id,
       deliveryResults: signalResult.deliveryResults,
-      vellumDeliveryId,
+      vellumDeliveryId: await vellumDeliveryIdPromise,
     });
 
     if (!vellumDeliveryId) {
-      recordApprovalCardDelivery({
+      await recordApprovalCardDelivery({
         requestId: request.id,
         channel: "vellum",
         status: "failed",

package/src/calls/guardian-wait-controller.ts

@@ -2,7 +2,7 @@
  * Transport-agnostic guardian access-request wait controller.
  *
  * Owns the in-call wait for a guardian's decision on a caller access
- * request: the hold message, periodic heartbeat updates, canonical-request
+ * request: the hold message, periodic heartbeat updates, guardian-request
  * polling, the consultation timeout, and wait-state utterance handling
  * (reassurance, impatience, callback offer/opt-in). Resolution is
  * delivered through injected `onApproved` / `onDenied` / `onTimeout`
@@ -16,7 +16,7 @@
  * from access-request-wait.ts.
  */
 
-import { getCanonicalGuardianRequest as getCanonicalGuardianRequestFn } from "../contacts/canonical-guardian-store.js";
+import { getGuardianRequestOrNull } from "../channels/gateway-guardian-requests.js";
 import { getLogger } from "../util/logger.js";
 import {
   classifyWaitUtterance,
@@ -65,7 +65,7 @@ export interface GuardianWaitResolutionContext {
 }
 
 export interface GuardianWaitStartParams {
-  /** Canonical guardian access-request id to poll. */
+  /** Guardian access-request id to poll. */
   requestId: string;
   assistantId: string;
   fromNumber: string;
@@ -89,8 +89,11 @@ export interface GuardianWaitControllerDeps {
   onApproved(ctx: GuardianWaitResolutionContext): void | Promise<void>;
   onDenied(ctx: GuardianWaitResolutionContext): void | Promise<void>;
   onTimeout(ctx: GuardianWaitResolutionContext): void | Promise<void>;
-  /** Canonical-request reader; defaults to the real store. */
-  getCanonicalGuardianRequest?: typeof getCanonicalGuardianRequestFn;
+  /**
+   * Guardian-request reader; defaults to the gateway client's degrading
+   * read (an unreachable gateway skips the tick and keeps polling).
+   */
+  getGuardianRequest?: typeof getGuardianRequestOrNull;
   /** Clock; defaults to Date.now. */
   now?: () => number;
   /** Overrides the `calls.accessRequestPollIntervalMs` config value. */
@@ -120,6 +123,8 @@ export class GuardianWaitController {
   private waitStartedAt = 0;
   private heartbeatSequence = 0;
   private lastInWaitReplyAt = 0;
+  /** In-flight guard so a slow gateway read never stacks poll ticks. */
+  private pollInFlight = false;
 
   private callbackOfferMade = false;
   private callbackOptIn = false;
@@ -178,7 +183,7 @@ export class GuardianWaitController {
     const pollIntervalMs =
       this.deps.pollIntervalMs ?? getAccessRequestPollIntervalMs();
     this.pollTimer = setInterval(() => {
-      this.pollCanonicalRequest();
+      void this.pollGuardianRequest();
     }, pollIntervalMs);
 
     const timeoutMs =
@@ -338,23 +343,31 @@ export class GuardianWaitController {
 
   // ── Internals ───────────────────────────────────────────────────────
 
-  private pollCanonicalRequest(): void {
-    if (this.state !== "awaiting_guardian_decision" || !this.params) {
-      this.clearTimers();
+  private async pollGuardianRequest(): Promise<void> {
+    if (this.pollInFlight) {
       return;
     }
-    const read =
-      this.deps.getCanonicalGuardianRequest ?? getCanonicalGuardianRequestFn;
-    const request = read(this.params.requestId);
-    if (!request) {
+    if (this.state !== "awaiting_guardian_decision" || !this.params) {
+      this.clearTimers();
       return;
     }
-    if (request.status === "approved") {
-      this.resolve("approved");
-    } else if (request.status === "denied") {
-      this.resolve("denied");
+    this.pollInFlight = true;
+    try {
+      const read = this.deps.getGuardianRequest ?? getGuardianRequestOrNull;
+      const request = await read(this.params.requestId);
+      // Re-check: a timeout or dispose may have resolved the wait mid-read.
+      if (this.state !== "awaiting_guardian_decision" || !request) {
+        return;
+      }
+      if (request.status === "approved") {
+        this.resolve("approved");
+      } else if (request.status === "denied") {
+        this.resolve("denied");
+      }
+      // 'pending' continues polling; 'expired'/'cancelled' handled by timeout.
+    } finally {
+      this.pollInFlight = false;
     }
-    // 'pending' continues polling; 'expired'/'cancelled' handled by timeout.
   }
 
   private resolve(resolution: GuardianWaitResolution): void {

package/src/calls/media-turn-detector.ts

@@ -75,7 +75,7 @@ export interface TurnDetectorCallbacks {
 // ---------------------------------------------------------------------------
 
 export class MediaTurnDetector {
-  private readonly silenceThresholdMs: number;
+  private silenceThresholdMs: number;
   private readonly maxTurnDurationMs: number;
   private readonly callbacks: TurnDetectorCallbacks;
 
@@ -116,6 +116,16 @@ export class MediaTurnDetector {
     return this.active;
   }
 
+  /**
+   * Update the trailing-silence threshold mid-session (the "pause before
+   * reply" live-tuning path). Applies from the next silence-timer arm — a
+   * countdown already in flight keeps its current duration until it resets on
+   * the next speech chunk — so the change takes effect on the next utterance.
+   */
+  setSilenceThresholdMs(silenceThresholdMs: number): void {
+    this.silenceThresholdMs = silenceThresholdMs;
+  }
+
   /**
    * Feed an inbound audio chunk to the detector with speech activity info.
    *

package/src/calls/telephony-credential-preflight.ts

@@ -15,6 +15,7 @@
  */
 
 import { getConfig } from "../config/loader.js";
+import { effectiveSttProvider } from "../config/schemas/stt.js";
 import type { TelephonySttCapability } from "../providers/speech-to-text/resolve.js";
 import { resolveTelephonySttCapability } from "../providers/speech-to-text/resolve.js";
 import { findPlayableTelephonyTtsFallback } from "./resolve-call-tts-provider.js";
@@ -72,7 +73,9 @@ export async function resolveTelephonyCredentialReadiness(): Promise<TelephonyCr
 
   if (stt.status !== "supported") {
     const providerId =
-      "providerId" in stt ? stt.providerId : getConfig().services.stt.provider;
+      "providerId" in stt
+        ? stt.providerId
+        : effectiveSttProvider(getConfig().services.stt);
     missing.push({ kind: "stt", providerId, reason: stt.reason });
     clauses.push(sttGapClause(stt, providerId));
   }
@@ -108,6 +111,11 @@ function sttGapClause(
 ): string {
   switch (capability.status) {
     case "missing-credentials": {
+      // Connection-based providers are fixed by connecting the account,
+      // not by entering an API key.
+      if (capability.credentialProvider === "vellum") {
+        return `a Vellum platform connection for managed speech (run 'assistant platform connect')`;
+      }
       return `an API key for the speech-to-text provider "${providerId}"`;
     }
     case "unsupported": {
@@ -135,6 +143,16 @@ function ttsGap(
         clause: `an API key for the text-to-speech provider "${providerId}" (no fallback provider has usable credentials)`,
       };
     }
+    case "missing-platform-connection": {
+      return {
+        gap: {
+          kind: "tts",
+          providerId,
+          reason: `Managed TTS has no usable Vellum platform connection and no playable fallback provider is available`,
+        },
+        clause: `a Vellum platform connection for managed speech (run 'assistant platform connect'; no fallback provider has usable credentials)`,
+      };
+    }
     case "missing-fish-audio-reference-id": {
       return {
         gap: {

package/src/calls/telephony-tts-capability.ts

@@ -37,7 +37,8 @@ import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
 export type TelephonyTtsNotPlayableReason =
   | "unsupported-format"
   | "missing-credentials"
-  | "missing-fish-audio-reference-id";
+  | "missing-fish-audio-reference-id"
+  | "missing-platform-connection";
 
 /**
  * Result of resolving whether a TTS provider is playable over the
@@ -112,6 +113,22 @@ export async function evaluateTelephonyTtsPlayability(
     }
   }
 
+  // The vellum secret alone doesn't prove usability: managed speech also
+  // needs the platform assistant identity, or synthesis fails before any
+  // request is made — with allowNativeFallback false, that would mean
+  // silent call failures instead of a BYOK fallback.
+  if (entry.id === "vellum") {
+    const { managedSpeechAvailable } =
+      await import("../platform/managed-speech.js");
+    if (!(await managedSpeechAvailable())) {
+      return {
+        status: "not-playable",
+        providerId: entry.id,
+        reason: "missing-platform-connection",
+      };
+    }
+  }
+
   if (entry.id === "fish-audio" && !fishAudioReferenceIdConfigured()) {
     return {
       status: "not-playable",

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

@@ -14,6 +14,15 @@ export const CALL_OPENING_ACK_MARKER = "[CALL_OPENING_ACK]";
 export const CALL_VERIFICATION_COMPLETE_MARKER = "[CALL_VERIFICATION_COMPLETE]";
 export const END_CALL_MARKER = "[END_CALL]";
 
+/**
+ * Emitted by the fast "front-door" model (triage-and-escalate voice routing)
+ * when a turn is too tricky for it to answer well. The front-door model speaks
+ * a brief holding phrase, appends this marker, and stops; the call controller
+ * then re-runs the turn on the stronger "quality" profile. Like the other
+ * markers, it is swallowed before reaching TTS — never spoken aloud.
+ */
+export const ESCALATE_MARKER = "[ESCALATE]";
+
 // ---------------------------------------------------------------------------
 // Regexes
 // ---------------------------------------------------------------------------
@@ -31,6 +40,7 @@ const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
 const CALL_OPENING_MARKER_REGEX = /\[CALL_OPENING\]/g;
 const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
 const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
+const ESCALATE_MARKER_REGEX = /\[ESCALATE\]/g;
 const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
 const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 
@@ -145,6 +155,7 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(CALL_OPENING_MARKER_REGEX, "")
     .replace(CALL_OPENING_ACK_MARKER_REGEX, "")
     .replace(END_CALL_MARKER_REGEX, "")
+    .replace(ESCALATE_MARKER_REGEX, "")
     .replace(GUARDIAN_TIMEOUT_MARKER_REGEX, "")
     .replace(GUARDIAN_UNAVAILABLE_MARKER_REGEX, "");
   return result;
@@ -167,6 +178,7 @@ const CONTROL_MARKER_STRINGS = [
   "[CALL_OPENING]",
   "[CALL_OPENING_ACK]",
   "[END_CALL]",
+  "[ESCALATE]",
   "[GUARDIAN_TIMEOUT]",
   "[GUARDIAN_UNAVAILABLE]",
 ];

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

@@ -35,6 +35,12 @@ import {
   CALL_OPENING_MARKER,
   CALL_VERIFICATION_COMPLETE_MARKER,
 } from "./voice-control-protocol.js";
+import {
+  escalatedContinuationRule,
+  ESCALATION_CONTINUATION_CONTENT,
+  frontDoorTriageRule,
+  type VoiceRoutingLeg,
+} from "./voice-triage-escalate.js";
 
 const log = getLogger("voice-session-bridge");
 
@@ -200,6 +206,29 @@ export interface VoiceTurnOptions {
   callbacks?: VoiceTurnCallbacks;
   /** Optional AbortSignal for external cancellation (e.g. barge-in). */
   signal?: AbortSignal;
+  /**
+   * Ad-hoc inference-profile override applied to every LLM call this turn
+   * issues (forwarded to `runAgentLoop` with `forceOverrideProfile`). Used by
+   * triage-and-escalate voice routing to run the front-door leg on the fast
+   * profile and the escalated leg on the quality profile. Undefined = the
+   * call-site default (today's behavior).
+   */
+  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`.
+   */
+  routingLeg?: VoiceRoutingLeg;
+  /**
+   * The interactive surface being resumed as a spoken turn. When set, the turn
+   * runs with this surface as the active surface (and no active page) so
+   * `buildActiveSurfaceContext` re-injects its `dynamic_page`/app HTML+schema,
+   * matching the text path's `activeSurfaceId`. Undefined on ordinary STT
+   * turns, which carry no active surface.
+   */
+  activeSurfaceId?: string;
 }
 
 export interface VoiceTurnHandle {
@@ -226,6 +255,7 @@ function buildVoiceCallControlPrompt(opts: {
   task?: string | null;
   isCallerGuardian?: boolean;
   skipDisclosure?: boolean;
+  routingLeg?: VoiceRoutingLeg;
 }): string {
   const config = getConfig();
   const disclosureEnabled =
@@ -310,9 +340,19 @@ function buildVoiceCallControlPrompt(opts: {
     "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. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links) or emojis in your spoken responses. Write plain conversational text only. Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
-    "</voice_call_control>",
   );
 
+  // Triage-and-escalate routing rules (voice-triage-escalate flag). The
+  // front-door leg triages and may hand off; the escalated leg continues the
+  // answer after a holding phrase was already spoken.
+  if (opts.routingLeg === "front-door") {
+    lines.push(`12. ${frontDoorTriageRule()}`);
+  } else if (opts.routingLeg === "escalated") {
+    lines.push(`12. ${escalatedContinuationRule()}`);
+  }
+
+  lines.push("</voice_call_control>");
+
   return lines.join("\n");
 }
 
@@ -397,27 +437,56 @@ export async function startVoiceTurn(
         ? "(verification completed — transitioning into conversation)"
         : opts.content;
 
-  // Opener / verification prompts are internal scaffolding: they persist a row
-  // so the model wakes, but they are not user speech and must not render as a
-  // live user bubble. Their echo is suppressed below (parity with
-  // `isEchoSuppressedUserMessage` on the text path).
+  // Opener / verification / escalation-continuation prompts are internal
+  // scaffolding: they persist a row so the model wakes, but they are not user
+  // speech and must not render as a live user bubble. Their echo is suppressed
+  // below (parity with `isEchoSuppressedUserMessage` on the text path).
   const isSyntheticVoicePrompt =
     opts.content === CALL_OPENING_MARKER ||
-    opts.content === CALL_VERIFICATION_COMPLETE_MARKER;
+    opts.content === CALL_VERIFICATION_COMPLETE_MARKER ||
+    opts.content === ESCALATION_CONTINUATION_CONTENT;
+
+  // The escalation-continuation prompt is a pure internal instruction ("give
+  // the full answer now"), not a real utterance and not the sort of scaffolding
+  // an opener is — it must never surface as a user message. Unlike the
+  // opener/verification rows (persisted un-hidden), persist it `hidden` so
+  // `/messages` filters it out after a refetch/reload, and flag the turn as a
+  // hidden prompt so prompt-as-user-speech consumers (e.g. title generation)
+  // skip it. The escalated model still sees the row in context — `hidden` only
+  // affects client display.
+  const isHiddenSyntheticPrompt =
+    opts.content === ESCALATION_CONTINUATION_CONTENT;
 
   // Build the call-control protocol prompt so the model knows how to emit
   // control markers (ASK_GUARDIAN, END_CALL, etc.) and recognize opener turns.
   const isCallerGuardian = opts.trustContext?.trustClass === "guardian";
 
-  const voiceCallControlPrompt =
-    opts.voiceControlPrompt === undefined
-      ? buildVoiceCallControlPrompt({
-          isInbound: opts.isInbound,
-          task: opts.task,
-          isCallerGuardian,
-          skipDisclosure: opts.skipDisclosure,
-        })
-      : opts.voiceControlPrompt;
+  let voiceCallControlPrompt: string | null;
+  if (opts.voiceControlPrompt === undefined) {
+    voiceCallControlPrompt = buildVoiceCallControlPrompt({
+      isInbound: opts.isInbound,
+      task: opts.task,
+      isCallerGuardian,
+      skipDisclosure: opts.skipDisclosure,
+      routingLeg: opts.routingLeg,
+    });
+  } 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 be told to
+    // emit [ESCALATE], so it could not hand off to the escalated leg.
+    voiceCallControlPrompt = opts.voiceControlPrompt;
+    const routingLegRule =
+      opts.routingLeg === "front-door"
+        ? frontDoorTriageRule()
+        : opts.routingLeg === "escalated"
+          ? escalatedContinuationRule()
+          : null;
+    if (voiceCallControlPrompt != null && routingLegRule) {
+      voiceCallControlPrompt = `${voiceCallControlPrompt}\n\n${routingLegRule}`;
+    }
+  }
 
   // Get or create the conversation
   const conversation = await getOrCreateConversation(opts.conversationId);
@@ -541,6 +610,7 @@ export async function startVoiceTurn(
     const persistResult = await conversation.persistUserMessage({
       content: persistedContent,
       requestId,
+      ...(isHiddenSyntheticPrompt ? { metadata: { hidden: true } } : {}),
     });
     return persistResult.id;
   };
@@ -902,6 +972,16 @@ export async function startVoiceTurn(
       // flag into subsequent non-voice turns on the same conversation.
       conversation.forcePromptSideEffects =
         !isGuardian && !usesLocalInteractiveApprovals;
+      // Surface-resume turns install the resumed surface as the active surface
+      // so `buildActiveSurfaceContext` re-injects its dynamic_page/app context,
+      // and clear `currentPage` so the resumed surface isn't paired with a prior
+      // turn's stale page (parity with the text path, which passes no page for
+      // surface actions). `runAgentLoop` clears `currentActiveSurfaceId` at turn
+      // end, so this stays turn-scoped. Left untouched on ordinary STT turns.
+      if (opts.activeSurfaceId !== undefined) {
+        conversation.currentActiveSurfaceId = opts.activeSurfaceId;
+        conversation.currentPage = undefined;
+      }
       await conversation.runAgentLoop(persistedContent, messageId, {
         onEvent: (msg: ServerMessage) => {
           if (msg.type === "error") {
@@ -931,6 +1011,21 @@ export async function startVoiceTurn(
           // Voice only reacts to the definitive tool_use_start event.
         },
         callSite: "callAgent",
+        // The escalation-continuation prompt is a transcript-suppressed machine
+        // signal (persisted `hidden`), so flag the turn to match — keeps
+        // prompt-as-user-speech consumers (e.g. title generation) from treating
+        // it as user speech.
+        ...(isHiddenSyntheticPrompt ? { isHiddenPrompt: true } : {}),
+        // Triage-and-escalate routing pins this turn to the fast front-door or
+        // strong escalation profile. `forceOverrideProfile` floats it above the
+        // callAgent call-site layers (callAgent is not `mainAgent`, so the
+        // override would otherwise sit below the call-site profile).
+        ...(opts.overrideProfile != null
+          ? {
+              overrideProfile: opts.overrideProfile,
+              forceOverrideProfile: true,
+            }
+          : {}),
       });
       if (lastError) {
         log.error(