@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/src/tests/db-tasks-read.test.ts

@@ -0,0 +1,183 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import * as db from "../be/db";
+
+beforeEach(async () => {
+  db.initDb(":memory:");
+  await db
+    .getDbClient()
+    .run(
+      "INSERT INTO users (id, name, createdAt, lastUpdatedAt) VALUES ('requester', 'Requester', '2026-01-01', '2026-01-01')",
+    );
+  for (const [id, status, taskType, tags, requester, updated, priority] of [
+    ["a", "pending", null, "[]", null, "03", 10],
+    ["b", "completed", "feature", '["blue"]', "requester", "02", 50],
+    ["c", "pending", "feature", '["blue"]', "requester", "03", 90],
+    ["h", "pending", "heartbeat", "[]", null, "04", 50],
+    ["t", "pending", null, '["heartbeat"]', null, "05", 50],
+    ["k", "pending", "heartbeat-checklist", "[]", null, "06", 50],
+    ["z", "pending", "boot-triage", "[]", null, "07", 50],
+  ] as const) {
+    await db.getDbClient().run(
+      `INSERT INTO agent_tasks (id, task, status, source, taskType, tags, requestedByUserId,
+       createdAt, lastUpdatedAt, priority, "key") VALUES (?, ?, ?, 'api', ?, ?, ?, ?, ?, ?, 'shared/demo/')`,
+      [
+        id,
+        `needle ${id}`,
+        status,
+        taskType,
+        tags,
+        requester,
+        "2026-01-01",
+        `2026-01-${updated}`,
+        priority,
+      ],
+    );
+  }
+});
+afterEach(() => db.closeDb());
+
+// Characterized against the pre-extraction facade at 8a8b7b53.
+const cases: {
+  name: string;
+  filters: db.TaskFilters;
+  params: string[];
+  ids: string[];
+  total?: number;
+}[] = [
+  { name: "defaults and priority tie", filters: {}, params: [], ids: ["c", "a", "b"] },
+  { name: "single status", filters: { status: "completed" }, params: ["completed"], ids: ["b"] },
+  { name: "empty statuses", filters: { status: [] }, params: [], ids: ["c", "a", "b"] },
+  {
+    name: "singleton statuses",
+    filters: { status: ["pending"] },
+    params: ["pending"],
+    ids: ["c", "a"],
+  },
+  {
+    name: "status array ordering",
+    filters: { status: ["completed", "pending"] },
+    params: ["completed", "pending"],
+    ids: ["c", "a", "b"],
+  },
+  {
+    name: "requester",
+    filters: { requestedByUserId: "requester" },
+    params: ["requester"],
+    ids: ["c", "b"],
+  },
+  {
+    name: "null wins",
+    filters: { requestedByUserId: "requester", requestedByUserIdIsNull: true },
+    params: [],
+    ids: ["a"],
+  },
+  { name: "search", filters: { search: "b" }, params: ["%b%", "%b%"], ids: ["b"] },
+  {
+    name: "combined ordering",
+    filters: {
+      status: ["pending", "completed"],
+      search: "needle",
+      taskType: "feature",
+      tags: ["blue"],
+      source: ["api"],
+      requestedByUserId: "requester",
+    },
+    params: [
+      "pending",
+      "completed",
+      "%needle%",
+      "%needle%",
+      "feature",
+      '%"blue"%',
+      "api",
+      "requester",
+    ],
+    ids: ["c", "b"],
+  },
+  {
+    name: "include heartbeat",
+    filters: { includeHeartbeat: true },
+    params: [],
+    ids: ["z", "k", "t", "h", "c", "a", "b"],
+  },
+  {
+    name: "created rowid tie",
+    filters: { orderBy: "createdAt" },
+    params: [],
+    ids: ["c", "b", "a"],
+  },
+  { name: "pagination", filters: { limit: 1, offset: 1 }, params: [], ids: ["a"], total: 3 },
+  { name: "zero limit", filters: { limit: 0 }, params: [], ids: [], total: 3 },
+  {
+    name: "namespace prefix",
+    filters: { keyPrefix: "shared/demo/" },
+    params: ["shared/demo/%"],
+    ids: ["c", "a", "b"],
+  },
+];
+
+for (const { name, filters, params, ids, total } of cases) {
+  test(name, async () => {
+    const client = db.getDbClient();
+    const listSpy = spyOn(client, "query");
+    const countSpy = spyOn(client, "get");
+    try {
+      expect((await db.getAllTasks(filters)).map((task) => task.id)).toEqual(ids);
+      expect(listSpy.mock.calls[0]?.[1]).toEqual(params);
+      const sql = listSpy.mock.calls[0]?.[0] ?? "";
+      expect(sql).toContain(`LIMIT ${filters.limit ?? 25} OFFSET ${filters.offset ?? 0}`);
+      expect(sql).toContain(
+        filters.orderBy === "createdAt"
+          ? "ORDER BY createdAt DESC, rowid DESC"
+          : "ORDER BY lastUpdatedAt DESC, priority DESC",
+      );
+      expect(await db.getTasksCount(filters)).toBe(total ?? ids.length);
+      expect(countSpy.mock.calls[0]?.[1]).toEqual(params);
+      expect((await db.getAllTasks({ ...filters, limit: 100, offset: 0 })).length).toBe(
+        await db.getTasksCount(filters),
+      );
+      expect((await db.getAllTasks(filters, { slim: true })).map((task) => task.id)).toEqual(ids);
+    } finally {
+      listSpy.mockRestore();
+      countSpy.mockRestore();
+    }
+  });
+}
+
+test("facade dependency callback preserves post-pagination readiness and propagates errors", async () => {
+  await db.getDbClient().run("UPDATE agent_tasks SET dependsOn = '[\"a\"]' WHERE id = 'c'");
+  expect(await db.getAllTasks({ readyOnly: true, limit: 1 })).toEqual([]);
+  expect(await db.getAllTasks({ readyOnly: true, limit: 1 }, { slim: true })).toEqual([]);
+  await db.getDbClient().run("UPDATE agent_tasks SET status = 'completed' WHERE id = 'a'");
+  expect((await db.getAllTasks({ readyOnly: true, limit: 1 })).map((t) => t.id)).toEqual(["c"]);
+  await db.getDbClient().run("UPDATE agent_tasks SET tags = '{' WHERE id = 'a'");
+  await expect(db.getAllTasks({ readyOnly: true, limit: 1 })).rejects.toThrow();
+});
+
+test("row defaults, malformed guarded JSON and slim preview remain unchanged", async () => {
+  await db
+    .getDbClient()
+    .run(
+      "UPDATE agent_tasks SET task = ?, followUpConfig = '{', routingAffinity = '{' WHERE id = 'a'",
+      ["x".repeat(400)],
+    );
+  const warning = spyOn(console, "warn").mockImplementation(() => {});
+  try {
+    const task = await db.getTaskById("a");
+    expect(task).toMatchObject({
+      tags: [],
+      dependsOn: [],
+      slackReplySent: false,
+      wasPaused: false,
+      routingAffinityInvalid: true,
+    });
+    expect(task?.followUpConfig).toBeUndefined();
+    expect(task?.requestedByUserId).toBeUndefined();
+    const slim = (await db.getAllTasks({ search: "a" }, { slim: true }))[0];
+    expect(slim?.task.length).toBeLessThanOrEqual(301);
+    expect(slim).not.toHaveProperty("output");
+    expect(await db.getTaskById("missing")).toBeNull();
+  } finally {
+    warning.mockRestore();
+  }
+});

