@vellumai/assistant 0.11.9 → 0.11.10-dev.202609091114.7b6342c

package/src/notifications/__tests__/background-failure-signal.test.ts

@@ -1,5 +1,20 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+
+const PRESENCE_FLAG = "activity-presence-suppression";
+
+let webFocused = false;
+const webPresenceArgs: unknown[][] = [];
+const realWebPresence = await import("../../runtime/web-presence.js");
+mock.module("../../runtime/web-presence.js", () => ({
+  ...realWebPresence,
+  isWebConversationFocused: (...args: unknown[]) => {
+    webPresenceArgs.push(args);
+    return webFocused;
+  },
+}));
+
 const emitCalls: Array<Record<string, unknown>> = [];
 mock.module("../emit-signal.js", () => ({
   emitNotificationSignal: (params: Record<string, unknown>) => {
@@ -105,3 +120,84 @@ describe("emitBackgroundFailureSignal", () => {
     });
   });
 });
+
+describe("emitBackgroundFailureSignal source-active suppression", () => {
+  beforeEach(() => {
+    emitCalls.length = 0;
+    webFocused = false;
+    webPresenceArgs.length = 0;
+    setOverridesForTesting({ [PRESENCE_FLAG]: true });
+  });
+
+  function emitWithPresence(presenceConversationId: string): void {
+    emitBackgroundFailureSignal({
+      jobName: "watcher-a",
+      sourceChannel: "assistant_tool",
+      sourceContextId: "conv-3",
+      errorKind: "exception",
+      errorMessage: "boom",
+      presenceConversationId,
+    });
+  }
+
+  test("reports the source as visible when the carried conversation is focused", () => {
+    webFocused = true;
+
+    emitWithPresence("conv-3");
+
+    expect(emitCalls[0].attentionHints).toMatchObject({
+      visibleInSourceNow: true,
+    });
+    expect(webPresenceArgs).toEqual([["conv-3"]]);
+  });
+
+  test("reports the source as not visible when the conversation is unfocused", () => {
+    webFocused = false;
+
+    emitWithPresence("conv-3");
+
+    expect(emitCalls[0].attentionHints).toMatchObject({
+      visibleInSourceNow: false,
+    });
+    expect(webPresenceArgs).toEqual([["conv-3"]]);
+  });
+
+  test("the scheduler and sweep-job reports carry no presence conversation", () => {
+    webFocused = true;
+
+    emitBackgroundFailureSignal({
+      jobName: "schedule:job-1",
+      sourceChannel: "scheduler",
+      sourceContextId: "job-1",
+      errorKind: "exception",
+      errorMessage: "retries exhausted",
+    });
+    emitBackgroundFailureSignal({
+      jobName: "memory.v2.sweep",
+      sourceChannel: "scheduler",
+      sourceContextId: "job-9",
+      errorKind: "exception",
+      errorMessage: "boom",
+    });
+
+    expect(emitCalls).toHaveLength(2);
+    for (const emitted of emitCalls) {
+      expect(emitted.attentionHints).toMatchObject({
+        visibleInSourceNow: false,
+      });
+    }
+    expect(webPresenceArgs).toEqual([]);
+  });
+
+  test("the flag off keeps the hint false without reading presence", () => {
+    webFocused = true;
+    setOverridesForTesting({ [PRESENCE_FLAG]: false });
+
+    emitWithPresence("conv-3");
+
+    expect(emitCalls[0].attentionHints).toMatchObject({
+      visibleInSourceNow: false,
+    });
+    expect(webPresenceArgs).toEqual([]);
+  });
+});

package/src/notifications/__tests__/broadcaster.test.ts

@@ -15,6 +15,8 @@ import type {
   ChannelDeliveryPayload,
   ChannelDestination,
   DeliveryResult,
+  DestinationBindingContext,
+  NotificationChannel,
   NotificationDecision,
 } from "../types.js";
 
@@ -62,16 +64,37 @@ mock.module("../conversation-pairing.js", () => ({
 }));
 
 // Status writes are inert by default; tests that need a failing store swap
