@vellumai/assistant 0.4.17 → 0.4.19

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

@@ -5,31 +5,31 @@
  * decision-model call is unavailable.
  */
 
-import { beforeEach, 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'],
+mock.module("../channels/config.js", () => ({
+  getDeliverableChannels: () => ["vellum", "telegram", "sms"],
 }));
 
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     notifications: {
-      decisionModelIntent: 'latency-optimized',
+      decisionModelIntent: "latency-optimized",
     },
   }),
 }));
 
-mock.module('../notifications/decisions-store.js', () => ({
+mock.module("../notifications/decisions-store.js", () => ({
   createDecision: () => {},
 }));
 
-mock.module('../notifications/preference-summary.js', () => ({
+mock.module("../notifications/preference-summary.js", () => ({
   getPreferenceSummary: () => undefined,
 }));
 
-mock.module('../notifications/thread-candidates.js', () => ({
+mock.module("../notifications/thread-candidates.js", () => ({
   buildThreadCandidates: () => undefined,
   serializeCandidatesForPrompt: () => undefined,
 }));
@@ -37,41 +37,43 @@ mock.module('../notifications/thread-candidates.js', () => ({
 let configuredProvider: { sendMessage: () => Promise<unknown> } | null = null;
 let extractedToolUse: unknown = null;
 
-mock.module('../providers/provider-send-message.js', () => ({
+mock.module("../providers/provider-send-message.js", () => ({
   getConfiguredProvider: () => configuredProvider,
   createTimeout: () => ({
     signal: new AbortController().signal,
     cleanup: () => {},
   }),
   extractToolUse: () => extractedToolUse,
-  userMessage: (text: string) => ({ role: 'user', content: text }),
+  userMessage: (text: string) => ({ role: "user", content: text }),
 }));
 
-mock.module('../util/logger.js', () => ({
+mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
 }));
 
-import { evaluateSignal } from '../notifications/decision-engine.js';
-import type { NotificationSignal } from '../notifications/signal.js';
-import type { NotificationChannel } from '../notifications/types.js';
+import { evaluateSignal } from "../notifications/decision-engine.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type { NotificationChannel } from "../notifications/types.js";
 
-function makeSignal(overrides?: Partial<NotificationSignal>): NotificationSignal {
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
   return {
-    signalId: 'sig-fallback-guardian-1',
-    assistantId: 'self',
+    signalId: "sig-fallback-guardian-1",
+    assistantId: "self",
     createdAt: Date.now(),
-    sourceChannel: 'voice',
-    sourceSessionId: 'call-session-1',
-    sourceEventName: 'guardian.question',
+    sourceChannel: "voice",
+    sourceSessionId: "call-session-1",
+    sourceEventName: "guardian.question",
     contextPayload: {
-      questionText: 'What is the gate code?',
+      questionText: "What is the gate code?",
     },
     attentionHints: {
       requiresAction: true,
-      urgency: 'high',
+      urgency: "high",
       isAsyncBackground: false,
       visibleInSourceNow: false,
     },
@@ -79,223 +81,245 @@ function makeSignal(overrides?: Partial<NotificationSignal>): NotificationSignal
   };
 }
 
-describe('notification decision fallback copy', () => {
+describe("notification decision fallback copy", () => {
   beforeEach(() => {
     configuredProvider = null;
     extractedToolUse = null;
   });
 
-  test('uses human-friendly template copy for guardian.question', async () => {
+  test("uses human-friendly template copy for guardian.question", async () => {
     const signal = makeSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(true);
-    expect(decision.renderedCopy.vellum?.title).toBe('Guardian Question');
-    expect(decision.renderedCopy.vellum?.body).toBe('What is the gate code?');
-    expect(decision.renderedCopy.vellum?.title).not.toBe('guardian.question');
-    expect(decision.renderedCopy.vellum?.body).not.toContain('Action required: guardian.question');
+    expect(decision.renderedCopy.vellum?.title).toBe("Guardian Question");
+    expect(decision.renderedCopy.vellum?.body).toBe("What is the gate code?");
+    expect(decision.renderedCopy.vellum?.title).not.toBe("guardian.question");
+    expect(decision.renderedCopy.vellum?.body).not.toContain(
+      "Action required: guardian.question",
+    );
   });
 
-  test('enforces free-text answer 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',
+        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[]);
+    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('<your answer>');
-    expect(decision.renderedCopy.vellum?.body).not.toContain('approve');
-    expect(decision.renderedCopy.vellum?.body).not.toContain('reject');
+    expect(decision.renderedCopy.vellum?.body).toContain("A1B2C3");
+    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 free-text answer 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: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Guardian Question',
-            body: 'Use reference code A1B2C3 for this request.',
+            title: "Guardian Question",
+            body: "Use reference code A1B2C3 for this request.",
           },
         },
-        dedupeKey: 'guardian-question-test',
+        dedupeKey: "guardian-question-test",
         confidence: 0.9,
       },
     };
 
     const signal = makeSignal({
       contextPayload: {
-        requestId: 'req-pending-1',
-        questionText: 'What is the gate code?',
-        requestCode: 'A1B2C3',
-        requestKind: 'pending_question',
-        callSessionId: 'call-1',
+        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[]);
+    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).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 () => {
+  test("enforcement appends answer instructions when LLM copy incorrectly uses approve/reject wording", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Guardian Question',
+            title: "Guardian Question",
             body: 'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
           },
         },
-        dedupeKey: 'guardian-question-wrong-instructions-test',
+        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',
+        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[]);
+    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).toContain(
+      '"A1B2C3 <your answer>"',
+    );
   });
 
-  test('enforcement appends explicit approve/reject instructions for tool-approval guardian questions', async () => {
+  test("enforcement appends explicit approve/reject instructions for tool-approval guardian questions", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Guardian Question',
-            body: 'Use reference code A1B2C3 for this request.',
+            title: "Guardian Question",
+            body: "Use reference code A1B2C3 for this request.",
           },
         },
-        dedupeKey: 'guardian-question-tool-approval-test',
+        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',
+        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[]);
+    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 () => {
+  test("approval-mode enforcement removes conflicting answer-mode phrasing", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Guardian Question',
+            title: "Guardian Question",
             body: 'Reference code: A1B2C3. Reply "A1B2C3 <your answer>".',
           },
         },
-        dedupeKey: 'guardian-question-approval-removes-answer-test',
+        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',
+        requestId: "req-grant-2",
+        questionText: "Allow running host_bash?",
+        requestCode: "A1B2C3",
+        requestKind: "tool_grant_request",
+        toolName: "host_bash",
       },
     });
 
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    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"');
-    expect(decision.renderedCopy.vellum?.body).not.toContain('<your answer>');
+    expect(decision.renderedCopy.vellum?.body).not.toContain("<your answer>");
   });
 });
 
 // ── Access-request instruction enforcement ──────────────────────────────
 
-describe('access-request instruction enforcement', () => {
+describe("access-request instruction enforcement", () => {
   beforeEach(() => {
     configuredProvider = null;
     extractedToolUse = null;
   });
 
-  function makeAccessRequestSignal(overrides?: Partial<NotificationSignal>): NotificationSignal {
+  function makeAccessRequestSignal(
+    overrides?: Partial<NotificationSignal>,
+  ): NotificationSignal {
     return {
-      signalId: 'sig-access-req-1',
-      assistantId: 'self',
+      signalId: "sig-access-req-1",
+      assistantId: "self",
       createdAt: Date.now(),
-      sourceChannel: 'telegram',
-      sourceSessionId: 'tg-session-1',
-      sourceEventName: 'ingress.access_request',
+      sourceChannel: "telegram",
+      sourceSessionId: "tg-session-1",
+      sourceEventName: "ingress.access_request",
       contextPayload: {
-        senderIdentifier: 'Alice',
-        requestCode: 'A1B2C3',
-        sourceChannel: 'telegram',
+        senderIdentifier: "Alice",
+        requestCode: "A1B2C3",
+        sourceChannel: "telegram",
       },
       attentionHints: {
         requiresAction: true,
-        urgency: 'high',
+        urgency: "high",
         isAsyncBackground: false,
         visibleInSourceNow: false,
       },
@@ -303,203 +327,224 @@ describe('access-request instruction enforcement', () => {
     };
   }
 
-  test('fallback copy includes access-request contract elements', async () => {
+  test("fallback copy includes access-request contract elements", async () => {
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    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('open invite flow');
+    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("open invite flow");
   });
 
-  test('enforcement appends contract when LLM copy is missing request code', async () => {
+  test("enforcement appends contract when LLM copy is missing request code", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Access Request',
-            body: 'Someone wants access to your assistant.',
+            title: "Access Request",
+            body: "Someone wants access to your assistant.",
           },
         },
-        dedupeKey: 'access-req-missing-code',
+        dedupeKey: "access-req-missing-code",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    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('open invite flow');
+    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("open invite flow");
   });
 
-  test('enforcement appends contract when LLM copy has code but missing invite flow', async () => {
+  test("enforcement appends contract when LLM copy has code but missing invite flow", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Access Request',
+            title: "Access Request",
             body: 'Alice wants access. Reply "A1B2C3 approve" or "A1B2C3 reject".',
           },
         },
-        dedupeKey: 'access-req-missing-invite',
+        dedupeKey: "access-req-missing-invite",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.body).toContain('open invite flow');
+    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
   });
 
-  test('enforcement does not duplicate when LLM copy already has all required elements', async () => {
-    const fullBody = 'Alice wants access.\nReply "A1B2C3 approve" to grant access or "A1B2C3 reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.';
+  test("enforcement does not duplicate when LLM copy already has all required elements", async () => {
+    const fullBody =
+      'Alice wants access.\nReply "A1B2C3 approve" to grant access or "A1B2C3 reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.';
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Access Request',
+            title: "Access Request",
             body: fullBody,
           },
         },
-        dedupeKey: 'access-req-already-valid',
+        dedupeKey: "access-req-already-valid",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
     // Body should remain unchanged when all required elements are present
     expect(decision.renderedCopy.vellum?.body).toBe(fullBody);
   });
 
-  test('enforcement also applies to deliveryText and threadSeedMessage', async () => {
+  test("enforcement also applies to deliveryText and threadSeedMessage", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['telegram'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["telegram"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           telegram: {
-            title: 'Access Request',
-            body: 'Someone wants access.',
-            deliveryText: 'Someone wants access.',
-            threadSeedMessage: 'Someone wants access.',
+            title: "Access Request",
+            body: "Someone wants access.",
+            deliveryText: "Someone wants access.",
+            threadSeedMessage: "Someone wants access.",
           },
         },
-        dedupeKey: 'access-req-multi-field',
+        dedupeKey: "access-req-multi-field",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['telegram'] as NotificationChannel[]);
-
-    expect(decision.renderedCopy.telegram?.deliveryText).toContain('A1B2C3');
-    expect(decision.renderedCopy.telegram?.deliveryText).toContain('open invite flow');
-    expect(decision.renderedCopy.telegram?.threadSeedMessage).toContain('A1B2C3');
-    expect(decision.renderedCopy.telegram?.threadSeedMessage).toContain('open invite flow');
+    const decision = await evaluateSignal(signal, [
+      "telegram",
+    ] as NotificationChannel[]);
+
+    expect(decision.renderedCopy.telegram?.deliveryText).toContain("A1B2C3");
+    expect(decision.renderedCopy.telegram?.deliveryText).toContain(
+      "open invite flow",
+    );
+    expect(decision.renderedCopy.telegram?.threadSeedMessage).toContain(
+      "A1B2C3",
+    );
+    expect(decision.renderedCopy.telegram?.threadSeedMessage).toContain(
+      "open invite flow",
+    );
   });
 
-  test('enforcement appends contract when LLM copy contains conflicting instructions', async () => {
+  test("enforcement appends contract when LLM copy contains conflicting instructions", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Access Request',
+            title: "Access Request",
             body: 'Alice wants access. Just reply "yes" or "no" to decide.',
           },
         },
-        dedupeKey: 'access-req-conflicting',
+        dedupeKey: "access-req-conflicting",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     // Must contain the proper contract instructions despite conflicting LLM copy
-    expect(decision.renderedCopy.vellum?.body).toContain('A1B2C3 approve');
-    expect(decision.renderedCopy.vellum?.body).toContain('A1B2C3 reject');
-    expect(decision.renderedCopy.vellum?.body).toContain('open invite flow');
+    expect(decision.renderedCopy.vellum?.body).toContain("A1B2C3 approve");
+    expect(decision.renderedCopy.vellum?.body).toContain("A1B2C3 reject");
+    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
   });
 
-  test('enforcement appends invite directive when requestCode is absent', async () => {
+  test("enforcement appends invite directive when requestCode is absent", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
     extractedToolUse = {
-      name: 'record_notification_decision',
+      name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ['vellum'],
-        reasoningSummary: 'LLM decision',
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision",
         renderedCopy: {
           vellum: {
-            title: 'Access Request',
-            body: 'Someone wants access to your assistant.',
+            title: "Access Request",
+            body: "Someone wants access to your assistant.",
           },
         },
-        dedupeKey: 'access-req-no-code-invite',
+        dedupeKey: "access-req-no-code-invite",
         confidence: 0.9,
       },
     };
 
     const signal = makeAccessRequestSignal({
       contextPayload: {
-        senderIdentifier: 'Alice',
-        sourceChannel: 'telegram',
+        senderIdentifier: "Alice",
+        sourceChannel: "telegram",
         // No requestCode
       },
     });
-    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
     // Invite directive should still be enforced even without requestCode
-    expect(decision.renderedCopy.vellum?.body).toContain('open invite flow');
+    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
     // Approve/reject should NOT be present since there is no requestCode
-    expect(decision.renderedCopy.vellum?.body).not.toContain('approve');
-    expect(decision.renderedCopy.vellum?.body).not.toContain('reject');
+    expect(decision.renderedCopy.vellum?.body).not.toContain("approve");
+    expect(decision.renderedCopy.vellum?.body).not.toContain("reject");
   });
 });