@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/calls/inbound-trust-reader.ts

@@ -10,10 +10,14 @@
  * fail-closed); this reader only reports the verdict or `null`.
  */
 
-import { type TrustVerdict, TrustVerdictSchema } from "@vellumai/gateway-client";
+import {
+  type TrustVerdict,
+  TrustVerdictSchema,
+} from "@vellumai/gateway-client";
 
 import type { ChannelId } from "../channels/types.js";
 import { ipcCall } from "../ipc/gateway-client.js";
+import { setMemberVerdict } from "../runtime/member-verdict-cache.js";
 
 // Short IPC timeout so the read resolves promptly rather than stalling call
 // setup on a gateway that accepts the socket but hangs.
@@ -33,8 +37,26 @@ export async function getInboundTrustVerdict(input: {
     if (!result) return null;
 
     const parsed = TrustVerdictSchema.safeParse(result.verdict);
-    return parsed.success ? parsed.data : null;
+    if (!parsed.success) return null;
+
+    // Single choke point: warm the member-verdict cache so the sync trust
+    // fallback resolves the member without a local ACL read.
+    setMemberVerdict(input.channelType, input.actorExternalId, parsed.data);
+    return parsed.data;
   } catch {
     return null;
   }
 }
+
+/**
+ * Resolve the verdict for a phone caller by their external number. Callers
+ * compute `otherPartyNumber` from their own transport-specific direction.
+ */
+export function getPhoneCallerVerdict(
+  otherPartyNumber: string | undefined,
+): Promise<TrustVerdict | null> {
+  return getInboundTrustVerdict({
+    channelType: "phone",
+    actorExternalId: otherPartyNumber || undefined,
+  });
+}

package/src/calls/media-stream-server.ts

@@ -52,6 +52,7 @@ import {
 } from "./call-store.js";
 import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
 import { finalizeCall } from "./finalize-call.js";
+import { getPhoneCallerVerdict } from "./inbound-trust-reader.js";
 import { MediaStreamOutput } from "./media-stream-output.js";
 import { parseMediaStreamFrame } from "./media-stream-parser.js";
 import type { MediaStreamStartEvent } from "./media-stream-protocol.js";
@@ -391,6 +392,25 @@ export class MediaStreamCallSession {
       return;
     }
 
