@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/tools/store-progress.ts

@@ -17,8 +17,11 @@ import {
   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
@@ -268,7 +271,8 @@ export const registerStoreProgressTool = (server: McpServer) => {
 
       // Create follow-up task for the lead when a worker task finishes.
       // This replaces the old poll-based tasks_finished trigger which was unreliable.
-      if (status && result.success && result.task) {
+      // 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)
@@ -280,11 +284,25 @@ export const registerStoreProgressTool = (server: McpServer) => {
 
               let followUpDescription: string;
               if (status === "completed") {
-                const outputSummary = output ? output.slice(0, 500) : "(no output)";
-                followUpDescription = `Worker task completed — review needed.\n\nAgent: ${agentName}\nTask: "${taskDesc}"\n\nOutput:\n${outputSummary}${output && output.length > 500 ? "..." : ""}\n\nUse \`get-task-details\` with taskId "${taskId}" for full details.`;
+                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)";
-                followUpDescription = `Worker task failed — action needed.\n\nAgent: ${agentName}\nTask: "${taskDesc}"\n\nFailure reason: ${reason}\n\nDecide whether to reassign, retry, or handle the failure. Use \`get-task-details\` with taskId "${taskId}" for full details.`;
+                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

package/src/tools/task-action.ts

@@ -5,6 +5,7 @@ import {
   checkDependencies,
   claimTask,
   createTaskExtended,
+  getActiveSessions,
   getActiveTaskCount,
   getAgentById,
   getDb,
@@ -12,8 +13,10 @@ import {
   hasCapacity,
   moveTaskFromBacklog,
   moveTaskToBacklog,
+  reassociateSessionLogs,
   rejectTask,
   releaseTask,
+  updateTaskClaudeSessionId,
 } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentTaskSchema } from "@/types";
@@ -164,6 +167,23 @@ export const registerTaskActionTool = (server: McpServer) => {
                 message: `Task "${taskId}" was already claimed by another agent. Try a different task.`,
               };
             }
+
+            // Reassociate session logs from pool trigger's random UUID to real task ID
+            const sessions = getActiveSessions(agentId);
+            const activeSession = sessions.find((s) => s.runnerSessionId);
+            if (activeSession?.runnerSessionId) {
+              const count = reassociateSessionLogs(activeSession.runnerSessionId, taskId);
+              if (count > 0) {
+                console.log(
+                  `[task-action] Reassociated ${count} session logs for claimed task ${taskId.slice(0, 8)}`,
+                );
+              }
+              // Propagate provider session ID (e.g. claudeSessionId) to the task
+              if (activeSession.providerSessionId) {
+                updateTaskClaudeSessionId(taskId, activeSession.providerSessionId);
+              }
+            }
+
             return {
               success: true,
               message: `Claimed task "${taskId}".`,

package/src/tools/templates.ts

@@ -0,0 +1,53 @@
+/**
+ * Task lifecycle prompt template definitions (store-progress follow-ups).
+ *
+ * Each template is registered at module load time via registerTemplate().
+ * Handlers import this module for the side-effect of registration.
+ */
+
+import { registerTemplate } from "../prompts/registry";
+
+// ============================================================================
+// Worker task follow-ups (created by store-progress for the lead)
+// ============================================================================
+
+registerTemplate({
+  eventType: "task.worker.completed",
+  header: "",
+  defaultBody: `Worker task completed \u2014 review needed.
+
+Agent: {{agent_name}}
+Task: "{{task_desc}}"
+
+Output:
+{{output_summary}}
+
+Use \`get-task-details\` with taskId "{{task_id}}" for full details.`,
+  variables: [
+    { name: "agent_name", description: "Worker agent name or ID prefix" },
+    { name: "task_desc", description: "Task description (truncated to 200 chars)" },
+    { name: "output_summary", description: "Task output (truncated to 500 chars)" },
+    { name: "task_id", description: "Original task ID" },
+  ],
+  category: "task_lifecycle",
+});
+
+registerTemplate({
+  eventType: "task.worker.failed",
+  header: "",
+  defaultBody: `Worker task failed \u2014 action needed.
+
+Agent: {{agent_name}}
+Task: "{{task_desc}}"
+
+Failure reason: {{failure_reason}}
+
+Decide whether to reassign, retry, or handle the failure. Use \`get-task-details\` with taskId "{{task_id}}" for full details.`,
+  variables: [
+    { name: "agent_name", description: "Worker agent name or ID prefix" },
+    { name: "task_desc", description: "Task description (truncated to 200 chars)" },
+    { name: "failure_reason", description: "Failure reason text" },
+    { name: "task_id", description: "Original task ID" },
+  ],
+  category: "task_lifecycle",
+});

package/src/tools/tool-config.ts

@@ -105,9 +105,32 @@ export const DEFERRED_TOOLS = new Set([
   "tracker-sync-status",
   "tracker-map-agent",
 
+  // Prompt Templates (5)
+  "list-prompt-templates",
+  "get-prompt-template",
+  "set-prompt-template",
+  "delete-prompt-template",
+  "preview-prompt-template",
+
   // Debug (1)
   "db-query",
 
+  // Approval Requests (1)
+  "request-human-input",
+
+  // Skills (11)
+  "skill-create",
+  "skill-update",
+  "skill-delete",
+  "skill-get",
+  "skill-list",
+  "skill-search",
+  "skill-install",
+  "skill-uninstall",
+  "skill-install-remote",
+  "skill-sync-remote",
+  "skill-publish",
+
   // Other (3)
   "cancel-task",
   "inject-learning",

package/src/tools/update-profile.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { updateAgentName, updateAgentProfile } from "@/be/db";
+import { getAgentById, updateAgentName, updateAgentProfile } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 import { type Agent, AgentSchema } from "@/types";
 
@@ -10,10 +10,17 @@ export const registerUpdateProfileTool = (server: McpServer) => {
     {
       title: "Update Profile",
       description:
-        "Updates the calling agent's profile information (name, description, role, capabilities).",
+        "Updates an agent's profile information (name, description, role, capabilities). By default updates the calling agent. Lead agents can update any agent's profile by providing the agentId parameter.",
       annotations: { idempotentHint: true },
 
       inputSchema: z.object({
+        agentId: z
+          .string()
+          .uuid()
+          .optional()
+          .describe(
+            "Target agent ID to update. If omitted, updates the calling agent. Only lead agents can update other agents' profiles.",
+          ),
         name: z.string().min(1).optional().describe("Agent name."),
         description: z.string().optional().describe("Agent description."),
         role: z
@@ -69,7 +76,18 @@ export const registerUpdateProfileTool = (server: McpServer) => {
       }),
     },
     async (
-      { name, description, role, capabilities, claudeMd, soulMd, identityMd, setupScript, toolsMd },
+      {
+        agentId,
+        name,
+        description,
+        role,
+        capabilities,
+        claudeMd,
+        soulMd,
+        identityMd,
+        setupScript,
+        toolsMd,
+      },
       requestInfo,
       _meta,
     ) => {
@@ -83,6 +101,54 @@ export const registerUpdateProfileTool = (server: McpServer) => {
         };
       }
 
+      // Determine target agent: if agentId is provided, check lead permissions
+      const isUpdatingSelf = !agentId || agentId === requestInfo.agentId;
+      const targetAgentId = isUpdatingSelf ? requestInfo.agentId : agentId;
+
+      if (!isUpdatingSelf) {
+        // Only lead agents can update other agents' profiles
+        const callingAgent = getAgentById(requestInfo.agentId);
+        if (!callingAgent) {
+          return {
+            content: [{ type: "text", text: "Calling agent not found." }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: "Calling agent not found.",
+            },
+          };
+        }
+        if (!callingAgent.isLead) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Only lead agents can update other agents' profiles. Provide no agentId to update your own profile.",
+              },
+            ],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message:
+                "Only lead agents can update other agents' profiles. Provide no agentId to update your own profile.",
+            },
+          };
+        }
+
+        // Validate target agent exists before proceeding
+        const targetAgent = getAgentById(targetAgentId);
+        if (!targetAgent) {
+          return {
+            content: [{ type: "text", text: `Target agent ${targetAgentId} not found.` }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: `Target agent ${targetAgentId} not found.`,
+            },
+          };
+        }
+      }
+
       // At least one field must be provided
       if (
         name === undefined &&
@@ -116,14 +182,14 @@ export const registerUpdateProfileTool = (server: McpServer) => {
 
         // Update name if provided
         if (name !== undefined) {
-          agent = updateAgentName(requestInfo.agentId, name);
+          agent = updateAgentName(targetAgentId, name);
           if (!agent) {
             return {
-              content: [{ type: "text", text: "Agent not found." }],
+              content: [{ type: "text", text: "Target agent not found." }],
               structuredContent: {
                 yourAgentId: requestInfo.agentId,
                 success: false,
-                message: "Agent not found.",
+                message: "Target agent not found.",
               },
             };
           }
@@ -131,7 +197,7 @@ export const registerUpdateProfileTool = (server: McpServer) => {
 
         // Update profile fields if provided
         agent = updateAgentProfile(
-          requestInfo.agentId,
+          targetAgentId,
           {
             description,
             role,
@@ -143,38 +209,41 @@ export const registerUpdateProfileTool = (server: McpServer) => {
             toolsMd,
           },
           {
-            changeSource: "self_edit",
+            changeSource: isUpdatingSelf ? "self_edit" : "lead_coaching",
             changedByAgentId: requestInfo.agentId,
           },
         );
 
-        // Write updated files to workspace so changes are visible immediately
-        if (soulMd !== undefined) {
-          try {
-            await Bun.write("/workspace/SOUL.md", soulMd);
-          } catch {
-            /* ignore */
+        // Write updated files to workspace only when updating self
+        // (remote agent files live on their own container)
+        if (isUpdatingSelf) {
+          if (soulMd !== undefined) {
+            try {
+              await Bun.write("/workspace/SOUL.md", soulMd);
+            } catch {
+              /* ignore */
+            }
           }
-        }
-        if (identityMd !== undefined) {
-          try {
-            await Bun.write("/workspace/IDENTITY.md", identityMd);
-          } catch {
-            /* ignore */
+          if (identityMd !== undefined) {
+            try {
+              await Bun.write("/workspace/IDENTITY.md", identityMd);
+            } catch {
+              /* ignore */
+            }
           }
-        }
-        if (setupScript !== undefined) {
-          try {
-            await Bun.write("/workspace/start-up.sh", `#!/bin/bash\n${setupScript}\n`);
-          } catch {
-            /* ignore */
+          if (setupScript !== undefined) {
+            try {
+              await Bun.write("/workspace/start-up.sh", `#!/bin/bash\n${setupScript}\n`);
+            } catch {
+              /* ignore */
+            }
           }
-        }
-        if (toolsMd !== undefined) {
-          try {
-            await Bun.write("/workspace/TOOLS.md", toolsMd);
-          } catch {
-            /* ignore */
+          if (toolsMd !== undefined) {
+            try {
+              await Bun.write("/workspace/TOOLS.md", toolsMd);
+            } catch {
+              /* ignore */
+            }
           }
         }
 
@@ -200,12 +269,15 @@ export const registerUpdateProfileTool = (server: McpServer) => {
         if (setupScript !== undefined) updatedFields.push("setupScript");
         if (toolsMd !== undefined) updatedFields.push("toolsMd");
 
+        const targetLabel = isUpdatingSelf ? "own" : `agent ${targetAgentId}`;
         return {
-          content: [{ type: "text", text: `Updated profile: ${updatedFields.join(", ")}.` }],
+          content: [
+            { type: "text", text: `Updated ${targetLabel} profile: ${updatedFields.join(", ")}.` },
+          ],
           structuredContent: {
             yourAgentId: requestInfo.agentId,
             success: true,
-            message: `Updated profile: ${updatedFields.join(", ")}.`,
+            message: `Updated ${targetLabel} profile: ${updatedFields.join(", ")}.`,
             agent,
           },
         };

package/src/tools/workflows/create-workflow.ts

@@ -44,6 +44,19 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
           .describe(
             "Optional input values resolved at execution time (env vars like VAR_NAME, secrets secret.NAME, or literals)",
           ),
+        dir: z
+          .string()
+          .min(1)
+          .startsWith("/")
+          .optional()
+          .describe(
+            "Default working directory for all agent-task nodes (absolute path, e.g. /tmp/workspace)",
+          ),
+        vcsRepo: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Default VCS repo for all agent-task nodes (e.g. org/repo)"),
       }),
       outputSchema: z.object({
         yourAgentId: z.string().optional(),
@@ -52,7 +65,10 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
         workflow: z.unknown().optional(),
       }),
     },
-    async ({ name, description, definition, triggers, cooldown, input }, requestInfo) => {
+    async (
+      { name, description, definition, triggers, cooldown, input, dir, vcsRepo },
+      requestInfo,
+    ) => {
       if (!requestInfo.agentId) {
         return {
           content: [{ type: "text" as const, text: "Agent ID required." }],
@@ -84,6 +100,8 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
           triggers,
           cooldown,
           input,
+          dir,
+          vcsRepo,
           createdByAgentId: requestInfo.agentId,
         });
         return {

package/src/tools/workflows/update-workflow.ts

@@ -33,6 +33,19 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
           .optional()
           .nullable()
           .describe("New input values (null to remove)"),
+        dir: z
+          .string()
+          .min(1)
+          .startsWith("/")
+          .optional()
+          .nullable()
+          .describe("Default working directory for all agent-task nodes (null to remove)"),
+        vcsRepo: z
+          .string()
+          .min(1)
+          .optional()
+          .nullable()
+          .describe("Default VCS repo for all agent-task nodes (null to remove)"),
         enabled: z.boolean().optional().describe("Enable or disable the workflow"),
       }),
       outputSchema: z.object({
@@ -43,7 +56,7 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
       }),
     },
     async (
-      { id, name, description, definition, triggers, cooldown, input, enabled },
+      { id, name, description, definition, triggers, cooldown, input, dir, vcsRepo, enabled },
       requestInfo,
     ) => {
       try {
@@ -85,6 +98,8 @@ export const registerUpdateWorkflowTool = (server: McpServer) => {
           triggers,
           cooldown: cooldown === null ? null : cooldown,
           input: input === null ? null : input,
+          dir: dir === null ? null : dir,
+          vcsRepo: vcsRepo === null ? null : vcsRepo,
           enabled,
         });
         if (!workflow) {

package/src/types.ts

@@ -543,6 +543,8 @@ export const ActiveSessionSchema = z.object({
   triggerType: z.string(),
   inboxMessageId: z.string().nullable(),
   taskDescription: z.string().nullable(),
+  runnerSessionId: z.string().nullable(),
+  providerSessionId: z.string().nullable(),
   startedAt: z.iso.datetime(),
   lastHeartbeatAt: z.iso.datetime(),
 });
@@ -608,10 +610,10 @@ export const WorkflowNodeSchema = z.object({
         "while node-level outputSchema validates the EXECUTOR's return value ({taskId, taskOutput}).",
     ),
   next: z
-    .union([z.string(), z.record(z.string(), z.string())])
+    .union([z.string(), z.array(z.string()), z.record(z.string(), z.string())])
     .optional()
     .describe(
-      "Next node(s): string for simple chaining, or record for port-based routing ({pass: 'a', fail: 'b'})",
+      "Next node(s): string for simple chaining, string[] for fan-out to parallel nodes, or record for port-based routing ({pass: 'a', fail: 'b'})",
     ),
   validation: StepValidationConfigSchema.optional(),
   retry: RetryPolicySchema.optional(),
@@ -653,6 +655,15 @@ export type WorkflowEdge = z.infer<typeof WorkflowEdgeSchema>;
 
 export const WorkflowDefinitionSchema = z.object({
   nodes: z.array(WorkflowNodeSchema).min(1),
+  onNodeFailure: z
+    .enum(["fail", "continue"])
+    .default("fail")
+    .describe(
+      "Behavior when a node's task fails or is cancelled. " +
+        "'fail' (default): mark the entire run as failed. " +
+        "'continue': treat the failed node as completed with error output and proceed — " +
+        "downstream convergence nodes receive '[FAILED: reason]' and can handle partial results.",
+    ),
 });
 export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
 
@@ -727,6 +738,8 @@ export const WorkflowSnapshotSchema = z.object({
   cooldown: CooldownConfigSchema.optional(),
   input: z.record(z.string(), InputValueSchema).optional(),
   triggerSchema: z.record(z.string(), z.unknown()).optional(),
+  dir: z.string().min(1).startsWith("/").optional(),
+  vcsRepo: z.string().min(1).optional(),
   enabled: z.boolean(),
 });
 export type WorkflowSnapshot = z.infer<typeof WorkflowSnapshotSchema>;
@@ -743,6 +756,8 @@ export const WorkflowSchema = z.object({
   cooldown: CooldownConfigSchema.optional(),
   input: z.record(z.string(), InputValueSchema).optional(),
   triggerSchema: z.record(z.string(), z.unknown()).optional(),
+  dir: z.string().min(1).startsWith("/").optional(),
+  vcsRepo: z.string().min(1).optional(),
   createdByAgentId: z.string().uuid().optional(),
   createdAt: z.string(),
   lastUpdatedAt: z.string(),
@@ -816,3 +831,95 @@ export const WorkflowRunStepSchema = z.object({
   nextPort: z.string().optional(),
 });
 export type WorkflowRunStep = z.infer<typeof WorkflowRunStepSchema>;
+
+// ============================================================================
+// Prompt Template Types
+// ============================================================================
+
+export const PromptTemplateScopeSchema = z.enum(["global", "agent", "repo"]);
+export const PromptTemplateStateSchema = z.enum([
+  "enabled",
+  "default_prompt_fallback",
+  "skip_event",
+]);
+
+export const PromptTemplateSchema = z.object({
+  id: z.string(),
+  eventType: z.string(),
+  scope: PromptTemplateScopeSchema,
+  scopeId: z.string().nullable(),
+  state: PromptTemplateStateSchema,
+  body: z.string(),
+  isDefault: z.boolean(),
+  version: z.number(),
+  createdBy: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type PromptTemplate = z.infer<typeof PromptTemplateSchema>;
+
+export const PromptTemplateHistorySchema = z.object({
+  id: z.string(),
+  templateId: z.string(),
+  version: z.number(),
+  body: z.string(),
+  state: z.string(),
+  changedBy: z.string().nullable(),
+  changedAt: z.string(),
+  changeReason: z.string().nullable(),
+});
+export type PromptTemplateHistory = z.infer<typeof PromptTemplateHistorySchema>;
+
+// ============================================================================
+// Skill Types
+// ============================================================================
+
+export const SkillTypeSchema = z.enum(["remote", "personal"]);
+export type SkillType = z.infer<typeof SkillTypeSchema>;
+
+export const SkillScopeSchema = z.enum(["global", "swarm", "agent"]);
+export type SkillScope = z.infer<typeof SkillScopeSchema>;
+
+export const SkillSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  content: z.string(),
+  type: SkillTypeSchema,
+  scope: SkillScopeSchema,
+  ownerAgentId: z.string().nullable(),
+  sourceUrl: z.string().nullable(),
+  sourceRepo: z.string().nullable(),
+  sourcePath: z.string().nullable(),
+  sourceBranch: z.string(),
+  sourceHash: z.string().nullable(),
+  isComplex: z.boolean(),
+  allowedTools: z.string().nullable(),
+  model: z.string().nullable(),
+  effort: z.string().nullable(),
+  context: z.string().nullable(),
+  agent: z.string().nullable(),
+  disableModelInvocation: z.boolean(),
+  userInvocable: z.boolean(),
+  version: z.number(),
+  isEnabled: z.boolean(),
+  createdAt: z.string(),
+  lastUpdatedAt: z.string(),
+  lastFetchedAt: z.string().nullable(),
+});
+export type Skill = z.infer<typeof SkillSchema>;
+
+export const AgentSkillSchema = z.object({
+  id: z.string(),
+  agentId: z.string(),
+  skillId: z.string(),
+  isActive: z.boolean(),
+  installedAt: z.string(),
+});
+export type AgentSkill = z.infer<typeof AgentSkillSchema>;
+
+export const SkillWithInstallInfoSchema = SkillSchema.extend({
+  isActive: z.boolean(),
+  installedAt: z.string(),
+});
+export type SkillWithInstallInfo = z.infer<typeof SkillWithInstallInfoSchema>;