@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/tests/follow-up-config-inheritance.test.ts

@@ -0,0 +1,260 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getScheduledTaskById,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { getRebootAffectedTasks, runRebootSweep } from "../heartbeat/heartbeat";
+import { createStandaloneScheduleTask } from "../scheduler/schedule-task";
+import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
+import { registerDeferTaskTool } from "../tools/defer-task";
+import { registerSendTaskTool } from "../tools/send-task";
+import type { FollowUpConfig } from "../types";
+
+// followUpConfig follows one piece of work, not the thread: continuations of
+// the same work inherit it, new work created with a parentTaskId does not.
+
+type Tool = { handler: (args: unknown, extra: unknown) => Promise<CallToolResult> };
+
+const ON_COMPLETED: FollowUpConfig = { onCompleted: "Switch the cron and DM the requester." };
+
+let leadId: string;
+let workerId: string;
+let sendTask: Tool;
+let deferTask: Tool;
+
+function callTool(tool: Tool, args: Record<string, unknown>, agentId: string) {
+  return tool.handler(args, {
+    sessionId: crypto.randomUUID(),
+    requestInfo: { headers: { "x-agent-id": agentId } },
+  });
+}
+
+function sentTaskId(result: CallToolResult): string {
+  const structured = result.structuredContent as { success: boolean; task?: { id: string } };
+  expect(structured.success).toBe(true);
+  return structured.task!.id;
+}
+
+async function followUpConfigOf(taskId: string) {
+  return (await getTaskById(taskId))?.followUpConfig;
+}
+
+async function workerTaskWithOnCompleted(description: string) {
+  const task = await createTaskExtended(description, {
+    agentId: workerId,
+    followUpConfig: ON_COMPLETED,
+  });
+  await startTask(task.id);
+  return task;
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  const server = new McpServer({ name: "follow-up-config-inheritance", version: "1.0.0" });
+  registerSendTaskTool(server);
+  registerDeferTaskTool(server);
+  const tools = (server as unknown as { _registeredTools: Record<string, Tool> })._registeredTools;
+  sendTask = tools["send-task"]!;
+  deferTask = tools["defer-task"]!;
+});
+
+beforeEach(async () => {
+  const db = getDbClient();
+  await db.run("DELETE FROM agent_tasks");
+  await db.run("DELETE FROM agents");
+  await db.run("DELETE FROM active_sessions");
+  leadId = (
+    await createAgent({
+      name: "Lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+      maxTasks: 50,
+    })
+  ).id;
+  workerId = (
+    await createAgent({
+      name: "Worker",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      maxTasks: 50,
+    })
+  ).id;
+});
+
+afterAll(() => closeDb());
+
+describe("createTaskExtended followUpConfig inheritance", () => {
+  test("a plain child with parentTaskId does not inherit", async () => {
+    const parent = await workerTaskWithOnCompleted("parent work");
+    const child = await createTaskExtended("unrelated child", { parentTaskId: parent.id });
+    expect(child.followUpConfig).toBeUndefined();
+  });
+
+  test("an explicit followUpConfig wins over the parent's", async () => {
+    const parent = await workerTaskWithOnCompleted("parent work");
+    const own: FollowUpConfig = { onFailed: "Retry once." };
+    const child = await createTaskExtended("continuation", {
+      parentTaskId: parent.id,
+      inheritParentFollowUpConfig: true,
+      followUpConfig: own,
+    });
+    expect(child.followUpConfig).toEqual(own);
+  });
+});
+
+describe("kept: continuations of the same work inherit followUpConfig", () => {
+  test("interrupted-task resume (createResumeFollowUp)", async () => {
+    const parent = await workerTaskWithOnCompleted("interrupted work");
+    const resume = await createResumeFollowUp({ parentId: parent.id, reason: "crash_recovery" });
+    expect(resume.kind).toBe("created");
+    if (resume.kind !== "created") return;
+    expect(resume.task.followUpConfig).toEqual(ON_COMPLETED);
+  });
+
+  test("reboot-sweep retry", async () => {
+    const parent = await workerTaskWithOnCompleted("work cut by a reboot");
+    await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+      new Date(Date.now() - 1000).toISOString(),
+      parent.id,
+    ]);
+
+    await runRebootSweep();
+
+    const retryTaskId = getRebootAffectedTasks().find(
+      (a) => a.original.id === parent.id,
+    )?.retryTaskId;
+    expect(retryTaskId).toBeTruthy();
+    expect(await followUpConfigOf(retryTaskId!)).toEqual(ON_COMPLETED);
+  });
+
+  test("defer-task wake-up continuation", async () => {
+    const parent = await workerTaskWithOnCompleted("work that waits");
+    const result = await callTool(
+      deferTask,
+      { taskId: parent.id, delayMs: 3_600_000, summary: "Waiting", note: "Check back" },
+      workerId,
+    );
+    const { success, scheduleId } = result.structuredContent as {
+      success: boolean;
+      scheduleId?: string;
+    };
+    expect(success).toBe(true);
+    const schedule = await getScheduledTaskById(scheduleId!);
+
+    const wake = await createStandaloneScheduleTask(schedule!);
+    expect(wake.parentTaskId).toBe(parent.id);
+    expect(wake.followUpConfig).toEqual(ON_COMPLETED);
+  });
+
+  test("send-task resume re-delegation (reroute-decision template)", async () => {
+    const parent = await workerTaskWithOnCompleted("crashed work");
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "resume the crashed work",
+          agentId: workerId,
+          routingReason: "reroute_fault",
+          routingNote: "same specialization as the crashed worker",
+          taskType: "resume",
+          parentTaskId: parent.id,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toEqual(ON_COMPLETED);
+  });
+});
+
+describe("stopped: new work does not inherit followUpConfig", () => {
+  test("Lead follow-up from createWorkerTaskFollowUp", async () => {
+    const task = await workerTaskWithOnCompleted("worker build task");
+    const completed = await completeTask(task.id, "done");
+    const followUp = await createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "done",
+    });
+    expect(followUp).not.toBeNull();
+    // The instruction is delivered in the follow-up's text, once.
+    expect(followUp!.task).toContain(ON_COMPLETED.onCompleted!);
+    expect(followUp!.followUpConfig).toBeUndefined();
+  });
+
+  test("send-task child with parentTaskId", async () => {
+    const parent = await workerTaskWithOnCompleted("original request");
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "a new delegation in the same thread",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns this area of the codebase",
+          parentTaskId: parent.id,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toBeUndefined();
+  });
+
+  test("send-task child keeps an explicit followUpConfig", async () => {
+    const parent = await workerTaskWithOnCompleted("original request 2");
+    const own: FollowUpConfig = { disabled: true };
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "delegation that is awaited inline",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns this area of the codebase",
+          parentTaskId: parent.id,
+          followUpConfig: own,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toEqual(own);
+  });
+
+  test("chain regression: worker task -> Lead follow-up -> send-task child", async () => {
+    const task = await workerTaskWithOnCompleted("tla-spec-sync build");
+    const completed = await completeTask(task.id, "built");
+    const followUp = await createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "built",
+    });
+    expect(followUp).not.toBeNull();
+
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "render the launch video",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns the video pipeline",
+          parentTaskId: followUp!.id,
+        },
+        leadId,
+      ),
+    );
+
+    expect(await followUpConfigOf(followUp!.id)).toBeUndefined();
+    expect(await followUpConfigOf(childId)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,84 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getChildTasks,
+  getDbClient,
+  getTaskById,
+  initDb,
+  startTask,
+  supersedeTask,
+} from "../be/db";
+import {
+  codeLevelTriage,
+  runRebootSweep,
+  setBeforeHeartbeatSupersedeForTests,
+} from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-orphan-resume.sqlite";
+
+describe("Heartbeat orphaned supersede repair (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> Age -> HbRead -> HbWrite -> ApiCrash -> ApiBoot (SupersededGetsResume).
+  test("a task superseded without a resume (crash before resume creation) gets a resume on the next sweep", async () => {
+    const agent = await createAgent({ name: "crashed-worker", isLead: false, status: "idle" });
+    const task = await createTaskExtended("Work interrupted mid-recovery", { agentId: agent.id });
+    await startTask(task.id);
+
+    // State the API process leaves behind if it dies between supersedeTask
+    // and createResumeFollowUp in remediateCrashedWorkerTask.
+    await supersedeTask(task.id, {
+      reason: "Auto-superseded by heartbeat: worker session not found (no active session for task)",
+      resumeTaskId: null,
+    });
+    await getDbClient().run("UPDATE agent_tasks SET finishedAt = ? WHERE id = ?", [
+      new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+      task.id,
+    ]);
+
+    // Restarted API: boot sweep, then a regular sweep.
+    await runRebootSweep();
+    await codeLevelTriage();
+
+    expect((await getTaskById(task.id))?.status).toBe("superseded");
+    expect(await getChildTasks(task.id)).toHaveLength(1);
+  });
+});