-// the implementation in.
-let updateDeliveryStatusImpl: (status: string) => void = () => {};
+// the implementation in, and tests that need the patch read it.
+let updateDeliveryStatusImpl: (
+  status: string,
+  patch?: { messageId?: string; canonicalMessageId?: string },
+) => void = () => {};
 
 mock.module("../deliveries-store.js", () => ({
   createDelivery: () => {},
-  updateDeliveryStatus: (_deliveryId: string, status: string) =>
-    updateDeliveryStatusImpl(status),
+  updateDeliveryStatus: (
+    _deliveryId: string,
+    status: string,
+    _error?: unknown,
+    patch?: { messageId?: string; canonicalMessageId?: string },
+  ) => updateDeliveryStatusImpl(status, patch),
   findDeliveryByDecisionAndChannel: () => undefined,
 }));
 
+// The post-acknowledgement row write is observed, never performed: the
+// broadcaster's contract is when it calls this and with what.
+let recordedPosts: Array<Record<string, unknown>> = [];
+let recordDeliveredChannelPostImpl: (
+  post: Record<string, unknown>,
+) => Promise<{ messageId: string }> = async () => ({ messageId: "row-1" });
+
+mock.module("../delivered-post-record.js", () => ({
+  recordDeliveredChannelPost: async (post: Record<string, unknown>) => {
+    recordedPosts.push(post);
+    return recordDeliveredChannelPostImpl(post);
+  },
+}));
+
 mock.module("../adapters/macos.js", () => ({
   isGuardianSensitiveEvent: () => false,
 }));
@@ -85,12 +108,21 @@ mock.module("../../persistence/conversation-crud.js", () => ({
 }));
 
 // Mock destination-resolver so platform channel tests get a destination
