@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

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

@@ -61,6 +61,36 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
+// Guardian identity for the access request resolves via the gateway delivery
+// reader, not the local contacts DB. Seed it per-test via seedGatewayGuardian.
+interface GatewayGuardian {
+  channelType: string;
+  contactId: string;
+  principalId?: string | null;
+  displayName?: string | null;
+  address: string;
+  externalChatId?: string | null;
+  status: string;
+  verifiedAt?: number | null;
+}
+let gatewayGuardians: GatewayGuardian[] = [];
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => gatewayGuardians,
+  guardianForChannel: (list: GatewayGuardian[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+function seedGatewayGuardian(g: Partial<GatewayGuardian> & {
+  channelType: string;
+  address: string;
+}): void {
+  gatewayGuardians.push({
+    contactId: `c-${g.channelType}`,
+    status: "active",
+    ...g,
+  });
+}
+
 import {
   listCanonicalGuardianDeliveries,
   listCanonicalGuardianRequests,
@@ -71,7 +101,7 @@ import { notifyGuardianOfAccessRequest } from "../runtime/access-request-helper.
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -86,7 +116,6 @@ const TEST_BEARER_TOKEN = "test-token";
  */
 function resetState(): string {
   const db = getDb();
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM notification_events");
@@ -96,6 +125,7 @@ function resetState(): string {
   db.run("DELETE FROM contacts");
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
+  gatewayGuardians = [];
   mockEmitResult = {
     signalId: "mock-signal-id",
     deduplicated: false,
@@ -103,8 +133,15 @@ function resetState(): string {
     reason: "mock",
     deliveryResults: [],
   };
-  // Seed the vellum anchor binding (gateway does this at startup in production)
+  // Seed the vellum anchor binding in the gateway list (gateway does this at
+  // startup in production). The DB write mirrors it for any local INFO reads.
   const principalId = `vellum-principal-${crypto.randomUUID()}`;
+  seedGatewayGuardian({
+    channelType: "vellum",
+    address: principalId,
+    principalId,
+    displayName: principalId,
+  });
   createGuardianBinding({
     channel: "vellum",
     guardianExternalUserId: principalId,
@@ -173,6 +210,12 @@ describe("non-member access request notification", () => {
 
   test("guardian is notified when a non-member messages and a guardian binding exists", async () => {
     // Set up a guardian binding for this channel using the anchor principal
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-789",
+      externalChatId: "guardian-chat-789",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
@@ -218,6 +261,12 @@ describe("non-member access request notification", () => {
   });
 
   test("no duplicate approval requests for repeated messages from same non-member", async () => {
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-789",
+      externalChatId: "guardian-chat-789",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
@@ -290,6 +339,12 @@ describe("non-member access request notification", () => {
     // Only a voice guardian binding exists — no Telegram binding.
     // Since cross-channel fallback was removed, the access request resolves
     // to the assistant's vellum anchor identity instead.
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice-user",
+      externalChatId: "guardian-voice-chat",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "guardian-voice-user",
@@ -352,8 +407,8 @@ describe("access-request-helper unit tests", () => {
     anchorPrincipalId = resetState();
   });
 
-  test("notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -373,8 +428,8 @@ describe("access-request-helper unit tests", () => {
     expect(pending.length).toBe(0);
   });
 
-  test("notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -401,8 +456,14 @@ describe("access-request-helper unit tests", () => {
     expect(emitSignalCalls.length).toBe(1);
   });
 
-  test("notifyGuardianOfAccessRequest falls back to assistant-anchored vellum identity when source-channel binding is missing", () => {
+  test("notifyGuardianOfAccessRequest falls back to assistant-anchored vellum identity when source-channel binding is missing", async () => {
     // Only voice binding exists
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice",
+      externalChatId: "voice-chat",
+      principalId: "test-principal-id",
+    });
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "guardian-voice",
@@ -411,7 +472,7 @@ describe("access-request-helper unit tests", () => {
       verifiedVia: "test",
     });
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "tg-chat",
@@ -436,8 +497,20 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("vellum");
   });
 
-  test("notifyGuardianOfAccessRequest prefers source-channel binding over vellum anchor", () => {
+  test("notifyGuardianOfAccessRequest prefers source-channel binding over vellum anchor", async () => {
     // Both Telegram and voice bindings exist with the anchor principal
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-tg",
+      externalChatId: "tg-chat",
+      principalId: anchorPrincipalId,
+    });
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice",
+      externalChatId: "voice-chat",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-tg",
@@ -453,7 +526,7 @@ describe("access-request-helper unit tests", () => {
       verifiedVia: "test",
     });
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -478,8 +551,100 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("telegram");
   });
 
-  test("notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest falls back to local source-channel binding when gateway delivery is empty", async () => {
+    // Gateway delivery read yields nothing (restart/timeout/malformed IPC).
+    gatewayGuardians = [];
+    // Local dual-written mirror still has the vellum anchor + telegram binding.
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "guardian-tg",
+      guardianDeliveryChatId: "tg-chat",
+      guardianPrincipalId: anchorPrincipalId,
+      verifiedVia: "test",
+    });
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-123",
+      actorExternalId: "unknown-user",
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+    // Request is decidable: local read supplied the principal + source binding.
+    expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
+    expect(pending[0].guardianExternalUserId).toBe("guardian-tg");
+
+    const payload = emitSignalCalls[0].contextPayload as Record<
+      string,
+      unknown
+    >;
+    expect(payload.guardianBindingChannel).toBe("telegram");
+  });
+
+  test("notifyGuardianOfAccessRequest falls back to local vellum anchor when gateway delivery is empty", async () => {
+    // Gateway empty; only the local vellum anchor from resetState remains.
+    gatewayGuardians = [];
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-123",
+      actorExternalId: "unknown-user",
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+    // Decidable via the local vellum anchor principal.
+    expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<
+      string,
+      unknown
+    >;
+    expect(payload.guardianBindingChannel).toBe("vellum");
+  });
+
+  test("notifyGuardianOfAccessRequest does not create a decisionable request when both gateway and local reads are empty", async () => {
+    // Genuinely unbound assistant: gateway empty AND no local binding. Prior
+    // behavior rejects creation of a decisionable request without a principal.
+    gatewayGuardians = [];
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+
+    await expect(
+      notifyGuardianOfAccessRequest({
+        canonicalAssistantId: "self",
+        sourceChannel: "telegram",
+        conversationExternalId: "chat-123",
+        actorExternalId: "unknown-user",
+      }),
+    ).rejects.toThrow();
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(0);
+  });
+
+  test("notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15559998888",
@@ -509,8 +674,8 @@ describe("access-request-helper unit tests", () => {
     expect(pending.length).toBe(1);
   });
 
-  test("notifyGuardianOfAccessRequest includes requestCode in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest includes requestCode in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -530,8 +695,8 @@ describe("access-request-helper unit tests", () => {
     expect((payload.requestCode as string).length).toBe(6);
   });
 
-  test("notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -571,7 +736,7 @@ describe("access-request-helper unit tests", () => {
       ],
     };
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15556667777",
@@ -604,6 +769,12 @@ describe("access-request-helper unit tests", () => {
     // Set up a telegram guardian binding with the anchor principal so
     // guardianResolutionSource resolves to "source-channel-contact" and
     // sameChannelOnly is true.
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-456",
+      externalChatId: "guardian-chat-456",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-456",
@@ -626,7 +797,7 @@ describe("access-request-helper unit tests", () => {
       ],
     };
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",

package/src/__tests__/notification-broadcaster.test.ts

@@ -24,6 +24,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => null,
+}));
+
 // Mock destination-resolver to return a destination for every requested channel.
 // External channels (telegram, slack) include bindingContext.
 mock.module("../notifications/destination-resolver.js", () => ({

package/src/__tests__/notification-candidate-guardian-context.test.ts

@@ -0,0 +1,203 @@
+/**
+ * DB-backed tests for guardian-context enrichment of notification conversation
+ * candidates.
+ *
+ * `buildConversationCandidates` counts each candidate's pending guardian
+ * requests through the canonical store's conversation-scope query, which
+ * matches both a request's source conversation and any conversation its card
+ * was delivered to. These tests lock that wiring — in particular that a
+ * request delivered to a conversation different from its synthetic source is
+ * still counted for the conversation that shows the card.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  createCanonicalGuardianDelivery,
+  createCanonicalGuardianRequest,
+  resolveCanonicalGuardianRequest,
+} from "../memory/canonical-guardian-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations } from "../memory/schema.js";
+import { recordGuardianRequestDeliveries } from "../notifications/canonical-delivery-recorder.js";
+import { buildConversationCandidates } from "../notifications/conversation-candidates.js";
+import { createDecision } from "../notifications/decisions-store.js";
+import { createDelivery } from "../notifications/deliveries-store.js";
+import { createEvent } from "../notifications/events-store.js";
+import type { NotificationChannel } from "../notifications/types.js";
+
+await initializeDb();
+
+const TEST_PRINCIPAL = "test-principal-id";
+const CHANNEL = "vellum" as NotificationChannel;
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM canonical_guardian_deliveries");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM notification_deliveries");
+  db.run("DELETE FROM notification_decisions");
+  db.run("DELETE FROM notification_events");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Seed a conversation the candidate builder will surface: a "sent" notification
+ * delivery wired event -> decision -> delivery -> conversation on `channel`.
+ */
+function seedCandidateConversation(
+  conversationId: string,
+  channel: NotificationChannel = CHANNEL,
+): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations)
+    .values({
+      id: conversationId,
+      title: "Test thread",
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+
+  const eventId = `evt-${conversationId}`;
+  const decisionId = `dec-${conversationId}`;
+  createEvent({
+    id: eventId,
+    sourceEventName: "schedule.notify",
+    sourceChannel: channel,
+    sourceContextId: conversationId,
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    payload: {},
+  });
+  createDecision({
+    id: decisionId,
+    notificationEventId: eventId,
+    shouldNotify: true,
+    selectedChannels: [channel],
+    reasoningSummary: "test",
+    confidence: 1,
+    fallbackUsed: false,
+  });
+  createDelivery({
+    id: `del-${conversationId}`,
+    notificationDecisionId: decisionId,
+    channel,
+    destination: "dest",
+    status: "sent",
+    attempt: 1,
+    sentAt: now,
+    conversationId,
+  });
+}
+
+function candidateFor(
+  conversationId: string,
+  channel: NotificationChannel = CHANNEL,
+) {
+  const set = buildConversationCandidates([channel]);
+  return set[channel]?.find((c) => c.conversationId === conversationId);
+}
+
+describe("buildConversationCandidates guardian enrichment", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("counts pending requests via both source and delivery conversation scope", () => {
+    const convId = "conv-guardian";
+    seedCandidateConversation(convId);
+
+    // (1) pending request whose SOURCE conversation is the candidate.
+    createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+
+    // (2) pending request with a synthetic source id whose card was DELIVERED
+    // to the candidate conversation (a different conversation than its source).
+    const delivered = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      conversationId: "access-req-xyz",
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    createCanonicalGuardianDelivery({
+      requestId: delivered.id,
+      destinationChannel: CHANNEL,
+      destinationConversationId: convId,
+    });
+
+    expect(
+      candidateFor(convId)?.guardianContext?.pendingUnresolvedRequestCount,
+    ).toBe(2);
+  });
+
+  test("omits guardian context when the conversation's only request is resolved", () => {
+    const convId = "conv-resolved";
+    seedCandidateConversation(convId);
+
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    resolveCanonicalGuardianRequest(req.id, "pending", { status: "approved" });
+
+    // The conversation still surfaces as a candidate (it had a delivery), but
+    // with no guardian context since nothing is pending.
+    const candidate = candidateFor(convId);
+    expect(candidate).toBeDefined();
+    expect(candidate?.guardianContext).toBeUndefined();
+  });
+
+  test("counts a Slack channel card recorded through the real recorder", () => {
+    const SLACK = "slack" as NotificationChannel;
+    const convId = "conv-slack-card";
+    seedCandidateConversation(convId, SLACK);
+
+    // Channel-only access request: a synthetic source conversation, card
+    // delivered to a Slack chat. The recorder records the card's internal
+    // conversation, so the Slack candidate counts it.
+    const req = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "access-req-synthetic",
+      guardianPrincipalId: TEST_PRINCIPAL,
+    });
+    recordGuardianRequestDeliveries({
+      requestId: req.id,
+      deliveryResults: [
+        {
+          channel: "slack",
+          destination: "slack-chat-1",
+          status: "sent",
+          conversationId: convId,
+          messageId: "ts-1",
+        },
+      ],
+    });
+
+    expect(
+      candidateFor(convId, SLACK)?.guardianContext
+        ?.pendingUnresolvedRequestCount,
+    ).toBe(1);
+  });
+});

package/src/__tests__/notification-decision-recipient-context.test.ts

@@ -36,17 +36,36 @@ mock.module("../prompts/system-prompt.js", () => ({
   buildCoreIdentityContext: () => null,
 }));
 
-// ── Guardian contact mock ────────────────────────────────────────────
+// ── Guardian binding + contact notes mocks ───────────────────────────
 
-let mockGuardianResult: {
-  contact: { notes: string | null };
-  channels: Record<string, unknown>[];
-} | null = null;
+// Guardian binding (ACL) is resolved via the gateway pull; notes (INFO) are
+// joined locally by contactId. Tests drive both via mutable slots.
+let guardianDeliveryFixture: Array<{ contactId: string }> = [];
+let contactInfoFixture: Record<string, { notes: string | null } | null> = {};
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => guardianDeliveryFixture,
+  anyGuardian: (list: Array<{ contactId: string }>) => list[0],
+}));
 
 mock.module("../contacts/contact-store.js", () => ({
-  listGuardianChannels: () => mockGuardianResult,
+  findContactInfoById: (contactId: string) =>
+    contactInfoFixture[contactId] ?? null,
 }));
 
+const GUARDIAN_CONTACT_ID = "guardian-contact-1";
+
+/** Bind a guardian with the given notes (or no guardian when notes is null). */
+function setGuardian(notes: string | null | undefined): void {
+  if (notes === undefined) {
+    guardianDeliveryFixture = [];
+    contactInfoFixture = {};
+    return;
+  }
+  guardianDeliveryFixture = [{ contactId: GUARDIAN_CONTACT_ID }];
+  contactInfoFixture = { [GUARDIAN_CONTACT_ID]: { notes } };
+}
+
 // ── Provider mock with system prompt capture ──────────────────────────
 
 let configuredProvider: {
@@ -134,15 +153,12 @@ describe("recipient context in notification decision engine", () => {
   beforeEach(() => {
     configuredProvider = null;
     extractedToolUse = null;
-    mockGuardianResult = null;
+    setGuardian(undefined);
     capturedSystemPrompt = undefined;
   });
 
   test("guardian contact notes appear in system prompt as <recipient-context>", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers formal tone. Address as Dr. Smith." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers formal tone. Address as Dr. Smith.");
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -157,7 +173,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when no guardian exists", async () => {
-    mockGuardianResult = null;
+    setGuardian(undefined);
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -169,10 +185,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when guardian notes are null", async () => {
-    mockGuardianResult = {
-      contact: { notes: null },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian(null);
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -184,10 +197,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when guardian notes are empty string", async () => {
-    mockGuardianResult = {
-      contact: { notes: "" },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("");
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -199,10 +209,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("large guardian notes are truncated to prevent oversized prompts", async () => {
-    mockGuardianResult = {
-      contact: { notes: "N".repeat(3000) },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("N".repeat(3000));
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -226,10 +233,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("fallback path works correctly without recipient context", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers formal tone." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers formal tone.");
     // null provider forces fallback path
     configuredProvider = null;
 
@@ -247,10 +251,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context appears after user-preferences in prompt", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers brief updates." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers brief updates.");
     setupLLMProvider();
 
     const signal = makeSignal();