@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/relay-server.test.ts

@@ -26,10 +26,6 @@ import {
   test,
 } from "bun:test";
 
-import { ADMISSION_FLOOR } from "@vellumai/gateway-client";
-
-import { TRUST_CLASS_RANK } from "../runtime/actor-trust-resolver.js";
-
 // ── Platform + logger mocks (must come before any source imports) ────
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -42,6 +38,28 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// The voice redemption path now claims the gateway-canonical row over IPC
+// before mutating. Stub it so tests don't attempt a real socket connect; the
+// claim returns consumed (updated:true) so redemption proceeds.
+//
+// `inviteClaimCalls` counts gateway claims so concurrency tests can assert that
+// a repeated code does NOT launch a second claim. `inviteClaimGate`, when set,
+// holds the claim open mid-flight so a test can drive the race window where a
+// second code arrives while the first redemption is still awaiting the gateway.
+let inviteClaimCalls = 0;
+let inviteClaimGate: Promise<void> | null = null;
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async () => undefined,
+  ipcCallPersistent: async (method: string) => {
+    if (method === "record_invite_redemption") {
+      inviteClaimCalls += 1;
+      if (inviteClaimGate) await inviteClaimGate;
+      return { ok: true, updated: true, mirrored: true };
+    }
+    return undefined;
+  },
+}));
+
 // ── Identity helpers mock ─────────────────────────────────────────────
 
 let mockAssistantName: string | null = "Vellum";
@@ -69,6 +87,19 @@ mock.module("../prompts/user-reference.js", () => ({
   },
 }));
 
+// ── Guardian delivery reader mock ───────────────────────────────────
+//
+// resolveGuardianLabel primes its displayName from the gateway binding via
+// getGuardianDelivery at setup. Tests drive the binding through this list.
+
+// Tests set this to drive the guardian binding directly. When null (the
+// default), the guardian-delivery-reader mock below derives the binding from
+// the DB-seeded createGuardianBinding setup. Single mock registration lives
+// below since `mock.module` is process-global and last-write-wins in Bun.
+let mockGuardianDeliveryList:
+  | Array<{ channelType: string; status: string; displayName: string | null }>
+  | null = null;
+
 // ── Config mock ─────────────────────────────────────────────────────
 
 const mockConfig = {
@@ -145,37 +176,89 @@ mock.module("../calls/channel-admission-reader.js", () => ({
   },
 }));
 
