@vellumai/assistant 0.3.3 → 0.3.5

package/src/__tests__/handlers-twilio-config.test.ts

@@ -523,6 +523,54 @@ describe('Twilio config handler', () => {
     }
   });
 
+  test('getTwilioConfig with assistantId prefers assistant-scoped mapping over global phone number', () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: {
+          'ast-alpha': '+15550000001',
+        },
+      },
+      ingress: { enabled: true, publicBaseUrl: 'https://test.ngrok.io' },
+    };
+
+    const savedEnv = process.env.TWILIO_PHONE_NUMBER;
+    delete process.env.TWILIO_PHONE_NUMBER;
+
+    try {
+      const config = getTwilioConfig('ast-alpha');
+      expect(config.phoneNumber).toBe('+15550000001');
+    } finally {
+      if (savedEnv !== undefined) process.env.TWILIO_PHONE_NUMBER = savedEnv;
+    }
+  });
+
+  test('getTwilioConfig with assistantId falls back to global number when mapping is missing', () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: {
+          'ast-alpha': '+15550000001',
+        },
+      },
+      ingress: { enabled: true, publicBaseUrl: 'https://test.ngrok.io' },
+    };
+
+    const savedEnv = process.env.TWILIO_PHONE_NUMBER;
+    delete process.env.TWILIO_PHONE_NUMBER;
+
+    try {
+      const config = getTwilioConfig('ast-beta');
+      expect(config.phoneNumber).toBe('+15551234567');
+    } finally {
+      if (savedEnv !== undefined) process.env.TWILIO_PHONE_NUMBER = savedEnv;
+    }
+  });
+
   // ── assign_number ───────────────────────────────────────────────────
 
   test('assign_number persists phone number to config', async () => {
@@ -958,6 +1006,79 @@ describe('Twilio config handler', () => {
     expect(body).toContain('new-tunnel.ngrok.io');
   });
 
+  test('ingress config update reconciles all unique assigned Twilio numbers (legacy + assistant mapping)', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: {
+          'ast-alpha': '+15551234567', // duplicate of legacy; should only sync once
+          'ast-beta': '+15553333333',
+        },
+      },
+    };
+
+    const fetchCalls: Array<{ url: string; method: string; body?: string }> = [];
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      fetchCalls.push({ url: urlStr, method: init?.method ?? 'GET', body: init?.body?.toString() });
+
+      if (urlStr.includes('/internal/telegram/reconcile')) {
+        return new Response('{}', { status: 200 });
+      }
+      if (urlStr.includes('IncomingPhoneNumbers.json?PhoneNumber=')) {
+        if (urlStr.includes('%2B15551234567')) {
+          return new Response(JSON.stringify({
+            incoming_phone_numbers: [{ sid: 'PN-legacy', phone_number: '+15551234567' }],
+          }), { status: 200 });
+        }
+        if (urlStr.includes('%2B15553333333')) {
+          return new Response(JSON.stringify({
+            incoming_phone_numbers: [{ sid: 'PN-beta', phone_number: '+15553333333' }],
+          }), { status: 200 });
+        }
+        return new Response(JSON.stringify({ incoming_phone_numbers: [] }), { status: 200 });
+      }
+      if (urlStr.includes('IncomingPhoneNumbers/PN-legacy.json') && init?.method === 'POST') {
+        return new Response(JSON.stringify({ sid: 'PN-legacy' }), { status: 200 });
+      }
+      if (urlStr.includes('IncomingPhoneNumbers/PN-beta.json') && init?.method === 'POST') {
+        return new Response(JSON.stringify({ sid: 'PN-beta' }), { status: 200 });
+      }
+      return new Response('{}', { status: 200 });
+    }) as typeof fetch;
+
+    const msg: IngressConfigRequest = {
+      type: 'ingress_config',
+      action: 'set',
+      publicBaseUrl: 'https://multi-number.ngrok.io',
+      enabled: true,
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleIngressConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; enabled: boolean };
+    expect(res.type).toBe('ingress_config_response');
+    expect(res.success).toBe(true);
+    expect(res.enabled).toBe(true);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const lookupCalls = fetchCalls.filter((c) => c.url.includes('IncomingPhoneNumbers.json?PhoneNumber='));
+    const lookedUpNumbers = lookupCalls
+      .map((c) => decodeURIComponent(c.url.split('PhoneNumber=')[1] ?? ''))
+      .sort();
+    expect(lookedUpNumbers).toEqual(['+15551234567', '+15553333333']);
+
+    const updateCalls = fetchCalls.filter((c) => c.method === 'POST' && c.url.includes('IncomingPhoneNumbers/PN-'));
+    const updatedSids = updateCalls.map((c) => (c.url.includes('PN-legacy') ? 'PN-legacy' : 'PN-beta')).sort();
+    expect(updatedSids).toEqual(['PN-beta', 'PN-legacy']);
+    expect(updateCalls[0]?.body ?? '').toContain('multi-number.ngrok.io');
+  });
+
   test('webhook sync failure on ingress update does not fail the ingress update', async () => {
     secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
     secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
@@ -1316,4 +1437,363 @@ describe('Twilio config handler', () => {
     expect(responseStr).not.toContain('AC_secret_account_sid_12345');
     expect(responseStr).not.toContain('secret_auth_token_67890');
   });
+
+  // ── sms_compliance_status ───────────────────────────────────────────
+
+  test('sms_compliance_status returns structured compliance data for toll-free number', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = { sms: { phoneNumber: '+18001234567' } };
+
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      // Phone number SID lookup
+      if (urlStr.includes('IncomingPhoneNumbers.json') && urlStr.includes('PhoneNumber=')) {
+        return new Response(JSON.stringify({
+          incoming_phone_numbers: [{ sid: 'PN123abc', phone_number: '+18001234567' }],
+        }), { status: 200 });
+      }
+      // Toll-free verification lookup
+      if (urlStr.includes('Tollfree/Verifications')) {
+        return new Response(JSON.stringify({
+          verifications: [{
+            sid: 'TF_VER_001',
+            status: 'TWILIO_APPROVED',
+            rejection_reason: null,
+            edit_allowed: false,
+          }],
+        }), { status: 200 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.numberType).toBe('toll_free');
+    expect(res.compliance!.verificationSid).toBe('TF_VER_001');
+    expect(res.compliance!.verificationStatus).toBe('TWILIO_APPROVED');
+  });
+
+  test('sms_compliance_status returns local_10dlc type for non-toll-free number without remote check', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = { sms: { phoneNumber: '+15551234567' } };
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.numberType).toBe('local_10dlc');
+    // No verification fields for non-toll-free
+    expect(res.compliance!.verificationSid).toBeUndefined();
+  });
+
+  test('sms_compliance_status returns error when no credentials', async () => {
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Twilio credentials not configured');
+  });
+
+  // ── sms_submit_tollfree_verification ────────────────────────────────
+
+  test('sms_submit_tollfree_verification validates required fields', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        // Missing all required fields
+        businessName: 'Test Biz',
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Missing required verification fields');
+    expect(res.error).toContain('tollfreePhoneNumberSid');
+  });
+
+  test('sms_submit_tollfree_verification defaults businessType to SOLE_PROPRIETOR', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    let capturedBody = '';
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications') && init?.method === 'POST') {
+        capturedBody = init?.body?.toString() ?? '';
+        return new Response(JSON.stringify({
+          sid: 'TF_VER_NEW',
+          status: 'PENDING_REVIEW',
+        }), { status: 201 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        tollfreePhoneNumberSid: 'PN123',
+        businessName: 'Test Biz',
+        businessWebsite: 'https://test.com',
+        notificationEmail: 'test@test.com',
+        useCaseCategories: ['CUSTOMER_CARE'],
+        useCaseSummary: 'Customer support messages',
+        productionMessageSample: 'Your order has shipped!',
+        optInImageUrls: ['https://test.com/optin.png'],
+        optInType: 'WEB_FORM',
+        messageVolume: '100',
+        // businessType NOT provided — should default to SOLE_PROPRIETOR
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.verificationSid).toBe('TF_VER_NEW');
+    expect(res.compliance!.verificationStatus).toBe('PENDING_REVIEW');
+
+    // Verify the default businessType was sent to Twilio
+    expect(capturedBody).toContain('BusinessType=SOLE_PROPRIETOR');
+  });
+
+  test('sms_submit_tollfree_verification rejects invalid useCaseCategories', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        tollfreePhoneNumberSid: 'PN123',
+        businessName: 'Test Biz',
+        businessWebsite: 'https://test.com',
+        notificationEmail: 'test@test.com',
+        useCaseCategories: ['INVALID_CATEGORY'],
+        useCaseSummary: 'Test',
+        productionMessageSample: 'Test message',
+        optInImageUrls: ['https://test.com/optin.png'],
+        optInType: 'WEB_FORM',
+        messageVolume: '100',
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Invalid useCaseCategories');
+    expect(res.error).toContain('INVALID_CATEGORY');
+  });
+
+  test('sms_submit_tollfree_verification returns error without verificationParams', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationParams is required');
+  });
+
+  // ── release_number ─────────────────────────────────────────────────
+
+  test('release_number clears config and secure keys', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    secureKeyStore['credential:twilio:phone_number'] = '+15551234567';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: { 'ast-alpha': '+15551234567' },
+      },
+    };
+
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      // Phone number SID lookup
+      if (urlStr.includes('IncomingPhoneNumbers.json') && urlStr.includes('PhoneNumber=')) {
+        return new Response(JSON.stringify({
+          incoming_phone_numbers: [{ sid: 'PN123abc', phone_number: '+15551234567' }],
+        }), { status: 200 });
+      }
+      // Phone number deletion
+      if (urlStr.includes('IncomingPhoneNumbers/PN123abc.json') && init?.method === 'DELETE') {
+        return new Response('', { status: 204 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; warning?: string };
+    expect(res.success).toBe(true);
+    expect(res.warning).toContain('Phone number released');
+
+    // Verify config was cleared
+    const sms = rawConfigStore.sms as Record<string, unknown>;
+    expect(sms.phoneNumber).toBeUndefined();
+    expect(sms.assistantPhoneNumbers).toBeUndefined();
+
+    // Verify secure key was cleared
+    expect(secureKeyStore['credential:twilio:phone_number']).toBeUndefined();
+  });
+
+  test('release_number returns error when no credentials', async () => {
+    rawConfigStore = { sms: { phoneNumber: '+15551234567' } };
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Twilio credentials not configured');
+  });
+
+  test('release_number returns error when no phone number assigned', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {};
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('No phone number to release');
+  });
+
+  // ── sms_delete_tollfree_verification ────────────────────────────────
+
+  test('sms_delete_tollfree_verification requires verificationSid', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_delete_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationSid is required');
+  });
+
+  test('sms_delete_tollfree_verification includes queue warning', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications/TF_VER_001') && init?.method === 'DELETE') {
+        return new Response('', { status: 204 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_delete_tollfree_verification',
+      verificationSid: 'TF_VER_001',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; warning?: string };
+    expect(res.success).toBe(true);
+    expect(res.warning).toContain('review queue');
+  });
+
+  // ── sms_update_tollfree_verification ────────────────────────────────
+
+  test('sms_update_tollfree_verification requires verificationSid', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_update_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationSid is required');
+  });
 });

