@vellumai/assistant 0.3.4 → 0.3.5

package/src/__tests__/session-runtime-assembly.test.ts

@@ -3,12 +3,14 @@ import type { Message } from '../providers/types.js';
 import {
   applyRuntimeInjections,
   injectChannelCapabilityContext,
+  injectGuardianContext,
   injectTemporalContext,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
+  stripGuardianContext,
   stripTemporalContext,
 } from '../daemon/session-runtime-assembly.js';
-import type { ChannelCapabilities } from '../daemon/session-runtime-assembly.js';
+import type { ChannelCapabilities, GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
 import { buildChannelAwarenessSection } from '../config/system-prompt.js';
 
 // ---------------------------------------------------------------------------
@@ -277,6 +279,12 @@ describe('buildChannelAwarenessSection', () => {
     const section = buildChannelAwarenessSection();
     expect(section).toContain('computer-control permissions on non-dashboard');
   });
+
+  test('includes guardian context contract for channel actors', () => {
+    const section = buildChannelAwarenessSection();
+    expect(section).toContain('<guardian_context>');
+    expect(section).toContain('Never infer guardian status');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -474,3 +482,79 @@ describe('applyRuntimeInjections with temporalContext', () => {
     expect(result[0].content.length).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// guardian_context
+// ---------------------------------------------------------------------------
+
+describe('injectGuardianContext', () => {
+  const baseUserMessage: Message = {
+    role: 'user',
+    content: [{ type: 'text', text: 'Can you text me updates?' }],
+  };
+
+  test('prepends guardian_context block to user message', () => {
+    const ctx: GuardianRuntimeContext = {
+      sourceChannel: 'sms',
+      actorRole: 'guardian',
+      guardianExternalUserId: 'guardian-user-1',
+      guardianChatId: '+15550001111',
+      requesterIdentifier: '+15550001111',
+      requesterExternalUserId: 'guardian-user-1',
+      requesterChatId: '+15550001111',
+    };
+
+    const result = injectGuardianContext(baseUserMessage, ctx);
+    expect(result.content.length).toBe(2);
+    const injected = result.content[0];
+    expect(injected.type).toBe('text');
+    const text = (injected as { type: 'text'; text: string }).text;
+    expect(text).toContain('<guardian_context>');
+    expect(text).toContain('actor_role: guardian');
+    expect(text).toContain('source_channel: sms');
+    expect(text).toContain('</guardian_context>');
+  });
+});
+
+describe('stripGuardianContext', () => {
+  test('strips guardian_context blocks from user messages', () => {
+    const messages: Message[] = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: '<guardian_context>\nactor_role: guardian\n</guardian_context>' },
+          { type: 'text', text: 'Hello' },
+        ],
+      },
+    ];
+    const result = stripGuardianContext(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toHaveLength(1);
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toBe('Hello');
+  });
+});
+
+describe('applyRuntimeInjections with guardianContext', () => {
+  const baseMessages: Message[] = [
+    {
+      role: 'user',
+      content: [{ type: 'text', text: 'Help me send this over SMS.' }],
+    },
+  ];
+
+  test('injects guardian context when provided', () => {
+    const result = applyRuntimeInjections(baseMessages, {
+      guardianContext: {
+        sourceChannel: 'sms',
+        actorRole: 'non-guardian',
+        guardianExternalUserId: 'guardian-1',
+        requesterExternalUserId: 'requester-1',
+        requesterIdentifier: '+15550002222',
+        requesterChatId: '+15550002222',
+      },
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toHaveLength(2);
+    expect((result[0].content[0] as { type: 'text'; text: string }).text).toContain('<guardian_context>');
+  });
+});

package/src/__tests__/sms-messaging-provider.test.ts

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const sendSmsMock = mock(async (..._args: unknown[]) => ({ messageSid: 'SM-mock-sid', status: 'queued' }));
+const getOrCreateConversationMock = mock((_key: string) => ({ conversationId: 'conv-1' }));
+const upsertOutboundBindingMock = mock((_input: Record<string, unknown>) => {});
+
+let secureKeys: Record<string, string | undefined> = {
+  'credential:twilio:account_sid': 'AC1234567890',
+  'credential:twilio:auth_token': 'auth-token',
+};
+
+let configState: {
+  sms?: {
+    phoneNumber?: string;
+    assistantPhoneNumbers?: Record<string, string>;
+  };
+} = {
+  sms: {},
+};
+
+mock.module('../security/secure-keys.js', () => ({
+  getSecureKey: (key: string) => secureKeys[key],
+}));
+
+mock.module('../util/platform.js', () => ({
+  readHttpToken: () => 'runtime-token',
+}));
+
+mock.module('../config/loader.js', () => ({
+  loadConfig: () => configState,
+}));
+
+mock.module('../memory/conversation-key-store.js', () => ({
+  getOrCreateConversation: (key: string) => getOrCreateConversationMock(key),
+}));
+
+mock.module('../memory/external-conversation-store.js', () => ({
+  upsertOutboundBinding: (input: Record<string, unknown>) => upsertOutboundBindingMock(input),
+}));
+
+mock.module('../messaging/providers/sms/client.js', () => ({
+  sendMessage: (
+    gatewayUrl: string,
+    bearerToken: string,
+    to: string,
+    text: string,
+    assistantId?: string,
+  ) => sendSmsMock(gatewayUrl, bearerToken, to, text, assistantId),
+}));
+
+import { smsMessagingProvider } from '../messaging/providers/sms/adapter.js';
+
+describe('smsMessagingProvider', () => {
+  beforeEach(() => {
+    sendSmsMock.mockClear();
+    getOrCreateConversationMock.mockClear();
+    upsertOutboundBindingMock.mockClear();
+    secureKeys = {
+      'credential:twilio:account_sid': 'AC1234567890',
+      'credential:twilio:auth_token': 'auth-token',
+    };
+    configState = { sms: {} };
+    delete process.env.TWILIO_PHONE_NUMBER;
+    delete process.env.GATEWAY_INTERNAL_BASE_URL;
+    delete process.env.GATEWAY_PORT;
+  });
+
+  test('isConnected is true when assistant-scoped numbers exist', () => {
+    configState = {
+      sms: {
+        assistantPhoneNumbers: { 'ast-alpha': '+15550001111' },
+      },
+    };
+
+    expect(smsMessagingProvider.isConnected?.()).toBe(true);
+  });
+
+  test('sendMessage forwards explicit assistant scope and avoids outbound binding writes for non-self', async () => {
+    await smsMessagingProvider.sendMessage('', '+15550002222', 'hi', {
+      assistantId: 'ast-alpha',
+    });
+
+    expect(sendSmsMock).toHaveBeenCalledWith(
+      'http://127.0.0.1:7830',
+      'runtime-token',
+      '+15550002222',
+      'hi',
+      'ast-alpha',
+    );
+    expect(getOrCreateConversationMock).toHaveBeenCalledWith('asst:ast-alpha:sms:+15550002222');
+    expect(upsertOutboundBindingMock).not.toHaveBeenCalled();
+  });
+
+  test('sendMessage uses messageSid from gateway response as result ID', async () => {
+    sendSmsMock.mockImplementation(async () => ({ messageSid: 'SM-test-12345', status: 'queued' }));
+    const result = await smsMessagingProvider.sendMessage('', '+15550009999', 'sid test', {
+      assistantId: 'self',
+    });
+    expect(result.id).toBe('SM-test-12345');
+  });
+
+  test('sendMessage falls back to timestamp-based ID when messageSid is absent', async () => {
+    sendSmsMock.mockImplementation(async () => ({}));
+    const before = Date.now();
+    const result = await smsMessagingProvider.sendMessage('', '+15550009999', 'no sid', {
+      assistantId: 'self',
+    });
+    expect(result.id).toMatch(/^sms-\d+$/);
+    const ts = parseInt(result.id.replace('sms-', ''), 10);
+    expect(ts).toBeGreaterThanOrEqual(before);
+  });
+
+  test('sendMessage uses canonical self key and writes outbound binding for self scope', async () => {
+    await smsMessagingProvider.sendMessage('', '+15550003333', 'hello', {
+      assistantId: 'self',
+    });
+
+    expect(getOrCreateConversationMock).toHaveBeenCalledWith('sms:+15550003333');
+    expect(upsertOutboundBindingMock).toHaveBeenCalledWith({
+      conversationId: 'conv-1',
+      sourceChannel: 'sms',
+      externalChatId: '+15550003333',
+    });
+  });
+});

package/src/__tests__/twilio-routes.test.ts

@@ -87,7 +87,7 @@ import {
   updateCallSession,
   getCallEvents,
 } from '../calls/call-store.js';
-import { resolveRelayUrl, handleStatusCallback, handleVoiceWebhook } from '../calls/twilio-routes.js';
+import { resolveRelayUrl, buildWelcomeGreeting, handleStatusCallback, handleVoiceWebhook } from '../calls/twilio-routes.js';
 import { registerCallCompletionNotifier, unregisterCallCompletionNotifier } from '../calls/call-state.js';
 
 initializeDb();
@@ -119,14 +119,14 @@ function resetTables() {
   ensuredConvIds = new Set();
 }
 
-function createTestSession(convId: string, callSid: string) {
+function createTestSession(convId: string, callSid: string, task = 'test task') {
   ensureConversation(convId);
   const session = createCallSession({
     conversationId: convId,
     provider: 'twilio',
     fromNumber: '+15550001111',
     toNumber: '+15559998888',
-    task: 'test task',
+    task,
   });
   updateCallSession(session.id, { providerCallSid: callSid });
   return session;
@@ -416,6 +416,24 @@ describe('twilio webhook routes', () => {
     });
   });
 
+  describe('buildWelcomeGreeting', () => {
+    test('builds a contextual opener from task text', () => {
+      const greeting = buildWelcomeGreeting('check store hours for tomorrow');
+      expect(greeting).toBe('Hello, I am calling about check store hours for tomorrow. Is now a good time to talk?');
+    });
+
+    test('ignores appended Context block when building opener', () => {
+      const greeting = buildWelcomeGreeting('check store hours\n\nContext: Caller asked by email');
+      expect(greeting).toBe('Hello, I am calling about check store hours. Is now a good time to talk?');
+      expect(greeting).not.toContain('Context:');
+    });
+
+    test('uses configured greeting override when provided', () => {
+      const greeting = buildWelcomeGreeting('check store hours', 'Custom hello');
+      expect(greeting).toBe('Custom hello');
+    });
+  });
+
   // ── TwiML relay URL generation ──────────────────────────────────────
   // Call handleVoiceWebhook directly since direct routes are blocked.
 
@@ -446,6 +464,24 @@ describe('twilio webhook routes', () => {
       const twiml = await res.text();
       expect(twiml).toContain('wss://gateway.example.com/v1/calls/relay');
     });
+
+    test('TwiML welcome greeting is task-aware by default', async () => {
+      const session = createTestSession(
+        'conv-twiml-3',
+        'CA_twiml_3',
+        'confirm appointment time\n\nContext: Prior email thread',
+      );
+      const req = makeVoiceRequest(session.id, { CallSid: 'CA_twiml_3' });
+
+      const res = await handleVoiceWebhook(req);
+
+      expect(res.status).toBe(200);
+      const twiml = await res.text();
+      expect(twiml).toContain(
+        'welcomeGreeting="Hello, I am calling about confirm appointment time. Is now a good time to talk?"',
+      );
+      expect(twiml).not.toContain('Hello, how can I help you today?');
+    });
   });
 
   // ── Handler-level idempotency concurrency tests ─────────────────

package/src/__tests__/twitter-cli-error-shaping.test.ts

@@ -100,7 +100,7 @@ describe('CLI error shaping', () => {
 
   test('routed non-session error with suggestAlternative emits structured JSON', () => {
     const err = Object.assign(
-      new Error('OAuth is not configured. Set up OAuth credentials in Settings, or switch to browser strategy.'),
+      new Error('OAuth is not configured. Provide your X developer credentials here in the chat to set up OAuth, or switch to browser strategy.'),
       {
         pathUsed: 'oauth' as const,
         suggestAlternative: 'browser' as const,
@@ -110,7 +110,7 @@ describe('CLI error shaping', () => {
 
     expect(payload).toEqual({
       ok: false,
-      error: 'OAuth is not configured. Set up OAuth credentials in Settings, or switch to browser strategy.',
+      error: 'OAuth is not configured. Provide your X developer credentials here in the chat to set up OAuth, or switch to browser strategy.',
       pathUsed: 'oauth',
       suggestAlternative: 'browser',
     });

package/src/__tests__/web-search.test.ts

@@ -414,7 +414,7 @@ async function executeWebSearch(
 
   if (!apiKey) {
     return {
-      content: 'Error: No web search API key configured. Set PERPLEXITY_API_KEY or BRAVE_API_KEY environment variable, or configure a key in settings.',
+      content: 'Error: No web search API key configured. Provide a PERPLEXITY_API_KEY or BRAVE_API_KEY here in the chat using the secure credential prompt, or set it from the Settings page.',
       isError: true,
     };
   }

package/src/__tests__/work-item-output.test.ts

@@ -0,0 +1,110 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import type { Database } from 'bun:sqlite';
+import * as net from 'node:net';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const testDir = mkdtempSync(join(tmpdir(), 'work-item-output-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: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+mock.module('./indexer.js', () => ({
+  indexMessageNow: () => {},
+}));
+
+import { addMessage, createConversation } from '../memory/conversation-store.js';
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { createTask, createTaskRun, updateTaskRun } from '../tasks/task-store.js';
+import { createWorkItem, updateWorkItem } from '../work-items/work-item-store.js';
+import { handleWorkItemOutput } from '../daemon/handlers/work-items.js';
+import type { HandlerContext } from '../daemon/handlers/shared.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+});
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+describe('handleWorkItemOutput', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('uses only the latest assistant text block for summary output', () => {
+    const task = createTask({
+      title: 'Delete weather report',
+      template: 'Delete weather_report_task.txt',
+    });
+    const run = createTaskRun(task.id);
+    const item = createWorkItem({
+      taskId: task.id,
+      title: 'Delete weather_report_task.txt',
+    });
+    const conversation = createConversation('Task output test');
+
+    updateTaskRun(run.id, {
+      status: 'completed',
+      conversationId: conversation.id,
+      finishedAt: Date.now(),
+    });
+    updateWorkItem(item.id, {
+      status: 'awaiting_review',
+      lastRunId: run.id,
+      lastRunConversationId: conversation.id,
+      lastRunStatus: 'completed',
+    });
+
+    addMessage(conversation.id, 'assistant', JSON.stringify([
+      { type: 'text', text: "I'll need to delete the weather report file from your Documents folder. This will permanently remove it." },
+      { type: 'text', text: "Looks like that file has already been deleted — it's no longer there. I'll mark this task as done." },
+      { type: 'text', text: 'The file is already deleted, so the task is complete.' },
+    ]));
+
+    const sent: Array<{ type: string; [key: string]: unknown }> = [];
+    const socket = {} as net.Socket;
+    const ctx = {
+      send: (_socket: net.Socket, msg: { type: string; [key: string]: unknown }) => sent.push(msg),
+    } as unknown as HandlerContext;
+
+    handleWorkItemOutput({ type: 'work_item_output', id: item.id }, socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const response = sent[0];
+    expect(response.type).toBe('work_item_output_response');
+    expect(response.success).toBe(true);
+    expect((response.output as { summary: string }).summary).toBe('The file is already deleted, so the task is complete.');
+  });
+});

package/src/calls/call-domain.ts

@@ -51,6 +51,7 @@ export type StartCallInput = {
   task: string;
   context?: string;
   conversationId: string;
+  assistantId?: string;
   callerIdentityMode?: 'assistant_number' | 'user_number';
 };
 
@@ -87,7 +88,8 @@ export type CallerIdentityResult =
  * - If `requestedMode` is provided but overrides are disabled, return an error.
  * - Otherwise, always use `assistant_number` (implicit default).
  *
- * For `assistant_number`: uses the Twilio phone number from `getTwilioConfig()`.
+ * For `assistant_number`: uses the Twilio phone number from
+ *   `getTwilioConfig(assistantId)` so multi-assistant mappings are honored.
  *   No eligibility check is performed — this is a fast path.
  * For `user_number`: uses `config.calls.callerIdentity.userNumber` or the
  *   secure key `credential:twilio:user_phone_number`, then validates that the
@@ -96,6 +98,7 @@ export type CallerIdentityResult =
 export async function resolveCallerIdentity(
   config: AssistantConfig,
   requestedMode?: 'assistant_number' | 'user_number',
+  assistantId?: string,
 ): Promise<CallerIdentityResult> {
   const identityConfig = config.calls.callerIdentity;
   let mode: 'assistant_number' | 'user_number';
@@ -118,8 +121,8 @@ export async function resolveCallerIdentity(
   }
 
   if (mode === 'assistant_number') {
-    const twilioConfig = getTwilioConfig();
-    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber }, 'Resolved caller identity');
+    const twilioConfig = getTwilioConfig(assistantId);
+    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber, assistantId }, 'Resolved caller identity');
     return { ok: true, mode, fromNumber: twilioConfig.phoneNumber, source };
   }
 
@@ -175,7 +178,7 @@ export async function resolveCallerIdentity(
  * Initiate a new outbound call.
  */
 export async function startCall(input: StartCallInput): Promise<StartCallResult | CallError> {
-  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode } = input;
+  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode, assistantId = 'self' } = input;
 
   if (!phoneNumber || typeof phoneNumber !== 'string') {
     return { ok: false, error: 'phone_number is required and must be a string', status: 400 };
@@ -204,7 +207,7 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     const provider = new TwilioConversationRelayProvider();
 
     // Resolve which phone number to use as caller ID
-    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode);
+    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode, assistantId);
     if (!identityResult.ok) {
       return { ok: false, error: identityResult.error, status: 400 };
     }

package/src/calls/call-orchestrator.ts

@@ -26,9 +26,21 @@ const log = getLogger('call-orchestrator');
 
 type OrchestratorState = 'idle' | 'processing' | 'waiting_on_user' | 'speaking';
 
-const ASK_USER_REGEX = /\[ASK_USER:\s*(.+?)\]/;
+const ASK_USER_CAPTURE_REGEX = /\[ASK_USER:\s*(.+?)\]/;
+const ASK_USER_MARKER_REGEX = /\[ASK_USER:\s*.+?\]/g;
+const USER_ANSWERED_MARKER_REGEX = /\[USER_ANSWERED:\s*.+?\]/g;
+const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
+const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
 const END_CALL_MARKER = '[END_CALL]';
 
+function stripInternalSpeechMarkers(text: string): string {
+  return text
+    .replace(ASK_USER_MARKER_REGEX, '')
+    .replace(USER_ANSWERED_MARKER_REGEX, '')
+    .replace(USER_INSTRUCTION_MARKER_REGEX, '')
+    .replace(END_CALL_MARKER_REGEX, '');
+}
+
 export class CallOrchestrator {
   private callSessionId: string;
   private relay: RelayConnection;
@@ -314,8 +326,12 @@ export class CallOrchestrator {
           const afterBracket = ttsBuffer;
           const couldBeControl =
             '[ASK_USER:'.startsWith(afterBracket) ||
+            '[USER_ANSWERED:'.startsWith(afterBracket) ||
+            '[USER_INSTRUCTION:'.startsWith(afterBracket) ||
             '[END_CALL]'.startsWith(afterBracket) ||
             afterBracket.startsWith('[ASK_USER:') ||
+            afterBracket.startsWith('[USER_ANSWERED:') ||
+            afterBracket.startsWith('[USER_INSTRUCTION:') ||
             afterBracket === '[END_CALL' ||
             afterBracket.startsWith('[END_CALL]');
 
@@ -339,13 +355,8 @@ export class CallOrchestrator {
         if (!this.isCurrentRun(runVersion)) return;
         ttsBuffer += text;
 
-        // If the buffer contains a complete control marker, strip it
-        if (ASK_USER_REGEX.test(ttsBuffer)) {
-          ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '');
-        }
-        if (ttsBuffer.includes(END_CALL_MARKER)) {
-          ttsBuffer = ttsBuffer.replace(END_CALL_MARKER, '');
-        }
+        // Remove complete control markers before text reaches TTS.
+        ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
 
         flushSafeText(false);
       });
@@ -354,7 +365,7 @@ export class CallOrchestrator {
       if (!this.isCurrentRun(runVersion)) return;
 
       // Final sweep: strip any remaining control markers from the buffer
-      ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '').replace(END_CALL_MARKER, '');
+      ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
       if (ttsBuffer.length > 0) {
         this.relay.sendTextToken(ttsBuffer, false);
       }
@@ -371,7 +382,7 @@ export class CallOrchestrator {
       // Record the assistant response
       this.conversationHistory.push({ role: 'assistant', content: responseText });
       recordCallEvent(this.callSessionId, 'assistant_spoke', { text: responseText });
-      const spokenText = responseText.replace(ASK_USER_REGEX, '').replace(END_CALL_MARKER, '').trim();
+      const spokenText = stripInternalSpeechMarkers(responseText).trim();
       if (spokenText.length > 0) {
         const session = getCallSession(this.callSessionId);
         if (session) {
@@ -380,7 +391,7 @@ export class CallOrchestrator {
       }
 
       // Check for ASK_USER pattern
-      const askMatch = responseText.match(ASK_USER_REGEX);
+      const askMatch = responseText.match(ASK_USER_CAPTURE_REGEX);
       if (askMatch) {
         const questionText = askMatch[1];
         createPendingQuestion(this.callSessionId, questionText);

package/src/calls/twilio-config.ts

@@ -13,20 +13,26 @@ export interface TwilioConfig {
   wssBaseUrl: string;
 }
 
-export function getTwilioConfig(): TwilioConfig {
-  const accountSid = getSecureKey('credential:twilio:account_sid');
-  const authToken = getSecureKey('credential:twilio:auth_token');
-  const config = loadConfig();
+function resolveTwilioPhoneNumber(assistantId: string | undefined, config: ReturnType<typeof loadConfig>): string {
+  if (assistantId) {
+    const assistantPhone = config.sms?.assistantPhoneNumbers?.[assistantId];
+    if (assistantPhone) {
+      return assistantPhone;
+    }
+  }
 
-  // Phone number resolution priority:
+  // Global fallback order:
   // 1. TWILIO_PHONE_NUMBER env var (explicit override)
   // 2. config file sms.phoneNumber (primary storage)
   // 3. credential:twilio:phone_number secure key (backward-compat fallback)
-  const phoneNumber =
-    process.env.TWILIO_PHONE_NUMBER ||
-    config.sms?.phoneNumber ||
-    getSecureKey('credential:twilio:phone_number') ||
-    '';
+  return process.env.TWILIO_PHONE_NUMBER || config.sms?.phoneNumber || getSecureKey('credential:twilio:phone_number') || '';
+}
+
+export function getTwilioConfig(assistantId?: string): TwilioConfig {
+  const accountSid = getSecureKey('credential:twilio:account_sid');
+  const authToken = getSecureKey('credential:twilio:auth_token');
+  const config = loadConfig();
+  const phoneNumber = resolveTwilioPhoneNumber(assistantId, config);
   const webhookBaseUrl = getPublicBaseUrl(config);
 
   // Always use the centralized relay URL derived from the public ingress base URL.
@@ -45,7 +51,7 @@ export function getTwilioConfig(): TwilioConfig {
     throw new Error('Twilio credentials not configured. Set credential:twilio:account_sid and credential:twilio:auth_token via the credential_store tool.');
   }
   if (!phoneNumber) {
-    throw new Error('TWILIO_PHONE_NUMBER not configured.');
+    throw new Error('Twilio phone number not configured.');
   }
 
   log.debug('Twilio config loaded successfully');