@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/server.ts

@@ -2,7 +2,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import pkg from "../package.json";
 import { initDb } from "./be/db";
 import { registerCancelTaskTool } from "./tools/cancel-task";
+import { registerContextDiffTool } from "./tools/context-diff";
+import { registerContextHistoryTool } from "./tools/context-history";
 import { registerCreateChannelTool } from "./tools/create-channel";
+import { registerDbQueryTool } from "./tools/db-query";
+import { registerDeleteChannelTool } from "./tools/delete-channel";
 // Epics capability
 import {
   registerAssignTaskToEpicTool,
@@ -13,20 +17,30 @@ import {
   registerUnassignTaskFromEpicTool,
   registerUpdateEpicTool,
 } from "./tools/epics";
-// Lead inbox tools
-import { registerGetInboxMessageTool } from "./tools/get-inbox-message";
 import { registerGetSwarmTool } from "./tools/get-swarm";
 import { registerGetTaskDetailsTool } from "./tools/get-task-details";
 import { registerGetTasksTool } from "./tools/get-tasks";
-import { registerInboxDelegateTool } from "./tools/inbox-delegate";
+import { registerInjectLearningTool } from "./tools/inject-learning";
 import { registerJoinSwarmTool } from "./tools/join-swarm";
 // Messaging capability
 import { registerListChannelsTool } from "./tools/list-channels";
 import { registerListServicesTool } from "./tools/list-services";
+// Memory capability
+import { registerMemoryGetTool } from "./tools/memory-get";
+import { registerMemorySearchTool } from "./tools/memory-search";
 import { registerMyAgentInfoTool } from "./tools/my-agent-info";
 import { registerPollTaskTool } from "./tools/poll-task";
 import { registerPostMessageTool } from "./tools/post-message";
+// Prompt template tools
+import {
+  registerDeletePromptTemplateTool,
+  registerGetPromptTemplateTool,
+  registerListPromptTemplatesTool,
+  registerPreviewPromptTemplateTool,
+  registerSetPromptTemplateTool,
+} from "./tools/prompt-templates";
 import { registerReadMessagesTool } from "./tools/read-messages";
+import { registerRegisterAgentMailInboxTool } from "./tools/register-agentmail-inbox";
 // Services capability
 import { registerRegisterServiceTool } from "./tools/register-service";
 // Scheduling capability
@@ -45,16 +59,45 @@ import { registerSlackReadTool } from "./tools/slack-read";
 import { registerSlackReplyTool } from "./tools/slack-reply";
 import { registerSlackUploadFileTool } from "./tools/slack-upload-file";
 import { registerStoreProgressTool } from "./tools/store-progress";
+// Swarm config tools
+import {
+  registerDeleteConfigTool,
+  registerGetConfigTool,
+  registerListConfigTool,
+  registerSetConfigTool,
+} from "./tools/swarm-config";
 // Task pool capability
 import { registerTaskActionTool } from "./tools/task-action";
+// Tracker capability
+import {
+  registerTrackerLinkEpicTool,
+  registerTrackerLinkTaskTool,
+  registerTrackerMapAgentTool,
+  registerTrackerStatusTool,
+  registerTrackerSyncStatusTool,
+  registerTrackerUnlinkTool,
+} from "./tools/tracker";
 import { registerUnregisterServiceTool } from "./tools/unregister-service";
 // Profiles capability
 import { registerUpdateProfileTool } from "./tools/update-profile";
 import { registerUpdateServiceStatusTool } from "./tools/update-service-status";
+// Workflows capability
+import {
+  registerCreateWorkflowTool,
+  registerDeleteWorkflowTool,
+  registerGetWorkflowRunTool,
+  registerGetWorkflowTool,
+  registerListWorkflowRunsTool,
+  registerListWorkflowsTool,
+  registerRetryWorkflowRunTool,
+  registerTriggerWorkflowTool,
+  registerUpdateWorkflowTool,
+} from "./tools/workflows";
 
 // Capability-based feature flags
 // Default: all capabilities enabled
-const DEFAULT_CAPABILITIES = "core,task-pool,messaging,profiles,services,scheduling,epics";
+const DEFAULT_CAPABILITIES =
+  "core,task-pool,messaging,profiles,services,scheduling,epics,memory,workflows";
 const CAPABILITIES = new Set(
   (process.env.CAPABILITIES || DEFAULT_CAPABILITIES).split(",").map((s) => s.trim()),
 );
@@ -96,6 +139,22 @@ export function createServer() {
   registerMyAgentInfoTool(server);
   registerCancelTaskTool(server);
 
+  // Debug tools - always registered (self-guards with lead check)
+  registerDbQueryTool(server);
+
+  // Swarm config tools - always registered (config management is fundamental)
+  registerSetConfigTool(server);
+  registerGetConfigTool(server);
+  registerListConfigTool(server);
+  registerDeleteConfigTool(server);
+
+  // Prompt template tools - always registered (prompt management is fundamental)
+  registerListPromptTemplatesTool(server);
+  registerGetPromptTemplateTool(server);
+  registerSetPromptTemplateTool(server);
+  registerDeletePromptTemplateTool(server);
+  registerPreviewPromptTemplateTool(server);
+
   // Slack integration tools (always registered, will no-op if Slack not configured)
   registerSlackReplyTool(server);
   registerSlackReadTool(server);
@@ -103,8 +162,9 @@ export function createServer() {
   registerSlackListChannelsTool(server);
   registerSlackUploadFileTool(server);
   registerSlackDownloadFileTool(server);
-  registerInboxDelegateTool(server);
-  registerGetInboxMessageTool(server);
+
+  // AgentMail integration tool (always registered, self-service inbox mapping)
+  registerRegisterAgentMailInboxTool(server);
 
   // Task pool capability - task pool operations (create unassigned, claim, release, accept, reject)
   if (hasCapability("task-pool")) {
@@ -115,6 +175,7 @@ export function createServer() {
   if (hasCapability("messaging")) {
     registerListChannelsTool(server);
     registerCreateChannelTool(server);
+    registerDeleteChannelTool(server);
     registerPostMessageTool(server);
     registerReadMessagesTool(server);
   }
@@ -122,6 +183,8 @@ export function createServer() {
   // Profiles capability - agent profile management
   if (hasCapability("profiles")) {
     registerUpdateProfileTool(server);
+    registerContextHistoryTool(server);
+    registerContextDiffTool(server);
   }
 
   // Services capability - PM2/background service registry
@@ -152,5 +215,33 @@ export function createServer() {
     registerUnassignTaskFromEpicTool(server);
   }
 
+  // Memory capability - persistent memory with vector search
+  if (hasCapability("memory")) {
+    registerMemorySearchTool(server);
+    registerMemoryGetTool(server);
+    registerInjectLearningTool(server);
+  }
+
+  // Tracker capability - external issue tracker integration
+  registerTrackerStatusTool(server);
+  registerTrackerLinkTaskTool(server);
+  registerTrackerLinkEpicTool(server);
+  registerTrackerUnlinkTool(server);
+  registerTrackerSyncStatusTool(server);
+  registerTrackerMapAgentTool(server);
+
+  // Workflows capability - DAG-based automation workflows
+  if (hasCapability("workflows")) {
+    registerCreateWorkflowTool(server);
+    registerListWorkflowsTool(server);
+    registerGetWorkflowTool(server);
+    registerUpdateWorkflowTool(server);
+    registerDeleteWorkflowTool(server);
+    registerTriggerWorkflowTool(server);
+    registerListWorkflowRunsTool(server);
+    registerGetWorkflowRunTool(server);
+    registerRetryWorkflowRunTool(server);
+  }
+
   return server;
 }

package/src/slack/HEURISTICS.md

@@ -0,0 +1,105 @@
+# Slack Routing & Buffering Heuristics
+
+This document covers all heuristics used by the Slack integration for message routing, buffering, and task creation.
+
+## Thread Follow-up Routing
+
+When someone @mentions the bot in a thread, the router checks whether a worker agent is already active in that thread before falling back to the lead agent.
+
+**Routing priority (in order):**
+
+1. `swarm#<uuid>` — explicit agent targeting (always wins)
+2. `swarm#all` — broadcast to all workers
+3. **Thread follow-up** — if in a thread and a worker is actively working there, route to that worker
+4. **Lead fallback** — if the bot was @mentioned and no other match, route to lead agent
+
+**Thread follow-up conditions:**
+- 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`
+
+**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.
+
+---
+
+## Additive Slack Buffer
+
+**Feature flag:** `ADDITIVE_SLACK=true` (disabled by default)
+
+When enabled, thread replies that do NOT @mention the bot are captured, buffered, and batched into a single follow-up task. This allows humans to give multi-message feedback in a thread without needing to @mention the bot each time.
+
+### How it works
+
+1. A human sends a non-@mention message in a thread where the swarm is already active (has existing tasks)
+2. The message enters an in-memory buffer keyed by `channelId:threadTs`
+3. A debounce timer starts (default 10 seconds)
+4. Additional messages within the window are appended to the buffer, resetting the timer each time
+5. When the timer expires, all buffered messages are flushed into a single task
+
+### Buffer flush behavior
+
+- All buffered messages are concatenated with `---` separators
+- The task is created as `pending` status
+- If there is an active task in the thread, the new task gets `dependsOn` set to it (dependency chaining)
+- If there is no active task, the new task has no dependency and is immediately pickable
+
+### Important: Initial @mentions are never buffered
+
+The first @mention in a thread always creates a task instantly. Only subsequent non-mention replies enter the buffer. This ensures responsiveness for explicit requests.
+
+### In-memory tradeoffs
+
+- Buffer is lost on server restart (acceptable since the 10s window is tiny)
+- No persistence across process restarts
+- Single-process only (no clustering support)
+
+---
+
+## `!now` Command
+
+**Syntax:** `/now [optional message]`
+
+Used inside a thread with an active buffer to flush immediately, bypassing the debounce timer and dependency chain.
+
+**Behavior:**
+- If text follows `!now`, it is appended to the buffer before flushing
+- The buffer is flushed with `immediate=true`, meaning **no `dependsOn`** is set
+- The resulting task is immediately pickable by any available agent
+- Works only when `ADDITIVE_SLACK=true` and in a thread with swarm activity
+
+**Use case:** When you have been adding context to a thread and want the swarm to pick it up right now, rather than waiting for the debounce or for the current task to finish.
+
+---
+
+## Dependency Chaining
+
+When the additive buffer flushes normally (not via `!now`), the created task uses `dependsOn` to chain to the latest active task in the thread.
+
+**Query:** Finds the most recent `in_progress` or `pending` task matching the thread's `slackChannelId` + `slackThreadTs`, ordered by `createdAt DESC`.
+
+**Effect:** The follow-up task stays in `pending` until the depended-on task completes. This prevents workers from picking up follow-up context before the original task is done.
+
+**`!now` override:** Using `!now` creates the task without any `dependsOn`, making it immediately available regardless of other active tasks.
+
+---
+
+## Feature Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `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 |
+
+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.
+
+---
+
+## Feedback Reactions Reference
+
+| Event | Slack Feedback | Description |
+|-------|---------------|-------------|
+| First non-mention message buffered | :eyes: reaction | Acknowledges the message was captured |
+| Additional message appended to buffer | :heavy_plus_sign: reaction | Indicates the message was added to existing buffer |
+| `!now` command used | :zap: reaction | Confirms instant flush was triggered |
+| Buffer flushed (with dependency) | :satellite: thread message | "N follow-up message(s) queued pending completion of current task" |
+| Buffer flushed (no dependency / `!now`) | :satellite: thread message | "N follow-up message(s) batched into task" |

package/src/slack/actions.ts

@@ -0,0 +1,133 @@
+import type { App } from "@slack/bolt";
+import { cancelTask, createTaskExtended, getAgentById, getLeadAgent, getTaskById } from "../be/db";
+import { buildCancelledBlocks, getTaskLink } from "./blocks";
+
+export function registerActionHandlers(app: App): void {
+  // "View Full Logs" — URL button, just ack (Slack opens the link automatically)
+  app.action("view_task_logs", async ({ ack }) => {
+    await ack();
+  });
+
+  // "Follow-up" — open a modal to send a follow-up message to the same agent
+  app.action("follow_up_task", async ({ ack, action, body, client }) => {
+    await ack();
+
+    if (action.type !== "button") return;
+    const taskId = action.value;
+    if (!taskId) return;
+
+    const triggerId = "trigger_id" in body ? body.trigger_id : undefined;
+    if (!triggerId) return;
+
+    try {
+      await client.views.open({
+        trigger_id: triggerId,
+        view: {
+          type: "modal",
+          callback_id: "follow_up_submit",
+          private_metadata: taskId,
+          title: { type: "plain_text", text: "Follow-up" },
+          submit: { type: "plain_text", text: "Send" },
+          close: { type: "plain_text", text: "Cancel" },
+          blocks: [
+            {
+              type: "input",
+              block_id: "follow_up_input",
+              label: { type: "plain_text", text: "Follow-up message" },
+              element: {
+                type: "plain_text_input",
+                action_id: "follow_up_text",
+                multiline: true,
+                placeholder: {
+                  type: "plain_text",
+                  text: "What would you like the agent to do next?",
+                },
+              },
+            },
+          ],
+        },
+      });
+    } catch (error) {
+      console.error("[Slack] Failed to open follow-up modal:", error);
+    }
+  });
+
+  // Handle follow-up modal submission
+  app.view("follow_up_submit", async ({ ack, view, body, client }) => {
+    await ack();
+
+    const taskId = view.private_metadata;
+    const followUpText = view.state.values.follow_up_input?.follow_up_text?.value || "";
+
+    if (!taskId || !followUpText) return;
+
+    const originalTask = getTaskById(taskId);
+    if (!originalTask || !originalTask.slackChannelId) return;
+
+    const lead = getLeadAgent();
+    const followUpTask = createTaskExtended(followUpText, {
+      agentId: lead?.id,
+      source: "slack",
+      parentTaskId: taskId,
+      slackChannelId: originalTask.slackChannelId,
+      slackThreadTs: originalTask.slackThreadTs,
+      slackUserId: body.user.id,
+    });
+
+    const taskLink = getTaskLink(followUpTask.id);
+    const agentName = lead ? lead.name : "queue";
+    const threadTs = originalTask.slackThreadTs;
+
+    try {
+      await client.chat.postMessage({
+        channel: originalTask.slackChannelId,
+        thread_ts: threadTs,
+        text: `💬 Follow-up sent to *${agentName}* (${taskLink})`,
+      });
+    } catch (error) {
+      console.error("[Slack] Failed to post follow-up confirmation:", error);
+    }
+  });
+
+  // "Cancel" — cancel the task and update the message
+  app.action("cancel_task", async ({ ack, action, client, body }) => {
+    await ack();
+
+    if (action.type !== "button") return;
+    const taskId = action.value;
+    if (!taskId) return;
+
+    const task = getTaskById(taskId);
+    if (!task) return;
+
+    // Cancel the task in DB
+    const cancelled = cancelTask(taskId, "Cancelled via Slack");
+    if (!cancelled) {
+      // Task was already in a terminal state
+      return;
+    }
+
+    // Update the message to show cancelled state
+    if (task.slackChannelId && task.agentId) {
+      const agent = getAgentById(task.agentId);
+      const agentName = agent?.name || "Unknown";
+      const blocks = buildCancelledBlocks({ agentName, taskId: task.id });
+
+      try {
+        // body.message?.ts is the message where the button was clicked
+        const messageTs = "message" in body && body.message?.ts;
+        if (messageTs && typeof messageTs === "string") {
+          await client.chat.update({
+            channel: task.slackChannelId,
+            ts: messageTs,
+            text: "Task cancelled",
+            // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+            blocks: blocks as any,
+          });
+        }
+      } catch (error) {
+        console.error("[Slack] Failed to update cancelled message:", error);
+      }
+    }
+  });
+}

package/src/slack/app.ts

@@ -41,9 +41,15 @@ export async function initSlackApp(): Promise<App | null> {
   // Register handlers
   const { registerMessageHandler } = await import("./handlers");
   const { registerCommandHandler } = await import("./commands");
+  const { registerActionHandlers } = await import("./actions");
 
   registerMessageHandler(app);
   registerCommandHandler(app);
+  registerActionHandlers(app);
+
+  // Register assistant thread handler (safe even if "Agents & AI Apps" isn't enabled)
+  const { createAssistant } = await import("./assistant");
+  app.assistant(createAssistant());
 
   return app;
 }
@@ -70,4 +76,5 @@ export async function stopSlackApp(): Promise<void> {
     app = null;
     console.log("[Slack] Bot disconnected");
   }
+  initialized = false;
 }

package/src/slack/assistant.ts

@@ -0,0 +1,118 @@
+import { Assistant } from "@slack/bolt";
+import {
+  createTaskExtended,
+  getAgentWorkingOnThread,
+  getLeadAgent,
+  getMostRecentTaskInThread,
+} from "../be/db";
+import { resolveTemplate } from "../prompts/resolver";
+import { bufferThreadMessage } from "./thread-buffer";
+// Side-effect import: registers all Slack event templates in the in-memory registry
+import "./templates";
+
+const additiveSlack = process.env.ADDITIVE_SLACK === "true";
+
+export function createAssistant(): Assistant {
+  return new Assistant({
+    threadStarted: async ({ say, setSuggestedPrompts, saveThreadContext }) => {
+      try {
+        await saveThreadContext();
+
+        const greetingResult = resolveTemplate("slack.assistant.greeting", {});
+        await say(greetingResult.text);
+
+        await setSuggestedPrompts({
+          title: "Try these:",
+          prompts: [
+            { title: "Check status", message: "What's the current status of all agents?" },
+            { title: "Assign a task", message: "Can you help me with..." },
+            { title: "List recent tasks", message: "Show me the most recent tasks" },
+          ],
+        });
+      } catch (error) {
+        console.error("[Slack] Assistant threadStarted error:", error);
+      }
+    },
+
+    threadContextChanged: async ({ saveThreadContext }) => {
+      await saveThreadContext();
+    },
+
+    userMessage: async ({ message, say, setStatus, setTitle, getThreadContext }) => {
+      try {
+        // Cast to access fields — Bolt's message union type is complex
+        const msg = message as unknown as Record<string, unknown>;
+        const threadTs = (msg.thread_ts as string) || message.ts;
+        const channelId = message.channel;
+        const messageText = (msg.text as string) || "";
+        const userId = (msg.user as string) || "";
+
+        // 1. Check if an agent is already working in this thread
+        const workingAgent = getAgentWorkingOnThread(channelId, threadTs);
+
+        if (workingAgent && workingAgent.status !== "offline") {
+          // Follow-up message → route to the same agent
+          if (additiveSlack) {
+            bufferThreadMessage(channelId, threadTs, messageText, userId, message.ts);
+            await setStatus("Queuing follow-up...");
+            return;
+          }
+
+          // Otherwise, create a follow-up task for the working agent
+          const latestTask = getMostRecentTaskInThread(channelId, threadTs);
+          createTaskExtended(messageText, {
+            agentId: workingAgent.id,
+            source: "slack",
+            slackChannelId: channelId,
+            slackThreadTs: threadTs,
+            slackUserId: userId,
+            parentTaskId: latestTask?.id,
+          });
+
+          await setStatus("Processing follow-up...");
+          return;
+        }
+
+        // 2. First message in thread — create new task for lead
+        await setStatus("Processing your request...");
+
+        if (messageText) {
+          const title = messageText.length > 50 ? `${messageText.slice(0, 47)}...` : messageText;
+          await setTitle(title);
+        }
+
+        // Optionally enrich with channel context
+        const ctx = await getThreadContext();
+        const channelContext =
+          ctx && typeof ctx === "object" && "channel_id" in ctx && ctx.channel_id
+            ? `\n\n[User is viewing channel <#${ctx.channel_id}>]`
+            : "";
+
+        const lead = getLeadAgent();
+        if (!lead) {
+          // No lead — still queue the task
+          createTaskExtended(messageText + channelContext, {
+            source: "slack",
+            slackChannelId: channelId,
+            slackThreadTs: threadTs,
+            slackUserId: userId,
+          });
+          const offlineResult = resolveTemplate("slack.assistant.offline", {});
+          await say(offlineResult.text);
+          return;
+        }
+
+        createTaskExtended(messageText + channelContext, {
+          agentId: lead.id,
+          source: "slack",
+          slackChannelId: channelId,
+          slackThreadTs: threadTs,
+          slackUserId: userId,
+        });
+        // setStatus shows typing indicator — watcher will post final result when done
+      } catch (error) {
+        console.error("[Slack] Assistant userMessage error:", error);
+      }
+    },
+  });
+}