@vellumai/assistant 0.4.26 → 0.4.30

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

@@ -22,6 +22,7 @@ import {
   beforeEach,
   describe,
   expect,
+  jest,
   type Mock,
   mock,
   test,
@@ -58,6 +59,13 @@ mock.module("../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockAssistantName,
 }));
 
+// ── User-reference mock (isolate from real USER.md) ──────────────────
+
+mock.module("../config/user-reference.js", () => ({
+  resolveUserReference: () => "my human",
+  resolveUserPronouns: () => null,
+}));
+
 // ── Config mock ─────────────────────────────────────────────────────
 
 const mockConfig = {
@@ -164,18 +172,21 @@ import {
   RelayConnection,
 } from "../calls/relay-server.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
+import {
+  createGuardianBinding,
+  upsertMember,
+} from "../contacts/contacts-write.js";
 import {
   listCanonicalGuardianRequests,
   resolveCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
 import {
-  createBinding,
   createChallenge,
+  createVerificationSession,
 } from "../memory/channel-guardian-store.js";
 import { addMessage, getMessages } from "../memory/conversation-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { createInvite } from "../memory/ingress-invite-store.js";
-import { upsertMember } from "../memory/ingress-member-store.js";
+import { getDb, initializeDb, resetDb, resetTestTables } from "../memory/db.js";
+import { createInvite } from "../memory/invite-store.js";
 import { conversations } from "../memory/schema.js";
 import {
   createOutboundSession,
@@ -241,22 +252,23 @@ function ensureConversation(id: string): void {
 }
 
 function resetTables() {
-  const db = getDb();
-  db.run("DELETE FROM guardian_action_deliveries");
-  db.run("DELETE FROM guardian_action_requests");
-  db.run("DELETE FROM call_pending_questions");
-  db.run("DELETE FROM call_events");
-  db.run("DELETE FROM call_sessions");
-  db.run("DELETE FROM tool_invocations");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-  db.run("DELETE FROM assistant_ingress_members");
-  db.run("DELETE FROM assistant_ingress_invites");
-  db.run("DELETE FROM channel_guardian_verification_challenges");
-  db.run("DELETE FROM channel_guardian_bindings");
-  db.run("DELETE FROM channel_guardian_rate_limits");
-  db.run("DELETE FROM canonical_guardian_requests");
-  db.run("DELETE FROM canonical_guardian_deliveries");
+  resetTestTables(
+    "guardian_action_deliveries",
+    "guardian_action_requests",
+    "call_pending_questions",
+    "call_events",
+    "call_sessions",
+    "tool_invocations",
+    "messages",
+    "conversations",
+    "assistant_ingress_invites",
+    "channel_guardian_verification_challenges",
+    "channel_guardian_rate_limits",
+    "canonical_guardian_requests",
+    "canonical_guardian_deliveries",
+    "contact_channels",
+    "contacts",
+  );
   ensuredConvIds = new Set();
 }
 
@@ -370,7 +382,7 @@ describe("relay-server", () => {
           },
           setChannelCapabilities: () => {},
           setAssistantId: () => {},
-          setGuardianContext: () => {},
+          setTrustContext: () => {},
           setCommandIntent: () => {},
           setTurnChannelContext: () => {},
           setVoiceCallControlPrompt: () => {},
@@ -869,7 +881,7 @@ describe("relay-server", () => {
     );
 
     // Let the delayed endSession callback flush to avoid timer bleed across tests.
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     const finalState = getCallSession(session.id);
     expect(finalState).not.toBeNull();
@@ -1454,12 +1466,13 @@ describe("relay-server", () => {
       assistantId: "self",
     });
 
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "voice",
       guardianExternalUserId: "+15550001111",
       guardianDeliveryChatId: "+15550001111",
       guardianPrincipalId: "+15550001111",
+      verifiedVia: "test",
     });
 
     mockSendMessage.mockImplementation(
@@ -1479,13 +1492,13 @@ describe("relay-server", () => {
 
     const runtimeContext = (
       relay.getController() as unknown as {
-        guardianContext?: {
+        trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
           guardianExternalUserId?: string;
         };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(runtimeContext?.sourceChannel).toBe("voice");
     expect(runtimeContext?.trustClass).toBe("guardian");
     expect(runtimeContext?.guardianExternalUserId).toBe("+15550001111");
@@ -1503,12 +1516,13 @@ describe("relay-server", () => {
       assistantId: "self",
     });
 
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "voice",
       guardianExternalUserId: "+15550009999",
       guardianDeliveryChatId: "+15550009999",
       guardianPrincipalId: "+15550009999",
+      verifiedVia: "test",
     });
     addTrustedVoiceContact("+15550002222", "self");
 
@@ -1529,14 +1543,14 @@ describe("relay-server", () => {
 
     const runtimeContext = (
       relay.getController() as unknown as {
-        guardianContext?: {
+        trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
           guardianExternalUserId?: string;
           requesterExternalUserId?: string;
         };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(runtimeContext?.sourceChannel).toBe("voice");
     expect(runtimeContext?.trustClass).toBe("trusted_contact");
     expect(runtimeContext?.guardianExternalUserId).toBe("+15550009999");
@@ -1557,12 +1571,13 @@ describe("relay-server", () => {
       initiatedFromConversationId: "conv-guardian-outbound-voice-origin",
     });
 
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "voice",
       guardianExternalUserId: "+15550001111",
       guardianDeliveryChatId: "+15550001111",
       guardianPrincipalId: "+15550001111",
+      verifiedVia: "test",
     });
 
     mockSendMessage.mockImplementation(
@@ -1582,13 +1597,13 @@ describe("relay-server", () => {
 
     const runtimeContext = (
       relay.getController() as unknown as {
-        guardianContext?: {
+        trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
           guardianExternalUserId?: string;
         };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(runtimeContext?.sourceChannel).toBe("voice");
     expect(runtimeContext?.trustClass).toBe("guardian");
     expect(runtimeContext?.guardianExternalUserId).toBe("+15550001111");
@@ -1608,12 +1623,13 @@ describe("relay-server", () => {
       initiatedFromConversationId: "conv-guardian-outbound-strict-origin",
     });
 
-    createBinding({
+    createGuardianBinding({
       assistantId: "self",
       channel: "telegram",
       guardianExternalUserId: "tg-guardian-user",
       guardianDeliveryChatId: "tg-guardian-chat",
       guardianPrincipalId: "tg-guardian-user",
+      verifiedVia: "test",
     });
 
     // Number matches the configured owner number, but there is no active
@@ -1636,12 +1652,12 @@ describe("relay-server", () => {
 
     const runtimeContext = (
       relay.getController() as unknown as {
-        guardianContext?: {
+        trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
         };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(runtimeContext?.sourceChannel).toBe("voice");
     expect(runtimeContext?.trustClass).toBe("unknown");
 
@@ -1674,9 +1690,9 @@ describe("relay-server", () => {
 
     const preVerify = (
       relay.getController() as unknown as {
-        guardianContext?: { trustClass?: string };
+        trustContext?: { trustClass?: string };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(preVerify?.trustClass).toBe("unknown");
 
     await relay.handleMessage(
@@ -1692,13 +1708,13 @@ describe("relay-server", () => {
 
     const postVerify = (
       relay.getController() as unknown as {
-        guardianContext?: {
+        trustContext?: {
           sourceChannel?: string;
           trustClass?: string;
           guardianExternalUserId?: string;
         };
       }
-    )?.guardianContext;
+    )?.trustContext;
     expect(postVerify?.sourceChannel).toBe("voice");
     expect(postVerify?.trustClass).toBe("guardian");
     expect(postVerify?.guardianExternalUserId).toBe(session.fromNumber);
@@ -1806,7 +1822,7 @@ describe("relay-server", () => {
     ).toBe(true);
 
     // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     // Verify end message was sent
     const endMessages = ws.sentMessages
@@ -1969,7 +1985,7 @@ describe("relay-server", () => {
     expect(originText).toContain("succeeded");
 
     // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     relay.destroy();
   });
@@ -2030,7 +2046,7 @@ describe("relay-server", () => {
     expect(originText).toContain("failed");
 
     // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     relay.destroy();
   });
@@ -2183,7 +2199,7 @@ describe("relay-server", () => {
     );
 
     // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     // Verify end message was sent
     const endMessages = ws.sentMessages
@@ -2326,15 +2342,16 @@ describe("relay-server", () => {
     // Should have transitioned to awaiting guardian decision
     expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Should have sent the hold message (guardian label defaults to "my human")
+    // Should have sent the hold message with guardian label and hold instruction.
+    // After the access request self-heals a vellum binding, the guardian label
+    // resolves to the vellum principal's display name rather than the static
+    // "my human" fallback, so we check structural copy without a specific label.
     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("I've let my human know"),
-      ),
-    ).toBe(true);
+    expect(textMessages.some((m) => (m.token ?? "").includes("I've let"))).toBe(
+      true,
+    );
     expect(
       textMessages.some((m) => (m.token ?? "").includes("Please hold")),
     ).toBe(true);
@@ -2491,7 +2508,7 @@ describe("relay-server", () => {
     ).toBe(true);
 
     // Let delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     relay.destroy();
   });
@@ -2711,7 +2728,7 @@ describe("relay-server", () => {
     ).toBe(true);
 
     // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     relay.destroy();
   });
@@ -2740,20 +2757,28 @@ describe("relay-server", () => {
       }),
     );
 
-    // Provide name
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Timeout Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      // Provide name
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Timeout Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Wait for timeout (2 seconds + buffer)
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout + endSession delay
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
+
+    // Let async fire-and-forget work settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     // Should be disconnecting after timeout
     expect(relay.getConnectionState()).toBe("disconnecting");
@@ -2782,9 +2807,6 @@ describe("relay-server", () => {
       events.some((e) => e.eventType === "inbound_acl_access_timeout"),
     ).toBe(true);
 
-    // Let the delayed endSession callback flush
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
     // Restore default timeout
     mockConfig.calls.userConsultTimeoutSeconds = 120;
 
@@ -3089,29 +3111,34 @@ describe("relay-server", () => {
       }),
     );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "OptIn Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "OptIn Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Trigger impatience to get callback offer
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Hurry up please",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Trigger impatience to get callback offer
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Hurry up please",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Wait for cooldown
-    await new Promise((resolve) => setTimeout(resolve, 3100));
+      // Advance past the 3s cooldown
+      jest.advanceTimersByTime(3200);
+    } finally {
+      jest.useRealTimers();
+    }
 
     const msgCountBeforeOptIn = ws.sentMessages.length;
 
@@ -3341,53 +3368,58 @@ describe("relay-server", () => {
       }),
     );
 
-    // Provide name to enter guardian wait
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Callback Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      // Provide name to enter guardian wait
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Callback Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Trigger impatience to get callback offer
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Hurry up please",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Trigger impatience to get callback offer
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Hurry up please",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Accept callback offer (callback decisions bypass cooldown)
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Yes, please call me back",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Accept callback offer (callback decisions bypass cooldown)
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Yes, please call me back",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Verify callback opt-in was set
-    const eventsBeforeTimeout = getCallEvents(session.id);
-    expect(
-      eventsBeforeTimeout.some(
-        (e) => e.eventType === "voice_guardian_wait_callback_opt_in_set",
-      ),
-    ).toBe(true);
+      // Verify callback opt-in was set
+      const eventsBeforeTimeout = getCallEvents(session.id);
+      expect(
+        eventsBeforeTimeout.some(
+          (e) => e.eventType === "voice_guardian_wait_callback_opt_in_set",
+        ),
+      ).toBe(true);
 
-    // Wait for timeout (2s) plus settling time
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout + endSession delay
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
 
-    expect(relay.getConnectionState()).toBe("disconnecting");
+    // Let async notification emission settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
-    // Allow async notification emission to complete
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(relay.getConnectionState()).toBe("disconnecting");
 
     const events = getCallEvents(session.id);
     // Should have exactly one callback_handoff_notified event (or callback_handoff_failed
@@ -3439,23 +3471,29 @@ describe("relay-server", () => {
       }),
     );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "No Callback Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "No Callback Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Wait for timeout without opting into callback
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout + endSession delay
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
 
-    expect(relay.getConnectionState()).toBe("disconnecting");
+    // Let async work settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(relay.getConnectionState()).toBe("disconnecting");
 
     const events = getCallEvents(session.id);
     // Should NOT have callback handoff events
@@ -3560,41 +3598,47 @@ describe("relay-server", () => {
       }),
     );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Race Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Race Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Opt into callback (callback decisions bypass cooldown)
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Hurry up please",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Opt into callback (callback decisions bypass cooldown)
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Hurry up please",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Yes call me back",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Yes call me back",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Wait for timeout to fire (2s) plus settling time
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
 
     // Now transport close too (simulating race)
     relay.handleTransportClosed(1000, "Normal closure");
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    // Let async work settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     const events = getCallEvents(session.id);
     // Guard should ensure only ONE handoff event
@@ -3632,45 +3676,51 @@ describe("relay-server", () => {
       }),
     );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Member Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Member Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Add the caller as a trusted contact AFTER the access request flow
-    // is entered so resolveActorTrust doesn't skip the flow. The handoff
-    // code uses findMember to resolve requesterMemberId at handoff time.
-    addTrustedVoiceContact("+15557770024");
+      // Add the caller as a trusted contact AFTER the access request flow
+      // is entered so resolveActorTrust doesn't skip the flow. The handoff
+      // code uses findMember to resolve requesterMemberId at handoff time.
+      addTrustedVoiceContact("+15557770024");
 
-    // Opt into callback (callback decisions bypass cooldown)
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Hurry up",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Opt into callback (callback decisions bypass cooldown)
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Hurry up",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Yes please call me back",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Yes please call me back",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Wait for timeout (2s) plus settling time
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    // Let async work settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     const events = getCallEvents(session.id);
     const handoffEvents = events.filter(
@@ -3719,40 +3769,46 @@ describe("relay-server", () => {
       }),
     );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "No Member Tester",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+    jest.useFakeTimers();
+    try {
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "No Member Tester",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
+      expect(relay.getConnectionState()).toBe("awaiting_guardian_decision");
 
-    // Opt into callback (callback decisions bypass cooldown)
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Come on hurry up",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      // Opt into callback (callback decisions bypass cooldown)
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Come on hurry up",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    await relay.handleMessage(
-      JSON.stringify({
-        type: "prompt",
-        voicePrompt: "Yes callback please",
-        lang: "en-US",
-        last: true,
-      }),
-    );
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "prompt",
+          voicePrompt: "Yes callback please",
+          lang: "en-US",
+          last: true,
+        }),
+      );
 
-    // Wait for timeout (2s) plus settling time
-    await new Promise((resolve) => setTimeout(resolve, 2500));
+      // Advance past the 2s timeout
+      jest.advanceTimersByTime(2500);
+    } finally {
+      jest.useRealTimers();
+    }
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    // Let async work settle
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     const events = getCallEvents(session.id);
     const handoffEvents = events.filter(
@@ -3850,4 +3906,227 @@ describe("relay-server", () => {
 
     relay.destroy();
   });
+
+  // ── Trusted-contact in-call continuation ─────────────────────────────
+
+  test("inbound trusted-contact verification: DTMF code entry continues same call with handoff copy", async () => {
+    ensureConversation("conv-tc-verify-continue");
+    const session = createCallSession({
+      conversationId: "conv-tc-verify-continue",
+      provider: "twilio",
+      fromNumber: "+15553334444",
+      toNumber: "+15551111111",
+      assistantId: "self",
+    });
+
+    // Create a trusted-contact verification challenge with status 'pending'
+    // so getPendingChallenge finds it during inbound setup, and
+    // verificationPurpose 'trusted_contact' so validateAndConsumeChallenge
+    // returns the correct verificationType.
+    const tcSecret = "654321";
+    createVerificationSession({
+      id: randomUUID(),
+      assistantId: "self",
+      channel: "voice",
+      challengeHash: createHash("sha256").update(tcSecret).digest("hex"),
+      expiresAt: Date.now() + 10 * 60 * 1000,
+      status: "pending",
+      verificationPurpose: "trusted_contact",
+    });
+    const secret = tcSecret;
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Sure, I can help with that."]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_tc_verify_continue",
+        from: "+15553334444",
+        to: "+15551111111",
+      }),
+    );
+
+    // Should be in verification-pending state
+    expect(relay.isGuardianVerificationActive()).toBe(true);
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // Enter the correct code via DTMF
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Verification should have succeeded — call remains connected
+    expect(relay.isGuardianVerificationActive()).toBe(false);
+    expect(relay.getConnectionState()).toBe("connected");
+
+    // Deterministic handoff copy should have been sent (not a fresh greeting)
+    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("said I can speak with you"),
+      ),
+    ).toBe(true);
+
+    // No end message should have been sent — call stays alive
+    const endMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string })
+      .filter((m) => m.type === "end");
+    expect(endMessages.length).toBe(0);
+
+    // assistant_spoke event should have been recorded for the handoff
+    const events = getCallEvents(session.id);
+    expect(events.some((e) => e.eventType === "assistant_spoke")).toBe(true);
+
+    // Session should be in_progress (not completed/failed)
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).toBe("in_progress");
+
+    relay.destroy();
+  });
+
+  test("inbound guardian verification (non-trusted-contact): still starts normal call flow", async () => {
+    ensureConversation("conv-guardian-verify-normal");
+    const session = createCallSession({
+      conversationId: "conv-guardian-verify-normal",
+      provider: "twilio",
+      fromNumber: "+15552223333",
+      toNumber: "+15551111111",
+      assistantId: "self",
+    });
+
+    // Create a guardian challenge (default verificationPurpose = 'guardian')
+    const secret = createPendingVoiceGuardianChallenge("self");
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help you?"]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_guardian_verify_normal",
+        from: "+15552223333",
+        to: "+15551111111",
+      }),
+    );
+
+    expect(relay.isGuardianVerificationActive()).toBe(true);
+
+    // Enter the correct code
+    for (const digit of secret) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Should have transitioned to connected with normal greeting (not handoff copy)
+    expect(relay.isGuardianVerificationActive()).toBe(false);
+    expect(relay.getConnectionState()).toBe("connected");
+
+    // Guardian binding should have been created
+    const binding = getGuardianBinding("self", "voice");
+    expect(binding).not.toBeNull();
+
+    // Normal greeting should fire (from mockSendMessage), not the handoff copy
+    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("how can I help")),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
+  test("invite redemption success: continues call with handoff copy instead of ending", async () => {
+    ensureConversation("conv-invite-continue");
+    const session = createCallSession({
+      conversationId: "conv-invite-continue",
+      provider: "twilio",
+      fromNumber: "+15557776666",
+      toNumber: "+15551111111",
+      assistantId: "self",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    createInvite({
+      assistantId: "self",
+      sourceChannel: "voice",
+      maxUses: 1,
+      expectedExternalUserId: "+15557776666",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+      friendName: "Eve",
+      guardianName: "Frank",
+    });
+
+    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_continue",
+        from: "+15557776666",
+        to: "+15551111111",
+      }),
+    );
+
+    // Should be in verification-pending for invite redemption
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // Enter the correct code via DTMF
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Call should remain connected
+    expect(relay.getConnectionState()).toBe("connected");
+
+    // Handoff copy should have been sent
+    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("said I can speak with you"),
+      ),
+    ).toBe(true);
+
+    // No end message — call stays alive
+    const endMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string })
+      .filter((m) => m.type === "end");
+    expect(endMessages.length).toBe(0);
+
+    // Session should be in_progress
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).toBe("in_progress");
+
+    // invite_redemption_succeeded event should exist
+    const events = getCallEvents(session.id);
+    expect(
+      events.some((e) => e.eventType === "invite_redemption_succeeded"),
+    ).toBe(true);
+
+    relay.destroy();
+  });
 });