@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/notifications/__tests__/edit-notification.test.ts

@@ -0,0 +1,330 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { FeedItem } from "../../home/feed-types.js";
+import type { NotificationDeliveryRow } from "../deliveries-store.js";
+
+// ── Module mocks ───────────────────────────────────────────────────────
+//
+// The home-feed writer is deliberately NOT mocked: these tests exercise
+// the real on-disk patch semantics through a temp workspace so the
+// "an empty title never clears the field" guarantee is covered end to
+// end. Only the sqlite-backed stores, the broadcaster, and the SSE hub
+// are intercepted.
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => () => {},
+  },
+  broadcastMessage: () => {},
+}));
+
+let decisionRow: { id: string } | null = null;
+let deliveryRows: NotificationDeliveryRow[] = [];
+const renderedCopyPatches: Array<{
+  id: string;
+  patch: { renderedTitle?: string; renderedBody?: string };
+}> = [];
+
+mock.module("../decisions-store.js", () => ({
+  findLatestDecisionByEventId: () => decisionRow,
+}));
+
+mock.module("../deliveries-store.js", () => ({
+  findDeliveriesByDecisionId: () => deliveryRows,
+  updateDeliveryRenderedCopy: (
+    id: string,
+    patch: { renderedTitle?: string; renderedBody?: string },
+  ) => {
+    renderedCopyPatches.push({ id, patch });
+    return true;
+  },
+}));
+
+const adapterUpdates: Array<{ title?: string; body?: string }> = [];
+let adapterSupportsUpdate = true;
+
+mock.module("../emit-signal.js", () => ({
+  getBroadcaster: () => ({
+    getAdapter: () =>
+      adapterSupportsUpdate
+        ? {
+            update: async (
+              _target: unknown,
+              patch: { title?: string; body?: string },
+            ) => {
+              adapterUpdates.push(patch);
+              return { success: true };
+            },
+          }
+        : {},
+  }),
+}));
+
+const { appendFeedItem, readHomeFeed } =
+  await import("../../home/feed-writer.js");
+const { editNotification, normalizeFeedItemId, feedItemIdToSignalId } =
+  await import("../edit-notification.js");
+
+// ── Fixtures ───────────────────────────────────────────────────────────
+
+const SIGNAL_ID = "sig-1";
+const FEED_ITEM_ID = `notif:${SIGNAL_ID}`;
+
+function makeItem(overrides: Partial<FeedItem> = {}): FeedItem {
+  return {
+    id: FEED_ITEM_ID,
+    type: "notification",
+    priority: 50,
+    title: "Backup complete",
+    summary: "Nightly backup finished",
+    timestamp: "2026-04-14T12:00:00.000Z",
+    status: "new",
+    createdAt: "2026-04-14T12:00:00.000Z",
+    ...overrides,
+  } as FeedItem;
+}
+
+function makeDelivery(
+  overrides: Partial<NotificationDeliveryRow> = {},
+): NotificationDeliveryRow {
+  return {
+    id: "del-1",
+    notificationDecisionId: "dec-1",
+    channel: "slack",
+    destination: "C123",
+    status: "sent",
+    attempt: 1,
+    renderedTitle: "Backup complete",
+    renderedBody: "Nightly backup finished",
+    errorCode: null,
+    errorMessage: null,
+    sentAt: 1700000000000,
+    conversationId: null,
+    messageId: "1700000000.0001",
+    conversationStrategy: null,
+    conversationAction: null,
+    conversationTargetId: null,
+    conversationFallbackUsed: null,
+    clientDeliveryStatus: null,
+    clientDeliveryError: null,
+    clientDeliveryAt: null,
+    createdAt: 1700000000000,
+    updatedAt: 1700000000000,
+    ...overrides,
+  };
+}
+
+function readItem(id = FEED_ITEM_ID): FeedItem | undefined {
+  return readHomeFeed().items.find((item) => item.id === id);
+}
+
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-edit-notif-"));
+  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  decisionRow = null;
+  deliveryRows = [];
+  renderedCopyPatches.length = 0;
+  adapterUpdates.length = 0;
+  adapterSupportsUpdate = true;
+});
+
+afterEach(() => {
+  if (origWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+  }
+  try {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+});
+
+// ── Tests ──────────────────────────────────────────────────────────────
+
+describe("normalizeFeedItemId", () => {
+  test("adds the notif: prefix to a bare uuid and leaves prefixed ids alone", () => {
+    expect(normalizeFeedItemId(SIGNAL_ID)).toBe(FEED_ITEM_ID);
+    expect(normalizeFeedItemId(` ${FEED_ITEM_ID} `)).toBe(FEED_ITEM_ID);
+    expect(feedItemIdToSignalId(FEED_ITEM_ID)).toBe(SIGNAL_ID);
+  });
+});
+
+describe("editNotification", () => {
+  test("applies a title edit to the feed item", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!.feedItem.title).toBe("Backup finished early");
+    expect(readItem()!.title).toBe("Backup finished early");
+    expect(readItem()!.summary).toBe("Nightly backup finished");
+  });
+
+  test("accepts a bare signal uuid as the id", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({
+      id: SIGNAL_ID,
+      title: "Renamed via bare id",
+    });
+
+    expect(result!.feedItem.id).toBe(FEED_ITEM_ID);
+    expect(readItem()!.title).toBe("Renamed via bare id");
+  });
+
+  test("an empty title edit leaves the previous title intact", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({ id: FEED_ITEM_ID, title: "" });
+
+    expect(result).not.toBeNull();
+    expect(result!.feedItem.title).toBe("Backup complete");
+    expect(readItem()!.title).toBe("Backup complete");
+  });
+
+  test("a whitespace-only title edit leaves the previous title intact", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({ id: FEED_ITEM_ID, title: "   \t" });
+
+    expect(result!.feedItem.title).toBe("Backup complete");
+    expect(readItem()!.title).toBe("Backup complete");
+  });
+
+  test("an empty title edit does not push a channel update", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [makeDelivery()];
+
+    const result = await editNotification({ id: FEED_ITEM_ID, title: "" });
+
+    expect(result!.channels).toEqual([]);
+    expect(adapterUpdates).toHaveLength(0);
+    expect(renderedCopyPatches).toHaveLength(0);
+  });
+
+  test("a body-only edit does not disturb the title", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      body: "Nightly backup finished in 4 minutes",
+    });
+
+    expect(result!.feedItem.title).toBe("Backup complete");
+    expect(result!.feedItem.summary).toBe(
+      "Nightly backup finished in 4 minutes",
+    );
+    expect(readItem()!.title).toBe("Backup complete");
+  });
+
+  test("a feed-only edit skips channel updates entirely", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [makeDelivery()];
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      status: "dismissed",
+    });
+
+    expect(result!.feedItem.status).toBe("dismissed");
+    expect(result!.channels).toEqual([]);
+    expect(adapterUpdates).toHaveLength(0);
+  });
+
+  test("returns null for an unknown id", async () => {
+    await appendFeedItem(makeItem());
+
+    const result = await editNotification({
+      id: "notif:does-not-exist",
+      title: "Nope",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  test("pushes the new copy to update-capable channel deliveries", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [makeDelivery()];
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+      body: "Done in 4 minutes",
+    });
+
+    expect(adapterUpdates).toEqual([
+      { title: "Backup finished early", body: "Done in 4 minutes" },
+    ]);
+    expect(renderedCopyPatches).toEqual([
+      {
+        id: "del-1",
+        patch: {
+          renderedTitle: "Backup finished early",
+          renderedBody: "Done in 4 minutes",
+        },
+      },
+    ]);
+    expect(result!.channels).toEqual([
+      { channel: "slack", deliveryId: "del-1", outcome: "updated" },
+    ]);
+  });
+
+  test("reports channels whose adapter cannot edit in place as unsupported", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [makeDelivery()];
+    adapterSupportsUpdate = false;
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+    });
+
+    expect(result!.channels[0]!.outcome).toBe("unsupported");
+    expect(renderedCopyPatches).toHaveLength(0);
+  });
+
+  test("skips deliveries that never reached sent", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [makeDelivery({ status: "failed" })];
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+    });
+
+    expect(result!.channels[0]!.outcome).toBe("skipped");
+    expect(adapterUpdates).toHaveLength(0);
+  });
+
+  test("skips channel updates when the feed item has no persisted decision", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = null;
+
+    const result = await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+    });
+
+    expect(result!.channels).toEqual([]);
+    expect(adapterUpdates).toHaveLength(0);
+  });
+});