package/src/tests/heartbeat-reboot-live.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getActiveSessionForTask,
+  getDbClient,
+  getTaskById,
+  initDb,
+  insertActiveSession,
+  startTask,
+} from "../be/db";
+import { runRebootSweep, setBeforeHeartbeatSupersedeForTests } from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-reboot-live.sqlite";
+
+async function backdateTask(taskId: string, isoTime: string): Promise<void> {
+  await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+    isoTime,
+    taskId,
+  ]);
+}
+
+describe("Reboot sweep live sessions (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> RegisterSession -> ApiCrash -> ApiBoot -> RebootFail (NoLiveKill).
+  test("reboot sweep does not fail a live worker whose last tool call was shortly before the API restart", async () => {
+    const gs = globalThis as typeof globalThis & { __runId?: string };
+    const original = gs.__runId;
+    const bootTime = Date.now();
+    gs.__runId = `run_${bootTime}`;
+    try {
+      const agent = await createAgent({ name: "live-worker", isLead: false, status: "busy" });
+      const task = await createTaskExtended("Long model call", { agentId: agent.id });
+      await startTask(task.id);
+      await backdateTask(task.id, new Date(bootTime - 60_000).toISOString());
+
+      // Worker container kept running through the API deploy. Its last
+      // PostToolUse heartbeat landed 30s before the new API process booted.
+      await insertActiveSession({
+        agentId: agent.id,
+        taskId: task.id,
+        triggerType: "task_assigned",
+      });
+      await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
+        new Date(bootTime - 30_000).toISOString(),
+        task.id,
+      ]);
+
+      await runRebootSweep();
+
+      expect((await getTaskById(task.id))?.status).toBe("in_progress");
+      expect(await getActiveSessionForTask(task.id)).not.toBeNull();
+    } finally {
+      gs.__runId = original;
+    }
+  });
+});

