@vellumai/assistant 0.3.27 → 0.4.0

package/src/__tests__/non-member-access-request.test.ts

@@ -80,11 +80,12 @@ mock.module('../runtime/gateway-client.js', () => ({
   },
 }));
 
+import { listCanonicalGuardianRequests } from '../memory/canonical-guardian-store.js';
 import {
   createBinding,
-  findPendingAccessRequestForRequester,
 } from '../memory/channel-guardian-store.js';
 import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { notifyGuardianOfAccessRequest } from '../runtime/access-request-helper.js';
 import { handleChannelInbound } from '../runtime/routes/channel-routes.js';
 
 initializeDb();
@@ -107,6 +108,8 @@ function resetState(): void {
   db.run('DELETE FROM channel_inbound_events');
   db.run('DELETE FROM conversations');
   db.run('DELETE FROM notification_events');
+  db.run('DELETE FROM canonical_guardian_requests');
+  db.run('DELETE FROM canonical_guardian_deliveries');
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
 }
@@ -152,9 +155,10 @@ describe('non-member access request notification', () => {
     expect(json.denied).toBe(true);
     expect(json.reason).toBe('not_a_member');
 
-    // Rejection reply was delivered
+    // Rejection reply was delivered — always-notify behavior means the reply
+    // indicates the guardian will be notified, even without a same-channel binding.
     expect(deliverReplyCalls.length).toBe(1);
-    expect((deliverReplyCalls[0].payload as Record<string, unknown>).text).toContain("you haven't been approved");
+    expect((deliverReplyCalls[0].payload as Record<string, unknown>).text).toContain("let them know");
   });
 
   test('guardian is notified when a non-member messages and a guardian binding exists', async () => {
@@ -185,18 +189,18 @@ describe('non-member access request notification', () => {
     expect(payload.senderExternalUserId).toBe('user-unknown-456');
     expect(payload.senderName).toBe('Alice Unknown');
 
-    // An approval request was created
-    const pending = findPendingAccessRequestForRequester(
-      'self',
-      'telegram',
-      'user-unknown-456',
-      'ingress_access_request',
-    );
-    expect(pending).not.toBeNull();
-    expect(pending!.status).toBe('pending');
-    expect(pending!.requesterExternalUserId).toBe('user-unknown-456');
-    expect(pending!.guardianExternalUserId).toBe('guardian-user-789');
-    expect(pending!.toolName).toBe('ingress_access_request');
+    // A canonical access request was created
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'user-unknown-456',
+      sourceChannel: 'telegram',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    expect(pending[0].status).toBe('pending');
+    expect(pending[0].requesterExternalUserId).toBe('user-unknown-456');
+    expect(pending[0].guardianExternalUserId).toBe('guardian-user-789');
+    expect(pending[0].toolName).toBe('ingress_access_request');
   });
 
   test('no duplicate approval requests for repeated messages from same non-member', async () => {
@@ -224,18 +228,19 @@ describe('non-member access request notification', () => {
     // Only one notification signal should be emitted (second is deduplicated)
     expect(emitSignalCalls.length).toBe(1);
 
-    // Only one approval request should exist
-    const pending = findPendingAccessRequestForRequester(
-      'self',
-      'telegram',
-      'user-unknown-456',
-      'ingress_access_request',
-    );
-    expect(pending).not.toBeNull();
+    // Only one canonical request should exist
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'user-unknown-456',
+      sourceChannel: 'telegram',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
   });
 
-  test('deny works without error when no guardian binding exists', async () => {
-    // No guardian binding — should deny without notification
+  test('access request is created and signal emitted even without same-channel guardian binding', async () => {
+    // No guardian binding on any channel — access request should still be
+    // created and notification signal emitted (null guardianExternalUserId).
     const req = buildInboundRequest();
     const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
     const json = await resp.json() as Record<string, unknown>;
@@ -243,20 +248,55 @@ describe('non-member access request notification', () => {
     expect(json.denied).toBe(true);
     expect(json.reason).toBe('not_a_member');
 
-    // Rejection reply was still delivered
+    // Rejection reply indicates guardian was notified
     expect(deliverReplyCalls.length).toBe(1);
+    expect((deliverReplyCalls[0].payload as Record<string, unknown>).text).toContain("let them know");
 
-    // No notification signal was emitted
-    expect(emitSignalCalls.length).toBe(0);
+    // Notification signal was emitted
+    expect(emitSignalCalls.length).toBe(1);
+    expect(emitSignalCalls[0].sourceEventName).toBe('ingress.access_request');
 
-    // No approval request was created
-    const pending = findPendingAccessRequestForRequester(
-      'self',
-      'telegram',
-      'user-unknown-456',
-      'ingress_access_request',
-    );
-    expect(pending).toBeNull();
+    // Canonical request was created with null guardianExternalUserId
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'user-unknown-456',
+      sourceChannel: 'telegram',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    expect(pending[0].guardianExternalUserId).toBeNull();
+  });
+
+  test('cross-channel fallback: SMS guardian binding resolves for Telegram access request', async () => {
+    // Only an SMS guardian binding exists — no Telegram binding
+    createBinding({
+      assistantId: 'self',
+      channel: 'sms',
+      guardianExternalUserId: 'guardian-sms-user',
+      guardianDeliveryChatId: 'guardian-sms-chat',
+    });
+
+    const req = buildInboundRequest();
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = await resp.json() as Record<string, unknown>;
+
+    expect(json.denied).toBe(true);
+    expect(json.reason).toBe('not_a_member');
+
+    // Notification signal emitted
+    expect(emitSignalCalls.length).toBe(1);
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.guardianBindingChannel).toBe('sms');
+
+    // Canonical request has the SMS guardian's external user ID
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'user-unknown-456',
+      sourceChannel: 'telegram',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    expect(pending[0].guardianExternalUserId).toBe('guardian-sms-user');
   });
 
   test('no notification when senderExternalUserId is absent', async () => {
@@ -279,3 +319,139 @@ describe('non-member access request notification', () => {
     expect(emitSignalCalls.length).toBe(0);
   });
 });
+
+describe('access-request-helper unit tests', () => {
+  beforeEach(() => {
+    resetState();
+  });
+
+  test('notifyGuardianOfAccessRequest returns no_sender_id when senderExternalUserId is absent', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: undefined,
+    });
+
+    expect(result.notified).toBe(false);
+    if (!result.notified) {
+      expect(result.reason).toBe('no_sender_id');
+    }
+
+    // No canonical request created
+    const pending = listCanonicalGuardianRequests({ status: 'pending', kind: 'access_request' });
+    expect(pending.length).toBe(0);
+  });
+
+  test('notifyGuardianOfAccessRequest creates request with null guardianExternalUserId when no binding exists', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'unknown-user',
+      senderName: 'Bob',
+    });
+
+    expect(result.notified).toBe(true);
+    if (result.notified) {
+      expect(result.created).toBe(true);
+    }
+
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'unknown-user',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    expect(pending[0].guardianExternalUserId).toBeNull();
+
+    // Signal was emitted
+    expect(emitSignalCalls.length).toBe(1);
+  });
+
+  test('notifyGuardianOfAccessRequest uses cross-channel binding when source-channel binding is missing', () => {
+    // Only SMS binding exists
+    createBinding({
+      assistantId: 'self',
+      channel: 'sms',
+      guardianExternalUserId: 'guardian-sms',
+      guardianDeliveryChatId: 'sms-chat',
+    });
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'tg-chat',
+      senderExternalUserId: 'unknown-tg-user',
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'unknown-tg-user',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    expect(pending[0].guardianExternalUserId).toBe('guardian-sms');
+
+    // Signal payload includes fallback channel
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.guardianBindingChannel).toBe('sms');
+  });
+
+  test('notifyGuardianOfAccessRequest prefers source-channel binding over cross-channel fallback', () => {
+    // Both Telegram and SMS bindings exist
+    createBinding({
+      assistantId: 'self',
+      channel: 'telegram',
+      guardianExternalUserId: 'guardian-tg',
+      guardianDeliveryChatId: 'tg-chat',
+    });
+    createBinding({
+      assistantId: 'self',
+      channel: 'sms',
+      guardianExternalUserId: 'guardian-sms',
+      guardianDeliveryChatId: 'sms-chat',
+    });
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'unknown-user',
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: 'unknown-user',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+    // Should use the Telegram binding, not SMS fallback
+    expect(pending[0].guardianExternalUserId).toBe('guardian-tg');
+
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.guardianBindingChannel).toBe('telegram');
+  });
+
+  test('notifyGuardianOfAccessRequest includes requestCode in contextPayload', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'unknown-user',
+      senderName: 'Test User',
+    });
+
+    expect(result.notified).toBe(true);
+    expect(emitSignalCalls.length).toBe(1);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.requestCode).toBeDefined();
+    expect(typeof payload.requestCode).toBe('string');
+    expect((payload.requestCode as string).length).toBe(6);
+  });
+});