package/src/notifications/__tests__/guardian-delivery-recorder.test.ts

@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const createGuardianRequestDeliveryMock = mock();
+const updateGuardianRequestDeliveryMock = mock();
+
+mock.module("../../channels/gateway-guardian-requests.js", () => ({
+  createGuardianRequestDelivery: (...args: unknown[]) =>
+    createGuardianRequestDeliveryMock(...args),
+  updateGuardianRequestDelivery: (...args: unknown[]) =>
+    updateGuardianRequestDeliveryMock(...args),
+}));
+
+import { recordGuardianRequestDeliveries } from "../guardian-delivery-recorder.js";
+import type { NotificationDeliveryResult } from "../types.js";
+
+beforeEach(() => {
+  createGuardianRequestDeliveryMock.mockReset();
+  updateGuardianRequestDeliveryMock.mockReset();
+  createGuardianRequestDeliveryMock.mockImplementation(async () => ({
+    id: `row-${createGuardianRequestDeliveryMock.mock.calls.length}`,
+  }));
+  updateGuardianRequestDeliveryMock.mockResolvedValue(undefined);
+});
+
+describe("recordGuardianRequestDeliveries", () => {
+  test("records rows only for addressable channels, skipping platform", async () => {
+    const deliveryResults: NotificationDeliveryResult[] = [
+      {
+        channel: "vellum",
+        destination: "vellum",
+        status: "sent",
+        conversationId: "conv-1",
+      },
+      {
+        // A forced platform push has no endpoint, so the broadcaster falls
+        // back to the channel name as the destination -- it must never be
+        // persisted as a destinationChatId.
+        channel: "platform",
+        destination: "platform",
+        status: "pending",
+      },
+      {
+        channel: "telegram",
+        destination: "12345",
+        status: "sent",
+        conversationId: "conv-1",
+        messageId: "tg-77",
+      },
+    ];
+
+    await recordGuardianRequestDeliveries({
+      requestId: "req-1",
+      deliveryResults,
+    });
+
+    const channels = createGuardianRequestDeliveryMock.mock.calls.map(
+      (call) => (call[0] as { destinationChannel: string }).destinationChannel,
+    );
+    expect(channels).toEqual(["vellum", "telegram"]);
+
+    const telegramRow = createGuardianRequestDeliveryMock.mock.calls[1]![0] as {
+      destinationChatId?: string;
+      destinationMessageId?: string;
+    };
+    expect(telegramRow.destinationChatId).toBe("12345");
+    expect(telegramRow.destinationMessageId).toBe("tg-77");
+
+    // Status patches apply only to the rows that were created.
+    expect(updateGuardianRequestDeliveryMock).toHaveBeenCalledTimes(2);
+  });
+});

