@desplega.ai/agent-swarm 1.52.0 → 1.52.1

package/src/http/poll.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { ensure } from "@desplega.ai/business-use";
 import { z } from "zod";
 import {
   claimMentions,
@@ -128,6 +129,20 @@ export async function handlePoll(
           if (pendingTask) {
             // Mark task as in_progress immediately to prevent duplicate polling
             startTask(pendingTask.id);
+
+            ensure({
+              id: "started",
+              flow: "task",
+              runId: pendingTask.id,
+              depIds: ["created"],
+              data: {
+                taskId: pendingTask.id,
+                agentId: myAgentId,
+                previousStatus: pendingTask.status,
+              },
+              validator: (data) => data.previousStatus === "pending",
+            });
+
             return {
               trigger: {
                 type: "task_assigned",

package/src/http/tasks.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { ensure } from "@desplega.ai/business-use";
 import { z } from "zod";
 import {
   cancelTask,
@@ -232,6 +233,24 @@ export async function handleTasks(
         source: (parsed.body.source as import("../types").AgentTaskSource) || "api",
         outputSchema: parsed.body.outputSchema || undefined,
       });
+
+      ensure({
+        id: "created",
+        flow: "task",
+        runId: task.id,
+        data: {
+          taskId: task.id,
+          agentId: task.agentId,
+          source: parsed.body.source || "api",
+          status: task.status,
+          task: task.task.slice(0, 200),
+          priority: task.priority,
+          tags: task.tags,
+          parentTaskId: task.parentTaskId,
+          epicId: task.epicId,
+        },
+      });
+
       json(res, task, 201);
     } catch (error) {
       console.error("[HTTP] Failed to create task:", error);
@@ -291,6 +310,36 @@ export async function handleTasks(
       return true;
     }
 
+    if (task.status === "pending") {
+      ensure({
+        id: "cancelled_pending",
+        flow: "task",
+        runId: parsed.params.id,
+        depIds: ["created"],
+        data: {
+          taskId: parsed.params.id,
+          agentId: task.agentId,
+          previousStatus: task.status,
+          reason,
+        },
+        validator: (data) => data.previousStatus === "pending",
+      });
+    } else {
+      ensure({
+        id: "cancelled_in_progress",
+        flow: "task",
+        runId: parsed.params.id,
+        depIds: ["started"],
+        data: {
+          taskId: parsed.params.id,
+          agentId: task.agentId,
+          previousStatus: task.status,
+          reason,
+        },
+        validator: (data) => data.previousStatus === "in_progress",
+      });
+    }
+
     if (task.agentId) {
       updateAgentStatusFromCapacity(task.agentId);
     }
@@ -386,6 +435,25 @@ export async function handleTasks(
       return true;
     }
 
+    if (result.task && !("alreadyFinished" in result && result.alreadyFinished)) {
+      const finishEventId = parsed.body.status === "completed" ? "completed" : "failed";
+      ensure({
+        id: finishEventId,
+        flow: "task",
+        runId: parsed.params.id,
+        depIds: ["started"],
+        data: {
+          taskId: parsed.params.id,
+          agentId: myAgentId,
+          previousStatus: "in_progress",
+          ...(finishEventId === "completed"
+            ? { hasOutput: !!parsed.body.output }
+            : { failureReason: parsed.body.failureReason }),
+        },
+        validator: (data) => data.previousStatus === "in_progress",
+      });
+    }
+
     json(res, {
       success: true,
       alreadyFinished: "alreadyFinished" in result ? result.alreadyFinished : false,
@@ -430,6 +498,19 @@ export async function handleTasks(
       return true;
     }
 
+    ensure({
+      id: "paused",
+      flow: "task",
+      runId: parsed.params.id,
+      depIds: ["started"],
+      data: {
+        taskId: parsed.params.id,
+        agentId: task.agentId,
+        previousStatus: task.status,
+      },
+      validator: (data) => data.previousStatus === "in_progress",
+    });
+
     json(res, { success: true, task: pausedTask });
     return true;
   }
@@ -460,6 +541,19 @@ export async function handleTasks(
       return true;
     }
 
+    ensure({
+      id: "resumed",
+      flow: "task",
+      runId: parsed.params.id,
+      depIds: ["paused"],
+      data: {
+        taskId: parsed.params.id,
+        agentId: task.agentId,
+        previousStatus: task.status,
+      },
+      validator: (data) => data.previousStatus === "paused",
+    });
+
     json(res, { success: true, task: resumedTask });
     return true;
   }

package/src/linear/outbound.ts

@@ -1,12 +1,7 @@
 import { getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
 import { workflowEventBus } from "../workflows/event-bus";
 import { getLinearClient } from "./client";
-import {
-  endAgentSession,
-  postAgentSessionAction,
-  postAgentSessionThought,
-  taskSessionMap,
-} from "./sync";
+import { endAgentSession, postAgentSessionAction, taskSessionMap } from "./sync";
 
 let subscribed = false;
 
@@ -60,8 +55,9 @@ async function handleTaskProgress(data: unknown): Promise<void> {
   const sessionId = taskSessionMap.get(taskId);
   if (!sessionId) return;
 
-  postAgentSessionThought(sessionId, progress).catch((err) => {
-    console.error(`[Linear Outbound] Failed to post progress thought for task ${taskId}:`, err);
+  // Use 'action' activity type — Linear renders it as a structured tool invocation card
+  postAgentSessionAction(sessionId, progress).catch((err) => {
+    console.error(`[Linear Outbound] Failed to post progress action for task ${taskId}:`, err);
   });
 }
 
@@ -75,7 +71,9 @@ async function handleTaskCompleted(data: unknown): Promise<void> {
   if (shouldSkipForLoopPrevention(sync)) return;
 
   const sessionId = taskSessionMap.get(taskId);
-  const body = output ? `Task completed.\n\n${output.slice(0, 2000)}` : "Task completed.";
+  const body = output
+    ? `Task completed.\n\n+++ Output\n${output.slice(0, 2000)}\n+++`
+    : "Task completed.";
 
   // Prefer AgentSession activity (shows in the agent panel) over issue comment (avoids duplication)
   if (sessionId) {
@@ -93,7 +91,7 @@ async function handleTaskCompleted(data: unknown): Promise<void> {
         return;
       }
       const comment = output
-        ? `Task completed by swarm agent.\n\nOutput:\n${output.slice(0, 2000)}`
+        ? `Task completed by swarm agent.\n\n+++ Output\n${output.slice(0, 2000)}\n+++`
         : "Task completed by swarm agent.";
       await client.createComment({ issueId: sync.externalId, body: comment });
       console.log(`[Linear Outbound] Posted completion comment for task ${taskId}`);
@@ -121,7 +119,9 @@ async function handleTaskFailed(data: unknown): Promise<void> {
   if (shouldSkipForLoopPrevention(sync)) return;
 
   const sessionId = taskSessionMap.get(taskId);
-  const body = failureReason ? `Task failed.\n\n${failureReason.slice(0, 2000)}` : "Task failed.";
+  const body = failureReason
+    ? `Task failed.\n\n+++ Error Details\n${failureReason.slice(0, 2000)}\n+++`
+    : "Task failed.";
 
   // Prefer AgentSession error activity over issue comment (avoids duplication)
   if (sessionId) {
@@ -139,7 +139,7 @@ async function handleTaskFailed(data: unknown): Promise<void> {
         return;
       }
       const comment = failureReason
-        ? `Task failed.\n\nReason:\n${failureReason.slice(0, 2000)}`
+        ? `Task failed.\n\n+++ Error Details\n${failureReason.slice(0, 2000)}\n+++`
         : "Task failed.";
       await client.createComment({ issueId: sync.externalId, body: comment });
       console.log(`[Linear Outbound] Posted failure comment for task ${taskId}`);

package/src/providers/claude-adapter.ts

@@ -1,5 +1,5 @@
 import { unlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { validateClaudeCredentials } from "../utils/credentials";
 import {
   parseStderrForErrors,
@@ -48,10 +48,26 @@ async function cleanupTaskFile(pid: number): Promise<void> {
  * Returns the path to the per-session config, or null if no config exists.
  */
 async function createSessionMcpConfig(cwd: string, taskId: string): Promise<string | null> {
-  const mcpJsonPath = join(cwd, ".mcp.json");
+  // Walk up from cwd to find .mcp.json (mirrors Claude CLI's project-level config discovery).
+  // In Docker, .mcp.json lives at /workspace/.mcp.json but tasks often run with cwd set to
+  // a subdirectory like /workspace/repos/<repo>, so a single-directory check misses it.
+  let searchDir = cwd;
+  let mcpJsonPath: string | null = null;
+  while (true) {
+    const candidate = join(searchDir, ".mcp.json");
+    if (await Bun.file(candidate).exists()) {
+      mcpJsonPath = candidate;
+      break;
+    }
+    const parent = dirname(searchDir);
+    if (parent === searchDir) break; // reached filesystem root
+    searchDir = parent;
+  }
+
+  if (!mcpJsonPath) return null;
+
   try {
     const file = Bun.file(mcpJsonPath);
-    if (!(await file.exists())) return null;
 
     const config = await file.json();
     const servers = config?.mcpServers;

package/src/scheduler/scheduler.ts

@@ -1,3 +1,4 @@
+import { ensure } from "@desplega.ai/business-use";
 import { CronExpressionParser } from "cron-parser";
 import {
   createTaskExtended,
@@ -239,7 +240,11 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
  * @param registry ExecutorRegistry for triggering workflows linked to schedules
  * @param intervalMs Polling interval in milliseconds (default: 10000)
  */
-export function startScheduler(registry: ExecutorRegistry, intervalMs = 10000): void {
+export function startScheduler(
+  registry: ExecutorRegistry,
+  intervalMs = 10000,
+  opts?: { runId?: string },
+): void {
   if (schedulerInterval) {
     console.log("[Scheduler] Already running");
     return;
@@ -254,6 +259,24 @@ export function startScheduler(registry: ExecutorRegistry, intervalMs = 10000):
   schedulerInterval = setInterval(async () => {
     await processSchedules();
   }, intervalMs);
+
+  ensure({
+    id: "scheduler_started",
+    flow: "api",
+    runId: opts?.runId ?? "",
+    depIds: ["listen"],
+    data: {},
+    // biome-ignore lint/correctness/noEmptyPattern: data unused, ctx needed
+    filter: ({}, ctx) => {
+      const start = ctx.deps.find((d) => d.id === "listen");
+      return !!start && start.data?.capabilities?.includes("scheduling");
+    },
+    // biome-ignore lint/correctness/noEmptyPattern: data unused, ctx needed
+    validator: ({}, ctx) => {
+      const start = ctx.deps.find((d) => d.id === "listen");
+      return !!start && start.data?.capabilities?.includes("scheduling");
+    },
+  });
 }
 
 /**

package/src/slack/blocks.ts

@@ -179,7 +179,7 @@ export function buildProgressBlocks(opts: {
 }): SlackBlock[] {
   const shortId = opts.taskId.slice(0, 8);
   return [
-    sectionBlock(`⏳ *${opts.agentName}* (\`${shortId}\`): ${opts.progress}`),
+    sectionBlock(`*${opts.agentName}* (\`${shortId}\`): ${opts.progress}`),
     cancelActionBlock(opts.taskId),
   ];
 }

package/src/tests/approval-requests.test.ts

@@ -3,13 +3,18 @@ import { unlink } from "node:fs/promises";
 import { createServer as createHttpServer, type Server } from "node:http";
 import {
   closeDb,
+  createAgent,
   createApprovalRequest,
+  createTaskExtended,
+  getAgentCurrentTask,
   getApprovalRequestById,
   getApprovalRequestByStepId,
   getExpiredPendingApprovals,
   initDb,
   listApprovalRequests,
   resolveApprovalRequest,
+  startTask,
+  updateApprovalRequestNotifications,
 } from "../be/db";
 import type { ExecutorMeta } from "../types";
 import type { ExecutorDependencies, ExecutorInput } from "../workflows/executors/base";
@@ -543,7 +548,7 @@ describe("Approval Requests", () => {
       dryRun: false,
     };
 
-    function executorInput(
+    function _executorInput(
       config: Record<string, unknown>,
       context: Record<string, unknown> = {},
     ): ExecutorInput {
@@ -572,8 +577,11 @@ describe("Approval Requests", () => {
       });
 
       expect(result.status).toBe("success");
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).async).toBe(true);
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).waitFor).toBe("approval.resolved");
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).correlationId).toBeTruthy();
 
       // Verify the request was created in DB
@@ -608,7 +616,9 @@ describe("Approval Requests", () => {
       });
 
       expect(result.status).toBe("success");
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).async).toBe(true);
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).correlationId).toBe(existingId);
     });
 
@@ -640,6 +650,7 @@ describe("Approval Requests", () => {
       });
 
       expect(result.status).toBe("success");
+      // biome-ignore lint/suspicious/noExplicitAny: test assertion on untyped executor result
       expect((result as any).async).toBeUndefined();
       expect(result.output).toBeDefined();
       expect(result.output!.requestId).toBe(existingId);
@@ -732,4 +743,206 @@ describe("Approval Requests", () => {
       expect(result.status).toBe("failed");
     });
   });
+
+  // ─── Follow-up task flow ─────────────────────────────────────
+  describe("Follow-up task: Slack metadata inheritance", () => {
+    test("sourceTaskId is stored and returned on resolved approval request", () => {
+      // Create a source task with Slack metadata
+      const agent = createAgent({
+        name: "test-follow-up-agent",
+        isLead: false,
+        status: "idle",
+      });
+      const sourceTask = createTaskExtended("original task with slack context", {
+        agentId: agent.id,
+        source: "mcp",
+        slackChannelId: "C_TEST_CHANNEL",
+        slackThreadTs: "1234567890.123456",
+        slackUserId: "U_TEST_USER",
+      });
+
+      // Create approval request linked to source task
+      const approvalData = makeApprovalData({ sourceTaskId: sourceTask.id });
+      const approval = createApprovalRequest(approvalData);
+      expect(approval.sourceTaskId).toBe(sourceTask.id);
+
+      // Resolve it
+      const resolved = resolveApprovalRequest(approval.id, {
+        status: "approved",
+        responses: { q1: { approved: true } },
+      });
+      expect(resolved).not.toBeNull();
+      expect(resolved!.sourceTaskId).toBe(sourceTask.id);
+    });
+
+    test("follow-up task inherits Slack metadata from source task via parentTaskId", () => {
+      const agent = createAgent({
+        name: "test-slack-inherit-agent",
+        isLead: false,
+        status: "idle",
+      });
+      const sourceTask = createTaskExtended("source task", {
+        agentId: agent.id,
+        source: "mcp",
+        slackChannelId: "C_FOLLOW_UP",
+        slackThreadTs: "9999999999.000000",
+        slackUserId: "U_FOLLOW_UP",
+      });
+
+      // Simulate what the respond handler does: create follow-up with parentTaskId
+      const followUp = createTaskExtended("follow-up task text", {
+        agentId: sourceTask.agentId ?? undefined,
+        parentTaskId: sourceTask.id,
+        source: "system",
+        taskType: "hitl-follow-up",
+        tags: ["hitl", "follow-up"],
+        // Explicit Slack metadata (as the handler now does)
+        slackChannelId: sourceTask.slackChannelId ?? undefined,
+        slackThreadTs: sourceTask.slackThreadTs ?? undefined,
+        slackUserId: sourceTask.slackUserId ?? undefined,
+      });
+
+      expect(followUp.slackChannelId).toBe("C_FOLLOW_UP");
+      expect(followUp.slackThreadTs).toBe("9999999999.000000");
+      expect(followUp.slackUserId).toBe("U_FOLLOW_UP");
+      expect(followUp.parentTaskId).toBe(sourceTask.id);
+      expect(followUp.taskType).toBe("hitl-follow-up");
+    });
+
+    test("follow-up task inherits Slack metadata even without explicit pass (auto-inheritance)", () => {
+      const agent = createAgent({
+        name: "test-auto-inherit-agent",
+        isLead: false,
+        status: "idle",
+      });
+      const sourceTask = createTaskExtended("source task auto", {
+        agentId: agent.id,
+        source: "mcp",
+        slackChannelId: "C_AUTO",
+        slackThreadTs: "1111111111.000000",
+        slackUserId: "U_AUTO",
+      });
+
+      // Without explicit Slack metadata — relies on auto-inheritance from parentTaskId
+      const followUp = createTaskExtended("auto-inherit follow-up", {
+        agentId: sourceTask.agentId ?? undefined,
+        parentTaskId: sourceTask.id,
+        source: "system",
+        taskType: "hitl-follow-up",
+      });
+
+      expect(followUp.slackChannelId).toBe("C_AUTO");
+      expect(followUp.slackThreadTs).toBe("1111111111.000000");
+      expect(followUp.slackUserId).toBe("U_AUTO");
+    });
+
+    test("no follow-up for workflow-linked requests (workflowRunId set)", () => {
+      const approvalData = makeApprovalData({
+        sourceTaskId: crypto.randomUUID(),
+        workflowRunId: crypto.randomUUID(),
+        workflowRunStepId: crypto.randomUUID(),
+      });
+      const approval = createApprovalRequest(approvalData);
+
+      // The condition in the handler is: !updated.workflowRunId && updated.sourceTaskId
+      // With workflowRunId set, this should be false
+      expect(approval.workflowRunId).toBeTruthy();
+      expect(approval.sourceTaskId).toBeTruthy();
+      // The handler would NOT create a follow-up task here
+      expect(!approval.workflowRunId && approval.sourceTaskId).toBe(false);
+    });
+
+    test("no follow-up when sourceTaskId is missing", () => {
+      const approvalData = makeApprovalData(); // no sourceTaskId
+      const approval = createApprovalRequest(approvalData);
+
+      expect(approval.sourceTaskId).toBeNull();
+      // The handler condition would be false
+      expect(!approval.workflowRunId && approval.sourceTaskId).toBeFalsy();
+    });
+  });
+
+  // ─── Server-side sourceTaskId fallback ───────────────────────
+  describe("getAgentCurrentTask fallback for sourceTaskId", () => {
+    test("returns the most recent in-progress task for an agent", () => {
+      const agent = createAgent({
+        name: "test-current-task-agent",
+        isLead: true,
+        status: "idle",
+      });
+
+      // Create a task and set it to in_progress
+      const task = createTaskExtended("lead agent task", {
+        agentId: agent.id,
+        source: "mcp",
+      });
+      startTask(task.id);
+
+      const currentTask = getAgentCurrentTask(agent.id);
+      expect(currentTask).not.toBeNull();
+      expect(currentTask!.id).toBe(task.id);
+    });
+
+    test("returns null when agent has no in-progress tasks", () => {
+      const agent = createAgent({
+        name: "test-no-task-agent",
+        isLead: true,
+        status: "idle",
+      });
+
+      const currentTask = getAgentCurrentTask(agent.id);
+      expect(currentTask).toBeNull();
+    });
+
+    test("fallback sourceTaskId resolves correctly for approval request", () => {
+      const agent = createAgent({
+        name: "test-fallback-agent",
+        isLead: true,
+        status: "idle",
+      });
+      const task = createTaskExtended("lead task calling request-human-input", {
+        agentId: agent.id,
+        source: "mcp",
+        slackChannelId: "C_LEAD_CHANNEL",
+        slackThreadTs: "1111111111.000000",
+        slackUserId: "U_LEAD_USER",
+      });
+      startTask(task.id);
+
+      // Simulate what the fixed request-human-input tool does:
+      // sourceTaskId from header is missing, so fall back to agent's current task
+      const headerSourceTaskId: string | undefined = undefined;
+      let sourceTaskId = headerSourceTaskId;
+      if (!sourceTaskId) {
+        const currentTask = getAgentCurrentTask(agent.id);
+        if (currentTask) {
+          sourceTaskId = currentTask.id;
+        }
+      }
+
+      const approval = createApprovalRequest(makeApprovalData({ sourceTaskId }));
+      expect(approval.sourceTaskId).toBe(task.id);
+    });
+  });
+
+  describe("updateApprovalRequestNotifications", () => {
+    test("stores messageTs back in notification channels", () => {
+      const channels = [
+        { channel: "slack", target: "C12345" },
+        { channel: "email", target: "user@example.com" },
+      ];
+      const approval = createApprovalRequest(makeApprovalData({ notificationChannels: channels }));
+      expect(approval.notificationChannels).toEqual(channels);
+
+      const updatedChannels = [
+        { channel: "slack", target: "C12345", messageTs: "1234567890.123456" },
+        { channel: "email", target: "user@example.com" },
+      ];
+      updateApprovalRequestNotifications(approval.id, updatedChannels);
+
+      const fetched = getApprovalRequestById(approval.id);
+      expect(fetched).not.toBeNull();
+      expect(fetched!.notificationChannels).toEqual(updatedChannels);
+    });
+  });
 });

package/src/tests/skill-sync.test.ts

@@ -97,7 +97,7 @@ describe("syncSkillsToFilesystem", () => {
   });
 
   test("skips complex skills", () => {
-    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+    const _result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
 
     const complexDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
     expect(existsSync(complexDir)).toBe(false);

package/src/tests/slack-blocks.test.ts

@@ -145,9 +145,10 @@ describe("buildProgressBlocks", () => {
     });
 
     expect(blocks.length).toBe(2);
-    // Single line: ⏳ *Gamma* (`aabbccdd`): Analyzing codebase...
+    // Single line: *Gamma* (`aabbccdd`): Analyzing codebase...
+    // (no ⏳ prefix — progress strings now carry their own emoji)
     expect(blocks[0].type).toBe("section");
-    expect(blocks[0].text.text).toContain("⏳");
+    expect(blocks[0].text.text).not.toContain("⏳");
     expect(blocks[0].text.text).toContain("Gamma");
     expect(blocks[0].text.text).toContain("aabbccdd");
     expect(blocks[0].text.text).toContain("Analyzing codebase...");

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

@@ -233,6 +233,7 @@ describe("AgentTaskConfigSchema — outputSchema", () => {
   test("accepts outputSchema 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,