@vellumai/assistant 0.4.2 → 0.4.4

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -100,6 +100,9 @@ interface TestSession {
   setAssistantId: (assistantId: string) => void;
   setGuardianContext: (ctx: unknown) => void;
   setCommandIntent: (intent: unknown) => void;
+  updateClient: (sendToClient: (msg: ServerMessage) => void, hasNoClient?: boolean) => void;
+  emitActivityState: (...args: unknown[]) => void;
+  emitConfirmationStateChanged: (...args: unknown[]) => void;
   processMessage: (...args: unknown[]) => Promise<string>;
 }
 
@@ -153,6 +156,9 @@ function makeSession(overrides: Partial<TestSession> = {}): TestSession {
     setAssistantId: () => {},
     setGuardianContext: () => {},
     setCommandIntent: () => {},
+    updateClient: () => {},
+    emitActivityState: () => {},
+    emitConfirmationStateChanged: () => {},
     processMessage: async () => 'msg-id',
     ...overrides,
   };
@@ -411,6 +417,53 @@ describe('handleUserMessage pending-confirmation reply interception', () => {
     expect(sent.some((event) => event.type === 'confirmation_request')).toBe(true);
   });
 
+  test('registers IPC confirmation events emitted via session sender (prompter path)', async () => {
+    let currentSender: (msg: ServerMessage) => void = () => {};
+    const session = makeSession({
+      hasAnyPendingConfirmation: () => false,
+      enqueueMessage: mock(() => ({ queued: false, requestId: 'direct-id' })),
+      updateClient: (sendToClient: (msg: ServerMessage) => void) => {
+        currentSender = sendToClient;
+      },
+      processMessage: async () => {
+        currentSender({
+          type: 'confirmation_request',
+          requestId: 'req-prompter-1',
+          toolName: 'call_start',
+          input: { phone_number: '+18084436762' },
+          riskLevel: 'high',
+          executionTarget: 'host',
+          allowlistOptions: [],
+          scopeOptions: [],
+          persistentDecisionsAllowed: false,
+        } as ServerMessage);
+        return 'msg-id';
+      },
+    });
+    const { ctx, sent } = createContext(session);
+
+    await handleUserMessage(makeMessage('please call now'), {} as net.Socket, ctx);
+
+    expect(registerMock).toHaveBeenCalledWith(
+      'req-prompter-1',
+      expect.objectContaining({
+        conversationId: 'conv-1',
+        kind: 'confirmation',
+        session,
+      }),
+    );
+    expect(createCanonicalGuardianRequestMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'req-prompter-1',
+        kind: 'tool_approval',
+        sourceType: 'desktop',
+        sourceChannel: 'vellum',
+        conversationId: 'conv-1',
+      }),
+    );
+    expect(sent.some((event) => event.type === 'confirmation_request')).toBe(true);
+  });
+
   test('syncs canonical status to approved for IPC allow decisions', () => {
     const session = {
       hasPendingConfirmation: (requestId: string) => requestId === 'req-confirm-allow',
@@ -433,6 +486,8 @@ describe('handleUserMessage pending-confirmation reply interception', () => {
       'always_allow',
       undefined,
       undefined,
+      undefined,
+      { source: 'button' },
     ]);
     expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
       'req-confirm-allow',

package/src/__tests__/headless-browser-navigate.test.ts

@@ -32,6 +32,8 @@ mock.module('../tools/browser/browser-manager.js', () => {
       getOrCreateSessionPage: getOrCreateSessionPageMock,
       clearSnapshotMap: mock(() => {}),
       supportsRouteInterception: true,
+      isInteractive: () => false,
+      positionWindowSidebar: () => {},
     },
   };
 });

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -28,7 +28,6 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
-  normalizeAssistantId: (id: string) => id === 'self' ? 'self' : id,
   readHttpToken: () => 'test-bearer-token',
 }));
 

package/src/__tests__/ingress-routes-http.test.ts

@@ -492,6 +492,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+        guardianName: 'Bob',
         maxUses: 3,
       }),
     });