package/src/__tests__/ipc-snapshot.test.ts

@@ -382,6 +382,12 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'twilio_config',
     action: 'get',
   },
+  channel_readiness: {
+    type: 'channel_readiness',
+    action: 'get',
+    channel: 'sms',
+    includeRemote: true,
+  },
   guardian_verification: {
     type: 'guardian_verification',
     action: 'create_challenge',
@@ -564,6 +570,17 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
   tool_names_list: {
     type: 'tool_names_list',
   },
+  dictation_request: {
+    type: 'dictation_request',
+    transcription: 'Hello world',
+    context: {
+      bundleIdentifier: 'com.example.app',
+      appName: 'Example App',
+      windowTitle: 'Main Window',
+      selectedText: 'some selected text',
+      cursorInTextField: true,
+    },
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -824,6 +841,11 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     sessionId: 'sess-routed-001',
     interactionType: 'computer_use',
   },
+  ride_shotgun_progress: {
+    type: 'ride_shotgun_progress',
+    watchId: 'watch-shotgun-001',
+    message: 'Observing user activity...',
+  },
   ride_shotgun_result: {
     type: 'ride_shotgun_result',
     sessionId: 'sess-shotgun-001',
@@ -1227,6 +1249,41 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     success: true,
     hasCredentials: true,
     phoneNumber: '+15551234567',
+    compliance: {
+      numberType: 'toll_free',
+      verificationSid: 'TF_VER_001',
+      verificationStatus: 'TWILIO_APPROVED',
+    },
+    testResult: {
+      messageSid: 'SM-test-001',
+      to: '+15559876543',
+      initialStatus: 'queued',
+      finalStatus: 'delivered',
+    },
+    diagnostics: {
+      readiness: { ready: true, issues: [] },
+      compliance: { status: 'TWILIO_APPROVED', detail: 'Toll-free verification: TWILIO_APPROVED' },
+      overallStatus: 'healthy',
+      actionItems: [],
+    },
+  },
+  channel_readiness_response: {
+    type: 'channel_readiness_response',
+    success: true,
+    snapshots: [
+      {
+        channel: 'sms',
+        ready: false,
+        checkedAt: 1700000000000,
+        stale: false,
+        reasons: [{ code: 'twilio_credentials', text: 'Twilio credentials are not configured' }],
+        localChecks: [
+          { name: 'twilio_credentials', passed: false, message: 'Twilio credentials are not configured' },
+          { name: 'phone_number', passed: true, message: 'Phone number is assigned' },
+          { name: 'ingress', passed: true, message: 'Public ingress URL is configured' },
+        ],
+      },
+    ],
   },
   guardian_verification_response: {
     type: 'guardian_verification_response',
@@ -1608,6 +1665,12 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     type: 'tool_names_list_response',
     names: ['bash', 'file_read', 'file_write'],
   },
+  dictation_response: {
+    type: 'dictation_response',
+    text: 'Hello world',
+    mode: 'dictation',
+    actionPlan: undefined,
+  },
 };
 
 // ---------------------------------------------------------------------------

