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

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

@@ -17,20 +17,6 @@ import { describe, expect, mock, setSystemTime, test } from "bun:test";
 // Mocks — declared before importing voice-session-bridge
 // ---------------------------------------------------------------------------
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({
-    workspaceGit: { turnCommitMaxWaitMs: 100 },
-    calls: {},
-  }),
-}));
-
 // Swapped per-test to hand startVoiceTurn a scripted fake conversation.
 let fakeConversation: FakeConversation;
 
@@ -38,9 +24,19 @@ mock.module("../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async () => fakeConversation,
 }));
 
+import { setConfig } from "../../__tests__/helpers/set-config.js";
 import { ABORT_WATCHDOG_MS } from "../../daemon/abort-watchdog.js";
 import { CALL_OPENING_MARKER } from "../voice-control-protocol.js";
 import { startVoiceTurn } from "../voice-session-bridge.js";
+import {
+  escalatedContinuationRule,
+  ESCALATION_CONTINUATION_CONTENT,
+  frontDoorTriageRule,
+} from "../voice-triage-escalate.js";
+
+// `resolveProcessingWaitMs` reads `workspaceGit.turnCommitMaxWaitMs`; seed it
+// so the wait-budget assertions below get a fixed, known value.
+setConfig("workspaceGit", { turnCommitMaxWaitMs: 100 });
 
 // ---------------------------------------------------------------------------
 // Fake conversation