+    // Verdict-first caller trust so this transport enforces the same gateway
+    // ACL as ConversationRelay. routeSetup uses it when present and not
+    // resolutionFailed, else falls back to local resolution. The reader returns
+    // null on failure, keeping the local path on a gateway blip.
+    const isInbound = session?.initiatedFromConversationId == null;
+    const otherPartyNumber = isInbound ? from : to;
+    const verdict = await getPhoneCallerVerdict(otherPartyNumber);
+
+    // The verdict read above yields the event loop; abort if the session was
+    // disposed meanwhile, matching the admission-read guard above.
+    if (this.disposed) {
+      log.info(
+        { callSessionId: this.callSessionId },
+        "Media-stream session disposed during verdict read — aborting setup",
+      );
+      this.setupRouting = false;
+      return;
+    }
+
     const { outcome, resolved } = routeSetup({
       callSessionId: this.callSessionId,
       session: session ?? null,
@@ -398,6 +418,7 @@ export class MediaStreamCallSession {
       to,
       customParameters: event.start.customParameters,
       admissionPolicy,
+      verdict,
     });
 
     log.info(

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

@@ -9,6 +9,7 @@
 import { findContactChannel } from "../contacts/contact-store.js";
 import { getCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import { getCachedMemberAcl } from "../runtime/member-verdict-cache.js";
 import { getLogger } from "../util/logger.js";
 import {
   getGuardianWaitUpdateInitialIntervalMs,
@@ -252,12 +253,11 @@ export function emitAccessRequestCallbackHandoff(
         address: fromNumber,
         externalChatId: fromNumber,
       });
-      if (
-        contactResult &&
-        contactResult.channel.status === "active" &&
-        contactResult.channel.policy === "allow"
-      ) {
-        requesterMemberId = contactResult.channel.id;
+      if (contactResult) {
+        const acl = getCachedMemberAcl("phone", fromNumber);
+        if (acl?.status === "active" && acl.policy === "allow") {
+          requesterMemberId = contactResult.channel.id;
+        }
       }
     } catch (err) {
       log.warn(

package/src/calls/relay-server.ts

@@ -8,15 +8,17 @@
 
 import { randomInt } from "node:crypto";
 
-import type { AdmissionPolicy } from "@vellumai/gateway-client";
+import type { AdmissionPolicy, TrustVerdict } from "@vellumai/gateway-client";
 import type { ServerWebSocket } from "bun";
 
 import {
-  findGuardianForChannel,
-  listGuardianChannels,
-} from "../contacts/contact-store.js";
+  getGuardianDelivery,
+  getGuardianDeliveryFresh,
+  voiceGuardianDisplayName,
+} from "../contacts/guardian-delivery-reader.js";
 import { getAssistantName } from "../daemon/identity-helpers.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import { getCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import { addMessage } from "../memory/conversation-crud.js";
 import { revokeScopedApprovalGrantsForContext } from "../memory/scoped-approval-grants.js";
@@ -26,6 +28,11 @@ import {
   resolveActorTrust,
   toTrustContext,
 } from "../runtime/actor-trust-resolver.js";
+import {
+  trustContextFromVerdict,
+  verdictHasMemberIdentity,
+  verdictMemberUnresolvable,
+} from "../runtime/trust-verdict-consumer.js";
 import {
   composeVerificationVoice,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
@@ -50,6 +57,10 @@ import {
 import { ConversationRelayTransport } from "./call-transport.js";
 import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
 import { finalizeCall } from "./finalize-call.js";
+import {
+  getInboundTrustVerdict,
+  getPhoneCallerVerdict,
+} from "./inbound-trust-reader.js";
 import {
   classifyWaitUtterance,
   emitAccessRequestCallbackHandoff,
@@ -252,6 +263,10 @@ export class RelayConnection {
   private accessRequestWaitStartedAt: number = 0;
   private heartbeatSequence = 0;
 
+  // Guardian displayName primed from the gateway binding at setup, read
+  // synchronously by the heartbeat-driven wait-label path.
+  private primedGuardianDisplayName: string | undefined;
+
   // In-wait prompt handling state
   private lastInWaitReplyAt = 0;
   private static readonly IN_WAIT_REPLY_COOLDOWN_MS = 3000;
@@ -261,6 +276,12 @@ export class RelayConnection {
   private callbackOptIn = false;
   private callbackHandoffNotified = false;
 
+  // True while mid-call trust is being re-resolved (async). handlePrompt defers
+  // prompts to trustReResolvePending so a verified caller can't start a turn
+  // under the stale pre-verification trust context during the await window.
+  private trustReResolving = false;
+  private trustReResolvePending: RelayPromptMessage[] = [];
+
   constructor(ws: ServerWebSocket<RelayWebSocketData>, callSessionId: string) {
     this.ws = ws;
     this.callSessionId = callSessionId;
@@ -581,12 +602,33 @@ export class RelayConnection {
     const session = getCallSession(this.callSessionId);
     this.recordSetupBookkeeping(session, msg);
 
+    // Prime the guardian displayName and warm the phone-channel guardian-
+    // delivery cache before routeSetup's SYNC resolveActorTrust fallback. That
+    // fallback reads the IO-free cache snapshot keyed per channel-filter; daemon
+    // startup warms only `vellum`, so a cold-process phone call would otherwise
+    // misclassify a guardian during a gateway verdict blip. Read fresh: gateway-
+    // side binding writes don't invalidate the daemon cache, so a stale empty
+    // snapshot from an earlier setup would survive the TTL otherwise. Both are
+    // independent IPC reads on different cache keys, so run them concurrently
+    // off the sync resolver's hot path.
+    await Promise.all([
+      this.primeGuardianDisplayName(),
+      getGuardianDeliveryFresh({ channelTypes: ["phone"] }),
+    ]);
+
     // Resolve the phone channel's inbound admission floor. The reader fails
     // open to `null` by contract, so a transport hiccup admits the caller.
     const admissionPolicy = await getChannelAdmissionPolicy("phone");
 
+    // Verdict-first caller trust. routeSetup uses it when present and not
+    // resolutionFailed, else falls back to local resolution. The reader
+    // returns null on failure, so a gateway blip keeps the local path.
+    const isInbound = session?.initiatedFromConversationId == null;
+    const otherPartyNumber = isInbound ? msg.from : msg.to;
+    const verdict = await getPhoneCallerVerdict(otherPartyNumber);
+
     try {
-      await this.routeSetupOutcome(msg, session, admissionPolicy);
+      await this.routeSetupOutcome(msg, session, admissionPolicy, verdict);
     } catch (err) {
       // Never leave the connection stranded in "setting_up": a setup that
       // throws before reaching a terminal outcome would otherwise drop every
@@ -615,6 +657,7 @@ export class RelayConnection {
     msg: RelaySetupMessage,
     session: ReturnType<typeof getCallSession>,
     admissionPolicy: AdmissionPolicy | null,
+    verdict: TrustVerdict | null,
   ): Promise<void> {
     const { outcome, resolved } = routeSetup({
       callSessionId: this.callSessionId,
@@ -623,6 +666,7 @@ export class RelayConnection {
       to: msg.to,
       customParameters: msg.customParameters,
       admissionPolicy,
+      verdict,
     });
 
     const initialTrustContext = toTrustContext(
@@ -780,7 +824,7 @@ export class RelayConnection {
       from,
       trustClass: resolved.actorTrust.trustClass,
       channelId: resolved.actorTrust.memberRecord?.channel.id,
-      memberPolicy: resolved.actorTrust.memberRecord?.channel.policy,
+      memberPolicy: resolved.actorTrust.memberRecord?.policy,
     });
     this.connectionState = "disconnecting";
     updateCallSession(this.callSessionId, {
@@ -871,6 +915,102 @@ export class RelayConnection {
       );
   }
 
+  /**
+   * Re-resolve caller trust after a mid-call 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.
+   */
+  private async resolveMidCallTrustContext(
+    assistantId: string,
+    fromNumber: string,
+  ): Promise<TrustContext> {
+    const verdict = await getInboundTrustVerdict({
+      channelType: "phone",
+      actorExternalId: 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,
+      });
+    }
+
+    // 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,
+    );
+  }
+
+  /**
+   * Re-resolve mid-call trust and install it on the controller, deferring any
+   * prompt that arrives during the async window. Guards the gap between
+   * connectionState flipping to "connected" and the upgraded context landing so
+   * a verified caller never starts a turn under the stale pre-verification
+   * trust. Clears the guard in a finally and flushes buffered prompts under the
+   * new context, so an IPC error can't wedge the call.
+   */
+  private async reResolveAndApplyTrustContext(
+    assistantId: string,
+    fromNumber: string,
+  ): Promise<void> {
+    if (!this.controller) return;
+    this.trustReResolving = true;
+    try {
+      const context = await this.resolveMidCallTrustContext(
+        assistantId,
+        fromNumber,
+      );
+      this.controller.setTrustContext(context);
+    } finally {
+      this.trustReResolving = false;
+      this.flushDeferredPrompts();
+    }
+  }
+
+  /**
+   * Replay prompts buffered while trust was re-resolving. Runs after the
+   * upgraded context is installed so deferred utterances are answered under the
+   * correct trust.
+   */
+  private flushDeferredPrompts(): void {
+    if (this.trustReResolvePending.length === 0) return;
+    const pending = this.trustReResolvePending;
+    this.trustReResolvePending = [];
+    for (const msg of pending) {
+      void this.handlePrompt(msg);
+    }
+  }
+
   /**
    * Shared post-activation handoff for all trusted-contact success paths
    * (access-request approval, invite redemption, verification code).
@@ -878,7 +1018,7 @@ export class RelayConnection {
    * transition copy, and marks the next utterance as opening-ack so the
    * LLM continues naturally.
    */
-  private continueCallAfterTrustedContactActivation(params: {
+  private async continueCallAfterTrustedContactActivation(params: {
     assistantId: string;
     fromNumber: string;
     activationReason?:
@@ -893,26 +1033,25 @@ export class RelayConnection {
      * address.
      */
     inviteeName?: string | null;
-  }): void {
+  }): Promise<void> {
     const { assistantId, fromNumber } = params;
 
     // Contact activation is handled by the gateway — the assistant no
     // longer writes contact/channel records on inbound voice calls.
 
-    const updatedTrust = resolveActorTrust({
-      assistantId,
-      sourceChannel: "phone",
-      conversationExternalId: fromNumber,
-      actorExternalId: fromNumber,
-    });
+    // Reach connected and clear wait/verification flags before re-resolving
+    // trust, so a prompt buffered during re-resolution flushes onto the
+    // real-turn path, not the verification/wait branches.
+    this.connectionState = "connected";
+    this.verificationSessionActive = false;
+    this.inviteRedemptionActive = false;
+    this.accessRequestWaitActive = false;
+    updateCallSession(this.callSessionId, { status: "in_progress" });
 
     if (this.controller) {
-      this.controller.setTrustContext(toTrustContext(updatedTrust, fromNumber));
+      await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
     }
 
-    this.connectionState = "connected";
-    updateCallSession(this.callSessionId, { status: "in_progress" });
-
     const guardianLabel = this.resolveGuardianLabel();
     let handoffText: string;
 
@@ -1045,7 +1184,7 @@ export class RelayConnection {
     const assistantId = this.verificationAssistantId;
     const fromNumber = this.verificationFromNumber;
 
-    const result = attemptVerificationCode({
+    const result = await attemptVerificationCode({
       verificationAssistantId: assistantId,
       verificationFromNumber: fromNumber,
       enteredCode,
@@ -1091,15 +1230,7 @@ export class RelayConnection {
 
         // Update trust context on the controller so the LLM knows this is the guardian
         if (this.controller) {
-          const verifiedActorTrust = resolveActorTrust({
-            assistantId,
-            sourceChannel: "phone",
-            conversationExternalId: fromNumber,
-            actorExternalId: fromNumber,
-          });
-          this.controller.setTrustContext(
-            toTrustContext(verifiedActorTrust, fromNumber),
-          );
+          await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
         }
 
         // Mark session as in-progress and transition to guardian conversation
@@ -1116,7 +1247,7 @@ export class RelayConnection {
             );
         }
       } else if (result.verificationType === "trusted_contact") {
-        this.continueCallAfterTrustedContactActivation({
+        await this.continueCallAfterTrustedContactActivation({
           assistantId,
           fromNumber,
           activationReason: "trusted_contact_verified",
@@ -1125,15 +1256,7 @@ export class RelayConnection {
         // Inbound guardian verification: binding already handled above,
         // proceed to normal call flow.
         if (this.controller) {
-          const verifiedActorTrust = resolveActorTrust({
-            assistantId,
-            sourceChannel: "phone",
-            conversationExternalId: fromNumber,
-            actorExternalId: fromNumber,
-          });
-          this.controller.setTrustContext(
-            toTrustContext(verifiedActorTrust, fromNumber),
-          );
+          await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
           this.startNormalCallFlow(this.controller, true);
         }
       }
@@ -1296,7 +1419,7 @@ export class RelayConnection {
    * Creates a canonical access request, notifies the guardian, and
    * enters the bounded wait loop for the guardian decision.
    */
-  private handleNameCaptureResponse(callerName: string): void {
+  private async handleNameCaptureResponse(callerName: string): Promise<void> {
     if (!this.accessRequestAssistantId || !this.accessRequestFromNumber) {
       return;
     }
@@ -1317,7 +1440,7 @@ export class RelayConnection {
     // Create canonical access request and notify the guardian, including
     // the caller's spoken name and voice channel metadata.
     try {
-      const accessResult = notifyGuardianOfAccessRequest({
+      const accessResult = await notifyGuardianOfAccessRequest({
         canonicalAssistantId: this.accessRequestAssistantId,
         sourceChannel: "phone",
         conversationExternalId: this.accessRequestFromNumber,
@@ -1410,7 +1533,7 @@ export class RelayConnection {
       }
 
       if (request.status === "approved") {
-        this.handleAccessRequestApproved();
+        void this.handleAccessRequestApproved();
       } else if (request.status === "denied") {
         void this.handleAccessRequestDenied();
       }
@@ -1462,7 +1585,7 @@ export class RelayConnection {
    * Handle an approved access request: activate the caller as a trusted
    * contact, update runtime context, and continue with normal call flow.
    */
-  private handleAccessRequestApproved(): void {
+  private async handleAccessRequestApproved(): Promise<void> {
     this.clearAccessRequestWait();
 
     const assistantId = this.accessRequestAssistantId!;
@@ -1480,7 +1603,7 @@ export class RelayConnection {
       "Access request approved — caller activated and continuing call",
     );
 
-    this.continueCallAfterTrustedContactActivation({
+    await this.continueCallAfterTrustedContactActivation({
       assistantId,
       fromNumber,
       activationReason: "access_approved",
@@ -1688,7 +1811,7 @@ export class RelayConnection {
         "Voice invite redemption succeeded",
       );
 
-      this.continueCallAfterTrustedContactActivation({
+      await this.continueCallAfterTrustedContactActivation({
         assistantId: this.inviteRedemptionAssistantId,
         fromNumber: this.inviteRedemptionFromNumber,
         activationReason: "invite_redeemed",
@@ -1731,15 +1854,20 @@ export class RelayConnection {
    * Resolve a human-readable guardian label for voice wait copy.
    * Delegates to the shared resolveGuardianName() which checks the
    * guardian's per-user persona file (users/<slug>.md) first, then falls
-   * back to Contact.displayName, then DEFAULT_USER_REFERENCE.
+   * back to the primed gateway-binding displayName, then
+   * DEFAULT_USER_REFERENCE.
    */
   private resolveGuardianLabel(): string {
-    // Look up the guardian contact for a displayName fallback
-    const voiceGuardian = findGuardianForChannel("phone");
-    const guardianChannels = voiceGuardian ? null : listGuardianChannels();
-    const guardianContact = voiceGuardian?.contact ?? guardianChannels?.contact;
+    return resolveGuardianName(this.primedGuardianDisplayName);
+  }
 
-    return resolveGuardianName(guardianContact?.displayName);
+  /**
+   * Prime the guardian displayName from the gateway binding so the
+   * synchronous wait-label path can read it without an IPC round-trip.
+   */
+  private async primeGuardianDisplayName(): Promise<void> {
+    const list = await getGuardianDelivery();
+    this.primedGuardianDisplayName = voiceGuardianDisplayName(list);
   }
 
   /**
@@ -1917,6 +2045,15 @@ export class RelayConnection {
       return;
     }
 
+    // Defer (don't drop) prompts while trust is being re-resolved mid-call so a
+    // verified caller's first utterance runs under the upgraded context, not the
+    // stale pre-verification one. flushDeferredPrompts replays them in order
+    // once the new context lands.
+    if (this.trustReResolving) {
+      this.trustReResolvePending.push(msg);
+      return;
+    }
+
     // Prompts arriving before setup routing/ACL completes are dropped — never
     // persisted or emitted — so a not-yet-authorized caller's speech can't be
     // stored ahead of the admission floor / trust ACL decision.
@@ -1942,7 +2079,7 @@ export class RelayConnection {
         { callSessionId: this.callSessionId, callerName },
         "Name captured from unknown inbound caller",
       );
-      this.handleNameCaptureResponse(callerName);
+      await this.handleNameCaptureResponse(callerName);
       return;
     }
 

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

@@ -6,7 +6,7 @@
  * next — without performing any side effects itself.
  */
 
-import type { AdmissionPolicy } from "@vellumai/gateway-client";
+import type { AdmissionPolicy, TrustVerdict } from "@vellumai/gateway-client";
 
 import { getConfig } from "../config/loader.js";
 import { getContact } from "../contacts/contact-store.js";
@@ -21,6 +21,10 @@ import {
   type AdmissionPolicyResult,
   enforceAdmissionPolicy,
 } from "../runtime/routes/inbound-stages/admission-policy.js";
+import {
+  actorTrustContextFromVerdict,
+  verdictMemberUnresolvable,
+} from "../runtime/trust-verdict-consumer.js";
 import { getLogger } from "../util/logger.js";
 import type { CallSession } from "./types.js";
 
@@ -40,6 +44,12 @@ interface SetupContext {
    * preserving all pre-admission behavior.
    */
   admissionPolicy?: AdmissionPolicy | null;
+  /**
+   * Gateway-stamped caller trust verdict. When present and not
+   * `resolutionFailed`, the caller's trust is built from it; otherwise the
+   * router falls back to local resolution.
+   */
+  verdict?: TrustVerdict | null;
 }
 
 // ── Setup outcomes ───────────────────────────────────────────────────
@@ -112,12 +122,32 @@ export function routeSetup(ctx: SetupContext): {
   const isInbound = ctx.session?.initiatedFromConversationId == null;
   const otherPartyNumber = isInbound ? ctx.from : ctx.to;
 
-  const actorTrust = resolveActorTrust({
-    assistantId,
-    sourceChannel: "phone",
-    conversationExternalId: otherPartyNumber,
-    actorExternalId: otherPartyNumber || undefined,
-  });
+  // Verdict-first: build caller trust from the gateway verdict when present.
+  // Voice falls back to local resolution on a missing/failed verdict so a
+  // gateway blip does not drop a known guardian's call — the deliberate
+  // difference from the fail-closed text path.
+  //
+  // A verdict that claims a member (contactId/channelId) but whose ACL can't be
+  // reassembled (malformed/mixed-version status·policy) also falls back to local
+  // resolution, so voice never trusts a member it cannot ACL-check. A real
+  // stranger verdict (no member identity) still takes the verdict path —
+  // memberRecord null is correct there.
+  const usable =
+    ctx.verdict &&
+    !ctx.verdict.resolutionFailed &&
+    !verdictMemberUnresolvable(ctx.verdict);
+  const actorTrust = usable
+    ? actorTrustContextFromVerdict(ctx.verdict!, {
+        sourceChannel: "phone",
+        conversationExternalId: otherPartyNumber,
+        actorDisplayName: undefined,
+      })
+    : resolveActorTrust({
+        assistantId,
+        sourceChannel: "phone",
+        conversationExternalId: otherPartyNumber,
+        actorExternalId: otherPartyNumber || undefined,
+      });
 
   const resolved: SetupResolved = {
     assistantId,
@@ -216,7 +246,7 @@ export function routeSetup(ctx: SetupContext): {
     ? enforceAdmissionPolicy({
         sourceChannel: "phone",
         trustClass: actorTrust.trustClass,
-        memberStatus: actorTrust.memberRecord?.channel.status,
+        memberStatus: actorTrust.memberRecord?.status,
         policy: ctx.admissionPolicy!,
       })
     : ({ admitted: true } as const);
@@ -253,7 +283,7 @@ export function routeSetup(ctx: SetupContext): {
     !pendingChallenge
   ) {
     // Check for blocked caller
-    if (actorTrust.memberRecord?.channel.status === "blocked") {
+    if (actorTrust.memberRecord?.status === "blocked") {
       log.info(
         {
           callSessionId: ctx.callSessionId,
@@ -336,14 +366,14 @@ export function routeSetup(ctx: SetupContext): {
     // gateway and assistant DBs) still get useful guidance instead of
     // the "I don't recognize this number" name-capture script.
     const unverifiedStatuses = new Set(["unverified", "pending"]);
-    const memberChannel = actorTrust.memberRecord?.channel;
-    if (memberChannel && unverifiedStatuses.has(memberChannel.status)) {
+    const member = actorTrust.memberRecord;
+    if (member && unverifiedStatuses.has(member.status)) {
       log.info(
         {
           callSessionId: ctx.callSessionId,
           from: ctx.from,
-          channelId: memberChannel.id,
-          channelStatus: memberChannel.status,
+          channelId: member.channel.id,
+          channelStatus: member.status,
         },
         "Inbound voice ACL: known but unverified caller — returning verification guidance",
       );
@@ -352,8 +382,8 @@ export function routeSetup(ctx: SetupContext): {
           action: "unverified_caller",
           assistantId,
           fromNumber: ctx.from,
-          displayName: actorTrust.memberRecord!.contact.displayName,
-          isGuardian: actorTrust.memberRecord!.contact.role === "guardian",
+          displayName: member.contact.displayName,
+          isGuardian: member.role === "guardian",
         },
         resolved,
       };
@@ -379,7 +409,7 @@ export function routeSetup(ctx: SetupContext): {
   }
 
   // Members with policy: 'deny'
-  if (actorTrust.memberRecord?.channel.policy === "deny") {
+  if (actorTrust.memberRecord?.policy === "deny") {
     log.info(
       {
         callSessionId: ctx.callSessionId,
@@ -400,7 +430,7 @@ export function routeSetup(ctx: SetupContext): {
   }
 
   // Members with policy: 'escalate' — live calls can't wait for approval
-  if (actorTrust.memberRecord?.channel.policy === "escalate") {
+  if (actorTrust.memberRecord?.policy === "escalate") {
     log.info(
       {
         callSessionId: ctx.callSessionId,