@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/types.ts

@@ -770,6 +770,15 @@ export const CreateTaskOptionsSchema = z.object({
    * Lead-only control-plane authorization.
    */
   inheritParentRoutingAffinity: z.boolean().optional(),
+  /**
+   * `followUpConfig` belongs to one piece of work, not to the thread, so a
+   * child does NOT inherit the parent's by default. Set this to `true` only on
+   * a continuation of the SAME work (interrupted-task resume, reboot-sweep
+   * retry, defer-task wake-up, a Lead `resume` re-delegation) so the creator's
+   * onCompleted/onFailed still fires when that work truly ends. An explicit
+   * `followUpConfig` always wins.
+   */
+  inheritParentFollowUpConfig: z.boolean().optional(),
   followUpConfig: FollowUpConfigSchema.optional(),
   requestedByUserId: z.string().optional(),
   contextKey: z.string().optional(),
@@ -1425,6 +1434,8 @@ export const AgentLogEventTypeSchema = z.enum([
   "task_dispatch_rejected_affinity",
   "task_authorization_rejected",
   "task_recovery_authorization",
+  // Reboot sweep moved a never-started dependent from the swept task to its retry
+  "task_dependency_repointed",
   "task_released",
   // A settled task's settlement fired a deferred wait (metadata names the waiter)
   "task_deferred_wait_woke",
@@ -2412,6 +2423,26 @@ export type AgentTaskSummary = Pick<
   | "totalCostUsd"
 >;
 
+/**
+ * `/api/tasks?fields=timeline` list item: only what the dashboard activity
+ * timeline draws (lane, bar extent, label, hover stats). Same bounded `task`
+ * preview as `AgentTaskSummary`.
+ */
+export type AgentTaskTimelineItem = Pick<
+  AgentTask,
+  | "id"
+  | "agentId"
+  | "parentTaskId"
+  | "task"
+  | "title"
+  | "status"
+  | "createdAt"
+  | "lastUpdatedAt"
+  | "finishedAt"
+  | "peakContextTokens"
+  | "totalCostUsd"
+>;
+
 export const PageVersionSchema = z
   .object({
     id: z.string(),
@@ -2594,6 +2625,12 @@ export const WorkflowRunSchema = z
   .openapi("WorkflowRun");
 export type WorkflowRun = z.infer<typeof WorkflowRunSchema>;
 
+/** List row of a run: no `context`, which `GET /api/workflow-runs/{id}` serves. */
+export const WorkflowRunSummarySchema = WorkflowRunSchema.omit({ context: true }).openapi(
+  "WorkflowRunSummary",
+);
+export type WorkflowRunSummary = z.infer<typeof WorkflowRunSummarySchema>;
+
 // --- Script Workflow Runs ---
 
 export const ScriptRunStatusSchema = z.enum([
@@ -3321,6 +3358,7 @@ export const PricingProviderSchema = z.enum([
   // adapter reports `totalCostUsd: 0`, so these rows settle at
   // `costSource: 'unpriced'`. Accepted here so the row is recorded at all.
   "acp",
+  "dsh",
 ]);
 export type PricingProvider = z.infer<typeof PricingProviderSchema>;
 

package/src/utils/context-window.ts

@@ -33,6 +33,7 @@ const CONTEXT_WINDOW_DEFAULTS: Record<string, number> = {
   "claude-opus-5": 1_000_000,
   "claude-fable-5": 1_000_000,
   "claude-mythos-5": 1_000_000,
+  "claude-sonnet-5-5": 1_000_000,
   "claude-sonnet-5": 1_000_000,
   // Anthropic 4.x family
   "claude-opus-4-8": 1_000_000,

package/src/workflows/approval-cancel.ts

@@ -0,0 +1,152 @@
+import {
+  type ApprovalRequest,
+  cancelApprovalRequestById,
+  getApprovalRequestById,
+  getDbClient,
+  getTaskById,
+  getWorkflowRun,
+  listCancelledApprovalRequestsForRun,
+  resolveApprovalRequest,
+} from "../be/db";
+import { can, type RbacPrincipal } from "../rbac";
+import {
+  createApprovalFollowUpTask,
+  postApprovalCancellationUpdates,
+} from "./approval-notifications";
+import { cancelWorkflowRunRows } from "./resume";
+
+export type CancelApprovalRequestResult =
+  | { ok: true; request: ApprovalRequest; alreadyCancelled: boolean; runCancelled: boolean }
+  | { ok: false; status: 403 | 404 | 409; message: string };
+
+const LIVE_RUN_STATUSES = new Set(["running", "waiting"]);
+
+/**
+ * Cancel 1 pending approval request. Shared by the HTTP route, the MCP tool,
+ * and the dashboard Discard button. A request that gates a live workflow run
+ * cancels that run too.
+ */
+export async function cancelApprovalRequest(input: {
+  id: string;
+  reason?: string;
+  principal: RbacPrincipal;
+  resolvedBy: string | null;
+  source?: "http" | "mcp";
+}): Promise<CancelApprovalRequestResult> {
+  const finalReason = input.reason ?? "Cancelled through the API";
+  let authorized = false;
+
+  // A null write means a concurrent change; re-read and apply the rules again.
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const existing = await getApprovalRequestById(input.id);
+    if (!existing) return { ok: false, status: 404, message: "Approval request not found" };
+    if (existing.status === "cancelled") {
+      return { ok: true, request: existing, alreadyCancelled: true, runCancelled: false };
+    }
+    if (existing.status !== "pending") {
+      return {
+        ok: false,
+        status: 409,
+        message: `Approval request already resolved with status: ${existing.status}`,
+      };
+    }
+
+    if (!authorized) {
+      const ownerAgentId = existing.sourceTaskId
+        ? ((await getTaskById(existing.sourceTaskId))?.agentId ?? null)
+        : null;
+      const decision = can({
+        principal: input.principal,
+        verb: "approval.cancel.any",
+        resource: { kind: "owned", ownerAgentId },
+        source: input.source ?? "http",
+      });
+      if (!decision.allow) return { ok: false, status: 403, message: decision.reason };
+      authorized = true;
+    }
+
+    const result = await cancelApprovalRequestAndRun(input.id, {
+      reason: finalReason,
+      resolvedBy: input.resolvedBy,
+    });
+    if (!result) continue;
+    if ("timedOut" in result) {
+      return {
+        ok: false,
+        status: 409,
+        message: `Approval request expired at ${result.timedOut.expiresAt}`,
+      };
+    }
+    return {
+      ok: true,
+      request: result.request,
+      alreadyCancelled: false,
+      runCancelled: result.runCancelled,
+    };
+  }
+
+  return { ok: false, status: 409, message: "Approval request changed during cancellation" };
+}
+
+/**
+ * Cancel 1 pending request and its live workflow run in 1 transaction: both
+ * commit, or neither does. The Slack thread updates run after COMMIT.
+ * Returns null when the request was not pending. A pending request whose
+ * explicit expiresAt passed becomes timeout instead, in the same transaction.
+ */
+export async function cancelApprovalRequestAndRun(
+  id: string,
+  data: { reason: string; resolvedBy: string | null; slackReason?: string },
+): Promise<
+  { request: ApprovalRequest; runCancelled: boolean } | { timedOut: ApprovalRequest } | null
+> {
+  const client = getDbClient();
+  return await client.transaction(async () => {
+    // An elapsed explicit deadline wins over the cancel. A workflow run then
+    // routes on its timeout port through getStuckApprovalRuns, as for a late answer.
+    const current = await getApprovalRequestById(id);
+    if (
+      current?.status === "pending" &&
+      current.expiresAt &&
+      new Date(current.expiresAt) < new Date()
+    ) {
+      const timedOut = await resolveApprovalRequest(id, {
+        status: "timeout",
+        resolutionReason: `Timed out: the cancellation arrived after the deadline ${current.expiresAt}`,
+      });
+      if (!timedOut) return null;
+      await createApprovalFollowUpTask(timedOut, "hitl.timeout");
+      return { timedOut };
+    }
+
+    const request = await cancelApprovalRequestById(id, {
+      reason: data.reason,
+      resolvedBy: data.resolvedBy,
+    });
+    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.
+    let runCancelled = false;
+    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 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);
+      }
+    });
+    return { request, runCancelled };
+  });
+}

package/src/workflows/approval-notifications.ts

@@ -2,9 +2,13 @@ import {
   type ApprovalRequest,
   claimApprovalCancellationNotification,
   completeApprovalCancellationNotificationClaim,
+  createTaskExtended,
+  getTaskById,
   releaseApprovalCancellationNotificationClaim,
 } from "../be/db";
+import { resolveTemplate } from "../prompts/resolver";
 import { getSlackApp } from "../slack/app";
+import { TERMINAL_TASK_STATUSES } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
 export interface ApprovalSlackClient {
@@ -70,3 +74,83 @@ export async function postApprovalCancellationUpdates(
     }
   }
 }
+
+/**
+ * Create the `hitl-follow-up` task that tells the requesting agent how a
+ * standalone approval request ended. Returns false when no task is created.
+ */
+export async function createApprovalFollowUpTask(
+  request: ApprovalRequest,
+  templateEventType: "hitl.follow_up" | "hitl.timeout",
+): Promise<boolean> {
+  if (request.workflowRunId || !request.sourceTaskId) return false;
+  const sourceTask = await getTaskById(request.sourceTaskId);
+  if (!sourceTask) return false;
+  // Timeouts only: the first sweep after deploy would otherwise create one task per finished backlog row.
+  // A human answer still gets a follow-up after the source task finishes, as before.
+  if (
+    templateEventType === "hitl.timeout" &&
+    (TERMINAL_TASK_STATUSES as readonly string[]).includes(sourceTask.status)
+  ) {
+    return false;
+  }
+
+  const { text: taskText } =
+    templateEventType === "hitl.follow_up"
+      ? resolveTemplate("hitl.follow_up", {
+          request_id: request.id,
+          title: request.title,
+          status: request.status,
+          responses: formatResponses(
+            request.questions as Array<{ id: string; type: string; label: string }>,
+            (request.responses ?? {}) as Record<string, unknown>,
+          ),
+        })
+      : resolveTemplate("hitl.timeout", {
+          request_id: request.id,
+          title: request.title,
+          expires_at: request.expiresAt ?? "",
+          reason: request.resolutionReason ?? "",
+        });
+
+  await createTaskExtended(taskText, {
+    agentId: sourceTask.agentId,
+    routingReason: sourceTask.agentId ? "continuity" : undefined,
+    routingSource: sourceTask.agentId ? "engine_default" : undefined,
+    parentTaskId: request.sourceTaskId,
+    source: "system",
+    taskType: "hitl-follow-up",
+    tags: ["hitl", "follow-up"],
+    // Explicit Slack metadata — parentTaskId auto-inherits too,
+    // but being explicit ensures the follow-up task always gets
+    // the right thread context even if inheritance logic changes.
+    slackChannelId: sourceTask.slackChannelId ?? undefined,
+    slackThreadTs: sourceTask.slackThreadTs ?? undefined,
+    slackUserId: sourceTask.slackUserId ?? undefined,
+  });
+  return true;
+}
+
+function formatResponses(
+  questions: Array<{ id: string; type: string; label: string }>,
+  responses: Record<string, unknown>,
+): string {
+  return questions
+    .map((q) => {
+      const answer = responses[q.id];
+      let answerText: string;
+      if (answer == null) {
+        answerText = "(no answer)";
+      } else if (q.type === "approval") {
+        const a = answer as { approved?: boolean; comment?: string };
+        answerText = a.approved ? "Approved" : "Rejected";
+        if (a.comment) answerText += ` — ${a.comment}`;
+      } else if (typeof answer === "object") {
+        answerText = JSON.stringify(answer);
+      } else {
+        answerText = String(answer);
+      }
+      return `- ${q.label}: ${answerText}`;
+    })
+    .join("\n");
+}

package/src/workflows/checkpoint.ts

@@ -1,4 +1,4 @@
-import { getDbClient, updateWorkflowRun, updateWorkflowRunStep } from "../be/db";
+import { getDbClient, getWorkflowRun, updateWorkflowRun, updateWorkflowRunStep } from "../be/db";
 import type { RetryPolicy } from "../types";
 
 /**
@@ -66,10 +66,15 @@ export async function checkpointStepFailure(
 
   const markRunFailed = options?.markRunFailed ?? true;
   if (markRunFailed) {
-    await updateWorkflowRun(runId, {
-      status: "failed",
-      error: `Step failed: ${error}`,
-      finishedAt: now,
+    // A cancel or finalization that committed while the step ran wins.
+    await getDbClient().transaction(async () => {
+      const run = await getWorkflowRun(runId);
+      if (run?.status !== "running" && run?.status !== "waiting") return;
+      await updateWorkflowRun(runId, {
+        status: "failed",
+        error: `Step failed: ${error}`,
+        finishedAt: now,
+      });
     });
   }
 

package/src/workflows/definition.ts

@@ -65,6 +65,27 @@ export function findEntryNodes(def: WorkflowDefinition): WorkflowNode[] {
   return def.nodes.filter((n) => !targets.has(n.id));
 }
 
+/**
+ * Pick the port a node routes on once validation has produced pass/fail.
+ *
+ * Validation decides when the node uses record-based `next` and the executor
+ * either chose no port or chose one that `next` does not declare. `script` and
+ * `swarm-script` always emit "success", so a `next: { pass, fail }` record would
+ * otherwise match nothing and the branch would end silently. An executor port
+ * that IS a key of `next` (property-match "true"/"false", a script node wired
+ * as `next: { success }`) stays authoritative.
+ */
+export function resolveValidationPort(
+  next: WorkflowNode["next"],
+  executorPort: string | undefined,
+  validationPassed: boolean | undefined,
+): string | undefined {
+  if (validationPassed === undefined) return executorPort;
+  if (!next || typeof next !== "object" || Array.isArray(next)) return executorPort;
+  if (executorPort && Object.hasOwn(next, executorPort)) return executorPort;
+  return validationPassed ? "pass" : "fail";
+}
+
 /**
  * Get successor node IDs for a given node and port.
  */

package/src/workflows/engine.ts

@@ -10,6 +10,7 @@ import {
   createWorkflowRun,
   createWorkflowRunStep,
   getCompletedStepNodeIds,
+  getCurrentStepForNode,
   getDbClient,
   getLatestStepForNode,
   getStepByIdempotencyKey,
@@ -24,7 +25,7 @@ import type { Workflow, WorkflowDefinition, WorkflowNode, WorkflowRunStep } from
 import { checkpointStep, checkpointStepFailure, checkpointStepWaiting } from "./checkpoint";
 import { loadCompletedStepRouting } from "./completed-step-routing";
 import { shouldSkipCooldown } from "./cooldown";
-import { findEntryNodes, getNextTargets, getSuccessors } from "./definition";
+import { findEntryNodes, getNextTargets, getSuccessors, resolveValidationPort } from "./definition";
 import type { AsyncExecutorResult } from "./executors/base";
 import type { ExecutorRegistry } from "./executors/registry";
 import { FOREACH_TERMINAL_STEP_STATUSES, resolveForeachParent } from "./foreach-join";
@@ -202,10 +203,32 @@ interface StepResult {
 // settles, including checkpointing and routing between executor calls.
 const activeWalks = new Map<string, number>();
 
+// Step rows an executeStep call in this process inserted and has not finished
+// yet. Process-local like activeWalks: a crash clears it, so a `running` row
+// left behind is not mistaken for a live execution.
+const executingSteps = new Set<string>();
+
 export function isWorkflowRunActive(runId: string): boolean {
   return activeWalks.has(runId);
 }
 
+/**
+ * Mark the run as owned by this process until the returned release runs.
+ * Recovery skips owned runs, so an executor outside walkGraph (the retry
+ * poller) holds the run for as long as it executes a step.
+ */
+export function holdWorkflowRun(runId: string): () => void {
+  activeWalks.set(runId, (activeWalks.get(runId) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const remaining = activeWalks.get(runId)! - 1;
+    if (remaining === 0) activeWalks.delete(runId);
+    else activeWalks.set(runId, remaining);
+  };
+}
+
 /**
  * Event-loop style graph walker.
  *
@@ -223,13 +246,11 @@ export async function walkGraph(
   secretKeys: Set<string> = new Set(),
   options: WorkflowExecutionOptions = {},
 ): Promise<void> {
-  activeWalks.set(runId, (activeWalks.get(runId) ?? 0) + 1);
+  const release = holdWorkflowRun(runId);
   try {
     await walkGraphOwned(def, runId, ctx, startNodes, registry, workflowId, secretKeys, options);
   } finally {
-    const remaining = activeWalks.get(runId)! - 1;
-    if (remaining === 0) activeWalks.delete(runId);
-    else activeWalks.set(runId, remaining);
+    release();
   }
 }
 
@@ -293,6 +314,8 @@ async function walkGraphOwned(
     }
   }
 
+  const awaited = awaitedNodeIds(allSteps, activeEdges);
+
   // Seed with start nodes whose predecessors are all completed (convergence gate).
   // For entry nodes (no predecessors), skip if already completed — these are
   // re-walk/recovery scenarios where memoization should apply.
@@ -306,7 +329,9 @@ async function walkGraphOwned(
     }
     // Non-entry node — allow through even if completed (loop target).
     // Check predecessors are ready.
-    const activePreds = preds.filter((predId) => activeEdges.has(`${predId}→${n.id}`));
+    const activePreds = preds.filter(
+      (predId) => activeEdges.has(`${predId}→${n.id}`) || awaited.has(predId),
+    );
     // If no active edges yet (first walk), check ALL structural predecessors
     const predsToCheck = activePreds.length > 0 ? activePreds : preds;
     return predsToCheck.every((p) => completedNodeIds.has(p));
@@ -376,12 +401,27 @@ async function walkGraphOwned(
     // Use executedInThisWalk (not completedNodeIds) to gate dedup — this
     // allows loop targets from prior walks to re-execute while preventing
     // double execution within the same walk.
+    // A sibling branch another walker is executing has no edge in this walk's
+    // activeEdges, so re-read the steps: a live predecessor holds the join,
+    // and one that completed elsewhere is rehydrated for the join's inputs.
     const readyNext: WorkflowNode[] = [];
+    const batchSteps = nextBatch.size > 0 ? await getWorkflowRunStepsByRunId(runId) : [];
+    const batchAwaited = awaitedNodeIds(batchSteps, activeEdges);
+    const batchLatest = latestStepByNode(batchSteps);
     for (const [nodeId, node] of nextBatch) {
       if (executedInThisWalk.has(nodeId)) continue; // Already done in this walk
 
       const allPreds = getAllPredecessors(def, nodeId);
-      const activePreds = allPreds.filter((predId) => activeEdges.has(`${predId}→${nodeId}`));
+      for (const predId of allPreds) {
+        if (completedNodeIds.has(predId)) continue;
+        const latest = batchLatest.get(predId);
+        if (latest?.status !== "completed") continue;
+        completedNodeIds.add(predId);
+        if (latest.output !== undefined) ctx[predId] = latest.output;
+      }
+      const activePreds = allPreds.filter(
+        (predId) => activeEdges.has(`${predId}→${nodeId}`) || batchAwaited.has(predId),
+      );
       const allActivePredsCompleted = activePreds.every((p) => completedNodeIds.has(p));
 
       if (allActivePredsCompleted) {
@@ -405,6 +445,8 @@ async function walkGraphOwned(
     if (!run || run.status !== "running") return;
 
     const finalSteps = await getWorkflowRunStepsByRunId(runId);
+    // Another walker is still executing a branch; it finalizes the run.
+    if (hasRunningStep(finalSteps)) return;
     const hasWaitingSteps = finalSteps.some((s) => s.status === "waiting");
     const hasPendingRetries = finalSteps.some(
       (s) => s.status === "failed" && s.nextRetryAt != null,
@@ -453,6 +495,42 @@ async function walkGraphOwned(
   });
 }
 
+/** Each node's latest step. Steps arrive in insert order (startedAt ASC). */
+function latestStepByNode(steps: WorkflowRunStep[]): Map<string, WorkflowRunStep> {
+  const latest = new Map<string, WorkflowRunStep>();
+  for (const step of steps) latest.set(step.nodeId, step);
+  return latest;
+}
+
+/**
+ * Nodes a join must wait for even without an active edge to it: the node's
+ * latest step is running or waiting, or a predecessor routed to it and it has
+ * no step yet. A terminally failed node is not awaited, so partial failure
+ * still lets the join run. An older `running` row superseded by a newer one
+ * (crash recovery) and the `pending` row a user retry leaves behind are
+ * ignored because only the latest step counts.
+ */
+function awaitedNodeIds(steps: WorkflowRunStep[], activeEdges: Set<string>): Set<string> {
+  const latest = latestStepByNode(steps);
+  const awaited = new Set<string>();
+  for (const [nodeId, step] of latest) {
+    if (step.status === "running" || step.status === "waiting") awaited.add(nodeId);
+  }
+  for (const edge of activeEdges) {
+    const target = edge.slice(edge.indexOf("→") + 1);
+    if (!latest.has(target)) awaited.add(target);
+  }
+  return awaited;
+}
+
+/** True while some node's latest step is still executing. */
+export function hasRunningStep(steps: WorkflowRunStep[]): boolean {
+  for (const step of latestStepByNode(steps).values()) {
+    if (step.status === "running") return true;
+  }
+  return false;
+}
+
 /**
  * Restore completed node outputs from their step checkpoints into workflow context.
  * Every recovery path must do this before resolving a node's declared inputs.
@@ -541,12 +619,28 @@ async function executeStep(
   // rides the INSERT itself — so the UNIQUE(idempotencyKey) index arbitrates
   // concurrent executions of the same node instead of an orphan step row
   // committing before a follow-up key UPDATE throws.
-  const dedup = await getDbClient().transaction(async () => {
+  let claimedStepId: string | undefined;
+  const claimStep = async () => {
     const run = await getWorkflowRun(runId);
     if (!run || (run.status !== "running" && run.status !== "waiting")) {
       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,
+    // or a user retry reaching a branch the live walk is running). The
+    // row-count key below is always new, so only this read, inside the insert
+    // transaction, stops a second execution. Foreach re-enters its own
+    // non-terminal row below and keeps that path.
+    if (node.type !== "foreach") {
+      const current = await getCurrentStepForNode(runId, node.id, getAllPredecessors(def, node.id));
+      // A `running` row this process is not executing was orphaned by a
+      // crash; recovery must be able to run the node again.
+      if (current && (current.status !== "running" || executingSteps.has(current.id))) {
+        return { current };
+      }
+    }
+
     // Count existing steps for this node to determine the current iteration.
     const iteration = await getStepCountForNode(runId, node.id);
     const idempotencyKey = `${runId}:${node.id}:${iteration}`;
@@ -584,10 +678,27 @@ async function executeStep(
         idempotencyKey,
       });
     }
+    // Registered before the transaction commits, so no other walker can see
+    // this `running` row without also seeing it owned.
+    claimedStepId = stepId;
+    executingSteps.add(stepId);
     return { existingStep, stepId, deduped: false };
-  });
+  };
+  const dedup = await getDbClient()
+    .transaction(claimStep)
+    .catch((err) => {
+      if (claimedStepId) executingSteps.delete(claimedStepId);
+      throw err;
+    });
 
   if ("halted" in dedup) return { outcome: "completed", successors: [] };
+  if ("current" in dedup && dedup.current) {
+    // The walker that owns the step routes its successors and finalizes the
+    // run; this one must not route them again.
+    if (dedup.current.status !== "completed") return { outcome: "waiting", successors: [] };
+    ctx[node.id] = dedup.current.output;
+    return { outcome: "completed", successors: [] };
+  }
 
   if (dedup.deduped && dedup.existingStep) {
     if (dedup.existingStep.status === "completed") {
@@ -601,9 +712,35 @@ async function executeStep(
     // Don't create a duplicate — just report as waiting.
     return { outcome: "waiting", successors: [] };
   }
-  const existingStep = dedup.existingStep;
-  const stepId = dedup.stepId;
+  try {
+    return await runClaimedStep(
+      def,
+      runId,
+      ctx,
+      node,
+      registry,
+      dedup.existingStep,
+      dedup.stepId,
+      workflowId,
+      options,
+    );
+  } finally {
+    executingSteps.delete(dedup.stepId);
+  }
+}
 
+/** Steps 3-10 of executeStep, for a step row this call inserted and owns. */
+async function runClaimedStep(
+  def: WorkflowDefinition,
+  runId: string,
+  ctx: Record<string, unknown>,
+  node: WorkflowNode,
+  registry: ExecutorRegistry,
+  existingStep: WorkflowRunStep | null | undefined,
+  stepId: string,
+  workflowId?: string,
+  options: WorkflowExecutionOptions = {},
+): Promise<StepResult> {
   // 3. Get executor
   const executor = registry.get(node.type);
 
@@ -777,16 +914,10 @@ async function executeStep(
 
   // 8. Set nextPort from validation result for record-based routing
   // When validation determines pass/fail and the node uses port-based `next`,
-  // route to the correct port instead of activating all ports.
-  if (
-    validationResult?.passed !== undefined &&
-    !result.nextPort &&
-    node.next &&
-    typeof node.next === "object" &&
-    !Array.isArray(node.next)
-  ) {
-    result.nextPort = validationResult.passed ? "pass" : "fail";
-  }
+  // route to the correct port instead of activating all ports. An executor port
+  // that `next` does not declare (script's "success" vs `{ pass, fail }`) is
+  // overridden too, otherwise the branch would dead-end.
+  result.nextPort = resolveValidationPort(node.next, result.nextPort, validationResult?.passed);
 
   // 9. Checkpoint success
   await checkpointStep(runId, stepId, node.id, result, ctx);

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

@@ -380,7 +380,7 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
                   elements: [
                     {
                       type: "mrkdwn",
-                      text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — auto-rejects if not responded`,
+                      text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — times out if not responded`,
                     },
                   ],
                 },