package/src/tests/heartbeat-stall-cas.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getChildTasks,
+  getDbClient,
+  getTaskById,
+  initDb,
+  startTask,
+  updateTaskProgress,
+} from "../be/db";
+import { codeLevelTriage, setBeforeHeartbeatSupersedeForTests } from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-stall-cas.sqlite";
+
+async function backdateTask(taskId: string, isoTime: string): Promise<void> {
+  await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+    isoTime,
+    taskId,
+  ]);
+}
+
+describe("Heartbeat stall classifier CAS (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> Age -> HbRead -> Progress -> HbWrite (NoLiveKill).
+  test("stall classifier does not supersede a task that made progress after the candidate read", async () => {
+    const agent = await createAgent({ name: "quiet-worker", isLead: false, status: "busy" });
+    const task = await createTaskExtended("Long quiet work", { agentId: agent.id });
+    await startTask(task.id);
+    await backdateTask(task.id, new Date(Date.now() - 10 * 60 * 1000).toISOString());
+
+    // The worker reports progress after the sweep read the candidate list.
+    setBeforeHeartbeatSupersedeForTests(async (candidate) => {
+      await updateTaskProgress(candidate.id, "still working");
+    });
+
+    await codeLevelTriage();
+
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+    expect(await getChildTasks(task.id)).toHaveLength(0);
+  });
+});

