@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/approval-conversation-turn.test.ts

@@ -0,0 +1,214 @@
+import { describe, test, expect } from 'bun:test';
+import { runApprovalConversationTurn } from '../runtime/approval-conversation-turn.js';
+import type {
+  ApprovalConversationContext,
+  ApprovalConversationGenerator,
+  ApprovalConversationResult,
+} from '../runtime/http-types.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeContext(overrides: Partial<ApprovalConversationContext> = {}): ApprovalConversationContext {
+  return {
+    toolName: 'execute_shell',
+    allowedActions: ['approve_once', 'approve_always', 'reject'],
+    role: 'guardian',
+    pendingApprovals: [{ runId: 'run-1', toolName: 'execute_shell' }],
+    userMessage: 'yes, go ahead',
+    ...overrides,
+  };
+}
+
+function makeGenerator(result: ApprovalConversationResult): ApprovalConversationGenerator {
+  return async () => result;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('runApprovalConversationTurn', () => {
+  test('successful keep_pending response (non-decision message)', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext({ userMessage: 'what does this tool do?' }),
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'This tool runs shell commands. Would you like to approve it?',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toBe('This tool runs shell commands. Would you like to approve it?');
+    expect(result.targetRunId).toBeUndefined();
+  });
+
+  test('successful approve_once response', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved! Running the command now.',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('approve_once');
+    expect(result.replyText).toBe('Approved! Running the command now.');
+    expect(result.targetRunId).toBe('run-1');
+  });
+
+  test('successful reject response', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      makeGenerator({
+        disposition: 'reject',
+        replyText: 'Request denied.',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('reject');
+    expect(result.replyText).toBe('Request denied.');
+  });
+
+  test('fail-closed on generator throwing an error', async () => {
+    const throwingGenerator: ApprovalConversationGenerator = async () => {
+      throw new Error('provider timeout');
+    };
+    const result = await runApprovalConversationTurn(makeContext(), throwingGenerator);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed on generator returning malformed output', async () => {
+    const malformedGenerator: ApprovalConversationGenerator = async () => {
+      // Return an object missing the required replyText
+      return { disposition: 'approve_once', replyText: '' } as ApprovalConversationResult;
+    };
+    const result = await runApprovalConversationTurn(makeContext(), malformedGenerator);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed on invalid disposition', async () => {
+    const badDisposition: ApprovalConversationGenerator = async () => {
+      return { disposition: 'yolo' as 'approve_once', replyText: 'Sure!' };
+    };
+    const result = await runApprovalConversationTurn(makeContext(), badDisposition);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed when disposition is not in allowedActions', async () => {
+    // Context only allows approve_once and reject (no approve_always)
+    const restrictedContext = makeContext({
+      allowedActions: ['approve_once', 'reject'],
+    });
+
+    const result = await runApprovalConversationTurn(
+      restrictedContext,
+      makeGenerator({
+        disposition: 'approve_always',
+        replyText: 'Approved permanently!',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('keep_pending is always allowed regardless of allowedActions', async () => {
+    const restrictedContext = makeContext({
+      allowedActions: ['approve_once', 'reject'],
+    });
+
+    const result = await runApprovalConversationTurn(
+      restrictedContext,
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'Can you tell me more about this request?',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toBe('Can you tell me more about this request?');
+  });
+
+  test('fail-closed when single pending approval and hallucinated targetRunId', async () => {
+    // Only one pending approval, but model returns a non-matching targetRunId
+    const result = await runApprovalConversationTurn(
+      makeContext({
+        pendingApprovals: [{ runId: 'run-1', toolName: 'execute_shell' }],
+      }),
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-nonexistent',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed when targetRunId does not match any pending approval', async () => {
+    const contextWithMultiple = makeContext({
+      pendingApprovals: [
+        { runId: 'run-1', toolName: 'execute_shell' },
+        { runId: 'run-2', toolName: 'file_write' },
+      ],
+    });
+
+    // Hallucinated run ID that doesn't match any pending approval
+    const result = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-nonexistent',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('targetRunId validation when multiple pending approvals', async () => {
+    const contextWithMultiple = makeContext({
+      pendingApprovals: [
+        { runId: 'run-1', toolName: 'execute_shell' },
+        { runId: 'run-2', toolName: 'file_write' },
+      ],
+    });
+
+    // Decision-bearing disposition without targetRunId should fail-close
+    const resultWithoutTarget = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        // no targetRunId
+      }),
+    );
+    expect(resultWithoutTarget.disposition).toBe('keep_pending');
+    expect(resultWithoutTarget.replyText).toContain("couldn't process");
+
+    // Decision-bearing disposition with targetRunId should succeed
+    const resultWithTarget = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(resultWithTarget.disposition).toBe('approve_once');
+    expect(resultWithTarget.targetRunId).toBe('run-1');
+
+    // Non-decision disposition without targetRunId should pass through fine
+    const resultKeepPending = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'Which request would you like to approve?',
+      }),
+    );
+    expect(resultKeepPending.disposition).toBe('keep_pending');
+  });
+});

package/src/__tests__/approval-hardcoded-copy-guard.test.ts

@@ -0,0 +1,41 @@
+/**
+ * Guard test: ensures no production hard-coded approval lifecycle copy creeps
+ * back into route/service files outside of the composer module.
+ *
+ * The composer file (`approval-message-composer.ts`) is intentionally excluded
+ * since that is where deterministic fallback copy legitimately lives.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { describe, test, expect } from 'bun:test';
+
+const SCANNED_FILES = [
+  'runtime/channel-approvals.ts',
+  'runtime/routes/channel-routes.ts',
+  'runtime/channel-guardian-service.ts',
+];
+
+const BANNED_PATTERNS: { pattern: RegExp; description: string }[] = [
+  { pattern: /The assistant wants to use/i, description: 'old standard prompt' },
+  { pattern: /Do you want to allow this/i, description: 'old approval question' },
+  { pattern: /['"`]I'm still waiting/i, description: 'old reminder prefix (string literal)' },
+  { pattern: /['"`].*is requesting to run/i, description: 'old guardian prompt (string literal)' },
+  { pattern: /['"`]Sent to guardian/i, description: 'old forwarding notice (string literal)' },
+  { pattern: /['"`]Guardian verified successfully/i, description: 'old verify success (string literal)' },
+  { pattern: /['"`]Verification failed/i, description: 'old verify failure (string literal)' },
+  { pattern: /['"`]Your request has been sent/i, description: 'old request forwarded notice (string literal)' },
+  { pattern: /['"`]No guardian is configured/i, description: 'old no-binding notice (string literal)' },
+];
+
+describe('approval hardcoded copy guard', () => {
+  for (const file of SCANNED_FILES) {
+    test(`${file} does not contain banned approval copy literals`, () => {
+      const content = readFileSync(join(__dirname, '..', file), 'utf-8');
+      for (const { pattern, description: _description } of BANNED_PATTERNS) {
+        const match = content.match(pattern);
+        expect(match).toBeNull();
+      }
+    });
+  }
+});

package/src/__tests__/approval-message-composer.test.ts

@@ -0,0 +1,253 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  composeApprovalMessage,
+  getFallbackMessage,
+} from '../runtime/approval-message-composer.js';
+import type {
+  ApprovalMessageScenario,
+  ApprovalMessageContext,
+} from '../runtime/approval-message-composer.js';
+
+// ---------------------------------------------------------------------------
+// Every scenario must produce a non-empty string
+// ---------------------------------------------------------------------------
+
+const ALL_SCENARIOS: ApprovalMessageScenario[] = [
+  'standard_prompt',
+  'guardian_prompt',
+  'reminder_prompt',
+  'guardian_delivery_failed',
+  'guardian_request_forwarded',
+  'guardian_disambiguation',
+  'guardian_identity_mismatch',
+  'request_pending_guardian',
+  'guardian_decision_outcome',
+  'guardian_expired_requester',
+  'guardian_expired_guardian',
+  'guardian_verify_success',
+  'guardian_verify_failed',
+  'guardian_verify_challenge_setup',
+  'guardian_verify_status_bound',
+  'guardian_verify_status_unbound',
+  'guardian_deny_no_identity',
+  'guardian_deny_no_binding',
+];
+
+describe('approval-message-composer', () => {
+  // -----------------------------------------------------------------------
+  // Fallback messages — every scenario produces non-empty output
+  // -----------------------------------------------------------------------
+
+  describe('getFallbackMessage', () => {
+    for (const scenario of ALL_SCENARIOS) {
+      test(`scenario "${scenario}" produces a non-empty string`, () => {
+        const msg = getFallbackMessage({ scenario });
+        expect(typeof msg).toBe('string');
+        expect(msg.trim().length).toBeGreaterThan(0);
+      });
+    }
+
+    test('standard_prompt includes toolName when provided', () => {
+      const msg = getFallbackMessage({
+        scenario: 'standard_prompt',
+        toolName: 'execute_shell',
+      });
+      expect(msg).toContain('execute_shell');
+    });
+
+    test('guardian_prompt includes requester identifier and toolName', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_prompt',
+        toolName: 'write_file',
+        requesterIdentifier: 'alice',
+      });
+      expect(msg).toContain('alice');
+      expect(msg).toContain('write_file');
+    });
+
+    test('guardian_delivery_failed includes toolName when provided', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_delivery_failed',
+        toolName: 'execute_shell',
+      });
+      expect(msg).toContain('execute_shell');
+    });
+
+    test('guardian_request_forwarded includes toolName', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_request_forwarded',
+        toolName: 'execute_shell',
+      });
+      expect(msg).toContain('execute_shell');
+    });
+
+    test('guardian_disambiguation includes pendingCount', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_disambiguation',
+        pendingCount: 3,
+      });
+      expect(msg).toContain('3');
+    });
+
+    test('guardian_decision_outcome includes decision and toolName', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_decision_outcome',
+        decision: 'approved',
+        toolName: 'read_file',
+      });
+      expect(msg).toContain('approved');
+      expect(msg).toContain('read_file');
+    });
+
+    test('guardian_expired_requester includes toolName', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_expired_requester',
+        toolName: 'deploy',
+      });
+      expect(msg).toContain('deploy');
+      expect(msg).toContain('expired');
+    });
+
+    test('guardian_expired_guardian includes requester and toolName', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_expired_guardian',
+        requesterIdentifier: 'bob',
+        toolName: 'delete_file',
+      });
+      expect(msg).toContain('bob');
+      expect(msg).toContain('delete_file');
+    });
+
+    test('guardian_verify_failed includes failureReason', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_verify_failed',
+        failureReason: 'Code did not match.',
+      });
+      expect(msg).toContain('Code did not match.');
+    });
+
+    test('guardian_verify_challenge_setup includes verifyCommand and ttlSeconds', () => {
+      const msg = getFallbackMessage({
+        scenario: 'guardian_verify_challenge_setup',
+        verifyCommand: '/verify abc123',
+        ttlSeconds: 30,
+      });
+      expect(msg).toContain('/verify abc123');
+      expect(msg).toContain('30');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // composeApprovalMessage — layered source selection
+  // -----------------------------------------------------------------------
+
+  describe('composeApprovalMessage', () => {
+    test('returns assistantPreface when provided (primary source)', () => {
+      const preface = 'The assistant already said something helpful.';
+      const msg = composeApprovalMessage({
+        scenario: 'standard_prompt',
+        toolName: 'execute_shell',
+        assistantPreface: preface,
+      });
+      expect(msg).toBe(preface);
+    });
+
+    test('ignores empty assistantPreface and falls back to template', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'standard_prompt',
+        toolName: 'execute_shell',
+        assistantPreface: '',
+      });
+      expect(msg).toContain('execute_shell');
+      expect(msg).not.toBe('');
+    });
+
+    test('ignores whitespace-only assistantPreface', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'standard_prompt',
+        toolName: 'execute_shell',
+        assistantPreface: '   ',
+      });
+      expect(msg).toContain('execute_shell');
+    });
+
+    test('falls back to deterministic template when no assistantPreface', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_prompt',
+        toolName: 'write_file',
+        requesterIdentifier: 'charlie',
+      });
+      expect(msg).toContain('charlie');
+      expect(msg).toContain('write_file');
+    });
+
+    test('fallback matches getFallbackMessage output', () => {
+      const ctx: ApprovalMessageContext = {
+        scenario: 'reminder_prompt',
+      };
+      expect(composeApprovalMessage(ctx)).toBe(getFallbackMessage(ctx));
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Verification scenario resilience — composed messages contain key facts
+  // -----------------------------------------------------------------------
+
+  describe('verification scenario resilience', () => {
+    test('guardian_verify_challenge_setup includes verify command and TTL', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_challenge_setup',
+        verifyCommand: '/guardian_verify abc123def456',
+        ttlSeconds: 600,
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+      expect(msg).toContain('/guardian_verify abc123def456');
+      expect(msg).toContain('600');
+    });
+
+    test('guardian_verify_failed includes failure reason', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_failed',
+        failureReason: 'Too many attempts. Please try again later.',
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+      expect(msg).toContain('Too many attempts');
+    });
+
+    test('guardian_verify_failed with invalid-or-expired reason includes that reason', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_failed',
+        failureReason: 'The verification code is invalid or has expired.',
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+      expect(msg).toContain('invalid or has expired');
+    });
+
+    test('guardian_verify_success produces a non-empty success message', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_success',
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+    });
+
+    test('guardian_verify_status_bound produces a non-empty message', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_status_bound',
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+    });
+
+    test('guardian_verify_status_unbound produces a non-empty message', () => {
+      const msg = composeApprovalMessage({
+        scenario: 'guardian_verify_status_unbound',
+      });
+      expect(typeof msg).toBe('string');
+      expect(msg.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/__tests__/browser-manager.test.ts

@@ -34,6 +34,7 @@ function createMockPage(closed = false) {
     keyboard: { press: async () => {} },
     mouse: { click: async () => {}, move: async () => {}, wheel: async () => {} },
     bringToFront: async () => {},
+    on: () => {},
   };
 }
 

package/src/__tests__/call-conversation-messages.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = mkdtempSync(join(tmpdir(), 'call-conversation-messages-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { conversations } from '../memory/schema.js';
+import { createCallSession, updateCallSession, recordCallEvent } from '../calls/call-store.js';
+import { getMessages } from '../memory/conversation-store.js';
+import { buildCallCompletionMessage, persistCallCompletionMessage } from '../calls/call-conversation-messages.js';
+
+initializeDb();
+
+function ensureConversation(id: string): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations).values({
+    id,
+    title: `Conversation ${id}`,
+    createdAt: now,
+    updatedAt: now,
+  }).run();
+}
+
+function resetTables(): void {
+  const db = getDb();
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM messages');
+  db.run('DELETE FROM conversations');
+}
+
+function getLatestAssistantText(conversationId: string): string {
+  const rows = getMessages(conversationId).filter((m) => m.role === 'assistant');
+  expect(rows.length).toBeGreaterThan(0);
+  const latest = rows[rows.length - 1];
+  const parsed = JSON.parse(latest.content) as Array<{ type: string; text?: string }>;
+  return parsed.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('');
+}
+
+describe('call-conversation-messages', () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  test('buildCallCompletionMessage labels failed calls correctly', () => {
+    const conversationId = 'conv-call-msg-failed';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'in_progress', startedAt: 1_000 });
+    updateCallSession(session.id, { status: 'failed', endedAt: 6_000 });
+    recordCallEvent(session.id, 'call_connected');
+    recordCallEvent(session.id, 'call_failed');
+
+    expect(buildCallCompletionMessage(session.id)).toBe('**Call failed** (5s). 2 event(s) recorded.');
+  });
+
+  test('buildCallCompletionMessage labels cancelled calls correctly', () => {
+    const conversationId = 'conv-call-msg-cancelled';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'in_progress', startedAt: 1_000 });
+    updateCallSession(session.id, { status: 'cancelled', endedAt: 4_000 });
+    recordCallEvent(session.id, 'call_connected');
+    recordCallEvent(session.id, 'call_ended');
+
+    expect(buildCallCompletionMessage(session.id)).toBe('**Call cancelled** (3s). 2 event(s) recorded.');
+  });
+
+  test('persistCallCompletionMessage keeps completed label when status is completed', () => {
+    const conversationId = 'conv-call-msg-completed';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'completed' });
+    recordCallEvent(session.id, 'call_ended');
+
+    const summary = persistCallCompletionMessage(conversationId, session.id);
+    expect(summary).toBe('**Call completed**. 1 event(s) recorded.');
+    expect(getLatestAssistantText(conversationId)).toBe('**Call completed**. 1 event(s) recorded.');
+  });
+});

package/src/__tests__/call-domain.test.ts

@@ -34,10 +34,10 @@ mock.module('../util/logger.js', () => ({
 }));
 
 mock.module('../calls/twilio-config.js', () => ({
-  getTwilioConfig: () => ({
+  getTwilioConfig: (assistantId?: string) => ({
     accountSid: 'AC_test',
     authToken: 'test_token',
-    phoneNumber: '+15550001111',
+    phoneNumber: assistantId === 'ast-alpha' ? '+15550003333' : '+15550001111',
     webhookBaseUrl: 'https://test.example.com',
     wssBaseUrl: 'wss://test.example.com',
   }),
@@ -97,6 +97,16 @@ describe('resolveCallerIdentity — strict implicit-default policy', () => {
     }
   });
 
+  test('assistant_number resolves from assistant-scoped Twilio number when assistantId is provided', async () => {
+    const result = await resolveCallerIdentity(makeConfig(), undefined, 'ast-alpha');
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.mode).toBe('assistant_number');
+      expect(result.fromNumber).toBe('+15550003333');
+      expect(result.source).toBe('implicit_default');
+    }
+  });
+
   test('explicit user_number succeeds when eligible', async () => {
     const result = await resolveCallerIdentity(
       makeConfig({ userNumber: '+15550002222' }),