@desplega.ai/agent-swarm 1.59.3 → 1.61.0

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.59.3",
+    "version": "1.61.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.59.3",
+  "version": "1.61.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

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { addEyesReactionOnTaskStart } from "../github/task-reactions";
 import { configureDbResolver } from "../prompts/resolver";
 import type {
   ActiveSession,
@@ -709,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;
@@ -716,6 +718,8 @@ type AgentTaskRow = {
   vcsCommentId: number | null;
   vcsAuthor: string | null;
   vcsUrl: string | null;
+  vcsInstallationId: number | null;
+  vcsNodeId: string | null;
   agentmailInboxId: string | null;
   agentmailMessageId: string | null;
   agentmailThreadId: string | null;
@@ -765,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,
@@ -772,6 +777,8 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     vcsCommentId: row.vcsCommentId ?? undefined,
     vcsAuthor: row.vcsAuthor ?? undefined,
     vcsUrl: row.vcsUrl ?? undefined,
+    vcsInstallationId: row.vcsInstallationId ?? undefined,
+    vcsNodeId: row.vcsNodeId ?? undefined,
     agentmailInboxId: row.agentmailInboxId ?? undefined,
     agentmailMessageId: row.agentmailMessageId ?? undefined,
     agentmailThreadId: row.agentmailThreadId ?? undefined,
@@ -950,7 +957,12 @@ export function startTask(taskId: string): AgentTask | null {
       });
     } catch {}
   }
-  return row ? rowToAgentTask(row) : null;
+  const result = row ? rowToAgentTask(row) : null;
+  // Fire-and-forget: add eyes reaction for GitHub-sourced tasks
+  if (result && oldTask.status !== "in_progress") {
+    addEyesReactionOnTaskStart(result).catch(() => {});
+  }
+  return result;
 }
 
 export function getTaskById(id: string): AgentTask | null {
@@ -958,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,
@@ -1800,6 +1825,8 @@ export interface CreateTaskOptions {
   vcsCommentId?: number;
   vcsAuthor?: string;
   vcsUrl?: string;
+  vcsInstallationId?: number;
+  vcsNodeId?: string;
   agentmailInboxId?: string;
   agentmailMessageId?: string;
   agentmailThreadId?: string;
@@ -1906,10 +1933,11 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
         taskType, tags, priority, dependsOn, offeredTo, offeredAt,
         slackChannelId, slackThreadTs, slackUserId,
         vcsProvider, vcsRepo, vcsEventType, vcsNumber, vcsCommentId, vcsAuthor, vcsUrl,
+        vcsInstallationId, vcsNodeId,
         agentmailInboxId, agentmailMessageId, agentmailThreadId,
         mentionMessageId, mentionChannelId, dir, parentTaskId, model, scheduleId,
         workflowRunId, workflowRunStepId, outputSchema, requestedByUserId, createdAt, lastUpdatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
     )
     .get(
       id,
@@ -1934,6 +1962,8 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
       options?.vcsCommentId ?? null,
       options?.vcsAuthor ?? null,
       options?.vcsUrl ?? null,
+      options?.vcsInstallationId ?? null,
+      options?.vcsNodeId ?? null,
       options?.agentmailInboxId ?? null,
       options?.agentmailMessageId ?? null,
       options?.agentmailThreadId ?? null,
@@ -2005,7 +2035,12 @@ export function claimTask(taskId: string, agentId: string): AgentTask | null {
     } catch {}
   }
 
-  return row ? rowToAgentTask(row) : null;
+  const result = row ? rowToAgentTask(row) : null;
+  // Fire-and-forget: add eyes reaction for GitHub-sourced tasks
+  if (result) {
+    addEyesReactionOnTaskStart(result).catch(() => {});
+  }
+  return result;
 }
 
 export function releaseTask(taskId: string): AgentTask | null {

package/src/be/migrations/033_vcs_installation_node_id.sql

@@ -0,0 +1,4 @@
+-- Add GitHub installation ID and GraphQL node ID to tasks
+-- Needed for adding reactions (eyes emoji) when agents pick up GitHub-sourced tasks
+ALTER TABLE agent_tasks ADD COLUMN vcsInstallationId INTEGER;
+ALTER TABLE agent_tasks ADD COLUMN vcsNodeId TEXT;

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/github/handlers.ts

@@ -183,6 +183,7 @@ export async function handlePullRequest(
       vcsAuthor: sender.login,
       requestedByUserId,
       vcsUrl: pr.html_url,
+      vcsInstallationId: installation?.id,
     });
 
     if (lead) {
@@ -281,6 +282,7 @@ export async function handlePullRequest(
       vcsAuthor: sender.login,
       requestedByUserId,
       vcsUrl: pr.html_url,
+      vcsInstallationId: installation?.id,
     });
 
     if (lead) {
@@ -371,6 +373,7 @@ export async function handlePullRequest(
       vcsAuthor: sender.login,
       requestedByUserId,
       vcsUrl: pr.html_url,
+      vcsInstallationId: installation?.id,
     });
 
     if (lead) {
@@ -458,6 +461,7 @@ export async function handlePullRequest(
     vcsNumber: pr.number,
     vcsAuthor: sender.login,
     vcsUrl: pr.html_url,
+    vcsInstallationId: installation?.id,
   });
 
   if (lead) {
@@ -531,6 +535,7 @@ export async function handleIssue(
       vcsAuthor: sender.login,
       requestedByUserId,
       vcsUrl: issue.html_url,
+      vcsInstallationId: installation?.id,
     });
 
     if (lead) {
@@ -617,6 +622,7 @@ export async function handleIssue(
       vcsAuthor: sender.login,
       requestedByUserId,
       vcsUrl: issue.html_url,
+      vcsInstallationId: installation?.id,
     });
 
     if (lead) {
@@ -686,6 +692,7 @@ export async function handleIssue(
     vcsNumber: issue.number,
     vcsAuthor: sender.login,
     vcsUrl: issue.html_url,
+    vcsInstallationId: installation?.id,
   });
 
   if (lead) {
@@ -784,6 +791,8 @@ export async function handleComment(
     vcsCommentId: comment.id,
     vcsAuthor: sender.login,
     vcsUrl: targetUrl,
+    vcsInstallationId: installation?.id,
+    vcsNodeId: comment.node_id,
   });
 
   if (lead) {
@@ -896,6 +905,8 @@ export async function handlePullRequestReview(
     vcsNumber: pr.number,
     vcsAuthor: sender.login,
     vcsUrl: review.html_url,
+    vcsInstallationId: installation?.id,
+    vcsNodeId: review.node_id,
   });
 
   if (lead) {

package/src/github/reactions.ts

@@ -102,6 +102,125 @@ export async function addIssueReaction(
   }
 }
 
