@desplega.ai/agent-swarm 2.5.1 → 2.5.3

package/src/workflows/executors/human-in-the-loop.ts

@@ -1,8 +1,11 @@
 import { z } from "zod";
+import {
+  ConfigQuestionSettingsSchema,
+  normalizeApprovalQuestions,
+} from "../../be/approval-config-question";
 import type { ExecutorMeta } from "../../types";
-import { getAppUrl } from "../../utils/constants";
 import { scrubSecrets } from "../../utils/secret-scrubber";
-import { postApprovalCancellationUpdates } from "../approval-notifications";
+import { dispatchApprovalNotifications } from "../approval-notifications";
 import type { ExecutorInput, ExecutorResult } from "./base";
 import { BaseExecutor } from "./base";
 
@@ -57,6 +60,15 @@ const QuestionSchema = z.discriminatedUnion("type", [
     description: z.string().optional(),
     defaultValue: z.boolean().optional(),
   }),
+  z.object({
+    id: z.string(),
+    type: z.literal("config"),
+    // Defaults to the config key during normalization in `run`.
+    label: z.string().optional(),
+    required: z.boolean().default(true),
+    description: z.string().optional(),
+    config: ConfigQuestionSettingsSchema,
+  }),
 ]);
 
 export const ApproverConfigSchema = z.object({
@@ -88,9 +100,6 @@ const DYNAMIC_QUESTIONS_TOKEN_RE = /^\{\{[^}]+\}\}$/;
  */
 export const MAX_HITL_QUESTIONS = 100;
 
-/** Slack Block Kit caps a section block's text at 3000 characters. */
-const SLACK_SECTION_TEXT_LIMIT = 3000;
-
 const MAX_REPORTED_ISSUES = 5;
 
 const HITLConfigSchema = z.object({
@@ -197,38 +206,6 @@ export function resolveHitlQuestions(
   return { ok: true, questions };
 }
 
-function escapeSlackMrkdwn(text: string): string {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-
-/**
- * Render the Slack "Questions" section text within Block Kit's 3000-character
- * section limit. Labels are escaped so upstream text cannot inject mentions or
- * links. When the list does not fit, the tail is replaced by a count; every
- * question stays answerable on the dashboard page the card's button opens.
- */
-export function buildSlackQuestionsSummary(
-  questions: ReadonlyArray<{ label: string }>,
-  timeoutText = "",
-): string {
-  const header = "*Questions:*\n";
-  const lines = questions.map((q) => `• ${escapeSlackMrkdwn(q.label.replace(/\s+/g, " ").trim())}`);
-  const fits = (shown: string[], omitted: number) => {
-    const tail =
-      omitted > 0 ? `\n_…and ${omitted} more. Answer all of them on the dashboard._` : "";
-    const text = `${header}${shown.join("\n")}${tail}${timeoutText}`;
-    return text.length <= SLACK_SECTION_TEXT_LIMIT ? text : null;
-  };
-
-  const full = fits(lines, 0);
-  if (full) return full;
-  for (let count = lines.length - 1; count >= 0; count--) {
-    const text = fits(lines.slice(0, count), lines.length - count);
-    if (text) return text;
-  }
-  return `${header}_${questions.length} questions. Answer them on the dashboard._`;
-}
-
 // ─── Executor ───────────────────────────────────────────────
 
 export class HumanInTheLoopExecutor extends BaseExecutor<
@@ -243,7 +220,18 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
   override async run(input: ExecutorInput): Promise<ExecutorResult<HITLOutput>> {
     const resolved = resolveHitlQuestions(input.config?.questions);
     if (!resolved.ok) return { status: "failed", error: resolved.error };
-    return super.run({ ...input, config: { ...input.config, questions: resolved.questions } });
+    // Config questions: the same create-time rules as the tool and REST paths.
+    const approvers = input.config?.approvers as { policy?: unknown } | undefined;
+    const normalized = await normalizeApprovalQuestions(resolved.questions, {
+      approvers: { policy: approvers?.policy },
+    });
+    if (!normalized.ok) {
+      return {
+        status: "failed",
+        error: `human-in-the-loop questions are invalid: ${normalized.error}`,
+      };
+    }
+    return super.run({ ...input, config: { ...input.config, questions: normalized.questions } });
   }
 
   protected async execute(
@@ -319,7 +307,16 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
 
     // 3. Dispatch notifications (fire-and-forget — failures must not block the workflow)
     if (config.notifications?.length) {
-      this.dispatchNotifications(requestId, config, db).catch((err) => {
+      dispatchApprovalNotifications(
+        {
+          requestId,
+          title: config.title,
+          questions: config.questions,
+          timeoutSeconds: config.timeout?.seconds,
+          notifications: config.notifications,
+        },
+        db,
+      ).catch((err) => {
         console.error(
           "[HITL] Unexpected error dispatching notifications:",
           scrubSecrets(err instanceof Error ? err.message : String(err)),
@@ -335,138 +332,4 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
       correlationId: requestId,
     } as ExecutorResult<HITLOutput>;
   }
-
-  /** Dispatch notifications for each configured channel. Updates DB with messageTs on success. */
-  private async dispatchNotifications(
-    requestId: string,
-    config: z.infer<typeof HITLConfigSchema>,
-    db: typeof import("../../be/db"),
-  ): Promise<void> {
-    if (!config.notifications?.length) return;
-
-    const approvalUrl = `${getAppUrl()}/approval-requests/${requestId}`;
-    const updatedChannels = [...config.notifications] as Array<
-      z.infer<typeof NotificationConfigSchema> & { messageTs?: string }
-    >;
-    let updated = false;
-
-    for (let i = 0; i < config.notifications.length; i++) {
-      const notification = config.notifications[i]!;
-
-      if (notification.channel === "email") {
-        console.warn(
-          `[HITL] Email notifications not yet supported (target: ${notification.target})`,
-        );
-        continue;
-      }
-
-      if (notification.channel === "slack") {
-        try {
-          const { getSlackApp } = await import("../../slack/app");
-          const slackApp = getSlackApp();
-          if (!slackApp) {
-            console.warn("[HITL] Slack not initialized — cannot send notification");
-            continue;
-          }
-
-          const questions = Array.isArray(config.questions) ? config.questions : [];
-          const questionsText = buildSlackQuestionsSummary(questions);
-
-          // The deadline is a caption under the button, not part of the ask.
-          const timeoutCaption = config.timeout
-            ? [
-                {
-                  type: "context",
-                  elements: [
-                    {
-                      type: "mrkdwn",
-                      text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — times out if not responded`,
-                    },
-                  ],
-                },
-              ]
-            : [];
-
-          const blocks = [
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: `🔔 *Approval Required: ${config.title}*`,
-              },
-            },
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: questionsText,
-              },
-            },
-            {
-              type: "actions",
-              elements: [
-                {
-                  type: "button",
-                  text: { type: "plain_text", text: "Review & Respond" },
-                  url: approvalUrl,
-                  style: "primary",
-                },
-              ],
-            },
-            ...timeoutCaption,
-          ];
-
-          const result = await slackApp.client.chat.postMessage({
-            channel: notification.target,
-            text: `Approval Required: ${config.title} — ${approvalUrl}`,
-            unfurl_links: false,
-            unfurl_media: false,
-            // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
-            blocks: blocks as any,
-          });
-
-          if (result.ts) {
-            updatedChannels[i] = { ...notification, messageTs: result.ts };
-            updated = true;
-          }
-
-          console.log(
-            `[HITL] Slack notification sent to ${notification.target} for request ${requestId}`,
-          );
-        } catch (err) {
-          console.error(
-            `[HITL] Failed to send Slack notification to ${notification.target}:`,
-            scrubSecrets(err instanceof Error ? err.message : String(err)),
-          );
-        }
-      }
-    }
-
-    // Persist messageTs values back to DB
-    if (updated) {
-      try {
-        await db.updateApprovalRequestNotifications(requestId, updatedChannels);
-        const latest = await db.getApprovalRequestById(requestId);
-        if (latest?.status === "cancelled") {
-          await postApprovalCancellationUpdates(
-            [latest],
-            latest.resolutionReason ?? "Workflow run cancelled",
-          );
-        }
-      } catch (err) {
-        console.error(
-          "[HITL] Failed to update notification channels in DB:",
-          scrubSecrets(err instanceof Error ? err.message : String(err)),
-        );
-      }
-    }
-  }
-}
-
-function formatTimeout(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
-  const hours = Math.floor(seconds / 3600);
-  const mins = Math.round((seconds % 3600) / 60);
-  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
 }

package/src/workflows/executors/sub-workflow.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { getChildWorkflowRunId, getWorkflowRunLineage } from "../../be/db/workflow-runs";
 import type { ExecutorMeta, WorkflowRun } from "../../types";
-import { startWorkflowExecution } from "../engine";
+import { ParentStepNotCurrentError, startWorkflowExecution } from "../engine";
 import type { ExecutorDependencies, ExecutorResult } from "./base";
 import { BaseExecutor } from "./base";
 import type { ExecutorRegistry } from "./registry";
@@ -35,15 +35,21 @@ const NON_NODE_CONTEXT_KEYS = new Set(["trigger", "input", "swarm", "workflow"])
 /**
  * The parent step's outcome for a child run: its result once the child
  * completed, an error once it failed, was cancelled or was skipped, and null
- * while it is still running or waiting.
+ * while it is still running or waiting. Only a failed child is retryable: a
+ * cancel or a skip is a decision, and a node retry must not override it. The
+ * synchronous (executor) and the parked (`resumeFromChildRun`) paths both
+ * apply this, so the same child end gets the same policy whenever it lands.
  */
 export function childRunOutcome(
   child: WorkflowRun,
-): { output: SubWorkflowOutput } | { error: string } | null {
+): { output: SubWorkflowOutput } | { error: string; retryable: boolean } | null {
   if (child.status === "running" || child.status === "waiting") return null;
   if (child.status !== "completed") {
     const reason = child.error ? `: ${child.error}` : "";
-    return { error: `Child workflow run ${child.id} ${child.status}${reason}` };
+    return {
+      error: `Child workflow run ${child.id} ${child.status}${reason}`,
+      retryable: child.status === "failed",
+    };
   }
   const outputs: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(child.context ?? {})) {
@@ -56,8 +62,9 @@ export function childRunOutcome(
 
 /**
  * Runs another workflow as a child run and waits for it. The child run records
- * this step as its parent, so a re-executed step reconnects to it instead of
- * starting a second child. The resume path is `resumeFromChildRun`.
+ * this step and its attempt (`retryCount`) as its parent, so a re-executed or
+ * recovered step reconnects to it instead of starting a second child, while a
+ * retry starts a new one. The resume path is `resumeFromChildRun`.
  */
 export class SubWorkflowExecutor extends BaseExecutor<
   typeof SubWorkflowConfigSchema,
@@ -82,9 +89,12 @@ export class SubWorkflowExecutor extends BaseExecutor<
   ): Promise<ExecutorResult<SubWorkflowOutput>> {
     const { db } = this.deps;
 
-    const existingId = await getChildWorkflowRunId(meta.stepId);
+    // The retry poller re-executes a failed step under the same id with a
+    // higher retryCount; that attempt must not settle on the previous child.
+    const attempt = (await db.getWorkflowRunStep(meta.stepId))?.retryCount ?? 0;
+    const existingId = await getChildWorkflowRunId(meta.stepId, attempt);
     const existing = existingId ? await db.getWorkflowRun(existingId) : null;
-    if (existing) return this.settle(existing);
+    if (existing) return this.settle(existing, config.workflowId);
 
     // Capped at the max depth, so a long chain fails closed instead of
     // hiding a cycle past the end of the scan.
@@ -109,17 +119,34 @@ export class SubWorkflowExecutor extends BaseExecutor<
     }
 
     // Returns once the child run exists; the child walks on its own. A child
-    // that already ended (cooldown, readiness, input failure) settles here.
-    const childRunId = await startWorkflowExecution(workflow, config.inputs ?? {}, this.registry, {
-      requestedByUserId: meta.requestedByUserId,
-      parentStepId: meta.stepId,
-    });
+    // that already ended (cooldown, readiness, input failure) settles here,
+    // and a concurrent execution of this attempt gets the child it created.
+    let childRunId: string;
+    try {
+      childRunId = await startWorkflowExecution(workflow, config.inputs ?? {}, this.registry, {
+        requestedByUserId: meta.requestedByUserId,
+        parentStepId: meta.stepId,
+        parentStepAttempt: attempt,
+      });
+    } catch (err) {
+      if (err instanceof ParentStepNotCurrentError) return { status: "failed", error: err.message };
+      throw err;
+    }
     const child = await db.getWorkflowRun(childRunId);
     if (!child) return { status: "failed", error: `Child workflow run ${childRunId} not found` };
-    return this.settle(child);
+    return this.settle(child, config.workflowId);
   }
 
-  private settle(child: WorkflowRun): ExecutorResult<SubWorkflowOutput> {
+  private settle(child: WorkflowRun, workflowId: string): ExecutorResult<SubWorkflowOutput> {
+    // The attempt already started a child of another workflow (the config
+    // changed under a recovered step). That is a conflict, not a reason to
+    // start a replacement next to it.
+    if (child.workflowId !== workflowId) {
+      return {
+        status: "failed",
+        error: `Child workflow run ${child.id} runs workflow ${child.workflowId}, not ${workflowId}`,
+      };
+    }
     const outcome = childRunOutcome(child);
     if (!outcome) {
       return {
@@ -129,7 +156,9 @@ export class SubWorkflowExecutor extends BaseExecutor<
         correlationId: child.id,
       } as ExecutorResult<SubWorkflowOutput>;
     }
-    if ("error" in outcome) return { status: "failed", error: outcome.error };
+    if ("error" in outcome) {
+      return { status: "failed", error: outcome.error, retryable: outcome.retryable };
+    }
     return { status: "success", output: outcome.output, nextPort: "success" };
   }
 }

package/src/workflows/executors/swarm-script.ts

@@ -10,12 +10,12 @@ import {
   restoreScratchScriptLastUsedIfUnchanged,
   touchScratchScriptLastUsed,
 } from "../../be/scripts/db";
+import { runScriptWithRunCredential } from "../../be/scripts/run-credential";
 import {
   DEFAULT_SCRIPT_RESOURCES,
   MAX_SCRIPT_WALL_CLOCK_MS,
   MIN_SCRIPT_WALL_CLOCK_MS,
 } from "../../scripts-runtime/executors/types";
-import { runScript } from "../../scripts-runtime/loader";
 import type { ExecutorMeta } from "../../types";
 import { getMcpBaseUrl } from "../../utils/constants";
 import { findInterpolationTokens } from "../../utils/template";
@@ -119,7 +119,7 @@ export class SwarmScriptExecutor extends BaseExecutor<
     const credentials = await buildScriptCredentialBindingsWithFailures({
       agentId: agentId ?? undefined,
     });
-    const output = await runScript({
+    const output = await runScriptWithRunCredential({
       source: resolved.source,
       args: config.args,
       fsMode: "none",

package/src/workflows/recovery.ts

@@ -12,7 +12,7 @@ import {
   resolveApprovalRequest,
   updateWorkflowRun,
 } from "../be/db";
-import { getSettledChildRunParentSteps } from "../be/db/workflow-runs";
+import { getRunningSubWorkflowSteps, getSettledChildRunParentSteps } from "../be/db/workflow-runs";
 import type { WorkflowRunStep } from "../types";
 import { shapeApprovalResolution } from "./approval-resolution";
 import { loadCompletedStepRouting } from "./completed-step-routing";
@@ -20,6 +20,7 @@ import { FAILED_TASK_OUTPUT_PREFIX } from "./constants";
 import {
   failRunOnUnreadableReplay,
   findReadyNodes,
+  isStepExecuting,
   isWorkflowRunActive,
   walkGraph,
 } from "./engine";
@@ -76,6 +77,9 @@ export async function recoverIncompleteRuns(registry: ExecutorRegistry): Promise
   // --- Case 6: foreach fan-outs with queued or orphaned items ---
   recovered += await recoverForeachFanouts(registry);
 
+  // --- Case 7: sub-workflow steps a crash left running ---
+  recovered += await recoverOrphanedSubWorkflowSteps(registry);
+
   if (recovered > 0) {
     console.log(`[workflows] Recovered ${recovered} incomplete run(s)`);
   }
@@ -98,6 +102,13 @@ async function recoverRunningRuns(registry: ExecutorRegistry): Promise<number> {
       if (isWorkflowRunActive(runId)) continue;
       const run = await getWorkflowRun(runId);
       if (!run || run.status !== "running") continue;
+      // A child run commits with its initial context. One without it was
+      // created before that held and lost its trigger and inputs in a crash;
+      // walking it from an empty context would run its nodes on blanks.
+      if (run.parentStepId && run.context === undefined) {
+        await failRunningRun(runId, "Child workflow run lost its initial context in a restart");
+        continue;
+      }
 
       const workflow = await getWorkflow(run.workflowId);
       if (!workflow) continue;
@@ -146,6 +157,57 @@ async function recoverRunningRuns(registry: ExecutorRegistry): Promise<number> {
   return recovered;
 }
 
+/** Fail a run that is still `running`; a cancel or finish that committed first wins. */
+async function failRunningRun(runId: string, error: string): Promise<void> {
+  await getDbClient().transaction(async () => {
+    const run = await getWorkflowRun(runId);
+    if (run?.status !== "running") return;
+    await updateWorkflowRun(runId, {
+      status: "failed",
+      error,
+      finishedAt: new Date().toISOString(),
+    });
+  });
+}
+
+/**
+ * Re-enter `sub-workflow` steps a crash left `running`. The running-run case
+ * misses two shapes: a run another branch already parked in `waiting`, and a
+ * loop iteration of a node that completed before. Walking the node lets
+ * executeStep re-claim the same step row, so the executor reconnects to the
+ * child that attempt already started. Foreach items are left to the fan-out
+ * case: their synthetic node ids are not in the definition.
+ */
+async function recoverOrphanedSubWorkflowSteps(registry: ExecutorRegistry): Promise<number> {
+  let recovered = 0;
+  for (const row of await getRunningSubWorkflowSteps()) {
+    try {
+      if (isWorkflowRunActive(row.runId) || isStepExecuting(row.stepId)) continue;
+      const run = await getWorkflowRun(row.runId);
+      if (!run || (run.status !== "running" && run.status !== "waiting")) continue;
+      const workflow = await getWorkflow(run.workflowId);
+      const node = workflow?.definition.nodes.find((n) => n.id === row.nodeId);
+      if (!workflow || !node) continue;
+      // DB reads above yield; a resume may have acquired the run meanwhile.
+      if (isWorkflowRunActive(row.runId)) continue;
+      await walkGraph(
+        workflow.definition,
+        row.runId,
+        (run.context ?? {}) as Record<string, unknown>,
+        [node],
+        registry,
+        workflow.id,
+        getSecretInputKeys(workflow.input),
+      );
+      recovered++;
+    } catch (err) {
+      if (await failRunOnUnreadableReplay(row.runId, err)) continue;
+      console.error(`[workflows] Failed to recover sub-workflow step ${row.stepId}:`, err);
+    }
+  }
+  return recovered;
+}
+
 /** Nodes with a failed step the retry poller will pick up (`nextRetryAt` set). */
 function retryPendingNodeIds(steps: WorkflowRunStep[]): Set<string> {
   const nodeIds = new Set<string>();

package/src/workflows/resume.ts

@@ -18,12 +18,14 @@ import {
   updateWorkflowRunStep,
 } from "../be/db";
 import { createForeachAttemptSteps, getChildWorkflowRunId } from "../be/db/workflow-runs";
-import type {
-  WaitStateRow,
-  WorkflowDefinition,
-  WorkflowNode,
-  WorkflowRun,
-  WorkflowRunStep,
+import {
+  type RetryPolicy,
+  RetryPolicySchema,
+  type WaitStateRow,
+  type WorkflowDefinition,
+  type WorkflowNode,
+  type WorkflowRun,
+  type WorkflowRunStep,
 } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import {
@@ -31,6 +33,7 @@ import {
   postApprovalCancellationUpdates,
 } from "./approval-notifications";
 import { shapeApprovalResolution } from "./approval-resolution";
+import { checkpointStepFailure } from "./checkpoint";
 import { loadCompletedStepRouting } from "./completed-step-routing";
 import { FAILED_TASK_OUTPUT_PREFIX } from "./constants";
 import { getNextTargets } from "./definition";
@@ -963,10 +966,11 @@ async function resumeClaimedWait(
 }
 
 /**
- * Resume a waiting `sub-workflow` step once its child run is terminal: a
- * completed child completes the step, any other end (or a deleted child) fails
- * the step and its run. Returns true when this call claimed the step. Safe to call repeatedly:
- * the live event and the recovery sweep both route here.
+ * Resume a waiting `sub-workflow` step once its current attempt's child run is
+ * terminal: a completed child completes the step, any other end (or a deleted
+ * child) fails the step and its run. Returns true when this call claimed the
+ * step. Safe to call repeatedly: the live event and the recovery sweep both
+ * route here, and only the call that claims the step walks its successors.
  */
 export async function resumeFromChildRun(
   parentStepId: string,
@@ -974,13 +978,6 @@ export async function resumeFromChildRun(
 ): Promise<boolean> {
   const step = await getWorkflowRunStep(parentStepId);
   if (!step || step.status !== "waiting" || step.nodeType !== "sub-workflow") return false;
-  const childId = await getChildWorkflowRunId(parentStepId);
-  const child = childId ? await getWorkflowRun(childId) : null;
-  // The child row exists before the step parks, so a missing one was deleted.
-  const outcome = child
-    ? childRunOutcome(child)
-    : { error: `Child workflow run of step ${parentStepId} was deleted` };
-  if (!outcome) return false;
 
   let claimed = false;
   await failClosedOnUnreadableReplay(step.runId, step.id, async () => {
@@ -990,10 +987,32 @@ export async function resumeFromChildRun(
     if (!workflow) return;
 
     const ctx = (run.context ?? {}) as Record<string, unknown>;
-    // A foreach item's failure settles the item: under `onNodeFailure:
-    // "continue"` it can close the join, so it routes like a success.
-    const routing =
-      "error" in outcome
+    // The step's attempt, that attempt's child and the claim share one
+    // transaction: a retry that re-parks the step under a newer attempt in
+    // between must not be settled by the previous attempt's child.
+    const routing = await getDbClient().transaction(async () => {
+      const current = await getWorkflowRunStep(step.id);
+      if (!current || current.status !== "waiting") return null;
+      const childId = await getChildWorkflowRunId(step.id, current.retryCount);
+      const child = childId ? await getWorkflowRun(childId) : null;
+      // The child row exists before the step parks, so a missing one was deleted.
+      const outcome = child
+        ? childRunOutcome(child)
+        : { error: `Child workflow run of step ${parentStepId} was deleted`, retryable: false };
+      if (!outcome) return null;
+      // A retryable end (a failed child) is this attempt failing: the node's
+      // retry policy applies exactly as on the executor path. The poller
+      // re-executes the step under the next attempt, which starts a new child.
+      if ("error" in outcome && outcome.retryable) {
+        const policy = childStepRetryPolicy(workflow.definition, step.nodeId);
+        if (policy && current.retryCount < policy.maxRetries) {
+          await checkpointStepFailure(run.id, step.id, outcome.error, current.retryCount, policy);
+          return CHILD_RETRY_SCHEDULED;
+        }
+      }
+      // A foreach item's failure settles the item: under `onNodeFailure:
+      // "continue"` it can close the join, so it routes like a success.
+      return "error" in outcome
         ? await failStepAndRunIfWaiting(
             workflow.definition,
             step.id,
@@ -1012,6 +1031,12 @@ export async function resumeFromChildRun(
             ctx,
             registry,
           );
+    });
+    if (!routing) return;
+    if (routing === CHILD_RETRY_SCHEDULED) {
+      claimed = true;
+      return;
+    }
     if (!routing.claimed || routing.runFailed) {
       claimed = routing.claimed;
       return;
@@ -1036,6 +1061,20 @@ export async function resumeFromChildRun(
   return claimed;
 }
 
+const CHILD_RETRY_SCHEDULED = {
+  claimed: true,
+  runFailed: false,
+  successors: [] as WorkflowNode[],
+} as const;
+
+/** The `node.retry` of a top-level `sub-workflow` node; foreach items retry through their parent. */
+function childStepRetryPolicy(def: WorkflowDefinition, nodeId: string): RetryPolicy | null {
+  const node = def.nodes.find((candidate) => candidate.id === nodeId);
+  if (!node?.retry) return null;
+  const parsed = RetryPolicySchema.safeParse(node.retry);
+  return parsed.success ? parsed.data : null;
+}
+
 // ─── 64KB firedPayload cap ──────────────────────────────────────────────────
 
 const FIRED_PAYLOAD_BYTE_CAP = 64 * 1024; // 64KB