@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -7,6 +7,7 @@ const runDeterministicChecksMock = mock();
 const createEventMock = mock();
 const updateEventDedupeKeyMock = mock();
 const dispatchDecisionMock = mock();
+const isPlatformClientConfiguredMock = mock();
 
 mock.module("../channels/config.js", () => ({
   getDeliverableChannels: () => ["vellum", "telegram"],
@@ -38,6 +39,12 @@ mock.module("../notifications/broadcaster.js", () => ({
   },
 }));
 
+// Capture the real enforcement before the module mock below replaces it:
+// the single_channel interplay tests exercise the genuine cap logic against
+// the urgency force-add's channel ordering.
+const { enforceRoutingIntent: realEnforceRoutingIntent } =
+  await import("../notifications/decision-engine.js");
+
 mock.module("../notifications/decision-engine.js", () => ({
   evaluateSignal: (...args: unknown[]) => evaluateSignalMock(...args),
   enforceRoutingIntent: (...args: unknown[]) =>
@@ -78,27 +85,41 @@ mock.module("../notifications/runtime-dispatch.js", () => ({
   dispatchDecision: (...args: unknown[]) => dispatchDecisionMock(...args),
 }));
 
+mock.module("../platform/client.js", () => ({
+  // The adapter import graph needs the class symbol; nothing in these tests
+  // dispatches through it.
+  VellumPlatformClient: class {
+    static async create(): Promise<null> {
+      return null;
+    }
+  },
+  isPlatformClientConfigured: () => isPlatformClientConfiguredMock(),
+}));
+
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 
-describe("emitNotificationSignal routing intent re-persistence", () => {
-  beforeEach(() => {
-    evaluateSignalMock.mockReset();
-    enforceRoutingIntentMock.mockReset();
-    updateDecisionMock.mockReset();
-    runDeterministicChecksMock.mockReset();
-    createEventMock.mockReset();
-    updateEventDedupeKeyMock.mockReset();
-    dispatchDecisionMock.mockReset();
-
-    createEventMock.mockReturnValue({ id: "evt-1" });
-    runDeterministicChecksMock.mockResolvedValue({ passed: true });
-    dispatchDecisionMock.mockResolvedValue({
-      dispatched: true,
-      reason: "ok",
-      deliveryResults: [],
-    });
+beforeEach(() => {
+  evaluateSignalMock.mockReset();
+  enforceRoutingIntentMock.mockReset();
+  updateDecisionMock.mockReset();
+  runDeterministicChecksMock.mockReset();
+  createEventMock.mockReset();
+  updateEventDedupeKeyMock.mockReset();
+  dispatchDecisionMock.mockReset();
+  isPlatformClientConfiguredMock.mockReset();
+
+  createEventMock.mockReturnValue({ id: "evt-1" });
+  runDeterministicChecksMock.mockResolvedValue({ passed: true });
+  dispatchDecisionMock.mockResolvedValue({
+    dispatched: true,
+    reason: "ok",
+    deliveryResults: [],
   });
+  isPlatformClientConfiguredMock.mockResolvedValue(true);
+  enforceRoutingIntentMock.mockImplementation((decision: unknown) => decision);
+});
 
+describe("emitNotificationSignal routing intent re-persistence", () => {
   test("re-persists selectedChannels/reasoningSummary when enforcement changes the decision", async () => {
     const preDecision = {
       shouldNotify: true,
@@ -226,21 +247,6 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
 });
 
 describe("emitNotificationSignal source-active pre-gate", () => {
-  beforeEach(() => {
-    evaluateSignalMock.mockReset();
-    runDeterministicChecksMock.mockReset();
-    createEventMock.mockReset();
-    dispatchDecisionMock.mockReset();
-
-    createEventMock.mockReturnValue({ id: "evt-src-active" });
-    runDeterministicChecksMock.mockResolvedValue({ passed: true });
-    dispatchDecisionMock.mockResolvedValue({
-      dispatched: true,
-      reason: "ok",
-      deliveryResults: [],
-    });
-  });
-
   test("suppresses visibleInSourceNow signals before the decision engine runs", async () => {
     const result = await emitNotificationSignal({
       sourceEventName: "ingress.trusted_contact.verification_sent",
@@ -294,23 +300,6 @@ describe("emitNotificationSignal source-active pre-gate", () => {
 });
 
 describe("access-request vellum floor", () => {
-  beforeEach(() => {
-    evaluateSignalMock.mockReset();
-    enforceRoutingIntentMock.mockReset();
-    updateDecisionMock.mockReset();
-    runDeterministicChecksMock.mockReset();
-    createEventMock.mockReset();
-    updateEventDedupeKeyMock.mockReset();
-    dispatchDecisionMock.mockReset();
-    createEventMock.mockReturnValue({ id: "evt-1" });
-    runDeterministicChecksMock.mockResolvedValue({ passed: true });
-    dispatchDecisionMock.mockResolvedValue({
-      dispatched: true,
-      reason: "ok",
-      deliveryResults: [],
-    });
-  });
-
   test("rescues a suppressed access-request decision onto the vellum channel", async () => {
     evaluateSignalMock.mockResolvedValue({
       shouldNotify: false,
@@ -467,3 +456,255 @@ describe("access-request vellum floor", () => {
     expect(dispatched.reasoningSummary).not.toContain("vellum forced");
   });
 });
+
+describe("high/critical urgency channel force", () => {
+  function makeDecision(overrides: Record<string, unknown>) {
+    return {
+      shouldNotify: true,
+      selectedChannels: ["telegram"],
+      reasoningSummary: "LLM selected telegram only",
+      renderedCopy: {},
+      dedupeKey: "dedupe-urg-1",
+      confidence: 0.9,
+      fallbackUsed: false,
+      persistedDecisionId: "dec-urg-1",
+      ...overrides,
+    };
+  }
+
+  function emitWithUrgency(urgency: "low" | "medium" | "high" | "critical") {
+    return emitNotificationSignal({
+      sourceEventName: "schedule.notify",
+      sourceChannel: "scheduler",
+      sourceContextId: "rem-urg-1",
+      attentionHints: {
+        requiresAction: true,
+        urgency,
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: { reminderId: "rem-urg-1" },
+    });
+  }
+
+  test("forces vellum and platform onto a high-urgency decision missing both", async () => {
+    evaluateSignalMock.mockResolvedValue(makeDecision({}));
+
+    const result = await emitWithUrgency("high");
+
+    expect(result.dispatched).toBe(true);
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toContain("vellum");
+    expect(dispatched.selectedChannels).toContain("platform");
+    expect(dispatched.selectedChannels).toContain("telegram");
+    expect(dispatched.reasoningSummary).toContain(
+      "(vellum, platform forced: high urgency)",
+    );
+  });
+
+  test("re-persists the stored decision with the force-added channels when routing enforcement is a no-op", async () => {
+    evaluateSignalMock.mockResolvedValue(makeDecision({}));
+
+    await emitWithUrgency("high");
+
+    // The identity enforcement mock leaves the decision unchanged, so only
+    // the urgency force-add differs from the evaluated decision. The stored
+    // row must still be synced to the dispatched channels.
+    expect(updateDecisionMock).toHaveBeenCalledTimes(1);
+    expect(updateDecisionMock).toHaveBeenCalledWith("dec-urg-1", {
+      selectedChannels: ["vellum", "telegram", "platform"],
+      reasoningSummary:
+        "LLM selected telegram only (vellum, platform forced: high urgency)",
+      validationResults: {
+        dedupeKey: "dedupe-urg-1",
+        channelCount: 3,
+        hasCopy: false,
+      },
+    });
+  });
+
+  test("forces only the missing channel when the other is already selected", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ selectedChannels: ["vellum"] }),
+    );
+
+    await emitWithUrgency("critical");
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(dispatched.reasoningSummary).toContain(
+      "(platform forced: critical urgency)",
+    );
+  });
+
+  test("leaves a high-urgency decision untouched when both channels are already selected", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ selectedChannels: ["vellum", "platform"] }),
+    );
+
+    await emitWithUrgency("high");
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(dispatched.reasoningSummary).not.toContain("forced");
+    expect(updateDecisionMock).not.toHaveBeenCalled();
+  });
+
+  test("leaves medium and low urgency selections untouched", async () => {
+    for (const urgency of ["medium", "low"] as const) {
+      dispatchDecisionMock.mockClear();
+      evaluateSignalMock.mockResolvedValue(makeDecision({}));
+
+      await emitWithUrgency(urgency);
+
+      const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+        selectedChannels: string[];
+        reasoningSummary: string;
+      };
+      expect(dispatched.selectedChannels).toEqual(["telegram"]);
+      expect(dispatched.reasoningSummary).not.toContain("forced");
+    }
+  });
+
+  test("does not force channels when the decision suppresses the notification", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ shouldNotify: false, selectedChannels: [] }),
+    );
+
+    await emitWithUrgency("high");
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      shouldNotify: boolean;
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.shouldNotify).toBe(false);
+    expect(dispatched.selectedChannels).toEqual([]);
+    expect(dispatched.reasoningSummary).not.toContain("forced");
+  });
+
+  test("routing-intent enforcement runs after the force-add and can cap channels", async () => {
+    evaluateSignalMock.mockResolvedValue(makeDecision({}));
+    // single_channel enforcement caps the selection to the source channel.
+    enforceRoutingIntentMock.mockImplementation(
+      (decision: { selectedChannels: string[] }) => ({
+        ...decision,
+        selectedChannels: ["telegram"],
+      }),
+    );
+
+    await emitNotificationSignal({
+      sourceEventName: "schedule.notify",
+      sourceChannel: "scheduler",
+      sourceContextId: "rem-urg-2",
+      routingIntent: "single_channel",
+      attentionHints: {
+        requiresAction: true,
+        urgency: "high",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: { reminderId: "rem-urg-2" },
+    });
+
+    // Enforcement sees the force-added channels...
+    const enforcedInput = enforceRoutingIntentMock.mock.calls[0][0] as {
+      selectedChannels: string[];
+    };
+    expect(enforcedInput.selectedChannels).toEqual([
+      "vellum",
+      "telegram",
+      "platform",
+    ]);
+    // ...and its cap wins over the force-add.
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+    };
+    expect(dispatched.selectedChannels).toEqual(["telegram"]);
+  });
+
+  test("forces only vellum when the platform client is not configured", async () => {
+    isPlatformClientConfiguredMock.mockResolvedValue(false);
+    evaluateSignalMock.mockResolvedValue(makeDecision({}));
+
+    await emitWithUrgency("high");
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toEqual(["vellum", "telegram"]);
+    expect(dispatched.reasoningSummary).toContain(
+      "(vellum forced: high urgency)",
+    );
+  });
+
+  // Real single_channel enforcement caps to the source channel when it is
+  // connected, else to the FIRST selected channel. The force-add prepends
+  // vellum precisely so that fallback keeps the in-app banner; these tests
+  // run the genuine enforcement to pin the interplay.
+  describe("interplay with real single_channel enforcement", () => {
+    beforeEach(() => {
+      enforceRoutingIntentMock.mockImplementation(
+        realEnforceRoutingIntent as (...args: unknown[]) => unknown,
+      );
+    });
+
+    function emitHighUrgencySingleChannel(
+      sourceChannel: "watcher" | "assistant_tool",
+    ) {
+      return emitNotificationSignal({
+        sourceEventName: "watcher.escalation",
+        sourceChannel,
+        sourceContextId: "watch-1",
+        routingIntent: "single_channel",
+        attentionHints: {
+          requiresAction: true,
+          urgency: "high",
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {},
+      });
+    }
+
+    test("vellum survives the cap when the decision selected only vellum", async () => {
+      evaluateSignalMock.mockResolvedValue(
+        makeDecision({ selectedChannels: ["vellum"] }),
+      );
+
+      await emitHighUrgencySingleChannel("watcher");
+
+      // Force-add appends platform: ["vellum", "platform"]. The source
+      // channel is not connected, so the cap falls back to index 0.
+      const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+        selectedChannels: string[];
+      };
+      expect(dispatched.selectedChannels).toEqual(["vellum"]);
+    });
+
+    test("the cap picks the prepended vellum when the decision selected another channel", async () => {
+      evaluateSignalMock.mockResolvedValue(
+        makeDecision({ selectedChannels: ["telegram"] }),
+      );
+
+      await emitHighUrgencySingleChannel("assistant_tool");
+
+      // Force-add yields ["vellum", "telegram", "platform"]; the
+      // non-connected source channel makes the cap take index 0.
+      const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+        selectedChannels: string[];
+      };
+      expect(dispatched.selectedChannels).toEqual(["vellum"]);
+    });
+  });
+});

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -14,6 +14,13 @@ mock.module("../messaging/providers/slack/withdraw.js", () => ({
   withdrawSlackApprovalCard,
 }));
 
+const withdrawTelegramApprovalCard = mock(
+  async (_params: Record<string, unknown>) => {},
+);
+mock.module("../messaging/providers/telegram-bot/withdraw.js", () => ({
+  withdrawTelegramApprovalCard,
+}));
+
 // The recorder writes through the gateway client; serve that surface from
 // the in-memory sim the assertions read.
 import {
@@ -60,6 +67,7 @@ describe("withdrawGuardianRequestCards", () => {
     completeSurfaceAndNotify.mockClear();
     markSurfaceCompleted.mockClear();
     withdrawSlackApprovalCard.mockClear();
+    withdrawTelegramApprovalCard.mockClear();
   });
 
   test("withdraws + broadcasts the in-app card when the decision came from another surface", async () => {
@@ -199,7 +207,7 @@ describe("withdrawGuardianRequestCards", () => {
     expect(withdrawSlackApprovalCard).toHaveBeenCalledTimes(1);
   });
 
-  test("ignores channels without in-place edit support (telegram)", async () => {
+  test("withdraws the Telegram card with a status reply when resolved from another surface", async () => {
     const req = makeRequest({ sourceChannel: "telegram" });
     bridgeState.seedDelivery({
       requestId: req.id,
@@ -208,10 +216,90 @@ describe("withdrawGuardianRequestCards", () => {
       destinationMessageId: "9",
     });
 
-    await withdrawGuardianRequestCards({ request: req, status: "approved" });
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "approved",
+      originChannel: "vellum",
+    });
 
     expect(withdrawSlackApprovalCard).not.toHaveBeenCalled();
-    expect(completeSurfaceAndNotify).not.toHaveBeenCalled();
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledTimes(1);
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "approved",
+      postStatusReply: true,
+    });
+  });
+
+  test("suppresses the Telegram status reply only when the origin flow replies to the guardian", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+      destinationMessageId: "9",
+    });
+
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "denied",
+      originChannel: "telegram",
+      decidedAction: "reject",
+      hasOriginGuardianReply: true,
+    });
+
+    // The resolver's guardian-facing reply is being delivered in that chat;
+    // withdrawal only drops the keyboard.
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "denied",
+      decidedAction: "reject",
+      postStatusReply: false,
+    });
+  });
+
+  test("posts the Telegram status reply for origin decisions without a guardian-facing resolver reply", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+      destinationMessageId: "9",
+    });
+
+    // Most resolvers (tool grants, tool approvals, questions) reply to the
+    // requester only, so the quoted status reply is the guardian's only
+    // durable outcome even for a decision made on Telegram itself.
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "approved",
+      originChannel: "telegram",
+      decidedAction: "approve_once",
+      hasOriginGuardianReply: false,
+    });
+
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "approved",
+      decidedAction: "approve_once",
+      postStatusReply: true,
+    });
+  });
+
+  test("skips the Telegram edit when no channel message id was captured", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+    });
+
+    await withdrawGuardianRequestCards({ request: req, status: "approved" });
+
+    expect(withdrawTelegramApprovalCard).not.toHaveBeenCalled();
   });
 
   test("is best-effort: a failing surface never blocks the others or throws", async () => {

package/src/__tests__/http-user-message-parity.test.ts

@@ -442,6 +442,72 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
   });
 });
 