@@ -514,6 +516,9 @@ describe('voice invite HTTP routes', () => {
     expect(invite.voiceCodeDigits).toBe(6);
     // expectedExternalUserId should be recorded
     expect(invite.expectedExternalUserId).toBe('+15551234567');
+    // friendName and guardianName should be recorded
+    expect(invite.friendName).toBe('Alice');
+    expect(invite.guardianName).toBe('Bob');
   });
 
   test('voice invite creation requires expectedExternalUserId', async () => {
@@ -522,6 +527,8 @@ describe('voice invite HTTP routes', () => {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         sourceChannel: 'voice',
+        friendName: 'Alice',
+        guardianName: 'Bob',
       }),
     });
 
@@ -540,6 +547,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: 'not-a-phone-number',
+        friendName: 'Alice',
+        guardianName: 'Bob',
       }),
     });
 
@@ -551,6 +560,44 @@ describe('voice invite HTTP routes', () => {
     expect(body.error).toContain('E.164');
   });
 
+  test('voice invite creation requires friendName', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        guardianName: 'Bob',
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('friendName');
+  });
+
+  test('voice invite creation requires guardianName', async () => {
+    const req = new Request('http://localhost/v1/ingress/invites', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sourceChannel: 'voice',
+        expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+      }),
+    });
+
+    const res = await handleCreateInvite(req);
+    const body = await res.json() as Record<string, unknown>;
+
+    expect(res.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error).toContain('guardianName');
+  });
+
   test('voiceCodeDigits is always 6 — custom values are ignored', async () => {
     const req = new Request('http://localhost/v1/ingress/invites', {
       method: 'POST',
@@ -558,6 +605,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+        guardianName: 'Bob',
         voiceCodeDigits: 8,
       }),
     });
@@ -579,6 +628,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+        guardianName: 'Bob',
       }),
     });
 
@@ -600,6 +651,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+        guardianName: 'Bob',
         maxUses: 1,
       }),
     }));
@@ -648,6 +701,8 @@ describe('voice invite HTTP routes', () => {
       body: JSON.stringify({
         sourceChannel: 'voice',
         expectedExternalUserId: '+15551234567',
+        friendName: 'Alice',
+        guardianName: 'Bob',
         maxUses: 1,
       }),
     }));

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

@@ -422,16 +422,6 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'telegram_config',
     action: 'get',
   },
-  twilio_config: {
-    type: 'twilio_config',
-    action: 'get',
-  },
-  channel_readiness: {
-    type: 'channel_readiness',
-    action: 'get',
-    channel: 'sms',
-    includeRemote: true,
-  },
   guardian_verification: {
     type: 'guardian_verification',
     action: 'create_challenge',
@@ -823,6 +813,24 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     sandboxed: false,
     sessionId: 'sess-001',
   },
+  confirmation_state_changed: {
+    type: 'confirmation_state_changed',
+    sessionId: 'sess-001',
+    requestId: 'req-002',
+    state: 'approved',
+    source: 'inline_nl',
+    causedByRequestId: 'req-003',
+    decisionText: 'approve',
+  },
+  assistant_activity_state: {
+    type: 'assistant_activity_state',
+    sessionId: 'sess-001',
+    activityVersion: 1,
+    phase: 'thinking',
+    anchor: 'assistant_turn',
+    requestId: 'req-003',
+    reason: 'message_dequeued',
+  },
   message_complete: {
     type: 'message_complete',
     sessionId: 'sess-001',
@@ -1446,47 +1454,6 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     connected: true,
     hasWebhookSecret: true,
   },
-  twilio_config_response: {
-    type: 'twilio_config_response',
-    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',
     success: true,

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

@@ -30,7 +30,6 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
-  normalizeAssistantId: (id: string) => id === 'self' ? 'self' : id,
   readHttpToken: () => 'test-bearer-token',
 }));
 
