@vellumai/assistant 0.11.10 → 0.11.11-staging.1

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__/home-feed-side-effect.test.ts

@@ -919,6 +919,33 @@ describe("writeHomeFeedItemForSignal", () => {
     expect(appendCalls[0]!.noteworthy).toBe(true);
   });
 
+  test("a mapped source event carries its feed category", async () => {
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      contextPayload: { title: "Nightly briefing", body: "Three things." },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, makeDecision());
+
+    expect(item?.category).toBe("scheduling");
+    expect(appendCalls[0]!.category).toBe("scheduling");
+  });
+
+  test("an unmapped source event carries no category instead of falling back to system", async () => {
+    conversationRow = { conversationType: "background" };
+    const signal = makeSignal({
+      sourceChannel: "assistant_tool",
+      sourceEventName: "user.send_notification",
+      contextPayload: { title: "Tool share", body: "Body" },
+    });
+
+    const item = await writeHomeFeedItemForSignal(signal, makeDecision());
+
+    expect(item).not.toBeNull();
+    expect("category" in item!).toBe(false);
+    expect("category" in appendCalls[0]!).toBe(false);
+  });
+
   test("credential.health_alert is noteworthy regardless of source channel", async () => {
     conversationRow = { conversationType: "background" };
     const signal = makeSignal({

package/src/notifications/__tests__/schedule-result-producer.test.ts

@@ -0,0 +1,397 @@
+/**
+ * Tests for `schedule-result-producer.ts`: which finished schedule runs owe
+ * the user a notification, and the shape of the signal the qualifying ones
+ * emit.
+ *
+ * The two gates carry the design: a run that notified itself must stay silent
+ * (no duplicates for a well-authored schedule), and a run that said nothing
+ * must stay silent (no "your schedule ran" noise).
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import type { AttentionState } from "../../persistence/conversation-attention-store.js";
+import type { MessageRow } from "../../persistence/conversation-crud.js";
+import type { ContentBlock } from "../../providers/types.js";
+
+// ── Module mocks ───────────────────────────────────────────────────────
+//
+// `mock.module` is hoisted, so these intercepts apply before the module under
+// test resolves its imports.
+
+const emitCalls: any[] = [];
+let assistantRow: MessageRow | null = null;
+/** Earlier assistant rows of the same turn (tool-call steps before the reply). */
+let turnRows: MessageRow[] = [];
+let attentionState: AttentionState | null = null;
+let alreadyNotified = false;
+const notifiedProbeArgs: Array<[string, number]> = [];
+
+mock.module("../emit-signal.js", () => ({
+  emitNotificationSignal: async (params: any) => {
+    emitCalls.push(params);
+    return {
+      signalId: "sig-1",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
+  },
+}));
+
+const realEventsStore = await import("../events-store.js");
+mock.module("../events-store.js", () => ({
+  ...realEventsStore,
+  hasNotifiedSourceContextSince: (contextId: string, since: number) => {
+    notifiedProbeArgs.push([contextId, since]);
+    return alreadyNotified;
+  },
+}));
+
+const CONVERSATION_ID = "conv-sched-1";
+const ASSISTANT_MESSAGE_ID = "msg-assistant-1";
+const SCHEDULE_ID = "sched-1";
+const RUN_ID = "run-1";
+const RUN_STARTED_AT = 1700000000000;
+
+const realCrud = await import("../../persistence/conversation-crud.js");
+mock.module("../../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  getMessageById: (messageId: string) =>
+    messageId === ASSISTANT_MESSAGE_ID
+      ? assistantRow
+      : (turnRows.find((row) => row.id === messageId) ?? null),
+  getAssistantMessageIdsInTurn: (messageId: string) =>
+    messageId === ASSISTANT_MESSAGE_ID
+      ? [...turnRows.map((row) => row.id), ASSISTANT_MESSAGE_ID]
+      : [messageId],
+}));
+
+const realAttentionStore =
+  await import("../../persistence/conversation-attention-store.js");
+mock.module("../../persistence/conversation-attention-store.js", () => ({
+  ...realAttentionStore,
+  getAttentionStateByConversationIds: (ids: string[]) => {
+    const map = new Map<string, AttentionState>();
+    if (attentionState) {
+      map.set(ids[0], attentionState);
+    }
+    return map;
+  },
+}));
+
+const { emitScheduleResultNotification } =
+  await import("../schedule-result-producer.js");
+
+// ── Fixtures ───────────────────────────────────────────────────────────
+
+function makeAssistantRow(
+  content: ContentBlock[],
+  overrides: Partial<MessageRow> = {},
+): MessageRow {
+  return {
+    id: ASSISTANT_MESSAGE_ID,
+    conversationId: CONVERSATION_ID,
+    role: "assistant",
+    content,
+    createdAt: RUN_STARTED_AT + 200,
+    metadata: null,
+    clientMessageId: null,
+    finalized: 1,
+    ...overrides,
+  };
+}
+
+/** An earlier row of the run's turn holding a single tool call. */
+function makeToolCallRow(
+  name: string,
+  input: Record<string, unknown>,
+): MessageRow {
+  return makeAssistantRow(
+    [{ type: "tool_use", id: `tu-${name}`, name, input }] as ContentBlock[],
+    { id: `msg-${name}`, createdAt: RUN_STARTED_AT + 100 },
+  );
+}
+
+function makeAttentionState(
+  overrides: Partial<AttentionState> = {},
+): AttentionState {
+  return {
+    conversationId: CONVERSATION_ID,
+    latestAssistantMessageId: ASSISTANT_MESSAGE_ID,
+    latestAssistantMessageAt: RUN_STARTED_AT + 200,
+    lastSeenAssistantMessageId: null,
+    lastSeenAssistantMessageAt: null,
+    lastSeenEventAt: null,
+    lastSeenConfidence: null,
+    lastSeenSignalType: null,
+    lastSeenSourceChannel: null,
+    lastSeenSource: null,
+    lastSeenEvidenceText: null,
+    createdAt: RUN_STARTED_AT,
+    updatedAt: RUN_STARTED_AT + 200,
+    ...overrides,
+  };
+}
+
+const warnCalls: unknown[] = [];
+const infoCalls: unknown[] = [];
+const rlog = {
+  warn: (...args: unknown[]) => {
+    warnCalls.push(args);
+  },
+  info: (...args: unknown[]) => {
+    infoCalls.push(args);
+  },
+} as any;
+
+async function run(
+  overrides: Partial<Parameters<typeof emitScheduleResultNotification>[0]> = {},
+): Promise<void> {
+  await emitScheduleResultNotification({
+    scheduleId: SCHEDULE_ID,
+    scheduleName: "Morning briefing",
+    conversationId: CONVERSATION_ID,
+    runId: RUN_ID,
+    runStartedAt: RUN_STARTED_AT,
+    rlog,
+    ...overrides,
+  });
+}
+
+beforeEach(() => {
+  emitCalls.length = 0;
+  warnCalls.length = 0;
+  infoCalls.length = 0;
+  notifiedProbeArgs.length = 0;
+  alreadyNotified = false;
+  turnRows = [];
+  attentionState = makeAttentionState();
+  assistantRow = makeAssistantRow([
+    { type: "text", text: "**3 new emails** and one calendar change." },
+  ] as ContentBlock[]);
+  setOverridesForTesting({ "schedule-result-notify": true });
+});
+
+describe("emitScheduleResultNotification", () => {
+  test("notifies when a run produced output and never notified itself", async () => {
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].sourceEventName).toBe("schedule.result");
+    expect(emitCalls[0].sourceChannel).toBe("scheduler");
+    // The run's conversation is the deep-link target and what earns the
+    // home-feed mirror.
+    expect(emitCalls[0].sourceContextId).toBe(CONVERSATION_ID);
+    expect(emitCalls[0].contextPayload.requestedTitle).toBe("Morning briefing");
+    expect(emitCalls[0].contextPayload.requestedMessage).toBe(
+      "**3 new emails** and one calendar change.",
+    );
+  });
+
+  test("stays silent when the run already notified itself", async () => {
+    alreadyNotified = true;
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("bounds the already-notified probe to this run, not the conversation", async () => {
+    // A reused conversation carries every prior run's notifications. Without
+    // the lower bound, run #2 onward would be silenced by run #1's send.
+    await run();
+
+    expect(notifiedProbeArgs).toEqual([[CONVERSATION_ID, RUN_STARTED_AT]]);
+  });
+
+  test("stays silent when the run delivered by email through messaging_send", async () => {
+    // The schedule skill's prescribed route for rich content. It writes no
+    // notification event, so only the tool call shows the user has the result.
+    turnRows = [
+      makeToolCallRow("messaging_send", {
+        platform: "gmail",
+        conversation_id: "thread-1",
+        message: "Inbox digest…",
+      }),
+    ];
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "Sent the digest to your inbox." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("stays silent when the run posted to Slack through chat.postMessage", async () => {
+    turnRows = [
+      makeToolCallRow("bash", {
+        command:
+          'assistant oauth request --provider slack_channel /chat.postMessage --json \'{"channel":"C1","text":"digest"}\'',
+      }),
+    ];
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "Posted the digest to #general." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("still notifies when the run's tool calls were not deliveries", async () => {
+    // Bash that reads Slack is not bash that posts to it.
+    turnRows = [
+      makeToolCallRow("bash", {
+        command:
+          'assistant oauth request --provider slack_channel /conversations.history --json \'{"channel":"C1"}\'',
+      }),
+      makeToolCallRow("messaging_search", { query: "newer_than:1d" }),
+    ];
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+  });
+
+  test("stays silent when the latest reply predates this run", async () => {
+    // A reused conversation whose current run wrote no reply: the attention
+    // state still points at yesterday's, which must not be re-sent as today's.
+    assistantRow = makeAssistantRow(
+      [{ type: "text", text: "Yesterday's briefing." }] as ContentBlock[],
+      { createdAt: RUN_STARTED_AT - 1 },
+    );
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("stays silent when the run produced no assistant message", async () => {
+    attentionState = makeAttentionState({ latestAssistantMessageId: null });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("stays silent when the reply flattens to nothing", async () => {
+    // A run that ended on tool calls with no closing prose: whitespace and
+    // markdown scaffolding only. Nothing to say, so nothing is said.
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "   \n\n  \n" },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("notifies for an honest empty-handed result", async () => {
+    // "Nothing changed" is the briefing's answer, not an absence of one. The
+    // user picked this cadence; a run with a real finding still reports.
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "No new mail since yesterday." },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload.requestedMessage).toBe(
+      "No new mail since yesterday.",
+    );
+  });
+
+  test("keeps markdown in the body so the detail panel renders it", async () => {
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "- **PR #12** merged\n- `deploy.sh` failed" },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(emitCalls[0].contextPayload.requestedMessage).toBe(
+      "- **PR #12** merged\n- `deploy.sh` failed",
+    );
+  });
+
+  test("emits at medium urgency so it neither posts silently nor alarms", async () => {
+    await run();
+
+    expect(emitCalls[0].attentionHints.urgency).toBe("medium");
+    expect(emitCalls[0].attentionHints.requiresAction).toBe(false);
+    expect(emitCalls[0].attentionHints.isAsyncBackground).toBe(true);
+    expect(emitCalls[0].attentionHints.visibleInSourceNow).toBe(false);
+  });
+
+  test("keys dedupe on the run so sub-hourly schedules are not collapsed", async () => {
+    // The pipeline's dedupe window is a flat hour. A schedule-scoped key would
+    // silently drop every run after the first within that hour.
+    await run();
+
+    expect(emitCalls[0].dedupeKey).toBe(
+      `schedule.result:${SCHEDULE_ID}:${RUN_ID}`,
+    );
+  });
+
+  test("clamps an unbounded schedule name into a title", async () => {
+    await run({ scheduleName: "x".repeat(200) });
+
+    expect(
+      emitCalls[0].contextPayload.requestedTitle.length,
+    ).toBeLessThanOrEqual(60);
+  });
+
+  test("truncates a runaway reply rather than carrying it whole", async () => {
+    assistantRow = makeAssistantRow([
+      { type: "text", text: "y".repeat(5000) },
+    ] as ContentBlock[]);
+
+    await run();
+
+    expect(
+      emitCalls[0].contextPayload.requestedMessage.length,
+    ).toBeLessThanOrEqual(2000);
+  });
+
+  test("stays silent when the flag is off", async () => {
+    setOverridesForTesting({ "schedule-result-notify": false });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("stays silent for a bootstrap-failure sentinel conversation id", async () => {
+    await run({ conversationId: `bootstrap-error:${SCHEDULE_ID}` });
+
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("swallows an emit failure so a successful run is not failed by it", async () => {
+    mock.module("../emit-signal.js", () => ({
+      emitNotificationSignal: async () => {
+        throw new Error("simulated pipeline failure");
+      },
+    }));
+    const { emitScheduleResultNotification: emitWithBrokenPipeline } =
+      await import("../schedule-result-producer.js");
+
+    await emitWithBrokenPipeline({
+      scheduleId: SCHEDULE_ID,
+      scheduleName: "Morning briefing",
+      conversationId: CONVERSATION_ID,
+      runId: RUN_ID,
+      runStartedAt: RUN_STARTED_AT,
+      rlog,
+    });
+
+    // Asserting the cause, not just that something warned: a re-import that
+    // failed for an unrelated reason would also land in the catch.
+    expect(warnCalls).toHaveLength(1);
+    expect((warnCalls[0] as any[])[0].err.message).toBe(
+      "simulated pipeline failure",
+    );
+  });
+});

package/src/notifications/copy-composer.ts

@@ -172,6 +172,15 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
     body: str(payload.message, "A reminder has fired"),
   }),
 
+  // Unreachable on the happy path: the producer always carries
+  // `requestedMessage`, so `composeFallbackCopy`'s verbatim branch answers
+  // first. This is the floor for a signal whose body was lost, and it names
+  // the schedule so the user can still find the run.
+  "schedule.result": (payload) => ({
+    title: sanitizedPayloadField(payload.scheduleName, "Schedule"),
+    body: "A scheduled run finished with results.",
+  }),
+
   // The schedule.* fields below (names, cadence, error reason) originate in
   // plugin-authored declaration files, so they are sanitized like any other
   // untrusted actor-controlled string before interpolation.
@@ -311,7 +320,8 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
     );
     const verb = parsed?.decision === "approved" ? "approved" : "denied";
     return {
-      title: "Trusted Contact Decision",
+      // The outcome is the headline; who decided it is the body's to say.
+      title: `Access request ${verb}`,
       body: `${requesterLabel}'s access request has been ${verb} by ${decidedByLabel}.`,
     };
   },
@@ -326,15 +336,27 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
     body: str(payload.body, "A watcher event requires your attention"),
   }),
 
-  "tool_confirmation.required_action": (payload) => ({
-    title: "Tool Confirmation",
-    body: str(payload.toolName, "A tool") + " requires your confirmation",
-  }),
+  "tool_confirmation.required_action": (payload) => {
+    const toolName = str(payload.toolName, "A tool");
+    return {
+      title: `${toolName} needs your confirmation`,
+      body: `${toolName} requires your confirmation`,
+    };
+  },
 
-  "activity.complete": (payload) => ({
-    title: "Activity Complete",
-    body: str(payload.summary, "An activity has completed"),
-  }),
+  // Titled by what was done rather than by the kind of event: the summary's
+  // first sentence is the outcome ("Finished the fuel-system diagnostic app"),
+  // which is what a reader scanning the bell wants to see. A summary without
+  // one still gets a title that says something happened.
+  "activity.complete": (payload) => {
+    const summary = nonEmpty(
+      typeof payload.summary === "string" ? payload.summary : undefined,
+    );
+    return {
+      title: summary ? deriveTitle(summary) : "Activity complete",
+      body: summary ?? "An activity has completed",
+    };
+  },
 
   "activity.failed": (payload) => {
     const jobName = str(payload.jobName, "background job");
@@ -357,12 +379,12 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
   },
 
   "quick_chat.response_ready": (payload) => ({
-    title: "Response Ready",
+    title: "Quick chat reply ready",
     body: str(payload.preview, "Your quick chat response is ready"),
   }),
 
   "voice.response_ready": (payload) => ({
-    title: "Voice Response",
+    title: "Voice reply ready",
     body: str(payload.preview, "A voice response is ready"),
   }),
 };