-// without needing guardian-delivery data.
+// without needing guardian-delivery data. A channel listed in
+// `destinationBindingContexts` gets that binding context, as a resolved
+// external chat would.
+let destinationBindingContexts: Record<string, DestinationBindingContext> = {};
 mock.module("../destination-resolver.js", () => ({
   resolveDestinations: (channels: readonly string[], _guardians: unknown) => {
     const map = new Map();
     for (const ch of channels) {
-      map.set(ch, { channel: ch, endpoint: ch, metadata: {} });
+      const bindingContext = destinationBindingContexts[ch];
+      map.set(ch, {
+        channel: ch,
+        endpoint: bindingContext?.externalChatId ?? ch,
+        metadata: {},
+        ...(bindingContext ? { bindingContext } : {}),
+      });
     }
     return map;
   },
@@ -142,7 +174,7 @@ interface CapturedSend {
 }
 
 function makeCapturingAdapter(
-  channel: "vellum" | "platform",
+  channel: NotificationChannel,
   result: DeliveryResult = { success: true },
 ): {
   adapter: ChannelAdapter;
@@ -168,6 +200,9 @@ beforeEach(() => {
   pairingByChannel = {};
   pairingErrorByChannel = {};
   updateDeliveryStatusImpl = () => {};
+  destinationBindingContexts = {};
+  recordedPosts = [];
+  recordDeliveredChannelPostImpl = async () => ({ messageId: "row-1" });
 });
 
 // ── Tests ───────────────────────────────────────────────────────────────
@@ -271,6 +306,135 @@ describe("NotificationBroadcaster delivery status recording", () => {
   });
 });
 
+describe("NotificationBroadcaster records a channel delivery after acknowledgement", () => {
+  const slackHome: PairingResult = {
+    conversationId: "conv-home",
+    messageId: null,
+    strategy: "continue_existing_conversation",
+    createdNewConversation: false,
+    conversationFallbackUsed: false,
+  };
+
+  test("a successful Slack send is recorded with the channel's message id, and the audit names the row", async () => {
+    composeFallbackReturn = {
+      slack: { title: "Check-in", body: "Two items need your eyes today." },
+    };
+    pairingByChannel = { slack: slackHome };
+    destinationBindingContexts = {
+      slack: { sourceChannel: "slack", externalChatId: "D0123456789" },
+    };
+    const patches: Array<{
+      status: string;
+      patch?: { messageId?: string; canonicalMessageId?: string };
+    }> = [];
+    updateDeliveryStatusImpl = (status, patch) => {
+      patches.push({ status, patch });
+    };
+
+    const { adapter, sends } = makeCapturingAdapter("slack", {
+      success: true,
+      messageId: "1756800000.000100",
+    });
+    const broadcaster = new NotificationBroadcaster([adapter]);
+
+    const results = await broadcaster.broadcastDecision(
+      makeSignal(),
+      makeDecision({ selectedChannels: ["slack"], renderedCopy: {} }),
+    );
+
+    expect(sends.length).toBe(1);
+    expect(results[0]?.status).toBe("sent");
+    expect(recordedPosts).toHaveLength(1);
+    expect(recordedPosts[0]).toEqual({
+      conversationId: "conv-home",
+      channel: "slack",
+      externalChatId: "D0123456789",
+      text: "Two items need your eyes today.",
+      providerMessageId: "1756800000.000100",
+    });
+    const sent = patches.find((p) => p.status === "sent");
+    expect(sent?.patch).toEqual({
+      messageId: "1756800000.000100",
+      canonicalMessageId: "row-1",
+    });
+  });
+
+  test("a failed Slack send records nothing", async () => {
+    composeFallbackReturn = {
+      slack: { title: "Check-in", body: "Two items need your eyes today." },
+    };
+    pairingByChannel = { slack: slackHome };
+    destinationBindingContexts = {
+      slack: { sourceChannel: "slack", externalChatId: "D0123456789" },
+    };
+
+    const { adapter } = makeCapturingAdapter("slack", {
+      success: false,
+      error: "channel_not_found",
+    });
+    const broadcaster = new NotificationBroadcaster([adapter]);
+
+    const results = await broadcaster.broadcastDecision(
+      makeSignal(),
+      makeDecision({ selectedChannels: ["slack"], renderedCopy: {} }),
+    );
+
+    expect(results[0]?.status).toBe("failed");
+    expect(recordedPosts).toHaveLength(0);
+  });
+
+  test("a successful send whose row write fails still reads as sent, without a row reference", async () => {
+    composeFallbackReturn = {
+      slack: { title: "Check-in", body: "Two items need your eyes today." },
+    };
+    pairingByChannel = { slack: slackHome };
+    destinationBindingContexts = {
+      slack: { sourceChannel: "slack", externalChatId: "D0123456789" },
+    };
+    recordDeliveredChannelPostImpl = async () => {
+      throw new Error("messages table is locked");
+    };
+    const patches: Array<{
+      status: string;
+      patch?: { messageId?: string; canonicalMessageId?: string };
+    }> = [];
+    updateDeliveryStatusImpl = (status, patch) => {
+      patches.push({ status, patch });
+    };
+
+    const { adapter } = makeCapturingAdapter("slack", {
+      success: true,
+      messageId: "1756800000.000100",
+    });
+    const broadcaster = new NotificationBroadcaster([adapter]);
+
+    const results = await broadcaster.broadcastDecision(
+      makeSignal(),
+      makeDecision({ selectedChannels: ["slack"], renderedCopy: {} }),
+    );
+
+    expect(results[0]?.status).toBe("sent");
+    const sent = patches.find((p) => p.status === "sent");
+    expect(sent?.patch).toEqual({ messageId: "1756800000.000100" });
+  });
+
+  test("a vellum delivery is not recorded through this path", async () => {
+    composeFallbackReturn = {
+      vellum: { title: "Reminder", body: "Time to drink water" },
+    };
+
+    const { adapter } = makeCapturingAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([adapter]);
+
+    await broadcaster.broadcastDecision(
+      makeSignal(),
+      makeDecision({ renderedCopy: {} }),
+    );
+
+    expect(recordedPosts).toHaveLength(0);
+  });
+});
+
 describe("NotificationBroadcaster platform deep-link from contextPayload", () => {
   test("uses deepLinkConversationId from contextPayload when no pairing exists", async () => {
     composeFallbackReturn = {

package/src/notifications/__tests__/decision-engine.test.ts

@@ -570,14 +570,15 @@ describe("decision tool title field specification", () => {
       tool.input_schema.properties.renderedCopy.properties.vellum.properties
         .title.description;
 
-    expect(description).toContain("2 to 5 words");
+    expect(description).toContain("2 to 6 words");
     expect(description).toContain("40 characters");
-    expect(description).toContain("noun phrase");
-    expect(description).toContain(
-      "Do NOT restate, summarize, or echo the body",
-    );
+    // The title carries a bell row on its own, so it states the outcome
+    // rather than naming a topic the body then explains.
+    expect(description).toContain("WHAT HAPPENED or WHAT IS NEEDED");
+    expect(description).toContain("Lead with the outcome");
+    expect(description).toContain("Do NOT restate the body word for word");
     expect(description).toContain("no markdown");
-    expect(description).toContain("Missing Context");
+    expect(description).toContain("Missing context");
     expect(description.match(/NOT '/g)?.length ?? 0).toBeGreaterThanOrEqual(2);
   });
 });
@@ -663,3 +664,75 @@ describe("title normalization", () => {
     expect(decision.renderedCopy.vellum?.title).toBe("Backup finished.");
   });
 });
+
+function makeScheduleResultSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-schedule-result-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "conv-schedule-run",
+    sourceEventName: "schedule.result",
+    contextPayload: {
+      requestedMessage: "- **3 new emails**\n- `deploy.sh` failed overnight",
+      requestedTitle: "Morning briefing",
+      scheduleName: "Morning briefing",
+      scheduleId: "sched-1",
+    },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+describe("schedule.result pass-through in notification decision engine", () => {
+  beforeEach(() => {
+    persistedDecisions = [];
+  });
+
+  test("carries the run's own output verbatim rather than rewriting it", async () => {
+    // The whole value of this notification is the digest itself. The
+    // classifier compresses a signal into a short alert, which would throw
+    // away the content the user set the schedule up to receive.
+    const decision = await evaluateSignal(makeScheduleResultSignal(), [
+      "vellum",
+      "platform",
+    ] as NotificationChannel[]);
+
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "- **3 new emails**\n- `deploy.sh` failed overnight",
+    );
+    expect(decision.renderedCopy.vellum?.title).toBe("Morning briefing");
+    expect(decision.reasoningSummary).toBe("schedule_result pass-through");
+    expect(decision.verbatimCopy).toBe(true);
+    expect(decision.fallbackUsed).toBe(false);
+  });
+
+  test("delivers to the notification center as well as push", async () => {
+    // Unlike an unseen chat reply, a scheduled run's output has no
+    // conversation the user is already in. `vellum` is where it persists.
+    const decision = await evaluateSignal(makeScheduleResultSignal(), [
+      "vellum",
+      "telegram",
+      "platform",
+    ] as NotificationChannel[]);
+
+    expect(decision.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(decision.shouldNotify).toBe(true);
+  });
+
+  test("still reaches the inbox when push is unavailable", async () => {
+    const decision = await evaluateSignal(makeScheduleResultSignal(), [
+      "vellum",
+      "telegram",
+    ] as NotificationChannel[]);
+
+    expect(decision.selectedChannels).toEqual(["vellum"]);
+    expect(decision.shouldNotify).toBe(true);
+  });
+});

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

@@ -74,6 +74,22 @@ mock.module("../../persistence/conversation-crud.js", () => ({
   getConversation: () => null,
 }));
 
+const reindexedMessageIds: string[] = [];
+mock.module("../../persistence/job-handlers/message-lexical.js", () => ({
+  enqueueLexicalIndexForMessage: (messageId: string) => {
+    reindexedMessageIds.push(messageId);
+  },
+}));
+
+const staleMarkedConversations: string[] = [];
+mock.module("../../daemon/conversation-registry.js", () => ({
+  findConversation: (conversationId: string) => ({
+    markHistoryStale: () => {
+      staleMarkedConversations.push(conversationId);
+    },
+  }),
+}));
+
 mock.module("../emit-signal.js", () => ({
   getBroadcaster: () => ({
     getAdapter: () =>
@@ -133,6 +149,7 @@ function makeDelivery(
     errorCode: null,
     errorMessage: null,
     sentAt: 1700000000000,
+    canonicalMessageId: null,
     conversationId: null,
     messageId: "1700000000.0001",
     conversationStrategy: null,
@@ -164,6 +181,8 @@ beforeEach(() => {
   renderedCopyPatches.length = 0;
   adapterUpdates.length = 0;
   messageRewrites.length = 0;
+  reindexedMessageIds.length = 0;
+  staleMarkedConversations.length = 0;
   messageOwners.clear();
   messageOwners.set("msg-9", "conv-source-1");
   messageLookupShouldThrow = false;
@@ -320,6 +339,46 @@ describe("editNotification", () => {
     ]);
   });
 
+  test("a body edit rewrites the delivery's canonical row, re-indexes it, and marks its conversation stale", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [
+      makeDelivery({
+        conversationId: "conv-chat-home",
+        canonicalMessageId: "row-42",
+      }),
+    ];
+
+    await editNotification({ id: FEED_ITEM_ID, body: "Done in 4 minutes" });
+
+    expect(messageRewrites).toContainEqual({
+      messageId: "row-42",
+      content: "Done in 4 minutes",
+    });
+    expect(reindexedMessageIds).toEqual(["row-42"]);
+    expect(staleMarkedConversations).toEqual(["conv-chat-home"]);
+  });
+
+  test("a title-only edit leaves the canonical row alone", async () => {
+    await appendFeedItem(makeItem());
+    decisionRow = { id: "dec-1" };
+    deliveryRows = [
+      makeDelivery({
+        conversationId: "conv-chat-home",
+        canonicalMessageId: "row-42",
+      }),
+    ];
+
+    await editNotification({
+      id: FEED_ITEM_ID,
+      title: "Backup finished early",
+    });
+
+    expect(messageRewrites.some((r) => r.messageId === "row-42")).toBe(false);
+    expect(reindexedMessageIds).toEqual([]);
+    expect(staleMarkedConversations).toEqual([]);
+  });
+
   test("reports channels whose adapter cannot edit in place as unsupported", async () => {
     await appendFeedItem(makeItem());
     decisionRow = { id: "dec-1" };

package/src/notifications/__tests__/resolve-visible-in-source.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for `resolve-visible-in-source.ts`: when a conversation-scoped
+ * producer is allowed to say the user is already watching this.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type pino from "pino";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+
+const FLAG = "activity-presence-suppression";
+const CONVERSATION_ID = "conv-1";
+
+let webFocused = false;
+let webPresenceShouldThrow = false;
+const webPresenceArgs: unknown[][] = [];
+const realWebPresence = await import("../../runtime/web-presence.js");
+mock.module("../../runtime/web-presence.js", () => ({
+  ...realWebPresence,
+  isWebConversationFocused: (...args: unknown[]) => {
+    webPresenceArgs.push(args);
+    if (webPresenceShouldThrow) {
+      throw new Error("simulated presence read failure");
+    }
+    return webFocused;
+  },
+}));
+
+const { resolveVisibleInSourceNow } =
+  await import("../resolve-visible-in-source.js");
+
+describe("resolveVisibleInSourceNow", () => {
+  beforeEach(() => {
+    webFocused = false;
+    webPresenceShouldThrow = false;
+    webPresenceArgs.length = 0;
+    setOverridesForTesting({ [FLAG]: true });
+  });
+
+  test("returns true when the flag is on and the conversation is focused", () => {
+    webFocused = true;
+
+    expect(resolveVisibleInSourceNow({ conversationId: CONVERSATION_ID })).toBe(
+      true,
+    );
+    expect(webPresenceArgs).toEqual([[CONVERSATION_ID]]);
+  });
+
+  test("returns false when the conversation is not focused", () => {
+    webFocused = false;
+
+    expect(resolveVisibleInSourceNow({ conversationId: CONVERSATION_ID })).toBe(
+      false,
+    );
+    expect(webPresenceArgs).toEqual([[CONVERSATION_ID]]);
+  });
+
+  test("returns false without reading presence when the flag is off", () => {
+    webFocused = true;
+    setOverridesForTesting({ [FLAG]: false });
+
+    expect(resolveVisibleInSourceNow({ conversationId: CONVERSATION_ID })).toBe(
+      false,
+    );
+    expect(webPresenceArgs).toEqual([]);
+  });
+
+  test("returns false and warns once when the presence read throws", () => {
+    webPresenceShouldThrow = true;
+    const warn = mock(() => {});
+
+    expect(
+      resolveVisibleInSourceNow({
+        conversationId: CONVERSATION_ID,
+        logger: { warn } as unknown as pino.Logger,
+      }),
+    ).toBe(false);
+    expect(warn).toHaveBeenCalledTimes(1);
+  });
+
+  test("short-circuits an empty conversation id", () => {
+    webFocused = true;
+
+    expect(resolveVisibleInSourceNow({ conversationId: "" })).toBe(false);
+    expect(webPresenceArgs).toEqual([]);
+  });
+
+  test("short-circuits an undefined conversation id", () => {
+    webFocused = true;
+
+    expect(resolveVisibleInSourceNow({ conversationId: undefined })).toBe(
+      false,
+    );
+    expect(webPresenceArgs).toEqual([]);
+  });
+});