@@ -69,10 +65,13 @@ interface FakeConversation {
   persistUserMessage: (opts: {
     content: string;
     requestId: string;
+    metadata?: Record<string, unknown>;
   }) => Promise<{ id: string }>;
   updateClient: (cb: unknown, reset?: boolean) => void;
   runAgentLoop: (...args: unknown[]) => Promise<void>;
   abort: (reason?: unknown) => void;
+  currentActiveSurfaceId?: string;
+  currentPage?: string;
 }
 
 function makeFakeConversation(opts: {
@@ -87,6 +86,9 @@ function makeFakeConversation(opts: {
 }) {
   const waitForIdleCalls: WaitForIdleCall[] = [];
   let persistCount = 0;
+  let lastPersistOpts:
+    | { content: string; requestId: string; metadata?: Record<string, unknown> }
+    | undefined;
   const conversation: FakeConversation = {
     conversationId: "conv-voice-bridge-test",
     callSessionId: undefined,
@@ -108,8 +110,9 @@ function makeFakeConversation(opts: {
     setTurnInterfaceContext: () => {},
     setChannelCapabilities: () => {},
     setVoiceCallControlPrompt: () => {},
-    persistUserMessage: async () => {
+    persistUserMessage: async (persistOpts) => {
       persistCount += 1;
+      lastPersistOpts = persistOpts;
       // Recorded before `onPersist` so scripted persist FAILURES also
       // appear in the event stream — ordering tests need the losing
       // attempt visible.
@@ -129,6 +132,7 @@ function makeFakeConversation(opts: {
     conversation,
     waitForIdleCalls,
     persistCount: () => persistCount,
+    lastPersistOpts: () => lastPersistOpts,
     setProcessingFlag: (value: boolean) => {
       opts.processing = value;
     },
@@ -263,6 +267,86 @@ const flushMicrotasks = async () => {
 // Tests
 // ---------------------------------------------------------------------------
 
+describe("startVoiceTurn escalation-continuation persistence", () => {
+  test("persists the escalation-continuation prompt as a hidden row", async () => {
+    // The continuation is a pure internal instruction — it must be persisted
+    // `hidden` so `/messages` filters it out of the transcript after a reload,
+    // not merely echo-suppressed live.
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      content: ESCALATION_CONTINUATION_CONTENT,
+    });
+
+    expect(fake.lastPersistOpts()?.content).toBe(
+      ESCALATION_CONTINUATION_CONTENT,
+    );
+    expect(fake.lastPersistOpts()?.metadata).toEqual({ hidden: true });
+  });
+
+  test("the opener prompt is persisted un-hidden (unchanged)", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn(makeTurnOptions()); // content: CALL_OPENING_MARKER
+
+    expect(fake.lastPersistOpts()?.metadata).toBeUndefined();
+  });
+});
+
+describe("startVoiceTurn triage-and-escalate control prompt", () => {
+  // Live-voice supplies its own voiceControlPrompt, bypassing
+  // buildVoiceCallControlPrompt where the routing-leg rule is normally injected.
+  // The rule must still be appended, or the front-door model is never told to
+  // emit [ESCALATE] and can't hand off.
+  const LIVE_VOICE_PROMPT = "You are speaking in a local live voice session.";
+
+  // The turn installs its resolved control prompt, then cleanup resets it to
+  // null — so capture every applied value and read the installed (non-null) one.
+  function captureInstalledPrompt(): () => string | undefined {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+    const applied: Array<string | null> = [];
+    fake.conversation.setVoiceCallControlPrompt = (prompt) => {
+      applied.push(prompt);
+    };
+    return () => applied.find((p): p is string => typeof p === "string");
+  }
+
+  test("appends the front-door triage rule to a caller-supplied prompt", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceControlPrompt: LIVE_VOICE_PROMPT,
+      routingLeg: "front-door",
+    });
+    expect(installed()).toContain(LIVE_VOICE_PROMPT);
+    expect(installed()).toContain(frontDoorTriageRule());
+  });
+
+  test("appends the escalated continuation rule to a caller-supplied prompt", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceControlPrompt: LIVE_VOICE_PROMPT,
+      routingLeg: "escalated",
+    });
+    expect(installed()).toContain(LIVE_VOICE_PROMPT);
+    expect(installed()).toContain(escalatedContinuationRule());
+  });
+
+  test("leaves a caller-supplied prompt verbatim when no routing leg is set", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceControlPrompt: LIVE_VOICE_PROMPT,
+    });
+    expect(installed()).toBe(LIVE_VOICE_PROMPT);
+  });
+});
+
 describe("startVoiceTurn conversation-lock wait", () => {
   test("an idle conversation starts the turn without consulting waitForIdle", async () => {
     const fake = makeFakeConversation({ processing: false });
@@ -553,7 +637,9 @@ describe("startVoiceTurn queued-message drain race", () => {
     };
     conv.setTrustContext = (ctx) => {
       conv.trustContext = ctx ?? undefined;
-      events.push(ctx === null || ctx === undefined ? "trust:clear" : "trust:install");
+      events.push(
+        ctx === null || ctx === undefined ? "trust:clear" : "trust:install",
+      );
     };
     fakeConversation = fake.conversation;
 
@@ -887,3 +973,52 @@ describe("startVoiceTurn race-loss state restore", () => {
     expect(waited.assistantId).toBe(winnerState.assistantId);
   });
 });
+
+describe("startVoiceTurn active-surface context (voice surface resume)", () => {
+  // Captured via an object property (not a bare `let`) so the closure write is
+  // visible to the assertion without control-flow narrowing to `null`.
+  const captureSurfaceStateAtLoop = () => {
+    const captured: {
+      value: { activeSurfaceId?: string; currentPage?: string } | null;
+    } = { value: null };
+    const fake = makeFakeConversation({
+      processing: false,
+      runAgentLoop: async () => {
+        captured.value = {
+          activeSurfaceId: fake.conversation.currentActiveSurfaceId,
+          currentPage: fake.conversation.currentPage,
+        };
+      },
+    });
+    return { fake, captured };
+  };
+
+  test("installs activeSurfaceId and clears currentPage before the agent loop runs", async () => {
+    const { fake, captured } = captureSurfaceStateAtLoop();
+    fakeConversation = fake.conversation;
+    // A prior turn's stale page must not survive into the resumed surface turn.
+    fake.conversation.currentPage = "stale-page";
+
+    await startVoiceTurn({ ...makeTurnOptions(), activeSurfaceId: "surf-1" });
+    await flushMicrotasks();
+
+    expect(captured.value).toEqual({
+      activeSurfaceId: "surf-1",
+      currentPage: undefined,
+    });
+  });
+
+  test("leaves currentPage untouched on an ordinary STT turn (no activeSurfaceId)", async () => {
+    const { fake, captured } = captureSurfaceStateAtLoop();
+    fakeConversation = fake.conversation;
+    fake.conversation.currentPage = "keep-me";
+
+    await startVoiceTurn(makeTurnOptions()); // no activeSurfaceId
+    await flushMicrotasks();
+
+    expect(captured.value).toEqual({
+      activeSurfaceId: undefined,
+      currentPage: "keep-me",
+    });
+  });
+});

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

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { clearFeatureFlagOverridesCache } from "../../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../../config/schema.js";
+import { ESCALATE_MARKER } from "../voice-control-protocol.js";
+import {
+  escalatedContinuationRule,
+  ESCALATION_CONTINUATION_CONTENT,
+  ESCALATION_PROFILE,
+  FRONT_DOOR_PROFILE,
+  frontDoorTriageRule,
+  isVoiceTriageEscalateEnabled,
+  needsFallbackBridge,
+  VOICE_TRIAGE_ESCALATE_FLAG,
+} from "../voice-triage-escalate.js";
+
+// The gate ignores the config arg (flags resolve from the override cache +
+// bundled registry), so a bare cast is sufficient.
+const CONFIG = {} as AssistantConfig;
+
+afterEach(() => {
+  clearFeatureFlagOverridesCache();
+});
+
+describe("voice-triage-escalate profiles", () => {
+  test("front door is the fast Speed profile, escalation is the Quality profile", () => {
+    expect(FRONT_DOOR_PROFILE).toBe("cost-optimized");
+    expect(ESCALATION_PROFILE).toBe("quality-optimized");
+  });
+});
+
+describe("isVoiceTriageEscalateEnabled", () => {
+  test("is off by default (registry defaultEnabled: false)", () => {
+    clearFeatureFlagOverridesCache();
+    expect(isVoiceTriageEscalateEnabled(CONFIG)).toBe(false);
+  });
+
+  test("is on when the flag override is set", () => {
+    setOverridesForTesting({ [VOICE_TRIAGE_ESCALATE_FLAG]: true });
+    expect(isVoiceTriageEscalateEnabled(CONFIG)).toBe(true);
+  });
+
+  test("is off when the flag override is explicitly false", () => {
+    setOverridesForTesting({ [VOICE_TRIAGE_ESCALATE_FLAG]: false });
+    expect(isVoiceTriageEscalateEnabled(CONFIG)).toBe(false);
+  });
+});
+
+describe("front-door triage rule", () => {
+  const rule = frontDoorTriageRule();
+
+  test("instructs the model to triage before answering and emit [ESCALATE]", () => {
+    expect(rule).toContain("TRIAGE FIRST");
+    expect(rule).toContain(ESCALATE_MARKER);
+    // Must decide up front — never answer, then bail (spoken audio is final).
+    expect(rule.toLowerCase()).toContain("before you begin answering");
+  });
+
+  test("lists tool uncertainty as an escalate trigger (no fabrication)", () => {
+    expect(rule.toLowerCase()).toContain("tool");
+  });
+});
+
+describe("escalated continuation rule", () => {
+  const rule = escalatedContinuationRule();
+
+  test("tells the quality model to continue without re-greeting or repeating", () => {
+    expect(rule.toLowerCase()).toContain("continue");
+    expect(rule.toLowerCase()).toContain("do not greet again");
+  });
+
+  test("forbids the quality model from emitting [ESCALATE] again", () => {
+    expect(rule).toContain(ESCALATE_MARKER);
+    expect(rule.toLowerCase()).toContain("never emit");
+  });
+});
+
+describe("needsFallbackBridge", () => {
+  test("false when the model spoke a real holding phrase before the marker", () => {
+    expect(
+      needsFallbackBridge("Let me think about that for a second. [ESCALATE]"),
+    ).toBe(false);
+  });
+
+  test("true for a bare marker with no holding phrase", () => {
+    expect(needsFallbackBridge("[ESCALATE]")).toBe(true);
+  });
+
+  test("true when only post-marker text exists — that text was never spoken", () => {
+    // Regression: the fallback decision must measure text BEFORE the marker.
+    // Post-marker text is suppressed from TTS, so counting it would skip the
+    // fallback and leave the caller in silence during the hand-off.
+    expect(
+      needsFallbackBridge(
+        "[ESCALATE] here is my weak answer the model kept going",
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("escalation continuation content", () => {
+  test("is an echo-suppressed synthetic prompt (parenthesized, non-user-speech)", () => {
+    expect(ESCALATION_CONTINUATION_CONTENT.startsWith("(")).toBe(true);
+    expect(ESCALATION_CONTINUATION_CONTENT.endsWith(")")).toBe(true);
+  });
+});
+
+// This module is the surface-agnostic escalation *policy* (profiles, prompt
+// rules, the fallback-bridge decision, the flag gate). The two-leg *routing*
+// runs on the in-app Voice Mode surface (LiveVoiceSession), gated behind both
+// the voice-mode and voice-triage-escalate flags — see
+// live-voice/__tests__/live-voice-triage-escalate.test.ts for the orchestration
+// coverage (flag gating, front-door → escalated hand-off, marker suppression,
+// fallback bridge, barge-in). What remains for the manual cli-testing flow is
+// true end-to-end audio: real TTS timing across the bridge, and the residual
+// broadcast/persist raw-marker leak (issue #37850, shared by both voice
+// surfaces) once that is addressed.
+describe("live-voice escalation orchestration (end-to-end — TODO)", () => {
+  test.todo(
+    "an unpunctuated fallback bridge is force-flushed so the caller hears audio during the escalated model's call, not silence",
+    () => {},
+  );
+  test.todo(
+    "the escalated answer's TTS follows the bridge audio with no listening window between them",
+    () => {},
+  );
+});

package/src/calls/access-request-wait.ts

@@ -5,7 +5,7 @@
  * decoupled from any transport's WebSocket lifecycle.
  */
 
-import { getCanonicalGuardianRequest } from "../contacts/canonical-guardian-store.js";
+import { getGuardianRequestOrNull } from "../channels/gateway-guardian-requests.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import { getCachedMemberAcl } from "../runtime/member-verdict-cache.js";
@@ -238,11 +238,6 @@ export function emitAccessRequestCallbackHandoff(
 
   const fromNumber = params.accessRequestFromNumber ?? null;
 
-  // Resolve canonical request for requestCode and conversationId
-  const canonicalRequest = params.accessRequestId
-    ? getCanonicalGuardianRequest(params.accessRequestId)
-    : null;
-
   // Resolve trusted-contact member reference when possible. Sync teardown
   // path: reads the member-verdict cache warmed by this call's setup-time
   // verdict fetch rather than awaiting a fresh gateway read.
@@ -269,36 +264,41 @@ export function emitAccessRequestCallbackHandoff(
   }
 
   const dedupeKey = `access-request-callback-handoff:${params.accessRequestId}`;
-  const sourceContextId =
-    canonicalRequest?.conversationId ??
-    `access-req-callback-${params.accessRequestId}`;
 
-  void emitNotificationSignal({
-    sourceEventName: "ingress.access_request.callback_handoff",
-    sourceChannel: "phone",
-    sourceContextId,
-    attentionHints: {
-      requiresAction: false,
-      urgency: "medium",
-      isAsyncBackground: true,
-      visibleInSourceNow: false,
-    },
-    contextPayload: {
-      requestId: params.accessRequestId,
-      requestCode: canonicalRequest?.requestCode ?? null,
-      callSessionId: params.callSessionId,
-      sourceChannel: "phone",
-      reason: params.reason,
-      callbackOptIn: true,
-      callerPhoneNumber: fromNumber,
-      callerName: params.accessRequestCallerName ?? null,
-      requesterExternalUserId: fromNumber,
-      requesterChatId: fromNumber,
-      requesterMemberId,
-      requesterMemberSourceChannel: requesterMemberId ? "phone" : null,
-    },
-    dedupeKey,
-  })
+  // The request row only enriches the notification (requestCode + source
+  // conversation), so the gateway read degrades to null on failure and the
+  // handoff still goes out.
+  void getGuardianRequestOrNull(params.accessRequestId)
+    .then((request) =>
+      emitNotificationSignal({
+        sourceEventName: "ingress.access_request.callback_handoff",
+        sourceChannel: "phone",
+        sourceContextId:
+          request?.sourceConversationId ??
+          `access-req-callback-${params.accessRequestId}`,
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {
+          requestId: params.accessRequestId,
+          requestCode: request?.requestCode ?? null,
+          callSessionId: params.callSessionId,
+          sourceChannel: "phone",
+          reason: params.reason,
+          callbackOptIn: true,
+          callerPhoneNumber: fromNumber,
+          callerName: params.accessRequestCallerName ?? null,
+          requesterExternalUserId: fromNumber,
+          requesterChatId: fromNumber,
+          requesterMemberId,
+          requesterMemberSourceChannel: requesterMemberId ? "phone" : null,
+        },
+        dedupeKey,
+      }),
+    )
     .then(() => {
       recordCallEvent(params.callSessionId, "callback_handoff_notified", {
         requestId: params.accessRequestId,

package/src/calls/call-controller.ts

@@ -10,11 +10,12 @@
 
 import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approval-grants.js";
 import {
-  expireCanonicalGuardianRequest,
-  getCanonicalRequestByPendingQuestionId,
-  getPendingCanonicalRequestByCallSessionId,
-  listCanonicalGuardianDeliveries,
-} from "../contacts/canonical-guardian-store.js";
+  expireGuardianRequest,
+  getPendingRequestByCallSession,
+  getPendingRequestByCallSessionOrNull,
+  getRequestByPendingQuestionOrNull,
+  listGuardianRequestDeliveriesOrEmpty,
+} from "../channels/gateway-guardian-requests.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
@@ -589,7 +590,7 @@ export class CallController {
       );
       if (!this.isCurrentRun(runVersion)) return;
 
-      this.handleTurnCompletion(fullResponseText);
+      await this.handleTurnCompletion(fullResponseText);
     } catch (err: unknown) {
       this.currentTurnHandle = null;
       // Aborted requests are expected (interruptions, rapid utterances)
@@ -1116,7 +1117,7 @@ export class CallController {
    * (ASK_GUARDIAN_APPROVAL / ASK_GUARDIAN), call finalization (END_CALL),
    * and normal idle transition.
    */
-  private handleTurnCompletion(fullResponseText: string): void {
+  private async handleTurnCompletion(fullResponseText: string): Promise<void> {
     const responseText = fullResponseText;
 
     // Record the assistant response event
@@ -1276,13 +1277,13 @@ export class CallController {
             // Expire the previous consultation's storage records so stale
             // guardian answers cannot match the old request.
             expirePendingQuestions(this.callSessionId);
-            const previousRequest = getPendingCanonicalRequestByCallSessionId(
+            const previousRequest = await getPendingRequestByCallSession(
               this.callSessionId,
             );
             if (previousRequest) {
               // Immediately expire with 'superseded' reason to prevent
               // stale answers from resolving the old request.
-              expireCanonicalGuardianRequest(previousRequest.id);
+              await expireGuardianRequest(previousRequest.id);
               log.info(
                 {
                   callSessionId: this.callSessionId,
@@ -1389,12 +1390,18 @@ export class CallController {
     // a completed call with a dangling pendingQuestion, and guardian
     // replies are cleanly rejected instead of hitting answerCall failures.
     expirePendingQuestions(this.callSessionId);
-    const previousRequest = getPendingCanonicalRequestByCallSessionId(
-      this.callSessionId,
-    );
-    if (previousRequest) {
-      expireCanonicalGuardianRequest(previousRequest.id);
-    }
+    // Fire-and-forget: the sync end-call path can't await the gateway
+    // expiry; a failure leaves a pending row the TTL sweep reaps.
+    void getPendingRequestByCallSession(this.callSessionId)
+      .then((previousRequest) =>
+        previousRequest ? expireGuardianRequest(previousRequest.id) : undefined,
+      )
+      .catch((err) => {
+        log.error(
+          { err, callSessionId: this.callSessionId },
+          "Failed to expire guardian request on call end",
+        );
+      });
 
     this.pendingGuardianInput = null;
     return true;
@@ -1545,23 +1552,22 @@ export class CallController {
         pendingQuestion,
         toolName: effectiveToolMeta?.toolName,
         inputDigest: effectiveToolMeta?.inputDigest,
-      }).then(() => {
-        // Backfill supersession chain: now that the new request exists in
-        // the store, link the old request to the new one.
+      }).then(async () => {
+        // Log the supersession chain now that the new request exists.
+        // The old request was already expired above; the read only feeds
+        // the log line, so it degrades to null on gateway failure.
         if (supersededRequestId) {
-          const newRequest = getCanonicalRequestByPendingQuestionId(
+          const newRequest = await getRequestByPendingQuestionOrNull(
             stablePendingQuestionId,
           );
           if (newRequest) {
-            // Canonical store does not track supersession metadata;
-            // the old request was already expired above.
             log.info(
               {
                 callSessionId: this.callSessionId,
                 oldRequestId: supersededRequestId,
                 newRequestId: newRequest.id,
               },
-              "Supersession chain: new canonical request created",
+              "Supersession chain: new guardian request created",
             );
           }
         }
@@ -1586,37 +1592,34 @@ export class CallController {
       // Mark the linked guardian action request as timed out and
       // send expiry notices to guardian destinations. Deliveries
       // must be captured before expiring the request changes
-      // their status.
-      const pendingActionRequest = getPendingCanonicalRequestByCallSessionId(
-        this.callSessionId,
-      );
-      if (pendingActionRequest) {
-        const canonicalDeliveries = listCanonicalGuardianDeliveries(
+      // their status. Fire-and-forget: the timer callback has no
+      // caller to propagate to, so failures are logged.
+      void (async () => {
+        const pendingActionRequest = await getPendingRequestByCallSessionOrNull(
+          this.callSessionId,
+        );
+        if (!pendingActionRequest) {
+          return;
+        }
+        const requestDeliveries = await listGuardianRequestDeliveriesOrEmpty(
           pendingActionRequest.id,
         );
-        // Expire the canonical request and its deliveries
-        expireCanonicalGuardianRequest(pendingActionRequest.id);
+        // Expire the guardian request and its deliveries
+        await expireGuardianRequest(pendingActionRequest.id);
         log.info(
           {
             callSessionId: this.callSessionId,
             requestId: pendingActionRequest.id,
           },
-          "Marked canonical guardian request as timed out",
+          "Marked guardian request as timed out",
         );
-        void sendGuardianExpiryNotices(
-          canonicalDeliveries,
-          this.assistantId,
-        ).catch((err) => {
-          log.error(
-            {
-              err,
-              callSessionId: this.callSessionId,
-              requestId: pendingActionRequest.id,
-            },
-            "Failed to send guardian action expiry notices after call timeout",
-          );
-        });
-      }
+        await sendGuardianExpiryNotices(requestDeliveries, this.assistantId);
+      })().catch((err) => {
+        log.error(
+          { err, callSessionId: this.callSessionId },
+          "Failed to expire guardian request after consultation timeout",
+        );
+      });
 
       // Expire pending questions and update call state
       expirePendingQuestions(this.callSessionId);

package/src/calls/call-setup-flow.ts

@@ -139,7 +139,7 @@ export interface CallSetupFlowDeps {
 
   // ── Name-capture sub-flow deps ──────────────────────────────────────
   /**
-   * Create the canonical access request and notify the guardian. Defaults
+   * Create the access request and notify the guardian. Defaults
    * to access-request-helper's {@link notifyGuardianOfAccessRequestImpl}.
    */
   notifyGuardianOfAccessRequest?: typeof notifyGuardianOfAccessRequestImpl;
@@ -1359,7 +1359,7 @@ export class CallSetupFlow {
   }
 
   /**
-   * Handle the caller's name: create the canonical access request, notify
+   * Handle the caller's name: create the guardian access request, notify
    * the guardian, and hand the wait off to a {@link GuardianWaitController}.
    * Fails closed to the timeout copy when no request id comes back.
    */

package/src/calls/call-setup-router.ts

@@ -279,7 +279,7 @@ export async function routeSetup(ctx: SetupContext): Promise<{
 
   // Floor-deny outcome shared by the unknown-caller and member-caller branches.
   // Live calls cannot await async re-verification, so the floor's
-  // `shouldChallenge` upgrade UX is not surfaced — same rationale as `escalate`.
+  // `shouldChallenge` upgrade UX is not surfaced.
   const floorDeny = (
     denyVerdict: Extract<AdmissionPolicyResult, { admitted: false }>,
   ) => {
@@ -434,29 +434,6 @@ export async function routeSetup(ctx: SetupContext): Promise<{
     };
   }
 
-  // Members with policy: 'escalate' — live calls can't wait for approval
-  if (actorTrust.memberRecord?.policy === "escalate") {
-    log.info(
-      {
-        callSessionId: ctx.callSessionId,
-        from: ctx.from,
-        channelId: actorTrust.memberRecord.channel.id,
-        trustClass: actorTrust.trustClass,
-      },
-      "Inbound voice ACL: member policy escalate — cannot hold live call for guardian approval",
-    );
-    return {
-      outcome: {
-        action: "deny",
-        message:
-          "This number requires guardian approval for calls. Please have the account guardian update your permissions.",
-        logReason:
-          "Inbound voice ACL: member policy escalate — voice calls cannot await guardian approval",
-      },
-      resolved,
-    };
-  }
-
   // Guardian verification challenge
   if (pendingChallenge) {
     return {