package/src/tests/heartbeat.test.ts

@@ -1,10 +1,12 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
+  cancelTask,
   claimTask,
   closeDb,
   createAgent,
   createTaskExtended,
+  failTask,
   getActiveSessionForTask,
   getDbClient,
   getIdleWorkersWithCapacity,
@@ -280,6 +282,13 @@ describe("Heartbeat Triage", () => {
   // ==========================================================================
 
   describe("Code-Level Triage", () => {
+    test("reports approval sweep counts in staleCleanup", async () => {
+      const findings = await codeLevelTriage();
+
+      expect(typeof findings.staleCleanup.approvalAutoCancelled).toBe("number");
+      expect(typeof findings.staleCleanup.approvalTimedOut).toBe("number");
+    });
+
     test("auto-supersedes stalled task with no active session (DES-523)", async () => {
       const agent = await createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = await createTaskExtended("Stalled task", { agentId: agent.id });
@@ -1037,6 +1046,93 @@ describe("Heartbeat Triage", () => {
       expect(retryTask!.priority).toBe(90);
       expect(retryTask!.source).toBe("slack");
     });
+
+    async function sweptTaskWithDependent(taskType?: string) {
+      const agent = await createAgent({ name: "dead-worker", isLead: false, status: "busy" });
+      const other = await createAgent({ name: "dependent-owner", isLead: false, status: "idle" });
+      const parent = await createTaskExtended("Thread root", { agentId: other.id });
+      const swept = await createTaskExtended("Research step", { agentId: agent.id, taskType });
+      await startTask(swept.id);
+      await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+        new Date(Date.now() - 1000).toISOString(),
+        swept.id,
+      ]);
+      const done = await createTaskExtended("Already done", { agentId: other.id });
+      await getDbClient().run("UPDATE agent_tasks SET status = 'completed' WHERE id = ?", [
+        done.id,
+      ]);
+      const dependent = await createTaskExtended("Act on the research", {
+        agentId: other.id,
+        dependsOn: [swept.id, done.id],
+        parentTaskId: parent.id,
+        priority: 70,
+        slackChannelId: "C0TEST",
+        slackThreadTs: "1700000000.000100",
+        slackUserId: "U0TEST",
+        followUpConfig: { onCompleted: "Tell the requester" },
+      });
+      return { swept, done, dependent, parent, other };
+    }
+
+    test("reboot sweep re-points a never-started dependent to the retry child instead of failing it", async () => {
+      const { swept, done, dependent, parent, other } = await sweptTaskWithDependent();
+      const cancelled = await createTaskExtended("Cancelled for another reason", {
+        agentId: other.id,
+        dependsOn: [swept.id],
+      });
+      await cancelTask(cancelled.id, "not needed");
+
+      await runRebootSweep();
+
+      expect((await getTaskById(swept.id))?.status).toBe("failed");
+      const retryTaskId = getRebootAffectedTasks()[0]!.retryTaskId;
+      expect(retryTaskId).not.toBeNull();
+
+      const survivor = await getTaskById(dependent.id);
+      expect(survivor?.status).toBe("pending");
+      expect(survivor?.failureReason).toBeFalsy();
+      expect(survivor?.dependsOn).toEqual([retryTaskId!, done.id]);
+      expect(survivor?.agentId).toBe(other.id);
+      expect(survivor?.parentTaskId).toBe(parent.id);
+      expect(survivor?.priority).toBe(70);
+      expect(survivor?.slackChannelId).toBe("C0TEST");
+      expect(survivor?.slackThreadTs).toBe("1700000000.000100");
+      expect(survivor?.slackUserId).toBe("U0TEST");
+      expect(survivor?.followUpConfig).toEqual({ onCompleted: "Tell the requester" });
+
+      const log = await getDbClient().get<{ oldValue: string; newValue: string }>(
+        "SELECT oldValue, newValue FROM agent_log WHERE taskId = ? AND eventType = 'task_dependency_repointed'",
+        [dependent.id],
+      );
+      expect(log).toEqual({ oldValue: swept.id, newValue: retryTaskId! });
+
+      // Already terminal for another reason: untouched.
+      const stillCancelled = await getTaskById(cancelled.id);
+      expect(stillCancelled?.status).toBe("cancelled");
+      expect(stillCancelled?.dependsOn).toEqual([swept.id]);
+    });
+
+    test("reboot sweep without a retry child still cascade-fails dependents", async () => {
+      const { swept, dependent } = await sweptTaskWithDependent("heartbeat-checklist");
+
+      await runRebootSweep();
+
+      expect(getRebootAffectedTasks()[0]!.retryTaskId).toBeNull();
+      const dead = await getTaskById(dependent.id);
+      expect(dead?.status).toBe("failed");
+      expect(dead?.failureReason).toBe(`Blocked dependency ${swept.id.slice(0, 8)} was failed`);
+    });
+
+    test("a non-reboot failure still cascade-fails dependents", async () => {
+      const { swept, dependent } = await sweptTaskWithDependent();
+
+      await failTask(swept.id, "Worker reported an error");
+
+      const dead = await getTaskById(dependent.id);
+      expect(dead?.status).toBe("failed");
+      expect(dead?.failureReason).toBe(`Blocked dependency ${swept.id.slice(0, 8)} was failed`);
+      expect(dead?.dependsOn).toContain(swept.id);
+    });
   });
 
   // ==========================================================================
@@ -1083,13 +1179,13 @@ describe("Heartbeat Triage", () => {
           task.id,
         ]);
 
-        // Session with pre-boot heartbeat (stale)
+        // Session with pre-boot heartbeat, stale past the 15 min threshold
         await insertActiveSession({
           agentId: agent.id,
           taskId: task.id,
           triggerType: "task_assigned",
         });
-        const preBootHb = new Date(bootTime - 30_000).toISOString();
+        const preBootHb = new Date(bootTime - 20 * 60_000).toISOString();
         await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
           preBootHb,
           task.id,
@@ -1189,7 +1285,7 @@ describe("Heartbeat Triage", () => {
           taskId: staleTask.id,
           triggerType: "task_assigned",
         });
-        const preBootHb = new Date(bootTime - 30_000).toISOString();
+        const preBootHb = new Date(bootTime - 20 * 60_000).toISOString();
         await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
           preBootHb,
           staleTask.id,

package/src/tests/hook-mcp-config.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { loadHookMcpConfig } from "../hooks/hook";
+
+describe("loadHookMcpConfig", () => {
+  test("falls back to the workspace config when the project has no .mcp.json", async () => {
+    const tempDir = `/tmp/hook-mcp-fallback-${crypto.randomUUID()}`;
+    const projectDir = `${tempDir}/repo`;
+    const workspaceDir = `${tempDir}/workspace`;
+    const expected = {
+      url: "http://localhost:3013/mcp",
+      headers: {
+        Authorization: "Bearer example-test-key",
+        "X-Agent-ID": "agent-test-id",
+      },
+    };
+
+    await Bun.$`mkdir -p ${projectDir} ${workspaceDir}`.quiet();
+    try {
+      await Bun.write(
+        `${workspaceDir}/.mcp.json`,
+        JSON.stringify({ mcpServers: { "agent-swarm": expected } }),
+      );
+
+      expect(await loadHookMcpConfig(projectDir, workspaceDir)).toEqual(expected);
+    } finally {
+      await Bun.$`rm -rf ${tempDir}`.quiet();
+    }
+  });
+});