-// Real floor semantics, mirroring relay-setup-router.test.ts. The
-// enforceAdmissionPolicy mock omits the exempt-channel short-circuit so the
-// deny path can be exercised end-to-end regardless of channel.
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realAdmissionPolicyModule = require("../runtime/routes/inbound-stages/admission-policy.js");
-mock.module("../runtime/routes/inbound-stages/admission-policy.js", () => ({
-  ...realAdmissionPolicyModule,
-  enforceAdmissionPolicy: (input: {
-    trustClass: string;
-    memberStatus: string | undefined;
-    policy: import("@vellumai/gateway-client").AdmissionPolicy;
+// ── Inbound trust verdict reader mock ───────────────────────────────
+//
+// Mid-call re-resolution (post verification/activation) prefers the gateway
+// verdict via getInboundTrustVerdict, falling back to local resolution on a
+// missing/failed/unusable verdict. Tests drive the verdict through
+// `mockMidCallVerdict`; null (the default) exercises the local fallback. As
+// with the admission reader, delegate to the real module for sibling files
+// that load later in the same worker.
+let mockMidCallVerdict:
+  | import("@vellumai/gateway-client").TrustVerdict
+  | null = null;
+// When set, the mid-call verdict reader blocks on this gate before returning,
+// simulating a slow gateway round-trip so a test can drive a prompt into the
+// re-resolution await window.
+let mockMidCallVerdictGate: Promise<void> | null = null;
+const realInboundTrustReaderModule = {
+  ...(await import("../calls/inbound-trust-reader.js")),
+};
+let inboundTrustMockActive = false;
+mock.module("../calls/inbound-trust-reader.js", () => ({
+  ...realInboundTrustReaderModule,
+  getInboundTrustVerdict: async (input: {
+    channelType: import("../channels/types.js").ChannelId;
+    actorExternalId?: string;
   }) => {
-    if (input.memberStatus === "blocked" || input.memberStatus === "revoked") {
-      return {
-        admitted: false,
-        reason:
-          input.memberStatus === "blocked" ? "member_blocked" : "member_revoked",
-        shouldChallenge: false,
-        effectivePolicy: input.policy,
-      };
+    if (!inboundTrustMockActive) {
+      return realInboundTrustReaderModule.getInboundTrustVerdict(input);
     }
-    const rank =
-      (TRUST_CLASS_RANK as Record<string, number>)[input.trustClass] ?? 0;
-    const floor = ADMISSION_FLOOR[input.policy];
-    if (rank >= floor) return { admitted: true };
-    return {
-      admitted: false,
-      reason: `admission_policy_${input.policy}`,
-      shouldChallenge: false,
-      effectivePolicy: input.policy,
-    };
+    if (mockMidCallVerdictGate) await mockMidCallVerdictGate;
+    return mockMidCallVerdict;
+  },
+}));
+
+// ── Guardian delivery reader ────────────────────────────────────────
+//
+// Guardian identity now resolves via the gateway delivery reader. Derive the
+// list from the DB-seeded guardian bindings so the existing createGuardianBinding
+// setup keeps driving guardian resolution without per-test changes.
+const realContactStoreModule = {
+  ...(await import("../contacts/contact-store.js")),
+};
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => {
+    // Tests that set mockGuardianDeliveryList drive the binding directly;
+    // otherwise derive from the DB-seeded createGuardianBinding bindings.
+    if (mockGuardianDeliveryList) return mockGuardianDeliveryList;
+    const guardians = realContactStoreModule.listGuardianChannels();
+    if (!guardians) return [];
+    return guardians.channels.map((ch) => ({
+      channelType: ch.type,
+      contactId: guardians.contact.id,
+      principalId: guardians.contact.principalId ?? null,
+      displayName: guardians.contact.displayName ?? null,
+      address: ch.address,
+      externalChatId: ch.externalChatId ?? null,
+      status: ch.status,
+      verifiedAt: ch.verifiedAt ?? null,
+    }));
+  },
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: unknown[]) => list[0],
+}));
+
+// ── Trust verdict consumer spy ──────────────────────────────────────
+//
+// Tracks whether the verdict mapper produced the final mid-call context, so a
+// test can assert the local resolver was used instead (verdict not consumed).
+let trustVerdictMapperUsed = false;
+const realTrustVerdictConsumerModule = {
+  ...(await import("../runtime/trust-verdict-consumer.js")),
+};
+mock.module("../runtime/trust-verdict-consumer.js", () => ({
+  ...realTrustVerdictConsumerModule,
+  trustContextFromVerdict: (
+    ...args: Parameters<
+      typeof realTrustVerdictConsumerModule.trustContextFromVerdict
+    >
+  ) => {
+    trustVerdictMapperUsed = true;
+    return realTrustVerdictConsumerModule.trustContextFromVerdict(...args);
   },
 }));
 
@@ -317,17 +400,19 @@ import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // Activate the channel-admission-reader stub only while this file's tests run,
 // so the registered (process-global) mock delegates to the real module for
 // sibling files that load later in the same worker.
 beforeAll(() => {
   admissionMockActive = true;
+  inboundTrustMockActive = true;
 });
 
 afterAll(() => {
   admissionMockActive = false;
+  inboundTrustMockActive = false;
   resetDbForTesting();
 });
 
@@ -489,10 +574,16 @@ describe("relay-server", () => {
       verifiedVia: "bootstrap",
     });
     activeRelayConnections.clear();
+    inviteClaimCalls = 0;
+    inviteClaimGate = null;
     mockUserReference = "my human";
     mockAssistantName = "Vellum";
+    mockGuardianDeliveryList = null;
     mockAdmissionPolicy = null;
     mockAdmissionGate = null;
+    mockMidCallVerdict = null;
+    mockMidCallVerdictGate = null;
+    trustVerdictMapperUsed = false;
     mockSendMessage.mockImplementation(createMockProviderResponse(["Hello"]));
     mockConfig.calls.verification.enabled = false;
     mockConfig.calls.verification.maxAttempts = 3;
@@ -2311,8 +2402,9 @@ describe("relay-server", () => {
 
   // ── Inbound voice invite redemption ──────────────────────────────────
 
-  test("inbound voice invite redemption: personalized welcome prompt with friend/guardian names", async () => {
+  test("inbound voice invite redemption: personalized welcome prompt uses contact displayName", async () => {
     ensureConversation("conv-invite-welcome");
+    mockUserReference = "Bob";
     const session = createCallSession({
       conversationId: "conv-invite-welcome",
       provider: "twilio",
@@ -2320,18 +2412,16 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    // Create a voice invite with friend/guardian names
+    // The invitee's name is read from the bound contact's displayName.
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Alice"),
       maxUses: 1,
       expectedExternalUserId: "+15558887777",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Alice",
-      guardianName: "Bob",
     });
 
     mockSendMessage.mockImplementation(
@@ -2352,7 +2442,8 @@ describe("relay-server", () => {
     // Should be in verification-pending state for invite redemption
     expect(relay.getConnectionState()).toBe("verification_pending");
 
-    // Check that the welcome prompt includes friend/guardian names
+    // Welcome prompt should use the contact's first-name and the resolved
+    // guardian label (not stale name flags from the invite row).
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
@@ -2387,6 +2478,7 @@ describe("relay-server", () => {
 
   test("inbound voice invite redemption: invalid code gets exact failure copy with guardian name and call ends", async () => {
     ensureConversation("conv-invite-fail");
+    mockUserReference = "Dave";
     const session = createCallSession({
       conversationId: "conv-invite-fail",
       provider: "twilio",
@@ -2394,18 +2486,16 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    // Create a voice invite with friend/guardian names
+    // Bound contact's displayName is used; guardian label is resolved at runtime.
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Carol"),
       maxUses: 1,
       expectedExternalUserId: "+15558886666",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Carol",
-      guardianName: "Dave",
     });
 
     const { ws, relay } = createMockWs(session.id);
@@ -2426,7 +2516,11 @@ describe("relay-server", () => {
       await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
     }
 
-    // Call should be marked as failed immediately
+    // Redemption is dispatched async (it now consults the gateway lifecycle
+    // pre-check over IPC), so flush the microtask/timer queue before asserting.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Call should be marked as failed
     const updated = getCallSession(session.id);
     expect(updated).not.toBeNull();
     expect(updated!.status).toBe("failed");
@@ -2466,6 +2560,184 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("inbound voice invite redemption: repeated code during in-flight claim is deduped (no second redemption, no spurious failure)", async () => {
+    ensureConversation("conv-invite-dedup");
+    const session = createCallSession({
+      conversationId: "conv-invite-dedup",
+      provider: "twilio",
+      fromNumber: "+15558885555",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Eve"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558885555",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help?"]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_dedup",
+        from: "+15558885555",
+        to: "+15551111111",
+      }),
+    );
+
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // Hold the gateway claim open so the first redemption stays in flight while
+    // the caller re-speaks the SAME code (the race this guard prevents).
+    let releaseClaim: () => void = () => {};
+    inviteClaimGate = new Promise<void>((resolve) => {
+      releaseClaim = resolve;
+    });
+
+    // First attempt: enter the full code via DTMF — dispatched fire-and-forget.
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    // Let the async handler reach the awaited gateway claim.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(inviteClaimCalls).toBe(1);
+
+    // Second attempt with the SAME code arrives while the first is in flight.
+    // It must be ignored — no second claim, no failure branch.
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(inviteClaimCalls).toBe(1);
+
+    // Now let the first redemption resolve.
+    releaseClaim();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Exactly one gateway claim ran across both attempts.
+    expect(inviteClaimCalls).toBe(1);
+
+    // Activation succeeded — call continued, never marked failed.
+    expect(relay.getConnectionState()).toBe("connected");
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).not.toBe("failed");
+
+    const events = getCallEvents(session.id);
+    expect(
+      events.some((e) => e.eventType === "invite_redemption_succeeded"),
+    ).toBe(true);
+    expect(events.some((e) => e.eventType === "invite_redemption_failed")).toBe(
+      false,
+    );
+
+    // No failure copy was sent for the deduped second attempt.
+    const failureCopy = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter(
+        (m) =>
+          m.type === "text" &&
+          (m.token ?? "").includes("incorrect or has since expired"),
+      );
+    expect(failureCopy.length).toBe(0);
+
+    relay.destroy();
+  });
+
+  test("inbound voice invite redemption: a fresh redemption after a prior attempt fully resolves still proceeds (guard cleared, no deadlock)", async () => {
+    // Prior attempt: a fully-resolved redemption on its own call.
+    ensureConversation("conv-invite-prior");
+    const priorSession = createCallSession({
+      conversationId: "conv-invite-prior",
+      provider: "twilio",
+      fromNumber: "+15558883333",
+      toNumber: "+15551111111",
+    });
+    const priorCode = generateVoiceCode(6);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Ivan"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558883333",
+      voiceCodeHash: hashVoiceCode(priorCode),
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help?"]),
+    );
+
+    const prior = createMockWs(priorSession.id);
+    await prior.relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_prior",
+        from: "+15558883333",
+        to: "+15551111111",
+      }),
+    );
+    for (const digit of priorCode) {
+      await prior.relay.handleMessage(
+        JSON.stringify({ type: "dtmf", digit }),
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(prior.relay.getConnectionState()).toBe("connected");
+    expect(inviteClaimCalls).toBe(1);
+    prior.relay.destroy();
+
+    // Fresh attempt: a brand-new redemption proceeds (the in-flight guard from
+    // the resolved attempt does not block it — it was cleared in finally).
+    ensureConversation("conv-invite-fresh");
+    const freshSession = createCallSession({
+      conversationId: "conv-invite-fresh",
+      provider: "twilio",
+      fromNumber: "+15558882222",
+      toNumber: "+15551111111",
+    });
+    const freshCode = generateVoiceCode(6);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Kim"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558882222",
+      voiceCodeHash: hashVoiceCode(freshCode),
+      voiceCodeDigits: 6,
+    });
+
+    const fresh = createMockWs(freshSession.id);
+    await fresh.relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_fresh",
+        from: "+15558882222",
+        to: "+15551111111",
+      }),
+    );
+    for (const digit of freshCode) {
+      await fresh.relay.handleMessage(
+        JSON.stringify({ type: "dtmf", digit }),
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // A second claim ran for the fresh attempt — guard did not deadlock it.
+    expect(inviteClaimCalls).toBe(2);
+    expect(fresh.relay.getConnectionState()).toBe("connected");
+
+    fresh.relay.destroy();
+  });
+
   test("inbound voice: unknown caller with no active invite enters name capture flow", async () => {
     ensureConversation("conv-invite-no-invite");
     const session = createCallSession({
@@ -4519,7 +4791,7 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
-  test("invite redemption success: continues call with handoff copy instead of ending", async () => {
+  test("invite redemption success: greeting uses bound contact's displayName first-token, not friendName", async () => {
     ensureConversation("conv-invite-continue");
     const session = createCallSession({
       conversationId: "conv-invite-continue",
@@ -4530,15 +4802,19 @@ describe("relay-server", () => {
 
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
+    // Bound contact's displayName is the source of truth — its first token
+    // (here "Carolina") is what the post-redemption greeting should use.
+    // The legacy friendName column carries an out-of-date free-text label
+    // ("Stale Name") to prove the greeting reads from the contact, not the
+    // legacy column.
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Carolina Flaherty"),
       maxUses: 1,
       expectedExternalUserId: "+15557776666",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Eve",
-      guardianName: "Frank",
+      friendName: "Stale Name",
     });
 
     mockSendMessage.mockImplementation(
@@ -4569,15 +4845,18 @@ describe("relay-server", () => {
     // Call should remain connected
     expect(relay.getConnectionState()).toBe("connected");
 
-    // Handoff copy should have been sent
+    // Handoff copy should use the contact's first-name, not the stale friendName
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
     expect(
       textMessages.some((m) =>
-        (m.token ?? "").includes("verified that you are Eve"),
+        (m.token ?? "").includes("verified that you are Carolina"),
       ),
     ).toBe(true);
+    expect(
+      textMessages.every((m) => !(m.token ?? "").includes("Stale Name")),
+    ).toBe(true);
 
     // No end message — call stays alive
     const endMessages = ws.sentMessages
@@ -4602,6 +4881,7 @@ describe("relay-server", () => {
   test("outbound invite prompt uses assistant introduction", async () => {
     ensureConversation("conv-outbound-invite-origin");
     ensureConversation("conv-outbound-invite");
+    mockUserReference = "Hank";
     const session = createCallSession({
       conversationId: "conv-outbound-invite",
       provider: "twilio",
@@ -4644,20 +4924,141 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("invite redemption success: empty contact displayName triggers neutral 'Hi there' greeting", async () => {
+    ensureConversation("conv-invite-blank-name");
+    mockUserReference = "my human";
+    mockAssistantName = "";
+    const session = createCallSession({
+      conversationId: "conv-invite-blank-name",
+      provider: "twilio",
+      fromNumber: "+15557775555",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    // displayName is whitespace-only — greeting falls back to "Hi there"
+    // rather than substituting the channel address.
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("   "),
+      maxUses: 1,
+      expectedExternalUserId: "+15557775555",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["I'd be happy to help."]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_blank_name",
+        from: "+15557775555",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").startsWith("Hi there!")),
+    ).toBe(true);
+    expect(
+      textMessages.every(
+        (m) => !(m.token ?? "").includes("+15557775555"),
+      ),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
+  test("invite redemption success: empty contact displayName with stale friendName column still greets 'Hi there'", async () => {
+    // Guards the Codex P2 on #35581 (discussion_r3453033493): when a bound
+    // contact's displayName is blank and the invite row carries a stale
+    // free-text friend_name, the greeting must NOT fall back to that stale
+    // label. contact_id is NOT NULL, so every invite is bound — empty
+    // displayName falls through to the neutral "Hi there" copy.
+    ensureConversation("conv-invite-stale-friend");
+    mockUserReference = "my human";
+    mockAssistantName = "";
+    const session = createCallSession({
+      conversationId: "conv-invite-stale-friend",
+      provider: "twilio",
+      fromNumber: "+15557774444",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("   "),
+      maxUses: 1,
+      expectedExternalUserId: "+15557774444",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+      friendName: "Stale Legacy Name",
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["I'd be happy to help."]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_stale_friend",
+        from: "+15557774444",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").startsWith("Hi there!")),
+    ).toBe(true);
+    expect(
+      textMessages.every(
+        (m) => !(m.token ?? "").includes("Stale Legacy Name"),
+      ),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
   // ── resolveGuardianLabel resolution priority ─────────────────────────
 
   test("guardian label: guardian persona name takes precedence over Contact.displayName", async () => {
     mockUserReference = "Alice";
 
-    // Create a guardian binding with a different displayName
-    createGuardianBinding({
-      channel: "phone",
-      guardianExternalUserId: "+15559990001",
-      guardianDeliveryChatId: "+15559990001",
-      guardianPrincipalId: "+15559990001",
-      verifiedVia: "test",
-      metadataJson: JSON.stringify({ displayName: "Bob" }),
-    });
+    // Gateway binding carries a different displayName
+    mockGuardianDeliveryList = [
+      { channelType: "phone", status: "active", displayName: "Bob" },
+    ];
 
     ensureConversation("conv-label-user-md");
     const session = createCallSession({
@@ -4694,15 +5095,10 @@ describe("relay-server", () => {
   test("guardian label: Contact.displayName used when guardian persona name is empty", async () => {
     mockUserReference = "my human";
 
-    // Create a guardian binding with a displayName
-    createGuardianBinding({
-      channel: "phone",
-      guardianExternalUserId: "+15559990002",
-      guardianDeliveryChatId: "+15559990002",
-      guardianPrincipalId: "+15559990002",
-      verifiedVia: "test",
-      metadataJson: JSON.stringify({ displayName: "Charlie" }),
-    });
+    // Gateway binding carries the guardian displayName
+    mockGuardianDeliveryList = [
+      { channelType: "phone", status: "active", displayName: "Charlie" },
+    ];
 
     ensureConversation("conv-label-contact");
     const session = createCallSession({
@@ -4738,10 +5134,8 @@ describe("relay-server", () => {
   test("guardian label: DEFAULT_USER_REFERENCE used when both guardian persona name and Contact.displayName are empty", async () => {
     mockUserReference = "my human";
 
-    // Clear guardian binding so resolveGuardianLabel falls back to DEFAULT_USER_REFERENCE
-    const db = getDb();
-    db.run("DELETE FROM contact_channels");
-    db.run("DELETE FROM contacts");
+    // Empty binding list so resolveGuardianLabel falls back to DEFAULT_USER_REFERENCE
+    mockGuardianDeliveryList = [];
 
     ensureConversation("conv-label-default");
     const session = createCallSession({
@@ -5139,4 +5533,563 @@ describe("relay-server", () => {
       relay.destroy();
     });
   });
+
+  // ── Mid-call trust re-resolution from the gateway verdict ───────────
+  //
+  // After a verification/activation success the relay re-resolves caller trust.
+  // It prefers the gateway verdict (authoritative right after the gateway
+  // updated the binding) and falls back to local resolution on a missing/
+  // failed/unusable verdict so a blip never drops the call.
+
+  function readControllerTrustClass(relay: RelayConnection): string | undefined {
+    return (
+      relay.getController() as unknown as {
+        trustContext?: { trustClass?: string };
+      }
+    )?.trustContext?.trustClass;
+  }
+
+  test("inbound guardian verification: re-resolves trust from the gateway verdict", async () => {
+    ensureConversation("conv-midcall-verdict-guardian");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-guardian",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    // The gateway verdict upgrades the caller to guardian post-verification.
+    mockMidCallVerdict = {
+      trustClass: "guardian",
+      canonicalSenderId: "+15559999999",
+      guardianExternalUserId: "+15559999999",
+      guardianPrincipalId: "+15559999999",
+    };
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, verified guardian!"]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_guardian",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+    // Controller trust reflects the gateway verdict's upgraded class.
+    expect(readControllerTrustClass(relay)).toBe("guardian");
+
+    relay.destroy();
+  });
+
+  test("inbound guardian verification: resolutionFailed verdict falls back to local resolution without dropping the call", async () => {
+    ensureConversation("conv-midcall-verdict-failed");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-failed",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    // A failed verdict must fall back to local resolution — the call stays up.
+    mockMidCallVerdict = {
+      trustClass: "unknown",
+      canonicalSenderId: null,
+      resolutionFailed: true,
+    };
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help you?"]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_failed",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Fail-soft: verification still completes and the call connects.
+    expect(relay.isVerificationSessionActive()).toBe(false);
+    expect(relay.getConnectionState()).toBe("connected");
+    expect(readControllerTrustClass(relay)).toBeDefined();
+
+    relay.destroy();
+  });
+
+  test("inbound guardian verification: member-claiming but unusable verdict falls back to local resolution", async () => {
+    ensureConversation("conv-midcall-verdict-unusable");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-unusable",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    // Claims a member (contactId/channelId) but the ACL can't be reassembled
+    // (missing status/policy) — mirrors the setup path's unusable condition.
+    mockMidCallVerdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "+15559999999",
+      contactId: "ct_unusable",
+      channelId: "ch_unusable",
+    };
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello there."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_unusable",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Fail-soft: unusable verdict does not drop the call; local fallback fires.
+    expect(relay.getConnectionState()).toBe("connected");
+    expect(readControllerTrustClass(relay)).toBeDefined();
+
+    relay.destroy();
+  });
+
+  test("inbound guardian verification: memberless unknown verdict falls back to local resolution (just-activated invitee not downgraded)", async () => {
+    ensureConversation("conv-midcall-verdict-unknown");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-unknown",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    // Invite redemption writes the channel assistant-side, so right after
+    // activation the gateway has no member and returns a memberless unknown
+    // verdict. Mid-call re-resolution must treat it as a stale gateway view
+    // and fall back to local resolution (which has the fresh channel) rather
+    // than downgrade the just-activated invitee to unknown.
+    mockMidCallVerdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "+15559999999",
+    };
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello there."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_unknown",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+    // Local resolver produced the final context; the unknown verdict was not
+    // consumed as authoritative.
+    expect(trustVerdictMapperUsed).toBe(false);
+    expect(readControllerTrustClass(relay)).toBeDefined();
+
+    relay.destroy();
+  });
+
+  function readControllerMemberStatus(
+    relay: RelayConnection,
+  ): string | undefined {
+    return (
+      relay.getController() as unknown as {
+        trustContext?: { memberStatus?: string };
+      }
+    )?.trustContext?.memberStatus;
+  }
+
+  test("inbound guardian verification: memberful blocked unknown verdict is honored (verdict path enforces blocked status)", async () => {
+    ensureConversation("conv-midcall-verdict-blocked");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-blocked",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello there."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    // Setup resolves locally (no verdict) so the pending guardian challenge
+    // drives verification rather than denying at the door.
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_blocked",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    // The gateway classifies a blocked member as trustClass "unknown" but still
+    // carries contactId/channelId and the deny ACL. This memberful unknown must
+    // take the verdict path on mid-call re-resolution so its blocked status is
+    // enforced — not fall back to local, which could miss a stale block.
+    mockMidCallVerdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "+15559999999",
+      contactId: "ct_blocked",
+      channelId: "ch_blocked",
+      status: "blocked",
+      policy: "deny",
+    };
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+    // Verdict path consumed the memberful unknown verdict; blocked status lands.
+    expect(trustVerdictMapperUsed).toBe(true);
+    expect(readControllerMemberStatus(relay)).toBe("blocked");
+
+    relay.destroy();
+  });
+
+  test("inbound guardian verification: memberful revoked unknown verdict is honored (verdict path enforces revoked status)", async () => {
+    ensureConversation("conv-midcall-verdict-revoked");
+    const session = createCallSession({
+      conversationId: "conv-midcall-verdict-revoked",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello there."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_verdict_revoked",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    mockMidCallVerdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "+15559999999",
+      contactId: "ct_revoked",
+      channelId: "ch_revoked",
+      status: "revoked",
+      policy: "deny",
+    };
+
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+    expect(trustVerdictMapperUsed).toBe(true);
+    expect(readControllerMemberStatus(relay)).toBe("revoked");
+
+    relay.destroy();
+  });
+
+  test("a prompt arriving during the mid-call re-resolution await is deferred and runs under the upgraded trust", async () => {
+    ensureConversation("conv-midcall-race");
+    const session = createCallSession({
+      conversationId: "conv-midcall-race",
+      provider: "twilio",
+      fromNumber: "+15559999999",
+      toNumber: "+15551111111",
+    });
+
+    const secret = createPendingVoiceGuardianChallenge();
+
+    // Capture the controller's trust class at the moment a turn actually fires,
+    // so we can prove the deferred prompt did not run under the stale context.
+    const trustClassAtTurn: Array<string | undefined> = [];
+    mockSendMessage.mockImplementation((...args: unknown[]) => {
+      trustClassAtTurn.push(readControllerTrustClass(relay));
+      return createMockProviderResponse(["Hello, verified guardian!"])(
+        ...(args as Parameters<ReturnType<typeof createMockProviderResponse>>),
+      );
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Setup resolves locally (no verdict) so the pending challenge drives
+    // verification; the gated guardian verdict is armed only for the mid-call
+    // re-resolution below.
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_race",
+        from: "+15559999999",
+        to: "+15551111111",
+      }),
+    );
+
+    // The gateway verdict upgrades the caller to guardian, but the round-trip is
+    // slow — gate it so a prompt can land in the re-resolution await window.
+    mockMidCallVerdict = {
+      trustClass: "guardian",
+      canonicalSenderId: "+15559999999",
+      guardianExternalUserId: "+15559999999",
+      guardianPrincipalId: "+15559999999",
+    };
+    let releaseVerdict!: () => void;
+    mockMidCallVerdictGate = new Promise<void>((resolve) => {
+      releaseVerdict = resolve;
+    });
+
+    // Enter the gated re-resolution: the final DTMF digit triggers
+    // handleVerificationCodeResult, which awaits the slow verdict.
+    const digits = secret.split("");
+    for (const digit of digits.slice(0, -1)) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    const verificationDone = relay.handleMessage(
+      JSON.stringify({ type: "dtmf", digit: digits[digits.length - 1] }),
+    );
+    // Let the verdict await begin (connectionState is now "connected", guard set).
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(relay.getConnectionState()).toBe("connected");
+    // Trust is still stale (verdict gated) — caller is not yet guardian.
+    expect(readControllerTrustClass(relay)).not.toBe("guardian");
+
+    // Prompt arrives mid-await: it must be deferred, not processed under stale trust.
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "Are my appointments confirmed?",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+    // No turn yet — the prompt was buffered, not run under the stale context.
+    expect(trustClassAtTurn).toHaveLength(0);
+
+    // Release the verdict; re-resolution installs the upgraded context, then the
+    // deferred prompt is flushed and its turn runs under guardian trust.
+    releaseVerdict();
+    await verificationDone;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(readControllerTrustClass(relay)).toBe("guardian");
+    expect(trustClassAtTurn.length).toBeGreaterThan(0);
+    expect(trustClassAtTurn.every((c) => c === "guardian")).toBe(true);
+
+    relay.destroy();
+  });
+
+  test("invite redemption: a prompt buffered during re-resolution runs as a real turn after activation (not dropped)", async () => {
+    ensureConversation("conv-midcall-invite-flush");
+    const session = createCallSession({
+      conversationId: "conv-midcall-invite-flush",
+      provider: "twilio",
+      fromNumber: "+15558887777",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Alice"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558887777",
+      voiceCodeHash: hashVoiceCode(code),
+      voiceCodeDigits: 6,
+    });
+
+    const turnCountBefore = mockSendMessage.mock.calls.length;
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Sure, here you go."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_invite_flush",
+        from: "+15558887777",
+        to: "+15551111111",
+      }),
+    );
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // Gate the mid-call verdict so the prompt lands inside the re-resolution
+    // await, after activation flips connectionState to "connected".
+    let releaseVerdict!: () => void;
+    mockMidCallVerdictGate = new Promise<void>((resolve) => {
+      releaseVerdict = resolve;
+    });
+
+    const digits = code.split("");
+    for (const digit of digits.slice(0, -1)) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    const redemptionDone = relay.handleMessage(
+      JSON.stringify({ type: "dtmf", digit: digits[digits.length - 1] }),
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    // Activation already reached the terminal state before re-resolution.
+    expect(relay.getConnectionState()).toBe("connected");
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "What's on my calendar today?",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+    // Buffered, not yet run (verdict gated).
+    expect(mockSendMessage.mock.calls.length).toBe(turnCountBefore);
+
+    releaseVerdict();
+    await redemptionDone;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // Flushed onto the real-turn path: the prompt produced an LLM turn rather
+    // than being dropped by the verification-pending branch.
+    expect(mockSendMessage.mock.calls.length).toBeGreaterThan(turnCountBefore);
+
+    relay.destroy();
+  });
+
+  test("access-request approval: a prompt buffered during re-resolution runs as a real turn (not misrouted to wait-state)", async () => {
+    ensureConversation("conv-midcall-access-flush");
+    const session = createCallSession({
+      conversationId: "conv-midcall-access-flush",
+      provider: "twilio",
+      fromNumber: "+15557770003",
+      toNumber: "+15551111111",
+    });
+
+    const turnCountBefore = mockSendMessage.mock.calls.length;
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Sure, here you go."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_midcall_access_flush",
+        from: "+15557770003",
+        to: "+15551111111",
+      }),
+    );
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "Bob Smith",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+
+    // Gate the mid-call verdict so the prompt lands inside the re-resolution
+    // await triggered by the approval poll.
+    let releaseVerdict!: () => void;
+    mockMidCallVerdictGate = new Promise<void>((resolve) => {
+      releaseVerdict = resolve;
+    });
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "+15557770003",
+      sourceChannel: "phone",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+    resolveCanonicalGuardianRequest(pending[0].id, "pending", {
+      status: "approved",
+      answerText: undefined,
+      decidedByExternalUserId: undefined,
+    });
+
+    // Let the poll detect approval and enter the gated re-resolution.
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(relay.getConnectionState()).toBe("connected");
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "What's on my calendar today?",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+    // Buffered, not yet run (verdict gated).
+    expect(mockSendMessage.mock.calls.length).toBe(turnCountBefore);
+
+    releaseVerdict();
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // Flushed onto the real-turn path rather than the awaiting-guardian-decision
+    // wait-state classifier: the prompt produced an LLM turn.
+    expect(mockSendMessage.mock.calls.length).toBeGreaterThan(turnCountBefore);
+
+    relay.destroy();
+  });
 });