@bastani/atomic 0.9.41-alpha.1 → 0.9.41-alpha.2

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -52451,7 +52451,7 @@ function compareDraftSourceOrder(left, right) {
 function runTopologyFor(drafts, tools) {
   return drafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run ?? tools.find((checkpoint) => checkpoint.topology?.run !== undefined)?.topology?.run;
 }
-function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
+function validateRunGroups(grouped, rootRunId, tools, checkpoints, allowPendingChildren = false) {
   const toolsFor = (runId) => tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
   const owners = new Map;
   const syntheticChildIds = new Set;
@@ -52463,6 +52463,11 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
       if (childRunId === parentRunId || owners.has(childRunId))
         return false;
       if (!grouped.has(childRunId)) {
+        if (allowPendingChildren && isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) && !childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId)) {
+          syntheticChildIds.add(childRunId);
+          owners.set(childRunId, draft);
+          continue;
+        }
         if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId))
           return false;
         syntheticChildIds.add(childRunId);
@@ -52495,6 +52500,10 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
   }
   return true;
 }
+function isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) {
+  const boundary = draft.topology?.boundary;
+  return workflowChildFromDraft(draft) === undefined && boundary?.event === "start" && boundary.status === "running" && boundary.child.runId === childRunId && boundary.child.parentRunId === parentRunId && boundary.child.parentStageId === draft.topology?.stageId && boundary.child.rootRunId === rootRunId;
+}
 function isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) {
   const child = workflowChildFromDraft(draft);
   const boundary = draft.topology?.boundary;
@@ -56014,6 +56023,20 @@ function resolve_budget(layers) {
 var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15;
 var WORKFLOW_HEARTBEAT_CUSTOM_TYPE = "workflows:workflow-heartbeat";
 
+// dist/builtin/workflows/src/shared/workflow-source.ts
+var WORKFLOW_SOURCES = new WeakMap;
+var OWN_MODULE_PATH = normalizeStackPath(import.meta.url);
+function isWorkflowRuntimeModule(path) {
+  const normalized = normalizeStackPath(path);
+  return normalized === OWN_MODULE_PATH || isWorkflowRuntimeFrame(normalized);
+}
+function recordWorkflowSource(definition, path) {
+  WORKFLOW_SOURCES.set(definition, path);
+}
+function workflowSource(definition) {
+  return WORKFLOW_SOURCES.get(definition);
+}
+
 // dist/builtin/workflows/src/workflows/identity.ts
 function normalizeWorkflowName(name) {
   if (!name || typeof name !== "string") {
@@ -56061,8 +56084,10 @@ function isWorkflowAuthoringImplementationFrame(filePath) {
     return false;
   return normalized.includes("/packages/workflows/") || normalized.includes("/dist/builtin/workflows/") || normalized.includes("/.atomic/agent/extensions/workflows/");
 }
-function workflowNameFromCaller() {
-  const stack = new Error().stack;
+function callerSourcePath(entry) {
+  const capture = new Error;
+  Error.captureStackTrace(capture, entry);
+  const stack = capture.stack;
   if (stack === undefined)
     return;
   for (const line of stack.split(`
@@ -56072,14 +56097,18 @@ function workflowNameFromCaller() {
       continue;
     if (isWorkflowAuthoringImplementationFrame(filePath))
       continue;
-    const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
-    if (base.length > 0)
-      return base;
+    return isWorkflowRuntimeModule(filePath) ? undefined : filePath;
   }
   return;
 }
-function resolveWorkflowName(name) {
-  const resolved = name ?? workflowNameFromCaller();
+function workflowNameFromSourcePath(filePath) {
+  if (filePath === undefined)
+    return;
+  const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
+  return base.length > 0 ? base : undefined;
+}
+function resolveWorkflowName(name, sourcePath) {
+  const resolved = name ?? workflowNameFromSourcePath(sourcePath);
   if (resolved === undefined) {
     throw new TypeError("workflow: name must be provided when caller filename cannot be inferred");
   }
@@ -56115,7 +56144,8 @@ function workflow(spec) {
     throw new TypeError("workflow: heartbeatIntervalMinutes must be a non-negative finite number");
   }
   assertWorkflowBudget(spec.budget, "workflow: budget");
-  const name = resolveWorkflowName(spec.name);
+  const source = callerSourcePath(workflow);
+  const name = resolveWorkflowName(spec.name, source);
   const normalizedName = normalizeWorkflowName(name);
   requireNonEmptyString(normalizedName, "normalized name");
   const frozenInputs = freezeSchemaMap(spec.inputs ?? {});
@@ -56137,6 +56167,8 @@ function workflow(spec) {
     run
   };
   const branded = stampWorkflowDefinition(definition);
+  if (source !== undefined)
+    recordWorkflowSource(branded, source);
   return Object.freeze(branded);
 }
 
@@ -63585,6 +63617,7 @@ function createWorkflowExitManager(input) {
       ...outputSnapshot !== undefined ? { outputSnapshot } : {},
       ...validationError !== undefined ? { validationError } : {}
     }));
+    input.onExitSelected?.(selectedExit);
     input.controller.abort(selectedExit);
     runWorkflowExitCleanups(reason);
     throw selectedExit;
@@ -64854,6 +64887,402 @@ function deferStageUntilRunRelease(input) {
   };
 }
 
+// dist/builtin/workflows/src/engine/run-rejection-boundary.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { inspect } from "node:util";
+var EVENT = "unhandledRejection";
+var BOUNDARY_KEY = Symbol.for("atomic-workflows/run-rejection-boundary@5");
+var FLAG = "--unhandled-rejections";
+var MAX_CAUSE_DEPTH2 = 8;
+var MAX_PRIMITIVES_PER_RUN = 64;
+var MAX_STOP_STRINGS = 64;
+var ENDED_RUN_GRACE_MS = 30000;
+var NATIVE_REPORTING_MODES = new Set(["throw", "warn-with-error-code"]);
+function boundaryBag() {
+  return globalThis;
+}
+function sharedBoundary() {
+  const bag = boundaryBag();
+  const existing = bag[BOUNDARY_KEY];
+  if (existing !== undefined && existing.version === 5)
+    return existing;
+  const created = {
+    version: 5,
+    store: new AsyncLocalStorage3,
+    owners: new WeakMap,
+    promises: new WeakMap,
+    scopes: new Set,
+    runs: new Map,
+    ended: new Map,
+    stops: new Set,
+    listener: undefined
+  };
+  bag[BOUNDARY_KEY] = created;
+  return created;
+}
+function isObject(value2) {
+  return typeof value2 === "object" && value2 !== null || typeof value2 === "function";
+}
+function isPrimitive(value2) {
+  return !isObject(value2);
+}
+function safeField3(value2, key) {
+  try {
+    return value2[key];
+  } catch {
+    return;
+  }
+}
+function strongerEffect(left, right) {
+  return left === "fail-run" || right === "fail-run" ? "fail-run" : "ignore";
+}
+function addAttribution(into, scope, effect) {
+  into.set(scope, strongerEffect(into.get(scope), effect));
+}
+function recordedOwners(boundary, reason) {
+  const owners = new Map;
+  let stopped = false;
+  const seen = new Set;
+  const pending = [{ value: reason, depth: 0 }];
+  while (pending.length > 0) {
+    const { value: value2, depth } = pending.pop();
+    if (depth > MAX_CAUSE_DEPTH2)
+      continue;
+    if (isPrimitive(value2)) {
+      if (depth === 0 || value2 !== undefined && value2 !== null) {
+        for (const scope of boundary.scopes) {
+          const entry = scope.primitives.get(value2);
+          if (entry !== undefined)
+            addAttribution(owners, scope, entry.effect);
+        }
+        if (typeof value2 === "string" && boundary.stops.has(value2))
+          stopped = true;
+      }
+      continue;
+    }
+    if (seen.has(value2))
+      continue;
+    seen.add(value2);
+    for (const [scope, effect] of boundary.owners.get(value2) ?? [])
+      addAttribution(owners, scope, effect);
+    pending.push({ value: safeField3(value2, "cause"), depth: depth + 1 });
+    const errors = safeField3(value2, "errors");
+    if (Array.isArray(errors))
+      for (const entry of errors)
+        pending.push({ value: entry, depth: depth + 1 });
+  }
+  return { owners, stopped };
+}
+function pruneEndedSources(boundary) {
+  const now = Date.now();
+  for (const [source, trees] of boundary.ended) {
+    for (const [rootRunId, endedAt] of trees)
+      if (now - endedAt > ENDED_RUN_GRACE_MS)
+        trees.delete(rootRunId);
+    if (trees.size === 0)
+      boundary.ended.delete(source);
+  }
+}
+function recordEndedRun(boundary, scope) {
+  if (scope.source === undefined)
+    return;
+  const trees = boundary.ended.get(scope.source) ?? new Map;
+  trees.set(scope.rootRunId, Date.now());
+  boundary.ended.set(scope.source, trees);
+}
+function endedInAnotherRunTree(boundary, source, live) {
+  for (const endedRoot of boundary.ended.get(source)?.keys() ?? [])
+    if (endedRoot !== live.rootRunId)
+      return true;
+  return false;
+}
+function recognizedSources(boundary) {
+  pruneEndedSources(boundary);
+  const sources = new Set(boundary.ended.keys());
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source !== undefined)
+      sources.add(scope.source);
+  return sources;
+}
+function authoringSource(reason, sources) {
+  if (sources.size === 0 || !isObject(reason))
+    return;
+  const stack = safeField3(reason, "stack");
+  if (typeof stack !== "string")
+    return;
+  for (const line of stack.split(`
+`)) {
+    if (!line.trimStart().startsWith("at "))
+      continue;
+    const path = parsePromptStackFrame(line)?.normalizedPath;
+    if (path === undefined)
+      continue;
+    if (isWorkflowRuntimeModule(path))
+      return;
+    if (/\/node_modules\//.test(path))
+      continue;
+    if (sources.has(path))
+      return path;
+  }
+  return;
+}
+function hasAncestorIn(scope, candidates) {
+  for (let ancestor = scope.parent;ancestor !== undefined; ancestor = ancestor.parent) {
+    if (candidates.has(ancestor))
+      return true;
+  }
+  return false;
+}
+function outermostLiveRuns(boundary, source) {
+  const matching = new Set;
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source === source)
+      matching.add(scope);
+  const outermost = new Set;
+  for (const scope of matching)
+    if (!hasAncestorIn(scope, matching))
+      outermost.add(scope);
+  return outermost;
+}
+function runOfSource(boundary, source) {
+  const [only, ...others] = outermostLiveRuns(boundary, source);
+  if (only === undefined)
+    return new Map;
+  if (others.length > 0 || only.sharedSource)
+    return;
+  if (endedInAnotherRunTree(boundary, source, only))
+    return;
+  return new Map([[only, "fail-run"]]);
+}
+function markSharedSource(boundary, source) {
+  const runs = outermostLiveRuns(boundary, source);
+  if (runs.size > 1)
+    for (const run of runs)
+      run.sharedSource = true;
+}
+function rejectingRun(boundary, recorded, promise, scoped) {
+  const tracked = promise === undefined ? undefined : boundary.promises.get(promise);
+  if (tracked !== undefined && recorded.has(tracked))
+    return tracked;
+  if (scoped !== undefined && recorded.has(scoped))
+    return scoped;
+  return;
+}
+function attribute(boundary, reason, promise) {
+  const { owners: recorded, stopped } = recordedOwners(boundary, reason);
+  const scoped = boundary.store.getStore();
+  if (recorded.size > 1) {
+    const rejecting = rejectingRun(boundary, recorded, promise, scoped);
+    if (rejecting !== undefined)
+      return new Map([[rejecting, recorded.get(rejecting) ?? "fail-run"]]);
+  }
+  if (recorded.size > 0)
+    return recorded;
+  if (stopped)
+    return new Map;
+  if (scoped !== undefined && boundary.scopes.has(scoped))
+    return new Map([[scoped, "fail-run"]]);
+  const origin = authoringSource(reason, recognizedSources(boundary));
+  if (origin === undefined)
+    return;
+  if (scoped !== undefined)
+    return new Map([[scoped, "ignore"]]);
+  return runOfSource(boundary, origin);
+}
+function unhandledRejectionError(reason) {
+  return Object.assign(new Error("This error originated either by throwing inside of an async function without a catch block, " + `or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${inspect(reason)}".`), { code: "ERR_UNHANDLED_REJECTION" });
+}
+function unhandledRejectionsMode() {
+  const args = [...(process.env.NODE_OPTIONS ?? "").split(/\s+/), ...process.execArgv];
+  let mode = "throw";
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg.startsWith(`${FLAG}=`))
+      mode = arg.slice(FLAG.length + 1);
+    else if (arg === FLAG && args[index + 1] !== undefined)
+      mode = args[index + 1] ?? mode;
+  }
+  return mode;
+}
+function surfaceNatively(boundary, reason) {
+  const listener = boundary.listener;
+  if (listener === undefined || process.listenerCount(EVENT) > 1)
+    return;
+  if (!NATIVE_REPORTING_MODES.has(unhandledRejectionsMode()))
+    return;
+  process.nextTick(() => {
+    process.removeListener(EVENT, listener);
+    Promise.reject(reason);
+    setImmediate(() => {
+      if (!process.listeners(EVENT).includes(listener))
+        process.on(EVENT, listener);
+    });
+  });
+}
+function onUnhandledRejection(reason, promise) {
+  const boundary = sharedBoundary();
+  const owners = attribute(boundary, reason, promise);
+  if (owners === undefined) {
+    surfaceNatively(boundary, reason);
+    return;
+  }
+  const error = isObject(reason) ? reason : unhandledRejectionError(reason);
+  for (const [scope, effect] of owners) {
+    if (effect !== "fail-run" || !scope.live)
+      continue;
+    try {
+      scope.fail(error);
+    } catch {}
+  }
+}
+function ensureInstalled(boundary) {
+  if (boundary.listener !== undefined)
+    return;
+  boundary.listener = onUnhandledRejection;
+  process.on(EVENT, onUnhandledRejection);
+}
+function record(boundary, scope, reason, effect) {
+  if (isPrimitive(reason)) {
+    recordPrimitive(scope, reason, effect);
+    return;
+  }
+  const owners = boundary.owners.get(reason);
+  if (owners === undefined)
+    boundary.owners.set(reason, new Map([[scope, effect]]));
+  else
+    addAttribution(owners, scope, effect);
+}
+function recordStop(boundary, reason) {
+  boundary.stops.delete(reason);
+  boundary.stops.add(reason);
+  if (boundary.stops.size <= MAX_STOP_STRINGS)
+    return;
+  const oldest = boundary.stops.values().next();
+  if (!oldest.done)
+    boundary.stops.delete(oldest.value);
+}
+function recordPrimitive(scope, reason, effect) {
+  if (!scope.live)
+    return;
+  if (scope.primitives.size >= MAX_PRIMITIVES_PER_RUN && !scope.primitives.has(reason)) {
+    const oldest = scope.primitives.keys().next();
+    if (!oldest.done)
+      scope.primitives.delete(oldest.value);
+  }
+  scope.generation += 1;
+  const generation = scope.generation;
+  scope.primitives.set(reason, { effect: strongerEffect(scope.primitives.get(reason)?.effect, effect), generation });
+  afterPendingRejectionReports().then(() => {
+    if (scope.primitives.get(reason)?.generation === generation)
+      scope.primitives.delete(reason);
+  });
+}
+function discardFailure() {}
+function afterPendingRejectionReports() {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel;
+    port1.onmessage = () => {
+      port1.close();
+      port2.close();
+      resolve();
+    };
+    port2.postMessage(undefined);
+  });
+}
+function openRunRejectionScope(options) {
+  const boundary = sharedBoundary();
+  ensureInstalled(boundary);
+  pruneEndedSources(boundary);
+  const parent = options.parentRunId === undefined ? undefined : boundary.runs.get(options.parentRunId);
+  const scope = {
+    runId: options.runId,
+    rootRunId: parent?.rootRunId ?? options.runId,
+    source: options.source === undefined ? undefined : normalizeStackPath(options.source),
+    parent,
+    fail: options.fail,
+    primitives: new Map,
+    generation: 0,
+    live: true,
+    sharedSource: false
+  };
+  boundary.scopes.add(scope);
+  boundary.runs.set(scope.runId, scope);
+  if (scope.source !== undefined)
+    markSharedSource(boundary, scope.source);
+  return {
+    run: (callback) => boundary.store.run(scope, callback),
+    contain: (promise, effect = "fail-run") => {
+      boundary.promises.set(promise, scope);
+      promise.then(undefined, (reason) => record(boundary, scope, reason, effect));
+      return promise;
+    },
+    watch: (promise) => {
+      const watched = promise.then(undefined, (reason) => {
+        record(boundary, scope, reason, "fail-run");
+        throw reason;
+      });
+      boundary.promises.set(watched, scope);
+      return watched;
+    },
+    ignore: (reason) => {
+      if (typeof reason === "string")
+        recordStop(boundary, reason);
+      else
+        record(boundary, scope, reason, "ignore");
+    },
+    settle: afterPendingRejectionReports,
+    close: () => {
+      scope.live = false;
+      scope.fail = discardFailure;
+      recordEndedRun(boundary, scope);
+      afterPendingRejectionReports().then(() => {
+        scope.primitives.clear();
+        scope.parent = undefined;
+        boundary.scopes.delete(scope);
+        if (boundary.runs.get(scope.runId) === scope)
+          boundary.runs.delete(scope.runId);
+      });
+    }
+  };
+}
+var WATCHED_STAGE_METHODS = [
+  "prompt",
+  "complete",
+  "sendUserMessage",
+  "steer",
+  "followUp",
+  "setModel",
+  "setThinkingLevel",
+  "cycleModel",
+  "cycleThinkingLevel",
+  "navigateTree",
+  "compact",
+  "abort"
+];
+function containStageRejections(stage, scope) {
+  const contained = Object.create(stage);
+  const descriptors = {};
+  for (const name of WATCHED_STAGE_METHODS) {
+    descriptors[name] = {
+      value: (...args) => {
+        const result = Reflect.apply(stage[name], stage, args);
+        return result instanceof Promise ? scope.watch(result) : result;
+      }
+    };
+  }
+  Object.defineProperties(contained, descriptors);
+  return contained;
+}
+function containUiRejections(ui, scope) {
+  return {
+    input: (prompt) => scope.watch(ui.input(prompt)),
+    confirm: (message) => scope.watch(ui.confirm(message)),
+    select: (message, options) => scope.watch(ui.select(message, options)),
+    editor: (initial) => scope.watch(ui.editor(initial)),
+    custom: (factory, options) => scope.watch(ui.custom(factory, options))
+  };
+}
+
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -70870,13 +71299,13 @@ class EngineRuntime {
 
 // dist/builtin/workflows/src/engine/session-closed-error.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError5 } from "@bastani/atomic";
-var MAX_CAUSE_DEPTH2 = 8;
+var MAX_CAUSE_DEPTH3 = 8;
 function reportsClosedSession(error) {
   return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError5(error);
 }
 function isSessionClosedError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH2 && current !== undefined; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH3 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -70948,7 +71377,12 @@ async function executeRun(def, resolvedInputs, opts) {
     workflowObservationRuntime(activeStore).control(runId, "kill");
     ownController.abort(callerSignal?.reason);
   };
-  const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
+  const exit = createWorkflowExitManager({
+    runId,
+    exitScope,
+    controller: ownController,
+    onExitSelected: (signal) => rejectionScope.ignore(signal)
+  });
   const sourceBackend = opts.durableBackend;
   const backendView = sourceBackend;
   const rootBackend = opts.durableRootBackend ?? backendView;
@@ -71462,6 +71896,22 @@ async function executeRun(def, resolvedInputs, opts) {
     baseFromPromptNodes: getPromptNodeUi
   });
   let pausedExit;
+  const authoredIn = workflowSource(def);
+  const rejectionScope = openRunRejectionScope({
+    runId,
+    ...opts.parentRun !== undefined ? { parentRunId: opts.parentRun.runId } : {},
+    ...authoredIn !== undefined ? { source: authoredIn } : {},
+    fail: (error) => {
+      if (findWorkflowGracefulQuit(error) !== undefined)
+        return;
+      const selected = terminalEvents.selectFailure(error);
+      if (selected.kind === "failure" && !ownController.signal.aborted)
+        ownController.abort(selected.error);
+    }
+  });
+  ownController.signal.addEventListener("abort", () => rejectionScope.ignore(ownController.signal.reason), {
+    once: true
+  });
   const ctx = {
     inputs: resolvedInputs,
     runId,
@@ -71472,28 +71922,30 @@ async function executeRun(def, resolvedInputs, opts) {
       if (scheduler.isRunPaused()) {
         pausedExit ??= whenRunning(async () => exit.exit(options));
         pausedExit.catch(() => {});
-        throw new Error("Workflow exit is waiting for explicit resume");
+        const waiting = new Error("Workflow exit is waiting for explicit resume");
+        rejectionScope.ignore(waiting);
+        throw waiting;
       }
       return exit.exit(options);
     },
-    ui,
+    ui: containUiRejections(ui, rejectionScope),
     stage: (name, options) => {
       ownController.signal.throwIfAborted();
       if (!scheduler.isRunPaused())
-        return durableStage(name, options);
+        return containStageRejections(durableStage(name, options), rejectionScope);
       const replayKey = stageReplayKeyGenerator(name);
-      return deferStageUntilRunRelease({
+      return containStageRejections(deferStageUntilRunRelease({
         name,
         create: () => durableStage(name, options, replayKey),
         isPaused: scheduler.isRunPaused,
         waitForRelease: waitForRunRelease,
         signal: ownController.signal
-      });
+      }), rejectionScope);
     },
-    task: gatedTask,
-    chain: (...args) => whenRunning(() => chain(...args)),
-    parallel: (...args) => whenRunning(() => parallel(...args)),
-    workflow: (...args) => whenRunning(() => {
+    task: (...args) => rejectionScope.watch(gatedTask(...args)),
+    chain: (...args) => rejectionScope.watch(whenRunning(() => chain(...args))),
+    parallel: (...args) => rejectionScope.watch(whenRunning(() => parallel(...args))),
+    workflow: (...args) => rejectionScope.watch(whenRunning(() => {
       const pending = durableWorkflow(...args);
       pendingChildWorkflows.add(pending);
       const settled = () => {
@@ -71501,13 +71953,11 @@ async function executeRun(def, resolvedInputs, opts) {
       };
       pending.then(settled, settled);
       return pending;
-    }),
+    })),
     tool: (...args) => {
       if (admittedTools.closed)
-        return tool(...args);
-      const pending = whenRunning(() => tool(...args));
-      pending.catch(() => {});
-      return pending;
+        return rejectionScope.contain(tool(...args), "ignore");
+      return rejectionScope.contain(whenRunning(() => tool(...args)));
     },
     ...opts.models !== undefined ? { models: opts.models } : {}
   };
@@ -71659,7 +72109,7 @@ async function executeRun(def, resolvedInputs, opts) {
     while (scheduler.isRunPaused())
       await waitForRunRelease();
     ownController.signal.throwIfAborted();
-    const rawResult = await raceAbort(runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx)), ownController.signal);
+    const rawResult = await raceAbort(runWorkflowDefinitionCallback(def.name, runId, () => rejectionScope.run(() => def.run(ctx))), ownController.signal);
     await drainCachedStagePersistence();
     while (scheduler.isRunPaused())
       await waitForRunRelease();
@@ -71669,6 +72119,7 @@ async function executeRun(def, resolvedInputs, opts) {
     if (pausedExit !== undefined)
       await pausedExit;
     budget.rethrowIfSystemOwnedStop(runSnapshot.stages.at(-1)?.name ?? startupFrontierStage);
+    await rejectionScope.settle();
     const normalTerminalEvent = terminalEvents.winner();
     if (normalTerminalEvent?.kind === "cancellation") {
       const gracefulQuit = findWorkflowGracefulQuit(normalTerminalEvent.reason);
@@ -71738,6 +72189,9 @@ async function executeRun(def, resolvedInputs, opts) {
     }
     if (ownerClosing && err instanceof Error && isSessionClosedError(err))
       return await suspendForClosedSession(err);
+    if (selectedTerminalEvent.kind === "failure" && pendingChildWorkflows.size > 0 && !ownController.signal.aborted) {
+      ownController.abort(err);
+    }
     await admittedTools.closeAndDrain();
     if (ownController.signal.aborted)
       await Promise.allSettled([...pendingChildWorkflows]);
@@ -71812,6 +72266,7 @@ async function executeRun(def, resolvedInputs, opts) {
     });
     return failed;
   } finally {
+    rejectionScope.close();
     callerSignal?.removeEventListener("abort", onCallerAbort);
     workflowObservationRuntime(activeStore).finishRun(runId);
     runtimeSettled.resolve();
@@ -72926,11 +73381,17 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   retainReachableRunGroups(grouped, rootRunId);
   if (policy.failOnUnreachable && grouped.size !== groupedCount)
     return [];
-  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints))
+  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints, policy.retainActive))
     return [];
   const syntheticChildren = [];
