@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/workflows/src/extension/workflow-tool-send.ts

@@ -1,9 +1,12 @@
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import {
-  ensurePostMortemStageHandle,
+  acquirePostMortemStageHandle,
   type PostMortemStageChatDeps,
 } from "../runs/foreground/postmortem-stage-chat.js";
-import type { StageControlHandle } from "../runs/foreground/stage-control-registry.js";
+import type {
+  DetachedStageHandleLease,
+  StageControlHandle,
+} from "../runs/foreground/stage-control-registry.js";
 import type { StageUserMessageDeliveryAction } from "../runs/foreground/stage-runner-types.js";
 import { store } from "../shared/store.js";
 import { stageUiBroker } from "../shared/stage-ui-broker.js";
@@ -12,6 +15,8 @@ import {
   hasStageInputAnswerContent,
   type StageInputAnswer,
 } from "../shared/stage-prompt.js";
+import { isTerminalRunStatus } from "../shared/store-internal.js";
+import { reciprocalWorkflowRootRunId } from "../shared/workflow-run-ownership.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { WorkflowToolArgs } from "./public-types.js";
 import {
@@ -21,8 +26,8 @@ import {
 } from "./workflow-targets.js";
 
 /**
- * Optional dependencies enabling `workflow send` to revive an eligible terminal
- * agent stage as a post-mortem chat when no process-local handle exists.
+ * Optional dependencies enabling `workflow send` to revive an eligible
+ * completed agent stage while its authoritative root is still nonterminal.
  */
 export interface WorkflowSendDeps {
   readonly resolvePostMortemDeps?: (runId: string) => PostMortemStageChatDeps;
@@ -60,28 +65,57 @@ function workflowSendResult(
   runId: string,
   stageId: string,
   delivery: WorkflowSendToolResult["delivery"],
-  status: WorkflowSendToolResult["status"],
+  status: "ok" | "noop",
   message: string,
 ): WorkflowSendToolResult {
   return { action: "send", runId, stageId, delivery, status, message };
 }
 
+function terminalWorkflowSendResult(
+  runId: string,
+  stageId: string,
+  workflowStatus: Parameters<typeof isTerminalRunStatus>[0],
+): WorkflowSendToolResult {
+  const message = `Cannot send a message because workflow ${runId} has terminated with status ${workflowStatus}. If work remains, start a new workflow to address it. Complete it inline only when the remaining task is small, deterministic, and low risk.`;
+  return {
+    action: "send",
+    runId,
+    stageId,
+    delivery: "rejected",
+    status: "failed",
+    code: "WORKFLOW_TERMINAL",
+    workflowStatus,
+    error: message,
+    message,
+  };
+}
+
+class WorkflowSendAdmissionError extends Error {
+  constructor(readonly result: WorkflowSendToolResult) {
+    super(result.message);
+  }
+}
+
+function terminalWorkflowSendResultForRoot(
+  rootRunId: string,
+  stageId: string,
+): WorkflowSendToolResult | undefined {
+  const rootRun = store.runs().find((run) => run.id === rootRunId);
+  return rootRun !== undefined && isTerminalRunStatus(rootRun.status)
+    ? terminalWorkflowSendResult(rootRun.id, stageId, rootRun.status)
+    : undefined;
+}
+
 async function deliverStageUserMessage(
   handle: StageControlHandle,
   text: string,
-  deliverAs?: "steer" | "followUp",
+  deliverAs: "steer" | "followUp" | undefined,
+  beforeDelivery: () => void,
 ): Promise<StageUserMessageDeliveryAction> {
-  if (handle.sendUserMessage !== undefined) return handle.sendUserMessage(text, { deliverAs });
-  if (!handle.isStreaming) {
-    await handle.prompt(text);
-    return "prompt";
+  if (handle.sendUserMessage === undefined) {
+    throw new Error("atomic-workflows: stage handle does not support admission-aware message delivery");
   }
-  if (deliverAs === "steer") {
-    await handle.steer(text);
-    return "steer";
-  }
-  await handle.followUp(text);
-  return "followUp";
+  return handle.sendUserMessage(text, { deliverAs }, beforeDelivery);
 }
 
 function deliveryMessage(delivery: StageUserMessageDeliveryAction): string {
@@ -106,6 +140,13 @@ export async function workflowSendAction(
   if (target.kind === "not_found") {
     return workflowSendResult(target.target, "", requestedDelivery, "noop", target.message);
   }
+  const runs = store.runs();
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const rootRunId = reciprocalWorkflowRootRunId(runById, target.runId) ?? target.runId;
+  const rootRun = runById.get(rootRunId);
+  if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
+    return terminalWorkflowSendResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
+  }
   const stage = resolveToolStageTarget(target.runId, args.stageId);
   if (!stage.ok || stage.stageId === undefined) {
     return workflowSendResult(
@@ -116,6 +157,7 @@ export async function workflowSendAction(
       stage.ok ? "Stage id, prefix, or name is required." : stage.message,
     );
   }
+  const resolvedStageId = stage.stageId;
   const stageRunId = stage.runId ?? target.runId;
   const run = store.runs().find((r) => r.id === stageRunId);
   const snapshot = run?.stages.find((s) => s.id === stage.stageId);
@@ -185,61 +227,118 @@ export async function workflowSendAction(
   if (text === undefined) {
     return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Send requires text, response, or message.");
   }
-  let handle: StageControlHandle | undefined = stageControlRegistry.get(stageRunId, stage.stageId);
-  if (handle === undefined && deps.resolvePostMortemDeps !== undefined && snapshot !== undefined) {
-    const revived = ensurePostMortemStageHandle(stageRunId, snapshot, deps.resolvePostMortemDeps(stageRunId));
-    if (revived.ok) handle = revived.handle;
+  let lease: DetachedStageHandleLease | undefined;
+  let handle: StageControlHandle | undefined;
+  const existingHandle = stageControlRegistry.peek(stageRunId, stage.stageId);
+  if (existingHandle !== undefined) {
+    lease = stageControlRegistry.acquireDetached(stageRunId, stage.stageId, () => existingHandle);
+    handle = lease.handle;
+  } else if (deps.resolvePostMortemDeps !== undefined && snapshot !== undefined) {
+    const acquired = acquirePostMortemStageHandle(stageRunId, snapshot, deps.resolvePostMortemDeps(stageRunId));
+    if (acquired.ok) {
+      lease = acquired.lease;
+      handle = lease.handle;
+    }
   }
   if (handle === undefined) {
     return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "No live handle for stage.");
   }
-  // A completed post-mortem handle is not live execution: its handle-level
-  // resume()/pause() reject by contract. Return a structured noop with guidance
-  // instead of letting that rejection cross the tool boundary. Failed handles
-  // remain eligible for their existing recoverable execution-resume semantics.
-  const isTerminalPostMortemStage = handle.status === "completed";
-  if (requestedDelivery === "resume" && handle.status !== "paused" && !isTerminalPostMortemStage) {
-    return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Stage is not paused; no resume message was delivered.");
-  }
-  if (handle.status === "paused" && requestedDelivery !== "resume" && requestedDelivery !== "auto") {
-    return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Stage is paused; resume it before sending a new message.");
-  }
-  if (requestedDelivery === "resume" || (requestedDelivery === "auto" && handle.status === "paused")) {
-    if (isTerminalPostMortemStage) {
-      return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Cannot resume a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+  let admitted = false;
+  // Store terminal publication and this final SDK admission check are both
+  // synchronous; no await occurs between this callback and SDK mutation.
+  const admitDelivery = (): void => {
+    const terminal = terminalWorkflowSendResultForRoot(rootRunId, args.stageId?.trim() ?? resolvedStageId);
+    if (terminal !== undefined) throw new WorkflowSendAdmissionError(terminal);
+    if (lease !== undefined && !lease.commit()) {
+      throw new WorkflowSendAdmissionError(workflowSendResult(
+        stageRunId,
+        resolvedStageId,
+        requestedDelivery,
+        "noop",
+        "Stage handle changed before message admission; retry against the current live stage.",
+      ));
     }
-    const resumedDelivery = await handle.resume(text);
-    if (resumedDelivery !== undefined && resumedDelivery !== "prompt") {
-      return workflowSendResult(stageRunId, stage.stageId, resumedDelivery, "ok", deliveryMessage(resumedDelivery));
+    admitted = true;
+  };
+  const terminalPending = Promise.withResolvers<never>();
+  const unsubscribeTerminal = store.subscribe(() => {
+    if (admitted) return;
+    const terminal = terminalWorkflowSendResultForRoot(rootRunId, args.stageId?.trim() ?? resolvedStageId);
+    if (terminal !== undefined) terminalPending.reject(new WorkflowSendAdmissionError(terminal));
+  });
+  const awaitAdmission = <T>(operation: Promise<T>): Promise<T> =>
+    Promise.race([operation, terminalPending.promise]);
+  try {
+    // A completed post-mortem handle is not live execution: its handle-level
+    // resume()/pause() reject by contract. Return a structured noop with guidance
+    // instead of letting that rejection cross the tool boundary. Failed handles
+    // remain eligible for their existing recoverable execution-resume semantics.
+    const isTerminalPostMortemStage = handle.status === "completed";
+    if (requestedDelivery === "resume" && handle.status !== "paused" && !isTerminalPostMortemStage) {
+      return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Stage is not paused; no resume message was delivered.");
     }
-    if (resumedDelivery === "prompt") {
-      return workflowSendResult(stageRunId, stage.stageId, "prompt", "ok", "Resumed stage and started prompt.");
+    if (handle.status === "paused" && requestedDelivery !== "resume" && requestedDelivery !== "auto") {
+      return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Stage is paused; resume it before sending a new message.");
     }
-    const hasResumeMessage = text.trim().length > 0;
-    return workflowSendResult(
-      stageRunId,
-      stage.stageId,
-      "resume",
-      "ok",
-      hasResumeMessage ? "Resumed interrupted stage with message." : "Resumed stage.",
-    );
-  }
-  if (requestedDelivery === "steer") {
-    if (isTerminalPostMortemStage) {
-      return workflowSendResult(stageRunId, stage.stageId, "steer", "noop", "Cannot steer a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+    const resumesStage = requestedDelivery === "resume" || (requestedDelivery === "auto" && handle.status === "paused");
+    if (!resumesStage && handle.sendUserMessage === undefined) {
+      return workflowSendResult(
+        stageRunId,
+        stage.stageId,
+        requestedDelivery,
+        "noop",
+        "Stage handle does not support admission-aware message delivery.",
+      );
     }
-    const delivery = await deliverStageUserMessage(handle, text, "steer");
-    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
-  }
-  if (requestedDelivery === "auto" && handle.isStreaming && !isTerminalPostMortemStage) {
-    const delivery = await deliverStageUserMessage(handle, text, "steer");
+    if (resumesStage) {
+      if (isTerminalPostMortemStage) {
+        return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Cannot resume a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+      }
+      const resumedDelivery = await awaitAdmission(handle.resume(text, admitDelivery));
+      if (resumedDelivery !== undefined && resumedDelivery !== "prompt") {
+        return workflowSendResult(stageRunId, stage.stageId, resumedDelivery, "ok", deliveryMessage(resumedDelivery));
+      }
+      if (resumedDelivery === "prompt") {
+        return workflowSendResult(stageRunId, stage.stageId, "prompt", "ok", "Resumed stage and started prompt.");
+      }
+      const hasResumeMessage = text.trim().length > 0;
+      return workflowSendResult(
+        stageRunId,
+        stage.stageId,
+        "resume",
+        "ok",
+        hasResumeMessage ? "Resumed interrupted stage with message." : "Resumed stage.",
+      );
+    }
+    if (requestedDelivery === "steer") {
+      if (isTerminalPostMortemStage) {
+        return workflowSendResult(stageRunId, stage.stageId, "steer", "noop", "Cannot steer a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+      }
+      const delivery = await awaitAdmission(deliverStageUserMessage(handle, text, "steer", admitDelivery));
+      return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
+    }
+    if (requestedDelivery === "auto" && handle.isStreaming && !isTerminalPostMortemStage) {
+      const delivery = await awaitAdmission(deliverStageUserMessage(handle, text, "steer", admitDelivery));
+      return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
+    }
+    if (requestedDelivery === "prompt") {
+      const delivery = await awaitAdmission(deliverStageUserMessage(handle, text, undefined, admitDelivery));
+      const message = delivery === "prompt" ? "Prompt sent to stage." : deliveryMessage(delivery);
+      return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", message);
+    }
+    const delivery = await awaitAdmission(deliverStageUserMessage(handle, text, "followUp", admitDelivery));
     return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
+  } catch (error) {
+    if (error instanceof WorkflowSendAdmissionError) return error.result;
+    throw error;
+  } finally {
+    unsubscribeTerminal();
+    if (!admitted) {
+      try {
+        await lease?.release();
+      } catch (error) {
+        console.warn("atomic-workflows: provisional workflow-send handle cleanup failed", error);
+      }
+    }
   }
-  if (requestedDelivery === "prompt") {
-    const delivery = await deliverStageUserMessage(handle, text);
-    const message = delivery === "prompt" ? "Prompt sent to stage." : deliveryMessage(delivery);
-    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", message);
-  }
-  const delivery = await deliverStageUserMessage(handle, text, "followUp");
-  return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
 }

package/dist/builtin/workflows/src/runs/background/run-inspect.ts

@@ -36,6 +36,8 @@ export interface RunDetail {
   readonly accumulatedDurationMs?: number;
   readonly inputs: Readonly<WorkflowInputValues>;
   readonly stages: readonly RunSnapshot["stages"][number][];
+  /** Always populated by inspectRun; optional for legacy structural literals. */
+  readonly tools?: readonly NonNullable<RunSnapshot["toolNodes"]>[number][];
   readonly result?: WorkflowOutputValues;
   readonly error?: string;
   readonly exited?: boolean;
@@ -45,6 +47,7 @@ export interface RunDetail {
   readonly failureRecoverability?: RunSnapshot["failureRecoverability"];
   readonly failureDisposition?: RunSnapshot["failureDisposition"];
   readonly failedStageId?: string;
+  readonly failedToolNodeId?: string;
   readonly resumable?: boolean;
   readonly retryAfterMs?: number;
   readonly blockedAt?: number;
@@ -77,7 +80,8 @@ export function inspectRun(
 
   // Deep copy so callers cannot mutate the store via the snapshot.
   const copy = structuredClone(candidate);
-  const expandedStages = expandWorkflowGraph(activeStore.snapshot(), copy.id).stages;
+  const expandedGraph = expandWorkflowGraph(activeStore.snapshot(), copy.id);
+  const expandedStages = expandedGraph.stages;
 
   const detail: RunDetail = {
     runId: copy.id,
@@ -93,6 +97,7 @@ export function inspectRun(
     accumulatedDurationMs: copy.accumulatedDurationMs,
     inputs: copy.inputs,
     stages: expandedStages.map((stage) => structuredClone(stage)),
+    tools: expandedGraph.tools.map((tool) => structuredClone(tool)),
     result: copy.result,
     error: copy.error ?? (effectiveRunStatus(copy) === copy.status ? undefined : (structuredRecoverableWorkflowFailureText(copy) ?? actionableReturnedStatusText(copy.result))),
     exited: copy.exited,
@@ -102,6 +107,7 @@ export function inspectRun(
     failureRecoverability: copy.failureRecoverability,
     failureDisposition: copy.failureDisposition,
     failedStageId: copy.failedStageId,
+    failedToolNodeId: copy.failedToolNodeId,
     resumable: copy.resumable,
     retryAfterMs: copy.retryAfterMs,
     blockedAt: copy.blockedAt,

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -21,6 +21,7 @@ import { topLevelWorkflowRuns } from "../../shared/run-visibility.js";
 import { effectiveRunStatus } from "../../shared/returned-run-status.js";
 import { markDurableResumed } from "./durable-resume-transition.js";
 import { resumeAcknowledgementMessage, settleResumeAcknowledgements, waitForResumeReconciliation } from "./resume-acknowledgements.js";
+import { selectedRunTerminalEvent } from "../../engine/run-terminal-event.js";
 import { aggregateWorkflowRootRunId, expandedControlRunIds, workflowHasPausedStages } from "./workflow-lifecycle-aggregate.js";
 // ---------------------------------------------------------------------------
 // Types
@@ -33,6 +34,8 @@ export interface RunStatusEntry {
   readonly startedAt: number;
   readonly durationMs?: number;
   readonly stageCount: number;
+  readonly toolCount?: number;
+  readonly nodeCount?: number;
 }
 
 export type KillResult =
@@ -79,14 +82,18 @@ export function statusRuns(opts?: { all?: boolean; store?: Store }): RunStatusEn
   const activeStore = opts?.store ?? defaultStore;
 
   const snapshot = activeStore.snapshot();
-  return topLevelWorkflowRuns(snapshot.runs).map((run) => ({
-    runId: run.id,
-    name: run.name,
-    status: effectiveRunStatus(run),
-    startedAt: run.startedAt,
-    durationMs: run.durationMs,
-    stageCount: expandWorkflowGraph(snapshot, run.id).stages.length,
-  }));
+  return topLevelWorkflowRuns(snapshot.runs).map((run) => {
+    const graph = expandWorkflowGraph(snapshot, run.id);
+    return {
+      runId: run.id,
+      name: run.name,
+      status: effectiveRunStatus(run),
+      startedAt: run.startedAt,
+      durationMs: run.durationMs,
+      stageCount: graph.stages.length,
+      ...(graph.tools.length > 0 ? { toolCount: graph.tools.length, nodeCount: graph.nodes.length } : {}),
+    };
+  });
 }
 // ---------------------------------------------------------------------------
 // killRun
@@ -124,6 +131,9 @@ export function killRun(
   // Abort active executor (no-op if not registered)
   const errorMessage = "workflow killed";
   opts?.cancellation?.abort(runId, errorMessage);
+  if (selectedRunTerminalEvent(runId)?.kind === "failure") {
+    return { ok: true, runId, previousStatus };
+  }
 
   const metadata = {
     failureKind: "cancelled",

package/dist/builtin/workflows/src/runs/background/workflow-lifecycle-aggregate.ts

@@ -1,5 +1,6 @@
 import { expandWorkflowGraph } from "../../shared/expanded-workflow-graph.js";
 import type { Store } from "../../shared/store-public-types.js";
+import { reciprocalWorkflowRootRunId } from "../../shared/workflow-run-ownership.js";
 
 /** Control-run ids visible below one workflow boundary, in graph order. */
 export function expandedControlRunIds(store: Store, runId: string): string[] {
@@ -11,17 +12,8 @@ export function expandedControlRunIds(store: Store, runId: string): string[] {
 
 /** Find the aggregate top-level lifecycle owner for a nested child run. */
 export function aggregateWorkflowRootRunId(store: Store, runId: string): string {
-  let current = runId;
-  const visited = new Set<string>();
-  while (!visited.has(current)) {
-    visited.add(current);
-    const parent = store.runs().find((run) => run.stages.some((stage) =>
-      stage.workflowChildRun?.runId === current || stage.workflowChild?.runId === current
-    ));
-    if (parent === undefined) return current;
-    current = parent.id;
-  }
-  return current;
+  const runById = new Map(store.runs().map((run) => [run.id, run]));
+  return reciprocalWorkflowRootRunId(runById, runId) ?? runId;
 }
 
 /** Whether this workflow boundary contains a paused/blocked descendant stage. */

package/dist/builtin/workflows/src/runs/foreground/executor-child-boundary.ts

@@ -1,6 +1,6 @@
 import type { RunSnapshot, StageSnapshot, WorkflowChildReplaySnapshot, WorkflowChildRunRef } from "../../shared/store-types.js";
 import type { Store } from "../../shared/store.js";
-import type { WorkflowChildResult } from "../../shared/types.js";
+import type { WorkflowChildResult, WorkflowSerializableValue } from "../../shared/types.js";
 import { appendStageEnd, appendStageStart } from "../../shared/persistence-session-entries.js";
 import { elapsedStageMs } from "../../shared/timing.js";
 import type { WorkflowFailure } from "../../shared/workflow-failures.js";
@@ -12,6 +12,9 @@ import { cloneWorkflowChildReplaySnapshot, cloneWorkflowChildValue } from "./exe
 import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
 import type { WorkflowExitCleanup } from "./executor-types.js";
 import { makeParentWorkflowExitAbortReason } from "./executor-abort.js";
+import type { DurableBoundaryRuntimeIdentity } from "../../durable/boundary-topology.js";
+import { DurableNestedTopologyError } from "../../durable/boundary-topology.js";
+import { parseWorkflowChildResult } from "../../durable/workflow-child-result.js";
 
 interface LinkedChildWorkflowExitState {
   readonly ref: WorkflowChildRunRef;
@@ -21,6 +24,8 @@ interface LinkedChildWorkflowExitState {
 
 export interface WorkflowBoundaryStage {
   readonly id: string;
+  readonly parentIds: readonly string[];
+  readonly sourceOrder: number;
   readonly replayedChild?: WorkflowChildResult;
   finalizeReplay(): void;
   linkChildRun(ref: WorkflowChildRunRef, childController: AbortController): void;
@@ -31,24 +36,19 @@ export interface WorkflowBoundaryStage {
 }
 
 function workflowChildResultFromReplay(snapshot: WorkflowChildReplaySnapshot): WorkflowChildResult {
-  const outputs = cloneWorkflowChildValue(snapshot.outputs);
-  if (snapshot.exited === true || snapshot.status !== "completed") {
-    return {
-      workflow: snapshot.workflow,
-      runId: snapshot.runId,
-      status: snapshot.status,
-      exited: true,
-      outputs,
-      ...(snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}),
-    };
-  }
-  return {
+  const candidate = {
     workflow: snapshot.workflow,
     runId: snapshot.runId,
-    status: "completed",
-    exited: false,
-    outputs,
-  };
+    status: snapshot.status,
+    exited: snapshot.exited,
+    outputs: cloneWorkflowChildValue(snapshot.outputs),
+    ...(snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}),
+  } as WorkflowSerializableValue;
+  const parsed = parseWorkflowChildResult(candidate);
+  if (parsed === undefined) {
+    throw new DurableNestedTopologyError("continuation child result has an invalid exited/status/output discriminant");
+  }
+  return parsed;
 }
 
 function requestLinkedChildWorkflowExit(linkedChild: LinkedChildWorkflowExitState, reason?: string): void {
@@ -77,9 +77,10 @@ export function createWorkflowBoundaryFactory(input: {
   readonly registerWorkflowExitCleanup: (stageId: string, cleanup: WorkflowExitCleanup) => () => void;
   readonly workflowExitSkippedReason: (reason?: string) => string;
   readonly classifyExecutorFailure: (error: unknown) => WorkflowFailure;
-}): (name: string, replayKey: string) => WorkflowBoundaryStage {
-  return (name: string, replayKey: string): WorkflowBoundaryStage => {
-    const stageId = crypto.randomUUID();
+}): (name: string, replayKey: string, identity?: DurableBoundaryRuntimeIdentity) => WorkflowBoundaryStage {
+  return (name: string, replayKey: string, identity?: DurableBoundaryRuntimeIdentity): WorkflowBoundaryStage => {
+    const stageId = identity?.boundaryId ?? crypto.randomUUID();
+    const sourceOrder = identity?.sourceOrder ?? input.runSnapshot.stages.length;
     const provisionalParentIds = input.tracker.onSpawn(stageId, name);
     const replayDecision = input.replayIndex.decide({
       displayName: name,
@@ -88,7 +89,7 @@ export function createWorkflowBoundaryFactory(input: {
       stageId,
       kind: "workflow",
     });
-    const parentIds = replayDecision.parentIds;
+    const parentIds = identity?.parentIds ?? replayDecision.parentIds;
     if (!sameStringSet(parentIds, provisionalParentIds)) input.tracker.replaceParents(stageId, parentIds);
     const replaySource = replayDecision.source;
     const replayChildSnapshot = replayDecision.kind === "replay" ? replayDecision.source.workflowChild : undefined;
@@ -203,6 +204,8 @@ export function createWorkflowBoundaryFactory(input: {
 
     return {
       id: stageId,
+      parentIds: Object.freeze([...parentIds]),
+      sourceOrder,
       ...(replayedChild !== undefined ? { replayedChild } : {}),
       finalizeReplay,
       linkChildRun(ref: WorkflowChildRunRef, childController: AbortController): void {

package/dist/builtin/workflows/src/runs/foreground/executor-hil.ts

@@ -320,7 +320,7 @@ export function shouldInjectResumeContinuation(state: {
   readonly aborted: boolean;
 }): boolean {
   if (state.reason === false || state.aborted) return false;
-  return state.reason === "queued-user-message" || state.gateEnabled;
+  return state.reason === "queued-user-message" || state.reason === "paused-queued-user-message" || state.gateEnabled;
 }
 
 let cachedReadinessGateTool: ReturnType<typeof createAskUserQuestionToolDefinition> | undefined;

package/dist/builtin/workflows/src/runs/foreground/executor-lifecycle.ts

@@ -8,19 +8,23 @@ import type {
   StageSnapshot,
 } from "../../shared/store-types.js";
 import type { Store } from "../../shared/store.js";
+import { isTerminalRunStatus } from "../../shared/store-internal.js";
 import type { WorkflowPersistencePort, WorkflowOutputValues } from "../../shared/types.js";
 import type { WorkflowFailure } from "../../shared/workflow-failures.js";
 import { appendRunBlocked, appendRunEnd } from "../../shared/persistence-session-entries.js";
 import type { RunOpts, RunResult } from "./executor-types.js";
 import { safeExecutorAggregateErrorItems } from "./executor-abort.js";
 
-export const EMPTY_WORKFLOW_GRAPH_ERROR_MESSAGE = "Workflow run completed without creating any workflow stages. Create at least one stage with ctx.stage(), ctx.task(), ctx.chain(), ctx.parallel(), or ctx.workflow().";
+export const EMPTY_WORKFLOW_GRAPH_ERROR_MESSAGE = "Workflow run completed without creating any workflow stages or durable tool nodes. Create tracked execution with ctx.stage(), ctx.task(), ctx.chain(), ctx.parallel(), ctx.workflow(), or ctx.tool().";
 
-export function assertWorkflowCreatedStage(runSnapshot: RunSnapshot): void {
-  if (runSnapshot.stages.length > 0) return;
+export function assertWorkflowCreatedExecution(runSnapshot: RunSnapshot): void {
+  if (runSnapshot.stages.length > 0 || (runSnapshot.toolNodes?.length ?? 0) > 0) return;
   throw new Error(EMPTY_WORKFLOW_GRAPH_ERROR_MESSAGE);
 }
 
+/** @deprecated Use assertWorkflowCreatedExecution. */
+export const assertWorkflowCreatedStage = assertWorkflowCreatedExecution;
+
 export function appendRunEndWhenRecorded(
   persistence: WorkflowPersistencePort | undefined,
   recorded: boolean,
@@ -37,6 +41,8 @@ export function appendRunEndWhenRecorded(
     readonly failureDisposition?: WorkflowFailureDisposition;
     readonly failureMessage?: string;
     readonly failedStageId?: string;
+    readonly failedToolNodeId?: string;
+    readonly failedToolNode?: import("../../shared/store-types.js").ToolNodeSnapshot;
     readonly resumable?: boolean;
     readonly retryAfterMs?: number;
     readonly ts: number;
@@ -46,24 +52,17 @@ export function appendRunEndWhenRecorded(
   appendRunEnd(persistence, payload);
 }
 
-export function isTerminalRunStatus(status: RunStatus): boolean {
-  return status === "completed" ||
-    status === "failed" ||
-    status === "killed" ||
-    status === "skipped" ||
-    status === "cancelled" ||
-    status === "blocked";
-}
-
 export function runResultFromSnapshot(snapshot: RunSnapshot): RunResult {
   return {
     runId: snapshot.id,
     status: snapshot.status,
     ...(snapshot.result !== undefined ? { result: snapshot.result } : {}),
     ...(snapshot.error !== undefined ? { error: snapshot.error } : {}),
+    ...(snapshot.failedToolNodeId !== undefined ? { failedToolNodeId: snapshot.failedToolNodeId } : {}),
     ...(snapshot.exited !== undefined ? { exited: snapshot.exited } : {}),
     ...(snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}),
     stages: [...snapshot.stages],
+    toolNodes: [...(snapshot.toolNodes ?? [])],
   };
 }
 
@@ -71,7 +70,7 @@ export function reconcileTerminalRunResult(
   runId: string,
   runSnapshot: RunSnapshot,
   activeStore: Store,
-  fallback: Omit<RunResult, "runId" | "stages">,
+  fallback: Omit<RunResult, "runId" | "stages" | "toolNodes">,
   onRunEnd: RunOpts["onRunEnd"],
 ): RunResult {
   const canonical = activeStore.runs().find((snapshot) =>
@@ -83,6 +82,7 @@ export function reconcileTerminalRunResult(
         runId,
         ...fallback,
         stages: [...runSnapshot.stages],
+        toolNodes: [...(runSnapshot.toolNodes ?? [])],
       };
   onRunEnd?.(runId, result.status, result.result, result.error, result.exitReason);
   return result;
@@ -96,6 +96,7 @@ export interface RunFailureMetadata {
   readonly failureDisposition?: WorkflowFailureDisposition;
   readonly failureMessage: string;
   readonly failedStageId?: string;
+  readonly failedToolNodeId?: string;
   readonly resumable: boolean;
   readonly retryAfterMs?: number;
 }
@@ -348,6 +349,21 @@ export function normalizeStageLessFailureMetadata(
   return { ...metadata, failureDisposition: "terminal_failed" };
 }
 
+/** A cancellation-shaped thrown error fails unless the run arbiter observed cancellation first. */
+export function normalizeFailureWinnerMetadata(
+  metadata: SelectedRunFailureMetadata,
+): SelectedRunFailureMetadata {
+  if (metadata.failureKind !== "cancelled" && metadata.failureCode !== "cancelled") return metadata;
+  return {
+    ...metadata,
+    failureKind: "unknown",
+    failureCode: "unknown",
+    failureRecoverability: "unknown",
+    failureDisposition: "terminal_failed",
+    resumable: true,
+  };
+}
+
 export function stageReplayFields(stage: StageSnapshot): Partial<Pick<StageSnapshot, "replayKey" | "replayedFromStageId" | "replayed">> {
   return {
     ...(stage.replayKey !== undefined ? { replayKey: stage.replayKey } : {}),
@@ -448,5 +464,6 @@ export function recordActiveBlockedFailure(
     status: "running",
     error: metadata.errorMessage,
     stages: [...runSnapshot.stages],
+    toolNodes: [...(runSnapshot.toolNodes ?? [])],
   };
 }