@desplega.ai/agent-swarm 1.60.0 → 1.62.0

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.60.0",
+    "version": "1.62.0",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.60.0",
+  "version": "1.62.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/be/db.ts

@@ -710,6 +710,7 @@ type AgentTaskRow = {
   slackChannelId: string | null;
   slackThreadTs: string | null;
   slackUserId: string | null;
+  slackReplySent: number;
   vcsProvider: string | null;
   vcsRepo: string | null;
   vcsEventType: string | null;
@@ -768,6 +769,7 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     slackChannelId: row.slackChannelId ?? undefined,
     slackThreadTs: row.slackThreadTs ?? undefined,
     slackUserId: row.slackUserId ?? undefined,
+    slackReplySent: !!row.slackReplySent,
     vcsProvider: (row.vcsProvider as "github" | "gitlab" | null) ?? undefined,
     vcsRepo: row.vcsRepo ?? undefined,
     vcsEventType: row.vcsEventType ?? undefined,
@@ -968,6 +970,19 @@ export function getTaskById(id: string): AgentTask | null {
   return row ? rowToAgentTask(row) : null;
 }
 
+export function markTaskSlackReplySent(taskId: string): void {
+  getDb().run(`UPDATE agent_tasks SET slackReplySent = 1 WHERE id = ?`, [taskId]);
+}
+
+export function getChildTasks(parentTaskId: string): AgentTask[] {
+  return getDb()
+    .prepare<AgentTaskRow, [string]>(
+      `SELECT * FROM agent_tasks WHERE parentTaskId = ? ORDER BY createdAt ASC`,
+    )
+    .all(parentTaskId)
+    .map(rowToAgentTask);
+}
+
 export function updateTaskClaudeSessionId(
   taskId: string,
   claudeSessionId: string,

package/src/be/migrations/034_slack_reply_sent.sql

@@ -0,0 +1,4 @@
+ALTER TABLE agent_tasks ADD COLUMN slackReplySent INTEGER DEFAULT 0;
+
+-- Index on parentTaskId for getChildTasks() query (Phase 4)
+CREATE INDEX IF NOT EXISTS idx_agent_tasks_parentTaskId ON agent_tasks(parentTaskId);

package/src/slack/blocks.ts

@@ -128,6 +128,38 @@ function cancelActionBlock(taskId: string): SlackBlock {
   };
 }
 
+// --- Utilities ---
+
+/**
+ * Format a duration between two dates in a compact human-readable form.
+ * Examples: "45s", "2m 14s", "1h 30m"
+ */
+export function formatDuration(start: Date, end: Date): string {
+  const ms = end.getTime() - start.getTime();
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+// --- Tree types ---
+
+export interface TreeNode {
+  taskId: string;
+  agentName: string;
+  status: "pending" | "in_progress" | "completed" | "failed" | "cancelled";
+  progress?: string;
+  duration?: string;
+  slackReplySent?: boolean;
+  output?: string; // Only used when !slackReplySent on completion
+  failureReason?: string; // Always shown on failure
+  children: TreeNode[];
+}
+
 // --- High-level block builders ---
 
 /**
@@ -139,14 +171,19 @@ export function buildCompletedBlocks(opts: {
   taskId: string;
   body: string;
   duration?: string;
+  minimal?: boolean; // true = suppress body (agent already replied via slack-reply)
 }): SlackBlock[] {
   const taskLink = getTaskLink(opts.taskId);
   let line = `✅ *${opts.agentName}* (${taskLink})`;
   if (opts.duration) line += ` · ${opts.duration}`;
 
   const blocks: SlackBlock[] = [sectionBlock(line)];
-  for (const chunk of splitText(opts.body)) {
-    blocks.push(sectionBlock(chunk));
+
+  // Only include body if not minimal (agent didn't reply via slack-reply)
+  if (!opts.minimal) {
+    for (const chunk of splitText(opts.body)) {
+      blocks.push(sectionBlock(chunk));
+    }
   }
   return blocks;
 }
@@ -231,3 +268,143 @@ export function buildBufferFlushBlocks(opts: {
 
   return [contextBlock(`📡 _${text}_ (${taskLink})`)];
 }
+
+// --- Tree rendering ---
+
+const STATUS_ICON: Record<TreeNode["status"], string> = {
+  pending: "📡",
+  in_progress: "⏳",
+  completed: "✅",
+  failed: "❌",
+  cancelled: "🚫",
+};
+
+const MAX_VISIBLE_CHILDREN = 8;
+const MAX_OUTPUT_LENGTH = 120;
+
+/**
+ * Truncate output to the first sentence or MAX_OUTPUT_LENGTH, whichever is shorter.
+ */
+function truncateOutput(text: string): string {
+  // Find first sentence boundary (. followed by space or end)
+  const sentenceEnd = text.search(/\.\s/);
+  const firstSentence = sentenceEnd !== -1 ? text.slice(0, sentenceEnd + 1) : text;
+  if (firstSentence.length <= MAX_OUTPUT_LENGTH) return firstSentence;
+  return `${text.slice(0, MAX_OUTPUT_LENGTH)}…`;
+}
+
+/**
+ * Render a single node line: icon + bold name + task link + optional duration.
+ */
+function renderNodeLine(node: TreeNode): string {
+  const icon = STATUS_ICON[node.status];
+  const taskLink = getTaskLink(node.taskId);
+  let line = `${icon} *${node.agentName}* (${taskLink})`;
+  if (node.duration) line += ` · ${node.duration}`;
+  return line;
+}
+
+/**
+ * Render detail lines for a child node (progress, output, failure reason).
+ * Returns an array of indented lines to appear below the child's main line.
+ */
+function renderChildDetail(node: TreeNode, indent: string): string[] {
+  const lines: string[] = [];
+
+  if (node.status === "failed" && node.failureReason) {
+    lines.push(`${indent}Error: ${node.failureReason}`);
+  }
+
+  if (node.status === "in_progress" && node.progress) {
+    lines.push(`${indent}${node.progress}`);
+  }
+
+  if (node.status === "completed" && !node.slackReplySent && node.output) {
+    lines.push(`${indent}${truncateOutput(node.output)}`);
+  }
+
+  return lines;
+}
+
+/**
+ * Render a single root node and its children as a mrkdwn tree string.
+ */
+function renderTree(root: TreeNode): string {
+  const lines: string[] = [];
+
+  // Root line
+  lines.push(renderNodeLine(root));
+
+  // Root-level detail (progress for in-progress root with no children)
+  if (root.children.length === 0) {
+    if (root.status === "in_progress" && root.progress) {
+      lines.push(`    ${root.progress}`);
+    }
+    if (root.status === "failed" && root.failureReason) {
+      lines.push(`    Error: ${root.failureReason}`);
+    }
+    if (root.status === "completed" && !root.slackReplySent && root.output) {
+      lines.push(`    ${truncateOutput(root.output)}`);
+    }
+    return lines.join("\n");
+  }
+
+  const visibleChildren = root.children.slice(0, MAX_VISIBLE_CHILDREN);
+  const hiddenCount = root.children.length - visibleChildren.length;
+
+  for (let i = 0; i < visibleChildren.length; i++) {
+    const child = visibleChildren[i] as TreeNode;
+    const isLast = i === visibleChildren.length - 1 && hiddenCount === 0;
+    const prefix = isLast ? "└ " : "├ ";
+    const continuationPrefix = isLast ? "    " : "│   ";
+
+    lines.push(`${prefix}${renderNodeLine(child)}`);
+
+    for (const detail of renderChildDetail(child, continuationPrefix)) {
+      lines.push(detail);
+    }
+  }
+
+  if (hiddenCount > 0) {
+    lines.push(`└ _and ${hiddenCount} more..._`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Check if any node in the tree is still active (pending or in_progress).
+ */
+function isTreeActive(node: TreeNode): boolean {
+  if (node.status === "pending" || node.status === "in_progress") return true;
+  return node.children.some(isTreeActive);
+}
+
+/**
+ * Build Slack blocks for a tree-based status message.
+ *
+ * Renders one or more root nodes as mrkdwn trees with status icons,
+ * agent names, task links, durations, progress text, and error details.
+ *
+ * For in-progress trees, includes a cancel button per active root.
+ *
+ * @param roots - Array of root TreeNode objects (one per assigned task in a round)
+ * @returns SlackBlock[] suitable for chat.postMessage / chat.update
+ */
+export function buildTreeBlocks(roots: TreeNode[]): SlackBlock[] {
+  console.log(
+    `[Slack] Building tree blocks for ${roots.length} root(s): ${roots.map((r) => r.taskId.slice(0, 8)).join(", ")}`,
+  );
+
+  const treeTexts = roots.map(renderTree);
+  const blocks: SlackBlock[] = [sectionBlock(treeTexts.join("\n\n"))];
+
+  // Add cancel buttons for active roots
+  for (const root of roots) {
+    if (isTreeActive(root)) {
+      blocks.push(cancelActionBlock(root.taskId));
+    }
+  }
+
+  return blocks;
+}

package/src/slack/handlers.ts

@@ -11,13 +11,13 @@ import {
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { workflowEventBus } from "../workflows/event-bus";
-import { buildAssignmentSummaryBlocks } from "./blocks";
+import { buildTreeBlocks, type TreeNode } from "./blocks";
 import type { SlackFile } from "./files";
 import { extractTaskFromMessage, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
-import { registerTaskMessage } from "./watcher";
+import { registerTreeMessage } from "./watcher";
 
 // User filtering configuration from environment variables
 const allowedEmailDomains = (process.env.SLACK_ALLOWED_EMAIL_DOMAINS || "")
@@ -591,9 +591,40 @@ export function registerMessageHandler(app: App): void {
       }
     }
 
-    // Send consolidated summary with Block Kit
+    // Send consolidated summary as initial tree with Block Kit
     const totalResults = results.assigned.length + results.queued.length + results.failed.length;
     if (totalResults > 0) {
+      // Build initial tree nodes from assignment results
+      const initialNodes: TreeNode[] = results.assigned.map(({ agentName, taskId }) => ({
+        taskId,
+        agentName,
+        status: "in_progress" as const,
+        children: [],
+      }));
+
+      // Add queued tasks
+      for (const q of results.queued) {
+        initialNodes.push({
+          taskId: q.taskId,
+          agentName: q.agentName,
+          status: "pending" as const,
+          children: [],
+        });
+      }
+
+      const blocks = buildTreeBlocks(initialNodes);
+
+      // Append failed assignment lines as context below the tree
+      if (results.failed.length > 0) {
+        const failedLines = results.failed
+          .map((f) => `⚠️ Could not assign to: *${f.agentName}* — ${f.reason}`)
+          .join("\n");
+        blocks.push({
+          type: "context",
+          elements: [{ type: "mrkdwn", text: failedLines }],
+        });
+      }
+
       // Build plain-text fallback
       const parts: string[] = [];
       if (results.assigned.length > 0) {
@@ -609,17 +640,25 @@ export function registerMessageHandler(app: App): void {
         parts.push(`Could not assign to: ${names}`);
       }
 
+      console.log(
+        `[Slack] Posting initial tree message with ${initialNodes.length} node(s)${results.failed.length > 0 ? ` and ${results.failed.length} failed assignment(s)` : ""}`,
+      );
+
       const resp = await say({
         text: parts.join(". "),
-        blocks: buildAssignmentSummaryBlocks(results),
+        blocks,
         thread_ts: msg.thread_ts || msg.ts,
       });
 
-      // Register the assignment message so the watcher can update it in-place
-      // (assignment → progress → completion all in one evolving message)
+      // Register the tree message so the watcher can update it in-place
+      // (assignment → progress → completion all in one evolving tree message)
       if (resp?.ts) {
         for (const { taskId } of results.assigned) {
-          registerTaskMessage(taskId, msg.channel, threadTs, resp.ts);
+          registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
+        }
+        // Also register queued tasks so they appear in the tree when they start
+        for (const { taskId } of results.queued) {
+          registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
         }
       }
     }

package/src/slack/responses.ts

@@ -7,6 +7,7 @@ import {
   buildCompletedBlocks,
   buildFailedBlocks,
   buildProgressBlocks,
+  formatDuration,
   markdownToSlack,
 } from "./blocks";
 
@@ -49,11 +50,24 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
     if (task.status === "completed") {
       const output = task.output || "Task completed.";
       const slackOutput = markdownToSlack(output);
-      const blocks = buildCompletedBlocks({ agentName, taskId: task.id, body: slackOutput });
+      const duration =
+        task.finishedAt && task.createdAt
+          ? formatDuration(new Date(task.createdAt), new Date(task.finishedAt))
+          : undefined;
+      console.log(
+        `[Slack] sendTaskResponse: task=${task.id} slackReplySent=${!!task.slackReplySent} minimal=${!!task.slackReplySent}`,
+      );
+      const blocks = buildCompletedBlocks({
+        agentName,
+        taskId: task.id,
+        body: slackOutput,
+        duration,
+        minimal: !!task.slackReplySent,
+      });
       await sendWithPersona(client, {
         channel: task.slackChannelId,
         thread_ts: task.slackThreadTs,
-        text: slackOutput,
+        text: task.slackReplySent ? `✅ ${agentName} completed` : slackOutput,
         username: getAgentDisplayName(agent),
         icon_emoji: getAgentEmoji(agent),
         blocks,
@@ -161,8 +175,21 @@ export async function updateToFinal(task: AgentTask, messageTs: string): Promise
   if (task.status === "completed") {
     const output = task.output || "Task completed.";
     const slackOutput = markdownToSlack(output);
-    blocks = buildCompletedBlocks({ agentName, taskId: task.id, body: slackOutput });
-    text = slackOutput;
+    const duration =
+      task.finishedAt && task.createdAt
+        ? formatDuration(new Date(task.createdAt), new Date(task.finishedAt))
+        : undefined;
+    console.log(
+      `[Slack] updateToFinal: task=${task.id} slackReplySent=${!!task.slackReplySent} minimal=${!!task.slackReplySent}`,
+    );
+    blocks = buildCompletedBlocks({
+      agentName,
+      taskId: task.id,
+      body: slackOutput,
+      duration,
+      minimal: !!task.slackReplySent,
+    });
+    text = task.slackReplySent ? `✅ ${agentName} completed` : slackOutput;
   } else if (task.status === "cancelled") {
     blocks = buildCancelledBlocks({ agentName, taskId: task.id });
     text = "Task cancelled";
@@ -187,6 +214,34 @@ export async function updateToFinal(task: AgentTask, messageTs: string): Promise
   }
 }
 
+/**
+ * Update a tree message directly with pre-built blocks via chat.update.
+ * Used by the watcher's tree rendering loop (Phase 5).
+ */
+export async function updateTreeMessage(
+  channelId: string,
+  messageTs: string,
+  blocks: unknown[],
+  fallbackText: string,
+): Promise<boolean> {
+  const app = getSlackApp();
+  if (!app) return false;
+
+  try {
+    await app.client.chat.update({
+      channel: channelId,
+      ts: messageTs,
+      text: fallbackText,
+      // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+      blocks: blocks as any,
+    });
+    return true;
+  } catch (error) {
+    console.error(`[Slack] Failed to update tree message:`, error);
+    return false;
+  }
+}
+
 async function sendWithPersona(
   client: WebClient,
   options: {

package/src/slack/thread-buffer.ts

@@ -6,6 +6,7 @@ import {
 } from "../be/db";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
+import { registerTreeMessage } from "./watcher";
 
 interface BufferedMessage {
   text: string;
@@ -197,13 +198,21 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
       : `${buffer.messages.length} follow-up message(s) batched into task`;
 
     try {
-      await app.client.chat.postMessage({
+      const result = await app.client.chat.postMessage({
         channel: buffer.channelId,
         thread_ts: buffer.threadTs,
         text: fallbackText,
         // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
         blocks: blocks as any,
       });
+
+      // Register the batching message as the tree message for this task
+      if (result.ts && task) {
+        registerTreeMessage(task.id, buffer.channelId, buffer.threadTs, result.ts);
+        console.log(
+          `[Slack] Registered batched task ${task.id.slice(0, 8)} tree message from buffer flush`,
+        );
+      }
     } catch (error) {
       console.error("[Slack] Failed to post buffer flush feedback:", error);
     }