@desplega.ai/agent-swarm 1.86.0 → 1.87.0

package/src/tests/heartbeat.test.ts

@@ -208,7 +208,7 @@ describe("Heartbeat Triage", () => {
   // ==========================================================================
 
   describe("Code-Level Triage", () => {
-    test("auto-fails stalled task with no active session", async () => {
+    test("auto-supersedes stalled task with no active session (DES-523)", async () => {
       const agent = createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = createTaskExtended("Stalled task", { agentId: agent.id });
       startTask(task.id);
@@ -219,17 +219,21 @@ describe("Heartbeat Triage", () => {
 
       const findings = await codeLevelTriage();
 
-      expect(findings.autoFailedTasks.length).toBe(1);
-      expect(findings.autoFailedTasks[0]!.taskId).toBe(task.id);
+      expect(findings.autoResumedTasks.length).toBe(1);
+      expect(findings.autoResumedTasks[0]!.taskId).toBe(task.id);
+      expect(findings.autoResumedTasks[0]!.reason).toContain("no active session");
+      expect(findings.autoFailedTasks.length).toBe(0);
       expect(findings.stalledTasks.length).toBe(0);
 
-      // Verify task is actually failed in DB
+      // Verify task is superseded (not failed) — the resume task carries the work forward.
+      // `failureReason` is unset on superseded tasks; the supersede reason lives on the log
+      // entry and on `findings.autoResumedTasks[].reason` (checked above).
       const updated = getTaskById(task.id);
-      expect(updated?.status).toBe("failed");
-      expect(updated?.failureReason).toContain("no active session");
+      expect(updated?.status).toBe("superseded");
+      expect(updated?.failureReason).toBeFalsy();
     });
 
-    test("auto-fails stalled task with stale session heartbeat", async () => {
+    test("auto-supersedes stalled task with stale session heartbeat (DES-523)", async () => {
       const agent = createAgent({ name: "crashed-worker", isLead: false, status: "busy" });
       const task = createTaskExtended("Stalled task", { agentId: agent.id });
       startTask(task.id);
@@ -250,14 +254,18 @@ describe("Heartbeat Triage", () => {
 
       const findings = await codeLevelTriage();
 
-      expect(findings.autoFailedTasks.length).toBe(1);
-      expect(findings.autoFailedTasks[0]!.taskId).toBe(task.id);
+      expect(findings.autoResumedTasks.length).toBe(1);
+      expect(findings.autoResumedTasks[0]!.taskId).toBe(task.id);
+      expect(findings.autoResumedTasks[0]!.reason).toContain("stale");
+      expect(findings.autoFailedTasks.length).toBe(0);
       expect(findings.stalledTasks.length).toBe(0);
 
-      // Verify task is failed and session is deleted
+      // Verify task is superseded and session is deleted.
+      // `failureReason` is unset on superseded tasks; the supersede reason lives on the log
+      // entry and on `findings.autoResumedTasks[].reason` (checked above).
       const updated = getTaskById(task.id);
-      expect(updated?.status).toBe("failed");
-      expect(updated?.failureReason).toContain("stale");
+      expect(updated?.status).toBe("superseded");
+      expect(updated?.failureReason).toBeFalsy();
 
       const session = getActiveSessionForTask(task.id);
       expect(session).toBeNull();
@@ -361,7 +369,7 @@ describe("Heartbeat Triage", () => {
       expect(findings.stalledTasks.length).toBe(0);
     });
 
-    test("sets agent to idle after auto-failing its only task", async () => {
+    test("sets agent to idle after auto-superseding its only task", async () => {
       const agent = createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = createTaskExtended("Stalled task", { agentId: agent.id });
       startTask(task.id);
@@ -371,7 +379,8 @@ describe("Heartbeat Triage", () => {
 
       await codeLevelTriage();
 
-      // Agent should be set to idle since it has no more active tasks
+      // Agent should be set to idle since the parent task is terminal (superseded)
+      // and the resume follow-up was routed to the unassigned pool (worker is "dead").
       const agents = getDb().query("SELECT status FROM agents WHERE id = ?").get(agent.id) as {
         status: string;
       };
@@ -404,7 +413,7 @@ describe("Heartbeat Triage", () => {
       expect(tasks.length).toBe(1);
     });
 
-    test("auto-fails stalled task with no session during sweep", async () => {
+    test("auto-supersedes stalled task with no session during sweep", async () => {
       const worker = createAgent({ name: "dead-worker", isLead: false, status: "busy" });
       const task = createTaskExtended("Stalled no-session", { agentId: worker.id });
       startTask(task.id);
@@ -415,7 +424,8 @@ describe("Heartbeat Triage", () => {
       await runHeartbeatSweep();
 
       const updated = getTaskById(task.id);
-      expect(updated?.status).toBe("failed");
+      // DES-523: heartbeat sweep now creates a resume follow-up instead of silently failing.
+      expect(updated?.status).toBe("superseded");
     });
 
     test("cleans stale sessions even when preflight gate bails", async () => {

package/src/tests/prompt-template-remaining.test.ts

@@ -324,6 +324,7 @@ describe("Task lifecycle — backward compatibility", () => {
   test("task.worker.completed produces expected output", () => {
     const result = resolveTemplate("task.worker.completed", {
       agent_name: "Worker-1",
+      creator_agent: "creator-agent-1",
       task_desc: "Fix the login page CSS",
       output_summary: "Fixed the CSS alignment issue on the login form",
       task_id: "task-abc-123",
@@ -334,6 +335,7 @@ describe("Task lifecycle — backward compatibility", () => {
     const expected = `Worker task completed \u2014 review needed.
 
 Agent: Worker-1
+Original task created by agent creator-agent-1
 Task: "Fix the login page CSS"
 
 Output:
@@ -352,6 +354,7 @@ Use \`get-task-details\` with taskId "task-abc-123" for full details.`;
   test("task.worker.failed produces expected output", () => {
     const result = resolveTemplate("task.worker.failed", {
       agent_name: "Worker-2",
+      creator_agent: "creator-agent-2",
       task_desc: "Deploy to production",
       failure_reason: "Docker build failed: missing dependency",
       task_id: "task-def-456",
@@ -362,6 +365,7 @@ Use \`get-task-details\` with taskId "task-abc-123" for full details.`;
     const expected = `Worker task failed \u2014 action needed.
 
 Agent: Worker-2
+Original task created by agent creator-agent-2
 Task: "Deploy to production"
 
 Failure reason: Docker build failed: missing dependency

package/src/tests/resume-session.test.ts

@@ -1,8 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { resolveResumeSession } from "../commands/resume-session";
+import { RESUME_DEPRECATED_REASON, resolveResumeSession } from "../commands/resume-session";
 
-describe("resolveResumeSession", () => {
-  test("allows local Claude resume for UUID session ids", () => {
+// Native resume was deprecated in the 2026-05-28 plan. resolveResumeSession
+// is now an observability shim — it records the candidates that would have
+// been resume targets in the old world, but never returns a resumeSessionId.
+
+describe("resolveResumeSession (observability shim)", () => {
+  test("returns no resumeSessionId for any candidate", () => {
     const resolution = resolveResumeSession("claude", [
       {
         source: "task",
@@ -11,28 +15,18 @@ describe("resolveResumeSession", () => {
       },
     ]);
 
-    expect(resolution.resumeSessionId).toBe("69dbe5a1-1130-45eb-983f-58a7a13c9c3c");
-    expect(resolution.source).toBe("task");
-    expect(resolution.provider).toBe("claude");
-    expect(resolution.skipped).toEqual([]);
+    expect(resolution.resumeSessionId).toBeUndefined();
+    expect(resolution.source).toBeUndefined();
+    expect(resolution.provider).toBeUndefined();
   });
 
-  test("rejects non-UUID ids for local Claude resume", () => {
+  test("records every non-empty candidate in skipped with the deprecation reason", () => {
     const resolution = resolveResumeSession("claude", [
       {
         source: "task",
-        sessionId: "ses_19c145de3ffeD9qLlntj8SRO28",
+        sessionId: "69dbe5a1-1130-45eb-983f-58a7a13c9c3c",
         provider: "claude",
       },
-    ]);
-
-    expect(resolution.resumeSessionId).toBeUndefined();
-    expect(resolution.skipped).toHaveLength(1);
-    expect(resolution.skipped[0]?.reason).toBe("Claude CLI --resume requires a UUID session id");
-  });
-
-  test("normalizes legacy managed Claude rows to claude-managed", () => {
-    const resolution = resolveResumeSession("claude-managed", [
       {
         source: "parent",
         sessionId: "sesn_resume_xyz",
@@ -41,53 +35,51 @@ describe("resolveResumeSession", () => {
       },
     ]);
 
-    expect(resolution.resumeSessionId).toBe("sesn_resume_xyz");
-    expect(resolution.source).toBe("parent");
-    expect(resolution.provider).toBe("claude-managed");
+    expect(resolution.skipped).toHaveLength(2);
+    for (const entry of resolution.skipped) {
+      expect(entry.reason).toBe(RESUME_DEPRECATED_REASON);
+    }
+    expect(resolution.skipped[0]?.source).toBe("task");
+    expect(resolution.skipped[0]?.sessionId).toBe("69dbe5a1-1130-45eb-983f-58a7a13c9c3c");
+    expect(resolution.skipped[1]?.source).toBe("parent");
+    expect(resolution.skipped[1]?.sessionId).toBe("sesn_resume_xyz");
   });
 
-  test("skips mismatched provider sessions and falls back to parent", () => {
+  test("ignores candidates with empty / whitespace-only sessionId", () => {
     const resolution = resolveResumeSession("claude", [
-      {
-        source: "task",
-        sessionId: "thread-codex",
-        provider: "codex",
-      },
-      {
-        source: "parent",
-        sessionId: "69dbe5a1-1130-45eb-983f-58a7a13c9c3c",
-        provider: "claude",
-      },
+      { source: "task", sessionId: undefined },
+      { source: "task", sessionId: null },
+      { source: "task", sessionId: "" },
+      { source: "parent", sessionId: "   " },
     ]);
 
-    expect(resolution.resumeSessionId).toBe("69dbe5a1-1130-45eb-983f-58a7a13c9c3c");
-    expect(resolution.source).toBe("parent");
-    expect(resolution.skipped).toHaveLength(1);
-    expect(resolution.skipped[0]?.reason).toContain("does not match current provider");
+    expect(resolution.skipped).toEqual([]);
+    expect(resolution.resumeSessionId).toBeUndefined();
   });
 
-  test("rejects legacy unknown non-UUID Claude session ids", () => {
+  test("preserves the candidate provider in the skipped entry for observability", () => {
     const resolution = resolveResumeSession("claude", [
       {
         source: "task",
-        sessionId: "ses_19c145de3ffeD9qLlntj8SRO28",
+        sessionId: "thread-codex",
+        provider: "codex",
       },
     ]);
 
-    expect(resolution.resumeSessionId).toBeUndefined();
-    expect(resolution.skipped[0]?.reason).toBe("legacy Claude resume requires a UUID session id");
+    expect(resolution.skipped).toHaveLength(1);
+    expect(resolution.skipped[0]?.provider).toBe("codex");
+    expect(resolution.skipped[0]?.reason).toBe(RESUME_DEPRECATED_REASON);
   });
 
-  test("does not resume providers without runner resume support", () => {
-    const resolution = resolveResumeSession("pi", [
-      {
-        source: "task",
-        sessionId: "pi-session",
-        provider: "pi",
-      },
-    ]);
+  test("currentProvider is ignored — same skipped output regardless", () => {
+    const candidates = [
+      { source: "task" as const, sessionId: "abc-123", provider: "claude" as const },
+    ];
+    const a = resolveResumeSession("claude", candidates);
+    const b = resolveResumeSession("pi", candidates);
+    const c = resolveResumeSession("codex", candidates);
 
-    expect(resolution.resumeSessionId).toBeUndefined();
-    expect(resolution.skipped[0]?.reason).toBe("provider pi does not support runner resume");
+    expect(a.skipped).toEqual(b.skipped);
+    expect(b.skipped).toEqual(c.skipped);
   });
 });

package/src/tests/structured-output.test.ts

@@ -253,6 +253,29 @@ describe("AgentTaskConfigSchema — outputSchema", () => {
       expect(parsed.data.outputSchema).toEqual(config.outputSchema);
     }
   });
+
+  test("accepts followUpConfig in config", async () => {
+    const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
+    const executor = new AgentTaskExecutor({
+      // biome-ignore lint/suspicious/noExplicitAny: mock DB for test
+      db: {} as any,
+      eventBus: { emit: () => {}, on: () => {}, off: () => {} },
+      interpolate: (t: string) => t,
+    });
+
+    const config = {
+      template: "Count files",
+      followUpConfig: {
+        onCompleted: "post the URL",
+        onFailed: "page Taras",
+      },
+    };
+    const parsed = executor.configSchema.safeParse(config);
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.followUpConfig).toEqual(config.followUpConfig);
+    }
+  });
 });
 
 // ─── Workflow agent-task → DB with outputSchema ──────────────
@@ -305,4 +328,50 @@ describe("Workflow agent-task creates task with outputSchema", () => {
     expect(task).toBeDefined();
     expect(task!.outputSchema).toEqual(schema);
   });
+
+  test("followUpConfig flows from executor config to created task", async () => {
+    const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
+    const db = await import("../be/db");
+
+    const executor = new AgentTaskExecutor({
+      db: db as typeof import("../be/db"),
+      eventBus: { emit: () => {}, on: () => {}, off: () => {} },
+      interpolate: (t: string) => t,
+    });
+
+    const wf = createWorkflow({
+      name: "test-follow-up-config",
+      definition: { nodes: [], edges: [] },
+    });
+    const run = createWorkflowRun({ id: crypto.randomUUID(), workflowId: wf.id });
+    const step = createWorkflowRunStep({
+      id: crypto.randomUUID(),
+      runId: run.id,
+      nodeId: "n1",
+      nodeType: "agent-task",
+    });
+
+    const followUpConfig = { disabled: true };
+
+    const result = await executor.run({
+      config: {
+        template: "Summarize the document",
+        followUpConfig,
+      },
+      context: {},
+      meta: {
+        runId: run.id,
+        stepId: step.id,
+        nodeId: "n1",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("success");
+    const taskId = (result as { correlationId?: string }).correlationId!;
+    const task = getTaskById(taskId);
+    expect(task).toBeDefined();
+    expect(task!.followUpConfig).toEqual(followUpConfig);
+  });
 });

package/src/tests/task-completion-idempotency.test.ts

@@ -8,6 +8,7 @@ import {
   createTaskExtended,
   failTask,
   getDb,
+  getLeadAgent,
   getLogsByTaskId,
   getTaskById,
   initDb,
@@ -362,7 +363,7 @@ describe("worker task follow-up creation", () => {
       slackThreadTs: "1700000000.000001",
       slackUserId: "U123",
     });
-    startTask(task.id, worker.id);
+    startTask(task.id);
 
     const completed = completeTask(task.id, "Worker output");
     expect(completed).not.toBeNull();
@@ -382,6 +383,152 @@ describe("worker task follow-up creation", () => {
     expect(rows[0]!.slackThreadTs).toBe("1700000000.000001");
     expect(rows[0]!.slackUserId).toBe("U123");
     expect(rows[0]!.task).toContain("Worker output");
+    expect(rows[0]!.task).not.toContain("{{follow_up_instructions}}");
+  });
+
+  test("skips lead follow-up when followUpConfig disables it", () => {
+    createAgent({
+      name: "follow-up-lead-disabled",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = createAgent({
+      name: "follow-up-worker-disabled",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Silent worker task", {
+      agentId: worker.id,
+      followUpConfig: { disabled: true },
+    });
+    startTask(task.id);
+
+    const completed = completeTask(task.id, "Worker output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Worker output",
+    });
+
+    expect(followUp).toBeNull();
+    expect(listFollowUpTasks(task.id)).toHaveLength(0);
+  });
+
+  test("injects onCompleted instructions into completed follow-up", () => {
+    createAgent({
+      name: "follow-up-lead-completed-instructions",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = createAgent({
+      name: "follow-up-worker-completed-instructions",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Worker task with completed instructions", {
+      agentId: worker.id,
+      creatorAgentId: worker.id,
+      followUpConfig: { onCompleted: "post the URL" },
+    });
+    startTask(task.id);
+
+    const completed = completeTask(task.id, "Worker output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Worker output",
+    });
+
+    expect(followUp).not.toBeNull();
+    const rows = listFollowUpTasks(task.id);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.task).toContain(`Original task created by agent ${worker.id}`);
+    expect(rows[0]!.task).toContain("Additional instructions from the task creator:");
+    expect(rows[0]!.task).toContain("post the URL");
+  });
+
+  test("injects only onFailed instructions into failed follow-up", () => {
+    createAgent({
+      name: "follow-up-lead-failed-instructions",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = createAgent({
+      name: "follow-up-worker-failed-instructions",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Worker task with failed instructions", {
+      agentId: worker.id,
+      creatorAgentId: worker.id,
+      followUpConfig: { onCompleted: "post the URL", onFailed: "page Taras" },
+    });
+    startTask(task.id);
+
+    const failed = failTask(task.id, "boom");
+    expect(failed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: failed!,
+      status: "failed",
+      failureReason: "boom",
+    });
+
+    expect(followUp).not.toBeNull();
+    const rows = listFollowUpTasks(task.id);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.task).toContain(`Original task created by agent ${worker.id}`);
+    expect(rows[0]!.task).toContain("page Taras");
+    expect(rows[0]!.task).not.toContain("post the URL");
+  });
+
+  test("inherits followUpConfig from parent task when child has no override", () => {
+    createAgent({
+      name: "follow-up-lead-inheritance",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = createAgent({
+      name: "follow-up-worker-inheritance",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const parent = createTaskExtended("Parent task", {
+      agentId: worker.id,
+      followUpConfig: { disabled: true },
+    });
+    const child = createTaskExtended("Child task", {
+      agentId: worker.id,
+      parentTaskId: parent.id,
+    });
+    startTask(child.id);
+
+    const fetchedChild = getTaskById(child.id);
+    expect(fetchedChild!.followUpConfig).toEqual({ disabled: true });
+
+    const completed = completeTask(child.id, "Child output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Child output",
+    });
+
+    expect(followUp).toBeNull();
+    expect(listFollowUpTasks(child.id)).toHaveLength(0);
   });
 
   test("does not create follow-up for lead-owned task", () => {
@@ -392,7 +539,7 @@ describe("worker task follow-up creation", () => {
       capabilities: [],
     });
     const task = createTaskExtended("Lead task", { agentId: lead.id });
-    startTask(task.id, lead.id);
+    startTask(task.id);
 
     const completed = completeTask(task.id, "Lead output");
     expect(completed).not.toBeNull();
@@ -406,4 +553,40 @@ describe("worker task follow-up creation", () => {
     expect(followUp).toBeNull();
     expect(listFollowUpTasks(task.id)).toHaveLength(0);
   });
+
+  test("marks original creator as you when lead created the worker task", () => {
+    const lead =
+      getLeadAgent() ??
+      createAgent({
+        name: "follow-up-lead-creator-you",
+        isLead: true,
+        status: "idle",
+        capabilities: [],
+      });
+    const worker = createAgent({
+      name: "follow-up-worker-creator-you",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Worker task created by lead", {
+      agentId: worker.id,
+      creatorAgentId: lead.id,
+    });
+    startTask(task.id);
+
+    const completed = completeTask(task.id, "Worker output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Worker output",
+    });
+
+    expect(followUp).not.toBeNull();
+    const rows = listFollowUpTasks(task.id);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.task).toContain(`Original task created by agent ${lead.id} (you)`);
+  });
 });