@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/__tests__/list-messages-system-card.test.ts

@@ -104,6 +104,58 @@ describe("handleListMessages system-card projection", () => {
     expect(silentRow?.noResponse).toBe(true);
   });
 
+  test("projects a reaction's typed emoji fields to the response", async () => {
+    const conv = createConversation();
+    const row = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "[reaction]" }]),
+      {
+        metadata: {
+          messageKind: "reaction",
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            eventKind: "reaction",
+            reaction: {
+              targetMessageId: "555.1",
+              emoji: "<:party_blob:111>",
+              emojiKind: "custom",
+              emojiName: "party_blob",
+              emojiId: "111",
+              emojiAnimated: true,
+              op: "added",
+            },
+          }),
+        },
+      },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conv.id },
+    })) as {
+      messages: Array<
+        ProjectedMessage & {
+          reaction?: {
+            emoji: string;
+            emojiKind?: string;
+            emojiName?: string;
+            emojiId?: string;
+            emojiAnimated?: boolean;
+          };
+        }
+      >;
+    };
+    const projected = response.messages.find((m) => m.id === row.id);
+    expect(projected?.reaction).toMatchObject({
+      emoji: "<:party_blob:111>",
+      emojiKind: "custom",
+      emojiName: "party_blob",
+      emojiId: "111",
+      emojiAnimated: true,
+    });
+  });
+
   test("projects the reaction fact from a reaction row's envelope", async () => {
     const conv = createConversation();
     const row = await addMessage(
@@ -144,6 +196,57 @@ describe("handleListMessages system-card projection", () => {
     expect(projected?.reaction?.selfAuthored).toBe(true);
   });
 
+  test("projects deletedAt from a row deleted on its channel", async () => {
+    // Mirror the delete propagation stamp: the row keeps its content and the
+    // envelope carries the marker, in either shape the daemon writes.
+    const conv = createConversation();
+    const discordRow = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "A message later deleted" }]),
+      {
+        metadata: {
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: "chan-1",
+            messageId: "111",
+            eventKind: "message",
+            deletedAt: 1725100000000,
+          }),
+        },
+      },
+    );
+    const slackRow = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "The assistant's deleted post" }]),
+      {
+        metadata: {
+          slackMeta: JSON.stringify({
+            source: "slack",
+            channelId: "C0123",
+            channelTs: "1725100000.000100",
+            eventKind: "message",
+            deletedAt: 1725100001000,
+          }),
+        },
+      },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conv.id },
+    })) as { messages: Array<ProjectedMessage & { deletedAt?: number }> };
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+    expect(
+      response.messages.find((m) => m.id === discordRow.id)?.deletedAt,
+    ).toBe(1725100000000);
+    expect(response.messages.find((m) => m.id === slackRow.id)?.deletedAt).toBe(
+      1725100001000,
+    );
+  });
+
   test("omits systemCard on ordinary user and assistant rows", async () => {
     const conv = createConversation();
     await addMessage(

package/src/__tests__/media-resolve-image-validation.test.ts

@@ -414,3 +414,80 @@ describe("unsendable-image notice", () => {
     );
   });
 });
