@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/messages-after-tiebreaker.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  countMessagesAfter,
+  getMessagesAfter,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+
+initializeDb();
+
+const CONV_ID = "conv-tiebreaker";
+
+function clearDb(): void {
+  const db = getDb();
+  db.delete(messages).run();
+  db.delete(conversations).run();
+}
+
+function seedConversation(): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id: CONV_ID,
+      title: null,
+      createdAt: now,
+      updatedAt: now,
+      source: "test",
+      conversationType: "default",
+      memoryScopeId: "default",
+    })
+    .run();
+}
+
+function insertMessage(id: string, createdAt: number): void {
+  getDb()
+    .insert(messages)
+    .values({
+      id,
+      conversationId: CONV_ID,
+      role: "user",
+      content: "",
+      createdAt,
+      metadata: null,
+    })
+    .run();
+}
+
+describe("countMessagesAfter / getMessagesAfter — millisecond-collision tie-breaker", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("messages sharing a millisecond timestamp with the reference are NOT permanently skipped (countMessagesAfter)", () => {
+    const ts = 1_700_000_000_000;
+    // Both messages share the exact same createdAt — id "b" sorts after
+    // id "a" lexicographically. Without a tie-breaker the second message
+    // would never be counted.
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, "a")).toBe(1);
+  });
+
+  test("messages sharing a millisecond timestamp with the reference are NOT permanently skipped (getMessagesAfter)", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    const result = getMessagesAfter(CONV_ID, "a");
+    expect(result.map((m) => m.id)).toEqual(["b"]);
+  });
+
+  test("strict-after semantics: a message with id sorting BEFORE the reference but identical timestamp is NOT included", () => {
+    const ts = 1_700_000_000_000;
+    // "a" sorts before "b". Reference is "b", so "a" should be excluded
+    // (strictly-after semantics, not "all rows at the same timestamp").
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, "b")).toBe(0);
+    expect(getMessagesAfter(CONV_ID, "b")).toEqual([]);
+  });
+
+  test("mixed collision + later timestamps: counts both same-ts tie-breaker rows and strictly-later rows", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+    insertMessage("c", ts);
+    insertMessage("d", ts + 1);
+
+    expect(countMessagesAfter(CONV_ID, "a")).toBe(3);
+    const result = getMessagesAfter(CONV_ID, "a");
+    expect(result.map((m) => m.id)).toEqual(["b", "c", "d"]);
+  });
+
+  test("missing reference returns 0/[] (conservative semantics preserved)", () => {
+    insertMessage("a", 1_700_000_000_000);
+    expect(countMessagesAfter(CONV_ID, "nonexistent")).toBe(0);
+    expect(getMessagesAfter(CONV_ID, "nonexistent")).toEqual([]);
+  });
+
+  test("null/empty reference still returns all messages", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts);
+
+    expect(countMessagesAfter(CONV_ID, null)).toBe(2);
+    expect(countMessagesAfter(CONV_ID, "")).toBe(2);
+    expect(getMessagesAfter(CONV_ID, null)).toHaveLength(2);
+    expect(getMessagesAfter(CONV_ID, "")).toHaveLength(2);
+  });
+});

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

@@ -95,97 +95,6 @@ describe("notification decision fallback copy", () => {
     );
   });
 