package/src/tests/db-tasks-write.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import * as db from "../be/db";
+import { telemetry } from "../telemetry";
+
+const agentId = "bbbb0000-0000-4000-8000-000000000003";
+const stamp = "2025-01-02T03:04:05.000Z";
+let events: string[];
+let taskEventSpy: ReturnType<typeof spyOn>;
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 5; i++) await Bun.sleep(0);
+}
+
+beforeEach(async () => {
+  db.closeDb();
+  db.initDb(":memory:");
+  await db.createAgent({ id: agentId, name: "Write fixtures", isLead: false, status: "idle" });
+  events = [];
+  taskEventSpy = spyOn(telemetry, "taskEvent").mockImplementation((event) => {
+    events.push(event);
+  });
+});
+afterEach(async () => {
+  await flush();
+  taskEventSpy.mockRestore();
+  db.closeDb();
+});
+
+async function fixture() {
+  const task = await db.createTask(agentId, "write fixture");
+  await db.updateTaskClaudeSessionId(
+    task.id,
+    "session-03",
+    "codex",
+    { fixture: true },
+    "fixture-model",
+    "codex",
+    { version: 3 },
+  );
+  await db
+    .getDbClient()
+    .run("UPDATE agent_tasks SET createdAt = ?, lastUpdatedAt = ? WHERE id = ?", [
+      stamp,
+      stamp,
+      task.id,
+    ]);
+  return (await db.getTaskById(task.id))!;
+}
+
+// These same fixtures also run against the merged base before extraction.
+describe("task write base behavior", () => {
+  test("create, start, pause and resume retain session identity and lifecycle timestamps", async () => {
+    const task = await fixture();
+    expect(task.status).toBe("pending");
+    expect(task.finishedAt).toBeUndefined();
+    expect(await db.getPendingTaskForAgent(agentId)).toEqual(task);
+    expect(await db.pauseTask(task.id)).toBeNull();
+    for (const [operation, status] of [
+      [db.startTask, "in_progress"],
+      [db.pauseTask, "paused"],
+      [db.resumeTask, "in_progress"],
+    ] as const) {
+      const result = (await operation(task.id))!;
+      expect(result.status).toBe(status);
+      expect(result.claudeSessionId).toBe("session-03");
+      expect(result.createdAt).toBe(stamp);
+      expect(result.lastUpdatedAt > stamp).toBe(true);
+      expect(result.finishedAt).toBeUndefined();
+      expect(result.provider).toBe("codex");
+      expect(result.harnessVariantMeta).toEqual({ version: 3 });
+    }
+    expect(await db.resumeTask(task.id)).toBeNull();
+    await flush();
+    expect(events).toEqual([]);
+    expect((await db.getLogsByTaskId(task.id)).map((log) => log.newValue).sort()).toEqual(
+      ["in_progress", "in_progress", "paused", "pending"].sort(),
+    );
+  });
+
+  for (const status of ["completed", "failed", "cancelled", "superseded"] as const) {
+    test(`${status} preserves timestamps and session, emits once and rejects repeated terminal transitions`, async () => {
+      const task = await fixture();
+      await db.startTask(task.id);
+      const terminalize =
+        status === "completed"
+          ? (id: string) => db.completeTask(id, "done")
+          : status === "failed"
+            ? (id: string) => db.failTask(id, "failed fixture")
+            : status === "cancelled"
+              ? (id: string) => db.cancelTask(id)
+              : (id: string) => db.supersedeTask(id, { reason: "restart", resumeTaskId: null });
+      const result = (await terminalize(task.id))!;
+      expect(result.status).toBe(status);
+      expect(result.createdAt).toBe(stamp);
+      expect(result.finishedAt! > stamp).toBe(true);
+      expect(result.lastUpdatedAt > stamp).toBe(true);
+      expect(result.claudeSessionId).toBe("session-03");
+      for (const operation of [
+        db.startTask,
+        db.pauseTask,
+        db.resumeTask,
+        db.completeTask,
+        (id: string) => db.failTask(id, "again"),
+        db.cancelTask,
+        (id: string) => db.supersedeTask(id, { reason: "again", resumeTaskId: null }),
+      ]) {
+        expect(await operation(task.id)).toBeNull();
+      }
+      expect(await db.getTaskById(task.id)).toEqual(result);
+      const updated = (await db.updateTaskProgress(task.id, "late progress"))!;
+      expect(updated.status).toBe(status);
+      expect(updated.finishedAt).toBe(result.finishedAt);
+      expect(updated.claudeSessionId).toBe("session-03");
+      await flush();
+      expect(events).toEqual([status]);
+    });
+  }
+
+  test("missing ids retain null, false and empty-list results", async () => {
+    for (const operation of [
+      db.startTask,
+      db.pauseTask,
+      db.resumeTask,
+      db.completeTask,
+      db.cancelTask,
+      (id: string) => db.failTask(id, "missing"),
+      (id: string) => db.supersedeTask(id, { reason: "missing", resumeTaskId: null }),
+      (id: string) => db.updateTaskClaudeSessionId(id, "missing"),
+      (id: string) => db.updateTaskTitle(id, "missing"),
+      (id: string) => db.updateTaskProgress(id, "missing"),
+      (id: string) => db.overwriteTerminalTaskResultText(id, { output: "missing" }),
+      (id: string) => db.assignUnassignedTaskPending(id, agentId),
+    ]) {
+      expect(await operation("missing")).toBeNull();
+    }
+    expect(await db.deleteTask("missing")).toBe(false);
+    expect(await db.backfillSupersedeTaskResumeTaskId("missing", "resume")).toBe(false);
+    expect(await db.getPendingTaskForAgent("missing")).toBeNull();
+    expect(await db.getPausedTasksForAgent("missing")).toEqual([]);
+    expect(await db.getOrphanedInProgressTasksForAgent("missing")).toEqual([]);
+    expect(await db.resetOrphanedInProgressTasksForAgent("missing")).toEqual([]);
+    expect(await db.getRecentlyCancelledTasksForAgent("missing")).toEqual([]);
+    await flush();
+    expect(events).toEqual([]);
+  });
+
+  test("rename and terminal text overwrite preserve activity timestamps", async () => {
+    const task = await fixture();
+    expect((await db.updateTaskTitle(task.id, "  title  "))?.title).toBe("title");
+    expect((await db.updateTaskTitle(task.id, "  "))?.title).toBeUndefined();
+    expect((await db.getTaskById(task.id))?.lastUpdatedAt).toBe(stamp);
+    expect(await db.overwriteTerminalTaskResultText(task.id, { output: "early" })).toBeNull();
+    const completed = (await db.completeTask(task.id, "original"))!;
+    const edited = (await db.overwriteTerminalTaskResultText(task.id, { output: "edited" }))!;
+    expect(edited.output).toBe("edited");
+    expect(edited.lastUpdatedAt).toBe(completed.lastUpdatedAt);
+    expect(edited.finishedAt).toBe(completed.finishedAt);
+    await flush();
+    expect(events).toEqual(["completed"]);
+  });
+
+  test("assignment, orphan recovery, paused and cancelled queries, supersede backfill and deletion", async () => {
+    const task = await fixture();
+    await db
+      .getDbClient()
+      .run(
+        "UPDATE agent_tasks SET agentId = NULL, status = 'unassigned', claudeSessionId = NULL WHERE id = ?",
+        [task.id],
+      );
+    expect((await db.assignUnassignedTaskPending(task.id, agentId))?.status).toBe("pending");
+    expect(await db.assignUnassignedTaskPending(task.id, agentId)).toBeNull();
+    await db.startTask(task.id);
+    await db
+      .getDbClient()
+      .run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [stamp, task.id]);
+    expect((await db.getOrphanedInProgressTasksForAgent(agentId)).map((t) => t.id)).toEqual([
+      task.id,
+    ]);
+    expect((await db.resetOrphanedInProgressTasksForAgent(agentId)).map((t) => t.status)).toEqual([
+      "pending",
+    ]);
+    await db.startTask(task.id);
+    await db.pauseTask(task.id);
+    expect((await db.getPausedTasksForAgent(agentId)).map((t) => t.id)).toEqual([task.id]);
+    await db.resumeTask(task.id);
+    await db.cancelTask(task.id);
+    expect((await db.getRecentlyCancelledTasksForAgent(agentId)).map((t) => t.id)).toEqual([
+      task.id,
+    ]);
+    const superseded = await fixture();
+    await db.supersedeTask(superseded.id, { reason: "restart", resumeTaskId: null });
+    expect(await db.backfillSupersedeTaskResumeTaskId(superseded.id, "resume-id")).toBe(true);
+    const log = (await db.getLogsByTaskId(superseded.id)).find(
+      (l) => l.eventType === "task_superseded",
+    )!;
+    expect(JSON.parse(log.metadata!).resumeTaskId).toBe("resume-id");
+    await flush();
+    expect(await db.deleteTask(task.id)).toBe(true);
+    expect(await db.getTaskById(task.id)).toBeNull();
+  });
+});
+
+test("racing terminal transitions emit only for the winning write", async () => {
+  const task = await fixture();
+  const results = await Promise.all([
+    db.completeTask(task.id, "winner"),
+    db.failTask(task.id, "failure"),
+    db.cancelTask(task.id),
+    db.supersedeTask(task.id, { reason: "restart", resumeTaskId: null }),
+  ]);
+  const winners = results.filter((result) => result !== null);
+  expect(winners).toHaveLength(1);
+  expect((await db.getTaskById(task.id))?.status).toBe(winners[0]!.status);
+  await flush();
+  expect(events).toEqual([winners[0]!.status]);
+});
+
+test("outer rollback restores the task and discards terminal telemetry and logs", async () => {
+  const task = await fixture();
+  await expect(
+    db.getDbClient().transaction(async () => {
+      await db.completeTask(task.id, "rolled back");
+      throw new Error("rollback fixture");
+    }),
+  ).rejects.toThrow("rollback fixture");
+  await flush();
+  expect(await db.getTaskById(task.id)).toEqual(task);
+  expect(events).toEqual([]);
+  expect((await db.getLogsByTaskId(task.id)).map((log) => log.newValue)).toEqual(["pending"]);
+});