+/**
+ * Add a reaction to a PR review comment (inline comment on a diff)
+ * Uses the pulls/comments endpoint (different from issues/comments)
+ */
+export async function addPullReviewCommentReaction(
+  repo: string,
+  commentId: number,
+  reaction: ReactionType,
+  installationId: number,
+): Promise<boolean> {
+  if (!isReactionsEnabled()) {
+    console.log("[GitHub] Reactions not enabled, skipping");
+    return false;
+  }
+
+  const token = await getInstallationToken(installationId);
+  if (!token) {
+    console.log("[GitHub] No installation token, skipping reaction");
+    return false;
+  }
+
+  try {
+    const response = await fetch(
+      `https://api.github.com/repos/${repo}/pulls/comments/${commentId}/reactions`,
+      {
+        method: "POST",
+        headers: {
+          Accept: "application/vnd.github+json",
+          Authorization: `Bearer ${token}`,
+          "X-GitHub-Api-Version": "2022-11-28",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ content: reaction }),
+      },
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        `[GitHub] Failed to add PR review comment reaction: ${response.status} ${errorText}`,
+      );
+      return false;
+    }
+
+    console.log(`[GitHub] Added ${reaction} reaction to PR review comment ${commentId}`);
+    return true;
+  } catch (error) {
+    console.error("[GitHub] Error adding PR review comment reaction:", error);
+    return false;
+  }
+}
+
+/**
+ * Add a reaction via the GraphQL API (for PR review bodies which REST doesn't support)
+ * Requires the node_id of the subject
+ */
+export async function addGraphQLReaction(
+  nodeId: string,
+  reaction:
+    | "THUMBS_UP"
+    | "THUMBS_DOWN"
+    | "LAUGH"
+    | "HOORAY"
+    | "CONFUSED"
+    | "HEART"
+    | "ROCKET"
+    | "EYES",
+  installationId: number,
+): Promise<boolean> {
+  if (!isReactionsEnabled()) {
+    console.log("[GitHub] Reactions not enabled, skipping");
+    return false;
+  }
+
+  const token = await getInstallationToken(installationId);
+  if (!token) {
+    console.log("[GitHub] No installation token, skipping GraphQL reaction");
+    return false;
+  }
+
+  try {
+    const response = await fetch("https://api.github.com/graphql", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        query: `mutation AddReaction($input: AddReactionInput!) {
+          addReaction(input: $input) {
+            reaction { content }
+          }
+        }`,
+        variables: {
+          input: { subjectId: nodeId, content: reaction },
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[GitHub] GraphQL reaction failed: ${response.status} ${errorText}`);
+      return false;
+    }
+
+    const data = (await response.json()) as { errors?: Array<{ message: string }> };
+    if (data.errors?.length) {
+      console.error(`[GitHub] GraphQL reaction errors: ${JSON.stringify(data.errors)}`);
+      return false;
+    }
+
+    console.log(`[GitHub] Added ${reaction} GraphQL reaction to node ${nodeId}`);
+    return true;
+  } catch (error) {
+    console.error("[GitHub] Error adding GraphQL reaction:", error);
+    return false;
+  }
+}
+
 /**
  * Post a comment on an issue or PR
  * Appears as agent-swarm-bot[bot] commenting

package/src/github/task-reactions.ts

@@ -0,0 +1,66 @@
+import type { AgentTask } from "../types";
+import {
+  addGraphQLReaction,
+  addIssueReaction,
+  addPullReviewCommentReaction,
+  addReaction,
+} from "./reactions";
+
+/**
+ * Add an 👀 eyes reaction to the source GitHub comment/review when a task starts.
+ * Called when a task transitions to `in_progress`.
+ *
+ * Handles three GitHub event types:
+ * - issue_comment: REST reaction on issue comment
+ * - pull_request_review_comment: REST reaction on PR review comment (inline)
+ * - pull_request_review: GraphQL reaction on review body (REST doesn't support review reactions)
+ */
+export async function addEyesReactionOnTaskStart(task: AgentTask): Promise<void> {
+  // Only for GitHub-sourced tasks with installation info
+  if (task.source !== "github" || task.vcsProvider !== "github") return;
+  if (!task.vcsInstallationId) return;
+
+  const installationId = task.vcsInstallationId;
+  const repo = task.vcsRepo;
+  if (!repo) return;
+
+  try {
+    switch (task.vcsEventType) {
+      case "issue_comment": {
+        // Issue comment — use REST issues/comments endpoint
+        if (task.vcsCommentId) {
+          await addReaction(repo, task.vcsCommentId, "eyes", installationId);
+        }
+        break;
+      }
+
+      case "pull_request_review_comment": {
+        // Inline PR review comment — use REST pulls/comments endpoint
+        if (task.vcsCommentId) {
+          await addPullReviewCommentReaction(repo, task.vcsCommentId, "eyes", installationId);
+        }
+        break;
+      }
+
+      case "pull_request_review": {
+        // PR review body — requires GraphQL API
+        if (task.vcsNodeId) {
+          await addGraphQLReaction(task.vcsNodeId, "EYES", installationId);
+        }
+        break;
+      }
+
+      case "pull_request":
+      case "issues": {
+        // PR or issue opened/labeled — react on the issue/PR itself
+        if (task.vcsNumber) {
+          await addIssueReaction(repo, task.vcsNumber, "eyes", installationId);
+        }
+        break;
+      }
+    }
+  } catch (error) {
+    // Never fail the task start due to a reaction error
+    console.error("[GitHub] Failed to add eyes reaction on task start:", error);
+  }
+}

package/src/github/types.ts

@@ -37,6 +37,7 @@ export interface IssueEvent extends GitHubWebhookEvent {
 export interface CommentEvent extends GitHubWebhookEvent {
   comment: {
     id: number;
+    node_id?: string;
     body: string;
     html_url: string;
     user: { login: string };
@@ -49,6 +50,7 @@ export interface PullRequestReviewEvent extends GitHubWebhookEvent {
   action: "submitted" | "edited" | "dismissed";
   review: {
     id: number;
+    node_id?: string;
     body: string | null;
     state: "approved" | "changes_requested" | "commented" | "dismissed";
     html_url: string;

package/src/slack/HEURISTICS.md

@@ -17,6 +17,7 @@ When someone @mentions the bot in a thread, the router checks whether a worker a
 - Message must be in a thread (`thread_ts` present)
 - An agent must have an active task (`in_progress` or `pending`) linked to that thread via `slackChannelId` + `slackThreadTs`
 - The matched agent must not be `offline`
+- If `SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION=true`, non-mention thread messages are silently dropped instead of routing to the working agent. DM assistant threads are unaffected.
 
 **Why this matters:** Without thread follow-up routing, every @mention in a thread goes to the lead, who then has to re-delegate. This shortcut sends the message directly to the worker already handling that conversation.
 
@@ -89,6 +90,7 @@ When the additive buffer flushes normally (not via `!now`), the created task use
 |------|---------|-------------|
 | `ADDITIVE_SLACK` | `false` | Enables non-mention thread message buffering and batching |
 | `ADDITIVE_SLACK_BUFFER_MS` | `10000` (10s) | Debounce window in milliseconds for the thread buffer |
+| `SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION` | `false` | Requires @mention for thread follow-up routing; non-mention thread messages are silently dropped |
 
 Both are read from environment variables. `ADDITIVE_SLACK` must be exactly `"true"` to enable. `ADDITIVE_SLACK_BUFFER_MS` is parsed as a number with fallback to 10000.
 

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;
+}