+
+describe("resolveMediaReferences file workspace_ref stay-on-disk", () => {
+  beforeEach(resetTables);
+
+  test("does not inline over-cap text or extracted_text", async () => {
+    const conv = createConversation();
+    const stored = await createInlineAttachment(
+      conv.id,
+      conv.createdAt,
+      "oversized-content.txt",
+      "text/plain",
+      Buffer.from("hello-over-cap").toString("base64"),
+    );
+    const messages: Message[] = [
+      userMessage([
+        {
+          type: "file",
+          source: {
+            type: "workspace_ref",
+            media_type: "text/plain",
+            attachmentId: stored.id,
+            sizeBytes: 8_000_001,
+            filename: "oversized-content.txt",
+          },
+          extracted_text: "this dump must not be resent",
+        },
+      ]),
+    ];
+
+    const resolved = await resolveMediaReferences(messages);
+    const block = resolved[0]!.content[0]!;
+    expect(block.type).toBe("file");
+    if (block.type !== "file") {
+      throw new Error("expected a file block");
+    }
+    expect(block.source.type).toBe("workspace_ref");
+    expect(block.extracted_text).toBeUndefined();
+    expect(JSON.stringify(resolved)).not.toContain("this dump must not be resent");
+    expect(JSON.stringify(resolved)).not.toContain("hello-over-cap");
+  });
+
+  test("does not inline video bytes or extracted_text", async () => {
+    const conv = createConversation();
+    const stored = await createInlineAttachment(
+      conv.id,
+      conv.createdAt,
+      "clip.mp4",
+      "video/mp4",
+      Buffer.from("not-a-real-video").toString("base64"),
+    );
+    const messages: Message[] = [
+      userMessage([
+        {
+          type: "file",
+          source: {
+            type: "workspace_ref",
+            media_type: "video/mp4",
+            attachmentId: stored.id,
+            sizeBytes: stored.sizeBytes,
+            filename: "clip.mp4",
+          },
+          extracted_text: "dump of the video as text",
+        },
+      ]),
+    ];
+
+    const resolved = await resolveMediaReferences(messages);
+    const block = resolved[0]!.content[0]!;
+    expect(block.type).toBe("file");
+    if (block.type !== "file") {
+      throw new Error("expected a file block");
+    }
+    expect(block.source.type).toBe("workspace_ref");
+    expect(block.extracted_text).toBeUndefined();
+    expect(JSON.stringify(resolved)).not.toContain("dump of the video");
+  });
+});

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

@@ -88,7 +88,7 @@ describe("notification decision fallback copy", () => {
     );
   });
 
