@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

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

@@ -243,7 +243,9 @@ export function emitAccessRequestCallbackHandoff(
     ? getCanonicalGuardianRequest(params.accessRequestId)
     : null;
 
-  // Resolve trusted-contact member reference when possible
+  // 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.
   let requesterMemberId: string | null = null;
   if (fromNumber) {
     try {

package/src/calls/audio-store.ts

@@ -1,5 +1,8 @@
 import { randomUUID } from "node:crypto";
 
+/** Audio formats that flow through call synthesis and the audio store. */
+export type CallAudioFormat = "mp3" | "wav" | "opus" | "pcm";
+
 interface AudioEntry {
   buffer: Buffer;
   contentType: string;
@@ -22,10 +25,7 @@ const TTL_MS = 60_000; // 60 seconds
 
 let currentBytes = 0;
 
-export function storeAudio(
-  buffer: Buffer,
-  format: "mp3" | "wav" | "opus" | "pcm",
-): string {
+export function storeAudio(buffer: Buffer, format: CallAudioFormat): string {
   evictExpired();
   // Evict oldest if over capacity
   while (currentBytes + buffer.length > MAX_STORE_BYTES && store.size > 0) {
@@ -50,7 +50,7 @@ export interface StreamingAudioHandle {
 }
 
 export function createStreamingEntry(
-  format: "mp3" | "wav" | "opus" | "pcm",
+  format: CallAudioFormat,
 ): StreamingAudioHandle {
   evictExpired();
   const id = randomUUID();
@@ -162,7 +162,7 @@ export function getAudio(id: string): AudioResult | null {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
-function contentTypeForFormat(format: "mp3" | "wav" | "opus" | "pcm"): string {
+function contentTypeForFormat(format: CallAudioFormat): string {
   return format === "mp3"
     ? "audio/mpeg"
     : format === "wav"

package/src/calls/call-constants.ts

@@ -70,5 +70,5 @@ export function getSilenceTimeoutMs(): number {
 }
 
 export function getEndCallListenWindowMs(): number {
-  return 15 * 1000;
+  return 2 * 1000;
 }

package/src/calls/call-controller.ts

@@ -16,10 +16,11 @@ import {
   listCanonicalGuardianDeliveries,
 } from "../contacts/canonical-guardian-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getCatalogProvider } from "../tts/provider-catalog.js";
+import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import {
   type AudioStoreSink,
   createAudioStoreSink,
@@ -27,6 +28,7 @@ import {
 } from "../tts/synthesis-stream.js";
 import type { TtsProvider, TtsProviderId } from "../tts/types.js";
 import { getLogger } from "../util/logger.js";
+import type { CallAudioFormat } from "./audio-store.js";
 import {
   getEndCallListenWindowMs,
   getMaxCallDurationMs,
@@ -55,7 +57,11 @@ import type { CallTransport } from "./call-transport.js";
 import { finalizeCall } from "./finalize-call.js";
 import { sendGuardianExpiryNotices } from "./guardian-action-sweep.js";
 import { dispatchGuardianQuestion } from "./guardian-dispatch.js";
-import { resolveCallTtsProvider } from "./resolve-call-tts-provider.js";
+import {
+  findPlayableTelephonyTtsFallbackProvider,
+  resolveCallTtsProvider,
+  resolveSynthesisFormats,
+} from "./resolve-call-tts-provider.js";
 import type { PromptSpeakerContext } from "./speaker-identification.js";
 import { sanitizeForTts } from "./tts-text-sanitizer.js";
 import {
@@ -69,6 +75,7 @@ import {
   stripInternalSpeechMarkers,
 } from "./voice-control-protocol.js";
 import {
+  CONVERSATION_BUSY_MESSAGE,
   startVoiceTurn,
   type VoiceTurnHandle,
 } from "./voice-session-bridge.js";
@@ -77,6 +84,12 @@ const log = getLogger("call-controller");
 
 type ControllerState = "idle" | "processing" | "speaking";
 
+/** Outcome of one segment's synthesis attempt. */
+type SegmentSynthesisStatus =
+  | "ok"
+  | "failed-before-audio"
+  | "failed-after-audio";
+
 /**
  * Tracks a pending guardian input request independently of the controller's
  * turn state. This allows the call to continue normal turn processing
@@ -459,10 +472,7 @@ export class CallController {
     this.endCallListenTimer = null;
     this.llmRunVersion++;
     this.abortCurrentTurn();
-    if (this.activeSynthesisAbort) {
-      this.activeSynthesisAbort.abort();
-      this.activeSynthesisAbort = null;
-    }
+    this.abortActiveSynthesis();
     this.currentTurnPromise = null;
     unregisterCallController(this.callSessionId);
 
@@ -512,14 +522,21 @@ export class CallController {
     this.abortController = new AbortController();
     // Abort any in-flight synthesized-TTS playback too, so a superseded or
     // torn-down turn's audio isn't streamed to the caller after they move on.
+    this.abortActiveSynthesis();
+    // Drop the aborted turn's unsent buffered text and cancel its queued /
+    // in-flight speech on transports that hold either (media-stream), so
+    // the aborted turn neither leaks text into the next turn's synthesis
+    // nor plays stale audio over it.
+    this.transport.discardPendingText?.();
+    this.transport.cancelPendingSpeech?.();
+  }
+
+  /** Abort and clear the in-flight synthesized-TTS segment, if any. */
+  private abortActiveSynthesis(): void {
     if (this.activeSynthesisAbort) {
       this.activeSynthesisAbort.abort();
       this.activeSynthesisAbort = null;
     }
-    // Drop the aborted turn's unsent buffered text on transports that
-    // accumulate tokens (media-stream), so it cannot leak into the next
-    // turn's synthesis.
-    this.transport.discardPendingText?.();
   }
 
   private formatCallerUtterance(
@@ -639,17 +656,17 @@ export class CallController {
   ): Promise<string> {
     // Resolve the active TTS provider through the global abstraction.
     // The catalog's callMode determines the call path: synthesized-play
-    // providers buffer text, synthesize via provider API, and stream
-    // audio chunks to Twilio via play-URL. Native-twilio providers
-    // stream text tokens through the transport, which re-synthesizes
-    // them via daemon TTS on media-stream.
+    // providers synthesize each speakable segment via the provider API as
+    // the LLM streams, playing audio chunks to Twilio via play-URL.
+    // Native-twilio providers stream text tokens through the transport,
+    // which re-synthesizes them via daemon TTS on media-stream.
     //
-    // When the transport requires WAV (media-stream), request WAV so
+    // When the transport requires PCM (media-stream), request PCM so
     // the audio store entry and any downstream fetch/transcode receives
-    // PCM that audioBufferToFrames can convert to mu-law.
+    // raw PCM that audioBufferToFrames can convert to mu-law.
     const { provider, useSynthesizedPath, audioFormat } =
       await resolveCallTtsProvider({
-        preferWav: this.transport.requiresWavAudio,
+        requiresPcmAudio: this.transport.requiresPcmAudio,
       });
 
     // Buffer incoming tokens so we can strip control markers ([ASK_GUARDIAN:...], [END_CALL])
@@ -658,17 +675,154 @@ export class CallController {
     let ttsBuffer = "";
     let fullResponseText = "";
 
-    // When using the synthesized path, we accumulate all text and synthesize
-    // the complete response at the end of the turn (better prosody).
-    let synthesizedTextBuffer = "";
+    // Synthesized path: text is split at speakable boundaries as it streams
+    // and each segment is synthesized while the LLM keeps generating. The
+    // chain serializes segments so play URLs reach the transport in order
+    // (transport FIFO gives gapless playback).
+    const synthProvider = useSynthesizedPath ? provider : null;
+    let pendingSynthText = "";
+    // Eager segmentation applies until the turn's first segment is
+    // enqueued: the opening clause flushes early so speech onset does not
+    // wait for a full sentence.
+    let firstSynthSegmentEnqueued = false;
+    let synthesisChain: Promise<void> = Promise.resolve();
+    // After a segment fails, the rest of the turn stays off the primary
+    // provider so text is never spoken out of order: non-PCM transports
+    // send native tokens; PCM-requiring transports (media-stream) retry
+    // through a playable fallback provider.
+    let synthesisFellBack = false;
+    // Fallback provider for PCM-requiring transports, resolved once per
+    // turn. `undefined` = not yet resolved; `null` = none available (or
+    // the fallback failed too) — affected segments are skipped.
+    let pcmFallbackProvider: TtsProvider | null | undefined;
+    // Non-recoverable failure (allowNativeFallback: false providers):
+    // remaining segments are skipped and the error rethrows after the
+    // chain drains so the outer handler speaks the generic recovery copy.
+    let synthesisFailure: { err: unknown } | undefined;
+    // Turn errored while still current — isCurrentRun can't catch this, so
+    // chain links check it to keep stale speech off the recovery prompt.
+    let synthesisCancelled = false;
+
+    // PCM-requiring transports re-synthesize native tokens through the
+    // same failing provider path, so a failed segment (and the rest of
+    // the turn) is spoken through a playable fallback provider instead.
+    const speakSegmentViaPcmFallback = async (
+      failedProviderId: string,
+      segment: string,
+    ): Promise<void> => {
+      if (pcmFallbackProvider === undefined) {
+        pcmFallbackProvider =
+          await findPlayableTelephonyTtsFallbackProvider(failedProviderId);
+        if (pcmFallbackProvider) {
+          log.warn(
+            {
+              provider: failedProviderId,
+              fallbackProvider: pcmFallbackProvider.id,
+            },
+            "Speaking remaining TTS segments via fallback provider",
+          );
+        } else {
+          log.error(
+            { provider: failedProviderId },
+            "No playable fallback TTS provider — skipping failed segments",
+          );
+        }
+      }
+      if (
+        !pcmFallbackProvider ||
+        synthesisCancelled ||
+        !this.isCurrentRun(runVersion)
+      ) {
+        return;
+      }
+      const fallbackStatus = await this.synthesizeAndStreamAudio(
+        pcmFallbackProvider,
+        segment,
+        runVersion,
+        audioFormat,
+      );
+      if (fallbackStatus !== "ok") {
+        // The fallback provider is failing too — stop retrying.
+        pcmFallbackProvider = null;
+      }
+    };
+
+    const enqueueSynthesisSegments = (
+      ttsProvider: TtsProvider,
+      segments: string[],
+    ): void => {
+      for (const rawSegment of segments) {
+        // Sanitized per segment (not per delta) so markdown spanning deltas
+        // is stripped before the text reaches any TTS route.
+        const segment = sanitizeForTts(rawSegment).trim();
+        if (segment.length === 0) {
+          continue;
+        }
+        firstSynthSegmentEnqueued = true;
+        synthesisChain = synthesisChain.then(async () => {
+          if (
+            !this.isCurrentRun(runVersion) ||
+            synthesisFailure ||
+            synthesisCancelled
+          ) {
+            return;
+          }
+          try {
+            if (!synthesisFellBack) {
+              const status = await this.synthesizeAndStreamAudio(
+                ttsProvider,
+                segment,
+                runVersion,
+                audioFormat,
+              );
+              if (status === "ok") {
+                return;
+              }
+              synthesisFellBack = true;
+              if (!this.transport.requiresPcmAudio) {
+                // synthesizeAndStreamAudio already handled the failed
+                // segment: its text went out as native tokens, or its
+                // partially-played audio stands.
+                return;
+              }
+              if (status === "failed-after-audio") {
+                // The segment's play URL already reached the caller, so
+                // the truncated audio stands — a fallback re-synthesis
+                // would speak the whole segment a second time. Later
+                // segments still route through the fallback provider.
+                return;
+              }
+            } else if (!this.transport.requiresPcmAudio) {
+              // Native route. Segments are trimmed, so restore the
+              // inter-segment separator.
+              this.beginSpeakingOnAudioStart(runVersion);
+              this.transport.sendTextToken(`${segment} `, false);
+              return;
+            }
+            await speakSegmentViaPcmFallback(ttsProvider.id, segment);
+          } catch (err) {
+            synthesisFailure = { err };
+          }
+        });
+      }
+    };
 
     /** Emit a chunk of safe text to the appropriate TTS backend. */
     const emitSafeChunk = (safeText: string): void => {
-      const cleaned = sanitizeForTts(safeText);
-      if (cleaned.length === 0) return;
-      if (useSynthesizedPath) {
-        synthesizedTextBuffer += cleaned;
+      if (synthProvider) {
+        // Boundary detection runs on raw text; each extracted segment is
+        // sanitized inside enqueueSynthesisSegments.
+        pendingSynthText += safeText;
+        const { segments, remainder } = extractSpeakableSegments(
+          pendingSynthText,
+          false,
+          { eager: !firstSynthSegmentEnqueued },
+        );
+        pendingSynthText = remainder;
+        enqueueSynthesisSegments(synthProvider, segments);
       } else {
+        const cleaned = sanitizeForTts(safeText);
+        if (cleaned.length === 0) return;
         this.beginSpeakingOnAudioStart(runVersion);
         this.transport.sendTextToken(cleaned, false);
       }
@@ -772,8 +926,27 @@ export class CallController {
     // inside the Promise constructor before this await adds its handler.
     // The await below still re-throws, caught by the outer try-catch.
     turnComplete.catch(() => {});
-    await turnComplete;
-    if (!this.isCurrentRun(runVersion)) return fullResponseText;
+    try {
+      await turnComplete;
+    } catch (err) {
+      // Cancel and settle this turn's synthesis before the error reaches
+      // the outer handler, so no straggling segment plays the partial
+      // answer over the recovery prompt. While this run is current no
+      // newer run's synthesis can be in flight, so the abort is safe.
+      if (this.isCurrentRun(runVersion)) {
+        synthesisCancelled = true;
+        this.abortActiveSynthesis();
+      }
+      await synthesisChain.catch(() => {});
+      throw err;
+    }
+    if (!this.isCurrentRun(runVersion)) {
+      // Superseded mid-stream (barge-in): drain the segment chain — queued
+      // links short-circuit on staleness — so this turn's synthesis fully
+      // settles instead of racing the next turn.
+      await synthesisChain.catch(() => {});
+      return fullResponseText;
+    }
 
     // Final sweep: strip any remaining control markers from the buffer
     ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
@@ -781,24 +954,19 @@ export class CallController {
       emitSafeChunk(ttsBuffer);
     }
 
-    // Synthesized-play path: when the active provider supports streaming,
-    // synthesize the complete response text via the provider's streaming
-    // API. The full text gives the provider better context for prosody
-    // and intonation. Audio streams back via chunked transfer encoding
-    // and is forwarded to Twilio as it arrives.
-    const sanitizedSynthText = sanitizeForTts(synthesizedTextBuffer.trim());
-    if (useSynthesizedPath && provider && sanitizedSynthText.length > 0) {
-      if (!this.isCurrentRun(runVersion)) return fullResponseText;
-      // Do NOT flip to `speaking` here — provider synthesis latency (or the
-      // no-audio fallback window) would still be silent. The transition happens
-      // inside synthesizeAndStreamAudio when the play URL / first audio chunk
-      // (or native fallback token) is actually emitted.
-      await this.synthesizeAndStreamAudio(
-        provider,
-        sanitizedSynthText,
-        runVersion,
-        audioFormat,
-      );
+    // Synthesized path: force-extract whatever never reached a speakable
+    // boundary, then drain the chain so every segment's audio (or its
+    // native fallback) is enqueued before the end-of-turn signal. The
+    // `speaking` flip happens inside synthesizeAndStreamAudio when the
+    // play URL / first audio chunk (or native fallback token) is actually
+    // emitted — never here, where provider latency would still be silent.
+    if (synthProvider) {
+      const { segments } = extractSpeakableSegments(pendingSynthText, true);
+      enqueueSynthesisSegments(synthProvider, segments);
+      await synthesisChain;
+      if (synthesisFailure) {
+        throw synthesisFailure.err;
+      }
     }
 
     // Synthesized playback (and its native fallback) can await provider
@@ -827,30 +995,32 @@ export class CallController {
   /**
    * Synthesize text via a streaming TTS provider and forward audio chunks
    * to Twilio through the audio store / play-URL mechanism.
+   *
+   * @returns `"ok"` on success or abort. On a handled provider failure,
+   *   `"failed-before-audio"` when the segment's play URL never went out:
+   *   on transports that accept text tokens the failed text has already
+   *   been sent natively; on PCM-requiring transports nothing was sent —
+   *   the caller owns the fallback-provider retry. `"failed-after-audio"`
+   *   when the provider failed mid-stream after the play URL was
+   *   delivered: the caller hears the truncated audio and nothing more is
+   *   sent for this segment on either transport — re-speaking it would
+   *   duplicate what already played. Callers keep subsequent segments off
+   *   the failed provider so text is never spoken out of order. Rethrows
+   *   when the provider's catalog entry has `allowNativeFallback: false`.
    */
   private async synthesizeAndStreamAudio(
     provider: TtsProvider,
     text: string,
     runVersion: number,
-    format: "mp3" | "wav" | "opus" = "mp3",
-  ): Promise<void> {
+    format: CallAudioFormat = "mp3",
+  ): Promise<SegmentSynthesisStatus> {
     let sink: AudioStoreSink | null = null;
     let playUrlSent = false;
     const abortController = new AbortController();
     try {
-      // When format is WAV (media-stream transport), request raw PCM from
-      // the provider so the audio bytes match the store's content-type.
-      // Without this, providers like Fish Audio still return mp3 and the
-      // downstream mu-law transcoder fails on the format mismatch.
-      const outputFormat = format === "wav" ? ("pcm" as const) : undefined;
-
-      // Use "pcm" as the store format when requesting PCM output so the
-      // audio store entry's content-type (audio/pcm) matches the raw PCM
-      // bytes providers return. Without this, the store says "audio/wav"
-      // but the bytes have no RIFF header, causing audioBufferToFrames to
-      // fall through to the wrong decode path.
+      const { outputFormat, storeFormat } = resolveSynthesisFormats(format);
       sink = createAudioStoreSink({
-        format: outputFormat ? "pcm" : format,
+        format: storeFormat,
         onPlayUrl: (url) => {
           // Audio is now reaching the caller (or, on transports with an
           // audio-start signal, will be the moment the first fetched frame
@@ -883,6 +1053,7 @@ export class CallController {
           { provider: provider.id },
           "TTS synthesis aborted (barge-in)",
         );
+        return "ok";
       } else {
         // Extract error class and code for diagnosable log entries.
         const errName = err instanceof Error ? err.name : String(err);
@@ -911,7 +1082,7 @@ export class CallController {
           { err, provider: provider.id, errName, errCode },
           "TTS synthesis failed — falling back to native token TTS",
         );
-        // If synthesis fails before any audio has started on a non-WAV
+        // If synthesis fails before any audio has started on a non-PCM
         // transport, degrade to token-based speech so the caller still
         // hears a response instead of silence. This fallback is only
         // used for providers whose catalog entry allows native fallback.
@@ -919,17 +1090,25 @@ export class CallController {
         // leak into the next caller turn.
         if (
           !playUrlSent &&
-          !this.transport.requiresWavAudio &&
+          !this.transport.requiresPcmAudio &&
           this.isCurrentRun(runVersion)
         ) {
           this.beginSpeakingOnAudioStart(runVersion);
-          this.transport.sendTextToken(text, false);
+          // Trailing space restores the inter-segment separator lost when
+          // the segment was trimmed at extraction.
+          this.transport.sendTextToken(`${text} `, false);
         }
+        return playUrlSent ? "failed-after-audio" : "failed-before-audio";
       }
     } finally {
-      this.activeSynthesisAbort = null;
+      // Identity-guarded: a late-finishing stale segment must not clear a
+      // newer turn's abort handle.
+      if (this.activeSynthesisAbort === abortController) {
+        this.activeSynthesisAbort = null;
+      }
       sink?.finalize();
     }
+    return "ok";
   }
 
   /**
@@ -1275,8 +1454,7 @@ export class CallController {
    */
   private isLockContentionError(err: unknown): boolean {
     return (
-      err instanceof Error &&
-      err.message.includes("already processing a message")
+      err instanceof Error && err.message.includes(CONVERSATION_BUSY_MESSAGE)
     );
   }
 

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

@@ -7,7 +7,7 @@
  * the owning server should continue the call once setup completes.
  */
 
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 
 // ── Transport surface ────────────────────────────────────────────────
 
@@ -19,7 +19,7 @@ import type { TrustContext } from "../daemon/trust-context.js";
 export interface SetupFlowTransport {
   sendTextToken(token: string, last: boolean): void;
   endSession(reason?: string): void;
-  readonly requiresWavAudio?: boolean;
+  readonly requiresPcmAudio?: boolean;
 }
 
 // ── Flow state ───────────────────────────────────────────────────────

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

@@ -15,18 +15,13 @@
 
 import { randomInt } from "node:crypto";
 
-import { getGuardianDeliveryFresh } from "../contacts/guardian-delivery-reader.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import type { addMessage as addMessageFn } from "../persistence/conversation-crud.js";
 import { notifyGuardianOfAccessRequest as notifyGuardianOfAccessRequestImpl } from "../runtime/access-request-helper.js";
-import {
-  resolveActorTrust,
-  toTrustContext,
-} from "../runtime/actor-trust-resolver.js";
+import { toTrustContext } from "../runtime/actor-trust-resolver.js";
 import {
   trustContextFromVerdict,
-  verdictHasMemberIdentity,
-  verdictMemberUnresolvable,
+  verdictUsability,
 } from "../runtime/trust-verdict-consumer.js";
 import {
   composeVerificationVoice,
@@ -133,10 +128,9 @@ export interface CallSetupFlowDeps {
   /** Gateway-native invite claim. Defaults to call-verification's. */
   attemptInviteCodeRedemption?: typeof attemptInviteCodeRedemptionImpl;
   /**
-   * Re-resolve caller trust after a successful mid-setup activation
-   * (verdict-first with local fallback). Defaults to
-   * {@link resolveMidCallTrustContext}; errors fail soft to the
-   * setup-time trust.
+   * Re-resolve caller trust after a successful mid-setup activation from the
+   * gateway verdict. Defaults to {@link resolveMidCallTrustContext}; errors
+   * (including an unavailable verdict) fail soft to the setup-time trust.
    */
   resolveMidCallTrustContext?(
     assistantId: string,
@@ -271,56 +265,24 @@ function requireDeps<K extends keyof CallSetupFlowDeps>(
 }
 
 /**
- * Re-resolve caller trust after a mid-setup verification/activation. Prefers
- * the gateway verdict (authoritative right after the gateway updated the
- * binding); falls back to local resolution on a missing/failed/unusable
- * verdict so a blip never drops the call. Mirrors the setup path's
- * verdict-first-with-fallback condition.
+ * Re-resolve caller trust after a mid-setup verification/activation from the
+ * gateway verdict (authoritative right after the gateway updated the
+ * binding). Throws on a missing/failed/member-unresolvable verdict — the
+ * caller keeps the setup-time trust, which can only under-privilege relative
+ * to a fresh grant.
  */
 export async function resolveMidCallTrustContext(
-  assistantId: string,
+  _assistantId: string,
   fromNumber: string,
 ): Promise<TrustContext> {
-  const verdict = await getPhoneCallerVerdict(fromNumber);
-
-  // Only a MEMBERLESS unknown verdict is treated as a stale gateway view and
-  // falls back to local: the caller was just activated, and invite redemption
-  // writes the channel assistant-side, so the gateway may not see the member
-  // yet — local resolution has it. A MEMBERFUL unknown verdict (blocked/revoked
-  // member, carrying contactId/channelId) is honored so its deny ACL is
-  // enforced; falling back could lose the gateway's member status if local
-  // state is stale.
-  const memberlessUnknown =
-    verdict?.trustClass === "unknown" && !verdictHasMemberIdentity(verdict);
-  const usable =
-    verdict &&
-    !verdict.resolutionFailed &&
-    !verdictMemberUnresolvable(verdict) &&
-    !memberlessUnknown;
-
-  if (usable) {
-    return trustContextFromVerdict(verdict, {
-      sourceChannel: "phone",
-      conversationExternalId: fromNumber,
-    });
+  const usability = verdictUsability(await getPhoneCallerVerdict(fromNumber));
+  if (!usability.usable) {
+    throw new Error(`Mid-call trust verdict unavailable (${usability.reason})`);
   }
-
-  // Warm the phone-channel guardian-delivery cache before the SYNC
-  // resolveActorTrust fallback, which reads the IO-free per-channel snapshot
-  // that daemon startup leaves cold for `phone`. Read fresh: gateway-side
-  // binding writes don't invalidate the daemon cache, so a stale empty
-  // snapshot would otherwise survive the TTL and misclassify the guardian.
-  await getGuardianDeliveryFresh({ channelTypes: ["phone"] });
-
-  return toTrustContext(
-    resolveActorTrust({
-      assistantId,
-      sourceChannel: "phone",
-      conversationExternalId: fromNumber,
-      actorExternalId: fromNumber,
-    }),
-    fromNumber,
-  );
+  return trustContextFromVerdict(usability.verdict, {
+    sourceChannel: "phone",
+    conversationExternalId: fromNumber,
+  });
 }
 
 /**