@@ -59,16 +58,23 @@ mock.module('../config/env.js', () => ({
 
 // Track emitNotificationSignal calls
 const emitSignalCalls: Array<Record<string, unknown>> = [];
+let mockEmitResult: {
+  signalId: string;
+  deduplicated: boolean;
+  dispatched: boolean;
+  reason: string;
+  deliveryResults: Array<Record<string, unknown>>;
+} = {
+  signalId: 'mock-signal-id',
+  deduplicated: false,
+  dispatched: true,
+  reason: 'mock',
+  deliveryResults: [],
+};
 mock.module('../notifications/emit-signal.js', () => ({
   emitNotificationSignal: async (params: Record<string, unknown>) => {
     emitSignalCalls.push(params);
-    return {
-      signalId: 'mock-signal-id',
-      deduplicated: false,
-      dispatched: true,
-      reason: 'mock',
-      deliveryResults: [],
-    };
+    return mockEmitResult;
   },
 }));
 
@@ -80,7 +86,10 @@ mock.module('../runtime/gateway-client.js', () => ({
   },
 }));
 
-import { listCanonicalGuardianRequests } from '../memory/canonical-guardian-store.js';
+import {
+  listCanonicalGuardianDeliveries,
+  listCanonicalGuardianRequests,
+} from '../memory/canonical-guardian-store.js';
 import {
   createBinding,
 } from '../memory/channel-guardian-store.js';
@@ -112,6 +121,17 @@ function resetState(): void {
   db.run('DELETE FROM canonical_guardian_deliveries');
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
+  mockEmitResult = {
+    signalId: 'mock-signal-id',
+    deduplicated: false,
+    dispatched: true,
+    reason: 'mock',
+    deliveryResults: [],
+  };
+}
+
+async function flushAsyncAccessRequestBookkeeping(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 function buildInboundRequest(overrides: Record<string, unknown> = {}): Request {
@@ -437,6 +457,34 @@ describe('access-request-helper unit tests', () => {
     expect(payload.guardianBindingChannel).toBe('telegram');
   });
 
+  test('notifyGuardianOfAccessRequest for voice channel includes senderName in contextPayload', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'voice',
+      externalChatId: '+15559998888',
+      senderExternalUserId: '+15559998888',
+      senderName: 'Alice Caller',
+    });
+
+    expect(result.notified).toBe(true);
+    expect(emitSignalCalls.length).toBe(1);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.sourceChannel).toBe('voice');
+    expect(payload.senderName).toBe('Alice Caller');
+    expect(payload.senderExternalUserId).toBe('+15559998888');
+    expect(payload.senderIdentifier).toBe('Alice Caller');
+
+    // Canonical request should exist
+    const pending = listCanonicalGuardianRequests({
+      status: 'pending',
+      requesterExternalUserId: '+15559998888',
+      sourceChannel: 'voice',
+      kind: 'access_request',
+    });
+    expect(pending.length).toBe(1);
+  });
+
   test('notifyGuardianOfAccessRequest includes requestCode in contextPayload', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
@@ -454,4 +502,106 @@ describe('access-request-helper unit tests', () => {
     expect(typeof payload.requestCode).toBe('string');
     expect((payload.requestCode as string).length).toBe(6);
   });
+
+  test('notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'revoked-user',
+      senderName: 'Revoked User',
+      previousMemberStatus: 'revoked',
+    });
+
+    expect(result.notified).toBe(true);
+    expect(emitSignalCalls.length).toBe(1);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.previousMemberStatus).toBe('revoked');
+  });
+
+  test('notifyGuardianOfAccessRequest persists canonical delivery rows from notification results', async () => {
+    mockEmitResult = {
+      signalId: 'sig-deliveries',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [
+        {
+          channel: 'vellum',
+          destination: 'vellum',
+          status: 'sent',
+          conversationId: 'conv-guardian-access-request',
+        },
+        {
+          channel: 'telegram',
+          destination: 'guardian-chat-123',
+          status: 'sent',
+        },
+      ],
+    };
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'voice',
+      externalChatId: '+15556667777',
+      senderExternalUserId: '+15556667777',
+      senderName: 'Noah',
+    });
+
+    expect(result.notified).toBe(true);
+    if (!result.notified) return;
+
+    await flushAsyncAccessRequestBookkeeping();
+
+    const deliveries = listCanonicalGuardianDeliveries(result.requestId);
+    const vellum = deliveries.find((d) => d.destinationChannel === 'vellum');
+    const telegram = deliveries.find((d) => d.destinationChannel === 'telegram');
+
+    expect(vellum).toBeDefined();
+    expect(vellum!.destinationConversationId).toBe('conv-guardian-access-request');
+    expect(vellum!.status).toBe('sent');
+    expect(telegram).toBeDefined();
+    expect(telegram!.destinationChatId).toBe('guardian-chat-123');
+    expect(telegram!.status).toBe('sent');
+  });
+
+  test('notifyGuardianOfAccessRequest records failed vellum fallback when pipeline has no vellum delivery', async () => {
+    mockEmitResult = {
+      signalId: 'sig-no-vellum',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'telegram-only',
+      deliveryResults: [
+        {
+          channel: 'telegram',
+          destination: 'guardian-chat-456',
+          status: 'sent',
+        },
+      ],
+    };
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'unknown-user',
+      senderName: 'Alice',
+    });
+
+    expect(result.notified).toBe(true);
+    if (!result.notified) return;
+
+    await flushAsyncAccessRequestBookkeeping();
+
+    const deliveries = listCanonicalGuardianDeliveries(result.requestId);
+    const vellum = deliveries.find((d) => d.destinationChannel === 'vellum');
+    const telegram = deliveries.find((d) => d.destinationChannel === 'telegram');
+
+    expect(vellum).toBeDefined();
+    expect(vellum!.status).toBe('failed');
+    expect(telegram).toBeDefined();
+    expect(telegram!.destinationChatId).toBe('guardian-chat-456');
+    expect(telegram!.status).toBe('sent');
+  });
 });

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

