@vellumai/assistant 0.8.2 → 0.8.3

package/src/notifications/__tests__/deterministic-checks.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for the deterministic pre-send checks.
+ *
+ * Focus: the rendered-copy quality check that suppresses notifications
+ * with empty bodies or bodies that leak the raw source event name
+ * (the `buildGenericCopy` fallback path).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+import { getDb } from "../../memory/db-connection.js";
+import { initializeDb } from "../../memory/db-init.js";
+import { notificationEvents } from "../../memory/schema.js";
+import {
+  type DeterministicCheckContext,
+  runDeterministicChecks,
+} from "../deterministic-checks.js";
+import type { NotificationSignal } from "../signal.js";
+import type { NotificationDecision } from "../types.js";
+
+initializeDb();
+
+beforeEach(() => {
+  getDb().delete(notificationEvents).run();
+});
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: `sig-${crypto.randomUUID()}`,
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "ctx-1",
+    sourceEventName: "schedule.notify",
+    contextPayload: {},
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+function makeDecision(
+  overrides?: Partial<NotificationDecision>,
+): NotificationDecision {
+  return {
+    shouldNotify: true,
+    selectedChannels: ["vellum"],
+    reasoningSummary: "test",
+    renderedCopy: {
+      vellum: { title: "Reminder", body: "Time to drink water" },
+    },
+    dedupeKey: `dk-${crypto.randomUUID()}`,
+    confidence: 0.9,
+    fallbackUsed: false,
+    ...overrides,
+  };
+}
+
+const context: DeterministicCheckContext = {
+  connectedChannels: ["vellum"],
+};
+
+describe("checkRenderedCopyQuality (via runDeterministicChecks)", () => {
+  test("passes when body is real non-empty text", async () => {
+    const result = await runDeterministicChecks(
+      makeSignal(),
+      makeDecision(),
+      context,
+    );
+    expect(result.passed).toBe(true);
+  });
+
+  test("fails when body is empty", async () => {
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "" },
+      },
+    });
+    const result = await runDeterministicChecks(
+      makeSignal(),
+      decision,
+      context,
+    );
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("empty");
+  });
+
+  test("fails when body is whitespace only", async () => {
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "   \n  " },
+      },
+    });
+    const result = await runDeterministicChecks(
+      makeSignal(),
+      decision,
+      context,
+    );
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("empty");
+  });
+
+  test("fails when body is the raw source event name", async () => {
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "user.send_notification" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("fallback leak");
+  });
+
+  test("fails when body matches the normalized source event name", async () => {
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "user send notification" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("fallback leak");
+  });
+
+  test("passes when channel was appended post-decision (urgency-forced vellum prepend)", async () => {
+    // Regression: emit-signal.ts prepends `vellum` to selectedChannels for
+    // high/critical urgency without populating renderedCopy.vellum. The
+    // broadcaster's composeFallbackCopy rescue handles those channels at
+    // delivery time, so the deterministic check must not fail-closed here.
+    const signal = makeSignal({
+      attentionHints: {
+        requiresAction: false,
+        urgency: "high",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+    });
+    const decision = makeDecision({
+      selectedChannels: ["vellum", "telegram"],
+      renderedCopy: {
+        telegram: { title: "Reminder", body: "Time to drink water" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, {
+      connectedChannels: ["vellum", "telegram"],
+    });
+    expect(result.passed).toBe(true);
+  });
+
+  test("passes when enforceRoutingIntent expanded channels post-decision", async () => {
+    // Regression: enforceRoutingIntent can expand selectedChannels to
+    // all_channels / multi_channel without populating renderedCopy for the
+    // added channels. Broadcaster fallback covers them — check must allow.
+    const decision = makeDecision({
+      selectedChannels: ["vellum", "telegram", "slack"],
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "Time to drink water" },
+      },
+    });
+    const result = await runDeterministicChecks(makeSignal(), decision, {
+      connectedChannels: ["vellum", "telegram", "slack"],
+    });
+    expect(result.passed).toBe(true);
+  });
+
+  test("still validates body quality for channels with rendered copy", async () => {
+    // Even when some channels lack copy (broadcaster fallback territory),
+    // channels that DO have copy must still pass the empty/event-name checks.
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      selectedChannels: ["vellum", "telegram"],
+      renderedCopy: {
+        telegram: { title: "Reminder", body: "user.send_notification" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, {
+      connectedChannels: ["vellum", "telegram"],
+    });
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("fallback leak");
+  });
+
+  test("fails when no selected channel has copy and fallback body is empty", async () => {
+    // Silent-no-delivery guard: if every selected channel is missing from
+    // renderedCopy AND the broadcaster's composeFallbackCopy can't produce
+    // a usable body (no template for sourceEventName → buildGenericCopy
+    // returns body=""), the gate must fail-closed rather than letting
+    // dispatchDecision report 0/N sent.
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      selectedChannels: ["vellum"],
+      renderedCopy: {},
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("fallback");
+  });
+
+  test("passes when no selected channel has copy but fallback yields a usable body", async () => {
+    // schedule.notify has a copy-composer template that produces a usable
+    // body even with empty payload — the broadcaster's fallback path will
+    // deliver, so the deterministic gate must allow it through.
+    const signal = makeSignal({ sourceEventName: "schedule.notify" });
+    const decision = makeDecision({
+      selectedChannels: ["vellum"],
+      renderedCopy: {},
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(true);
+  });
+
+  test("passes when shouldNotify is false regardless of copy contents", async () => {
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      shouldNotify: false,
+      // Empty body + event-name body would both fail the copy check if
+      // shouldNotify were true. Short-circuit must skip the check.
+      renderedCopy: {
+        vellum: { title: "", body: "" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(true);
+  });
+
+  test("passes assistant_tool pass-through even when body matches normalized event name", async () => {
+    // The pass-through path produces verbatim user-supplied body text.
+    // A coincidental match with the source event name is the user's
+    // intent, not a fallback leak — the check must not suppress it.
+    const signal = makeSignal({
+      sourceChannel: "assistant_tool",
+      sourceEventName: "assistant.share",
+    });
+    const decision = makeDecision({
+      reasoningSummary: "assistant_tool pass-through",
+      renderedCopy: {
+        vellum: { title: "Assistant share", body: "assistant share" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(true);
+  });
+
+  test("fails assistant_tool pass-through with empty body (empty-body branch still fires)", async () => {
+    const signal = makeSignal({ sourceChannel: "assistant_tool" });
+    const decision = makeDecision({
+      reasoningSummary: "assistant_tool pass-through",
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("empty");
+  });
+
+  test("still fails non-pass-through decision when body matches event name", async () => {
+    // Regression guard: the pass-through short-circuit must not weaken
+    // the check for LLM/fallback paths.
+    const signal = makeSignal({ sourceEventName: "user.send_notification" });
+    const decision = makeDecision({
+      reasoningSummary: "llm classification",
+      renderedCopy: {
+        vellum: { title: "Reminder", body: "user.send_notification" },
+      },
+    });
+    const result = await runDeterministicChecks(signal, decision, context);
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("fallback leak");
+  });
+});

package/src/notifications/__tests__/emit-signal-home-feed.test.ts

@@ -144,6 +144,7 @@ describe("emitNotificationSignal home-feed wire-up", () => {
       sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
       sourceContextId: "conv-source-1",
+      contextPayload: { title: "Background job done" },
       attentionHints: {
         requiresAction: false,
         urgency: "medium",