@desplega.ai/agent-swarm 2.2.0 → 2.4.0

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

@@ -9,6 +9,8 @@ import {
   createTaskExtended,
   createUser,
   createWorkflow,
+  deleteTask,
+  deleteTaskAttachment,
   getAssetKeyMappingByProvider,
   getDb,
   getDbClient,
@@ -166,6 +168,11 @@ describe("cross-entity asset namespace invariants", () => {
       ).sourceEntityType,
     ).toBe("task-attachment");
 
+    const lastUpdatedAt = "2026-01-01T00:00:00.000Z";
+    await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+      lastUpdatedAt,
+      task.id,
+    ]);
     expect(
       await moveAssetKey({
         entityType: "task",
@@ -173,7 +180,8 @@ describe("cross-entity asset namespace invariants", () => {
         key: "shared/archive/",
         changedBy: userId,
       }),
-    ).toBe(true);
+    ).toEqual({ movedTaskIds: [task.id] });
+    expect((await getTaskById(task.id))?.lastUpdatedAt).toBe(lastUpdatedAt);
     expect((await getTaskById(task.id))?.key).toBe("shared/archive/");
     const after = await getAssetKeyMappingByProvider({
       providerId: "agent-fs",
@@ -251,7 +259,7 @@ describe("cross-entity asset namespace invariants", () => {
         key: "shared/products/",
         changedBy: userId,
       }),
-    ).toBe(true);
+    ).toEqual({});
     expect(
       await moveAssetKey({
         entityType: "script",
@@ -259,7 +267,7 @@ describe("cross-entity asset namespace invariants", () => {
         key: "shared/automation/",
         changedBy: userId,
       }),
-    ).toBe(true);
+    ).toEqual({});
 
     expect(
       await getDbClient().get<{ key: string }>('SELECT "key" AS key FROM apps WHERE id = ?', [
@@ -330,6 +338,174 @@ describe("cross-entity asset namespace invariants", () => {
     expect(auditAssetKeys(getDb()).warningCount).toBe(0);
   });
 
+  test("shared provider files allow moves and follow only their source task", async () => {
+    const first = await createTaskExtended("first attachment owner", {
+      agentId,
+      key: "shared/first/",
+    });
+    const source = await createTaskExtended("source attachment owner", {
+      agentId,
+      key: "shared/source/",
+    });
+    const provider = {
+      providerId: "agent-fs",
+      providerOrgId: "shared-org",
+      providerDriveId: "shared-drive",
+      providerKey: "shared-file.md",
+    };
+    for (const task of [first, source]) {
+      await insertTaskAttachment({
+        taskId: task.id,
+        name: "shared-file.md",
+        kind: "agent-fs",
+        providerId: provider.providerId,
+        providerKey: provider.providerKey,
+        orgId: provider.providerOrgId,
+        driveId: provider.providerDriveId,
+      });
+    }
+    const mapping = (await getAssetKeyMappingByProvider(provider))!;
+    expect(mapping.key).toBe(source.key);
+    const historyBefore = await getDbClient().query(
+      "SELECT id FROM asset_key_history WHERE entity_id = ? ORDER BY id",
+      [mapping.id],
+    );
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+
+    await moveAssetKey({ entityType: "task", id: first.id, key: "shared/first-moved/" });
+    expect(await getAssetKeyMappingByProvider(provider)).toEqual(mapping);
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+    expect(
+      await getDbClient().query(
+        "SELECT id FROM asset_key_history WHERE entity_id = ? ORDER BY id",
+        [mapping.id],
+      ),
+    ).toEqual(historyBefore);
+
+    await moveAssetKey({ entityType: "task", id: source.id, key: "shared/source-moved/" });
+    expect((await getAssetKeyMappingByProvider(provider))?.key).toBe("shared/source-moved/");
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+    expect(
+      await getDbClient().query("SELECT entity_type FROM asset_key_history WHERE entity_id = ?", [
+        mapping.id,
+      ]),
+    ).toHaveLength(historyBefore.length + 1);
+
+    await getDbClient().run(
+      `UPDATE asset_key_mappings SET "key" = 'shared/no-attaching-task/' WHERE id = ?`,
+      [mapping.id],
+    );
+    const drift = auditAssetKeys(getDb()).issues.filter(
+      (issue) => issue.code === "provider-mapping-drift",
+    );
+    expect(drift).toHaveLength(1);
+    expect(drift[0]?.entityId).toBe(mapping.id);
+    await expect(
+      moveAssetKey({ entityType: "task", id: first.id, key: "shared/blocked/" }),
+    ).rejects.toThrow("blocked until");
+    await getDbClient().run(
+      `UPDATE asset_key_mappings SET "key" = ?, source_entity_type = 'task-attachment', source_entity_id = ? WHERE id = ?`,
+      ["shared/source-moved/", mapping.sourceEntityId!, mapping.id],
+    );
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+  });
+
+  test("a task move takes only the descendants the caller passes", async () => {
+    const root = await createTaskExtended("partial root", { agentId, key: "shared/partial/" });
+    const checked = await createTaskExtended("checked child", { agentId, parentTaskId: root.id });
+    const unchecked = await createTaskExtended("unchecked child", {
+      agentId,
+      parentTaskId: root.id,
+    });
+
+    expect(
+      await moveAssetKey({
+        entityType: "task",
+        id: root.id,
+        key: "shared/partial-moved/",
+        descendantTaskIds: [checked.id],
+      }),
+    ).toEqual({ movedTaskIds: [root.id, checked.id] });
+    expect((await getTaskById(checked.id))?.key).toBe("shared/partial-moved/");
+    expect((await getTaskById(unchecked.id))?.key).toBe("shared/partial/");
+  });
+
+  test("deleting the source attachment of a shared file leaves moves open", async () => {
+    const [kept, deleted, removed] = await Promise.all(
+      ["shared/detach-a/", "shared/detach-b/", "shared/detach-c/"].map((key) =>
+        createTaskExtended(`detach ${key}`, { agentId, key }),
+      ),
+    );
+    const other = await createTaskExtended("unrelated move", { agentId, key: "shared/other/" });
+    const provider = {
+      providerId: "agent-fs",
+      providerOrgId: "shared-org",
+      providerDriveId: "shared-drive",
+      providerKey: "detach.md",
+    };
+    const attach = (taskId: string) =>
+      insertTaskAttachment({
+        taskId,
+        name: "detach.md",
+        kind: "agent-fs",
+        providerId: provider.providerId,
+        providerKey: provider.providerKey,
+        orgId: provider.providerOrgId,
+        driveId: provider.providerDriveId,
+      });
+    await attach(kept!.id);
+    const sourceAttachment = await attach(deleted!.id);
+    expect((await getAssetKeyMappingByProvider(provider))?.key).toBe("shared/detach-b/");
+
+    expect(await deleteTaskAttachment(sourceAttachment.id)).toBe(true);
+    expect(await getAssetKeyMappingByProvider(provider)).toMatchObject({
+      key: "shared/detach-b/",
+      sourceEntityType: "external",
+    });
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+    await moveAssetKey({ entityType: "task", id: other.id, key: "shared/other-moved/" });
+
+    await attach(removed!.id);
+    expect(await deleteTask(removed!.id)).toBe(true);
+    expect(await getAssetKeyMappingByProvider(provider)).toMatchObject({
+      key: "shared/detach-c/",
+      sourceEntityType: "external",
+    });
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+
+    await moveAssetKey({ entityType: "task", id: kept!.id, key: "shared/detach-moved/" });
+    expect((await getAssetKeyMappingByProvider(provider))?.key).toBe("shared/detach-moved/");
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+  });
+
+  test("an external mapping that a task still attaches follows that task's move", async () => {
+    const task = await createTaskExtended("external owner", { agentId, key: "shared/external/" });
+    const provider = {
+      providerId: "agent-fs",
+      providerOrgId: "shared-org",
+      providerDriveId: "shared-drive",
+      providerKey: "external.md",
+    };
+    await insertTaskAttachment({
+      taskId: task.id,
+      name: "external.md",
+      kind: "agent-fs",
+      providerId: provider.providerId,
+      providerKey: provider.providerKey,
+      orgId: provider.providerOrgId,
+      driveId: provider.providerDriveId,
+    });
+    const mapping = (await getAssetKeyMappingByProvider(provider))!;
+    await getDbClient().run(
+      "UPDATE asset_key_mappings SET source_entity_type = 'external', source_entity_id = NULL WHERE id = ?",
+      [mapping.id],
+    );
+
+    await moveAssetKey({ entityType: "task", id: task.id, key: "shared/external-moved/" });
+    expect((await getAssetKeyMappingByProvider(provider))?.key).toBe("shared/external-moved/");
+    expect(auditAssetKeys(getDb()).ok).toBe(true);
+  });
+
   test("personal namespace users are audited and missing users are repairable warnings", async () => {
     const task = await createTaskExtended("personal", {
       agentId,

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/check-pr-body.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import {
   checkPrBody,
   isFixTitle,
+  isRankingEntryPr,
   pickedChoices,
   prBodyWarnings,
   proseWordCount,
@@ -34,6 +35,28 @@ const TEMPLATE = `<!-- top comment -->
 
 const URGENT = "## Urgency\n- [ ] asap\n- [x] nice to have\n";
 
+describe("isRankingEntryPr", () => {
+  test("exempts only a one-file entry PR with the matching title", () => {
+    expect(
+      isRankingEntryPr("chore(ranking): add acme.dev", ["community/ranking/acme.dev.json"]),
+    ).toBe(true);
+    expect(
+      isRankingEntryPr("chore(ranking): remove acme.dev", ["community/ranking/acme.dev.json"]),
+    ).toBe(true);
+    expect(
+      isRankingEntryPr("chore(ranking): add acme.dev", ["community/ranking/acme.com.json"]),
+    ).toBe(false);
+    expect(
+      isRankingEntryPr("chore(ranking): add acme.dev", [
+        "community/ranking/acme.dev.json",
+        "src/server.ts",
+      ]),
+    ).toBe(false);
+    expect(isRankingEntryPr("feat: add acme.dev", ["community/ranking/acme.dev.json"])).toBe(false);
+    expect(isRankingEntryPr("chore(ranking): add acme.dev", undefined)).toBe(false);
+  });
+});
+
 describe("check-pr-body", () => {
   test("template markers set when a section is required", () => {
     expect(templateSections(TEMPLATE)).toEqual([

package/src/tests/check-ranking-entry.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, test } from "bun:test";
+import {
+  checkRankingEntries,
+  type Entry,
+  isEntryPath,
+  parseEntry,
+  type Verification,
+} from "../../scripts/check-ranking-entry";
+
+const CLAIM = "rk_3f9a1c0e7b2d4a6f8e1c3b5d7f9a2c4e";
+const OTHER_CLAIM = "rk_00000000000000000000000000000001";
+const file = (domain: string, claim = CLAIM) =>
+  JSON.stringify({ $schema: "./schema.json", domain, claim });
+
+const VERIFIED: Verification = {
+  verified: true,
+  reasons: [],
+  telemetryActive7d: true,
+  websiteMatchesDomain: true,
+  listing: {
+    name: "Acme",
+    domain: "acme.dev",
+    category: "engineering",
+    subcategory: "qa-testing",
+    description: "QA | release automation",
+    sourceCodeUrl: null,
+  },
+};
+
+describe("parseEntry", () => {
+  test("accepts the opt-in file", () => {
+    expect(parseEntry("acme.dev.json", file("acme.dev"))).toEqual({
+      domain: "acme.dev",
+      claim: CLAIM,
+    });
+  });
+
+  test.each([
+    ["acme.dev.json", "{", "valid JSON"],
+    ["acme.dev.json", "[]", "JSON object"],
+    [
+      "acme.dev.json",
+      JSON.stringify({ domain: "acme.dev", claim: CLAIM, name: "Acme" }),
+      "unknown keys",
+    ],
+    ["www.acme.dev.json", file("www.acme.dev"), "bare lowercase hostname"],
+    ["Acme.ba.json", file("Acme.ba"), "bare lowercase hostname"],
+    ["other.ba.json", file("acme.dev"), "must be named acme.dev.json"],
+    ["acme.dev.json", file("acme.dev", "rk_short"), "claim"],
+  ])("rejects %s %s", (name, text, message) => {
+    expect(() => parseEntry(name, text)).toThrow(message);
+  });
+
+  test("README and schema are not entries", () => {
+    expect(isEntryPath("community/ranking/acme.dev.json")).toBe(true);
+    expect(isEntryPath("community/ranking/schema.json")).toBe(false);
+    expect(isEntryPath("community/ranking/README.md")).toBe(false);
+    expect(isEntryPath("community/ranking/nested/acme.dev.json")).toBe(false);
+  });
+});
+
+describe("checkRankingEntries", () => {
+  const files: Record<string, string> = {
+    "community/ranking/acme.dev.json": file("acme.dev"),
+    "community/ranking/acme.com.json": file("acme.com", CLAIM),
+  };
+  const run = (
+    paths: string[],
+    verify: (entry: Entry) => Promise<Verification>,
+    all = ["acme.dev.json"],
+  ) =>
+    checkRankingEntries({
+      changes: paths.map((path) => ({ status: "A", path })),
+      readEntry: (path) => files[path] ?? "",
+      allEntries: all.map((name) => [name, files[`community/ranking/${name}`] ?? ""]),
+      verify,
+    });
+
+  test("a verified entry passes and the summary shows the listing", async () => {
+    const asked: Entry[] = [];
+    const result = await run(["community/ranking/acme.dev.json"], async (entry) => {
+      asked.push(entry);
+      return VERIFIED;
+    });
+    expect(result.problems).toEqual([]);
+    expect(asked).toEqual([{ domain: "acme.dev", claim: CLAIM }]);
+    const summary = result.summary.join("\n");
+    expect(summary).toContain("### acme.dev: verified");
+    expect(summary).toContain(
+      "| Acme | engineering | qa-testing | QA \\| release automation | — |",
+    );
+  });
+
+  test("an unverified entry fails with the proxy's reasons", async () => {
+    const result = await run(["community/ranking/acme.dev.json"], async () => ({
+      ...VERIFIED,
+      verified: false,
+      reasons: ["telemetry_inactive_7d"],
+    }));
+    expect(result.problems).toHaveLength(1);
+    expect(result.problems[0]).toContain("telemetry_inactive_7d");
+  });
+
+  test("a proxy error fails without throwing", async () => {
+    const result = await run(["community/ranking/acme.dev.json"], async () => {
+      throw new Error("the proxy answered 503");
+    });
+    expect(result.problems[0]).toContain("503");
+  });
+
+  test("a claim shared with another entry fails before verify", async () => {
+    let called = false;
+    const result = await run(["community/ranking/acme.com.json"], async () => {
+      called = true;
+      return VERIFIED;
+    }, ["acme.dev.json", "acme.com.json"]);
+    expect(called).toBe(false);
+    expect(result.problems[0]).toContain("acme.dev.json");
+  });
+
+  test("a removal needs no proof, and README edits are ignored", async () => {
+    const result = await checkRankingEntries({
+      changes: [
+        { status: "D", path: "community/ranking/acme.dev.json" },
+        { status: "M", path: "community/ranking/README.md" },
+      ],
+      readEntry: () => "",
+      allEntries: [],
+      verify: async () => {
+        throw new Error("must not be called");
+      },
+    });
+    expect(result.problems).toEqual([]);
+    expect(result.summary).toEqual(["- Removed `acme.dev.json`."]);
+  });
+
+  test("the claim differs per entry in a valid two-entry PR", async () => {
+    files["community/ranking/acme.com.json"] = file("acme.com", OTHER_CLAIM);
+    const result = await run(
+      ["community/ranking/acme.com.json", "community/ranking/acme.dev.json"],
+      async () => VERIFIED,
+      ["acme.dev.json", "acme.com.json"],
+    );
+    expect(result.problems).toEqual([]);
+  });
+});

package/src/tests/db-extraction-contract.test.ts

@@ -15,6 +15,7 @@ test("facade exposes repository bindings without internal exports", () => {
         "rowToAgentTaskSummary",
         "configureTaskReadDependencies",
         "NEVER_STARTED_TASK_STATUSES",
+        "readableSessionCondition",
       ].includes(name)
     ) {
       expect(name in db).toBe(false);

package/src/tests/db-task-read-contract.test.ts

@@ -660,6 +660,7 @@ const internal = [
   "type:AgentTaskRow",
   "value:configureTaskReadDependencies",
   "value:NEVER_STARTED_TASK_STATUSES",
+  "value:readableSessionCondition",
   "value:rowToAgentTask",
   "value:rowToAgentTaskSummary",
 ].sort();

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(436);
+    expect(generatedKeys).toHaveLength(436);
     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 () => {