@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tools/send-task.ts

@@ -6,8 +6,10 @@ import {
   getAgentById,
   getDb,
   getEpicById,
+  getTaskById,
   hasCapacity,
 } from "@/be/db";
+import { findDuplicateTask } from "@/tools/task-dedup";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentTaskSchema } from "@/types";
 
@@ -16,6 +18,7 @@ export const registerSendTaskTool = (server: McpServer) => {
     "send-task",
     {
       title: "Send a task",
+      annotations: { destructiveHint: false },
       description:
         "Sends a task to a specific agent, creates an unassigned task for the pool, or offers a task for acceptance.",
       inputSchema: z.object({
@@ -46,6 +49,51 @@ export const registerSendTaskTool = (server: McpServer) => {
           .describe("Priority 0-100 (default: 50)."),
         dependsOn: z.array(z.uuid()).optional().describe("Task IDs this task depends on."),
         epicId: z.string().uuid().optional().describe("Epic to associate this task with."),
+        parentTaskId: z
+          .uuid()
+          .optional()
+          .describe(
+            "Parent task ID for session continuity. Child task will resume the parent's Claude session. Auto-routes to the same worker unless agentId is explicitly provided.",
+          ),
+        dir: z
+          .string()
+          .min(1)
+          .startsWith("/")
+          .optional()
+          .describe(
+            "Working directory (absolute path) for the agent to start in. If the directory doesn't exist, falls back to the default working directory.",
+          ),
+        vcsRepo: z
+          .string()
+          .optional()
+          .describe(
+            "VCS repo identifier (e.g., 'desplega-ai/agent-swarm' for GitHub or 'group/project' for GitLab). Links the task to a registered repo for workspace context.",
+          ),
+        model: z
+          .enum(["haiku", "sonnet", "opus"])
+          .optional()
+          .describe(
+            "Model to use for this task ('haiku', 'sonnet', or 'opus'). If not set, uses agent/global config MODEL_OVERRIDE or defaults to 'opus'.",
+          ),
+        allowDuplicate: z
+          .boolean()
+          .default(false)
+          .describe(
+            "If true, skip duplicate detection and create the task even if a similar one exists.",
+          ),
+        slackChannelId: z
+          .string()
+          .optional()
+          .describe(
+            "Slack channel ID to post progress updates to. Use this to propagate Slack context when delegating from a Slack thread.",
+          ),
+        slackThreadTs: z
+          .string()
+          .optional()
+          .describe(
+            "Slack thread timestamp. Required with slackChannelId for thread-level updates.",
+          ),
+        slackUserId: z.string().optional().describe("Slack user ID of the original requester."),
       }),
       outputSchema: z.object({
         yourAgentId: z.string().uuid().optional(),
@@ -55,7 +103,24 @@ export const registerSendTaskTool = (server: McpServer) => {
       }),
     },
     async (
-      { agentId, task, offerMode, taskType, tags, priority, dependsOn, epicId },
+      {
+        agentId,
+        task,
+        offerMode,
+        taskType,
+        tags,
+        priority,
+        dependsOn,
+        epicId,
+        dir,
+        parentTaskId,
+        vcsRepo,
+        model,
+        allowDuplicate,
+        slackChannelId,
+        slackThreadTs,
+        slackUserId,
+      },
       requestInfo,
       _meta,
     ) => {
@@ -91,7 +156,8 @@ export const registerSendTaskTool = (server: McpServer) => {
         };
       }
 
-      // Validate epicId if provided
+      // Validate epicId and auto-inherit vcsRepo from epic if not explicitly provided
+      let effectiveVcsRepo = vcsRepo;
       if (epicId) {
         const epic = getEpicById(epicId);
         if (!epic) {
@@ -104,21 +170,61 @@ export const registerSendTaskTool = (server: McpServer) => {
             },
           };
         }
+        if (!vcsRepo && epic.vcsRepo) {
+          effectiveVcsRepo = epic.vcsRepo;
+        }
+      }
+
+      // Auto-route to parent's worker if parentTaskId is set and no explicit agentId
+      let effectiveAgentId = agentId;
+      if (parentTaskId && !agentId) {
+        const parentTask = getTaskById(parentTaskId);
+        if (parentTask?.agentId) {
+          effectiveAgentId = parentTask.agentId;
+        }
+      }
+
+      // Dedup guard: check for similar recent tasks
+      if (!allowDuplicate && requestInfo.agentId) {
+        const duplicate = findDuplicateTask({
+          taskDescription: task,
+          creatorAgentId: requestInfo.agentId,
+          targetAgentId: effectiveAgentId ?? undefined,
+        });
+        if (duplicate) {
+          const msg = `Duplicate task detected (matches task ${duplicate.task.id.slice(0, 8)}, ${duplicate.reason}). Skipping. Use allowDuplicate: true to override.`;
+          return {
+            content: [{ type: "text", text: msg }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: msg,
+            },
+          };
+        }
       }
 
       const txn = getDb().transaction(() => {
         // Build tags with epic tag if epicId is provided
         const finalTags = epicId ? [...(tags || []), `epic:${getEpicById(epicId)?.name}`] : tags;
 
-        // If no agentId, create an unassigned task for the pool
-        if (!agentId) {
+        // If no agentId (and no auto-routed agentId), create an unassigned task for the pool
+        if (!effectiveAgentId) {
           const newTask = createTaskExtended(task, {
             creatorAgentId: requestInfo.agentId,
+            sourceTaskId: requestInfo.sourceTaskId,
             taskType,
             tags: finalTags,
             priority,
             dependsOn,
             epicId,
+            dir,
+            parentTaskId,
+            vcsRepo: effectiveVcsRepo,
+            model,
+            slackChannelId,
+            slackThreadTs,
+            slackUserId,
           });
 
           return {
@@ -128,12 +234,12 @@ export const registerSendTaskTool = (server: McpServer) => {
           };
         }
 
-        const agent = getAgentById(agentId);
+        const agent = getAgentById(effectiveAgentId);
 
         if (!agent) {
           return {
             success: false,
-            message: `Agent with ID "${agentId}" not found.`,
+            message: `Agent with ID "${effectiveAgentId}" not found.`,
           };
         }
 
@@ -145,8 +251,8 @@ export const registerSendTaskTool = (server: McpServer) => {
         }
 
         // For direct assignment (not offer), check if agent has capacity
-        if (!offerMode && !hasCapacity(agentId)) {
-          const activeCount = getActiveTaskCount(agentId);
+        if (!offerMode && !hasCapacity(effectiveAgentId)) {
+          const activeCount = getActiveTaskCount(effectiveAgentId);
           return {
             success: false,
             message: `Agent "${agent.name}" is at capacity (${activeCount}/${agent.maxTasks ?? 1} tasks). Use offerMode: true to offer the task instead, or wait for a task to complete.`,
@@ -156,13 +262,21 @@ export const registerSendTaskTool = (server: McpServer) => {
         if (offerMode) {
           // Offer the task to the agent (they must accept/reject)
           const newTask = createTaskExtended(task, {
-            offeredTo: agentId,
+            offeredTo: effectiveAgentId,
             creatorAgentId: requestInfo.agentId,
+            sourceTaskId: requestInfo.sourceTaskId,
             taskType,
             tags: finalTags,
             priority,
             dependsOn,
             epicId,
+            dir,
+            parentTaskId,
+            vcsRepo: effectiveVcsRepo,
+            model,
+            slackChannelId,
+            slackThreadTs,
+            slackUserId,
           });
 
           return {
@@ -174,13 +288,21 @@ export const registerSendTaskTool = (server: McpServer) => {
 
         // Direct assignment
         const newTask = createTaskExtended(task, {
-          agentId,
+          agentId: effectiveAgentId,
           creatorAgentId: requestInfo.agentId,
+          sourceTaskId: requestInfo.sourceTaskId,
           taskType,
           tags: finalTags,
           priority,
           dependsOn,
           epicId,
+          dir,
+          parentTaskId,
+          vcsRepo: effectiveVcsRepo,
+          model,
+          slackChannelId,
+          slackThreadTs,
+          slackUserId,
         });
 
         return {

package/src/tools/slack-download-file.ts

@@ -11,7 +11,9 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
     {
       title: "Download file from Slack",
       description:
-        "Download a file from Slack by file ID or URL. Files are saved to /workspace/shared/downloads/slack/ by default.",
+        "Download a file from Slack by file ID or URL. Files are saved to the agent's download directory on the shared disk by default.",
+      annotations: { readOnlyHint: true, openWorldHint: true },
+
       inputSchema: z.object({
         fileId: z
           .string()
@@ -26,7 +28,7 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
           .string()
           .optional()
           .describe(
-            "Where to save the file. Can be a directory or full path. Defaults to /workspace/shared/downloads/slack/",
+            "Where to save the file. Can be a directory or full path. Defaults to /workspace/shared/downloads/{agentId}/slack/",
           ),
         filename: z
           .string()

package/src/tools/slack-list-channels.ts

@@ -19,6 +19,8 @@ export const registerSlackListChannelsTool = (server: McpServer) => {
       title: "List Slack channels",
       description:
         "List Slack channels the bot is a member of. Use this to discover available channels for reading messages.",
+      annotations: { readOnlyHint: true, openWorldHint: true },
+
       inputSchema: z.object({
         types: z
           .array(z.enum(["public", "private", "dm", "mpim"]))

package/src/tools/slack-post.ts

@@ -12,6 +12,8 @@ export const registerSlackPostTool = (server: McpServer) => {
       title: "Post new message to Slack channel",
       description:
         "Post a new message to a Slack channel. This creates a new message (not a thread reply). Requires lead privileges.",
+      annotations: { openWorldHint: true },
+
       inputSchema: z.object({
         channelId: z.string().min(1).describe("The Slack channel ID to post to."),
         message: z.string().min(1).max(4000).describe("The message content to post."),

package/src/tools/slack-read.ts

@@ -37,6 +37,8 @@ export const registerSlackReadTool = (server: McpServer) => {
       title: "Read Slack thread/channel history",
       description:
         "Read messages from a Slack thread or channel. Use inboxMessageId or taskId to read from a thread you have context for, or provide channelId directly for channel history (leads only).",
+      annotations: { readOnlyHint: true, openWorldHint: true },
+
       inputSchema: z.object({
         inboxMessageId: z.uuid().optional().describe("Read thread history for an inbox message."),
         taskId: z.uuid().optional().describe("Read thread history for a task."),

package/src/tools/slack-reply.ts

@@ -12,6 +12,8 @@ export const registerSlackReplyTool = (server: McpServer) => {
       title: "Reply to Slack thread",
       description:
         "Send a reply to a Slack thread. Use inboxMessageId for inbox messages, or taskId for task-related threads.",
+      annotations: { openWorldHint: true },
+
       inputSchema: z.object({
         inboxMessageId: z
           .uuid()

package/src/tools/slack-upload-file.ts

@@ -85,6 +85,8 @@ export const registerSlackUploadFileTool = (server: McpServer) => {
       title: "Upload file to Slack",
       description:
         "Upload a file (image, document, etc.) to a Slack channel or thread. Use inboxMessageId or taskId for context, or provide channelId directly (leads only). Maximum file size is 1 GB.",
+      annotations: { openWorldHint: true },
+
       inputSchema: z.object({
         inboxMessageId: z
           .uuid()

package/src/tools/store-progress.ts

@@ -2,16 +2,27 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import {
   completeTask,
+  createMemory,
   createSessionCost,
+  createTaskExtended,
   failTask,
   getAgentById,
   getDb,
+  getEpicWithProgress,
+  getLeadAgent,
   getTaskById,
+  markEpicsProgressNotified,
   updateAgentStatusFromCapacity,
+  updateMemoryEmbedding,
   updateTaskProgress,
 } from "@/be/db";
+import { getEmbedding, serializeEmbedding } from "@/be/embedding";
+import { resolveTemplate } from "@/prompts/resolver";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentTaskSchema } from "@/types";
+// Side-effect import: registers task lifecycle templates in the in-memory registry
+import "./templates";
+import { validateJsonSchema } from "@/workflows/json-schema-validator";
 
 // Schema for optional cost data that agents can self-report
 const CostDataSchema = z
@@ -34,6 +45,8 @@ export const registerStoreProgressTool = (server: McpServer) => {
       title: "Store task progress",
       description:
         "Stores the progress of a specific task. Can also mark task as completed or failed, which will set the agent back to idle.",
+      annotations: { idempotentHint: true },
+
       inputSchema: z.object({
         taskId: z.uuid().describe("The ID of the task to update progress for."),
         progress: z.string().optional().describe("The progress update to store."),
@@ -93,11 +106,54 @@ export const registerStoreProgressTool = (server: McpServer) => {
         }
 
         let updatedTask = existingTask;
+        const isTerminal = ["completed", "failed", "cancelled"].includes(existingTask.status);
+
+        // Update progress if provided (with deduplication)
+        // Skip for tasks already in a terminal state to prevent zombie revival
+        if (progress && !isTerminal) {
+          // Skip if same progress text was set within the last 5 minutes
+          const isDuplicate =
+            existingTask.progress === progress &&
+            existingTask.lastUpdatedAt &&
+            Date.now() - new Date(existingTask.lastUpdatedAt).getTime() < 5 * 60 * 1000;
 
-        // Update progress if provided
-        if (progress) {
-          const result = updateTaskProgress(taskId, progress);
-          if (result) updatedTask = result;
+          if (!isDuplicate) {
+            const result = updateTaskProgress(taskId, progress);
+            if (result) updatedTask = result;
+          }
+        }
+
+        // Validate structured output against outputSchema if present
+        if (
+          status === "completed" &&
+          existingTask.outputSchema &&
+          typeof existingTask.outputSchema === "object"
+        ) {
+          const schema = existingTask.outputSchema as Record<string, unknown>;
+          if (!output) {
+            return {
+              success: false,
+              message: `Task has an outputSchema but no output was provided. You must call store-progress with a valid JSON output matching this schema:\n${JSON.stringify(schema, null, 2)}`,
+            };
+          }
+
+          let parsed: unknown;
+          try {
+            parsed = JSON.parse(output);
+          } catch {
+            return {
+              success: false,
+              message: `Task output must be valid JSON matching the outputSchema. Got invalid JSON. Schema:\n${JSON.stringify(schema, null, 2)}`,
+            };
+          }
+
+          const validationErrors = validateJsonSchema(schema, parsed);
+          if (validationErrors.length > 0) {
+            return {
+              success: false,
+              message: `Task output does not match the outputSchema. Errors:\n${validationErrors.join("\n")}\n\nExpected schema:\n${JSON.stringify(schema, null, 2)}\n\nPlease fix your output and retry.`,
+            };
+          }
         }
 
         // Handle status change
@@ -155,6 +211,151 @@ export const registerStoreProgressTool = (server: McpServer) => {
 
       const result = txn();
 
+      // Index completed and failed tasks as memory (async, non-blocking)
+      if ((status === "completed" || status === "failed") && result.success && result.task) {
+        (async () => {
+          try {
+            const taskContent =
+              status === "completed"
+                ? `Task: ${result.task!.task}\n\nOutput:\n${output || "(no output)"}`
+                : `Task: ${result.task!.task}\n\nFailure reason:\n${failureReason || "No reason provided"}\n\nThis task failed. Learn from this to avoid repeating the mistake.`;
+
+            // Skip indexing if there's truly no content
+            if (taskContent.length < 30) return;
+
+            const memory = createMemory({
+              agentId: requestInfo.agentId,
+              content: taskContent,
+              name: `Task: ${result.task!.task.slice(0, 80)}`,
+              scope: "agent",
+              source: "task_completion",
+              sourceTaskId: taskId,
+            });
+            const embedding = await getEmbedding(taskContent);
+            if (embedding) {
+              updateMemoryEmbedding(memory.id, serializeEmbedding(embedding));
+            }
+
+            // Auto-promote high-value completions to swarm memory (P3)
+            // Epic-linked tasks are also promoted so workers on the same epic can see each other's learnings
+            const shouldShareWithSwarm =
+              status === "completed" &&
+              (result.task!.taskType === "research" ||
+                result.task!.tags?.includes("knowledge") ||
+                result.task!.tags?.includes("shared") ||
+                result.task!.epicId != null);
+
+            if (shouldShareWithSwarm) {
+              try {
+                const swarmMemory = createMemory({
+                  agentId: requestInfo.agentId,
+                  scope: "swarm",
+                  name: `Shared: ${result.task!.task.slice(0, 80)}`,
+                  content: `Task completed by agent ${requestInfo.agentId}:\n\n${taskContent}`,
+                  source: "task_completion",
+                  sourceTaskId: taskId,
+                });
+                const swarmEmbedding = await getEmbedding(taskContent);
+                if (swarmEmbedding) {
+                  updateMemoryEmbedding(swarmMemory.id, serializeEmbedding(swarmEmbedding));
+                }
+              } catch {
+                // Non-blocking — swarm memory promotion failure is not critical
+              }
+            }
+          } catch {
+            // Non-blocking — task completion memory failure should not affect task status
+          }
+        })();
+      }
+
+      // Create follow-up task for the lead when a worker task finishes.
+      // This replaces the old poll-based tasks_finished trigger which was unreliable.
+      // Skip for workflow-managed tasks — the workflow engine handles sequencing via resume.ts.
+      if (status && result.success && result.task && !result.task.workflowRunId) {
+        try {
+          const taskAgent = getAgentById(result.task.agentId ?? "");
+          // Only create follow-ups for worker tasks (not lead's own tasks)
+          if (taskAgent && !taskAgent.isLead) {
+            const leadAgent = getLeadAgent();
+            if (leadAgent) {
+              const agentName = taskAgent.name || result.task.agentId?.slice(0, 8) || "Unknown";
+              const taskDesc = result.task.task.slice(0, 200);
+
+              let followUpDescription: string;
+              if (status === "completed") {
+                const outputSummary = output
+                  ? `${output.slice(0, 500)}${output.length > 500 ? "..." : ""}`
+                  : "(no output)";
+                const completedResult = resolveTemplate("task.worker.completed", {
+                  agent_name: agentName,
+                  task_desc: taskDesc,
+                  output_summary: outputSummary,
+                  task_id: taskId,
+                });
+                followUpDescription = completedResult.text;
+              } else {
+                const reason = failureReason || "(no reason given)";
+                const failedResult = resolveTemplate("task.worker.failed", {
+                  agent_name: agentName,
+                  task_desc: taskDesc,
+                  failure_reason: reason,
+                  task_id: taskId,
+                });
+                followUpDescription = failedResult.text;
+              }
+
+              // Enrich follow-up with epic context if task belongs to an epic
+              let epicContext = "";
+              if (result.task.epicId) {
+                const epic = getEpicWithProgress(result.task.epicId);
+                if (epic) {
+                  epicContext = `\n\n## Epic Context\n`;
+                  epicContext += `**Epic:** ${epic.name}\n`;
+                  epicContext += `**Goal:** ${epic.goal}\n`;
+                  epicContext += `**Progress:** ${epic.progress}% (${epic.taskStats.completed}/${epic.taskStats.total} tasks)\n`;
+                  if (epic.plan) {
+                    epicContext += `**Plan:**\n${epic.plan.slice(0, 1000)}\n`;
+                  }
+                  if (epic.nextSteps) {
+                    epicContext += `**Next Steps:**\n${epic.nextSteps}\n`;
+                  }
+                  epicContext += `\n**Action Required:** Review the output above in the context of this epic. `;
+                  epicContext += `If the epic goal is not yet met, create the next task(s) with epicId="${result.task.epicId}". `;
+                  epicContext += `If blocked or unclear, notify the stakeholder. `;
+                  epicContext += `If the goal is met, update the epic status to completed.`;
+                }
+              }
+
+              // If the original task came from Slack, forward context so lead can reply
+              createTaskExtended(followUpDescription + epicContext, {
+                agentId: leadAgent.id,
+                source: "system",
+                taskType: "follow-up",
+                parentTaskId: taskId,
+                epicId: result.task.epicId || undefined,
+                slackChannelId: result.task.slackChannelId,
+                slackThreadTs: result.task.slackThreadTs,
+                slackUserId: result.task.slackUserId,
+              });
+
+              // Deduplicate: mark epic progress as notified so epic_progress_changed
+              // doesn't re-fire for this same task completion
+              if (result.task.epicId) {
+                markEpicsProgressNotified([result.task.epicId]);
+              }
+
+              console.log(
+                `[store-progress] Created follow-up task for lead (${leadAgent.name}) — ${status} task ${taskId.slice(0, 8)} by ${agentName}`,
+              );
+            }
+          }
+        } catch (err) {
+          // Non-blocking — follow-up task creation failure should not affect the store-progress response
+          console.warn(`[store-progress] Failed to create follow-up task: ${err}`);
+        }
+      }
+
       return {
         content: [{ type: "text", text: result.message }],
         structuredContent: {

package/src/tools/swarm-config/delete-config.ts

@@ -0,0 +1,87 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { deleteSwarmConfig, getSwarmConfigById } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerDeleteConfigTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "delete-config",
+    {
+      title: "Delete Config",
+      description:
+        "Delete a swarm configuration entry by its ID. Use list-config to find config IDs first.",
+      annotations: { destructiveHint: true },
+
+      inputSchema: z.object({
+        id: z.string().uuid().describe("The config entry ID to delete."),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+      }),
+    },
+    async ({ id }, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: 'Agent ID not found. Set the "X-Agent-ID" header.' }],
+          structuredContent: {
+            success: false,
+            message: 'Agent ID not found. Set the "X-Agent-ID" header.',
+          },
+        };
+      }
+
+      try {
+        // Check if config exists first for a better error message
+        const existing = getSwarmConfigById(id);
+        if (!existing) {
+          return {
+            content: [{ type: "text", text: `Config entry "${id}" not found.` }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: `Config entry "${id}" not found.`,
+            },
+          };
+        }
+
+        const deleted = deleteSwarmConfig(id);
+        if (!deleted) {
+          return {
+            content: [{ type: "text", text: `Failed to delete config entry "${id}".` }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: `Failed to delete config entry "${id}".`,
+            },
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Config "${existing.key}" (scope: ${existing.scope}${existing.scopeId ? `, scopeId: ${existing.scopeId}` : ""}) deleted successfully.`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Config "${existing.key}" deleted successfully.`,
+          },
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Failed to delete config: ${message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Failed to delete config: ${message}`,
+          },
+        };
+      }
+    },
+  );
+};