@desplega.ai/agent-swarm 1.88.0 → 1.90.0

package/src/tests/github-handlers-cancel-config.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for the runtime-config flags that control whether GitHub unassign and
+ * review-request-removed events terminate the linked swarm task.
+ *
+ * Flags (scope "global"):
+ *   github.cancelOnUnassign              — PR unassigned + issue unassigned
+ *   github.cancelOnReviewRequestRemoved  — PR review_request_removed
+ *
+ * Absent / any value ≠ "false" → cancel (current behavior, default).
+ * Value "false" → leave task untouched, return { created: false }.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  deleteSwarmConfig,
+  getDb,
+  getSwarmConfigs,
+  getTaskById,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { handleIssue, handlePullRequest } from "../github/handlers";
+import { GITHUB_BOT_NAME } from "../github/mentions";
+import type { IssueEvent, PullRequestEvent } from "../github/types";
+
+const TEST_DB_PATH = "./test-github-handlers-cancel-config.sqlite";
+
+const BASE_REPO = { full_name: "test/repo", html_url: "https://github.com/test/repo" };
+const BASE_PR = {
+  number: 1,
+  title: "Test PR",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/pull/1",
+  user: { login: "sender" },
+  head: { ref: "feature", sha: "abc1234567890" },
+  base: { ref: "main" },
+  merged: false,
+  merged_by: undefined,
+};
+const BASE_ISSUE = {
+  number: 10,
+  title: "Test Issue",
+  body: null as string | null,
+  html_url: "https://github.com/test/repo/issues/10",
+  user: { login: "sender" },
+};
+
+// ── Setup ──
+
+beforeAll(async () => {
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  initDb(TEST_DB_PATH);
+  createAgent({
+    id: "lead-cancel-config-test",
+    name: "CancelConfigTestLead",
+    status: "idle",
+    isLead: true,
+  });
+});
+
+afterAll(async () => {
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+// Clear tasks and config rows between tests.
+beforeEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM agent_tasks").run();
+  // Remove both flag rows so each test starts from a clean slate.
+  for (const key of ["github.cancelOnUnassign", "github.cancelOnReviewRequestRemoved"]) {
+    const rows = getSwarmConfigs({ scope: "global", key });
+    for (const row of rows) deleteSwarmConfig(row.id);
+  }
+});
+
+// ── Helpers ──
+
+function seedTask(vcsNumber: number, kind: "pr" | "issue"): string {
+  const task = createTaskExtended("test task", {
+    agentId: "lead-cancel-config-test",
+    source: "github",
+    vcsProvider: "github",
+    vcsRepo: BASE_REPO.full_name,
+    vcsNumber,
+    vcsEventType: kind === "pr" ? "pull_request" : "issues",
+  });
+  return task.id;
+}
+
+function setConfigFlag(key: string, value: string) {
+  upsertSwarmConfig({ scope: "global", key, value });
+}
+
+function getTaskStatus(taskId: string): string | undefined {
+  return getTaskById(taskId)?.status;
+}
+
+// ── github.cancelOnUnassign — PR unassigned ──
+
+describe("PR unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    // Task must NOT have been failed — still pending.
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnUnassign — issue unassigned ──
+
+describe("issue unassigned — github.cancelOnUnassign", () => {
+  test("default (no config row): unassign cancels the task", async () => {
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': unassign leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_ISSUE.number, "issue");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: IssueEvent = {
+      action: "unassigned",
+      issue: { ...BASE_ISSUE },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handleIssue(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── github.cancelOnReviewRequestRemoved ──
+
+describe("PR review_request_removed — github.cancelOnReviewRequestRemoved", () => {
+  test("default (no config row): review removal cancels the task", async () => {
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("config = 'false': review removal leaves task untouched", async () => {
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+    expect(getTaskStatus(taskId)).toBe("pending");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    const result = await handlePullRequest(event);
+
+    expect(result.created).toBe(false);
+    expect(getTaskStatus(taskId)).toBe("pending");
+  });
+});
+
+// ── Independence: flags do not bleed into each other ──
+
+describe("flag independence", () => {
+  test("cancelOnUnassign=false does NOT affect review_request_removed (still cancels)", async () => {
+    // Only disable the unassign flag; leave review-request flag absent (default = cancel).
+    setConfigFlag("github.cancelOnUnassign", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "review_request_removed",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      requested_reviewer: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // review_request_removed STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+
+  test("cancelOnReviewRequestRemoved=false does NOT affect unassign (still cancels)", async () => {
+    // Only disable the review-request flag; leave unassign flag absent (default = cancel).
+    setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+    const taskId = seedTask(BASE_PR.number, "pr");
+
+    const event: PullRequestEvent = {
+      action: "unassigned",
+      pull_request: { ...BASE_PR },
+      repository: BASE_REPO,
+      sender: { login: "someone" },
+      assignee: { login: GITHUB_BOT_NAME, id: 1 },
+    };
+    await handlePullRequest(event);
+
+    // unassigned STILL cancels because its own flag is absent (default true).
+    expect(getTaskStatus(taskId)).toBe("failed");
+  });
+});

package/src/tests/heartbeat-supersede-resume.test.ts

@@ -10,16 +10,29 @@ import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:tes
 import { unlink } from "node:fs/promises";
 import {
   closeDb,
+  completeTask,
   createAgent,
   createTaskExtended,
   getChildTasks,
   getDb,
+  getLogsByTaskId,
   getTaskById,
   initDb,
   insertActiveSession,
   startTask,
 } from "../be/db";
-import { codeLevelTriage } from "../heartbeat/heartbeat";
+import {
+  createTrackerSync,
+  getTrackerSync,
+  getTrackerSyncByExternalId,
+} from "../be/db-queries/tracker";
+import {
+  codeLevelTriage,
+  MAX_RESUME_GENERATIONS,
+  RESUME_BUDGET_EXHAUSTED_REASON,
+  setBeforeHeartbeatSupersedeForTests,
+} from "../heartbeat/heartbeat";
+import { RESUME_GENERATION_TAG_PREFIX } from "../tasks/worker-follow-up";
 
 const TEST_DB_PATH = "./test-heartbeat-supersede-resume.sqlite";
 
@@ -46,6 +59,8 @@ describe("Heartbeat — supersede + resume (DES-523)", () => {
   });
 
   beforeEach(() => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    getDb().run("DELETE FROM tracker_sync");
     getDb().run("DELETE FROM agent_tasks");
     getDb().run("DELETE FROM agents");
     getDb().run("DELETE FROM active_sessions");
@@ -81,7 +96,82 @@ describe("Heartbeat — supersede + resume (DES-523)", () => {
     expect(resume.taskType).toBe("resume");
     expect(resume.tags).toContain("auto-resume");
     expect(resume.tags).toContain("reason:crash_recovery");
+    expect(resume.tags).toContain(`${RESUME_GENERATION_TAG_PREFIX}1`);
     expect(resume.id).toBe(findings.autoResumedTasks[0]!.resumeTaskId);
+
+    const supersedeLog = getLogsByTaskId(parent.id).find(
+      (log) => log.eventType === "task_superseded",
+    );
+    expect(supersedeLog).toBeTruthy();
+    const metadata = JSON.parse(supersedeLog!.metadata ?? "{}") as { resumeTaskId?: string };
+    expect(metadata.resumeTaskId).toBe(resume.id);
+  });
+
+  test("Case A: crash-recovery resume chain stops at the generation cap", async () => {
+    const agent = createAgent({ name: "dead-resume-worker", isLead: false, status: "busy" });
+    const parent = createTaskExtended("Resume at generation cap", {
+      agentId: agent.id,
+      taskType: "resume",
+      tags: [
+        "auto-resume",
+        "reason:crash_recovery",
+        `${RESUME_GENERATION_TAG_PREFIX}${MAX_RESUME_GENERATIONS}`,
+      ],
+    });
+    startTask(parent.id);
+
+    const oldTime = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+    getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [oldTime, parent.id]);
+
+    const findings = await codeLevelTriage();
+
+    expect(findings.autoResumedTasks.length).toBe(0);
+    expect(findings.autoFailedTasks.length).toBe(1);
+    expect(findings.autoFailedTasks[0]!.taskId).toBe(parent.id);
+    expect(findings.autoFailedTasks[0]!.reason).toBe(RESUME_BUDGET_EXHAUSTED_REASON);
+
+    const updatedParent = getTaskById(parent.id);
+    expect(updatedParent?.status).toBe("failed");
+    expect(updatedParent?.failureReason).toBe(RESUME_BUDGET_EXHAUSTED_REASON);
+    expect(getChildTasks(parent.id).length).toBe(0);
+  });
+
+  test("Case A: supersede race does not create a resume child or repoint tracker_sync", async () => {
+    const agent = createAgent({ name: "dead-worker-race", isLead: false, status: "busy" });
+    const parent = createTaskExtended("Tracked parent that finishes during heartbeat", {
+      agentId: agent.id,
+    });
+    startTask(parent.id);
+
+    createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: parent.id,
+      externalId: "linear-race-issue",
+      externalIdentifier: "ENG-637",
+      externalUrl: "https://linear.app/test/issue/ENG-637",
+    });
+
+    const oldTime = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+    getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [oldTime, parent.id]);
+
+    setBeforeHeartbeatSupersedeForTests((task) => {
+      expect(task.id).toBe(parent.id);
+      completeTask(parent.id, "finished by racing worker");
+    });
+
+    const findings = await codeLevelTriage();
+
+    expect(findings.autoResumedTasks.length).toBe(0);
+    expect(findings.autoFailedTasks.length).toBe(0);
+
+    const updatedParent = getTaskById(parent.id);
+    expect(updatedParent?.status).toBe("completed");
+    expect(getChildTasks(parent.id).length).toBe(0);
+
+    expect(getTrackerSync("linear", "task", parent.id)).not.toBeNull();
+    const byExternal = getTrackerSyncByExternalId("linear", "task", "linear-race-issue");
+    expect(byExternal?.swarmId).toBe(parent.id);
   });
 
   // --------------------------------------------------------------------------

package/src/tests/heartbeat.test.ts

@@ -7,13 +7,17 @@ import {
   getActiveSessionForTask,
   getDb,
   getIdleWorkersWithCapacity,
+  getOrphanedInProgressTasksForAgent,
+  getPendingTaskForAgent,
   getStalledInProgressTasks,
   getTaskById,
   getUnassignedPoolTasks,
   initDb,
   insertActiveSession,
+  resetOrphanedInProgressTasksForAgent,
   startTask,
   updateAgentStatus,
+  updateTaskClaudeSessionId,
 } from "../be/db";
 import {
   codeLevelTriage,
@@ -157,6 +161,60 @@ describe("Heartbeat Triage", () => {
     });
   });
 
+  describe("orphaned in_progress recovery", () => {
+    test("resets stale in_progress task with no session and no claudeSessionId to pending", () => {
+      const agent = createAgent({ name: "orphan-worker", isLead: false, status: "idle" });
+      const task = createTaskExtended("Orphaned task", { agentId: agent.id });
+      startTask(task.id);
+
+      const oldTime = new Date(Date.now() - 2 * 60 * 1000).toISOString();
+      getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [oldTime, task.id]);
+
+      const orphaned = getOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(orphaned.map((t) => t.id)).toContain(task.id);
+
+      const reset = resetOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(reset.map((t) => t.id)).toContain(task.id);
+
+      const updated = getTaskById(task.id);
+      expect(updated?.status).toBe("pending");
+      expect(getPendingTaskForAgent(agent.id)?.id).toBe(task.id);
+    });
+
+    test("does not reset tasks with active session, provider session, or fresh update", () => {
+      const agent = createAgent({ name: "live-worker", isLead: false, status: "idle" });
+      const withActiveSession = createTaskExtended("Live session task", { agentId: agent.id });
+      const withProviderSession = createTaskExtended("Provider session task", {
+        agentId: agent.id,
+      });
+      const fresh = createTaskExtended("Fresh task", { agentId: agent.id });
+
+      startTask(withActiveSession.id);
+      startTask(withProviderSession.id);
+      startTask(fresh.id);
+
+      const oldTime = new Date(Date.now() - 2 * 60 * 1000).toISOString();
+      getDb().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id IN (?, ?)", [
+        oldTime,
+        withActiveSession.id,
+        withProviderSession.id,
+      ]);
+      insertActiveSession({
+        agentId: agent.id,
+        taskId: withActiveSession.id,
+        triggerType: "task_assigned",
+      });
+      updateTaskClaudeSessionId(withProviderSession.id, "claude-live-session");
+
+      const reset = resetOrphanedInProgressTasksForAgent(agent.id, 60);
+      expect(reset.length).toBe(0);
+
+      expect(getTaskById(withActiveSession.id)?.status).toBe("in_progress");
+      expect(getTaskById(withProviderSession.id)?.status).toBe("in_progress");
+      expect(getTaskById(fresh.id)?.status).toBe("in_progress");
+    });
+  });
+
   describe("getIdleWorkersWithCapacity", () => {
     test("returns idle non-lead agents", () => {
       createAgent({ name: "idle-worker", isLead: false, status: "idle" });
@@ -306,10 +364,13 @@ describe("Heartbeat Triage", () => {
       expect(findings.autoAssigned.length).toBe(1);
       expect(findings.autoAssigned[0]!.agentId).toBe(worker.id);
 
-      // Verify task is now in_progress
+      // Verify task is pending so the worker's normal poll returns task_assigned.
       const task = getTaskById(findings.autoAssigned[0]!.taskId);
-      expect(task?.status).toBe("in_progress");
+      expect(task?.status).toBe("pending");
       expect(task?.agentId).toBe(worker.id);
+
+      const dispatchable = getPendingTaskForAgent(worker.id);
+      expect(dispatchable?.id).toBe(task?.id);
     });
 
     test("auto-assignment skips lead agents", async () => {
@@ -340,6 +401,26 @@ describe("Heartbeat Triage", () => {
       expect(findings.autoAssigned.length).toBe(0);
     });
 
+    test("auto-assignment counts pending reservations when assigning pool tasks", async () => {
+      const worker = createAgent({ name: "single-slot-worker", isLead: false, status: "idle" });
+      createTaskExtended("Pool task 1");
+      createTaskExtended("Pool task 2");
+
+      const findings = await codeLevelTriage();
+      expect(findings.autoAssigned.length).toBe(1);
+      expect(findings.autoAssigned[0]!.agentId).toBe(worker.id);
+
+      const assigned = getDb()
+        .query("SELECT COUNT(*) as count FROM agent_tasks WHERE agentId = ? AND status = 'pending'")
+        .get(worker.id) as { count: number };
+      const remaining = getDb()
+        .query("SELECT COUNT(*) as count FROM agent_tasks WHERE status = 'unassigned'")
+        .get() as { count: number };
+
+      expect(assigned.count).toBe(1);
+      expect(remaining.count).toBe(1);
+    });
+
     test("fixes worker with busy status but no active tasks", async () => {
       createAgent({ name: "ghost-busy", isLead: false, status: "busy" });
 
@@ -408,7 +489,7 @@ describe("Heartbeat Triage", () => {
 
       // Verify task was auto-assigned
       const tasks = getDb()
-        .query("SELECT * FROM agent_tasks WHERE status = 'in_progress' AND agentId = ?")
+        .query("SELECT * FROM agent_tasks WHERE status = 'pending' AND agentId = ?")
         .all(worker.id) as Array<{ id: string }>;
       expect(tasks.length).toBe(1);
     });

package/src/tests/http-api-integration.test.ts

@@ -13,6 +13,7 @@ import { Webhook } from "svix";
 const TEST_PORT = 19876;
 const TEST_DB_PATH = `/tmp/test-http-integration-${Date.now()}.sqlite`;
 const BASE = `http://localhost:${TEST_PORT}`;
+const TEST_API_KEY = "test-http-integration-key";
 
 let serverProc: Subprocess;
 
@@ -28,6 +29,7 @@ async function api(
 ): Promise<{ status: number; body: any; ok: boolean }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
+    Authorization: `Bearer ${TEST_API_KEY}`,
     ...opts.headers,
   };
   if (opts.agentId) headers["x-agent-id"] = opts.agentId;
@@ -106,7 +108,7 @@ beforeAll(async () => {
       ...process.env,
       PORT: String(TEST_PORT),
       DATABASE_PATH: TEST_DB_PATH,
-      API_KEY: "", // no auth required
+      API_KEY: TEST_API_KEY,
       CAPABILITIES: "core,task-pool,messaging,profiles,services,scheduling,memory",
       // Disable optional integrations
       SLACK_BOT_TOKEN: "",