package/src/notifications/__tests__/home-feed-side-effect.test.ts

@@ -320,11 +320,9 @@ describe("writeHomeFeedItemForSignal", () => {
     expect(appendCalls).toHaveLength(0);
   });
 
-  test("writes a feed item with undefined title when only the body is available", async () => {
-    // Regression: when `notifications send` is called without `--title`, the
-    // notification pipeline must not manufacture a title (the LLM's rendered
-    // copy echoes the body into `renderedCopy.title`). Leave `title`
-    // undefined so renderers fall back to `summary` instead of stuttering.
+  test("derives a title from the summary when only the body is available", async () => {
+    // With no authored candidate at all, the title is derived from the
+    // summary rather than left off: every row carries a headline.
     conversationRow = { conversationType: "background" };
     const signal = makeSignal({
       sourceEventName: "example.event",
@@ -335,14 +333,14 @@ describe("writeHomeFeedItemForSignal", () => {
 
     expect(item).not.toBeNull();
     expect(appendCalls).toHaveLength(1);
-    expect(appendCalls[0]!.title).toBeUndefined();
+    expect(appendCalls[0]!.title).toBe("Real body");
     expect(appendCalls[0]!.summary).toBe("Real body");
   });
 
-  test("ignores LLM-rendered title when no payload title was supplied", async () => {
-    // The LLM often echoes the body verbatim into `renderedCopy.title` when
-    // the source didn't pass one. The home-feed writer must NOT promote that
-    // echo into the feed item — only an explicit source title is honored.
+  test("uses the LLM-rendered title when no payload title was supplied", async () => {
+    // The model authors `renderedCopy.title` as a topic headline, and the
+    // decision engine validates it before it gets here, so it is the second
+    // candidate after the payload title.
     conversationRow = { conversationType: "background" };
     const signal = makeSignal({
       sourceEventName: "example.event",
@@ -351,7 +349,7 @@ describe("writeHomeFeedItemForSignal", () => {
     const decision = makeDecision({
       renderedCopy: {
         vellum: {
-          title: "Real body",
+          title: "Nightly sync finished",
           body: "Real body",
         },
       },
@@ -361,10 +359,170 @@ describe("writeHomeFeedItemForSignal", () => {
 
     expect(item).not.toBeNull();
     expect(appendCalls).toHaveLength(1);
-    expect(appendCalls[0]!.title).toBeUndefined();
+    expect(appendCalls[0]!.title).toBe("Nightly sync finished");
     expect(appendCalls[0]!.summary).toBe("Real body");
   });
 
+  test("payload title wins over the rendered title when it is clean", async () => {
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      sourceEventName: "example.event",
+      contextPayload: { title: "Payload headline" },
+    });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "Model headline",
+          body: "A description of what the run did.",
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Payload headline");
+    expect(appendCalls[0]!.title).toBe("Payload headline");
+  });
+
+  test("keeps a payload title that opens the summary", async () => {
+    // A correct topic headline is usually the opening noun phrase of the body,
+    // so an authored title that overlaps the summary still wins.
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      sourceEventName: "example.event",
+      contextPayload: { title: "Nightly Backup Failure" },
+    });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "Reminder plumbing check",
+          body: "Nightly backup failure on db-primary at 02:14. Retry scheduled.",
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Nightly Backup Failure");
+    expect(appendCalls[0]!.summary).toBe(
+      "Nightly backup failure on db-primary at 02:14. Retry scheduled.",
+    );
+  });
+
+  test("keeps a payload title that matches the summary's first sentence", async () => {
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      sourceEventName: "example.event",
+      contextPayload: { title: "Test notifications reminder." },
+    });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "Model headline",
+          body: "Test notifications reminder. It fired on schedule.",
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Test notifications reminder.");
+    expect(appendCalls[0]!.summary).toBe(
+      "Test notifications reminder. It fired on schedule.",
+    );
+  });
+
+  test("always writes a non-empty title even when the copy is unusable", async () => {
+    // `normalizeTitle` rejects prose-shaped candidates, so both authored
+    // titles drop out and the derivation carries the row.
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      sourceEventName: "example.event",
+      contextPayload: { title: "I need to name this notification somehow" },
+    });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "Let me summarize what happened",
+          body: "Disk usage crossed 90 percent. Cleanup ran.",
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Disk usage crossed 90 percent.");
+    expect(appendCalls[0]!.title).toBeTruthy();
+  });
+
+  test("derives a single-line plain title from a markdown-headed conversation seed", async () => {
+    // The summary prefers `conversationSeedMessage`, which carries structured
+    // markdown and hard line breaks. The derived title must not.
+    conversationRow = { conversationType: "background" };
+    const seed =
+      "## Nightly Backup Report\n\nThe backup job on db-primary failed at 02:14.";
+    const signal = makeSignal({ sourceEventName: "example.event" });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "",
+          body: "The backup job failed.",
+          conversationSeedMessage: seed,
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe(
+      "Nightly Backup Report The backup job on db-primary failed at…",
+    );
+    expect(item?.summary).toBe(seed);
+  });
+
+  test("strips tilde fences and indented headings, matching migration 138", async () => {
+    // Workspace migration 138 backfills titles with its own self-contained copy
+    // of these rules. A backfilled title and a freshly written one must match
+    // for the same summary, so both accept CommonMark's 3-space indent and both
+    // fence styles.
+    conversationRow = { conversationType: "background" };
+    const seed = "   ## Indented heading\n\n~~~\ntilde fence\n~~~\nBody text.";
+    const signal = makeSignal({ sourceEventName: "example.event" });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "",
+          body: "Body text.",
+          conversationSeedMessage: seed,
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Indented heading tilde fence Body text.");
+  });
+
+  test("derives a single-line plain title from a markdown-list conversation seed", async () => {
+    conversationRow = { conversationType: "background" };
+    const seed = "- Ran 12 checks\n- 3 failed\n\nSee the log for details.";
+    const signal = makeSignal({ sourceEventName: "example.event" });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: {
+          title: "",
+          body: "Check run finished.",
+          conversationSeedMessage: seed,
+        },
+      },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, decision);
+
+    expect(item?.title).toBe("Ran 12 checks 3 failed See the log for details.");
+    expect(item?.summary).toBe(seed);
+  });
+
   test("treats whitespace-only rendered copy and payload values as missing and returns null", async () => {
     conversationRow = { conversationType: "background" };
     const signal = makeSignal({

package/src/notifications/adapters/macos.ts

@@ -101,12 +101,15 @@ export class VellumAdapter implements ChannelAdapter {
       this.broadcast({
         type: "notification_intent",
         deliveryId: payload.deliveryId,
+        correlationId: payload.correlationId,
         sourceEventName: payload.sourceEventName,
         title: payload.copy.title,
         body: payload.copy.body,
         deepLinkMetadata: payload.deepLinkTarget,
         targetGuardianPrincipalId,
         silent,
+        remotePushDispatched: payload.remotePushDispatched,
+        remotePushPlatforms: payload.remotePushPlatforms,
       } as AssistantEvent);
 
       log.info(