-  test("enforces free-text answer instructions for guardian.question when requestCode exists", async () => {
+  test("enforces free-text answer instructions into chat copy and keeps them out of vellum copy", async () => {
     const signal = makeSignal({
       contextPayload: {
         requestId: "req-pending-1",
@@ -101,13 +101,20 @@ describe("notification decision fallback copy", () => {
     });
     const decision = await evaluateSignal(signal, [
       "vellum",
+      "telegram",
     ] 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.telegram?.body).toContain("A1B2C3");
+    expect(decision.renderedCopy.telegram?.body).toContain("<your answer>");
+    expect(decision.renderedCopy.telegram?.body).not.toContain("approve");
+    expect(decision.renderedCopy.telegram?.body).not.toContain("reject");
+    // The bell and the banner read the vellum copy and act through the
+    // card, so the question arrives without the chat channel's mechanics.
+    expect(decision.renderedCopy.vellum?.body).toBe("What is the gate code?");
+    expect(decision.renderedCopy.vellum?.conversationSeedMessage).toBe(
+      "What is the gate code?",
+    );
   });
 
   test("enforcement appends free-text answer instructions when LLM copy only mentions request code", async () => {
@@ -118,10 +125,10 @@ describe("notification decision fallback copy", () => {
       name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ["vellum"],
+        selectedChannels: ["telegram"],
         reasoningSummary: "LLM decision",
         renderedCopy: {
-          vellum: {
+          telegram: {
             title: "Guardian Question",
             body: "Use reference code A1B2C3 for this request.",
           },
@@ -143,17 +150,19 @@ describe("notification decision fallback copy", () => {
     });
 
     const decision = await evaluateSignal(signal, [
-      "vellum",
+      "telegram",
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.body).toContain(
+    expect(decision.renderedCopy.telegram?.body).toContain(
       '"A1B2C3 <your answer>"',
     );
-    expect(decision.renderedCopy.vellum?.body).not.toContain(
+    expect(decision.renderedCopy.telegram?.body).not.toContain(
       '"A1B2C3 approve"',
     );
-    expect(decision.renderedCopy.vellum?.body).not.toContain('"A1B2C3 reject"');
+    expect(decision.renderedCopy.telegram?.body).not.toContain(
+      '"A1B2C3 reject"',
+    );
   });
 
   test("enforcement appends answer instructions when LLM copy incorrectly uses approve/reject wording", async () => {
@@ -164,10 +173,10 @@ describe("notification decision fallback copy", () => {
       name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ["vellum"],
+        selectedChannels: ["telegram"],
         reasoningSummary: "LLM decision",
         renderedCopy: {
-          vellum: {
+          telegram: {
             title: "Guardian Question",
             body: 'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
           },
@@ -189,11 +198,11 @@ describe("notification decision fallback copy", () => {
     });
 
     const decision = await evaluateSignal(signal, [
-      "vellum",
+      "telegram",
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.body).toContain(
+    expect(decision.renderedCopy.telegram?.body).toContain(
       '"A1B2C3 <your answer>"',
     );
   });
@@ -206,10 +215,10 @@ describe("notification decision fallback copy", () => {
       name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ["vellum"],
+        selectedChannels: ["telegram"],
         reasoningSummary: "LLM decision",
         renderedCopy: {
-          vellum: {
+          telegram: {
             title: "Guardian Question",
             body: "Use reference code A1B2C3 for this request.",
           },
@@ -230,12 +239,12 @@ describe("notification decision fallback copy", () => {
     });
 
     const decision = await evaluateSignal(signal, [
-      "vellum",
+      "telegram",
     ] 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.telegram?.body).toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.telegram?.body).toContain('"A1B2C3 reject"');
   });
 
   test("approval-mode enforcement removes conflicting answer-mode phrasing", async () => {
@@ -246,10 +255,10 @@ describe("notification decision fallback copy", () => {
       name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ["vellum"],
+        selectedChannels: ["telegram"],
         reasoningSummary: "LLM decision",
         renderedCopy: {
-          vellum: {
+          telegram: {
             title: "Guardian Question",
             body: 'Reference code: A1B2C3. Reply "A1B2C3 <your answer>".',
           },
@@ -270,13 +279,13 @@ describe("notification decision fallback copy", () => {
     });
 
     const decision = await evaluateSignal(signal, [
-      "vellum",
+      "telegram",
     ] 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.telegram?.body).toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.telegram?.body).toContain('"A1B2C3 reject"');
+    expect(decision.renderedCopy.telegram?.body).not.toContain("<your answer>");
   });
 
   test("slack approval copy is stripped of request-code instructions instead of enforced", async () => {
@@ -292,12 +301,18 @@ describe("notification decision fallback copy", () => {
 
     const decision = await evaluateSignal(signal, [
       "vellum",
+      "telegram",
       "slack",
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(true);
-    // Vellum keeps the code-reply directive.
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
+    // Telegram answers by typed reply and keeps the code-reply directive.
+    expect(decision.renderedCopy.telegram?.body).toContain('"A1B2C3 approve"');
+    // Vellum acts through the card: the same text as Slack, code-free.
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      decision.renderedCopy.slack?.body,
+    );
+    expect(decision.renderedCopy.vellum?.body).not.toContain("A1B2C3");
     // Slack renders Approve/Reject buttons — no code anywhere in its copy.
     expect(decision.renderedCopy.slack?.body).toBe(
       "Approve tool: bash — ls /tmp (requested by Alice)",
@@ -374,6 +389,110 @@ describe("notification decision fallback copy", () => {
   });
 });
 
+// ── Surfaces that act through the card ───────────────────────────────────
+
+/**
+ * The vellum copy is read by the bell detail, the OS banner, and the
+ * delivery audit row, and the platform push mirrors it. None of them takes
+ * a typed reply, so the chat channels' "Reference code / Reply CODE" copy
+ * is noise there and is kept out on every decision path.
+ */
+describe("guardian copy for surfaces that act through the card", () => {
+  beforeEach(() => {
+    configuredProvider = null;
+    extractedToolUse = null;
+  });
+
+  test("a question with options reaches the bell as the question and its options, nothing else", async () => {
+    const signal = makeSignal({
+      sourceChannel: "telegram",
+      contextPayload: {
+        requestId: "req-ask-bell-1",
+        requestCode: "E96831",
+        requestKind: "pending_question",
+        questionText:
+          "When you say it feels too harsh, what is the feeling exactly?",
+        options: [
+          { id: "heavy", label: "Lines too heavy" },
+          { id: "showy", label: "Feels showy" },
+          { id: "both", label: "Both, honestly" },
+        ],
+      },
+    });
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+      "telegram",
+    ] as NotificationChannel[]);
+
+    const expectedQuestion =
+      "When you say it feels too harsh, what is the feeling exactly?\n\n1. Lines too heavy\n2. Feels showy\n3. Both, honestly";
+    // The bell reads the seed; the banner reads the body. Line structure is
+    // preserved so the options render as lines rather than one run-on blob.
+    expect(decision.renderedCopy.vellum?.conversationSeedMessage).toBe(
+      expectedQuestion,
+    );
+    expect(decision.renderedCopy.vellum?.body).toBe(expectedQuestion);
+    expect(decision.renderedCopy.vellum?.deliveryText).toBe(expectedQuestion);
+    // The chat channel still carries the answer mechanics after the options.
+    expect(decision.renderedCopy.telegram?.deliveryText).toBe(
+      `${expectedQuestion}\n\nReference code: E96831. Reply "E96831 <your answer>".`,
+    );
+  });
+
+  test("model-authored code phrasing is stripped from vellum and platform copy", async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: "record_notification_decision",
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum", "platform"],
+        reasoningSummary: "LLM decision",
+        renderedCopy: {
+          vellum: {
+            title: "Tool Grant Request",
+            body: 'Alice is asking to run ls /tmp.\nApproval code: A1B2C3\nReply "A1B2C3 approve" or "A1B2C3 reject".',
+            conversationSeedMessage:
+              "**Alice** is asking to run `ls /tmp`.\n\nReference code: A1B2C3.",
+          },
+          platform: {
+            title: "Tool Grant Request",
+            body: 'Alice is asking to run ls /tmp. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+          },
+        },
+        dedupeKey: "guardian-question-vellum-llm-test",
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: "req-grant-vellum-1",
+        questionText: "Approve tool: bash (requested by Alice)",
+        requestCode: "A1B2C3",
+        requestKind: "tool_grant_request",
+        toolName: "bash",
+      },
+    });
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+      "platform",
+    ] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+    expect(decision.renderedCopy.vellum?.conversationSeedMessage).toBe(
+      "**Alice** is asking to run `ls /tmp`.",
+    );
+    expect(decision.renderedCopy.platform?.body).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+  });
+});
+
 // ── Access-request instruction enforcement ──────────────────────────────
 
 describe("access-request instruction enforcement", () => {
@@ -406,22 +525,24 @@ describe("access-request instruction enforcement", () => {
     };
   }
 
-  test("fallback copy includes access-request contract elements", async () => {
+  test("fallback copy carries the requester context and no reply mechanics", async () => {
     const signal = makeAccessRequestSignal();
     const decision = await evaluateSignal(signal, [
       "vellum",
+      "telegram",
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(true);
-    // Directive form, not prose mentions: the guardian must be able to reply
-    // with these exact code+verb tokens.
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 trust"');
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 block"');
-    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
+    for (const channel of ["vellum", "telegram"] as const) {
+      const body = decision.renderedCopy[channel]?.body ?? "";
+      expect(body).toContain("Alice");
+      expect(body).not.toContain("A1B2C3");
+      // Context, not mechanics: no surface offers an invite button.
+      expect(body).toContain('Reply "open invite flow"');
+    }
   });
 
-  test("enforcement appends contract when LLM copy is missing request code", async () => {
+  test("model copy with no mechanics keeps its text and gains the invite sentence", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -448,13 +569,12 @@ describe("access-request instruction enforcement", () => {
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 trust"');
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
-    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 block"');
-    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      'Someone wants access to your assistant.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+    );
   });
 
-  test("enforcement appends contract when LLM copy has code but missing invite flow", async () => {
+  test("model-authored code directives are stripped, leaving the ask", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -481,10 +601,12 @@ describe("access-request instruction enforcement", () => {
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      'Alice wants access.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+    );
   });
 
-  test("enforcement does not duplicate when LLM copy already has all required elements", async () => {
+  test("the code directive is stripped from model copy and the invite directive stays", async () => {
     const fullBody =
       'Alice wants access.\nReply "A1B2C3 verify" to send them a verification code, "A1B2C3 trust" to trust them without one, "A1B2C3 reject" to leave them unverified, or "A1B2C3 block" to block them.\nReply "open invite flow" to start Trusted Contacts invite flow.';
     configuredProvider = {
@@ -513,11 +635,14 @@ describe("access-request instruction enforcement", () => {
     ] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(false);
-    // Body should remain unchanged when all required elements are present
-    expect(decision.renderedCopy.vellum?.body).toBe(fullBody);
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      'Alice wants access.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+    );
   });
 
-  test("enforcement also applies to deliveryText and conversationSeedMessage", async () => {
+  test("the strip covers deliveryText and conversationSeedMessage too", async () => {
+    const withMechanics =
+      'Someone wants access.\nReply "A1B2C3 trust" to trust them, "A1B2C3 reject" to leave them unverified, or "A1B2C3 block" to block them.';
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -530,9 +655,9 @@ describe("access-request instruction enforcement", () => {
         renderedCopy: {
           telegram: {
             title: "Access Request",
-            body: "Someone wants access.",
-            deliveryText: "Someone wants access.",
-            conversationSeedMessage: "Someone wants access.",
+            body: withMechanics,
+            deliveryText: withMechanics,
+            conversationSeedMessage: withMechanics,
           },
         },
         dedupeKey: "access-req-multi-field",
@@ -545,19 +670,16 @@ describe("access-request instruction enforcement", () => {
       "telegram",
     ] as NotificationChannel[]);
 
-    expect(decision.renderedCopy.telegram?.deliveryText).toContain("A1B2C3");
-    expect(decision.renderedCopy.telegram?.deliveryText).toContain(
-      "open invite flow",
-    );
-    expect(decision.renderedCopy.telegram?.conversationSeedMessage).toContain(
-      "A1B2C3",
-    );
-    expect(decision.renderedCopy.telegram?.conversationSeedMessage).toContain(
-      "open invite flow",
+    const expected =
+      'Someone wants access.\nReply "open invite flow" to start Trusted Contacts invite flow.';
+    expect(decision.renderedCopy.telegram?.body).toBe(expected);
+    expect(decision.renderedCopy.telegram?.deliveryText).toBe(expected);
+    expect(decision.renderedCopy.telegram?.conversationSeedMessage).toBe(
+      expected,
     );
   });
 
-  test("enforcement appends contract when LLM copy contains conflicting instructions", async () => {
+  test("model copy that leaves the invite sentence out gets it appended", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -565,31 +687,33 @@ describe("access-request instruction enforcement", () => {
       name: "record_notification_decision",
       input: {
         shouldNotify: true,
-        selectedChannels: ["vellum"],
+        selectedChannels: ["telegram"],
         reasoningSummary: "LLM decision",
         renderedCopy: {
-          vellum: {
+          telegram: {
             title: "Access Request",
-            body: 'Alice wants access. Just reply "yes" or "no" to decide.',
+            body: "Alice wants access.",
+            deliveryText: "Alice wants access.",
           },
         },
-        dedupeKey: "access-req-conflicting",
+        dedupeKey: "access-req-invite-ensured",
         confidence: 0.9,
       },
     };
 
-    const signal = makeAccessRequestSignal();
-    const decision = await evaluateSignal(signal, [
-      "vellum",
+    const decision = await evaluateSignal(makeAccessRequestSignal(), [
+      "telegram",
     ] as NotificationChannel[]);
 
-    // Must contain the proper contract instructions despite conflicting LLM copy
-    expect(decision.renderedCopy.vellum?.body).toContain("A1B2C3 verify");
-    expect(decision.renderedCopy.vellum?.body).toContain("A1B2C3 reject");
-    expect(decision.renderedCopy.vellum?.body).toContain("open invite flow");
+    expect(decision.fallbackUsed).toBe(false);
+    const expected =
+      'Alice wants access.\nReply "open invite flow" to start Trusted Contacts invite flow.';
+    expect(decision.renderedCopy.telegram?.body).toBe(expected);
+    expect(decision.renderedCopy.telegram?.deliveryText).toBe(expected);
+    expect(decision.renderedCopy.telegram?.title).toBe("Access Request");
   });
 
-  test("enforcement appends invite directive when requestCode is absent", async () => {
+  test("the invite directive stays even when the request has no code", async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -602,7 +726,7 @@ describe("access-request instruction enforcement", () => {
         renderedCopy: {
           vellum: {
             title: "Access Request",
-            body: "Someone wants access to your assistant.",
+            body: 'Someone wants access to your assistant.\nReply "open invite flow" to start Trusted Contacts invite flow.',
           },
         },
         dedupeKey: "access-req-no-code-invite",
@@ -622,11 +746,9 @@ describe("access-request instruction enforcement", () => {
     ] 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");
-    // 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).toBe(
+      'Someone wants access to your assistant.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+    );
   });
 });