@desplega.ai/agent-swarm 2.5.3 → 2.5.4

package/src/tools/workflows/cancel-workflow-run.ts

@@ -10,7 +10,7 @@ export const registerCancelWorkflowRunTool = (server: McpServer) => {
       title: "Cancel Workflow Run",
       annotations: { destructiveHint: true },
       description:
-        "Cancel a running or waiting workflow run. Cancels all non-terminal steps and their associated tasks.",
+        "Cancel a running or waiting workflow run and every child run below it. Cancels their non-terminal steps, tasks, pending approvals and queued retries in one transaction; finished child runs keep their status. Repeating the cancel on a cancelled run finishes any child runs still open.",
       inputSchema: z.object({
         runId: z.string().uuid().describe("Workflow run ID to cancel"),
         reason: z.string().optional().describe("Optional reason for cancellation"),

package/src/utils/context-window.ts

@@ -67,7 +67,12 @@ function catalogContext(provider: string, model: string): number | undefined {
  * Unknown models get a conservative 200k so percent math stays finite.
  */
 export function getContextWindowSize(model: string): number {
-  if (!model) return DEFAULT_CONTEXT_WINDOW;
+  return getKnownContextWindowSize(model) ?? DEFAULT_CONTEXT_WINDOW;
+}
+
+/** {@link getContextWindowSize} without the fallback: undefined when the catalog has no window. */
+export function getKnownContextWindowSize(model: string | undefined): number | undefined {
+  if (!model) return undefined;
   const slash = model.indexOf("/");
   if (slash > 0) {
     const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));
@@ -83,11 +88,8 @@ export function getContextWindowSize(model: string): number {
     if (dated) return dated;
   }
   const shortname = resolveClaudeShortname(model);
-  if (shortname) {
-    const resolved = catalogContext("anthropic", shortname);
-    if (resolved) return resolved;
-  }
-  return DEFAULT_CONTEXT_WINDOW;
+  if (shortname) return catalogContext("anthropic", shortname);
+  return undefined;
 }
 
 /**

package/src/workflows/approval-cancel.ts

@@ -4,16 +4,15 @@ import {
   getApprovalRequestById,
   getDbClient,
   getTaskById,
-  getWorkflowRun,
-  listCancelledApprovalRequestsForRun,
   resolveApprovalRequest,
 } from "../be/db";
+import { getWorkflowRunStatus } from "../be/db/workflow-runs";
 import { can, type RbacPrincipal } from "../rbac";
 import {
   createApprovalFollowUpTask,
   postApprovalCancellationUpdates,
 } from "./approval-notifications";
-import { cancelWorkflowRunRows } from "./resume";
+import { cancelWorkflowRunRows, postTreeApprovalCancellations } from "./resume";
 
 export type CancelApprovalRequestResult =
   | { ok: true; request: ApprovalRequest; alreadyCancelled: boolean; runCancelled: boolean }
@@ -126,25 +125,28 @@ export async function cancelApprovalRequestAndRun(
     if (!request) return null;
 
     // The request is cancelled first so it keeps this reason; the run cancel
-    // then skips it because it is no longer pending.
+    // then skips it because it is no longer pending. The run's child tree is
+    // cancelled with it.
     let runCancelled = false;
+    let treeRunIds: string[] = [];
     const runId = request.workflowRunId;
     if (runId) {
-      const run = await getWorkflowRun(runId);
-      if (run && LIVE_RUN_STATUSES.has(run.status)) {
-        runCancelled = await cancelWorkflowRunRows(runId, data.reason);
+      const status = await getWorkflowRunStatus(runId);
+      if (status && LIVE_RUN_STATUSES.has(status)) {
+        const result = await cancelWorkflowRunRows(runId, data.reason);
+        runCancelled = result.cancelled;
+        treeRunIds = result.runIds;
       }
     }
 
     const slackReason = data.slackReason ?? data.reason;
     client.afterCommit(async () => {
       await postApprovalCancellationUpdates([request], slackReason);
-      if (runCancelled && runId) {
-        // Other requests the run cancel closed get the run's reason.
-        const others = (await listCancelledApprovalRequestsForRun(runId)).filter(
-          (row) => row.id !== request.id,
-        );
-        await postApprovalCancellationUpdates(others, data.reason);
+      if (runCancelled) {
+        // Other requests the tree cancel closed get the run's reason.
+        await postTreeApprovalCancellations(treeRunIds, data.reason, {
+          exceptRequestId: request.id,
+        });
       }
     });
     return { request, runCancelled };

package/src/workflows/approval-notifications.ts

@@ -9,6 +9,7 @@ import {
   releaseApprovalCancellationNotificationClaim,
   updateApprovalRequestNotifications,
 } from "../be/db";
+import { approvalCancellationNotificationKey } from "../be/db/approvals";
 import { resolveTemplate } from "../prompts/resolver";
 import { getSlackApp } from "../slack/app";
 import { resolveSlackConversationId } from "../slack/dm";
@@ -263,7 +264,10 @@ export async function postApprovalCancellationUpdates(
 
     for (const notification of slackThreads) {
       if (notification.channel !== "slack" || !notification.messageTs) continue;
-      const notificationKey = `${notification.target}:${notification.messageTs}`;
+      const notificationKey = approvalCancellationNotificationKey(
+        notification.target,
+        notification.messageTs,
+      );
       const claim = await claimApprovalCancellationNotification(approval.id, notificationKey);
       if (!claim) continue;
       try {

package/src/workflows/checkpoint.ts

@@ -1,12 +1,14 @@
 import { getDbClient, getWorkflowRun, updateWorkflowRun, updateWorkflowRunStep } from "../be/db";
+import { getRunLineageBlock } from "../be/db/workflow-runs";
 import type { RetryPolicy } from "../types";
 
 /**
  * The execution a checkpoint belongs to: the step attempt (`retryCount`) that
  * claimed the row. A fenced checkpoint writes only while that attempt still
  * owns the row: the step is `running` with that `retryCount` in a `running` or
- * `waiting` run. A cancel, a newer attempt or another settle that committed
- * meanwhile wins, and the stale execution writes nothing.
+ * `waiting` run with no cancelled ancestor. A cancel, a newer attempt or
+ * another settle that committed meanwhile wins, and the stale execution
+ * writes nothing.
  */
 export type StepFence = { retryCount: number };
 
@@ -19,7 +21,7 @@ async function holdsFence(runId: string, stepId: string, fence: StepFence): Prom
         AND r.status IN ('running', 'waiting')`,
     [stepId, runId, fence.retryCount],
   );
-  return row != null;
+  return row != null && (await getRunLineageBlock(runId)) == null;
 }
 
 /**
@@ -129,6 +131,7 @@ export async function checkpointStepWaiting(
   options: { keepRunStatus?: boolean } = {},
 ): Promise<boolean> {
   return getDbClient().transaction(async () => {
+    if (await getRunLineageBlock(runId)) return false;
     const step = await getDbClient().get<{ id: string }>(
       `UPDATE workflow_run_steps
          SET status = 'waiting'

package/src/workflows/engine.ts

@@ -21,7 +21,11 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
 } from "../be/db";
-import { getChildWorkflowRunId, isParentStepAttemptCurrent } from "../be/db/workflow-runs";
+import {
+  getChildWorkflowRunId,
+  getRunLineageBlock,
+  isParentStepAttemptCurrent,
+} from "../be/db/workflow-runs";
 import { WorkflowReplayStateError } from "../be/workflow-replay";
 import { telemetry } from "../telemetry";
 import type { Workflow, WorkflowDefinition, WorkflowNode, WorkflowRunStep } from "../types";
@@ -67,6 +71,13 @@ export interface WorkflowExecutionOptions {
   parentStepId?: string;
   /** The parent step's `retryCount`; each attempt gets its own child run. */
   parentStepAttempt?: number;
+  /**
+   * Runs inside the transaction that commits a top-level run (or reuses the
+   * day's setup-failure run), after the run row is written. A throw rolls the
+   * run back and nothing else happens: no walk, no alert, no telemetry. The
+   * HTTP trigger records its `Idempotency-Key` here.
+   */
+  accept?: (run: { runId: string; skipped: boolean }) => Promise<void>;
 }
 
 /**
@@ -111,12 +122,16 @@ export async function startWorkflowExecution(
     await getAutomationSetupStates(),
   );
   if (preflight.state === "needs_setup" && !options.parentStepId) {
-    const { runId, recorded } = await recordWorkflowPreflightFailure({
-      workflowId: workflow.id,
-      triggerType: options.triggerType ?? "manual",
-      triggerData,
-      failureReason: preflight.failureReason!,
-      createdBy: options.requestedByUserId,
+    const { runId, recorded } = await getDbClient().transaction(async () => {
+      const failure = await recordWorkflowPreflightFailure({
+        workflowId: workflow.id,
+        triggerType: options.triggerType ?? "manual",
+        triggerData,
+        failureReason: preflight.failureReason!,
+        createdBy: options.requestedByUserId,
+      });
+      await options.accept?.({ runId: failure.runId, skipped: false });
+      return failure;
     });
     if (recorded) await notifyAutomationPreflightFailure(preflight);
     return runId;
@@ -276,7 +291,8 @@ async function buildInitialRunState(
  * executing and returns the child that attempt already started instead of a
  * second one; the unique (parentStepId, parentStepAttempt) index backs this
  * across processes. A setup failure claims the day's alert in the same
- * transaction, so concurrent failures alert exactly once.
+ * transaction, so concurrent failures alert exactly once. `options.accept`
+ * runs last in it.
  */
 async function createRunWithInitialState(
   workflow: Workflow,
@@ -314,6 +330,7 @@ async function createRunWithInitialState(
       initial.status === "failed" && initial.preflight
         ? await isFirstWorkflowPreflightFailureToday(workflow.id, runId)
         : undefined;
+    await options.accept?.({ runId, skipped: initial.status === "skipped" });
     return { runId, created: true, preflightAlert };
   });
 }
@@ -606,6 +623,8 @@ async function walkGraphOwned(
   await getDbClient().transaction(async () => {
     const run = await getWorkflowRun(runId);
     if (!run || run.status !== "running") return;
+    // Inside a cancelled tree the run's outcome is the cancel, not its steps.
+    if (await getRunLineageBlock(runId)) return;
 
     const finalSteps = await getWorkflowRunStepsByRunId(runId);
     // Another walker is still executing a branch; it finalizes the run.
@@ -793,6 +812,9 @@ async function executeStep(
     if (!run || (run.status !== "running" && run.status !== "waiting")) {
       return { halted: true as const };
     }
+    // A live run under a cancelled ancestor (or with a broken parent link)
+    // starts no step: the cancel covers its whole tree.
+    if (await getRunLineageBlock(runId)) return { halted: true as const };
 
     // Another walker already started or finished this node for the same
     // predecessor completions (two branch completions both walking the join,

package/src/workflows/executors/foreach.ts

@@ -6,7 +6,7 @@ import { getSuccessors } from "../definition";
 import { foreachBodyTypeError } from "../foreach-body";
 import {
   buildForeachAggregate,
-  FOREACH_TERMINAL_STEP_STATUSES,
+  isForeachChildSettled,
   parseSyntheticNodeId,
 } from "../foreach-join";
 import { getMaxWorkflowStepsPerRun } from "../limits";
@@ -144,7 +144,7 @@ export class ForeachExecutor extends BaseExecutor<
     const childSteps = (await this.deps.db.getWorkflowRunStepsByRunId(meta.runId)).filter(
       (step) => parseSyntheticNodeId(step.nodeId)?.parentNodeId === meta.nodeId,
     );
-    if (childSteps.every((step) => FOREACH_TERMINAL_STEP_STATUSES.has(step.status))) {
+    if (childSteps.every(isForeachChildSettled)) {
       return { status: "success", output: buildForeachAggregate(childSteps) };
     }
 

package/src/workflows/foreach-driver.ts

@@ -11,6 +11,7 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
 } from "../be/db";
+import { getRunLineageBlock, getWorkflowRunStatus } from "../be/db/workflow-runs";
 import type {
   Workflow,
   WorkflowDefinition,
@@ -41,6 +42,7 @@ import {
   cancelQueuedForeachChildren,
   FOREACH_TERMINAL_STEP_STATUSES,
   type ForeachChildOutcome,
+  isRetryPending,
   latestForeachChildren,
   settleForeachChild,
 } from "./foreach-join";
@@ -352,8 +354,8 @@ async function parkRunIfRunning(runId: string): Promise<void> {
 
 /**
  * Flip `pending` children to `running`, in item order, while fewer than the
- * fan-out's `concurrency` cap are in flight (`running` or `waiting`, latest
- * attempt rows only), and collect unowned `running` ones. Ownership is registered before commit, so no other
+ * fan-out's `concurrency` cap are in flight (`running`, `waiting` or queued
+ * for a retry, latest attempt rows only), and collect unowned `running` ones. Ownership is registered before commit, so no other
  * drive can see a claimed row without also seeing it owned.
  */
 async function claimChildren(
@@ -367,6 +369,10 @@ async function claimChildren(
     // so concurrent drives (a settlement's drive and the recovery sweep)
     // serialize here and never exceed the cap together.
     await getDbClient().transaction(async () => {
+      // A cancel of the run (or of an ancestor) that committed first wins.
+      const status = await getWorkflowRunStatus(runId);
+      if (status !== "running" && status !== "waiting") return;
+      if (await getRunLineageBlock(runId)) return;
       const children = latestForeachChildren(
         def,
         parentNode.id,
@@ -379,7 +385,8 @@ async function claimChildren(
         }
       }
       const inFlight = children.filter(
-        (child) => child.status === "running" || child.status === "waiting",
+        (child) =>
+          child.status === "running" || child.status === "waiting" || isRetryPending(child),
       ).length;
       let free = foreachConcurrencyCap(parentNode) - inFlight;
       for (const child of children) {

package/src/workflows/foreach-join.ts

@@ -7,6 +7,7 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
 } from "../be/db";
+import { getRunLineageBlock } from "../be/db/workflow-runs";
 import type {
   WorkflowDefinition,
   WorkflowNode,
@@ -27,6 +28,22 @@ export const FOREACH_TERMINAL_STEP_STATUSES = new Set([
   "skipped",
 ]);
 
+/**
+ * A failed step queued for the retry poller (`nextRetryAt` set). A foreach
+ * child in this state is still in flight: it is not settled and holds its
+ * concurrency slot until the poller re-queues it.
+ */
+export function isRetryPending(step: Pick<WorkflowRunStep, "status" | "nextRetryAt">): boolean {
+  return step.status === "failed" && step.nextRetryAt != null;
+}
+
+/** A foreach child whose outcome is final: terminal and not queued for a retry. */
+export function isForeachChildSettled(
+  step: Pick<WorkflowRunStep, "status" | "nextRetryAt">,
+): boolean {
+  return FOREACH_TERMINAL_STEP_STATUSES.has(step.status) && !isRetryPending(step);
+}
+
 export interface SyntheticNodeId {
   parentNodeId: string;
   itemKey: string;
@@ -74,8 +91,9 @@ export async function joinForeach(
 
   const children = latestForeachChildren(def, parent.id, await getWorkflowRunStepsByRunId(runId));
 
-  // `pending` (queued, not started) is non-terminal like running and waiting.
-  if (children.some((step) => !FOREACH_TERMINAL_STEP_STATUSES.has(step.status))) {
+  // `pending` (queued, not started) and a child queued for a retry are
+  // non-terminal like running and waiting.
+  if (children.some((step) => !isForeachChildSettled(step))) {
     return { joined: false, parentNodeId: parent.id, successors: [] };
   }
 
@@ -244,6 +262,8 @@ export async function settleForeachChild(
     });
 
     if (run.status !== "running" && run.status !== "waiting") return unclaimed;
+    // The outcome stays on the item as history; a cancelled tree routes nothing.
+    if (await getRunLineageBlock(runId)) return unclaimed;
 
     if (outcome.status !== "completed" && effectiveFailurePolicy(parent, def) === "fail-fast") {
       const reason = options.runError ?? outcome.error ?? `foreach item ${current.nodeId} failed`;
@@ -270,8 +290,9 @@ export async function settleForeachChild(
 
 /**
  * Fail-fast: cancel every queued (`pending`) child of the fan-out so none of
- * them starts. In-flight children are left to finish and record their outcome.
- * A run retry gives each cancelled item a new attempt.
+ * them starts, and every child queued for a retry so the retry poller does not
+ * revive the failed run. In-flight children are left to finish and record their
+ * outcome. A run retry gives each cancelled item a new attempt.
  */
 export async function cancelQueuedForeachChildren(
   def: WorkflowDefinition,
@@ -294,9 +315,11 @@ export async function cancelQueuedForeachChildren(
       await getWorkflowRunStepsByRunId(runId),
     );
     for (const child of children) {
-      if (child.status !== "pending") continue;
+      if (child.status !== "pending" && !isRetryPending(child)) continue;
       const row = await getDbClient().get<{ id: string }>(
-        "UPDATE workflow_run_steps SET status = 'cancelled', error = ?, finishedAt = ? WHERE id = ? AND status = 'pending' RETURNING id",
+        `UPDATE workflow_run_steps SET status = 'cancelled', error = ?, finishedAt = ?, nextRetryAt = NULL
+          WHERE id = ? AND (status = 'pending' OR (status = 'failed' AND nextRetryAt IS NOT NULL))
+          RETURNING id`,
         [error, finishedAt, child.id],
       );
       if (row) cancelled++;

package/src/workflows/recovery.ts

@@ -12,7 +12,11 @@ import {
   resolveApprovalRequest,
   updateWorkflowRun,
 } from "../be/db";
-import { getRunningSubWorkflowSteps, getSettledChildRunParentSteps } from "../be/db/workflow-runs";
+import {
+  getRunLineageBlock,
+  getRunningSubWorkflowSteps,
+  getSettledChildRunParentSteps,
+} from "../be/db/workflow-runs";
 import type { WorkflowRunStep } from "../types";
 import { shapeApprovalResolution } from "./approval-resolution";
 import { loadCompletedStepRouting } from "./completed-step-routing";
@@ -227,6 +231,7 @@ async function completeIfSettled(runId: string, ctx: Record<string, unknown>): P
   return getDbClient().transaction(async () => {
     const run = await getWorkflowRun(runId);
     if (run?.status !== "running") return false;
+    if (await getRunLineageBlock(runId)) return false;
     const steps = await getWorkflowRunStepsByRunId(runId);
     if (retryPendingNodeIds(steps).size > 0) return false;
     const latest = new Map<string, WorkflowRunStep>();