@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/dist/{cli-25j01dpj.js → cli-24j1jeeb.js}

@@ -2,17 +2,17 @@ import {
   getKv2,
   upsertKv2,
   init_db3
-} from "./cli-kxawjrxg.js";
+} from "./cli-g8ka5j4j.js";
 import {
   resolveIdentity,
   recordUnmappedIdentity
-} from "./cli-aecdcr77.js";
+} from "./cli-4hxrf0p4.js";
 import {
   findUserByExternalId,
   findOrCreateUserByEmail,
   linkIdentity,
   init_users
-} from "./cli-e8jyq7d8.js";
+} from "./cli-esakngh8.js";
 
 // src/slack/enrich.ts
 init_db3();

package/dist/{cli-ta8bd7th.js → cli-2sjhpsns.js}

@@ -13,11 +13,11 @@ import {
   claudeMdLineageOf,
   planClaudeMdSync,
   init_profile_sync
-} from "./cli-gpv60278.js";
+} from "./cli-hfeb68z4.js";
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-n4c8e3s5.js";
+} from "./cli-708wdy32.js";
 
 // src/commands/claude-md-session.ts
 init_file_lock();

package/dist/{cli-p859hcc8.js → cli-39aet655.js}

@@ -13,11 +13,11 @@ async function createRuntimeProvider(kind, target = {}) {
       return new StaticRuntimeProvider;
     }
     case "docker": {
-      const { DockerRuntimeProvider } = await import("./docker-nfy2gc8t.js");
+      const { DockerRuntimeProvider } = await import("./docker-fdzyewpz.js");
       return new DockerRuntimeProvider;
     }
     case "e2b": {
-      const { E2BRuntimeProvider } = await import("./e2b-cjtf8k1z.js");
+      const { E2BRuntimeProvider } = await import("./e2b-fn3zacvt.js");
       return new E2BRuntimeProvider(target);
     }
     case "k8s":

package/dist/{cli-g1cw7xtt.js → cli-39rrw8yp.js}

@@ -1,7 +1,7 @@
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-n4c8e3s5.js";
+} from "./cli-708wdy32.js";
 
 // src/providers/devin-adapter.ts
 init_secret_scrubber();

package/dist/{cli-e2ar4bp1.js → cli-3aqd4jaa.js}

@@ -1,7 +1,18 @@
 import {
   getDbClient2,
+  listUndeliveredCancelledApprovalRequestIds,
+  init_approvals,
   getTaskById2,
   cancelTask2,
+  getRunLineageBlock,
+  getWorkflowRunTreeIds,
+  getWorkflowRunStatus,
+  getOpenWorkflowTreeTaskIds,
+  getTaskIdsWithDependents,
+  workflowRunTreeHasOpenWork,
+  cancelOpenWorkflowTreeSteps,
+  disarmWorkflowTreeRetries,
+  cancelLiveWorkflowTreeRuns,
   getChildWorkflowRunId,
   getWorkflowRunLineage,
   createForeachAttemptSteps,
@@ -15,14 +26,14 @@ import {
   getCompletedStepNodeIds2,
   getTaskByWorkflowRunStepId2,
   detachTaskFromWorkflowRunStep2,
+  getApprovalRequestById2,
   cancelPendingApprovalRequestsForRun2,
-  listCancelledApprovalRequestsForRun2,
   getWaitStateById2,
   getPendingEventWaitNames2,
   getPendingWaitsByEvent2,
   resolveWaitState2,
   init_db3
-} from "./cli-kxawjrxg.js";
+} from "./cli-g8ka5j4j.js";
 import {
   BaseExecutor,
   postApprovalCancellationUpdates,
@@ -42,6 +53,7 @@ import {
   findReadyNodes,
   startForeachDrive,
   FOREACH_TERMINAL_STEP_STATUSES,
+  isRetryPending,
   parseSyntheticNodeId,
   resolveForeachParent,
   settleForeachChild,
@@ -49,16 +61,16 @@ import {
   stepFailureMode,
   getNextTargets,
   getSuccessors
-} from "./cli-jjznk3f7.js";
+} from "./cli-3fwqy71j.js";
 import {
   workflowEventBus2,
   init_event_bus
-} from "./cli-dabehxhp.js";
+} from "./cli-kt907da6.js";
 import {
   RetryPolicySchema,
   SUPERSEDED_WORKFLOW_TASK_REASON,
   init_types
-} from "./cli-mz9afxxf.js";
+} from "./cli-4rf0f5vg.js";
 import {
   init_zod
 } from "./cli-4chz1hye.js";