-  test("enforces guardian-facing popup copy for heartbeat alerts", async () => {
-    configuredProvider = { sendMessage: async () => ({}) };
-    extractedToolUse = {
-      input: {
-        shouldNotify: true,
-        selectedChannels: ["vellum"],
-        reasoningSummary: "Heartbeat found a useful follow-up.",
-        renderedCopy: {
-          vellum: {
-            title: "Heartbeat Follow-up",
-            body: "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
-          },
-        },
-        dedupeKey: "heartbeat:test",
-        confidence: 0.9,
-      },
-    };
-
-    const decision = await evaluateSignal(
-      makeSignal({
-        sourceEventName: "heartbeat.alert",
-        sourceChannel: "watcher",
-        contextPayload: {
-          summary:
-            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
-          conversationTitle: "Running Habit Tracking",
-        },
-        attentionHints: {
-          requiresAction: true,
-          urgency: "medium",
-          isAsyncBackground: true,
-          visibleInSourceNow: false,
-        },
-      }),
-      ["vellum"] as NotificationChannel[],
-    );
-
-    expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.title).toBe("Heartbeat Alert");
-    expect(decision.renderedCopy.vellum?.body).toBe(
-      "I found something worth your attention in a heartbeat check. Open the conversation for details.",
-    );
-    expect(decision.renderedCopy.vellum?.body).not.toContain(
-      "reminding the guardian",
-    );
-  });
-
-  test("keeps direct guardian-facing heartbeat copy", async () => {
-    configuredProvider = { sendMessage: async () => ({}) };
-    extractedToolUse = {
-      input: {
-        shouldNotify: true,
-        selectedChannels: ["vellum"],
-        reasoningSummary: "Heartbeat found a useful follow-up.",
-        renderedCopy: {
-          vellum: {
-            title: "Tracker Ready",
-            body: "Your daily tracker is ready. Review it before the next check-in.",
-          },
-        },
-        dedupeKey: "heartbeat:direct-copy-test",
-        confidence: 0.9,
-      },
-    };
-
-    const decision = await evaluateSignal(
-      makeSignal({
-        sourceEventName: "heartbeat.alert",
-        sourceChannel: "watcher",
-        contextPayload: {
-          summary:
-            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
-          conversationTitle: "Running Habit Tracking",
-        },
-        attentionHints: {
-          requiresAction: true,
-          urgency: "medium",
-          isAsyncBackground: true,
-          visibleInSourceNow: false,
-        },
-      }),
-      ["vellum"] as NotificationChannel[],
-    );
-
-    expect(decision.fallbackUsed).toBe(false);
-    expect(decision.renderedCopy.vellum?.title).toBe("Tracker Ready");
-    expect(decision.renderedCopy.vellum?.body).toBe(
-      "Your daily tracker is ready. Review it before the next check-in.",
-    );
-  });
-
   test("enforces free-text answer instructions for guardian.question when requestCode exists", async () => {
     const signal = makeSignal({
       contextPayload: {

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

@@ -147,7 +147,10 @@ describe("notification decision strategy", () => {
       expect(copy.telegram!.deliveryText).toBe("Take out the trash");
     });
 
-    test("unknown event name produces generic copy with urgency prefix", () => {
+    test("unknown event name produces generic copy with empty body", () => {
+      // The event-name-derived body fallback was removed; the deterministic
+      // `checkRenderedCopyQuality` check in deterministic-checks.ts will
+      // suppress notifications that end up with an empty body.
       const signal = makeSignal({
         sourceEventName: "some_novel.event",
         attentionHints: {
@@ -161,12 +164,16 @@ describe("notification decision strategy", () => {
       const copy = composeFallbackCopy(signal, channels);
       expect(copy.vellum).toBeDefined();
       expect(copy.vellum!.title).toBe("Notification");
-      expect(copy.vellum!.body).toContain("Urgent:");
-      expect(copy.vellum!.body).toContain("action required");
-      expect(copy.telegram!.deliveryText).toBe(copy.telegram!.body);
+      expect(copy.vellum!.body).toBe("");
+      // Telegram deliveryText falls back to title when body is empty; the
+      // checkRenderedCopyQuality check still suppresses on empty body.
+      expect(copy.telegram!.body).toBe("");
     });
 
-    test("unknown event name without urgency produces clean generic copy", () => {
+    test("unknown event name without urgency also produces empty body", () => {
+      // The event-name-derived body fallback was removed; the deterministic
+      // `checkRenderedCopyQuality` check in deterministic-checks.ts will
+      // suppress notifications that end up with an empty body.
       const signal = makeSignal({
         sourceEventName: "background.sync_complete",
         attentionHints: {
@@ -179,10 +186,8 @@ describe("notification decision strategy", () => {
 
       const copy = composeFallbackCopy(signal, channels);
       expect(copy.vellum).toBeDefined();
-      expect(copy.vellum!.body).not.toContain("Urgent:");
-      expect(copy.vellum!.body).not.toContain("action required");
-      // Dots and underscores in event name are replaced with spaces
-      expect(copy.vellum!.body).toContain("background sync complete");
+      expect(copy.vellum!.title).toBe("Notification");
+      expect(copy.vellum!.body).toBe("");
     });
 
     test("fallback copy is generated for every requested channel", () => {
@@ -373,28 +378,6 @@ describe("notification decision strategy", () => {
         "A guardian question needs your attention",
       );
     });
-
-    test("heartbeat.alert fallback avoids intermediary-instruction popup copy", () => {
-      const signal = makeSignal({
-        sourceEventName: "heartbeat.alert",
-        contextPayload: {
-          summary:
-            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
-          conversationTitle: "Running Habit Tracking",
-        },
-      });
-
-      const copy = composeFallbackCopy(signal, channels);
-      expect(copy.vellum).toBeDefined();
-      expect(copy.vellum!.title).toBe("Heartbeat Alert");
-      expect(copy.vellum!.body).toBe(
-        "I found something worth your attention in a heartbeat check. Open the conversation for details.",
-      );
-      expect(copy.vellum!.conversationSeedMessage).toContain(
-        "consider reminding the guardian",
-      );
-      expect(copy.telegram!.deliveryText).toBe(copy.vellum!.body);
-    });
   });
 
   // -- NotificationChannel type correctness ----------------------------------

package/src/__tests__/notification-deep-link.test.ts

@@ -156,6 +156,7 @@ describe("notification deep-link metadata", () => {
             conversationId: "conv-123",
             conversationType: "notification",
           },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -179,6 +180,7 @@ describe("notification deep-link metadata", () => {
         {
           sourceEventName: "test.event",
           copy: { title: "Alert", body: "No deep link" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -199,6 +201,7 @@ describe("notification deep-link metadata", () => {
           sourceEventName: "guardian.question",
           copy: { title: "Guardian Question", body: "What is the code?" },
           deepLinkTarget: { conversationId },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -215,6 +218,7 @@ describe("notification deep-link metadata", () => {
         {
           sourceEventName: "test.event",
           copy: { title: "T", body: "B" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -231,6 +235,7 @@ describe("notification deep-link metadata", () => {
         {
           sourceEventName: "test.event",
           copy: { title: "T", body: "B" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -247,6 +252,7 @@ describe("notification deep-link metadata", () => {
         {
           sourceEventName: "guardian.question",
           copy: { title: "Alert", body: "Body" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -268,6 +274,7 @@ describe("notification deep-link metadata", () => {
             conversationId: "conv-task-run-42",
             workItemId: "work-item-7",
           },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -287,6 +294,7 @@ describe("notification deep-link metadata", () => {
           sourceEventName: "guardian.question",
           copy: { title: "Question", body: "Body" },
           deepLinkTarget: { conversationId: "conv-1", messageId: "msg-1" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -309,6 +317,7 @@ describe("notification deep-link metadata", () => {
           sourceEventName: "schedule.notify",
           copy: { title: "Reminder", body: "Take out the trash" },
           deepLinkTarget: { conversationId: "conv-new-convo-001" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -332,6 +341,7 @@ describe("notification deep-link metadata", () => {
             body: "Still need to take out the trash",
           },
           deepLinkTarget: { conversationId: "conv-reused-convo-042" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -358,6 +368,7 @@ describe("notification deep-link metadata", () => {
             conversationId: stableConversationId,
             messageId: "msg-seed-1",
           },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -371,6 +382,7 @@ describe("notification deep-link metadata", () => {
             conversationId: stableConversationId,
             messageId: "msg-seed-2",
           },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -402,6 +414,7 @@ describe("notification deep-link metadata", () => {
           sourceEventName: "schedule.notify",
           copy: { title: "Reminder", body: "First" },
           deepLinkTarget: { conversationId, messageId: "msg-a" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -411,6 +424,7 @@ describe("notification deep-link metadata", () => {
           sourceEventName: "schedule.notify",
           copy: { title: "Reminder", body: "Second" },
           deepLinkTarget: { conversationId, messageId: "msg-b" },
+          urgency: "medium",
         },
         { channel: "vellum" },
       );
@@ -442,6 +456,7 @@ describe("notification deep-link metadata", () => {
             sourceEventName: "activity.complete",
             copy: { title: "Activity", body },
             deepLinkTarget: { conversationId: boundConvId },
+            urgency: "medium",
           },
           { channel: "vellum" },
         );

package/src/__tests__/notification-guardian-path.test.ts

@@ -31,8 +31,6 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-
-
 const emitCalls: unknown[] = [];
 let mockConversationCreated: ConversationCreatedInfo | null = null;
 let mockEmitResult: {
@@ -189,6 +187,7 @@ describe("ASK_GUARDIAN canonical notification path", () => {
       conversationId: "conv-from-thread-callback",
       title: "Guardian question",
       sourceEventName: "guardian.question",
+      silent: false,
     };
     mockEmitResult = {
       signalId: "sig-2",

package/src/__tests__/notification-platform-adapter.test.ts

@@ -37,7 +37,8 @@ interface FetchCall {
 }
 
 const fetchCalls: FetchCall[] = [];
-const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> = [];
+const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> =
+  [];
 let clientAvailable = true;
 
 mock.module("../platform/client.js", () => ({
@@ -84,6 +85,7 @@ function makePayload(
     copy: { title: "Reminder", body: "Check the oven!" },
     deepLinkTarget: { type: "conversation", id: "conv-1" },
     contextPayload: { jobId: "job-1" },
+    urgency: "medium",
     ...overrides,
   };
 }
@@ -118,9 +120,7 @@ describe("PlatformPushAdapter", () => {
     expect(fetchCalls).toHaveLength(1);
 
     const call = fetchCalls[0]!;
-    expect(call.path).toBe(
-      "/v1/assistants/test-assistant-id/push/dispatch/",
-    );
+    expect(call.path).toBe("/v1/assistants/test-assistant-id/push/dispatch/");
     expect(call.method).toBe("POST");
     expect(call.body.delivery_id).toBe("delivery-uuid-1");
     expect(call.body.source_event_name).toBe("schedule.notify");
@@ -216,6 +216,7 @@ describe("PlatformPushAdapter", () => {
     const payload: ChannelDeliveryPayload = {
       sourceEventName: "schedule.notify",
       copy: { title: "Hi", body: "Hello" },
+      urgency: "medium",
     };
 
     const result = await adapter.send(payload, makeDestination());

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -58,6 +58,7 @@ function makePayload(
       title: "Reminder",
       body: "Check the oven now!",
     },
+    urgency: "medium",
     ...overrides,
   };
 }

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { VellumAdapter } from "../notifications/adapters/macos.js";
+import type {
+  ChannelDeliveryPayload,
+  ChannelDestination,
+} from "../notifications/types.js";
+
+function makePayload(
+  overrides?: Partial<ChannelDeliveryPayload>,
+): ChannelDeliveryPayload {
+  return {
+    deliveryId: "delivery-uuid-1",
+    sourceEventName: "schedule.notify",
+    copy: { title: "Reminder", body: "Hello" },
+    urgency: "medium",
+    ...overrides,
+  };
+}
+
+function makeDestination(
+  overrides?: Partial<ChannelDestination>,
+): ChannelDestination {
+  return {
+    channel: "vellum",
+    ...overrides,
+  };
+}
+
+function captureBroadcast(): {
+  adapter: VellumAdapter;
+  sent: ServerMessage[];
+} {
+  const sent: ServerMessage[] = [];
+  const adapter = new VellumAdapter((msg) => sent.push(msg));
+  return { adapter, sent };
+}
+
+describe("VellumAdapter silent flag", () => {
+  test("non-urgent (low) urgency broadcasts silent: true", async () => {
+    const { adapter, sent } = captureBroadcast();
+    const result = await adapter.send(
+      makePayload({ urgency: "low" }),
+      makeDestination(),
+    );
+
+    expect(result.success).toBe(true);
+    expect(sent).toHaveLength(1);
+    const intent = sent[0] as Extract<
+      ServerMessage,
+      { type: "notification_intent" }
+    >;
+    expect(intent.type).toBe("notification_intent");
+    expect(intent.silent).toBe(true);
+  });
+
+  test("non-urgent (medium) urgency broadcasts silent: true", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload({ urgency: "medium" }), makeDestination());
+
+    const intent = sent[0] as Extract<
+      ServerMessage,
+      { type: "notification_intent" }
+    >;
+    expect(intent.silent).toBe(true);
+  });
+
+  test("urgent (high) urgency broadcasts silent: false", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload({ urgency: "high" }), makeDestination());
+
+    const intent = sent[0] as Extract<
+      ServerMessage,
+      { type: "notification_intent" }
+    >;
+    expect(intent.silent).toBe(false);
+  });
+
+  test("critical urgency broadcasts silent: false", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(makePayload({ urgency: "critical" }), makeDestination());
+
+    const intent = sent[0] as Extract<
+      ServerMessage,
+      { type: "notification_intent" }
+    >;
+    expect(intent.silent).toBe(false);
+  });
+
+  test("broadcasts title, body, deepLinkTarget, and deliveryId verbatim", async () => {
+    const { adapter, sent } = captureBroadcast();
+    await adapter.send(
+      makePayload({
+        deliveryId: "delivery-xyz",
+        copy: { title: "T", body: "B" },
+        deepLinkTarget: { conversationId: "conv-abc" },
+        urgency: "high",
+      }),
+      makeDestination(),
+    );
+
+    const intent = sent[0] as Extract<
+      ServerMessage,
+      { type: "notification_intent" }
+    >;
+    expect(intent.deliveryId).toBe("delivery-xyz");
+    expect(intent.title).toBe("T");
+    expect(intent.body).toBe("B");
+    expect(intent.deepLinkMetadata).toEqual({ conversationId: "conv-abc" });
+    expect(intent.silent).toBe(false);
+  });
+});