@desplega.ai/agent-swarm 1.156.0 → 1.158.0

package/src/tests/db-client-busy-retry.test.ts

@@ -202,6 +202,102 @@ describe("db-client SQLITE_BUSY retry", () => {
     expect(Date.now() - started).toBeLessThan(500);
   });
 
+  describe("under the production 5000ms ambient busy_timeout", () => {
+    /** Largest gap between 5ms ticks while `work` runs: the longest the loop was frozen. */
+    async function maxLoopFreezeMs(work: () => Promise<unknown>): Promise<number> {
+      let last = performance.now();
+      let maxGap = 0;
+      const ticker = setInterval(() => {
+        const now = performance.now();
+        maxGap = Math.max(maxGap, now - last);
+        last = now;
+      }, 5);
+      try {
+        await work();
+        // One more tick so a freeze that ended on the last attempt is seen.
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      } finally {
+        clearInterval(ticker);
+      }
+      return maxGap;
+    }
+
+    beforeEach(() => {
+      main.exec("PRAGMA busy_timeout = 5000");
+    });
+
+    test("a contended write still succeeds via the async retry", async () => {
+      const released = holdWriteLock(300);
+      const freezeMs = await maxLoopFreezeMs(() =>
+        client.run("INSERT INTO items (name) VALUES (?)", ["contended"]),
+      );
+      await released;
+      const landed = await client.get<{ name: string }>(
+        "SELECT name FROM items WHERE name = 'contended'",
+      );
+      expect(landed?.name).toBe("contended");
+      // Every attempt spins at most attemptSpinMs (25ms) or finalAttemptSpinMs;
+      // the release happened during an async backoff sleep.
+      expect(freezeMs).toBeLessThan(1_000);
+    });
+
+    test("the final statement attempt spins finalAttemptSpinMs, not the ambient timeout", async () => {
+      const tight = createBunSqliteClient(() => main, {
+        maxWaitMs: 60,
+        backoffMs: [20, 20],
+        attemptSpinMs: 25,
+        finalAttemptSpinMs: 50,
+      });
+      // The holder releases on a timer, which cannot fire while the final
+      // attempt blocks the loop: pre-fix this froze for the full 5000ms.
+      const released = holdWriteLock(3_000);
+      let caught: unknown;
+      const startedAt = performance.now();
+      const freezeMs = await maxLoopFreezeMs(async () => {
+        try {
+          await tight.run("INSERT INTO items (name) VALUES (?)", ["never"]);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      const wallMs = performance.now() - startedAt;
+      await released;
+      expect((caught as { code?: string }).code).toBe("SQLITE_BUSY");
+      expect(wallMs).toBeLessThan(2_000);
+      expect(freezeMs).toBeLessThan(1_000);
+      const row = main.query<{ timeout: number }, []>("PRAGMA busy_timeout").get();
+      expect(row?.timeout).toBe(5000);
+    });
+
+    test("the final BEGIN IMMEDIATE attempt spins finalAttemptSpinMs, not the ambient timeout", async () => {
+      const tight = createBunSqliteClient(() => main, {
+        maxWaitMs: 60,
+        backoffMs: [20, 20],
+        attemptSpinMs: 25,
+        finalAttemptSpinMs: 50,
+      });
+      const released = holdWriteLock(3_000);
+      let caught: unknown;
+      const startedAt = performance.now();
+      const freezeMs = await maxLoopFreezeMs(async () => {
+        try {
+          await tight.transaction(async (tx) => {
+            await tx.run("INSERT INTO items (name) VALUES (?)", ["never-tx"]);
+          });
+        } catch (err) {
+          caught = err;
+        }
+      });
+      const wallMs = performance.now() - startedAt;
+      await released;
+      expect((caught as { code?: string }).code).toBe("SQLITE_BUSY");
+      expect(wallMs).toBeLessThan(2_000);
+      expect(freezeMs).toBeLessThan(1_000);
+      const row = main.query<{ timeout: number }, []>("PRAGMA busy_timeout").get();
+      expect(row?.timeout).toBe(5000);
+    });
+  });
+
   test("reads proceed under an external write lock without needing the retry path", async () => {
     await client.run("INSERT INTO items (name) VALUES (?)", ["pre-existing"]);
     const released = holdWriteLock(150);

package/src/tests/db-client.test.ts

@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -427,3 +427,62 @@ describe("db-client transactions on a shared WAL file (second connection)", () =
     expect(row?.n).toBe(11);
   });
 });
+
+describe("db-client slow statement warning", () => {
+  // A recursive CTE is pure CPU inside one driver call, so it blocks the
+  // event loop the same way a slow production query does.
+  const SLOW_SQL = `/* ${"padding ".repeat(40)} */ WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM c WHERE x < ?) SELECT count(*) AS n FROM c WHERE ? IS NOT NULL`;
+  const SLOW_ROWS = 3_000_000;
+  const PARAM_SECRET = "param-value-that-must-not-be-logged";
+
+  const slowWarnings = (spy: ReturnType<typeof spyOn>): string[] =>
+    spy.mock.calls
+      .map((args) => String(args[0]))
+      .filter((line) => line.includes("[db-client] slow sync statement"));
+
+  test("logs a statement that blocked the loop past 100ms, with truncated SQL and no params", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const startedAt = performance.now();
+      const row = await client.get<{ n: number }>(SLOW_SQL, [SLOW_ROWS, PARAM_SECRET]);
+      const elapsedMs = performance.now() - startedAt;
+      expect(row?.n).toBe(SLOW_ROWS);
+      // Guard the premise: on a machine fast enough to finish under the
+      // threshold, the warning is correctly absent and this test says so.
+      expect(elapsedMs).toBeGreaterThan(100);
+      const lines = slowWarnings(warn);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toMatch(/blocked the event loop for \d+ms: \/\* padding/);
+      expect(lines[0]).not.toContain(PARAM_SECRET);
+      expect(lines[0]).not.toContain("WITH RECURSIVE");
+      expect(lines[0]?.endsWith("…")).toBe(true);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("logs a slow statement run inside a transaction", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await client.transaction(async (tx) => {
+        await tx.get(SLOW_SQL, [SLOW_ROWS, PARAM_SECRET]);
+      });
+      const lines = slowWarnings(warn);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).not.toContain(PARAM_SECRET);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("does not log fast statements", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await client.run("INSERT INTO items (name) VALUES (?)", ["fast"]);
+      await client.query("SELECT name FROM items");
+      expect(slowWarnings(warn)).toHaveLength(0);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});

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

@@ -41,6 +41,7 @@ const baseFacade = `type:AgentMailInboxMapping
 type:ApiKeyStatus
 type:AppVersion
 type:ApprovalRequest
+type:ApprovalRequestSummary
 type:AssetSummaryFilters
 type:AttributionByPersonRow
 type:AvailableKeyIndicesResult
@@ -64,6 +65,7 @@ type:InboxSummary
 type:InsertPricingRowInput
 type:InsertTaskAttachmentInput
 type:KeyCostSummary
+type:KvJsonFieldEquals
 type:McpServerFilters
 type:McpServerInsert
 type:MentionPreview
@@ -113,6 +115,7 @@ value:autoEncryptLegacyPlaintextSecrets
 value:backfillSupersedeTaskResumeTaskId
 value:bindSlackMessageTimestamp
 value:buildRoutingAffinityFromAgent
+value:cancelApprovalRequestById
 value:cancelPendingApprovalRequestsForRun
 value:cancelPendingSteeringForTask
 value:cancelTask
@@ -223,6 +226,7 @@ value:getActiveSessions
 value:getActiveTaskCount
 value:getAgentById
 value:getAgentCurrentTask
+value:getAgentDailyTaskCounts
 value:getAgentHarnessProviders
 value:getAgentMailInboxMapping
 value:getAgentMailInboxMappingsByAgent
@@ -265,6 +269,7 @@ value:getContextSnapshotsByTaskId
 value:getContextSummaryByTaskId
 value:getContextVersion
 value:getContextVersionHistory
+value:getCurrentStepForNode
 value:getDailySpendForAgent
 value:getDailySpendForUser
 value:getDailySpendGlobal
@@ -370,6 +375,7 @@ value:getSlackTasksMissingTree
 value:getSlackTreeMessage
 value:getSlackTreeMessageByThread
 value:getSlackTreeMessages
+value:getStaleApprovalRequests
 value:getStalePinnedResumes
 value:getStaleUnassignedAffinityTasks
 value:getStalledInProgressTasks
@@ -380,6 +386,7 @@ value:getStepCountForNode
 value:getStuckApprovalRuns
 value:getStuckWaitRuns
 value:getStuckWorkflowRuns
+value:getSupersededTasksWithoutResume
 value:getSwarmConfigById
 value:getSwarmConfigLookupById
 value:getSwarmConfigs
@@ -436,9 +443,11 @@ value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSettledSlackMessage
 value:isSqliteVecAvailable
+value:kvPrefixUpperBound
 value:listAgentsWithCredStatusByProvider
 value:listAllMetrics
 value:listAllPages
+value:listApprovalRequestSummaries
 value:listApprovalRequests
 value:listAssetSummaries
 value:listCancelledApprovalRequestsForRun
@@ -595,6 +604,7 @@ value:getMostRecentTaskInThread
 value:getPendingSlackRelayTasks
 value:getRecentlyFinishedWorkerTasks
 value:getSlackTasksMissingTree
+value:getSupersededTasksWithoutResume
 value:getTaskById
 value:getTaskStats
 value:getTasksByAgentId

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

@@ -42,6 +42,7 @@ const baseFacade = `type:AgentMailInboxMapping
 type:ApiKeyStatus
 type:AppVersion
 type:ApprovalRequest
+type:ApprovalRequestSummary
 type:AssetSummaryFilters
 type:AttributionByPersonRow
 type:AvailableKeyIndicesResult
@@ -65,6 +66,7 @@ type:InboxSummary
 type:InsertPricingRowInput
 type:InsertTaskAttachmentInput
 type:KeyCostSummary
+type:KvJsonFieldEquals
 type:McpServerFilters
 type:McpServerInsert
 type:MentionPreview
@@ -114,6 +116,7 @@ value:autoEncryptLegacyPlaintextSecrets
 value:backfillSupersedeTaskResumeTaskId
 value:bindSlackMessageTimestamp
 value:buildRoutingAffinityFromAgent
+value:cancelApprovalRequestById
 value:cancelPendingApprovalRequestsForRun
 value:cancelPendingSteeringForTask
 value:cancelTask
@@ -224,6 +227,7 @@ value:getActiveSessions
 value:getActiveTaskCount
 value:getAgentById
 value:getAgentCurrentTask
+value:getAgentDailyTaskCounts
 value:getAgentHarnessProviders
 value:getAgentMailInboxMapping
 value:getAgentMailInboxMappingsByAgent
@@ -266,6 +270,7 @@ value:getContextSnapshotsByTaskId
 value:getContextSummaryByTaskId
 value:getContextVersion
 value:getContextVersionHistory
+value:getCurrentStepForNode
 value:getDailySpendForAgent
 value:getDailySpendForUser
 value:getDailySpendGlobal
@@ -371,6 +376,7 @@ value:getSlackTasksMissingTree
 value:getSlackTreeMessage
 value:getSlackTreeMessageByThread
 value:getSlackTreeMessages
+value:getStaleApprovalRequests
 value:getStalePinnedResumes
 value:getStaleUnassignedAffinityTasks
 value:getStalledInProgressTasks
@@ -381,6 +387,7 @@ value:getStepCountForNode
 value:getStuckApprovalRuns
 value:getStuckWaitRuns
 value:getStuckWorkflowRuns
+value:getSupersededTasksWithoutResume
 value:getSwarmConfigById
 value:getSwarmConfigLookupById
 value:getSwarmConfigs
@@ -437,9 +444,11 @@ value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSettledSlackMessage
 value:isSqliteVecAvailable
+value:kvPrefixUpperBound
 value:listAgentsWithCredStatusByProvider
 value:listAllMetrics
 value:listAllPages
+value:listApprovalRequestSummaries
 value:listApprovalRequests
 value:listAssetSummaries
 value:listCancelledApprovalRequestsForRun

package/src/tests/deferred-schedule-reaper.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Spent deferral timers are reaped once they age past the retention window,
+ * whether the ceiling fired them or a watched task's settlement woke the
+ * waiter early. The wake-up task keeps its `scheduleId` and stays readable.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createScheduledTask,
+  createTaskExtended,
+  getDbClient,
+  getScheduledTaskById,
+  getTaskById,
+  initDb,
+  startTask,
+  updateScheduledTask,
+} from "../be/db";
+import {
+  reapSpentDeferredSchedules,
+  reconcileDeferredTaskWaits,
+  SPENT_DEFERRED_SCHEDULE_RETENTION_MS,
+} from "../scheduler/deferred-task-waits";
+import { executeSchedule } from "../scheduler/scheduler";
+import { registerDeferTaskTool } from "../tools/defer-task";
+
+const TEST_DB_PATH = "./test-deferred-schedule-reaper.sqlite";
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+type Result = { structuredContent: { success: boolean; message: string; scheduleId?: string } };
+type Tool = { handler: (args: unknown, extra: unknown) => Promise<Result> };
+
+let agentId: string;
+let tool: Tool;
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  agentId = (
+    await createAgent({
+      name: "Reap worker",
+      isLead: false,
+      status: "busy",
+      capabilities: [],
+      maxTasks: 10,
+    })
+  ).id;
+  const server = new McpServer({ name: "reap-test", version: "1.0.0" });
+  registerDeferTaskTool(server);
+  tool = (server as unknown as { _registeredTools: Record<string, Tool> })._registeredTools[
+    "defer-task"
+  ]!;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+async function activeTask() {
+  const task = await createTaskExtended("work in progress", { agentId });
+  await startTask(task.id);
+  return task;
+}
+
+async function defer(taskId: string, extra: Record<string, unknown> = {}) {
+  const result = await tool.handler(
+    { taskId, delayMs: 3600000, summary: "Submitted", note: "Check the result", ...extra },
+    { sessionId: crypto.randomUUID(), requestInfo: { headers: { "x-agent-id": agentId } } },
+  );
+  expect(result.structuredContent.success).toBe(true);
+  return (await getScheduledTaskById(result.structuredContent.scheduleId!))!;
+}
+
+async function wakeTask(scheduleId: string) {
+  const row = await getDbClient().get<{ id: string }>(
+    "SELECT id FROM agent_tasks WHERE scheduleId = ?",
+    [scheduleId],
+  );
+  return row ? getTaskById(row.id) : null;
+}
+
+async function waitRows(scheduleId: string) {
+  const row = await getDbClient().get<{ waits: number; members: number }>(
+    `SELECT (SELECT COUNT(*) FROM deferred_task_waits WHERE scheduleId = ?) AS waits,
+            (SELECT COUNT(*) FROM deferred_task_wait_members WHERE scheduleId = ?) AS members`,
+    [scheduleId, scheduleId],
+  );
+  return row!;
+}
+
+/** `now` just inside and just past the retention window, measured from lastRunAt. */
+async function horizons(scheduleId: string) {
+  const lastRunAt = (await getScheduledTaskById(scheduleId))!.lastRunAt!;
+  const firedAt = new Date(lastRunAt).getTime();
+  return {
+    inside: new Date(firedAt + SPENT_DEFERRED_SCHEDULE_RETENTION_MS - DAY_MS),
+    past: new Date(firedAt + SPENT_DEFERRED_SCHEDULE_RETENTION_MS + DAY_MS),
+  };
+}
+
+describe("reapSpentDeferredSchedules", () => {
+  test("timer fires: the spent row is kept inside the window and deleted past it", async () => {
+    const parent = await activeTask();
+    const schedule = await defer(parent.id);
+    await executeSchedule(schedule);
+
+    const fired = (await getScheduledTaskById(schedule.id))!;
+    expect(fired.enabled).toBe(false);
+    expect(fired.lastRunAt).toBeDefined();
+    const wake = await wakeTask(schedule.id);
+    expect(wake?.parentTaskId).toBe(parent.id);
+
+    const { inside, past } = await horizons(schedule.id);
+    await reapSpentDeferredSchedules(inside);
+    expect(await getScheduledTaskById(schedule.id)).not.toBeNull();
+
+    expect(await reapSpentDeferredSchedules(past)).toBeGreaterThanOrEqual(1);
+    expect(await getScheduledTaskById(schedule.id)).toBeNull();
+    // The wake-up task survives with its provenance id intact.
+    const after = await getTaskById(wake!.id);
+    expect(after?.scheduleId).toBe(schedule.id);
+    expect(after?.parentTaskId).toBe(parent.id);
+  });
+
+  test("settlement wakes early: the disabled timer is reaped and its wait cascades", async () => {
+    const parent = await activeTask();
+    const producer = await activeTask();
+    const schedule = await defer(parent.id, {
+      wakeOn: { taskId: producer.id, event: "settled" },
+    });
+    expect(await waitRows(schedule.id)).toEqual({ waits: 1, members: 1 });
+
+    await completeTask(producer.id, "ready");
+    await reconcileDeferredTaskWaits(producer.id);
+    const woken = (await getScheduledTaskById(schedule.id))!;
+    // Woken before its ceiling: disabled with lastRunAt set, never left armed.
+    expect(woken.enabled).toBe(false);
+    expect(woken.nextRunAt).toBeUndefined();
+    expect(woken.lastRunAt).toBeDefined();
+    const wake = await wakeTask(schedule.id);
+    expect(wake?.task).toContain(`Wake-up cause: task.completed for task ${producer.id}`);
+
+    const { inside, past } = await horizons(schedule.id);
+    await reapSpentDeferredSchedules(inside);
+    expect(await getScheduledTaskById(schedule.id)).not.toBeNull();
+
+    await reapSpentDeferredSchedules(past);
+    expect(await getScheduledTaskById(schedule.id)).toBeNull();
+    expect(await waitRows(schedule.id)).toEqual({ waits: 0, members: 0 });
+    expect((await getTaskById(wake!.id))?.scheduleId).toBe(schedule.id);
+  });
+
+  test("armed, never-fired, and ordinary one-time schedules are never reaped", async () => {
+    const farFuture = new Date(Date.now() + 10 * 365 * DAY_MS);
+
+    const armed = await defer((await activeTask()).id);
+
+    // Auto-disabled after a dispatch failure: no lastRunAt, kept as evidence.
+    const neverFired = await defer((await activeTask()).id);
+    await updateScheduledTask(neverFired.id, { enabled: false, lastErrorMessage: "boom" });
+
+    const ordinary = await createScheduledTask({
+      name: `ordinary-one-time-${crypto.randomUUID()}`,
+      taskTemplate: "one-off",
+      targetType: "agent-task",
+      scheduleType: "one_time",
+      nextRunAt: new Date(Date.now() + DAY_MS).toISOString(),
+      targetAgentId: agentId,
+    });
+    await updateScheduledTask(ordinary.id, {
+      enabled: false,
+      nextRunAt: null,
+      lastRunAt: new Date().toISOString(),
+    });
+
+    await reapSpentDeferredSchedules(farFuture);
+    expect((await getScheduledTaskById(armed.id))?.enabled).toBe(true);
+    expect(await getScheduledTaskById(neverFired.id)).not.toBeNull();
+    expect(await getScheduledTaskById(ordinary.id)).not.toBeNull();
+  });
+});

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

@@ -78,7 +78,7 @@ describe("docs API index footprint", () => {
     expect(tasks).toContain('"path":"/api/task-templates","method":"get"');
   });
 
-  test("OpenAPI and generated pages keep all 381 operations", async () => {
+  test("OpenAPI and generated pages keep all 383 operations", async () => {
     const spec = await Bun.file(resolve(repoRoot, "openapi.json")).json();
     const operationKeys = [];
     const tags = new Set();
@@ -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(381);
-    expect(generatedKeys).toHaveLength(381);
+    expect(operationKeys).toHaveLength(383);
+    expect(generatedKeys).toHaveLength(383);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/events-http.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import type { Subprocess } from "bun";
+import { fetchProfileSyncRejectionBanner } from "../commands/profile-sync";
 import { getFreePort, SERVER_BOOT_HOOK_TIMEOUT_MS } from "./test-net";
 
 let TEST_PORT = 0;
@@ -270,6 +271,108 @@ describe("GET /api/events", () => {
   });
 });
 
+describe("GET /api/events — latestPerDataField", () => {
+  const AGENT = "profile-sync-latest-agent";
+  const ids: Record<string, string> = {};
+
+  beforeAll(async () => {
+    const seed: [string, string, string][] = [
+      ["tools-old", "system.profile_sync_rejected", "toolsMd"],
+      ["claude-rejected", "system.profile_sync_rejected", "claudeMd"],
+      ["soul-reconciled", "system.profile_sync_reconciled", "soulMd"],
+      ["tools-new", "system.profile_sync_rejected", "toolsMd"],
+      ["claude-reconciled", "system.profile_sync_reconciled", "claudeMd"],
+      ["soul-rejected", "system.profile_sync_rejected", "soulMd"],
+    ];
+    for (const [key, event, field] of seed) {
+      const { body } = await post("/api/events", {
+        category: "system",
+        event,
+        status: event.endsWith("rejected") ? "error" : "ok",
+        source: "api",
+        agentId: AGENT,
+        data: { field, diskSize: 30_000, dbSize: 19_000, budget: 20_000, delta: 11_000 },
+      });
+      ids[key] = (body.event as { id: string }).id;
+      // createdAt has millisecond precision: keep the seed strictly ordered.
+      await Bun.sleep(5);
+    }
+    await post("/api/events", {
+      category: "system",
+      event: "system.profile_sync_conflict",
+      source: "api",
+      agentId: AGENT,
+      data: { field: "toolsMd" },
+    });
+  });
+
+  test("returns the newest event per (event, data.field) and confirms the mode", async () => {
+    const { status, body } = await get(
+      `/api/events?events=system.profile_sync_rejected,system.profile_sync_reconciled&dataFields=soulMd,claudeMd,toolsMd,identityMd&agentId=${AGENT}&latestPerDataField=true`,
+    );
+    expect(status).toBe(200);
+    expect(body.latestPerDataField).toBe(true);
+    const returned = (body.events as { id: string }[]).map((event) => event.id);
+    expect(returned).toEqual([
+      ids["soul-rejected"],
+      ids["claude-reconciled"],
+      ids["tools-new"],
+      ids["soul-reconciled"],
+      ids["claude-rejected"],
+    ]);
+  });
+
+  test("a single-event request keeps today's response shape", async () => {
+    const { status, body } = await get(
+      `/api/events?event=system.profile_sync_rejected&agentId=${AGENT}&dataField=toolsMd&limit=1`,
+    );
+    expect(status).toBe(200);
+    expect(Object.keys(body)).toEqual(["events"]);
+    expect((body.events as { id: string }[]).map((event) => event.id)).toEqual([ids["tools-new"]]);
+  });
+
+  test("rejects an unknown name in events", async () => {
+    const { status } = await get("/api/events?events=system.profile_sync_rejected,not.an.event");
+    expect(status).toBe(400);
+  });
+
+  test("rejects latestPerDataField without dataFields", async () => {
+    const { status } = await get(
+      "/api/events?events=system.profile_sync_rejected&latestPerDataField=true",
+    );
+    expect(status).toBe(400);
+  });
+
+  test("the profile-sync banner is identical through one batched call and 8 lookups", async () => {
+    const config = { apiUrl: BASE, apiKey: TEST_API_KEY, agentId: AGENT };
+    const eventRequests: string[] = [];
+    const recording = (async (input: string | URL | Request, init?: RequestInit) => {
+      const url = new URL(String(input));
+      if (url.pathname === "/api/events") eventRequests.push(url.search);
+      return fetch(input, init);
+    }) as typeof fetch;
+    // Simulates an API that predates latestPerDataField: drop the confirmation.
+    const legacy = (async (input: string | URL | Request, init?: RequestInit) => {
+      const response = await recording(input, init);
+      if (!new URL(String(input)).searchParams.has("latestPerDataField")) return response;
+      const { latestPerDataField: _dropped, ...rest } = await response.json();
+      return new Response(JSON.stringify(rest), { status: response.status });
+    }) as typeof fetch;
+
+    const batched = await fetchProfileSyncRejectionBanner(config, recording);
+    const batchedCalls = eventRequests.length;
+    eventRequests.length = 0;
+    const perField = await fetchProfileSyncRejectionBanner(config, legacy);
+
+    expect(batchedCalls).toBe(1);
+    expect(eventRequests).toHaveLength(9);
+    expect(batched).toContain(ids["tools-new"] ?? "missing");
+    expect(batched).toContain(ids["soul-rejected"] ?? "missing");
+    expect(batched).not.toContain(ids["claude-rejected"] ?? "missing");
+    expect(batched).toBe(perField);
+  });
+});
+
 describe("GET /api/events/counts", () => {
   test("returns counts grouped by event name", async () => {
     const { status, body } = await get("/api/events/counts");

package/src/tests/extensions-catalog.test.ts

@@ -32,23 +32,28 @@ afterEach(async () => {
 });
 
 describe("predefined extension catalog", () => {
-  test("every bundled entry passes the manifest schema and bundle validation", async () => {
-    const catalog = getExtensionCatalog();
-    expect(Object.keys(catalog).sort()).toEqual([
-      "notify-on-complete",
-      "require-ticket-ref",
-      "require-verification-note",
-      "task-digest",
-    ]);
-    for (const [name, entry] of Object.entries(catalog)) {
-      expect(entry.manifest.name).toBe(name);
-      expect(ExtensionManifestSchema.safeParse(entry.manifest).success).toBe(true);
-      const result = await validateBundle({ manifest: entry.manifest, files: entry.files });
-      expect(result).toMatchObject({ ok: true });
-    }
-    expect(getCatalogEntry("task-digest")?.manifestFile).toBe("manifest.yaml");
-    expect(getCatalogEntry("toString")).toBeNull();
-  });
+  test(
+    "every bundled entry passes the manifest schema and bundle validation",
+    async () => {
+      const catalog = getExtensionCatalog();
+      expect(Object.keys(catalog).sort()).toEqual([
+        "github-sender-allowlist",
+        "notify-on-complete",
+        "require-ticket-ref",
+        "require-verification-note",
+        "task-digest",
+      ]);
+      for (const [name, entry] of Object.entries(catalog)) {
+        expect(entry.manifest.name).toBe(name);
+        expect(ExtensionManifestSchema.safeParse(entry.manifest).success).toBe(true);
+        const result = await validateBundle({ manifest: entry.manifest, files: entry.files });
+        expect(result).toMatchObject({ ok: true });
+      }
+      expect(getCatalogEntry("task-digest")?.manifestFile).toBe("manifest.yaml");
+      expect(getCatalogEntry("toString")).toBeNull();
+    },
+    { timeout: 15_000 },
+  );
 
   test("the generator reads YAML and JSON templates and their referenced files", async () => {
     const dir = await templatesDir({