@vellumai/assistant 0.8.1 → 0.8.3

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -47,12 +47,24 @@ mock.module("../../util/platform.js", () => ({
 
 // Stub config so heartbeat is enabled. Must export every symbol from
 // the real module because Bun's mock.module replaces the entire module.
-const stubConfig = {
+// Tests that need to flex maxConsecutiveRuns mutate this in-place.
+const stubConfig: {
+  heartbeat: {
+    enabled: boolean;
+    intervalMs: number;
+    activeHoursStart: number | null;
+    activeHoursEnd: number | null;
+    maxConsecutiveRuns: number | null;
+    disposition: string;
+  };
+} = {
   heartbeat: {
     enabled: true,
     intervalMs: 60_000,
     activeHoursStart: null,
     activeHoursEnd: null,
+    maxConsecutiveRuns: null,
+    disposition: "Default disposition text.",
   },
 };
 mock.module("../../config/loader.js", () => ({
@@ -91,7 +103,6 @@ mock.module("../../prompts/system-prompt.js", () => ({
   SYSTEM_PROMPT_CACHE_BOUNDARY: "<<CACHE_BOUNDARY>>",
   buildCoreIdentityContext: () => "",
   buildSystemPrompt: () => "",
-  buildCliReferenceSection: () => "",
   ensurePromptFiles: () => {},
   stripCommentLines: (s: string) => s,
 }));
@@ -165,7 +176,6 @@ mock.module("../../runtime/pre-first-message-gate.js", () => ({
   hasReceivedUserMessage: () => preFirstMessageGateOpen,
 }));
 
-
 const { HeartbeatService } = await import("../heartbeat-service.js");
 
 let origWorkspaceDir: string | undefined;
@@ -178,6 +188,7 @@ beforeEach(() => {
   runBackgroundJobCalls.length = 0;
   skipHeartbeatRunCalls.length = 0;
   preFirstMessageGateOpen = true;
+  stubConfig.heartbeat.maxConsecutiveRuns = null;
   runBackgroundJobImpl = async () => ({
     conversationId: STUB_CONVERSATION_ID,
     ok: true,
@@ -351,9 +362,127 @@ describe("HeartbeatService", () => {
 
     expect(runBackgroundJobCalls).toHaveLength(1);
     expect(
-      skipHeartbeatRunCalls.some(
-        (c) => c.reason === "pre_first_user_message",
-      ),
+      skipHeartbeatRunCalls.some((c) => c.reason === "pre_first_user_message"),
     ).toBe(false);
   });
+
+  describe("max consecutive runs cap", () => {
+    test("skips with reason 'max_consecutive_runs' after the cap is hit", async () => {
+      stubConfig.heartbeat.maxConsecutiveRuns = 2;
+      const service = new HeartbeatService({ alerter: () => {} });
+
+      expect(await service.runOnce({ force: false })).toBe(true);
+      expect(await service.runOnce({ force: false })).toBe(true);
+      expect(await service.runOnce({ force: false })).toBe(false);
+
+      expect(runBackgroundJobCalls).toHaveLength(2);
+      expect(
+        skipHeartbeatRunCalls.some((c) => c.reason === "max_consecutive_runs"),
+      ).toBe(true);
+    });
+
+    test("resetTimer() clears the counter so auto runs resume", async () => {
+      stubConfig.heartbeat.maxConsecutiveRuns = 1;
+      const service = new HeartbeatService({ alerter: () => {} });
+      service.start();
+      try {
+        await service.runOnce({ force: false });
+        expect(await service.runOnce({ force: false })).toBe(false);
+
+        service.resetTimer();
+        expect(await service.runOnce({ force: false })).toBe(true);
+        expect(runBackgroundJobCalls).toHaveLength(2);
+      } finally {
+        await service.stop();
+      }
+    });
+
+    test("resetTimer() during an in-flight run is not undone by that run's increment", async () => {
+      // Regression: if a guardian message arrives mid-run, `resetTimer()`
+      // zeroes the counter but the in-flight run's `finally` block used to
+      // unconditionally `_consecutiveRuns++`, leaving the counter at 1 and
+      // tripping the cap-at-1 path one auto run too early.
+      stubConfig.heartbeat.maxConsecutiveRuns = 1;
+
+      let releaseInflight: () => void = () => {};
+      const inflight = new Promise<void>((resolve) => {
+        releaseInflight = resolve;
+      });
+      runBackgroundJobImpl = async () => {
+        await inflight;
+        return { conversationId: STUB_CONVERSATION_ID, ok: true };
+      };
+
+      const service = new HeartbeatService({ alerter: () => {} });
+      service.start();
+      try {
+        const runPromise = service.runOnce({ force: false });
+        // Guardian message arrives while the run is still executing.
+        service.resetTimer();
+        releaseInflight();
+        expect(await runPromise).toBe(true);
+
+        // The reset during the in-flight run must survive: the next auto run
+        // should proceed because the counter is still 0, not 1.
+        runBackgroundJobImpl = async () => ({
+          conversationId: STUB_CONVERSATION_ID,
+          ok: true,
+        });
+        expect(await service.runOnce({ force: false })).toBe(true);
+        expect(
+          skipHeartbeatRunCalls.some(
+            (c) => c.reason === "max_consecutive_runs",
+          ),
+        ).toBe(false);
+      } finally {
+        await service.stop();
+      }
+    });
+
+    test("null disables the cap entirely", async () => {
+      stubConfig.heartbeat.maxConsecutiveRuns = null;
+      const service = new HeartbeatService({ alerter: () => {} });
+
+      for (let i = 0; i < 5; i++) {
+        expect(await service.runOnce({ force: false })).toBe(true);
+      }
+      expect(runBackgroundJobCalls).toHaveLength(5);
+      expect(
+        skipHeartbeatRunCalls.some((c) => c.reason === "max_consecutive_runs"),
+      ).toBe(false);
+    });
+
+    test("force runs bypass the cap and do not increment the counter", async () => {
+      stubConfig.heartbeat.maxConsecutiveRuns = 2;
+      const service = new HeartbeatService({ alerter: () => {} });
+
+      // Five force runs would push us well past the cap if force counted.
+      for (let i = 0; i < 5; i++) {
+        expect(await service.runOnce({ force: true })).toBe(true);
+      }
+      // Two auto runs should still proceed because the counter is at zero.
+      expect(await service.runOnce({ force: false })).toBe(true);
+      expect(await service.runOnce({ force: false })).toBe(true);
+      // The third auto run trips the cap.
+      expect(await service.runOnce({ force: false })).toBe(false);
+      expect(
+        skipHeartbeatRunCalls.some((c) => c.reason === "max_consecutive_runs"),
+      ).toBe(true);
+    });
+
+    test("reconfigure() resets the counter", async () => {
+      stubConfig.heartbeat.maxConsecutiveRuns = 1;
+      const service = new HeartbeatService({ alerter: () => {} });
+      service.start();
+      try {
+        await service.runOnce({ force: false });
+        expect(await service.runOnce({ force: false })).toBe(false);
+
+        service.reconfigure();
+        expect(await service.runOnce({ force: false })).toBe(true);
+      } finally {
+        await service.stop();
+      }
+    });
+  });
 });

package/src/heartbeat/heartbeat-run-store.ts

@@ -23,7 +23,8 @@ export type HeartbeatSkipReason =
   | "disabled"
   | "outside_active_hours"
   | "overlap"
-  | "pre_first_user_message";
+  | "pre_first_user_message"
+  | "max_consecutive_runs";
 
 export interface HeartbeatRunRecord {
   id: string;

package/src/heartbeat/heartbeat-service.ts

@@ -9,8 +9,6 @@ import {
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
 import type { HeartbeatAlert } from "../daemon/message-protocol.js";
-import { getConversation, getMessages } from "../memory/conversation-crud.js";
-import { GENERATING_TITLE } from "../memory/conversation-title-service.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import {
   GUARDIAN_PERSONA_TEMPLATE,
@@ -47,9 +45,6 @@ const DEFAULT_CHECKLIST = `- Check in with yourself. Read NOW.md. Is it still ac
 const EARLY_HEARTBEAT_THRESHOLD = 3;
 const REENGAGEMENT_COOLDOWN_MS = 18 * 60 * 60 * 1000; // 18 hours
 const HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-const HEARTBEAT_ALERT_MARKER = "HEARTBEAT_ALERT";
-const HEARTBEAT_OK_MARKER = "HEARTBEAT_OK";
-const HEARTBEAT_ALERT_SUMMARY_MAX_CHARS = 700;
 
 // Stripped-comment form of the guardian persona scaffold. Computed
 // once at module load because stripping comment lines is deterministic
@@ -102,69 +97,6 @@ function recordReengagementTimestamp(): void {
   }
 }
 
-type HeartbeatDisposition = "alert" | "ok" | "unknown";
-
-function parseHeartbeatDisposition(text: string | null): HeartbeatDisposition {
-  if (!text) return "unknown";
-  const lines = text
-    .trim()
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
-  const lastLine = lines.at(-1);
-  if (lastLine === HEARTBEAT_ALERT_MARKER) return "alert";
-  if (lastLine === HEARTBEAT_OK_MARKER) return "ok";
-  return "unknown";
-}
-
-function stripHeartbeatDispositionMarkers(text: string): string {
-  return text
-    .replace(
-      new RegExp(
-        `(?:\\r?\\n)?\\s*(?:${HEARTBEAT_ALERT_MARKER}|${HEARTBEAT_OK_MARKER})\\s*$`,
-      ),
-      "",
-    )
-    .trim();
-}
-
-function truncateSummary(text: string, maxChars: number): string {
-  if (text.length <= maxChars) return text;
-  return `${text.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
-}
-
-function buildHeartbeatAlertSummary(text: string | null): string {
-  const summary = text ? stripHeartbeatDispositionMarkers(text) : "";
-  return truncateSummary(
-    summary || "Your assistant found something worth your attention.",
-    HEARTBEAT_ALERT_SUMMARY_MAX_CHARS,
-  );
-}
-
-function extractVisibleTextFromStoredMessageContent(raw: string): string {
-  try {
-    const parsed = JSON.parse(raw) as unknown;
-    if (typeof parsed === "string") return parsed;
-    if (!Array.isArray(parsed)) return "";
-    const texts: string[] = [];
-    for (const block of parsed) {
-      if (
-        block != null &&
-        typeof block === "object" &&
-        "type" in block &&
-        block.type === "text" &&
-        "text" in block &&
-        typeof block.text === "string"
-      ) {
-        texts.push(block.text);
-      }
-    }
-    return texts.join("\n").trim();
-  } catch {
-    return raw;
-  }
-}
-
 export interface HeartbeatDeps {
   alerter: (alert: HeartbeatAlert) => void;
   onConversationCreated?: (info: {
@@ -198,6 +130,13 @@ export class HeartbeatService {
   private _startupMissedCount = 0;
   private _startupCrashedCount = 0;
   private _hasRunStartupRecovery = false;
+  // Counter of consecutive auto-heartbeats since the last guardian message.
+  // Reset by resetTimer (guardian message), reconfigure, and stop. Force runs
+  // bypass the cap and do not increment.
+  private _consecutiveRuns = 0;
+  // Bumped every time the counter is reset so an in-flight run that finishes
+  // after a guardian message can detect the reset and skip its increment.
+  private _resetGeneration = 0;
 
   constructor(deps: HeartbeatDeps) {
     this.deps = deps;
@@ -262,6 +201,11 @@ export class HeartbeatService {
               isAsyncBackground: true,
               visibleInSourceNow: false,
             },
+            conversationMetadata: {
+              source: "heartbeat",
+              groupId: "system:background",
+              conversationType: "background",
+            },
           }).catch((err) => {
             log.warn(
               { err },
@@ -350,6 +294,8 @@ export class HeartbeatService {
 
   /** Restart the timer with the latest config (e.g. after settings change). */
   reconfigure(): void {
+    this._consecutiveRuns = 0;
+    this._resetGeneration++;
     this.configEpoch++;
     if (this._pendingRunId) {
       supersedePendingRun(this._pendingRunId);
@@ -371,6 +317,10 @@ export class HeartbeatService {
    * after an active conversation.
    */
   resetTimer(): void {
+    // Counter resets even when the timer is null so a guardian message during
+    // a stopped window still clears the count.
+    this._consecutiveRuns = 0;
+    this._resetGeneration++;
     if (!this.timer) return;
     if (this.cronMode) {
       clearTimeout(this.timer as ReturnType<typeof setTimeout>);
@@ -390,6 +340,8 @@ export class HeartbeatService {
   }
 
   async stop(): Promise<void> {
+    this._consecutiveRuns = 0;
+    this._resetGeneration++;
     this.stopped = true;
     if (this.timer) {
       clearTimeout(this.timer as ReturnType<typeof setTimeout>);
@@ -500,6 +452,28 @@ export class HeartbeatService {
       }
     }
 
+    // Cap consecutive auto-runs without a guardian message so the assistant
+    // stops burning LLM tokens when the user is away. Force runs (manual
+    // operator action) bypass the cap and do not increment the counter.
+    if (
+      !force &&
+      config.maxConsecutiveRuns != null &&
+      this._consecutiveRuns >= config.maxConsecutiveRuns
+    ) {
+      log.debug(
+        {
+          consecutiveRuns: this._consecutiveRuns,
+          maxConsecutiveRuns: config.maxConsecutiveRuns,
+        },
+        "Max consecutive runs reached, skipping",
+      );
+      if (runId) skipHeartbeatRun(runId, "max_consecutive_runs");
+      if (!this.cronMode) {
+        this.scheduleNextRun(config.intervalMs);
+      }
+      return false;
+    }
+
     // Overlap prevention
     if (this.activeRun) {
       log.debug("Previous heartbeat run still active, skipping");
@@ -516,6 +490,11 @@ export class HeartbeatService {
     }
     const run = this.executeRun(runId, scheduledFor);
     this.activeRun = run;
+    // Snapshot the reset generation so we can detect whether a reset (guardian
+    // message, reconfigure, stop) happened while this run was in flight. If it
+    // did, the counter was already zeroed and we must not undo that reset by
+    // incrementing in `finally`.
+    const startGeneration = this._resetGeneration;
     try {
       await run;
     } catch (err) {
@@ -525,6 +504,9 @@ export class HeartbeatService {
         this.activeRun = null;
       }
       this._lastRunAt = Date.now();
+      if (!force && this._resetGeneration === startGeneration) {
+        this._consecutiveRuns++;
+      }
       if (!this.cronMode) {
         this.scheduleNextRun(getConfig().heartbeat.intervalMs);
       }
@@ -648,6 +630,7 @@ export class HeartbeatService {
           conversationMetadata: {
             source: "heartbeat",
             groupId: "system:background",
+            conversationType: "background",
           },
         });
       } catch (err) {
@@ -659,65 +642,6 @@ export class HeartbeatService {
     }
   }
 
-  private getLatestAssistantMessage(
-    conversationId: string,
-  ): { id: string; text: string } | null {
-    try {
-      const messages = getMessages(conversationId);
-      for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i]!;
-        if (message.role !== "assistant") continue;
-        return {
-          id: message.id,
-          text: extractVisibleTextFromStoredMessageContent(message.content),
-        };
-      }
-    } catch (err) {
-      log.warn(
-        { err, conversationId },
-        "Failed to read heartbeat assistant message",
-      );
-    }
-    return null;
-  }
-
-  private async emitHeartbeatAlertNotification(params: {
-    runId: string;
-    conversationId: string;
-    messageId?: string;
-    conversationTitle: string;
-    summary: string;
-  }): Promise<void> {
-    const { emitNotificationSignal } =
-      await import("../notifications/emit-signal.js");
-
-    await emitNotificationSignal({
-      sourceEventName: "heartbeat.alert",
-      sourceChannel: "watcher",
-      sourceContextId: params.runId,
-      dedupeKey: `heartbeat:alert:${params.runId}`,
-      attentionHints: {
-        requiresAction: true,
-        urgency: "medium",
-        isAsyncBackground: true,
-        visibleInSourceNow: false,
-      },
-      contextPayload: {
-        title: "Heartbeat Alert",
-        summary: params.summary,
-        conversationTitle: params.conversationTitle,
-        conversationId: params.conversationId,
-        messageId: params.messageId,
-      },
-      routingIntent: "single_channel",
-      conversationAffinityHint: { vellum: params.conversationId },
-      conversationMetadata: {
-        source: "heartbeat",
-        groupId: "system:background",
-      },
-    });
-  }
-
   private async executeRun(runId: string, scheduledFor: number): Promise<void> {
     log.info("Running heartbeat");
 
@@ -746,9 +670,9 @@ export class HeartbeatService {
     // The runner fires `onConversationCreated` synchronously after
     // bootstrap so the macOS sidebar gets the new conversation
     // immediately rather than waiting up to HEARTBEAT_TIMEOUT_MS for
-    // the LLM turn to finish. We forward to `deps.onConversationCreated`
-    // for every run; "silent OK" is enforced by NOT emitting any
-    // notification signal further down, not by hiding the conversation.
+    // the LLM turn to finish. If the model judges the run worth
+    // surfacing to the guardian, it calls the `notifications` skill
+    // directly — no in-band marker.
     let conversationId: string | undefined;
     const result = await runBackgroundJob({
       jobName: "heartbeat",
@@ -780,62 +704,26 @@ export class HeartbeatService {
         "Heartbeat completed",
       );
 
-      // Mark the run record as ok and surface any disposition-driven
-      // alert the assistant decided to raise. The runner owns failure
-      // emission via `activity.failed`; success-side surfacing (alerts,
-      // late warnings) lives here so it can read the actual conversation
-      // contents.
+      // Mark the run record as ok. The runner owns failure emission via
+      // `activity.failed`; any user-facing alert the model decided to
+      // raise was emitted in-band via the `notifications` skill during
+      // the turn itself.
       const transitioned = completeHeartbeatRun(runId, {
         status: "ok",
         conversationId: result.conversationId,
       });
 
-      if (transitioned) {
-        let title = "Heartbeat";
-        try {
-          const row = getConversation(result.conversationId);
-          if (row?.title && row.title !== GENERATING_TITLE) {
-            title = row.title;
-          }
-        } catch {
-          // Best-effort; fall back to generic title.
-        }
-
-        const assistantMessage = this.getLatestAssistantMessage(
-          result.conversationId,
-        );
-        const disposition = parseHeartbeatDisposition(
-          assistantMessage?.text ?? null,
-        );
-        if (disposition === "alert") {
-          // Conversation was already surfaced via the runner's bootstrap
-          // callback above; alert just needs to emit the notification.
-          void this.emitHeartbeatAlertNotification({
+      if (transitioned && latenessMs > LATE_THRESHOLD_MS) {
+        const lateMinutes = Math.round(latenessMs / 60_000);
+        log.warn(
+          {
+            latenessMs,
+            lateMinutes,
+            scheduledFor,
             runId,
-            conversationId: result.conversationId,
-            messageId: assistantMessage?.id,
-            conversationTitle: title,
-            summary: buildHeartbeatAlertSummary(assistantMessage?.text ?? null),
-          }).catch((err) => {
-            log.warn(
-              { err, conversationId: result.conversationId },
-              "Failed to emit heartbeat alert notification",
-            );
-          });
-        }
-
-        if (latenessMs > LATE_THRESHOLD_MS) {
-          const lateMinutes = Math.round(latenessMs / 60_000);
-          log.warn(
-            {
-              latenessMs,
-              lateMinutes,
-              scheduledFor,
-              runId,
-            },
-            "Heartbeat ran late",
-          );
-        }
+          },
+          "Heartbeat ran late",
+        );
       }
       return;
     }
@@ -900,18 +788,14 @@ Do NOT attempt to use tools for these providers — they will fail. Skip any che
 </credential-status>`;
     }
 
-    prompt += `\n\n<heartbeat-disposition>
-This heartbeat runs frequently. Do not manufacture a report just because it ran.
-If there is nothing genuinely useful, actionable, or interesting to surface, keep the response brief and end with HEARTBEAT_OK.
-If there is something worth interrupting the guardian for, write a concise guardian-facing note first: what happened, why it matters, and the recommended next step. Address the guardian directly as "you"; do not write instructions to yourself or another intermediary. Then end with HEARTBEAT_ALERT. That note may be used as notification copy.
-After completing your review, end your response with one of:
-- HEARTBEAT_OK — if everything looks good, no action needed
-- HEARTBEAT_ALERT — if you found issues that need attention (describe them before this marker)
-</heartbeat-disposition>`;
+    const disposition = getConfig().heartbeat.disposition;
+    if (disposition) {
+      prompt += `\n\n<heartbeat-disposition>\n${disposition}\n</heartbeat-disposition>`;
+    }
 
     if (completedRunCount < EARLY_HEARTBEAT_THRESHOLD) {
       prompt += `\n\n<early-heartbeat>
-This is one of your first heartbeats. Your user hasn't heard from you yet and may not know you're here. Find something genuinely useful to share — a follow-up from a recent conversation, something you noticed, or a quick check-in. Lean toward HEARTBEAT_ALERT this time. First impressions matter.
+This is one of your first heartbeats. Your user hasn't heard from you yet and may not know you're here. Find something genuinely useful to share — a follow-up from a recent conversation, something you noticed, or a quick check-in. Lean toward surfacing it via the notifications skill this time. First impressions matter.
 </early-heartbeat>`;
     }
 

package/src/home/__tests__/feed-types.test.ts

@@ -82,6 +82,62 @@ describe("feedItemSchema — valid minimal items", () => {
     expect(parsed.expiresAt).toBe("2026-04-15T00:00:00.000Z");
     expect(parsed.detailPanel?.kind).toBe("emailDraft");
   });
+
+  test("category field passes through when present", () => {
+    for (const cat of [
+      "security",
+      "scheduling",
+      "background",
+      "email",
+      "system",
+    ] as const) {
+      const parsed = feedItemSchema.parse({
+        ...minimalNotification(),
+        category: cat,
+      });
+      expect(parsed.category).toBe(cat);
+    }
+  });
+
+  test("metadata field passes through when present", () => {
+    const parsed = feedItemSchema.parse({
+      ...minimalNotification(),
+      metadata: { subject: "Hello", count: 3, nested: { ok: true } },
+    });
+    expect(parsed.metadata).toEqual({
+      subject: "Hello",
+      count: 3,
+      nested: { ok: true },
+    });
+  });
+
+  test("items without category or metadata still parse (backward compat)", () => {
+    const parsed = feedItemSchema.parse(minimalNotification());
+    expect(parsed.category).toBeUndefined();
+    expect(parsed.metadata).toBeUndefined();
+  });
+
+  test("noteworthy field passes through when present", () => {
+    const parsed = feedItemSchema.parse({
+      ...minimalNotification(),
+      noteworthy: true,
+    });
+    expect(parsed.noteworthy).toBe(true);
+  });
+
+  test("items without noteworthy field still parse (backward compat)", () => {
+    const parsed = feedItemSchema.parse(minimalNotification());
+    expect(parsed.noteworthy).toBeUndefined();
+  });
+
+  test("title is optional and may be omitted", () => {
+    const { title: _omitted, ...rest } = minimalNotification();
+    const parsed = feedItemSchema.parse(rest);
+    expect(parsed.title).toBeUndefined();
+    expect(parsed.summary).toBe(
+      "You mentioned wanting to review the onboarding designs.",
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -142,6 +198,12 @@ describe("feedItemSchema — enum validation", () => {
     }
   });
 
+  test("rejects unknown `category`", () => {
+    expect(() =>
+      feedItemSchema.parse({ ...minimalNotification(), category: "weather" }),
+    ).toThrow();
+  });
+
   test("rejects unknown `status`", () => {
     expect(() =>
       feedItemSchema.parse({ ...minimalNotification(), status: "archived" }),
@@ -204,4 +266,22 @@ describe("parseFeedFile", () => {
       }),
     ).toThrow();
   });
+
+  test("accepts a file with a noteworthy item", () => {
+    const parsed = parseFeedFile({
+      version: 2,
+      items: [{ ...minimalNotification(), noteworthy: true }],
+      updatedAt: NOW_ISO,
+    });
+    expect(parsed.items[0]?.noteworthy).toBe(true);
+  });
+
+  test("accepts a file whose items omit noteworthy (backward compat)", () => {
+    const parsed = parseFeedFile({
+      version: 2,
+      items: [minimalNotification()],
+      updatedAt: NOW_ISO,
+    });
+    expect(parsed.items[0]?.noteworthy).toBeUndefined();
+  });
 });