+  const pendingChildren = [];
   for (const [parentRunId, runDrafts] of grouped) {
     for (const draft of runDrafts) {
+      const pendingChildRunId = childRunIdFromDraft(draft);
+      if (policy.retainActive && pendingChildRunId !== undefined && !grouped.has(pendingChildRunId) && isPendingChildBoundary(draft, parentRunId, pendingChildRunId, rootRunId)) {
+        pendingChildren.push({ parentRunId, owner: draft });
+        continue;
+      }
       const child = workflowChildFromDraft(draft);
       if (child?.exited !== true || grouped.has(child.runId))
         continue;
@@ -73039,6 +73500,28 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       resumable: false
     });
   }
+  for (const { parentRunId, owner } of pendingChildren) {
+    if (!emittedRunIds.has(parentRunId))
+      return [];
+    const topology = owner.topology;
+    const boundary = topology.boundary;
+    const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
+    if (parentStageId === undefined)
+      return [];
+    runs.push({
+      id: boundary.child.runId,
+      name: boundary.child.runName,
+      inputs: {},
+      status: "running",
+      stages: [],
+      toolNodes: [],
+      startedAt: owner.startedAt ?? owner.firstCompletedAt,
+      parentRunId,
+      parentStageId,
+      rootRunId: boundary.child.rootRunId,
+      resumable: false
+    });
+  }
   return runs;
 }
 function stageSnapshotFromDraft(draft, id, parentIds) {