@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/workflows/resume.ts

@@ -1,4 +1,5 @@
 import {
+  getCompletedStepNodeIds,
   getWorkflow,
   getWorkflowRun,
   getWorkflowRunStep,
@@ -7,8 +8,7 @@ import {
   updateWorkflowRunStep,
 } from "../be/db";
 import { checkpointStep } from "./checkpoint";
-import { getSuccessors } from "./definition";
-import { walkGraph } from "./engine";
+import { findReadyNodes, walkGraph } from "./engine";
 import type { WorkflowEventBus } from "./event-bus";
 import type { ExecutorRegistry } from "./executors/registry";
 
@@ -21,6 +21,14 @@ interface TaskEvent {
   failureReason?: string;
 }
 
+interface ApprovalEvent {
+  requestId: string;
+  status: "approved" | "rejected" | "timeout";
+  responses: Record<string, unknown> | null;
+  workflowRunId?: string;
+  workflowRunStepId?: string;
+}
+
 /**
  * Wire up event bus listeners for workflow resume on task lifecycle events.
  */
@@ -41,13 +49,31 @@ export function setupWorkflowResumeListener(
   eventBus.on("task.failed", async (data: unknown) => {
     const event = data as TaskEvent;
     if (!event.workflowRunId || !event.workflowRunStepId) return;
-    markRunFailed(event, event.failureReason ?? "Task failed");
+    try {
+      await handleTaskFailure(event, event.failureReason ?? "Task failed", registry);
+    } catch (err) {
+      console.error("[workflows] Handle task failure error:", err);
+    }
   });
 
   eventBus.on("task.cancelled", async (data: unknown) => {
     const event = data as TaskEvent;
     if (!event.workflowRunId || !event.workflowRunStepId) return;
-    markRunFailed(event, "Task was cancelled");
+    try {
+      await handleTaskFailure(event, "Task was cancelled", registry);
+    } catch (err) {
+      console.error("[workflows] Handle task cancellation error:", err);
+    }
+  });
+
+  eventBus.on("approval.resolved", async (data: unknown) => {
+    const event = data as ApprovalEvent;
+    if (!event.workflowRunId || !event.workflowRunStepId) return;
+    try {
+      await resumeFromApprovalResolution(event, registry);
+    } catch (err) {
+      console.error("[workflows] Resume from approval resolution failed:", err);
+    }
   });
 }
 
@@ -64,7 +90,7 @@ async function resumeFromTaskCompletion(
   registry: ExecutorRegistry,
 ): Promise<void> {
   const run = getWorkflowRun(event.workflowRunId!);
-  if (!run || run.status !== "waiting") return;
+  if (!run || (run.status !== "waiting" && run.status !== "running")) return;
 
   const step = getWorkflowRunStep(event.workflowRunStepId!);
   if (!step || step.status !== "waiting") return;
@@ -94,9 +120,80 @@ async function resumeFromTaskCompletion(
   // Set run back to running
   updateWorkflowRun(run.id, { status: "running" });
 
-  // Find successors and continue DAG walk
-  const successors = getSuccessors(workflow.definition, step.nodeId, "default");
-  await walkGraph(workflow.definition, run.id, ctx, successors, registry, workflow.id);
+  // Use convergence-aware node detection instead of blindly passing successors.
+  // This prevents duplicate step creation for convergence nodes (e.g., fan-out → merge).
+  // findReadyNodes checks ALL predecessors are completed before marking a node ready.
+  const completedNodeIds = new Set(getCompletedStepNodeIds(run.id));
+  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
+
+  if (readyNodes.length > 0) {
+    await walkGraph(workflow.definition, run.id, ctx, readyNodes, registry, workflow.id);
+  } else {
+    finalizeOrWait(run.id);
+  }
+}
+
+/**
+ * If no nodes are ready and no steps are still waiting, finalize the run.
+ * Otherwise set it back to waiting for the next task completion.
+ */
+export function finalizeOrWait(runId: string): void {
+  const steps = getWorkflowRunStepsByRunId(runId);
+  const hasWaiting = steps.some((s) => s.status === "waiting");
+  if (hasWaiting) {
+    updateWorkflowRun(runId, { status: "waiting" });
+  } else {
+    // All steps done (completed or failed) — finalize the run
+    updateWorkflowRun(runId, {
+      status: "completed",
+      finishedAt: new Date().toISOString(),
+    });
+  }
+}
+
+/**
+ * Handle task failure/cancellation — respects workflow's onNodeFailure config.
+ * 'fail' (default): mark the entire run as failed.
+ * 'continue': treat as completed with error output, let convergence proceed.
+ */
+async function handleTaskFailure(
+  event: TaskEvent,
+  reason: string,
+  registry: ExecutorRegistry,
+): Promise<void> {
+  const run = getWorkflowRun(event.workflowRunId!);
+  if (!run) return;
+
+  const workflow = getWorkflow(run.workflowId);
+  if (!workflow) return;
+
+  const onFailure = workflow.definition.onNodeFailure ?? "fail";
+
+  if (onFailure === "fail") {
+    markRunFailed(event, reason);
+    return;
+  }
+
+  // "continue": treat as completed with error output
+  const step = getWorkflowRunStep(event.workflowRunStepId!);
+  if (!step) return;
+
+  const ctx = (run.context ?? {}) as Record<string, unknown>;
+  const stepOutput = {
+    taskId: event.taskId,
+    taskOutput: `[FAILED: ${reason}] This node failed or was cancelled.`,
+  };
+  checkpointStep(run.id, step.id, step.nodeId, { output: stepOutput }, ctx);
+
+  updateWorkflowRun(run.id, { status: "running" });
+  const completedNodeIds = new Set(getCompletedStepNodeIds(run.id));
+  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
+
+  if (readyNodes.length > 0) {
+    await walkGraph(workflow.definition, run.id, ctx, readyNodes, registry, workflow.id);
+  } else {
+    finalizeOrWait(run.id);
+  }
 }
 
 /**
@@ -136,8 +233,61 @@ export async function retryFailedRun(runId: string, registry: ExecutorRegistry):
   const ctx = (run.context ?? {}) as Record<string, unknown>;
   updateWorkflowRun(runId, { status: "running", error: undefined, context: ctx });
 
-  // Resume from the failed node
-  const node = workflow.definition.nodes.find((n) => n.id === failedStep.nodeId);
-  if (!node) throw new Error(`Node ${failedStep.nodeId} not found in workflow definition`);
-  await walkGraph(workflow.definition, runId, ctx, [node], registry, workflow.id);
+  // Resume from the failed node — use findReadyNodes for convergence safety
+  const completedNodeIds = new Set(getCompletedStepNodeIds(runId));
+  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
+  const failedNode = workflow.definition.nodes.find((n) => n.id === failedStep.nodeId);
+  if (!failedNode) throw new Error(`Node ${failedStep.nodeId} not found in workflow definition`);
+
+  // Include the failed node if it's not already in ready nodes
+  const nodesToRun = readyNodes.some((n) => n.id === failedNode.id)
+    ? readyNodes
+    : [failedNode, ...readyNodes];
+  await walkGraph(workflow.definition, runId, ctx, nodesToRun, registry, workflow.id);
+}
+
+/**
+ * Resume a workflow after a linked approval request is resolved.
+ *
+ * 1. Verify run and step are in "waiting" state
+ * 2. Checkpoint step completion with approval response data
+ * 3. Route to the appropriate port (approved/rejected/timeout)
+ * 4. Continue the graph walk
+ */
+async function resumeFromApprovalResolution(
+  event: ApprovalEvent,
+  registry: ExecutorRegistry,
+): Promise<void> {
+  const run = getWorkflowRun(event.workflowRunId!);
+  if (!run || (run.status !== "waiting" && run.status !== "running")) return;
+
+  const step = getWorkflowRunStep(event.workflowRunStepId!);
+  if (!step || step.status !== "waiting") return;
+
+  const workflow = getWorkflow(run.workflowId);
+  if (!workflow) return;
+
+  const ctx = (run.context ?? {}) as Record<string, unknown>;
+
+  // Determine output port based on approval status
+  const nextPort =
+    event.status === "timeout" ? "timeout" : event.status === "rejected" ? "rejected" : "approved";
+
+  const stepOutput = {
+    requestId: event.requestId,
+    status: event.status,
+    responses: event.responses,
+  };
+
+  checkpointStep(run.id, step.id, step.nodeId, { output: stepOutput, nextPort }, ctx);
+  updateWorkflowRun(run.id, { status: "running" });
+
+  const completedNodeIds = new Set(getCompletedStepNodeIds(run.id));
+  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
+
+  if (readyNodes.length > 0) {
+    await walkGraph(workflow.definition, run.id, ctx, readyNodes, registry, workflow.id);
+  } else {
+    finalizeOrWait(run.id);
+  }
 }

package/src/workflows/triggers.ts

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
-import { getWorkflow } from "../be/db";
-import type { TriggerConfig } from "../types";
+import { getWorkflow, getWorkflowsByScheduleId } from "../be/db";
+import type { ScheduledTask, TriggerConfig } from "../types";
 import { startWorkflowExecution } from "./engine";
 import type { ExecutorRegistry } from "./executors/registry";
 
@@ -52,6 +52,35 @@ export async function handleWebhookTrigger(
   return { runId };
 }
 
+/**
+ * Handle a schedule trigger: find workflows linked to this schedule and execute them.
+ * Returns an array of workflow run IDs. Empty array means no workflows matched
+ * (caller should fall through to standalone task creation).
+ */
+export async function handleScheduleTrigger(
+  scheduleId: string,
+  schedule: ScheduledTask,
+  registry: ExecutorRegistry,
+): Promise<string[]> {
+  const workflows = getWorkflowsByScheduleId(scheduleId);
+  if (workflows.length === 0) return [];
+
+  const runIds: string[] = [];
+  for (const workflow of workflows) {
+    const triggerData = {
+      scheduleId,
+      scheduleName: schedule.name,
+      firedAt: new Date().toISOString(),
+    };
+    const runId = await startWorkflowExecution(workflow, triggerData, registry);
+    runIds.push(runId);
+    console.log(
+      `[Triggers] Schedule "${schedule.name}" triggered workflow "${workflow.name}" (run: ${runId})`,
+    );
+  }
+  return runIds;
+}
+
 /**
  * Verify HMAC-SHA256 signature.
  * Supports both `sha256=<hex>` format and raw hex.

package/src/workflows/version.ts

@@ -30,6 +30,8 @@ export function snapshotWorkflow(workflowId: string, changedByAgentId?: string):
     cooldown: workflow.cooldown,
     input: workflow.input,
     triggerSchema: workflow.triggerSchema,
+    dir: workflow.dir,
+    vcsRepo: workflow.vcsRepo,
     enabled: workflow.enabled,
   };
 

package/.claude/settings.json

@@ -1,84 +0,0 @@
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code post-task"
-          }
-        ]
-      },
-      {
-        "matcher": "TodoWrite",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code post-todo"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code pre-task"
-          }
-        ]
-      }
-    ],
-    "SessionEnd": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code session-end"
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code session-start"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code stop"
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code user-prompt-submit"
-          }
-        ]
-      }
-    ]
-  },
-  "permissions": {
-    "deny": [
-      "Read(./.entire/metadata/**)"
-    ]
-  }
-}

package/.claude/settings.local.json

@@ -1,117 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "mcp__agent-swarm__*",
-      "Bash(bun run tsc:*)",
-      "Bash(docker build:*)",
-      "Skill(frontend-design:frontend-design)",
-      "Bash(gh repo view:*)",
-      "WebSearch",
-      "WebFetch(domain:www.claude.com)",
-      "WebFetch(domain:simonwillison.net)",
-      "WebFetch(domain:deepwiki.com)",
-      "WebFetch(domain:docs.claude.com)",
-      "Bash(bun run tsc:check:*)",
-      "Bash(bun tsc:*)",
-      "Bash(bun run lint:*)",
-      "Bash(bun run format:*)",
-      "Bash(sqlite3:*)",
-      "Bash(cat:*)",
-      "mcp__context7__resolve-library-id",
-      "mcp__context7__get-library-docs",
-      "Bash(bun run build:*)",
-      "Bash(pnpm run build:*)",
-      "WebFetch(domain:geminicli.com)",
-      "Bash(bun run docs:mcp:*)",
-      "Bash(bun test:*)",
-      "Bash(curl:*)",
-      "WebFetch(domain:github.com)",
-      "Bash(gh pr checks:*)",
-      "Bash(gh run view:*)",
-      "Bash(timeout 5 bun run:*)",
-      "Bash(bun run typecheck:*)",
-      "Bash(npx tsc:*)",
-      "WebFetch(domain:docs.github.com)",
-      "Bash(bun run lint:fix:*)",
-      "Skill(desplega:research)",
-      "Bash(bun run check:*)",
-      "Bash(bun build:*)",
-      "WebFetch(domain:www.npmjs.com)",
-      "Bash(sentry-cli:*)"
-    ]
-  },
-  "enableAllProjectMcpServers": true,
-  "enabledMcpjsonServers": [
-    "agent-swarm"
-  ],
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ],
-    "PreCompact": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bun run \"$CLAUDE_PROJECT_DIR\"/src/hooks/hook.ts"
-          }
-        ]
-      }
-    ]
-  },
-  "spinnerTipsEnabled": false,
-  "prefersReducedMotion": true
-}

package/.dockerignore

@@ -1,61 +0,0 @@
-# Dependencies
-node_modules/
-
-# Logs
-logs/
-*.log
-
-# Bindings
-work/
-
-# Database
-*.sqlite
-*.sqlite-wal
-*.sqlite-shm
-
-# Git
-.git/
-.gitignore
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Build artifacts
-dist/
-build/
-*.tsbuildinfo
-
-# Environment files (secrets should be passed via env vars)
-.env
-.env.*
-!.env.example
-
-# Backup files
-*.bak
-
-# Claude local config (will be created in container)
-.claude/
-.mcp.json
-
-# Test files
-*.test.ts
-*.spec.ts
-__tests__/
-coverage/
-
-# Documentation
-*.md
-!cc-plugin/**/*.md
-
-# Other dockerfiles and compose files
-Dockerfile
-docker-compose.yml
-docker-compose.*.yml
-!docker-compose.worker.yml

package/.editorconfig

@@ -1,15 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_style = space
-indent_size = 2
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.md]
-trim_trailing_whitespace = false
-
-[*.json]
-indent_size = 2

package/.entire/settings.json

@@ -1,4 +0,0 @@
-{
-  "enabled": true,
-  "telemetry": false
-}

package/.env.docker.example

@@ -1,56 +0,0 @@
-# Docker Worker / Lead Agent Environment Variables
-# Copy this file to .env.docker and fill in your values
-# Full reference: docs/ENVS.md
-
-# ---- Required ----
-# Run `claude setup-token` to get your OAuth token
-CLAUDE_CODE_OAUTH_TOKEN=your-oauth-token-here
-API_KEY=your-api-key-here
-
-# ---- Agent Identity ----
-# Keep AGENT_ID stable across restarts for task resume and identity persistence
-AGENT_ID=
-AGENT_NAME=
-AGENT_ROLE=worker                       # "worker" or "lead"
-
-# ---- Networking ----
-MCP_BASE_URL=http://host.docker.internal:3013
-SWARM_URL=swarm.example.com             # Base domain for service discovery
-# Host ports for exposed services (used in docker-compose.example.yml).
-# These names and defaults are examples — adjust to fit your setup.
-# In isolated environments (each container in its own network namespace),
-# you can map all services to the same port (e.g. 3000:3000).
-# LEAD_PORT=3020
-# WORKER1_PORT=3021
-# WORKER2_PORT=3022
-
-# ---- Behavior ----
-YOLO=false                               # Keep spawning sessions even if one fails
-# MAX_CONCURRENT_TASKS=1                 # Parallel tasks (default: 1 for worker, 2 for lead)
-# SHUTDOWN_TIMEOUT=30000                 # Grace period (ms) before pausing tasks on shutdown
-
-# ---- Logging ----
-# SESSION_ID=                            # Reuse to continue logging to the same folder
-# LOG_DIR=/logs                          # Base directory for session logs
-
-# ---- System Prompt (optional) ----
-SYSTEM_PROMPT=
-SYSTEM_PROMPT_FILE=
-
-# ---- Templates (optional) ----
-# TEMPLATE_ID=official/coder             # Template for initial profile (fetched on first boot)
-# TEMPLATE_REGISTRY_URL=https://templates.agent-swarm.dev
-
-# ---- Startup ----
-STARTUP_SCRIPT_STRICT=true               # Exit if startup script fails
-
-# ---- GitHub (for git operations) ----
-GITHUB_TOKEN=                            # Personal access token for gh CLI and git push
-GITHUB_EMAIL=worker-agent@desplega.ai    # Git commit email
-GITHUB_NAME=Worker Agent                 # Git commit name
-
-# ---- Sentry (optional) ----
-# Create an Organization Auth Token at https://sentry.io/settings/{org}/auth-tokens/
-# Required scopes: event:read, project:read, org:read
-SENTRY_AUTH_TOKEN=
-SENTRY_ORG=