@@ -76,7 +88,7 @@ import {
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-n4c8e3s5.js";
+} from "./cli-708wdy32.js";
 
 // src/workflows/approval-resolution.ts
 function shapeApprovalResolution(registry, definition, nodeId, parkedOutput, approval) {
@@ -98,6 +110,7 @@ function shapeApprovalResolution(registry, definition, nodeId, parkedOutput, app
 
 // src/workflows/resume.ts
 init_db3();
+init_approvals();
 init_workflow_runs();
 init_types();
 init_secret_scrubber();
@@ -184,8 +197,13 @@ class SubWorkflowExecutor extends BaseExecutor {
       throw err;
     }
     const child = await db.getWorkflowRun(childRunId);
-    if (!child)
-      return { status: "failed", error: `Child workflow run ${childRunId} not found` };
+    if (!child) {
+      return {
+        status: "failed",
+        error: `Child workflow run ${childRunId} not found`,
+        retryable: false
+      };
+    }
     return this.settle(child, config.workflowId);
   }
   settle(child, workflowId) {
@@ -490,6 +508,7 @@ function computeNextPort(mode, status) {
 
 // src/workflows/task-step-routing.ts
 init_db3();
+init_workflow_runs();
 init_types();
 var UNCLAIMED = {
   claimed: false,
@@ -547,6 +566,8 @@ async function checkpointPortStepAndResolveSuccessors(def, runId, stepId, nodeId
     if (!run || run.status !== "waiting" && run.status !== "running") {
       return UNCLAIMED;
     }
+    if (await getRunLineageBlock(runId))
+      return UNCLAIMED;
     if (resolveForeachParent(def, nodeId)) {
       return toRoutingResult(await settleForeachChild(def, runId, stepId, { status: "completed", output, nextPort }, ctx, {
         registry
@@ -570,12 +591,14 @@ var SUPERSEDE_RETRY_POLICY = {
   maxDelayMs: 30000
 };
 async function scheduleTaskStepRetry(def, runId, step, taskId, reason) {
-  const node = def.nodes.find((n) => n.id === step.nodeId);
+  const foreachParent = resolveForeachParent(def, step.nodeId);
+  const node = resolveStepNode(def, step.nodeId);
   if (!node || node.type !== "agent-task")
     return "not-eligible";
+  const declaredRetry = foreachParent ? foreachParent.retry : node.retry;
   let policy;
-  if (node.retry) {
-    const parsed = RetryPolicySchema.safeParse(node.retry);
+  if (declaredRetry) {
+    const parsed = RetryPolicySchema.safeParse(declaredRetry);
     if (!parsed.success)
       return "not-eligible";
     policy = parsed.data;
@@ -590,6 +613,13 @@ async function scheduleTaskStepRetry(def, runId, step, taskId, reason) {
       return "not-claimed";
     if (!await isTaskBoundToStep(taskId, step.id))
       return "not-claimed";
+    if (foreachParent) {
+      const run = await getWorkflowRun2(runId);
+      if (run?.status !== "running" && run?.status !== "waiting")
+        return "not-eligible";
+    }
+    if (await getRunLineageBlock(runId))
+      return "not-claimed";
     if (current.retryCount >= policy.maxRetries)
       return "not-eligible";
     await detachTaskFromWorkflowRunStep2(taskId);
@@ -610,6 +640,8 @@ async function completeTaskStepAndResolveSuccessors(def, runId, step, output, ct
       return UNCLAIMED;
     if (ownerTaskId && !await isTaskBoundToStep(ownerTaskId, step.id))
       return UNCLAIMED;
+    if (await getRunLineageBlock(runId))
+      return UNCLAIMED;
     if (resolveForeachParent(def, step.nodeId)) {
       return toRoutingResult(await settleForeachChild(def, runId, step.id, {
         status: "completed",
@@ -750,10 +782,14 @@ async function resumeFromTaskCompletionUnguarded(event, registry) {
 }
 async function finalizeOrWait2(runId) {
   await getDbClient2().transaction(async () => {
+    const status = await getWorkflowRunStatus(runId);
+    if (status !== "running" && status !== "waiting")
+      return;
+    if (await getRunLineageBlock(runId))
+      return;
     const steps = await getWorkflowRunStepsByRunId2(runId);
     if (hasRunningStep(steps)) {
-      const run = await getWorkflowRun2(runId);
-      if (run?.status === "waiting")
+      if (status === "waiting")
         await updateWorkflowRun2(runId, { status: "running" });
       return;
     }
@@ -872,6 +908,9 @@ async function retryFailedRun2(runId, registry) {
     const current = await getWorkflowRun2(runId);
     if (!current || current.status !== "failed")
       return null;
+    const blocked = await getRunLineageBlock(runId);
+    if (blocked)
+      throw new Error(`Retry not started, run left failed: ${blocked}`);
     const currentSteps = await getWorkflowRunStepsByRunId2(runId);
     const attempts = foreachRetryAttempts(workflow.definition, [
       ...latestStepPerNode(currentSteps).values()
@@ -879,6 +918,11 @@ async function retryFailedRun2(runId, registry) {
     const capError = foreachRetryCapError(currentSteps.length, attempts);
     if (capError)
       throw new Error(`Retry not started, run left failed: ${capError}`);
+    for (const step of currentSteps) {
+      if (isRetryPending(step) && resolveForeachParent(workflow.definition, step.nodeId)) {
+        await updateWorkflowRunStep2(step.id, { nextRetryAt: null });
+      }
+    }
     if (!foreachParent) {
       await updateWorkflowRunStep2(failedStep.id, {
         status: shouldRetryFailedNode ? "pending" : "cancelled",
@@ -941,52 +985,80 @@ function foreachRetryCapError(existingSteps, attempts) {
     return null;
   return `foreach retry would reach ${maxSteps} total steps (WORKFLOW_MAX_STEPS_PER_RUN): ${existingSteps} existing + ${added} new attempts leaves no room for the retry walk`;
 }
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "cancelled", "skipped"]);
 async function cancelWorkflowRunRows2(runId, cancelReason) {
-  const terminalStatuses = ["completed", "failed", "cancelled", "skipped"];
   const now = new Date().toISOString();
+  const settledTree = await getDbClient2().transaction(async () => {
+    if (await getWorkflowRunStatus(runId) !== "cancelled")
+      return null;
+    const ids = await getWorkflowRunTreeIds(runId);
+    return await workflowRunTreeHasOpenWork(ids) ? null : ids;
+  }, { readOnly: true });
+  if (settledTree)
+    return { cancelled: false, runIds: settledTree };
   return await getDbClient2().transaction(async () => {
-    const current = await getWorkflowRun2(runId);
-    if (!current || terminalStatuses.includes(current.status))
-      return false;
-    const steps = await getWorkflowRunStepsByRunId2(runId);
-    for (const step of steps) {
-      if (terminalStatuses.includes(step.status))
-        continue;
-      const task = await getTaskByWorkflowRunStepId2(step.id);
-      if (task) {
-        await cancelTask2(task.id, cancelReason);
-      }
-      await updateWorkflowRunStep2(step.id, {
-        status: "cancelled",
-        error: cancelReason,
-        finishedAt: now
-      });
+    const rootStatus = await getWorkflowRunStatus(runId);
+    if (!rootStatus || TERMINAL_RUN_STATUSES.has(rootStatus) && rootStatus !== "cancelled") {
+      return { cancelled: false, runIds: [] };
     }
-    await cancelPendingApprovalRequestsForRun2(runId, cancelReason);
-    await updateWorkflowRun2(runId, {
-      status: "cancelled",
-      error: cancelReason,
-      finishedAt: now
-    });
-    return true;
+    const runIds = await getWorkflowRunTreeIds(runId);
+    const openTaskIds = await getOpenWorkflowTreeTaskIds(runIds);
+    const withDependents = openTaskIds.length > 0 ? await getTaskIdsWithDependents() : new Set;
+    for (const taskId of openTaskIds) {
+      await cancelTask2(taskId, cancelReason, { cascadeDependents: withDependents.has(taskId) });
+    }
+    await cancelOpenWorkflowTreeSteps(runIds, cancelReason, now);
+    await disarmWorkflowTreeRetries(runIds, now);
+    for (const id of runIds)
+      await cancelPendingApprovalRequestsForRun2(id, cancelReason);
+    await cancelLiveWorkflowTreeRuns(runIds.slice(1), cancelReason, now);
+    if (rootStatus !== "cancelled") {
+      await updateWorkflowRun2(runId, { status: "cancelled", error: cancelReason, finishedAt: now });
+    }
+    return { cancelled: rootStatus !== "cancelled", runIds };
   });
 }
-async function cancelWorkflowRun2(runId, reason) {
-  const run = await getWorkflowRun2(runId);
+var inFlightCancels = new Map;
+function cancelWorkflowRun2(runId, reason) {
+  const inFlight = inFlightCancels.get(runId);
+  if (inFlight)
+    return inFlight;
+  const cancel = cancelWorkflowRunOnce(runId, reason).finally(() => {
+    inFlightCancels.delete(runId);
+  });
+  inFlightCancels.set(runId, cancel);
+  return cancel;
+}
+async function cancelWorkflowRunOnce(runId, reason) {
+  const run = await getWorkflowRun2(runId, "display");
   if (!run)
     throw new Error("Workflow run not found");
-  const terminalStatuses = ["completed", "failed", "cancelled", "skipped"];
-  if (terminalStatuses.includes(run.status) && run.status !== "cancelled") {
+  if (TERMINAL_RUN_STATUSES.has(run.status) && run.status !== "cancelled") {
     throw new Error(`Cannot cancel run in '${run.status}' state`);
   }
   const cancelReason = reason ?? "Cancelled by user";
-  const applied = await cancelWorkflowRunRows2(runId, cancelReason);
-  const cancelledApprovals = await listCancelledApprovalRequestsForRun2(runId);
-  const latestRun = await getWorkflowRun2(runId);
-  if (!applied && latestRun?.status !== "cancelled") {
+  const { cancelled, runIds } = await cancelWorkflowRunRows2(runId, cancelReason);
+  const latestRun = await getWorkflowRun2(runId, "display");
+  if (!cancelled && latestRun?.status !== "cancelled") {
     throw new Error(`Cannot cancel run in '${latestRun?.status ?? "missing"}' state`);
   }
-  await postApprovalCancellationUpdates(cancelledApprovals, applied ? cancelReason : latestRun?.error ?? cancelReason);
+  await postTreeApprovalCancellations2(runIds, cancelled ? cancelReason : latestRun?.error ?? cancelReason);
+}
+async function postTreeApprovalCancellations2(runIds, reason, options = {}) {
+  try {
+    const approvals = [];
+    for (const id of await listUndeliveredCancelledApprovalRequestIds(runIds)) {
+      if (id === options.exceptRequestId)
+        continue;
+      const approval = await getApprovalRequestById2(id);
+      if (approval)
+        approvals.push(approval);
+    }
+    if (approvals.length > 0)
+      await postApprovalCancellationUpdates(approvals, reason);
+  } catch (err) {
+    console.error("[workflows] approval cancellation updates not posted:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+  }
 }
 async function resumeFromApprovalResolution(event, registry) {
   await failClosedOnUnreadableReplay(event.workflowRunId, event.workflowRunStepId, () => resumeFromApprovalResolutionUnguarded(event, registry));
@@ -1084,6 +1156,8 @@ async function resumeFromChildRun2(parentStepId, registry) {
       const current = await getWorkflowRunStep2(step.id);
       if (!current || current.status !== "waiting")
         return null;
+      if (await getRunLineageBlock(run.id))
+        return null;
       const childId = await getChildWorkflowRunId(step.id, current.retryCount);
       const child = childId ? await getWorkflowRun2(childId) : null;
       const outcome = child ? childRunOutcome(child) : { error: `Child workflow run of step ${parentStepId} was deleted`, retryable: false };
@@ -1241,4 +1315,4 @@ function isPayloadInRun(payload, runId) {
   const rec = payload;
   return rec._runId === runId || rec.workflowRunId === runId;
 }
-export { shapeApprovalResolution, SubWorkflowExecutor, WaitExecutor, failStepAndRunIfWaiting, checkpointPortStepAndResolveSuccessors, scheduleTaskStepRetry, completeTaskStepAndResolveSuccessors, setupWorkflowResumeListener2, finalizeOrWait2, retryFailedRun2, cancelWorkflowRunRows2, cancelWorkflowRun2, resumeWaitState2, recoverResolvedWaitState2, resumeFromChildRun2, initWaitBusSubscriptions2, subscribeWaitToBus2 };
+export { shapeApprovalResolution, SubWorkflowExecutor, WaitExecutor, failStepAndRunIfWaiting, checkpointPortStepAndResolveSuccessors, scheduleTaskStepRetry, completeTaskStepAndResolveSuccessors, setupWorkflowResumeListener2, finalizeOrWait2, retryFailedRun2, cancelWorkflowRunRows2, cancelWorkflowRun2, postTreeApprovalCancellations2, resumeWaitState2, recoverResolvedWaitState2, resumeFromChildRun2, initWaitBusSubscriptions2, subscribeWaitToBus2 };