package/src/__tests__/messaging-send-tool.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import type { MessagingProvider } from '../messaging/provider.js';
+import type { SendOptions } from '../messaging/provider-types.js';
+
+const sendMessageMock = mock(async (..._args: unknown[]) => ({
+  id: 'msg-1',
+  timestamp: 123,
+  conversationId: 'conv-1',
+}));
+
+const provider: MessagingProvider = {
+  id: 'sms',
+  displayName: 'SMS',
+  credentialService: 'twilio',
+  capabilities: new Set(['send']),
+  testConnection: async () => ({ connected: true, user: 'x', platform: 'sms' }),
+  listConversations: async () => [],
+  getHistory: async () => [],
+  search: async () => ({ total: 0, messages: [], hasMore: false }),
+  sendMessage: (token: string, conversationId: string, text: string, options?: SendOptions) =>
+    sendMessageMock(token, conversationId, text, options),
+};
+
+mock.module('../config/bundled-skills/messaging/tools/shared.js', () => ({
+  resolveProvider: () => provider,
+  withProviderToken: async (_provider: MessagingProvider, fn: (token: string) => Promise<unknown>) => fn('provider-token'),
+  ok: (content: string) => ({ content, isError: false }),
+  err: (content: string) => ({ content, isError: true }),
+}));
+
+import { run } from '../config/bundled-skills/messaging/tools/messaging-send.js';
+
+describe('messaging-send tool', () => {
+  beforeEach(() => {
+    sendMessageMock.mockClear();
+  });
+
+  test('passes assistantId from tool context to provider send options', async () => {
+    const result = await run(
+      {
+        platform: 'sms',
+        conversation_id: '+15550004444',
+        text: 'test message',
+      },
+      {
+        workingDir: '/tmp',
+        sessionId: 'sess-1',
+        conversationId: 'conv-1',
+        assistantId: 'ast-alpha',
+      },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(sendMessageMock).toHaveBeenCalledWith(
+      'provider-token',
+      '+15550004444',
+      'test message',
+      {
+        subject: undefined,
+        inReplyTo: undefined,
+        assistantId: 'ast-alpha',
+      },
+    );
+  });
+});

package/src/__tests__/run-orchestrator-assistant-events.test.ts

@@ -68,6 +68,8 @@ function makeSessionEmittingViaClient(...messages: ServerMessage[]): Session {
     persistUserMessage: () => undefined as unknown as string,
     memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
     setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setGuardianContext: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },
@@ -90,6 +92,8 @@ function makeSessionEmittingViaAgentLoop(...messages: ServerMessage[]): Session
     persistUserMessage: () => undefined as unknown as string,
     memoryPolicy: { scopeId: 'default', includeDefaultFallback: false, strictSideEffects: false },
     setChannelCapabilities: () => {},
+    setAssistantId: () => {},
+    setGuardianContext: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       for (const msg of messages) {