@@ -96,22 +96,27 @@ describe('notification decision fallback copy', () => {
     expect(decision.renderedCopy.vellum?.body).not.toContain('Action required: guardian.question');
   });
 
-  test('enforces request-code instructions for guardian.question when requestCode exists', async () => {
+  test('enforces free-text answer instructions for guardian.question when requestCode exists', async () => {
     const signal = makeSignal({
       contextPayload: {
+        requestId: 'req-pending-1',
         questionText: 'What is the gate code?',
         requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
       },
     });
     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');
+    expect(decision.renderedCopy.vellum?.body).toContain('<your answer>');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('approve');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('reject');
   });
 
-  test('enforcement appends explicit approve/reject instructions when LLM copy only mentions request code', async () => {
+  test('enforcement appends free-text answer instructions when LLM copy only mentions request code', async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -134,8 +139,127 @@ describe('notification decision fallback copy', () => {
 
     const signal = makeSignal({
       contextPayload: {
+        requestId: 'req-pending-1',
         questionText: 'What is the gate code?',
         requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 <your answer>"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('"A1B2C3 reject"');
+  });
+
+  test('enforcement appends answer instructions when LLM copy incorrectly uses approve/reject wording', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+          },
+        },
+        dedupeKey: 'guardian-question-wrong-instructions-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-pending-approve-phrasing',
+        questionText: 'What is the gate code?',
+        requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 <your answer>"');
+  });
+
+  test('enforcement appends explicit approve/reject instructions for tool-approval guardian questions', 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-tool-approval-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-grant-1',
+        questionText: 'Allow running host_bash?',
+        requestCode: 'A1B2C3',
+        requestKind: 'tool_grant_request',
+        toolName: 'host_bash',
+      },
+    });
+
+    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"');
+  });
+
+  test('approval-mode enforcement removes conflicting answer-mode phrasing', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Reference code: A1B2C3. Reply "A1B2C3 <your answer>".',
+          },
+        },
+        dedupeKey: 'guardian-question-approval-removes-answer-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-grant-2',
+        questionText: 'Allow running host_bash?',
+        requestCode: 'A1B2C3',
+        requestKind: 'tool_grant_request',
+        toolName: 'host_bash',
       },
     });
 
@@ -144,5 +268,6 @@ describe('notification decision fallback copy', () => {
     expect(decision.fallbackUsed).toBe(false);
     expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
     expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('<your answer>');
   });
 });