package/src/__tests__/notification-decision-fallback.test.ts

@@ -5,7 +5,7 @@
  * decision-model call is unavailable.
  */
 
-import { describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
 
 mock.module('../channels/config.js', () => ({
   getDeliverableChannels: () => ['vellum', 'telegram', 'sms'],
@@ -13,6 +13,8 @@ mock.module('../channels/config.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     notifications: {
       decisionModelIntent: 'latency-optimized',
     },
@@ -32,13 +34,16 @@ mock.module('../notifications/thread-candidates.js', () => ({
   serializeCandidatesForPrompt: () => undefined,
 }));
 
+let configuredProvider: { sendMessage: () => Promise<unknown> } | null = null;
+let extractedToolUse: unknown = null;
+
 mock.module('../providers/provider-send-message.js', () => ({
-  getConfiguredProvider: () => null,
+  getConfiguredProvider: () => configuredProvider,
   createTimeout: () => ({
     signal: new AbortController().signal,
     cleanup: () => {},
   }),
-  extractToolUse: () => null,
+  extractToolUse: () => extractedToolUse,
   userMessage: (text: string) => ({ role: 'user', content: text }),
 }));
 
@@ -75,6 +80,11 @@ function makeSignal(overrides?: Partial<NotificationSignal>): NotificationSignal
 }
 
 describe('notification decision fallback copy', () => {
+  beforeEach(() => {
+    configuredProvider = null;
+    extractedToolUse = null;
+  });
+
   test('uses human-friendly template copy for guardian.question', async () => {
     const signal = makeSignal();
     const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
@@ -85,4 +95,54 @@ describe('notification decision fallback copy', () => {
     expect(decision.renderedCopy.vellum?.title).not.toBe('guardian.question');
     expect(decision.renderedCopy.vellum?.body).not.toContain('Action required: guardian.question');
   });
+
+  test('enforces request-code instructions for guardian.question when requestCode exists', async () => {
+    const signal = makeSignal({
+      contextPayload: {
+        questionText: 'What is the gate code?',
+        requestCode: 'A1B2C3',
+      },
+    });
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(true);
+    expect(decision.renderedCopy.vellum?.body).toContain('A1B2C3');
+    expect(decision.renderedCopy.vellum?.body).toContain('approve');
+    expect(decision.renderedCopy.vellum?.body).toContain('reject');
+  });
+
+  test('enforcement appends explicit approve/reject instructions when LLM copy only mentions request code', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Use reference code A1B2C3 for this request.',
+          },
+        },
+        dedupeKey: 'guardian-question-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        questionText: 'What is the gate code?',
+        requestCode: 'A1B2C3',
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
+  });
 });

package/src/__tests__/notification-decision-strategy.test.ts

@@ -55,6 +55,23 @@ describe('notification decision strategy', () => {
       expect(copy.vellum!.body).toContain('What is the gate code?');
     });
 
+    test('guardian.question template includes request-code instructions when present', () => {
+      const signal = makeSignal({
+        sourceEventName: 'guardian.question',
+        contextPayload: {
+          questionText: 'What is the gate code?',
+          requestCode: 'A1B2C3',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('A1B2C3');
+      expect(copy.vellum!.body).toContain('approve');
+      expect(copy.vellum!.body).toContain('reject');
+      expect(copy.telegram!.deliveryText).toContain('A1B2C3');
+    });
+
     test('reminder.fired template uses message from payload', () => {
       const signal = makeSignal({
         sourceEventName: 'reminder.fired',
@@ -134,6 +151,67 @@ describe('notification decision strategy', () => {
       expect(copy.vellum!.deliveryText).toBeUndefined();
     });
 
+    test('ingress.access_request template includes requester identifier', () => {
+      const signal = makeSignal({
+        sourceEventName: 'ingress.access_request',
+        contextPayload: {
+          senderIdentifier: 'Alice',
+          requestCode: 'A1B2C3',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.title).toBe('Access Request');
+      expect(copy.vellum!.body).toContain('Alice');
+      expect(copy.vellum!.body).toContain('requesting access');
+    });
+
+    test('ingress.access_request template includes request code instruction when present', () => {
+      const signal = makeSignal({
+        sourceEventName: 'ingress.access_request',
+        contextPayload: {
+          senderIdentifier: 'Bob',
+          requestCode: 'D4E5F6',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('D4E5F6');
+      expect(copy.vellum!.body).toContain('approve');
+      expect(copy.vellum!.body).toContain('reject');
+    });
+
+    test('ingress.access_request template includes invite flow instruction', () => {
+      const signal = makeSignal({
+        sourceEventName: 'ingress.access_request',
+        contextPayload: {
+          senderIdentifier: 'Charlie',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('open invite flow');
+    });
+
+    test('ingress.access_request Telegram deliveryText is concise', () => {
+      const signal = makeSignal({
+        sourceEventName: 'ingress.access_request',
+        contextPayload: {
+          senderIdentifier: 'Dave',
+          requestCode: 'ABC123',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, ['telegram']);
+      expect(copy.telegram).toBeDefined();
+      expect(copy.telegram!.deliveryText).toBeDefined();
+      expect(typeof copy.telegram!.deliveryText).toBe('string');
+      expect(copy.telegram!.deliveryText!.length).toBeGreaterThan(0);
+    });
+
     test('empty payload falls back to default text in template', () => {
       const signal = makeSignal({
         sourceEventName: 'guardian.question',

package/src/__tests__/notification-guardian-path.test.ts

@@ -47,6 +47,8 @@ mock.module('../memory/channel-guardian-store.js', () => ({
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    ui: {},
+    
     calls: {
       userConsultTimeoutSeconds: 120,
     },
@@ -108,6 +110,8 @@ function ensureConversation(id: string): void {
 
 function resetTables(): void {
   const db = getDb();
+  db.run('DELETE FROM canonical_guardian_deliveries');
+  db.run('DELETE FROM canonical_guardian_requests');
   db.run('DELETE FROM guardian_action_deliveries');
   db.run('DELETE FROM guardian_action_requests');
   db.run('DELETE FROM call_pending_questions');
@@ -268,16 +272,15 @@ describe('ASK_GUARDIAN canonical notification path', () => {
 
     const db = getDb();
     const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-    const request = raw.query('SELECT * FROM guardian_action_requests WHERE call_session_id = ?').get(session.id) as
+    const request = raw.query('SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?').get(session.id) as
       | { id: string }
       | undefined;
     const deliveries = raw.query(
-      'SELECT destination_channel, destination_conversation_id, destination_chat_id, destination_external_user_id, status FROM guardian_action_deliveries WHERE request_id = ? ORDER BY destination_channel ASC',
+      'SELECT destination_channel, destination_conversation_id, destination_chat_id, status FROM canonical_guardian_deliveries WHERE request_id = ? ORDER BY destination_channel ASC',
     ).all(request!.id) as Array<{
       destination_channel: string;
       destination_conversation_id: string | null;
       destination_chat_id: string | null;
-      destination_external_user_id: string | null;
       status: string;
     }>;
 
@@ -286,7 +289,6 @@ describe('ASK_GUARDIAN canonical notification path', () => {
     const vellum = deliveries.find((d) => d.destination_channel === 'vellum');
     expect(telegram).toBeDefined();
     expect(telegram!.destination_chat_id).toBe('tg-chat-abc');
-    expect(telegram!.destination_external_user_id).toBe('tg-user-xyz');
     expect(telegram!.status).toBe('sent');
     expect(vellum).toBeDefined();
     expect(vellum!.destination_conversation_id).toBe('conv-guardian-vellum');
@@ -322,16 +324,15 @@ describe('ASK_GUARDIAN canonical notification path', () => {
 
     const db = getDb();
     const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-    const request = raw.query('SELECT * FROM guardian_action_requests WHERE call_session_id = ?').get(session.id) as
+    const request = raw.query('SELECT * FROM canonical_guardian_requests WHERE call_session_id = ?').get(session.id) as
       | { id: string }
       | undefined;
     const vellumDelivery = raw.query(
-      'SELECT status, last_error FROM guardian_action_deliveries WHERE request_id = ? AND destination_channel = ?',
-    ).get(request!.id, 'vellum') as { status: string; last_error: string | null } | undefined;
+      'SELECT status FROM canonical_guardian_deliveries WHERE request_id = ? AND destination_channel = ?',
+    ).get(request!.id, 'vellum') as { status: string } | undefined;
 
     expect(vellumDelivery).toBeDefined();
     expect(vellumDelivery!.status).toBe('failed');
-    expect(vellumDelivery!.last_error).toContain('No vellum delivery result');
   });
 
   test('context payload includes callSessionId and activeGuardianRequestCount for candidate-affinity', async () => {
@@ -426,11 +427,11 @@ describe('ASK_GUARDIAN canonical notification path', () => {
       pendingQuestion: pq2,
     });
 
-    // Verify: two distinct guardian_action_requests exist
+    // Verify: two distinct canonical_guardian_requests exist
     const db = getDb();
     const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
     const requests = raw.query(
-      'SELECT id, question_text FROM guardian_action_requests WHERE call_session_id = ? ORDER BY created_at ASC',
+      'SELECT id, question_text FROM canonical_guardian_requests WHERE call_session_id = ? ORDER BY created_at ASC',
     ).all(session.id) as Array<{ id: string; question_text: string }>;
     expect(requests).toHaveLength(2);
     expect(requests[0].question_text).toBe('Can they enter through the side gate?');
@@ -438,7 +439,7 @@ describe('ASK_GUARDIAN canonical notification path', () => {
 
     // Verify: each request has its own delivery row pointing to the shared conversation
     const deliveries = raw.query(
-      'SELECT request_id, destination_conversation_id, status FROM guardian_action_deliveries WHERE destination_conversation_id = ? ORDER BY created_at ASC',
+      'SELECT request_id, destination_conversation_id, status FROM canonical_guardian_deliveries WHERE destination_conversation_id = ? ORDER BY created_at ASC',
     ).all(sharedConvId) as Array<{ request_id: string; destination_conversation_id: string; status: string }>;
     expect(deliveries).toHaveLength(2);
     expect(deliveries[0].request_id).toBe(requests[0].id);
@@ -478,16 +479,15 @@ describe('ASK_GUARDIAN canonical notification path', () => {
     // The dispatch should still create a failed fallback delivery row
     const db = getDb();
     const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-    const request = raw.query('SELECT id FROM guardian_action_requests WHERE call_session_id = ?').get(session.id) as
+    const request = raw.query('SELECT id FROM canonical_guardian_requests WHERE call_session_id = ?').get(session.id) as
       | { id: string }
       | undefined;
     expect(request).toBeDefined();
 
     const delivery = raw.query(
-      'SELECT status, last_error FROM guardian_action_deliveries WHERE request_id = ? AND destination_channel = ?',
-    ).get(request!.id, 'vellum') as { status: string; last_error: string | null } | undefined;
+      'SELECT status FROM canonical_guardian_deliveries WHERE request_id = ? AND destination_channel = ?',
+    ).get(request!.id, 'vellum') as { status: string } | undefined;
     expect(delivery).toBeDefined();
     expect(delivery!.status).toBe('failed');
-    expect(delivery!.last_error).toContain('No vellum delivery result');
   });
 });

package/src/__tests__/oauth-connect-handler.test.ts

@@ -39,7 +39,9 @@ mock.module('../util/logger.js', () => ({
 }));
 
 mock.module('../config/loader.js', () => ({
-  getConfig: () => ({}),
+  getConfig: () => ({
+    ui: {},
+    }),
   loadConfig: () => ({ ingress: { publicBaseUrl: 'https://test.example.com' } }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},

package/src/__tests__/oauth2-gateway-transport.test.ts

@@ -11,6 +11,8 @@ mock.module('../config/loader.js', () => ({
     ingress: { publicBaseUrl: mockPublicBaseUrl },
   }),
   getConfig: () => ({
+    ui: {},
+    
     ingress: { publicBaseUrl: mockPublicBaseUrl },
   }),
   loadRawConfig: () => ({}),

package/src/__tests__/onboarding-starter-tasks.test.ts

@@ -151,7 +151,7 @@ describe('starter task playbook integration with buildSystemPrompt', () => {
     expect(result).not.toContain('## Starter Task Playbooks');
   });
 
-  test('starter task playbook appears before channel awareness', () => {
+  test('starter task playbook and channel awareness both present during onboarding', () => {
     writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
     writeFileSync(join(TEST_DIR, 'BOOTSTRAP.md'), '# First run');
     const result = buildSystemPrompt();
@@ -159,7 +159,6 @@ describe('starter task playbook integration with buildSystemPrompt', () => {
     const channelIdx = result.indexOf('## Channel Awareness & Trust Gating');
     expect(starterIdx).toBeGreaterThan(-1);
     expect(channelIdx).toBeGreaterThan(-1);
-    expect(starterIdx).toBeLessThan(channelIdx);
   });
 
   test('all three kickoff intents present in full system prompt during onboarding', () => {
@@ -171,9 +170,10 @@ describe('starter task playbook integration with buildSystemPrompt', () => {
     expect(result).toContain('[STARTER_TASK:research_to_ui]');
   });
 
-  test('system prompt does not contain invalid config_update surface type', () => {
+  test('system prompt does not contain invalid config_update surface type (bare)', () => {
     writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
     const result = buildSystemPrompt();
-    expect(result).not.toContain('config_update');
+    // voice_config_update is a valid tool name; only bare 'config_update' surface type is invalid
+    expect(result).not.toContain('surface_type: "config_update"');
   });
 });