@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

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

@@ -29,6 +29,7 @@ import {
   resolveTurnCommitWaitMs,
 } from "../daemon/abort-watchdog.js";
 import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
+import type { ModeSessionSourceHandle } from "../daemon/conversation-mode-session.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
 import { preactivateHostProxySkills } from "../daemon/host-proxy-preactivation.js";
@@ -48,15 +49,16 @@ import {
   updateMessageContent,
 } from "../persistence/conversation-crud.js";
 import { VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND } from "../plugin-api/constants.js";
-import { doesSupportVision } from "../plugin-api/vision-support.js";
+import { dispatchProviderResolvable } from "../providers/connection-resolution.js";
 import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
-import type { ContentBlock, Message } from "../providers/types.js";
+import type { ContentBlock } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { sttCatalogKeyForRole } from "../stt/roles.js";
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
 import { getAllTools } from "../tools/registry.js";
 import { sensitiveToolReach } from "../tools/tool-approval-handler.js";
 import { createAbortReason } from "../util/abort-reasons.js";
@@ -74,6 +76,8 @@ import {
   stripInternalSpeechMarkers,
   terminalControlMarkerLength,
 } from "./voice-control-protocol.js";
+import { judgeEscalation } from "./voice-escalation-judge.js";
+import type { VoiceEscalationTarget } from "./voice-escalation-target.js";
 import {
   createFrontDoorStreamGate,
   escalatedContinuationRule,
@@ -87,81 +91,35 @@ import {
 const log = getLogger("voice-session-bridge");
 
 /**
- * Profile an image-bearing voice leg is pinned to.
+ * The conversation's effective `mainAgent` profile, or null when nothing
+ * selected one and the ordinary call-agent resolution applies. Images in the
+ * history need no special profile: a text-only model gets them captioned by
+ * the `image-fallback` plugin, exactly as a typed turn does.
  *
- * The latency-class profile is the one voice already leans on (it fronts every
- * turn through `voiceFrontDoor`); `callAgent`'s `balanced` profile carries no
- * guarantee that its model takes images, and a model that rejects an image
- * fails the whole leg rather than degrading it.
- *
- * Whether THIS profile takes images is an install-level question, not a
- * constant: a BYO provider resolves the key through its own column of the
- * intent matrix, and on Fireworks that lands on a text-only model while its
- * `balanced` column is vision-capable. Pinning there would break the exact
- * turns this pin exists to save, hence the capability check at the call site.
- */
-const VOICE_IMAGE_PROFILE = "latency-optimized";
-
-/**
- * The profile the conversation's own text turns run on, resolved the way a
- * `mainAgent` turn resolves it: the conversation's pinned profile when it
- * carries one, else the workspace chat-model selection (`llm.activeProfile`),
- * else the main agent's call-site pin.
- *
- * The escalated voice leg runs through `callAgent`, whose chain never
- * consults `llm.activeProfile`, so without this the hand-off lands on that
- * site's shipped `balanced` default while the same conversation's typed
- * turns run on whatever the user picked. Pinning the text-turn winner keeps
- * the stronger model the front door escalates to the one the conversation is
- * already using.
- *
- * `profile` is the name to pin (a mix's own name, so dispatch re-expands it
- * to the same arm from the conversation seed); `modelProfile` is the concrete
- * profile whose model actually runs (the chosen arm of a mix), which is what
- * capability checks must judge: a mix reads as vision-capable when any arm
- * is, but only one arm serves this conversation.
- *
- * Null when nothing above named a profile (the winner is the code-owned
- * anchor): the leg then keeps its ordinary call-site resolution, which lands
- * on the same anchor intent and still honors a `callAgent` site pin.
+ * A mix resolves to the arm this conversation's seed selects, not the mix's
+ * own name. Dispatch lands on that arm either way, but the image-fallback
+ * check judges the profile it is handed, and a mix reads as vision-capable
+ * when any arm is: a text-only chosen arm would get raw images.
  */
 function conversationProfileForEscalation(
   conversation: OverrideProfileFields & { conversationId: string },
-): { profile: string; modelProfile: string } | null {
+): string | null {
   const overrideProfile = resolveOverrideProfile(conversation);
-  let chosenArm: string | undefined;
+  const mix: { arm?: { mixProfile: string; chosenProfile: string } } = {};
   const selection = selectWinningProfile("mainAgent", getConfig().llm, {
     ...(overrideProfile != null ? { overrideProfile } : {}),
     selectionSeed: conversation.conversationId,
-    onMixSelected: ({ chosenProfile }) => {
-      chosenArm = chosenProfile;
+    isResolvableProvider: dispatchProviderResolvable,
+    onMixSelected: (selected) => {
+      mix.arm = selected;
     },
   });
   if (selection.source === "default" || selection.profileName == null) {
     return null;
   }
-  return {
-    profile: selection.profileName,
-    modelProfile: chosenArm ?? selection.profileName,
-  };
-}
-
-/**
- * Does this conversation's history carry an image?
- *
- * Images persist inline and are re-sent on every later turn, so one photo
- * taken mid-call makes every remaining turn of that call an image turn -- the
- * check is over the whole history, not just this turn's own content.
- */
-function conversationCarriesImage(messages: readonly Message[]): boolean {
-  return messages.some((message) =>
-    message.content.some(
-      (block) =>
-        block.type === "image" ||
-        (block.type === "tool_result" &&
-          block.contentBlocks?.some((nested) => nested.type === "image")),
-    ),
-  );
+  return mix.arm?.mixProfile === selection.profileName
+    ? mix.arm.chosenProfile
+    : selection.profileName;
 }
 
 /**
@@ -388,9 +346,20 @@ export interface VoiceTurnCallbacks {
   tool_result?: (event: VoiceToolResultEvent) => void;
 }
 
+export type { VoiceEscalationTarget } from "./voice-escalation-target.js";
+
 export interface VoiceTurnOptions {
+  /** Internal task update delivered through the call, with its original attribution. */
+  subagentNotification?: SubagentParentNotification;
   /** The conversation ID for this voice call's session. */
   conversationId: string;
+  /** Camera source captured when this voice turn was accepted. */
+  modeSessionSource?: ModeSessionSourceHandle;
+  /** Camera ownership already claimed by the accepting live session. */
+  preacceptedModeSession?: {
+    requestId: string;
+    source: ModeSessionSourceHandle;
+  };
   /** Voice session ID for scoped grant matching. Defaults to callSessionId. */
   voiceSessionId?: string;
   /** The call session ID for scoped grant matching. */
@@ -497,6 +466,8 @@ export interface VoiceTurnOptions {
   onError?: (message: string) => void;
   /** Event-name callbacks: tool activity, persisted row ids, raw stream. */
   callbacks?: VoiceTurnCallbacks;
+  /** Called once the escalated leg's actual target profile is resolved. */
+  onEscalationTargetResolved?: (target: VoiceEscalationTarget) => void;
   /**
    * Called when this turn leaves a confirmation for the user to answer instead
    * of deciding it, so the client can put the prompt where they can see it.
@@ -553,6 +524,8 @@ export interface VoiceTurnOptions {
    * fixed sentinel.
    */
   hiddenSyntheticPrompt?: boolean;
+  /** Original caller request resumed by a synthetic turn, used for routing. */
+  routingUtterance?: string;
   /**
    * Unified front-door: this leg was dispatched speculatively at a silence
    * boundary, so its decision rule includes the hold branch (leading token
@@ -586,6 +559,19 @@ export interface VoiceTurnHandle {
    * rollback — a missing discard degrades to abort-without-rollback.
    */
   discard?: () => Promise<void>;
+  /**
+   * Front-door legs only: the escalation judge's verdict on this turn,
+   * resolving true when the turn needs the escalated leg. Never rejects.
+   * Absent when the judge does not apply (other legs, synthetic prompts).
+   */
+  escalationJudgement?: Promise<boolean>;
+  /**
+   * Abort a front-door leg whose answer the escalation judge overruled. The
+   * caller never heard that answer, so the teardown transcript-hygiene pass
+   * deletes its row instead of leaving it in the history the escalated leg
+   * reads. The user row stays: the turn continues on the escalated leg.
+   */
+  overrule?: () => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -1004,10 +990,8 @@ 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);
+  const routingUtterance = opts.routingUtterance?.trim() || persistedContent;
+  const routingLegRule = routingLegRuleFor(opts, routingUtterance);
   let voiceCallControlPrompt: string | null;
   if (opts.voiceControlPrompt === undefined) {
     voiceCallControlPrompt = buildVoiceCallControlPrompt({
@@ -1201,7 +1185,7 @@ export async function startVoiceTurn(
     detachApprovalObserver = undefined;
   };
 
-  const requestId = uuidv7();
+  const requestId = opts.preacceptedModeSession?.requestId ?? uuidv7();
   const turnId = crypto.randomUUID();
   // Ids this turn's row actually links, read back by `discardFn` so a rollback
   // does not take the attachments down with the row.
@@ -1219,6 +1203,7 @@ export async function startVoiceTurn(
       ...(turnAttachments.length > 0 ? { attachments: turnAttachments } : {}),
       requestId,
       metadata: {
+        ...opts.subagentNotification?.metadata,
         // Durable "this turn came from an open voice session" marker; see
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
@@ -1484,6 +1469,13 @@ export async function startVoiceTurn(
     restoreTurnState(preInstallState);
     throw err;
   }
+  if (opts.modeSessionSource && !opts.preacceptedModeSession) {
+    conversation.modeSessions.claimTurn(
+      requestId,
+      opts.modeSessionSource,
+      Date.now(),
+    );
+  }
   try {
     messageId = await persistTurnUserMessage();
   } catch (err) {
@@ -1497,6 +1489,7 @@ export async function startVoiceTurn(
       // this turn still owns the state it installed. Release it to
       // defaults, matching the agent-loop finally of a turn that ran.
       cleanup();
+      conversation.modeSessions?.releaseTurn?.(requestId);
       throw err;
     }
     // A busy failure ALWAYS means a live winner holds the lock — even with
@@ -1522,6 +1515,7 @@ export async function startVoiceTurn(
       // The retry lost again (or failed outright) without this turn ever
       // running — leave the conversation exactly as the winner left it.
       restoreTurnState(preRetryState);
+      conversation.modeSessions?.releaseTurn?.(requestId);
       throw retryErr;
     }
   }
@@ -1563,12 +1557,14 @@ export async function startVoiceTurn(
   // (JARVIS-1258). Synthetic opener/verification prompts persist a row but are
   // not user speech, so their echo is suppressed.
   if (!isSyntheticVoicePrompt) {
+    const modeSession = conversation.modeSessions?.getTurnOwner?.(requestId);
     broadcastMessage({
       type: "user_message_echo",
       text: persistedContent,
       conversationId: opts.conversationId,
       messageId,
       requestId,
+      ...(modeSession ? { modeSession } : {}),
     });
     // The echoed row is already durably persisted and the agent loop hasn't
     // started, so advance the snapshot↔stream anchor to the echo's seq — else
@@ -1797,6 +1793,8 @@ export async function startVoiceTurn(
   let reservedAssistantRowId: string | null = null;
   // Set by the handle's discard(): the whole leg must leave no trace.
   let discarded = false;
+  // Set by the handle's overrule(): the leg's answer was never spoken.
+  let overruled = false;
 
   // Verdict-first gate on the hub broadcast. A front-door leg's raw stream
   // carries its routing verdict, so hub subscribers (web, passive devices)
@@ -1817,12 +1815,46 @@ export async function startVoiceTurn(
    */
   const broadcastLegEvent = (msg: AssistantEvent): void => {
     if (frontDoorStreamGate === null || msg.type !== "assistant_text_delta") {
-      broadcastMessage(msg);
+      emitHubEvent(msg);
       return;
     }
     const released = frontDoorStreamGate.push(msg.text);
     if (released.length > 0) {
-      broadcastMessage({ ...msg, text: released });
+      // Answer text while the escalation judge is out: hold it, and every
+      // leg event after it, until the verdict says the caller hears it.
+      if (
+        frontDoorStreamGate.answering &&
+        !escalationJudgeSettled &&
+        hubHold === null
+      ) {
+        hubHold = [];
+      }
+      emitHubEvent({ ...msg, text: released });
+    }
+  };
+
+  // Hub events held while the escalation judge decides whether the
+  // front-door answer is spoken. Null when nothing is held.
+  let hubHold: AssistantEvent[] | null = null;
+  let escalationJudgeSettled = true;
+  const emitHubEvent = (msg: AssistantEvent): void => {
+    if (hubHold !== null) {
+      hubHold.push(msg);
+      return;
+    }
+    broadcastMessage(msg);
+  };
+  // Release held hub events once the judge settles. An overruled answer's
+  // text is dropped: the caller never heard it, and its row is deleted.
+  const releaseHubHold = (): void => {
+    escalationJudgeSettled = true;
+    const held = hubHold ?? [];
+    hubHold = null;
+    for (const msg of held) {
+      if (overruled && msg.type === "assistant_text_delta") {
+        continue;
+      }
+      broadcastMessage(msg);
     }
   };
 
@@ -1879,6 +1911,9 @@ export async function startVoiceTurn(
       if (discarded) {
         deleteMessageById(reservedAssistantRowId);
         action = "delete_discarded";
+      } else if (overruled) {
+        deleteMessageById(reservedAssistantRowId);
+        action = "delete_overruled";
       } else {
         const row = getMessageById(reservedAssistantRowId, opts.conversationId);
         const terminalMarkerLength = row
@@ -1959,6 +1994,46 @@ export async function startVoiceTurn(
     }
   };
 
+  // The escalation judge runs beside the front-door leg's model call, so its
+  // verdict is usually in before the leg's first answer word. Snapshot the
+  // history now: the leg's own reply must not be part of what is judged.
+  // Hidden fresh-view follow-ups route with their image; this text-only judge
+  // cannot assess that context.
+  const escalationJudgement =
+    opts.routingLeg === "front-door" && !isHiddenSyntheticPrompt
+      ? judgeEscalation({
+          conversationId: opts.conversationId,
+          history: conversation.getMessages(),
+          utterance: opts.content,
+          ...(opts.signal ? { signal: opts.signal } : {}),
+        }).then((judgement) => {
+          if (judgement.outcome !== "unavailable") {
+            log.info(
+              {
+                turnId,
+                outcome: judgement.outcome,
+                noul: judgement.noul,
+                latencyMs: judgement.latencyMs,
+              },
+              "Voice escalation judge verdict",
+            );
+          }
+          return judgement.escalate;
+        })
+      : undefined;
+  if (escalationJudgement !== undefined) {
+    escalationJudgeSettled = false;
+    // A clear verdict releases at once; an escalate verdict waits a macrotask
+    // so the driver's overrule, reacting to the same promise, lands first.
+    void escalationJudgement.then((escalate) => {
+      if (escalate) {
+        setTimeout(releaseHubHold, 0);
+      } else {
+        releaseHubHold();
+      }
+    });
+  }
+
   // Fire-and-forget the agent loop
   void (async () => {
     const loopEnterAt = Date.now();
@@ -2000,47 +2075,26 @@ export async function startVoiceTurn(
         conversation.toolsDisabledDepth++;
         frontDoorToolsSuppressed = true;
       }
-      // An escalated leg follows the conversation's own model: the front
-      // door hands off to the profile the caller's typed turns already run
-      // on, not to `callAgent`'s shipped default. Null keeps the ordinary
-      // call-site resolution.
+      // An escalated leg follows the conversation's effective main-agent
+      // target, including direct call-site tuning and the concrete arm of a
+      // mix. The semantic call site remains `callAgent` below so voice tool
+      // and delivery behavior do not change.
       const conversationProfile =
         opts.routingLeg === "escalated"
           ? conversationProfileForEscalation(conversation)
           : null;
-      // Resolved once here rather than inside the options literal below, so
-      // the history scan happens once per leg. A front-door leg is skipped:
-      // its own call site already resolves to the same profile. A
-      // conversation profile whose model takes images needs no image pin
-      // either; one that does not yields to the image pin, since a model
-      // that rejects an image fails the whole leg. The judged profile is the
-      // concrete arm that serves this conversation, not a mix's name. The
-      // capability checks come before the scan because they are the cheaper
-      // of the two and they decide whether the pin is worth anything at all.
-      const needsImagePin =
-        opts.routingLeg !== "front-door" &&
-        !(
-          conversationProfile != null &&
-          doesSupportVision(conversationProfile.modelProfile)
-        ) &&
-        doesSupportVision(VOICE_IMAGE_PROFILE) &&
-        conversationCarriesImage(conversation.getMessages());
-      if (needsImagePin) {
-        log.info(
-          { turnId, routingLeg: opts.routingLeg ?? null },
-          "Voice leg carries an image; pinning the image-capable profile",
-        );
-      } else if (conversationProfile != null) {
+      if (conversationProfile != null) {
         log.info(
-          { turnId, profile: conversationProfile.profile },
+          { turnId, profile: conversationProfile },
           "Escalated voice leg pinned to the conversation's own profile",
         );
       }
-      const profilePin =
-        opts.overrideProfile ??
-        (needsImagePin
-          ? VOICE_IMAGE_PROFILE
-          : (conversationProfile?.profile ?? null));
+      const profilePin = opts.overrideProfile ?? conversationProfile;
+      // Optional cache traffic must not consume the last admitted request.
+      // A configured cap reserves its whole budget for user-visible calls.
+      const shouldWarmEscalation =
+        opts.routingLeg === "escalated" &&
+        config.rateLimit.maxRequestsPerMinute === 0;
       if (opts.macosDesktopSession === true && !frontDoorToolsSuppressed) {
         const sourceInterface = turnInterfaceContext.userMessageInterface;
         const sourceActorPrincipalId =
@@ -2056,6 +2110,9 @@ export async function startVoiceTurn(
         );
       }
       await conversation.runAgentLoop(persistedContent, messageId, {
+        ...(opts.subagentNotification?.cronRunId
+          ? { cronRunId: opts.subagentNotification.cronRunId }
+          : {}),
         onEvent: (msg: AssistantEvent) => {
           if (msg.type === "assistant_turn_start") {
             reservedAssistantRowId = msg.messageId;
@@ -2123,6 +2180,9 @@ export async function startVoiceTurn(
         // ordinary call-agent resolution.
         callSite:
           opts.routingLeg === "front-door" ? "voiceFrontDoor" : "callAgent",
+        ...(opts.routingLeg === "escalated"
+          ? { inferenceCallSite: "mainAgent" as const }
+          : {}),
         // A caller is on the line, so the turn is interactive: approval prompts
         // must be raised rather than pre-denied, because the approval observer
         // above is what decides them (auto-resolve for a non-guardian caller,
@@ -2138,18 +2198,83 @@ export async function startVoiceTurn(
           : {}),
         // Triage-and-escalate routing pins this turn to the fast front-door
         // profile or to the conversation's own profile for the escalated
-        // leg. `forceOverrideProfile` floats it above the callAgent call-site
-        // layers (callAgent is not `mainAgent`, so the override would
-        // otherwise sit below the call-site profile).
+        // leg. `forceOverrideProfile` preserves an explicit routing pin.
         //
-        // An explicit routing pin wins; failing that, a leg whose history
-        // carries an image is pinned to a profile whose model takes one;
-        // failing that, an escalated leg is pinned to the conversation's
-        // profile. A front-door leg needs none of these: its own call site
-        // already resolves there.
+        // An explicit routing pin wins; failing that, an escalated leg is
+        // pinned to the conversation's profile. A front-door leg needs
+        // neither: its own call site already resolves there.
         ...(profilePin != null
           ? { overrideProfile: profilePin, forceOverrideProfile: true }
           : {}),
+        ...(opts.routingLeg === "escalated"
+          ? {
+              // Warming and diagnostics use the final post-hook request. The
+              // observer stays synchronous so neither delays provider dispatch.
+              onFirstModelCallPrepared: (prepared) => {
+                if (shouldWarmEscalation && !prepared.disableCache) {
+                  void conversation.warmPromptCache({
+                    callSite: prepared.callSite ?? "mainAgent",
+                    ...(prepared.overrideProfile !== undefined
+                      ? { overrideProfile: prepared.overrideProfile }
+                      : {}),
+                    forceOverrideProfile: prepared.forceOverrideProfile,
+                    signal: prepared.signal ?? opts.signal,
+                    systemPrompt: prepared.systemPrompt,
+                    tools: prepared.tools,
+                  });
+                }
+                let selectedMixArm:
+                  | { mixProfile: string; chosenProfile: string }
+                  | undefined;
+                const escalationSelection = selectWinningProfile(
+                  prepared.callSite ?? "mainAgent",
+                  config.llm,
+                  {
+                    ...(prepared.overrideProfile !== undefined
+                      ? { overrideProfile: prepared.overrideProfile }
+                      : {}),
+                    forceOverrideProfile: prepared.forceOverrideProfile,
+                    selectionSeed: conversation.conversationId,
+                    isResolvableProvider: dispatchProviderResolvable,
+                    onMixSelected: (selection) => {
+                      selectedMixArm = selection;
+                    },
+                  },
+                );
+                let source: VoiceEscalationTarget["source"] = "call_site";
+                if (escalationSelection.source === "override") {
+                  if (prepared.overrideProfile !== profilePin) {
+                    source = "pre_model_hook";
+                  } else if (opts.overrideProfile != null) {
+                    source = "turn_override";
+                  } else {
+                    source = "conversation";
+                  }
+                }
+                const target: VoiceEscalationTarget = {
+                  profile:
+                    (selectedMixArm?.mixProfile ===
+                    escalationSelection.profileName
+                      ? selectedMixArm.chosenProfile
+                      : escalationSelection.profileName) ?? "balanced",
+                  source,
+                };
+                try {
+                  opts.onEscalationTargetResolved?.(target);
+                } catch (err) {
+                  log.warn(
+                    {
+                      err,
+                      turnId,
+                      profile: target.profile,
+                      source: target.source,
+                    },
+                    "Voice escalation target callback failed",
+                  );
+                }
+              },
+            }
+          : {}),
       });
       if (lastError) {
         log.error(
@@ -2166,6 +2291,17 @@ export async function startVoiceTurn(
         conversation.toolsDisabledDepth--;
       }
       cleanup();
+      // A judge verdict that lands after the model finished can still
+      // overrule the answer. Wait for it (bounded by the judge's own budget)
+      // so the overrule's row cleanup runs here, before the escalated leg,
+      // blocked on this teardown, reads history.
+      if (
+        escalationJudgement !== undefined &&
+        !discarded &&
+        (await escalationJudgement)
+      ) {
+        await new Promise<void>((resolve) => setTimeout(resolve, 0));
+      }
       await finalizeVoiceLegTranscript();
       settleTurnTeardown();
     }
@@ -2225,9 +2361,17 @@ export async function startVoiceTurn(
     }
   };
 
+  const overruleFn = () => {
+    overruled = true;
+    abortFn();
+  };
+
   return {
     turnId,
     abort: abortFn,
     discard: discardFn,
+    ...(escalationJudgement !== undefined
+      ? { escalationJudgement, overrule: overruleFn }
+      : {}),
   };
 }

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

@@ -401,6 +401,8 @@ export function createFrontDoorVerdictMachine(
 export interface FrontDoorStreamGate {
   push(deltaText: string): string;
   finish(): string;
+  /** Whether the leg's verdict classified its output as the answer. */
+  readonly answering: boolean;
 }
 
 /**
@@ -424,11 +426,13 @@ export function createFrontDoorStreamGate(
   holdEnabled: boolean,
 ): FrontDoorStreamGate {
   const machine = createFrontDoorVerdictMachine(holdEnabled);
+  let answering = false;
   const releasable = (bridge: string): string =>
     bridge.length < MIN_SPOKEN_BRIDGE_CHARS ? "" : bridge;
   const release = (step: FrontDoorStep): string => {
     switch (step.kind) {
       case "answer":
+        answering = true;
         return step.text;
       case "escalate":
         return step.bridge === null ? "" : releasable(step.bridge);
@@ -441,6 +445,9 @@ export function createFrontDoorStreamGate(
   return {
     push: (deltaText) => release(machine.push(deltaText)),
     finish: () => release(machine.finish()),
+    get answering() {
+      return answering;
+    },
   };
 }