+describe("HTTP POST /v1/messages visibleAppId transport metadata", () => {
+  beforeEach(() => {
+    routeGuardianReplyMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  async function captureTransport(
+    body: Record<string, unknown>,
+  ): Promise<Record<string, unknown> | undefined> {
+    const conversation = makeConversation({
+      persistUserMessage: mock(async () => ({
+        id: "persisted-msg-id",
+        deduplicated: false,
+      })),
+      runAgentLoop: mock(async () => undefined),
+    });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage("hello", conversation, body, {
+      onGetOrCreateConversation: (_conversationId, opts) => {
+        capturedOptions = opts;
+      },
+    });
+
+    expect(res.status).toBe(202);
+    return capturedOptions?.transport as Record<string, unknown> | undefined;
+  }
+
+  test("carries the reported visible app onto the transport", async () => {
+    expect(await captureTransport({ visibleAppId: "app-abc" })).toEqual({
+      channelId: "vellum",
+      interfaceId: "macos",
+      visibleAppId: "app-abc",
+    });
+  });
+
+  test("omits visibleAppId when no app is in view", async () => {
+    expect(await captureTransport({})).toEqual({
+      channelId: "vellum",
+      interfaceId: "macos",
+    });
+  });
+
+  test("carries a long plugin-bundled app id, which the viewer can open", async () => {
+    // `plugins~<plugin>~<app>`, both segments at the filesystem's 255-byte
+    // ceiling. The open route resolves ids this long, so ingress must not clip
+    // them or the app on screen goes unreported.
+    const longPluginAppId = `plugins~${"p".repeat(255)}~${"a".repeat(255)}`;
+
+    expect(await captureTransport({ visibleAppId: longPluginAppId })).toEqual({
+      channelId: "vellum",
+      interfaceId: "macos",
+      visibleAppId: longPluginAppId,
+    });
+  });
+
+  test("drops a traversal-shaped visibleAppId without rejecting the message", async () => {
+    expect(
+      await captureTransport({ visibleAppId: "../../etc/passwd" }),
+    ).toEqual({
+      channelId: "vellum",
+      interfaceId: "macos",
+    });
+  });
+});
+
 // ============================================================================
 // CLIENT METADATA — sanitized x-vellum-* headers persisted under
 // metadata.client for turn analytics

package/src/__tests__/list-messages-attachments.test.ts

@@ -193,6 +193,93 @@ describe("handleListMessages attachments", () => {
     expect(docAtt!.data).toBeUndefined();
   });
 
+  test("contentBlocks attachment blocks are metadata-only references", async () => {
+    // The flat `attachments` array is the sole payload carrier. An inline
+    // file-block ref places an `attachment` block in `contentBlocks`, but
+    // that block must reference the row by id without repeating its base64:
+    // duplicating it doubles every image in the response and in client
+    // memory.
+    const conv = createConversation();
+    const stored = uploadAttachment("photo.png", "image/png", IMAGE_BASE64);
+    const msg = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "check this image" },
+        {
+          type: "file",
+          source: { type: "workspace_ref", attachmentId: stored.id },
+          filename: "photo.png",
+          media_type: "image/png",
+        },
+      ]),
+    );
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as {
+      messages: {
+        attachments?: AttachmentPayload[];
+        contentBlocks?: Array<{
+          type: string;
+          attachment?: {
+            id: string;
+            data?: string;
+            thumbnailData?: string;
+          };
+        }>;
+      }[];
+    };
+
+    expect(body.messages).toHaveLength(1);
+    const row = body.messages[0];
+
+    // Payload ships on the flat array.
+    expect(row.attachments).toHaveLength(1);
+    expect(row.attachments![0].data).toBe(IMAGE_BASE64);
+
+    // The inline block references the same row without the payload.
+    const blocks = (row.contentBlocks ?? []).filter(
+      (b) => b.type === "attachment",
+    );
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].attachment!.id).toBe(stored.id);
+    expect(blocks[0].attachment!.data).toBeUndefined();
+    expect(blocks[0].attachment!.thumbnailData).toBeUndefined();
+  });
+
+  test("synthesized attachment blocks are metadata-only references", async () => {
+    // Directive attachments take the appendix path (no file-block ref), which
+    // must strip the payload the same way the inline path does.
+    const conv = createConversation();
+    const msg = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "" }]),
+    );
+    const stored = uploadAttachment("output.png", "image/png", IMAGE_BASE64);
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as {
+      messages: {
+        attachments?: AttachmentPayload[];
+        contentBlocks?: Array<{
+          type: string;
+          attachment?: { id: string; data?: string };
+        }>;
+      }[];
+    };
+
+    const row = body.messages[0];
+    expect(row.attachments![0].data).toBe(IMAGE_BASE64);
+    const blocks = (row.contentBlocks ?? []).filter(
+      (b) => b.type === "attachment",
+    );
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].attachment!.data).toBeUndefined();
+  });
+
   test("attachment-only assistant message synthesizes contentBlocks", async () => {
     // When the assistant's entire response was a <vellum-attachment/> tag,
     // parseDirectives strips it → cleanText is empty → renderHistoryContent