@desplega.ai/agent-swarm 2.2.0 → 2.3.0

package/src/tests/asset-key-migration.test.ts

@@ -4,6 +4,7 @@ import { closeDb, createTaskExtended, createUser, getDb, getDbClient, initDb } f
 const FRESH_DB = "./test-asset-key-migration-fresh.sqlite";
 const HISTORICAL_DB = "./test-asset-key-migration-historical.sqlite";
 const HISTORY_REBUILD_DB = "./test-asset-key-migration-history-rebuild.sqlite";
+const INBOX_UPGRADE_DB = "./test-asset-key-migration-inbox-upgrade.sqlite";
 const LEGACY_STATUS_DB = "./test-asset-key-migration-legacy-status.sqlite";
 
 const globals = globalThis as typeof globalThis & {
@@ -97,6 +98,7 @@ beforeAll(async () => {
   await removeDb(HISTORICAL_DB);
   await removeDb(HISTORY_REBUILD_DB);
   await removeDb(LEGACY_STATUS_DB);
+  await removeDb(INBOX_UPGRADE_DB);
   initDb(FRESH_DB);
 });
 
@@ -108,6 +110,7 @@ afterAll(async () => {
   await removeDb(HISTORICAL_DB);
   await removeDb(HISTORY_REBUILD_DB);
   await removeDb(LEGACY_STATUS_DB);
+  await removeDb(INBOX_UPGRADE_DB);
 });
 
 describe("asset namespace key migrations", () => {
@@ -173,6 +176,38 @@ describe("asset namespace key migrations", () => {
     expect(historySchema).toContain("'script'");
   });
 
+  test("inbox read cursor is nullable on fresh databases and has no backfill on upgrade", async () => {
+    const column = await getDbClient().get<{ notnull: number; dflt_value: string | null }>(
+      "SELECT \"notnull\", dflt_value FROM pragma_table_info('inbox_item_state') WHERE name = 'lastReadAt'",
+    );
+    expect(column).toEqual({ notnull: 0, dflt_value: null });
+    closeDb();
+    initDb(INBOX_UPGRADE_DB);
+    try {
+      const user = await createUser({ name: "Upgrade User", email: "inbox-upgrade@example.com" });
+      const readAt = "2026-01-01T00:00:00.000Z";
+      await getDbClient().run(
+        `INSERT INTO inbox_item_state (userId, itemType, itemId, status, readAt)
+         VALUES (?, 'to_read', 'existing-item', 'done', ?)`,
+        [user.id, readAt],
+      );
+      await getDbClient().run("ALTER TABLE inbox_item_state DROP COLUMN lastReadAt");
+      await getDbClient().run("DELETE FROM _migrations WHERE version = 227");
+      closeDb();
+      initDb(INBOX_UPGRADE_DB);
+      expect(
+        await getDbClient().get(
+          "SELECT status, readAt, lastReadAt FROM inbox_item_state WHERE itemId = 'existing-item'",
+        ),
+      ).toEqual({ status: "done", readAt, lastReadAt: null });
+      closeDb();
+      expect(() => initDb(INBOX_UPGRADE_DB)).not.toThrow();
+    } finally {
+      closeDb();
+      initDb(FRESH_DB);
+    }
+  });
+
   test("old insert statements may omit key and repeated shared namespaces are valid", () => {
     const now = new Date().toISOString();
     const taskId = crypto.randomUUID();

package/src/tests/docs-index-footprint.test.js

@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(430);
-    expect(generatedKeys).toHaveLength(430);
+    expect(operationKeys).toHaveLength(431);
+    expect(generatedKeys).toHaveLength(431);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/heartbeat-checklist.test.ts

@@ -13,10 +13,14 @@ import {
   closeDb,
   createAgent,
   createTaskExtended,
+  deletePromptTemplate,
   getDbClient,
+  getKv,
+  getRecentFailedTasks,
   initDb,
   startTask,
   updateAgentProfile,
+  upsertPromptTemplate,
   upsertSwarmConfig,
 } from "../be/db";
 import { getScript, upsertScriptByName } from "../be/scripts/db";
@@ -240,6 +244,89 @@ describe("Heartbeat Checklist", () => {
       expect(tasks[0]!.priority).toBe(60);
     });
 
+    test("receipt stores exactly the ten rendered full IDs from twelve failures", async () => {
+      const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await updateAgentProfile(lead.id, { heartbeatMd: "- Check failures" });
+      for (let i = 0; i < 12; i++) {
+        const task = await createTaskExtended(`receipt failure ${i}`, { agentId: lead.id });
+        await getDbClient().run(
+          "UPDATE agent_tasks SET status = 'failed', failureReason = ?, finishedAt = ? WHERE id = ?",
+          [`receipt reason ${i}`, new Date(Date.now() - (i + 1) * 60e3).toISOString(), task.id],
+        );
+      }
+      const failures = await getRecentFailedTasks(6);
+      const before = Date.now();
+      await checkHeartbeatChecklist();
+      const checklist = await getDbClient().get<{ id: string; task: string }>(
+        "SELECT id, task FROM agent_tasks WHERE taskType = 'heartbeat-checklist'",
+      );
+      expect(checklist).toBeDefined();
+      const receipt = await getKv("heartbeat-checklist:reported-failures", checklist!.id);
+      expect(receipt?.value).toEqual(failures.slice(0, 10).map((task) => task.id));
+      expect(receipt?.expiresAt).toBeGreaterThanOrEqual(before + 7 * 24 * 3600e3);
+      expect(receipt?.expiresAt).toBeLessThanOrEqual(Date.now() + 7 * 24 * 3600e3);
+      for (const failure of failures.slice(0, 10)) {
+        expect(checklist!.task).toContain(`[${failure.id.slice(0, 8)}]`);
+      }
+      for (const failure of failures.slice(10)) {
+        expect(checklist!.task).not.toContain(`[${failure.id.slice(0, 8)}]`);
+      }
+    });
+
+    test("receipt excludes failures when the global checklist template omits system status", async () => {
+      const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await updateAgentProfile(lead.id, { heartbeatMd: "- Check standing orders" });
+      const failure = await createTaskExtended("Unrendered failure", { agentId: lead.id });
+      await getDbClient().run(
+        "UPDATE agent_tasks SET status = 'failed', failureReason = ?, finishedAt = ? WHERE id = ?",
+        ["boom", new Date(Date.now() - 1000).toISOString(), failure.id],
+      );
+      const template = upsertPromptTemplate({
+        eventType: "heartbeat.checklist",
+        scope: "global",
+        state: "enabled",
+        body: "Review standing orders:\n{{heartbeat_content}}",
+      });
+      try {
+        await checkHeartbeatChecklist();
+        const checklist = await getDbClient().get<{ id: string; task: string }>(
+          "SELECT id, task FROM agent_tasks WHERE taskType = 'heartbeat-checklist'",
+        );
+        expect(checklist?.task).toBe("Review standing orders:\n- Check standing orders");
+        expect(
+          (await getKv("heartbeat-checklist:reported-failures", checklist!.id))?.value,
+        ).toEqual([]);
+      } finally {
+        await deletePromptTemplate(template.id);
+      }
+    });
+
+    test("receipt write errors log and preserve the created checklist", async () => {
+      const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
+      await updateAgentProfile(lead.id, { heartbeatMd: "- Check failures" });
+      await getDbClient().run(`CREATE TRIGGER reject_heartbeat_receipt
+        BEFORE INSERT ON kv_entries
+        WHEN NEW.namespace = 'heartbeat-checklist:reported-failures'
+        BEGIN SELECT RAISE(FAIL, 'receipt unavailable'); END`);
+      const log = spyOn(console, "error").mockImplementation(() => {});
+      try {
+        await checkHeartbeatChecklist();
+        const checklist = await getDbClient().get<{ id: string }>(
+          "SELECT id FROM agent_tasks WHERE taskType = 'heartbeat-checklist'",
+        );
+        expect(checklist).toBeDefined();
+        expect(log).toHaveBeenCalledWith(
+          expect.stringContaining(
+            `Failed to save reported failures for checklist ${checklist!.id}`,
+          ),
+          expect.any(Error),
+        );
+      } finally {
+        log.mockRestore();
+        await getDbClient().run("DROP TRIGGER reject_heartbeat_receipt");
+      }
+    });
+
     test("dedup: skips when active heartbeat-checklist task exists for lead", async () => {
       const lead = await createAgent({ name: "lead", isLead: true, status: "idle" });
       await updateAgentProfile(lead.id, {
@@ -725,6 +812,7 @@ describe("Heartbeat Checklist", () => {
       expect(tasks.length).toBe(1);
       expect(tasks[0]!.agentId).toBe(lead.id);
       expect(tasks[0]!.priority).toBe(70);
+      expect(await getKv("heartbeat-checklist:reported-failures", tasks[0]!.id)).toBeNull();
     });
 
     test("boot-triage task includes reboot context", async () => {

package/src/tests/heartbeat-jev-gate.test.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
@@ -19,7 +20,9 @@ type Fixture = {
   configs: Record<string, string>;
   heartbeatMd?: string;
   prevStatus?: string;
+  reportedFailures?: unknown;
   prevOutput?: string | null;
+  prevCreatedAt?: string | null;
   failed?: Array<Record<string, unknown>>;
   approvalStatus?: string;
   /** Stands in for `ctx.swarm.systemOne_decide`; returns the bridge result. */
@@ -33,6 +36,7 @@ function fakeCtx(f: Fixture) {
     kvSets: 0,
     decides: [] as Array<Record<string, any>>,
     approvalReads: 0,
+    previousReads: 0,
   };
   const table = (columns: string[], rows: unknown[][]) => ({
     success: true,
@@ -56,17 +60,48 @@ function fakeCtx(f: Fixture) {
           },
         };
       },
-      db_query: async ({ sql }: { sql: string }) => {
+      db_query: async ({ sql, params = [] }: { sql: string; params?: any[] }) => {
         if (sql.includes("FROM approval_requests")) {
           calls.approvalReads++;
           return table(["status"], f.approvalStatus ? [[f.approvalStatus]] : []);
         }
         if (sql.includes("heartbeatMd")) return table(["heartbeatMd"], [[f.heartbeatMd ?? ""]]);
-        if (sql.includes("'heartbeat-checklist'")) {
-          return table(
-            ["id", "output", "status"],
-            [["prev-id", f.prevOutput ?? null, f.prevStatus ?? ""]],
-          );
+        if (sql.includes("'heartbeat-checklist'") || sql.includes("finishedAt <= ?")) {
+          if (sql.includes("'heartbeat-checklist'")) calls.previousReads++;
+          // Execute historical selection against real rows, including its bounds and limit.
+          const db = new Database(":memory:");
+          try {
+            db.run(`CREATE TABLE agent_tasks (
+              id TEXT, output TEXT, task TEXT, agentId TEXT, taskType TEXT,
+              status TEXT, createdAt TEXT, finishedAt TEXT
+            )`);
+            if (f.prevCreatedAt !== null)
+              db.run("INSERT INTO agent_tasks VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+                "prev-id",
+                f.prevOutput ?? null,
+                f.prevStatus ?? "",
+                LEAD,
+                "heartbeat-checklist",
+                "completed",
+                f.prevCreatedAt ?? "2026-10-15T13:00:00.000Z",
+                null,
+              ]);
+            for (const failure of f.failed ?? []) {
+              db.run("INSERT INTO agent_tasks VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+                failure.id,
+                null,
+                failure.task,
+                failure.agentId,
+                "test",
+                "failed",
+                "2026-10-15T06:00:00.000Z",
+                failure.finishedAt,
+              ]);
+            }
+            return { data: { rows: db.query(sql).all(...params) } };
+          } finally {
+            db.close();
+          }
         }
         if (sql.includes("completed24")) {
           return table(
@@ -75,7 +110,10 @@ function fakeCtx(f: Fixture) {
           );
         }
         if (sql.includes("status = 'failed' AND finishedAt")) {
-          const rows = f.failed ?? [];
+          const rows = (f.failed ?? [])
+            .filter((r) => String(r.finishedAt) > params[0])
+            .sort((a, b) => String(b.finishedAt).localeCompare(String(a.finishedAt)))
+            .slice(0, 10);
           return table(
             ["id", "agentId", "task", "failureReason", "finishedAt"],
             rows.map((r) => [r.id, r.agentId, r.task, r.failureReason, r.finishedAt]),
@@ -93,8 +131,13 @@ function fakeCtx(f: Fixture) {
         }
         throw new Error(`unexpected sql: ${sql}`);
       },
-      kv_getOrNull: async ({ key }: { key: string }) =>
-        kv.has(key) ? { key, value: kv.get(key) } : null,
+      kv_getOrNull: async ({ namespace, key }: { namespace: string; key: string }) => {
+        if (namespace === "heartbeat-checklist:reported-failures") {
+          expect(key).toBe("prev-id");
+          return f.reportedFailures === undefined ? null : { key, value: f.reportedFailures };
+        }
+        return kv.has(key) ? { key, value: kv.get(key) } : null;
+      },
       kv_set: async ({ key, value }: { key: string; value: unknown }) => {
         calls.kvSets++;
         kv.set(key, value);
@@ -168,6 +211,7 @@ describe("heartbeat-jev-gate with a provider", () => {
   test("wake at or above the threshold, with the new failures and due items in summary", async () => {
     const { ctx } = fakeCtx({
       configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures: ["aaaaaaaa-0000"],
       heartbeatMd: [
         "# Standing orders",
         `- Watch: release on ${MMDD} — lift after ship`,
@@ -176,7 +220,7 @@ describe("heartbeat-jev-gate with a provider", () => {
       ].join("\n"),
       // The previous checklist already listed aaaaaaaa, so only bbbbbbbb is new.
       prevStatus:
-        '## Recent Failures (last 6h) [auto-generated]\n- [aaaaaaaa] "old failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z\n',
+        '## Current System Status [auto-generated]\n## Recent Failures (last 6h) [auto-generated]\n- [aaaaaaaa] "old failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z\n',
       prevOutput: "All clear.\n\nNothing to do.",
       failed: [
         {
@@ -217,6 +261,346 @@ describe("heartbeat-jev-gate with a provider", () => {
     });
   });
 
+  for (const ordersFirst of [true, false]) {
+    test(`previous failures are not new with standing orders ${ordersFirst ? "before" : "after"} status`, async () => {
+      const failures =
+        '## Recent Failures (last 6h) [auto-generated]\n- [aaaaaaaa] "old failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z\n';
+      const orders = "## Your Standing Orders\n- Already triaged.\n";
+      const status = `## Current System Status [auto-generated]\n${failures}`;
+      const { ctx } = fakeCtx({
+        configs: { TYPESAFE_API_KEY: "x" },
+        reportedFailures: ["aaaaaaaa-0000"],
+        prevStatus: ordersFirst ? orders + status : status + orders,
+        failed: [
+          {
+            id: "aaaaaaaa-0000",
+            agentId: "12345678-bbbb",
+            task: "old failure",
+            failureReason: "boom",
+            finishedAt: "2026-10-15T12:00:00Z",
+          },
+          {
+            id: "bbbbbbbb-0000",
+            agentId: "12345678-bbbb",
+            task: "new failure",
+            failureReason: "exit 1",
+            finishedAt: "2026-10-15T13:01:00.000Z",
+          },
+        ],
+        jev: jevSays(0.9),
+      });
+      const verdict = await run(ctx, { dryRun: true });
+      expect(verdict.state.new_failures_since_previous_heartbeat).toEqual([
+        "bbbbbbbb: new failure | exit 1",
+      ]);
+      expect(verdict.state.failures_last_6h_total).toBe(2);
+    });
+  }
+
+  test.each([
+    "## Recent Failures (last 6h) [auto-generated]\nNone.\n",
+    "",
+  ])("failures outside the previous Recent Failures section stay new (%s)", async (section) => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      prevStatus: `## Current System Status [auto-generated]\n${section}## Gate Findings [auto-generated]\n- [aaaaaaaa] "quoted failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z\n`,
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "quoted failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T13:01:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "aaaaaaaa: quoted failure | boom",
+    ]);
+  });
+
+  test.each([
+    "- Item 544: fix `## Recent Failures` parsing.\n",
+    "## Recent Failures\nSnapshot notes.\n",
+    '## Recent Failures (last 6h) [auto-generated]\n- [bbbbbbbb] "snapshot quote" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z\n',
+  ])("snapshot failure headings cannot hijack generated status (%s)", async (snapshot) => {
+    const { ctx, calls } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures: ["aaaaaaaa-0000"],
+      prevStatus: [
+        "## Your Standing Orders (snapshot from HEARTBEAT.md)",
+        snapshot,
+        "## Instructions",
+        "Review the generated status.",
+        "## Current System Status [auto-generated]",
+        "## Recent Failures (last 6h) [auto-generated]",
+        '- [aaaaaaaa] "old failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z',
+      ].join("\n"),
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "old failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00Z",
+        },
+        {
+          id: "bbbbbbbb-0000",
+          agentId: "12345678-bbbb",
+          task: "snapshot quote",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T13:01:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "bbbbbbbb: snapshot quote | boom",
+    ]);
+    expect(calls.previousReads).toBe(1);
+  });
+
+  test("an absent generated failures section cannot use a trailing snapshot heading", async () => {
+    const { ctx, calls } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      prevStatus: [
+        "## Current System Status [auto-generated]",
+        "## Task Overview [auto-generated]",
+        "- Failed (24h): 0",
+        "## Agent Status [auto-generated]",
+        "- Online: 6",
+        "## Your Standing Orders (snapshot from HEARTBEAT.md)",
+        "## Recent Failures (last 6h) [auto-generated]",
+        '- [aaaaaaaa] "snapshot quote" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z',
+      ].join("\n"),
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "snapshot quote",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T13:01:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "aaaaaaaa: snapshot quote | boom",
+    ]);
+    expect(calls.previousReads).toBe(1);
+  });
+
+  test("a failed-task title heading does not hide later failures", async () => {
+    const { ctx, calls } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures: ["aaaaaaaa-0000", "bbbbbbbb-0000"],
+      prevStatus: [
+        "## Current System Status [auto-generated]",
+        "## Recent Failures (last 6h) [auto-generated]",
+        '- [aaaaaaaa] "Fix the task\n## Requirements" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z',
+        '- [bbbbbbbb] "later failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z',
+        "## Gate Findings [auto-generated]",
+        '- [cccccccc] "outside failures" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00Z',
+      ].join("\n"),
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "Fix the task\n## Requirements",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00Z",
+        },
+        {
+          id: "bbbbbbbb-0000",
+          agentId: "12345678-bbbb",
+          task: "later failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00Z",
+        },
+        {
+          id: "cccccccc-0000",
+          agentId: "12345678-bbbb",
+          task: "outside failures",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T13:01:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    const verdict = await run(ctx, { dryRun: true });
+    expect(verdict.state.new_failures_since_previous_heartbeat).toEqual([
+      "cccccccc: outside failures | boom",
+    ]);
+    expect(verdict.state.failures_last_6h_total).toBe(3);
+    expect(calls.previousReads).toBe(1);
+  });
+
+  test("code-fenced snapshot system and agent markers cannot hide previous failures", async () => {
+    const { ctx, calls } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures: ["aaaaaaaa-0000"],
+      prevStatus: [
+        "## Your Standing Orders (snapshot from HEARTBEAT.md)",
+        "```md",
+        "## Current System Status [auto-generated]",
+        "## Agent Status [auto-generated]",
+        "```",
+        "## Current System Status [auto-generated]",
+        "## Recent Failures (last 6h) [auto-generated]",
+        '- [aaaaaaaa] "old failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00.000Z',
+        "## Agent Status [auto-generated]",
+      ].join("\n"),
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "old failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toBe(
+      "none",
+    );
+    expect(calls.previousReads).toBe(1);
+  });
+
+  test("a generated Requirements heading in a failed title cannot hide later failures", async () => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures: ["aaaaaaaa-0000", "bbbbbbbb-0000"],
+      prevStatus: [
+        "## Current System Status [auto-generated]",
+        "## Recent Failures (last 6h) [auto-generated]",
+        '- [aaaaaaaa] "Fix\n## Requirements [auto-generated]\nbody" — agent: 12345678, reason: boom, at: 2026-10-15T12:00:00.000Z',
+        '- [bbbbbbbb] "later failure" — agent: 12345678, reason: boom, at: 2026-10-15T12:01:00.000Z',
+        "## Agent Status [auto-generated]",
+      ].join("\n"),
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "Fix\n## Requirements [auto-generated]\nbody",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00.000Z",
+        },
+        {
+          id: "bbbbbbbb-0000",
+          agentId: "12345678-bbbb",
+          task: "later failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:01:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toBe(
+      "none",
+    );
+  });
+
+  test("a failure finished after previous creation stays new even if its ID is quoted", async () => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      prevStatus:
+        '## Current System Status [auto-generated]\n## Recent Failures (last 6h) [auto-generated]\n- [aaaaaaaa] "new failure" — agent: 12345678, reason: boom, at: 2026-10-15T13:00:00.001Z',
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "new failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T13:00:00.001Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "aaaaaaaa: new failure | boom",
+    ]);
+  });
+
+  test.each([
+    { reportedFailures: ["aaaaaaaa-0000"] },
+    { reportedFailures: '["aaaaaaaa-0000"]' },
+  ])("a failure unseen during gathering stays new before checklist creation (%j)", async ({
+    reportedFailures,
+  }) => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures,
+      prevCreatedAt: "2026-10-15T13:00:00.000Z",
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "reported",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00.000Z",
+        },
+        {
+          id: "bbbbbbbb-0000",
+          agentId: "12345678-bbbb",
+          task: "unseen",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:59:59.999Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "bbbbbbbb: unseen | boom",
+    ]);
+  });
+
+  test.each(
+    [undefined, "not JSON", {}, [42]].map((reportedFailures) => ({ reportedFailures })),
+  )("missing or invalid receipts treat every current failure as new (%j)", async ({
+    reportedFailures,
+  }) => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      reportedFailures,
+      prevStatus: '## Recent Failures (last 6h) [auto-generated]\n- [aaaaaaaa] "quoted"',
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "still new",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "aaaaaaaa: still new | boom",
+    ]);
+  });
+
+  test("without a previous checklist all current failures are new", async () => {
+    const { ctx } = fakeCtx({
+      configs: { TYPESAFE_API_KEY: "x" },
+      prevCreatedAt: null,
+      failed: [
+        {
+          id: "aaaaaaaa-0000",
+          agentId: "12345678-bbbb",
+          task: "first failure",
+          failureReason: "boom",
+          finishedAt: "2026-10-15T12:00:00.000Z",
+        },
+      ],
+      jev: jevSays(0.9),
+    });
+    expect((await run(ctx, { dryRun: true })).state.new_failures_since_previous_heartbeat).toEqual([
+      "aaaaaaaa: first failure | boom",
+    ]);
+  });
+
   test("threshold and time zone come from swarm config", async () => {
     const { ctx } = fakeCtx({
       configs: {