@bastani/atomic 0.9.18 → 0.9.19-alpha.2

package/dist/builtin/workflows/src/index.js

@@ -302,7 +302,7 @@ function createSessionScopedSingleton(key, createLocal) {
   const live = () => shared.instance ?? instance;
   const current = () => live();
   const adoptWithResult = (scope, options) => {
-    const current2 = live();
+    const current = live();
     let targetCreated = false;
     const target = sessionScopedExtensionState(scope, key, () => {
       targetCreated = true;
@@ -311,8 +311,8 @@ function createSessionScopedSingleton(key, createLocal) {
       shared.localClaimed = true;
       return shared.local;
     });
-    const preservedCurrent = !targetCreated && target !== current2 && options?.preserveCurrentWhenTargetExists?.(current2, target) === true;
-    shared.instance = preservedCurrent ? current2 : target;
+    const preservedCurrent = !targetCreated && target !== current && options?.preserveCurrentWhenTargetExists?.(current, target) === true;
+    shared.instance = preservedCurrent ? current : target;
     instance = shared.instance;
     return { instance: shared.instance, preservedCurrent };
   };
@@ -569,17 +569,17 @@ function cloneWorkflowExitSnapshotValue(value, seen, stack = new Set) {
     return stack.has(objectValue) ? makeWorkflowExitSnapshotInvalidValue("circular object") : previousClone;
   }
   if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(objectValue, clone2);
+    const clone = [];
+    seen.set(objectValue, clone);
     stack.add(objectValue);
     try {
       for (let index = 0;index < value.length; index += 1) {
-        clone2[index] = cloneWorkflowExitSnapshotValue(value[index], seen, stack);
+        clone[index] = cloneWorkflowExitSnapshotValue(value[index], seen, stack);
       }
     } finally {
       stack.delete(objectValue);
     }
-    return clone2;
+    return clone;
   }
   if (!isPlainWorkflowExitSnapshotObject(objectValue)) {
     return makeWorkflowExitSnapshotInvalidValue(workflowSerializableTypeName(value));
@@ -952,7 +952,7 @@ function buildStagePromptAdapter(id, kind, args, createdAt) {
 }
 
 // dist/builtin/workflows/src/shared/stage-ui-broker.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/pending-stage-delivery.ts
 var PENDING_STAGE_MESSAGE_LIMIT = 50;
@@ -963,7 +963,7 @@ function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity
   }
   const messageId = input.message.id;
   const queued = pendingStageMessagesFor(messages, input.runId, input.stageKey, stageIdentity);
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing, stageIdentity) !== pendingStageMessageSignature(input, stageIdentity)) {
       return {
@@ -1013,7 +1013,7 @@ function queueStickyStageMessage(messages, input, senderGroup, runGroup) {
     return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.targetPath };
   }
   const messageId = input.message.id;
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing) !== pendingStageMessageSignature(input)) {
       return {
@@ -1064,7 +1064,7 @@ function queuedStickyCount(messages, runId, targetPath) {
   return messages.filter((entry) => entry.runId === runId && entry.sticky === true && entry.targetPath === targetPath && entry.status === "queued").length;
 }
 function recordPendingStageMessageDeliveries(messages, runId, messageId, records, deliveredAt) {
-  const index = messages.findIndex((entry2) => entry2.runId === runId && entry2.id === messageId && entry2.sticky === true && entry2.status === "queued");
+  const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued");
   if (index < 0)
     return messages;
   const entry = messages[index];
@@ -1507,6 +1507,7 @@ function compactStage(stage) {
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
+    structured: _structured,
     ...metadata
   } = stage;
   return {
@@ -1565,6 +1566,173 @@ function deepFreezeGraphValue(value) {
   }
 }
 
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+import { randomUUID } from "node:crypto";
+
+// dist/builtin/workflows/src/shared/workflow-activity.ts
+function workflowActivityNodeKey(runId, nodeId) {
+  return `${runId}:${nodeId}`;
+}
+
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+class WorkflowObservationRuntime {
+  runs;
+  invalidate;
+  liveRunIds = new Set;
+  executingStageIds = new Set;
+  executingToolNodeIds = new Set;
+  stoppingRunIds = new Set;
+  retryingStageIds = new Set;
+  acknowledgedFailureRunIds = new Set;
+  listeners = new Set;
+  replayStageIds = new Set;
+  previous = new Map;
+  recoveryDepth = 0;
+  constructor(runs, invalidate) {
+    this.runs = runs;
+    this.invalidate = invalidate;
+  }
+  get recovering() {
+    return this.recoveryDepth > 0;
+  }
+  startRun(runId) {
+    this.liveRunIds.add(runId);
+    this.stoppingRunIds.delete(runId);
+  }
+  finishRun(runId) {
+    this.liveRunIds.delete(runId);
+    this.stoppingRunIds.delete(runId);
+    for (const ids of [
+      this.executingStageIds,
+      this.executingToolNodeIds,
+      this.retryingStageIds,
+      this.replayStageIds
+    ]) {
+      for (const id of ids)
+        if (id.startsWith(`${runId}:`))
+          ids.delete(id);
+    }
+    this.invalidate();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  rootRunId(run) {
+    if (run.rootRunId !== undefined)
+      return run.rootRunId;
+    if (run.parentRunId === undefined)
+      return run.id;
+    const parent = this.runs().find((candidate) => candidate.id === run.parentRunId);
+    return parent ? this.rootRunId(parent) : run.parentRunId;
+  }
+  lifecycle(target, attribution = "unknown") {
+    if (this.recovering && !this.liveRunIds.has(target.runId))
+      return;
+    const run = this.runs().find((candidate) => candidate.id === target.runId);
+    if (!run)
+      return;
+    const rootRunId = this.rootRunId(run);
+    const now = Date.now();
+    this.emit({
+      kind: "lifecycle",
+      event: {
+        type: "workflow_lifecycle",
+        eventId: randomUUID(),
+        runId: run.id,
+        rootRunId,
+        occurredAt: now,
+        observedAt: now,
+        target: canonicalTarget(target, rootRunId),
+        attribution,
+        delivery: target.kind === "stage" && this.replayStageIds.has(workflowActivityNodeKey(run.id, target.stageId)) ? "replay" : "live"
+      }
+    });
+  }
+  control(runId, action, attribution = "unknown") {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (!run)
+      return;
+    if ((action === "quit" || action === "kill" || action === "interrupt") && this.liveRunIds.has(runId))
+      this.stoppingRunIds.add(runId);
+    if (action === "resume")
+      this.stoppingRunIds.delete(runId);
+    this.lifecycle({ kind: "run", runId, status: run.status, action }, attribution);
+    this.invalidate();
+  }
+  heartbeat(runId, scheduledAt, intervalMinutes) {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (run)
+      this.emit({
+        kind: "heartbeat",
+        event: { type: "workflow_heartbeat", runId, rootRunId: this.rootRunId(run), scheduledAt, intervalMinutes }
+      });
+  }
+  beginRecovery() {
+    this.recoveryDepth++;
+    if (this.recoveryDepth === 1)
+      this.emit({ kind: "availability" });
+    let ended = false;
+    return () => {
+      if (ended)
+        return;
+      ended = true;
+      this.capture();
+      this.recoveryDepth--;
+      if (!this.recovering)
+        this.emit({ kind: "availability" });
+    };
+  }
+  capture() {
+    const next = new Map;
+    const visit = (key, target, historical = false) => {
+      next.set(key, target);
+      const previous = this.previous.get(key);
+      if (!historical && this.liveRunIds.has(target.runId) && previous?.status !== target.status) {
+        this.lifecycle(previous && previous.kind !== "prompt" && target.kind !== "prompt" ? { ...target, previousStatus: previous.status } : target, this.runs().find((run) => run.id === target.runId)?.origin);
+      }
+    };
+    for (const run of this.runs()) {
+      const existing = this.previous.has(`run:${run.id}`);
+      visit(`run:${run.id}`, { kind: "run", runId: run.id, status: run.status });
+      for (const stage of run.stages) {
+        visit(`stage:${workflowActivityNodeKey(run.id, stage.id)}`, { kind: "stage", runId: run.id, stageId: stage.id, stageName: stage.name, status: stage.status }, !existing);
+        if (stage.pendingPrompt)
+          visit(`prompt:${stage.pendingPrompt.id}`, {
+            kind: "prompt",
+            runId: run.id,
+            stageId: stage.id,
+            promptId: stage.pendingPrompt.id,
+            status: "opened"
+          }, !existing);
+      }
+      for (const tool of run.toolNodes ?? [])
+        visit(`tool:${workflowActivityNodeKey(run.id, tool.id)}`, { kind: "tool", runId: run.id, toolNodeId: tool.id, toolName: tool.name, status: tool.status }, !existing);
+      if (run.pendingPrompt)
+        visit(`prompt:${run.pendingPrompt.id}`, { kind: "prompt", runId: run.id, promptId: run.pendingPrompt.id, status: "opened" }, !existing);
+    }
+    this.previous = next;
+  }
+}
+var workflowObservationRuntimeKey = Symbol.for("atomic-workflows/store-observation-runtime@1");
+function canonicalTarget(target, rootRunId) {
+  if (target.runId === rootRunId)
+    return target;
+  switch (target.kind) {
+    case "stage":
+      return { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "tool":
+      return { ...target, toolNodeId: workflowActivityNodeKey(target.runId, target.toolNodeId) };
+    case "prompt":
+      return target.stageId === undefined ? target : { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "run":
+      return target;
+  }
+}
+
 // dist/builtin/workflows/src/shared/store-internal.ts
 var TERMINAL_STATUSES = new Set([
   "completed",
@@ -1667,6 +1835,7 @@ function createStoreState() {
 function createStoreContext(state = createStoreState()) {
   let cachedGraphVersion = -1;
   let cachedGraphSnapshot;
+  const observation = new WorkflowObservationRuntime(() => state.runs, bumpAndNotify);
   function snapshot() {
     return JSON.parse(JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }));
   }
@@ -1678,6 +1847,7 @@ function createStoreContext(state = createStoreState()) {
     return cachedGraphSnapshot;
   }
   function notify() {
+    observation.capture();
     for (const fn of state.invalidationListeners) {
       try {
         fn();
@@ -1733,6 +1903,7 @@ function createStoreContext(state = createStoreState()) {
     const prompt = stage.pendingPrompt;
     if (!prompt)
       return;
+    observation.lifecycle({ kind: "prompt", runId, stageId: stage.id, promptId: prompt.id, status: "cancelled" });
     stage.pendingPrompt = undefined;
     state.stagePromptDrafts.delete(stagePromptDraftKey(runId, stage.id, prompt.id));
     rejectPrompt(prompt.id, reason);
@@ -1744,6 +1915,7 @@ function createStoreContext(state = createStoreState()) {
   }
   return {
     state,
+    observation,
     snapshot,
     graphSnapshot,
     notify,
@@ -1913,8 +2085,8 @@ function createPendingStageDeliveryStoreMethods(context) {
   };
 }
 function resolvePendingStageIdentity(run, stageKey) {
-  const exactIds = run.stages.filter((stage2) => stage2.id === stageKey);
-  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage2) => stage2.name === stageKey);
+  const exactIds = run.stages.filter((stage) => stage.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage) => stage.name === stageKey);
   if (candidates.length !== 1)
     return;
   const stage = candidates[0];
@@ -1953,6 +2125,7 @@ function createPromptStoreMethods(context) {
       const pending = run.pendingPrompt;
       if (!pending || pending.id !== promptId)
         return false;
+      context.observation.lifecycle({ kind: "prompt", runId, promptId, status: "answered" });
       run.pendingPrompt = undefined;
       context.bumpAndNotify();
       const entry = state.resolvers.get(promptId);
@@ -2023,6 +2196,13 @@ function createPromptStoreMethods(context) {
         state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stageId));
         delete stage.promptAnswerState;
       }
+      context.observation.lifecycle({
+        kind: "prompt",
+        runId,
+        stageId,
+        promptId,
+        status: options.recordAnswer === false ? "cancelled" : "answered"
+      });
       stage.pendingPrompt = undefined;
       if (stage.status === "awaiting_input") {
         stage.status = "running";
@@ -2239,6 +2419,7 @@ function createRunStoreMethods(context) {
       }
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         run.pendingPrompt = undefined;
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
       }
@@ -2320,6 +2501,7 @@ function createRunStoreMethods(context) {
       const run = state.runs[index];
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
       }
       context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
@@ -2480,6 +2662,8 @@ function createToolNodeStoreMethods(context) {
         return false;
       node.status = "running";
       node.startedAt = startedAt;
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingToolNodeIds.add(workflowActivityNodeKey(runId, nodeId));
       context.bumpAndNotify();
       return true;
     },
@@ -2487,6 +2671,7 @@ function createToolNodeStoreMethods(context) {
       const node = context.findRun(runId)?.toolNodes?.find((candidate) => candidate.id === nodeId);
       if (node === undefined || node.status === "completed" || node.status === "failed" || node.status === "cached" || node.status === "cancelled")
         return false;
+      context.observation.executingToolNodeIds.delete(workflowActivityNodeKey(runId, nodeId));
       node.status = update.status;
       if (update.endedAt !== undefined)
         node.endedAt = update.endedAt;
@@ -2516,6 +2701,9 @@ function createStageStoreMethods(context) {
       if (!run.stages.some((s) => s.id === stage.id)) {
         run.stages.push(stage);
       }
+      if (stage.status === "running" && context.observation.liveRunIds.has(runId)) {
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stage.id));
+      }
       context.bumpAndNotify();
     },
     recordStageWorkflowChildRun(runId, stageId, ref) {
@@ -2525,8 +2713,12 @@ function createStageStoreMethods(context) {
       const stage = context.findStage(run, stageId);
       if (!stage)
         return false;
-      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow)
+      const released = context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
+      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow) {
+        if (released)
+          context.bumpAndNotify();
         return false;
+      }
       stage.workflowChildRun = { ...ref };
       context.bumpAndNotify();
       return true;
@@ -2565,6 +2757,7 @@ function createStageStoreMethods(context) {
       const existing = context.findStage(run, stage.id);
       if (!existing)
         return;
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stage.id));
       existing.status = stage.status;
       existing.endedAt = stage.endedAt;
       if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
@@ -2788,6 +2981,7 @@ function createStageStoreMethods(context) {
         context.bumpAndNotify();
         return false;
       }
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
       stage.status = "paused";
       stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
       stage.resumedAt = undefined;
@@ -2820,6 +3014,8 @@ function createStageStoreMethods(context) {
         return false;
       }
       const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stageId));
       stage.status = "running";
       if (stage.startedAt !== undefined) {
         stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
@@ -2842,13 +3038,18 @@ function createStageStoreMethods(context) {
 // dist/builtin/workflows/src/shared/store-factory.ts
 function createStore() {
   const context = createStoreContext();
-  return {
+  const created = {
+    [workflowObservationRuntimeKey]: context.observation,
     ...createRunStoreMethods(context),
     ...createPendingStageDeliveryStoreMethods(context),
     ...createStageStoreMethods(context),
     ...createToolNodeStoreMethods(context),
     ...createPromptStoreMethods(context)
   };
+  return created;
+}
+function workflowObservationRuntime(activeStore) {
+  return activeStore[workflowObservationRuntimeKey];
 }
 var SESSION_KEY2 = "workflows:store:v1";
 var singleton2 = createSessionScopedSingleton(SESSION_KEY2, createStore);
@@ -2858,7 +3059,7 @@ function key(runId, stageId) {
   return `${runId}\x00${stageId}`;
 }
 function nextRequestId() {
-  return `stage-ui-${randomUUID()}`;
+  return `stage-ui-${randomUUID2()}`;
 }
 
 class StageUiBroker {
@@ -3265,8 +3466,8 @@ function normalizeUIContext(adapter) {
   };
 }
 function stringField(value, keys) {
-  for (const key2 of keys) {
-    const candidate = value[key2];
+  for (const key of keys) {
+    const candidate = value[key];
     if (typeof candidate === "string" && candidate.length > 0)
       return candidate;
   }
@@ -3463,17 +3664,17 @@ function schemaIsRequired(schema) {
 import { Value as Value2 } from "typebox/value";
 function validateInputs(schema, inputs) {
   const errors = [];
-  for (const key2 of Object.keys(inputs)) {
-    if (!(key2 in schema)) {
-      errors.push({ key: key2, reason: "unknown input key (not declared by this workflow)" });
+  for (const key of Object.keys(inputs)) {
+    if (!(key in schema)) {
+      errors.push({ key, reason: "unknown input key (not declared by this workflow)" });
     }
   }
-  for (const [key2, def] of Object.entries(schema)) {
-    const value = inputs[key2];
+  for (const [key, def] of Object.entries(schema)) {
+    const value = inputs[key];
     let hasTypeError = false;
     if (value === undefined) {
       if (schemaIsRequired(def)) {
-        errors.push({ key: key2, reason: "required input is missing" });
+        errors.push({ key, reason: "required input is missing" });
       }
       continue;
     }
@@ -3481,25 +3682,25 @@ function validateInputs(schema, inputs) {
     switch (kind) {
       case "text":
         if (typeof value !== "string") {
-          errors.push({ key: key2, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "number":
         if (typeof value !== "number" || !Number.isFinite(value)) {
-          errors.push({ key: key2, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "integer":
         if (typeof value !== "number" || !Number.isInteger(value)) {
-          errors.push({ key: key2, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "boolean":
         if (typeof value !== "boolean") {
-          errors.push({ key: key2, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
@@ -3507,24 +3708,24 @@ function validateInputs(schema, inputs) {
         const choices = schemaChoices(def) ?? [];
         const allowed = choices.join(", ");
         if (typeof value !== "string") {
-          errors.push({ key: key2, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         } else if (!choices.includes(value)) {
-          errors.push({ key: key2, reason: `must be one of [${allowed}]` });
+          errors.push({ key, reason: `must be one of [${allowed}]` });
         }
         break;
       }
       default:
         if (!Value2.Check(def, value)) {
           const first = [...Value2.Errors(def, value)][0];
-          errors.push({ key: key2, reason: first === undefined ? `does not match ${kind} schema` : first.message });
+          errors.push({ key, reason: first === undefined ? `does not match ${kind} schema` : first.message });
           hasTypeError = true;
         }
         break;
     }
-    const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key2}"`);
+    const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key}"`);
     if (serializableError !== undefined) {
-      errors.push({ key: key2, reason: serializableError.replace(/^input "[^"]+" /, "") });
+      errors.push({ key, reason: serializableError.replace(/^input "[^"]+" /, "") });
     }
   }
   return errors;
@@ -3533,18 +3734,19 @@ function validateInputs(schema, inputs) {
 // dist/builtin/workflows/src/runs/foreground/executor-inputs.ts
 function resolveInputs(schema, provided) {
   const resolved = {};
-  for (const [key2, value] of Object.entries(provided)) {
+  for (const [key, value] of Object.entries(provided)) {
     if (value !== undefined)
-      resolved[key2] = value;
+      resolved[key] = value;
   }
-  const withDefaults = Value3.Default(Type2.Object(schema, { additionalProperties: true }), resolved);
-  for (const [key2, value] of Object.entries(withDefaults)) {
+  const ownedInputs = Value3.Clone(resolved);
+  const withDefaults = Value3.Default(Type2.Object(schema, { additionalProperties: true }), ownedInputs);
+  for (const [key, value] of Object.entries(withDefaults)) {
     if (value !== undefined)
-      resolved[key2] = value;
+      resolved[key] = value;
   }
-  for (const [key2, schemaDef] of Object.entries(schema)) {
-    if (schemaIsRequired(schemaDef) && resolved[key2] === undefined) {
-      throw new TypeError(`atomic-workflows: required input "${key2}" not provided`);
+  for (const [key, schemaDef] of Object.entries(schema)) {
+    if (schemaIsRequired(schemaDef) && resolved[key] === undefined) {
+      throw new TypeError(`atomic-workflows: required input "${key}" not provided`);
     }
   }
   return resolved;
@@ -3590,12 +3792,12 @@ ${formatValidationErrors(errors)}`);
 function asRecord(value) {
   return value !== null && typeof value === "object" ? value : undefined;
 }
-function field(value, key2) {
-  return asRecord(value)?.[key2];
+function field(value, key) {
+  return asRecord(value)?.[key];
 }
-function safeField(value, key2) {
+function safeField(value, key) {
   try {
-    return field(value, key2);
+    return field(value, key);
   } catch {
     return;
   }
@@ -3625,8 +3827,8 @@ function findProcessFailureError(value, seen, depth) {
     return value;
   if (nonEmptyProcessOutput(safeField(value, "stderr")))
     return value;
-  for (const key2 of ["cause", "error", "response", "body"]) {
-    const selected = findProcessFailureError(safeField(value, key2), seen, depth + 1);
+  for (const key of ["cause", "error", "response", "body"]) {
+    const selected = findProcessFailureError(safeField(value, key), seen, depth + 1);
     if (selected !== undefined)
       return selected;
   }
@@ -3654,8 +3856,8 @@ function selectProcessFailureError(error) {
 function hasProcessFailureEvidence(error) {
   return findProcessFailureError(error, new Set, 0) !== undefined;
 }
-function stringField2(value, key2) {
-  const raw = field(value, key2);
+function stringField2(value, key) {
+  const raw = field(value, key);
   return typeof raw === "string" && raw.length > 0 ? raw : undefined;
 }
 function errorMessage(error) {
@@ -3837,15 +4039,15 @@ function redactSensitiveText(value) {
 var TOOL_FAILURE_TEXT_LIMIT_BYTES = 16384;
 var TRUNCATION_PREFIX = `[workflow tool output truncated; showing final bytes]
 `;
-function safeField2(error, key2) {
+function safeField2(error, key) {
   try {
-    return field(error, key2);
+    return field(error, key);
   } catch {
     return;
   }
 }
-function exposedText(error, key2) {
-  const value = safeField2(error, key2);
+function exposedText(error, key) {
+  const value = safeField2(error, key);
   if (typeof value === "string")
     return value;
   try {
@@ -3954,7 +4156,7 @@ function canonicalJsonString(value) {
     return `[${value.map(canonicalJsonString).join(",")}]`;
   const object = value;
   const keys = Object.keys(object).sort();
-  return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalJsonString(object[key2])}`).join(",")}}`;
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJsonString(object[key])}`).join(",")}}`;
 }
 // dist/builtin/workflows/src/durable/backend.ts
 function pendingStageMessagesForDurableRun(backend, logicalRunId, rootWorkflowId = logicalRunId) {
@@ -3993,13 +4195,13 @@ function cloneWorkflowChildReplaySnapshot(snapshot) {
 }
 function workflowChildReplaySnapshot(alias, childResult) {
   const outputs = {};
-  for (const [key2, value] of Object.entries(childResult.outputs)) {
+  for (const [key, value] of Object.entries(childResult.outputs)) {
     if (value === undefined)
       continue;
     try {
-      outputs[key2] = cloneWorkflowChildValue(value);
+      outputs[key] = cloneWorkflowChildValue(value);
     } catch (err) {
-      throw new Error(`atomic-workflows: child workflow "${alias}" (${childResult.workflow}) exposed output "${key2}" is not serializable for continuation replay: ${workflowChildSerializationMessage(err)}`, { cause: err });
+      throw new Error(`atomic-workflows: child workflow "${alias}" (${childResult.workflow}) exposed output "${key}" is not serializable for continuation replay: ${workflowChildSerializationMessage(err)}`, { cause: err });
     }
   }
   const exitReason = childResult.exited === true ? childResult.exitReason : undefined;
@@ -4148,10 +4350,10 @@ function durableStageGroupKey(stage, stages = [stage]) {
 function groupByDurableStageKey(stages) {
   const groups = new Map;
   for (const stage of stages) {
-    const key2 = durableStageGroupKey(stage, stages);
-    const group = groups.get(key2) ?? [];
+    const key = durableStageGroupKey(stage, stages);
+    const group = groups.get(key) ?? [];
     group.push(stage);
-    groups.set(key2, group);
+    groups.set(key, group);
   }
   return groups;
 }
@@ -4193,13 +4395,13 @@ function hasCycle(topologies) {
 function parseWorkflowChildResult(value) {
   if (!isOrdinaryObject(value))
     return;
-  const workflow2 = value.workflow;
+  const workflow = value.workflow;
   const runId = value.runId;
   const status = value.status;
   const exited = value.exited;
   const outputs = value.outputs;
   const exitReason = value.exitReason;
-  if (typeof workflow2 !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
+  if (typeof workflow !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
     return;
   if (exited === false) {
     if (status !== "completed" || exitReason !== undefined)
@@ -4637,7 +4839,7 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
 }
 
 // dist/builtin/workflows/src/durable/tool-primitive.ts
-import { runCallback } from "@bastani/atomic";
+import { collectAgentTasks, runCallback } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/engine/workflow-tool-abort.ts
 class WorkflowToolAbortError extends Error {
@@ -4767,6 +4969,58 @@ function captureCallbackSource(fn) {
     return;
   }
 }
+async function awaitTerminalTask(task) {
+  for (;; ) {
+    const observed = await task.host.waitForTask(task.taskId);
+    if (!observed.ok)
+      throw new Error(`${observed.error.code}: ${observed.error.message}`);
+    if (observed.value.kind === "settled")
+      return observed.value.result;
+  }
+}
+function replaceTaskObservations(value, terminal) {
+  if (!value || typeof value !== "object")
+    return value;
+  if (Array.isArray(value)) {
+    const next = value.map((item) => replaceTaskObservations(item, terminal));
+    return next.some((item, index) => item !== value[index]) ? next : value;
+  }
+  const object = value;
+  if (object.kind === "yielded" && typeof object.taskId === "string") {
+    const result = terminal.get(object.taskId);
+    if (result)
+      return { kind: "settled", taskId: object.taskId, result };
+  }
+  let changed = false;
+  const next = {};
+  for (const [key, item] of Object.entries(object)) {
+    next[key] = replaceTaskObservations(item, terminal);
+    changed ||= next[key] !== item;
+  }
+  if (changed && next.details !== object.details && next.details && typeof next.details === "object" && !Array.isArray(next.details) && Array.isArray(object.content)) {
+    const details = next.details;
+    const original = object.details;
+    if (details.taskResponse !== undefined && details.taskResponse !== original.taskResponse) {
+      const before = JSON.stringify(original.taskResponse);
+      next.content = object.content.map((part) => {
+        if (!part || typeof part !== "object" || Array.isArray(part))
+          return part;
+        const content = part;
+        return content.type === "text" && content.text === before ? { ...content, text: JSON.stringify(details.taskResponse) } : part;
+      });
+    }
+  }
+  return changed ? next : value;
+}
+function invokeTaskCallback(fn, signal) {
+  return collectAgentTasks(signal, () => fn({ signal }), async (value, tasks) => {
+    if (tasks.length === 0)
+      return value;
+    const terminal = new Map;
+    await Promise.all(tasks.map(async (task) => terminal.set(task.taskId, await awaitTerminalTask(task))));
+    return replaceTaskObservations(value, terminal);
+  });
+}
 function createToolPrimitive(input) {
   const ordinals = new Map;
   return (name, args, fn, options) => {
@@ -4883,11 +5137,11 @@ async function executeToolInvocation(input, ordinals, name, args, fn, options, c
         control.noteCancelled();
       else
         input.onFailureObserved?.(error, node.id);
-      const endedAt2 = Date.now();
+      const endedAt = Date.now();
       input.onNodeEnd?.(node.id, {
         status: cancelled ? "cancelled" : "failed",
-        endedAt: endedAt2,
-        ...node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt2 - node.startedAt) } : {},
+        endedAt,
+        ...node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt - node.startedAt) } : {},
         error: error instanceof Error ? error.message : String(error)
       });
       input.onNodeSettle?.(node.id);
@@ -4942,7 +5196,7 @@ async function executeTimedToolAttempt(toolName, runId, fn, baseSignal, timeoutM
   const timeoutController = new AbortController;
   const attemptSignal = AbortSignal.any([baseSignal, timeoutController.signal]);
   return runCallback({ kind: "workflow.ctx_tool", name: toolName, runId }, async () => {
-    const callbackResult = Promise.resolve().then(() => fn({ signal: attemptSignal })).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error }));
+    const callbackResult = Promise.resolve().then(() => invokeTaskCallback(fn, attemptSignal)).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error }));
     let cancelDeadline;
     let onAbort;
     let timeoutError;
@@ -4997,7 +5251,7 @@ async function executeLiveToolInvocation(live) {
   try {
     const result = await executeWithRetries(() => {
       attempts += 1;
-      const callback = options?.timeoutMs === undefined ? runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () => fn({ signal: toolSignal })) : executeTimedToolAttempt(name, input.workflowId, fn, toolSignal, options.timeoutMs);
+      const callback = options?.timeoutMs === undefined ? runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () => invokeTaskCallback(fn, toolSignal)) : executeTimedToolAttempt(name, input.workflowId, fn, toolSignal, options.timeoutMs);
       return callback.catch((error) => {
         callbackError = error;
         throw error;
@@ -5060,12 +5314,12 @@ async function executeLiveToolInvocation(live) {
     const callbackFailure = callbackError ?? error;
     if (returnFailure && !callbackCompleted && isExplicitCallbackCancellation(callbackFailure)) {
       input.onFailureObserved?.(callbackFailure, node.id);
-      const failure3 = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, callbackFailure, attempts);
+      const failure = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, callbackFailure, attempts);
       input.onNodeEnd?.(node.id, {
         status: "failed",
-        endedAt: failure3.failedAt,
-        durationMs: Math.max(0, failure3.failedAt - startedAt),
-        error: failure3.message
+        endedAt: failure.failedAt,
+        durationMs: Math.max(0, failure.failedAt - startedAt),
+        error: failure.message
       });
       input.onNodeSettle?.(node.id);
       throw callbackFailure;
@@ -5123,12 +5377,12 @@ async function executeLiveToolInvocation(live) {
     }
     const reportedFailure = timeoutFailure ? callbackError : error;
     input.onFailureObserved?.(reportedFailure, node.id);
-    const failure2 = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, reportedFailure, attempts);
+    const failure = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, reportedFailure, attempts);
     input.onNodeEnd?.(node.id, {
       status: "failed",
-      endedAt: failure2.failedAt,
-      durationMs: Math.max(0, failure2.failedAt - startedAt),
-      error: failure2.message
+      endedAt: failure.failedAt,
+      durationMs: Math.max(0, failure.failedAt - startedAt),
+      error: failure.message
     });
     input.onNodeSettle?.(node.id);
     throw reportedFailure;
@@ -5184,9 +5438,9 @@ var CALLBACK_CANCELLATION_CODES = new Set([
   "err_cancelled"
 ]);
 var CALLBACK_CANCELLATION_STOP_REASONS = new Set(["aborted", "canceled", "cancelled"]);
-function safeCancellationField(error, key2) {
+function safeCancellationField(error, key) {
   try {
-    return field(error, key2);
+    return field(error, key);
   } catch {
     return;
   }
@@ -5213,16 +5467,16 @@ function isExplicitCallbackCancellation(error) {
       return true;
     if (!hasProcessFailure && hasCancellationMarker(CALLBACK_CANCELLATION_CODES, safeCancellationField(current.value, "code")))
       return true;
-    for (const key2 of ["cause", "error", "response", "body"]) {
-      pending.push({ value: safeCancellationField(current.value, key2), depth: current.depth + 1 });
+    for (const key of ["cause", "error", "response", "body"]) {
+      pending.push({ value: safeCancellationField(current.value, key), depth: current.depth + 1 });
     }
-    for (const key2 of ["diagnostics", "errors"]) {
-      const entries = safeCancellationField(current.value, key2);
+    for (const key of ["diagnostics", "errors"]) {
+      const entries = safeCancellationField(current.value, key);
       if (!Array.isArray(entries))
         continue;
       for (const entry of entries) {
         pending.push({
-          value: key2 === "diagnostics" ? safeCancellationField(entry, "error") ?? entry : entry,
+          value: key === "diagnostics" ? safeCancellationField(entry, "error") ?? entry : entry,
           depth: current.depth + 1
         });
       }
@@ -5387,8 +5641,8 @@ function pendingStageIdForReplay(backend, workflowId, replayKey, stageName) {
   return candidates.size === 1 ? candidates.values().next().value : undefined;
 }
 function createDurableStagePrimitive(input) {
-  return (name, options) => {
-    const replayKey = input.nextReplayKey(name);
+  return (name, options, reservedReplayKey) => {
+    const replayKey = reservedReplayKey ?? input.nextReplayKey(name);
     const cached = stageCheckpointWithOutput(input.backend, input.workflowId, replayKey);
     if (cached !== undefined) {
       input.recordCachedStage?.(name, replayKey, cached);
@@ -5702,11 +5956,11 @@ function preferredHydrationTopology(replayValueCheckpoint, checkpoints) {
   }
   return replayValueCheckpoint.topology === undefined ? metadataValue(checkpoints, "topology") : {};
 }
-function metadataValue(checkpoints, key2) {
+function metadataValue(checkpoints, key) {
   for (let index = checkpoints.length - 1;index >= 0; index -= 1) {
-    const value = checkpoints[index]?.[key2];
+    const value = checkpoints[index]?.[key];
     if (value !== undefined)
-      return { [key2]: value };
+      return { [key]: value };
   }
   return {};
 }
@@ -5741,7 +5995,7 @@ function stageMetadataCheckpointId(replayKey, stage) {
     result: stage.result ?? ""
   })}`;
 }
-function recordCachedStageIntoStore(store2, runId, name, replayKey, output, completedStageReplayKeys, parentIds, checkpoint) {
+function recordCachedStageIntoStore(store, runId, name, replayKey, output, completedStageReplayKeys, parentIds, checkpoint) {
   const now = Date.now();
   const sourceStageId = checkpoint?.topology?.run?.runId === runId ? checkpoint.topology.stageId : undefined;
   const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
@@ -5777,16 +6031,16 @@ function recordCachedStageIntoStore(store2, runId, name, replayKey, output, comp
     ...checkpoint?.artifacts !== undefined ? { artifacts: checkpoint.artifacts } : {},
     ...checkpoint?.warnings !== undefined ? { warnings: checkpoint.warnings } : {}
   };
-  store2.recordStageStart(runId, snapshot);
-  store2.recordStageEnd(runId, snapshot);
+  store.recordStageStart(runId, snapshot);
+  store.recordStageEnd(runId, snapshot);
   completedStageReplayKeys.set(stageId, replayKey);
 }
-function recordCachedStageWithTracker(store2, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys, stageFailFastScope, sourceToReplayedNodeIds) {
+function recordCachedStageWithTracker(store, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys, stageFailFastScope, sourceToReplayedNodeIds) {
   const sourceStageId = checkpoint.topology?.run?.runId === runId ? checkpoint.topology.stageId : undefined;
   const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
   let parentIds = tracker.onSpawn(stageId, name);
   const sourceParents = sourceStageId === undefined ? undefined : checkpoint.topology?.parentIds;
-  const run = store2.runs().find((candidate) => candidate.id === runId);
+  const run = store.runs().find((candidate) => candidate.id === runId);
   const restored = sourceParents?.map((sourceId) => sourceToReplayedNodeIds?.get(sourceId) ?? run?.stages.find((stage) => stage.id === sourceId || stage.replayedFromStageId === sourceId)?.id);
   if (restored?.every((id) => id !== undefined)) {
     parentIds = restored;
@@ -5797,7 +6051,7 @@ function recordCachedStageWithTracker(store2, tracker, runId, name, replayKey, c
   }
   if (checkpoint.topology?.run?.runId === runId)
     sourceToReplayedNodeIds?.set(checkpoint.topology.stageId, stageId);
-  recordCachedStageIntoStore(store2, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
+  recordCachedStageIntoStore(store, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
   tracker.onSettle(stageId);
 }
 function isWorkflowTaskResult(value) {
@@ -6467,6 +6721,11 @@ function classifyWorkflowFailure(error) {
   }
   return failureForDecision(unknownDecision(), message, error);
 }
+// dist/builtin/workflows/src/durable/workflow-status-transition.ts
+async function transitionDurableWorkflowStatus(backend, workflowId, expectedStatuses, status, pendingPrompts, resumable) {
+  return await backend.transitionWorkflowStatus(workflowId, expectedStatuses, status, pendingPrompts, resumable);
+}
+
 // dist/builtin/workflows/src/durable/dbos-process-owner.ts
 var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
 function emptyOwner2() {
@@ -6540,9 +6799,9 @@ function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
 function getDurableBackend() {
-  const owner2 = getDurableBackendProcessOwner();
-  const memoized = owner2.initializedBackend !== undefined && isMemoizedBackendUsable(owner2.initializedBackend) ? owner2.initializedBackend : undefined;
-  const backend = owner2.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  const owner = getDurableBackendProcessOwner();
+  const memoized = owner.initializedBackend !== undefined && isMemoizedBackendUsable(owner.initializedBackend) ? owner.initializedBackend : undefined;
+  const backend = owner.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
@@ -6575,7 +6834,7 @@ function restoreBudgetState(value) {
     if (restored !== undefined)
       warnings[dimension] = restored;
   }
-  const requiredNumbers = (candidate, fields) => isRecord(candidate) && fields.every((field2) => numericDuration(candidate[field2]) !== undefined);
+  const requiredNumbers = (candidate, fields) => isRecord(candidate) && fields.every((field) => numericDuration(candidate[field]) !== undefined);
   const accountingValue = value.accounting;
   const accounting = isRecord(accountingValue) && requiredNumbers(accountingValue, ["tokens", "cost"]) && requiredNumbers(accountingValue.baseline, ["input", "output", "cacheRead", "cacheWrite", "cost"]) && requiredNumbers(accountingValue.perCounter, ["input", "output", "cacheRead", "cacheWrite"]) ? accountingValue : undefined;
   const state = {
@@ -6807,8 +7066,8 @@ class ScopedDurableBackend {
       scope
     };
   }
-  scopeKey(key2) {
-    return `${this.scope.scopePrefix}:${key2}`;
+  scopeKey(key) {
+    return `${this.scope.scopePrefix}:${key}`;
   }
   remap(checkpoint) {
     const workflowId = this.scope.rootWorkflowId;
@@ -7313,31 +7572,31 @@ function createGitWorktreeSetupCache() {
     get(options) {
       if (disposed)
         throw new Error("Git worktree setup cache is already disposed");
-      const key2 = gitWorktreeSetupCacheKey(options);
-      const cached = results.get(key2);
+      const key = gitWorktreeSetupCacheKey(options);
+      const cached = results.get(key);
       if (cached !== undefined) {
         assertCachedGitWorktreeIdentity(cached, options);
         return cached.result;
       }
       const result = setupGitWorktree(options);
-      results.set(key2, { result, identity: captureGitWorktreeIdentity(result) });
+      results.set(key, { result, identity: captureGitWorktreeIdentity(result) });
       return result;
     },
     dispose() {
       if (disposed)
         return;
       disposed = true;
-      let firstError2;
+      let firstError;
       for (const cached of results.values()) {
         try {
           cached.identity.generation.dispose();
         } catch (error) {
-          firstError2 ??= error instanceof Error ? error : new Error(String(error));
+          firstError ??= error instanceof Error ? error : new Error(String(error));
         }
       }
       results.clear();
-      if (firstError2 !== undefined)
-        throw firstError2;
+      if (firstError !== undefined)
+        throw firstError;
     }
   };
 }
@@ -7637,24 +7896,24 @@ function safePatchAgentName(agent) {
 }
 function removeSyntheticPath(worktree, syntheticPath) {
   const resolved = path4.resolve(worktree.path, syntheticPath);
-  const relative3 = path4.relative(worktree.path, resolved);
-  if (!relative3 || relative3 === "." || relative3 === ".." || relative3.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative3)) {
+  const relative = path4.relative(worktree.path, resolved);
+  if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative)) {
     return;
   }
-  let stat2;
+  let stat;
   try {
-    stat2 = fs4.lstatSync(resolved);
+    stat = fs4.lstatSync(resolved);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT")
       return;
     throw error;
   }
-  if (stat2.isSymbolicLink()) {
+  if (stat.isSymbolicLink()) {
     fs4.unlinkSync(resolved);
     return;
   }
-  if (stat2.isDirectory()) {
+  if (stat.isDirectory()) {
     fs4.rmSync(resolved, { recursive: true, force: true });
     return;
   }
@@ -8018,14 +8277,14 @@ function normalizeSyntheticPath(worktreePath, rawPath) {
   if (path6.isAbsolute(trimmed))
     throw new Error(`synthetic path must be relative: ${rawPath}`);
   const resolved = path6.resolve(worktreePath, trimmed);
-  const relative4 = path6.relative(worktreePath, resolved);
-  if (!relative4 || relative4 === ".") {
+  const relative = path6.relative(worktreePath, resolved);
+  if (!relative || relative === ".") {
     throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
   }
-  if (relative4 === ".." || relative4.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative4)) {
+  if (relative === ".." || relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative)) {
     throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
   }
-  return path6.normalize(relative4);
+  return path6.normalize(relative);
 }
 function hasTrackedEntries(worktreePath, relativePath) {
   const result = runGit(worktreePath, ["ls-files", "--", relativePath]);
@@ -8168,15 +8427,15 @@ function cleanupWorktrees(setup) {
 import { lstatSync as lstatSync4, realpathSync as realpathSync4 } from "node:fs";
 import { dirname as dirname6, isAbsolute as isAbsolute5, relative as relative4, resolve as resolve6, sep as sep5 } from "node:path";
 function relativePathWithin(root, candidate) {
-  const path7 = relative4(root, candidate);
-  return path7 === ".." || path7.startsWith(`..${sep5}`) || isAbsolute5(path7) ? undefined : path7;
+  const path = relative4(root, candidate);
+  return path === ".." || path.startsWith(`..${sep5}`) || isAbsolute5(path) ? undefined : path;
 }
-function existingRealPath(path7, description) {
+function existingRealPath(path, description) {
   try {
-    return realpathSync4.native(path7);
+    return realpathSync4.native(path);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`atomic-workflows: cannot resolve ${description} ${path7}: ${message}`);
+    throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
   }
 }
 function resolveWorktreeStageCwd(cwd, setup) {
@@ -8394,7 +8653,7 @@ function truncateTaskOutput(text, maxOutput) {
 [workflow output truncated; limits: ${limits.bytes} bytes, ${limits.lines} lines]`;
 }
 function withoutUndefinedProperties(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, field2]) => field2 !== undefined));
+  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined));
 }
 function sharedTaskDefaultsFromOptions(options) {
   const {
@@ -8500,7 +8759,7 @@ async function mapParallelSteps(steps, concurrency, failFast, mapper, onFirstFai
       if (selectedFailure !== undefined)
         throw selectedFailure;
     }
-    throw new AggregateError(failures.map((failure2) => failure2.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    throw new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
   }
   return results;
 }
@@ -8773,32 +9032,32 @@ function reconcileTerminalRunResult(runId, runSnapshot, activeStore, fallback, o
   onRunEnd?.(runId, result.status, result.result, result.error, result.exitReason);
   return result;
 }
-function applyFailureToStage(stage, failure2) {
+function applyFailureToStage(stage, failure) {
   stage.status = "failed";
-  stage.error = failure2.userMessage;
-  stage.failureKind = failure2.kind;
-  stage.failureCode = failure2.code;
-  stage.failureRecoverability = failure2.recoverability;
-  stage.failureDisposition = failure2.disposition;
-  stage.retryAfterMs = failure2.retryAfterMs;
-  stage.failureMessage = failure2.message;
-}
-function runFailureMetadata(failure2, stages) {
+  stage.error = failure.userMessage;
+  stage.failureKind = failure.kind;
+  stage.failureCode = failure.code;
+  stage.failureRecoverability = failure.recoverability;
+  stage.failureDisposition = failure.disposition;
+  stage.retryAfterMs = failure.retryAfterMs;
+  stage.failureMessage = failure.message;
+}
+function runFailureMetadata(failure, stages) {
   const failedStage = stages.find((stage) => stage.status === "failed");
-  const failureKind = failedStage?.failureKind ?? failure2.kind;
-  const failureCode = failedStage?.failureCode ?? failure2.code;
-  const failureRecoverability = failedStage?.failureRecoverability ?? failure2.recoverability;
-  const failureDisposition = failedStage?.failureDisposition ?? failure2.disposition;
-  const retryAfterMs = failedStage?.retryAfterMs ?? failure2.retryAfterMs;
+  const failureKind = failedStage?.failureKind ?? failure.kind;
+  const failureCode = failedStage?.failureCode ?? failure.code;
+  const failureRecoverability = failedStage?.failureRecoverability ?? failure.recoverability;
+  const failureDisposition = failedStage?.failureDisposition ?? failure.disposition;
+  const retryAfterMs = failedStage?.retryAfterMs ?? failure.retryAfterMs;
   return {
-    errorMessage: failedStage?.error ?? failure2.userMessage,
+    errorMessage: failedStage?.error ?? failure.userMessage,
     failureKind,
     ...failureCode !== undefined ? { failureCode } : {},
     failureRecoverability,
     failureDisposition,
-    failureMessage: failedStage?.failureMessage ?? failure2.message,
+    failureMessage: failedStage?.failureMessage ?? failure.message,
     ...failedStage !== undefined ? { failedStageId: failedStage.id } : {},
-    resumable: failure2.resumable,
+    resumable: failure.resumable,
     ...retryAfterMs !== undefined ? { retryAfterMs } : {}
   };
 }
@@ -8827,17 +9086,17 @@ function runFailureMetadataFromStage(fallbackFailure, stage) {
     ...retryAfterMs !== undefined ? { retryAfterMs } : {}
   };
 }
-function runFailureMetadataFromFailure(failure2, failedStage) {
+function runFailureMetadataFromFailure(failure, failedStage) {
   return {
-    errorMessage: failedStage?.error ?? failure2.userMessage,
-    failureKind: failure2.kind,
-    ...failure2.code !== undefined ? { failureCode: failure2.code } : {},
-    failureRecoverability: failure2.recoverability,
-    failureDisposition: failure2.disposition,
-    failureMessage: failedStage?.failureMessage ?? failure2.message,
+    errorMessage: failedStage?.error ?? failure.userMessage,
+    failureKind: failure.kind,
+    ...failure.code !== undefined ? { failureCode: failure.code } : {},
+    failureRecoverability: failure.recoverability,
+    failureDisposition: failure.disposition,
+    failureMessage: failedStage?.failureMessage ?? failure.message,
     ...failedStage !== undefined ? { failedStageId: failedStage.id } : {},
-    resumable: failure2.resumable,
-    ...failure2.retryAfterMs !== undefined ? { retryAfterMs: failure2.retryAfterMs } : {}
+    resumable: failure.resumable,
+    ...failure.retryAfterMs !== undefined ? { retryAfterMs: failure.retryAfterMs } : {}
   };
 }
 function aggregateInnerFailures(error, classifyFailure) {
@@ -8851,20 +9110,20 @@ function stageFailureCandidate(stage) {
     recoverability: stage.failureRecoverability ?? "unknown"
   };
 }
-function aggregateFailureCandidate(failure2) {
+function aggregateFailureCandidate(failure) {
   return {
     source: "aggregate",
-    failure: failure2,
-    disposition: failure2.disposition,
-    recoverability: failure2.recoverability
+    failure,
+    disposition: failure.disposition,
+    recoverability: failure.recoverability
   };
 }
-function outerFailureCandidate(failure2) {
+function outerFailureCandidate(failure) {
   return {
     source: "outer",
-    failure: failure2,
-    disposition: failure2.disposition,
-    recoverability: failure2.recoverability
+    failure,
+    disposition: failure.disposition,
+    recoverability: failure.recoverability
   };
 }
 function isRecoverableActiveBlockedCandidate(candidate) {
@@ -8951,24 +9210,24 @@ function stageReplayFields(stage) {
   };
 }
 function finalizeKilled(runId, runSnapshot, activeStore, persistence, onRunEnd) {
-  const errorMessage2 = "workflow killed";
+  const errorMessage = "workflow killed";
   const metadata = {
     failureKind: "cancelled",
     failureCode: "cancelled",
     failureRecoverability: "non_recoverable",
     failureDisposition: "terminal_killed",
-    failureMessage: errorMessage2,
+    failureMessage: errorMessage,
     resumable: false
   };
-  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage2, metadata);
+  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage, metadata);
   appendRunEndWhenRecorded(persistence, recorded, {
     runId,
     status: "killed",
-    error: errorMessage2,
+    error: errorMessage,
     ...metadata,
     ts: Date.now()
   });
-  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage2 }, onRunEnd);
+  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage }, onRunEnd);
 }
 function finalizeKilledByFailure(runId, runSnapshot, activeStore, persistence, onRunEnd, metadata) {
   const recorded = activeStore.recordRunEnd(runId, "killed", undefined, metadata.errorMessage, metadata);
@@ -9035,32 +9294,32 @@ function recordActiveBlockedFailure(runId, runSnapshot, activeStore, persistence
 
 // dist/builtin/workflows/src/runs/foreground/executor-outputs.ts
 import { Value as Value5 } from "typebox/value";
-function hasOwnWorkflowOutput(record, key2) {
-  return Object.hasOwn(record, key2);
+function hasOwnWorkflowOutput(record, key) {
+  return Object.hasOwn(record, key);
 }
 function assertWorkflowOutputsExplicit(scope, sourceOutput, declarations, missingOutputSuffix = "") {
-  for (const key2 of Object.keys(sourceOutput)) {
-    if (!hasOwnWorkflowOutput(declarations, key2)) {
-      throw new Error(`atomic-workflows: ${scope} returned undeclared output "${key2}"; declare it in outputs: { "${key2}": Type.... } or remove it from the .run() return`);
+  for (const key of Object.keys(sourceOutput)) {
+    if (!hasOwnWorkflowOutput(declarations, key)) {
+      throw new Error(`atomic-workflows: ${scope} returned undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from the .run() return`);
     }
   }
-  for (const [key2, schema] of Object.entries(declarations)) {
-    if (!(key2 in sourceOutput)) {
+  for (const [key, schema] of Object.entries(declarations)) {
+    if (!(key in sourceOutput)) {
       if (schemaIsRequired(schema)) {
-        throw new Error(`atomic-workflows: ${scope} missing output "${key2}"${missingOutputSuffix}`);
+        throw new Error(`atomic-workflows: ${scope} missing output "${key}"${missingOutputSuffix}`);
       }
       continue;
     }
-    const value = sourceOutput[key2];
+    const value = sourceOutput[key];
     const kind = schemaFieldKind(schema);
     if (!Value5.Check(schema, value)) {
       const choices = schemaChoices(schema);
       if (kind === "select" && choices !== undefined && typeof value === "string") {
-        throw new Error(`atomic-workflows: ${scope} output "${key2}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
+        throw new Error(`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
       }
-      throw new Error(`atomic-workflows: ${scope} output "${key2}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
+      throw new Error(`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
     }
-    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key2}"`);
+    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
     if (serializableError !== undefined)
       throw new Error(`atomic-workflows: ${serializableError}`);
   }
@@ -9093,27 +9352,27 @@ function assertWorkflowExitOutputs(workflowName, result, declaredOutputs) {
   const declarations = declaredOutputs ?? {};
   const sourceOutput = result ?? {};
   const scope = `workflow "${workflowName}" ctx.exit()`;
-  for (const key2 of Object.keys(sourceOutput)) {
-    if (!hasOwnWorkflowOutput(declarations, key2)) {
-      throw new Error(`atomic-workflows: ${scope} provided undeclared output "${key2}"; declare it in outputs: { "${key2}": Type.... } or remove it from ctx.exit({ outputs })`);
+  for (const key of Object.keys(sourceOutput)) {
+    if (!hasOwnWorkflowOutput(declarations, key)) {
+      throw new Error(`atomic-workflows: ${scope} provided undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from ctx.exit({ outputs })`);
     }
   }
-  for (const [key2, schema] of Object.entries(declarations)) {
-    if (!(key2 in sourceOutput))
+  for (const [key, schema] of Object.entries(declarations)) {
+    if (!(key in sourceOutput))
       continue;
-    const value = sourceOutput[key2];
-    const invalidSnapshotValue = workflowExitSnapshotInvalidValueMessage(`${scope} output "${key2}"`, value);
+    const value = sourceOutput[key];
+    const invalidSnapshotValue = workflowExitSnapshotInvalidValueMessage(`${scope} output "${key}"`, value);
     if (invalidSnapshotValue !== undefined)
       throw new Error(`atomic-workflows: ${invalidSnapshotValue}`);
     const kind = schemaFieldKind(schema);
     if (!Value5.Check(schema, value)) {
       const choices = schemaChoices(schema);
       if (kind === "select" && choices !== undefined && typeof value === "string") {
-        throw new Error(`atomic-workflows: ${scope} output "${key2}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
+        throw new Error(`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
       }
-      throw new Error(`atomic-workflows: ${scope} output "${key2}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
+      throw new Error(`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
     }
-    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key2}"`);
+    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
     if (serializableError !== undefined)
       throw new Error(`atomic-workflows: ${serializableError}`);
   }
@@ -9122,10 +9381,10 @@ function selectWorkflowOutputs(child, rawOutput) {
   const declarations = child.outputs ?? {};
   const sourceOutput = rawOutput ?? {};
   const selected = {};
-  for (const key2 of Object.keys(declarations)) {
-    const value = sourceOutput[key2];
+  for (const key of Object.keys(declarations)) {
+    const value = sourceOutput[key];
     if (value !== undefined)
-      selected[key2] = value;
+      selected[key] = value;
   }
   return selected;
 }
@@ -9540,8 +9799,8 @@ function buildPromptNodeUiAdapter(input) {
       try {
         if (mergedSignal.signal.aborted)
           throw hilAbortError(mergedSignal.signal);
-        const accepted3 = input.activeStore.recordStageAwaitingInput(input.runId, stageId, true, prompt.createdAt);
-        if (!accepted3) {
+        const accepted = input.activeStore.recordStageAwaitingInput(input.runId, stageId, true, prompt.createdAt);
+        if (!accepted) {
           const error = new Error("atomic-workflows: ctx.ui.custom prompt node is unavailable");
           stageSnapshot.skippedReason = "prompt-unavailable";
           await finalizePromptStage("skipped");
@@ -9571,15 +9830,15 @@ function buildPromptNodeUiAdapter(input) {
         mergedSignal.dispose();
       }
     }
-    const accepted2 = input.activeStore.recordStagePendingPrompt(input.runId, stageId, prompt);
-    if (!accepted2) {
+    const accepted = input.activeStore.recordStagePendingPrompt(input.runId, stageId, prompt);
+    if (!accepted) {
       stageSnapshot.skippedReason = "prompt-unavailable";
       await finalizePromptStage("skipped");
       return fallbackForPromptDescriptor(descriptor);
     }
     const waiter = input.activeStore.awaitStagePendingPrompt(input.runId, stageId, prompt.id);
     try {
-      const response = await new Promise((resolve9, reject) => {
+      const response = await new Promise((resolve, reject) => {
         const onAbort = () => {
           input.activeStore.resolveStagePendingPrompt(input.runId, stageId, prompt.id, fallbackForPromptDescriptor(descriptor), { recordAnswer: false });
           reject(hilAbortError(input.signal));
@@ -9591,7 +9850,7 @@ function buildPromptNodeUiAdapter(input) {
         input.signal.addEventListener("abort", onAbort, { once: true });
         waiter.then((value) => {
           input.signal.removeEventListener("abort", onAbort);
-          resolve9(value);
+          resolve(value);
         }, (err) => {
           input.signal.removeEventListener("abort", onAbort);
           reject(err);
@@ -9652,8 +9911,8 @@ function buildPromptNodeUiAdapter(input) {
 // dist/builtin/workflows/src/runs/foreground/executor-run-finalizers.ts
 function createRunFinalizers(input) {
   const finalizeWorkflowExitValidationFailure = (err, exitReason) => {
-    const failure2 = input.classifyExecutorFailure(err);
-    const classifiedMetadata = runFailureMetadata(failure2, input.runSnapshot.stages);
+    const failure = input.classifyExecutorFailure(err);
+    const classifiedMetadata = runFailureMetadata(failure, input.runSnapshot.stages);
     const metadata = {
       ...classifiedMetadata,
       resumable: false,
@@ -9718,8 +9977,8 @@ function createRunFinalizers(input) {
       ...signal.reason !== undefined ? { exitReason: signal.reason } : {}
     }, input.opts.onRunEnd);
   };
-  const finalizeParentWorkflowExitCancellation = async (abortReason3) => {
-    const parentReason = abortReason3.workflowExitReason;
+  const finalizeParentWorkflowExitCancellation = async (abortReason) => {
+    const parentReason = abortReason.workflowExitReason;
     await input.drainWorkflowExitCleanups(parentReason);
     const exitReason = parentWorkflowExitRunReason(parentReason);
     const metadata = { resumable: false, exited: true, exitReason };
@@ -9748,6 +10007,7 @@ function isTerminalStage(stage) {
 function createStageScheduler(input) {
   const releaseBarriers = new Map;
   const cascadePauseOwners = new Map;
+  let runBarrier;
   const makeReleaseBarrier = () => {
     const resolver = Promise.withResolvers();
     resolver.promise.catch(() => {});
@@ -9869,6 +10129,8 @@ function createStageScheduler(input) {
     }
   };
   const rejectReleaseBarriers = (reason) => {
+    runBarrier?.reject(reason);
+    runBarrier = undefined;
     cascadePauseOwners.clear();
     for (const [stageId, barrier] of releaseBarriers) {
       releaseBarriers.delete(stageId);
@@ -9891,6 +10153,19 @@ function createStageScheduler(input) {
   };
   return {
     tracker: input.tracker,
+    isRunPaused: () => runBarrier !== undefined,
+    pauseRun: () => {
+      runBarrier ??= makeReleaseBarrier();
+    },
+    releaseRun: () => {
+      const barrier = runBarrier;
+      runBarrier = undefined;
+      barrier?.resolve();
+    },
+    waitForRunRelease: async () => {
+      while (runBarrier !== undefined)
+        await runBarrier.promise;
+    },
     stageById,
     setStageParentIds,
     descendantsOf,
@@ -10165,8 +10440,8 @@ class ConcurrencyLimiter {
       this._running++;
       return Promise.resolve();
     }
-    return new Promise((resolve9) => {
-      this._queue.push(resolve9);
+    return new Promise((resolve) => {
+      this._queue.push(resolve);
     });
   }
   release() {
@@ -10190,6 +10465,24 @@ function createRunLimiter(defaultConcurrency) {
   return new ConcurrencyLimiter(defaultConcurrency ?? 4);
 }
 
+// dist/builtin/workflows/src/shared/abort.ts
+function raceAbort2(operation, signal) {
+  if (signal === undefined)
+    return operation;
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+  }
+  const abort = Promise.withResolvers();
+  const onAbort = () => {
+    abort.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  return Promise.race([operation, abort.promise]).finally(() => {
+    signal.removeEventListener("abort", onAbort);
+  });
+}
+
 // dist/builtin/workflows/src/engine/primitives/chain.ts
 function createChainPrimitive(input) {
   return async (steps, options = {}) => {
@@ -10234,11 +10527,11 @@ function createWorkflowExitManager(input) {
   const trackWorkflowExitCleanup = (operation) => {
     if (operation === undefined)
       return;
-    let tracked2;
-    tracked2 = Promise.resolve(operation).catch(() => {}).finally(() => {
-      workflowExitCleanupPromises.delete(tracked2);
+    let tracked;
+    tracked = Promise.resolve(operation).catch(() => {}).finally(() => {
+      workflowExitCleanupPromises.delete(tracked);
     });
-    workflowExitCleanupPromises.add(tracked2);
+    workflowExitCleanupPromises.add(tracked);
   };
   const invokeWorkflowExitCleanup = (cleanup, reason) => {
     try {
@@ -10364,10 +10657,10 @@ function createWorkflowExitManager(input) {
   };
 }
 // dist/builtin/workflows/src/engine/primitives/parallel.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/intercom-group.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var DEFAULT_INTERCOM_GROUP = "default";
 function workflowInvocationIntercomGroup(rootRunId) {
   return `workflow:${rootRunId}`;
@@ -10390,22 +10683,22 @@ function resolveStageGroup(stageOptions, workflowGroup) {
   const group = stageOptions.group;
   if (group === undefined)
     return workflowGroup;
-  const authored = group === true ? randomUUID2() : group.trim();
+  const authored = group === true ? randomUUID3() : group.trim();
   if (authored.length === 0)
     return;
   if (workflowGroup === undefined || authored === DEFAULT_INTERCOM_GROUP)
     return authored;
-  const owner2 = normalizeGroup(workflowGroup);
-  if (authored === owner2 || authored.startsWith(`${owner2}/`))
+  const owner = normalizeGroup(workflowGroup);
+  if (authored === owner || authored.startsWith(`${owner}/`))
     return authored;
-  return `${owner2}/${authored}`;
+  return `${owner}/${authored}`;
 }
 function workflowInvocationOwnsGroup(workflowGroup, candidate) {
   if (workflowGroup === undefined || candidate === undefined)
     return false;
-  const owner2 = normalizeGroup(workflowGroup);
+  const owner = normalizeGroup(workflowGroup);
   const group = normalizeGroup(candidate);
-  return group === owner2 || group.startsWith(`${owner2}/`);
+  return group === owner || group.startsWith(`${owner}/`);
 }
 function stageHasIntercomAccess(_stageOptions) {
   return true;
@@ -10448,7 +10741,7 @@ function fold_usage(results) {
 
 // dist/builtin/workflows/src/shared/budget-meter.ts
 var usageFields = ["input", "output", "cacheRead", "cacheWrite", "cost"];
-var addUsage = (left, right) => Object.fromEntries(usageFields.map((field2) => [field2, left[field2] + right[field2]]));
+var addUsage = (left, right) => Object.fromEntries(usageFields.map((field) => [field, left[field] + right[field]]));
 function foldTreeUsage(tree) {
   const run = "run" in tree ? tree.run : tree;
   const folded = fold_usage(run.stages.filter((stage) => stage.replayed !== true).map((stage) => ({ stageName: stage.name, text: stage.result ?? "", modelAttempts: stage.modelAttempts })));
@@ -10460,7 +10753,7 @@ function meter_run(tree, now) {
     durationMs: elapsedRunMs("run" in tree ? tree.run : tree, now),
     tokens: usage.input + usage.output,
     cost: usage.cost,
-    perCounter: Object.fromEntries(usageFields.filter((field2) => field2 !== "cost").map((field2) => [field2, usage[field2]]))
+    perCounter: Object.fromEntries(usageFields.filter((field) => field !== "cost").map((field) => [field, usage[field]]))
   };
 }
 
@@ -10479,7 +10772,7 @@ class WorkflowBudgetExceededError extends Error {
 var withFrontier = (report, frontierStage, summary, usage) => Object.assign({ ...report, frontierStage: frontierStage ?? "workflow frontier" }, summary === undefined ? {} : { wrapUpSummary: summary }, usage === undefined ? {} : { wrapUpUsage: usage });
 var usageFields2 = ["input", "output", "cacheRead", "cacheWrite", "cost"];
 var counterFields = ["input", "output", "cacheRead", "cacheWrite"];
-var mapFields = (fields, fn = () => 0) => Object.fromEntries(fields.map((field2) => [field2, fn(field2)]));
+var mapFields = (fields, fn = () => 0) => Object.fromEntries(fields.map((field) => [field, fn(field)]));
 function createRunBudgetController(input) {
   const { run, budget } = input;
   const ownEnabled = budget.maxDurationMs > 0 || budget.maxTokens > 0 || budget.maxCost > 0;
@@ -10490,7 +10783,7 @@ function createRunBudgetController(input) {
   const previousAccounting = state?.accounting;
   const initial = previousAccounting && usageEnabled ? meter_run(input.usageTree?.() ?? { run }, Date.now()) : undefined;
   const initialAccounting = initial === undefined ? undefined : { ...initial.perCounter, cost: initial.cost };
-  let baseline = mapFields(usageFields2, (field2) => initialAccounting?.[field2] ?? 0);
+  let baseline = mapFields(usageFields2, (field) => initialAccounting?.[field] ?? 0);
   let charged = {
     baseline,
     tokens: previousAccounting?.tokens ?? 0,
@@ -10508,13 +10801,13 @@ function createRunBudgetController(input) {
   };
   const accountUsage = (meters) => {
     const current = { ...meters.perCounter, cost: meters.cost };
-    const delta = mapFields(usageFields2, (field2) => Math.max(0, current[field2] - baseline[field2]));
-    baseline = mapFields(usageFields2, (field2) => Math.max(baseline[field2], current[field2]));
+    const delta = mapFields(usageFields2, (field) => Math.max(0, current[field] - baseline[field]));
+    baseline = mapFields(usageFields2, (field) => Math.max(baseline[field], current[field]));
     charged = {
       baseline,
       tokens: charged.tokens + delta.input + delta.output,
       cost: charged.cost + delta.cost,
-      perCounter: mapFields(counterFields, (field2) => charged.perCounter[field2] + delta[field2])
+      perCounter: mapFields(counterFields, (field) => charged.perCounter[field] + delta[field])
     };
     updateState({ accounting: charged });
     return Object.assign(meters, { tokens: charged.tokens, cost: charged.cost, perCounter: charged.perCounter });
@@ -10591,21 +10884,21 @@ function createRunBudgetController(input) {
     return { check: ownCheckpoint(frontierStage) };
   };
   const checkpoint = (frontierStage) => boundaryCheckpoint(frontierStage).check;
-  const finishBoundary = (owner2, frontierStage) => {
-    throw owner2?.finishWrapUp(frontierStage, undefined, undefined, false) ?? finishWrapUp(frontierStage, undefined, undefined, false);
+  const finishBoundary = (owner, frontierStage) => {
+    throw owner?.finishWrapUp(frontierStage, undefined, undefined, false) ?? finishWrapUp(frontierStage, undefined, undefined, false);
   };
-  const deliverBoundary = (owner2, frontierStage) => {
-    owner2?.deliverWrapUp(frontierStage) ?? deliverWrapUp(frontierStage);
+  const deliverBoundary = (owner, frontierStage) => {
+    owner?.deliverWrapUp(frontierStage) ?? deliverWrapUp(frontierStage);
   };
   const stopAtBoundary = (frontierStage) => {
     const resolvedFrontierStage = frontierStage ?? handlers.at(-1)?.frontierStage;
-    const { check, owner: owner2 } = boundaryCheckpoint(resolvedFrontierStage);
+    const { check, owner } = boundaryCheckpoint(resolvedFrontierStage);
     if (check.kind === "wrap_up") {
-      deliverBoundary(owner2, resolvedFrontierStage ?? "workflow frontier");
-      finishBoundary(owner2, resolvedFrontierStage);
+      deliverBoundary(owner, resolvedFrontierStage ?? "workflow frontier");
+      finishBoundary(owner, resolvedFrontierStage);
     }
     if (check.kind === "exhausted")
-      finishBoundary(owner2, resolvedFrontierStage);
+      finishBoundary(owner, resolvedFrontierStage);
   };
   const rethrowIfSystemOwnedStop = (frontierStage) => {
     root?.rethrowIfSystemOwnedStop(frontierStage);
@@ -10699,11 +10992,11 @@ function createRunBudgetController(input) {
 function createParallelPrimitive(input) {
   return async (steps, options = {}) => {
     input.runtime.exit.throwIfWorkflowExitSelected();
-    const normalizeGroup2 = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
-    const normalizedOptions = normalizeGroup2(options);
-    const normalizedSteps = steps.map(normalizeGroup2);
+    const normalizeGroup = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
+    const normalizedOptions = normalizeGroup(options);
+    const normalizedSteps = steps.map(normalizeGroup);
     const needsAutoGroup = normalizedOptions.group === true || normalizedSteps.some((step) => step.group === true);
-    const autoGroup = needsAutoGroup ? randomUUID3() : undefined;
+    const autoGroup = needsAutoGroup ? randomUUID4() : undefined;
     const resolveAutoGroup = (value) => value.group === true && autoGroup ? { ...value, group: autoGroup } : value;
     const resolvedOptions = resolveAutoGroup(normalizedOptions);
     const resolvedSteps = normalizedSteps.map(resolveAutoGroup);
@@ -10744,9 +11037,9 @@ function createParallelPrimitive(input) {
       beforeMap: input.runtime.exit.throwIfWorkflowExitSelected,
       isControlSignal: (error) => findWorkflowExitSignal(error, input.runtime.exit.exitScope) !== undefined,
       selectSettledFailure: (failures) => {
-        if (!everyStepCompleted() || !failures.every((failure2) => failure2.error instanceof WorkflowBudgetExceededError))
+        if (!everyStepCompleted() || !failures.every((failure) => failure.error instanceof WorkflowBudgetExceededError))
           return;
-        return failures.reduce((selected, failure2) => failure2.index < selected.index ? failure2 : selected).error;
+        return failures.reduce((selected, failure) => failure.index < selected.index ? failure : selected).error;
       }
     });
   };
@@ -10896,6 +11189,8 @@ function wrapUiWithDurable(base, deps) {
   return {
     async input(promptText) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("input", promptText, callerStack);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10915,6 +11210,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async confirm(message) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("confirm", message, callerStack);
       const hit = cached(identity);
       if (typeof hit === "boolean") {
@@ -10934,6 +11231,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async select(message, options) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("select", message, callerStack, [...options]);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10953,6 +11252,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async editor(initial) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("editor", initial ?? "", callerStack, initial ?? null);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10972,6 +11273,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async custom(factory, options) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const replayIdentity = options?.replayIdentity ?? factory?.name ?? "custom";
       const identity = nextIdentity("custom", replayIdentity, callerStack, { replayIdentity });
       const hit = cachedCustom(identity);
@@ -11004,26 +11307,32 @@ function buildExitGatedUiContext(input) {
   const base = input.opts.usePromptNodesForUi === true ? input.baseFromPromptNodes() : input.opts.executionMode === "non_interactive" && input.opts.ui === undefined ? makeHeadlessUnavailableUIContext() : normalizeUIContext(input.opts.ui);
   const promptNodeReplay = input.opts.usePromptNodesForUi === true && input.opts.continuation !== undefined;
   const durableBase = input.durableUi !== undefined && !promptNodeReplay ? wrapUiWithDurable(base, input.durableUi) : base;
+  const invoke = (call) => {
+    input.throwIfWorkflowExitSelected();
+    if (!promptNodeReplay || input.durableUi?.beforeCall === undefined)
+      return call();
+    return withPromptCallerStack(new Error().stack, async () => {
+      for (let wait = input.durableUi?.beforeCall?.();wait !== undefined; wait = input.durableUi?.beforeCall?.())
+        await wait;
+      input.throwIfWorkflowExitSelected();
+      return call();
+    });
+  };
   return {
     async input(promptText) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.input(promptText);
+      return await invoke(() => durableBase.input(promptText));
     },
     async confirm(message) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.confirm(message);
+      return await invoke(() => durableBase.confirm(message));
     },
     async select(message, options) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.select(message, options);
+      return await invoke(() => durableBase.select(message, options));
     },
     async editor(initial) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.editor(initial);
+      return await invoke(() => durableBase.editor(initial));
     },
     async custom(factory, options) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.custom(factory, options);
+      return await invoke(() => durableBase.custom(factory, options));
     }
   };
 }
@@ -11273,8 +11582,8 @@ function structuredRecoverableFailureFromSnapshot(snapshot, failedStageId) {
 function isRecoverableProviderFailureKind(kind) {
   return kind === "auth" || kind === "rate_limit" || kind === "provider";
 }
-function stringResultField(result, key2) {
-  const value = result?.[key2];
+function stringResultField(result, key) {
+  const value = result?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
@@ -11292,7 +11601,7 @@ async function finalizeDurableTerminalStatus(input) {
     if (durableStatus === "failed" || durableStatus === "blocked") {
       recordRunTimingCheckpoint(input.durableBackend, input.runSnapshot);
     }
-    const failure2 = durableStatus === "failed" ? {
+    const failure = durableStatus === "failed" ? {
       ...input.runSnapshot.error !== undefined ? { error: input.runSnapshot.error } : {},
       ...input.runSnapshot.exited === true ? {
         exited: true,
@@ -11304,7 +11613,7 @@ async function finalizeDurableTerminalStatus(input) {
       ...input.runSnapshot.failureDisposition !== undefined ? { failureDisposition: input.runSnapshot.failureDisposition } : {},
       ...input.runSnapshot.failedToolNodeId !== undefined ? { failedToolNodeId: input.runSnapshot.failedToolNodeId } : {}
     } : undefined;
-    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure2);
+    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure);
   }
   await input.durableBackend.flush(input.runId);
 }
@@ -11561,17 +11870,17 @@ function childRunIdFromDraft(draft) {
 }
 function boundaryOwner(grouped, childRunId) {
   for (const drafts of grouped.values()) {
-    const owner2 = drafts.find((draft) => childRunIdFromDraft(draft) === childRunId);
-    if (owner2 !== undefined)
-      return owner2;
+    const owner = drafts.find((draft) => childRunIdFromDraft(draft) === childRunId);
+    if (owner !== undefined)
+      return owner;
   }
   return;
 }
-function childRunStatus(owner2) {
-  const child = workflowChildFromDraft(owner2);
+function childRunStatus(owner) {
+  const child = workflowChildFromDraft(owner);
   if (child !== undefined)
     return child.status;
-  const status = owner2.topology?.boundary?.status;
+  const status = owner.topology?.boundary?.status;
   return status === "failed" || status === "skipped" || status === "completed" ? status : "running";
 }
 function mergeStageGroup(records, allStages, allCheckpoints) {
@@ -11621,12 +11930,12 @@ function mergeStageDraft(existing, checkpoint, sequence) {
     ...checkpoint.topology !== undefined ? { topology: checkpoint.topology } : existing?.topology !== undefined ? { topology: existing.topology } : {}
   };
 }
-function valueOrExisting(key2, checkpoint, existing) {
-  const checkpointValue = checkpoint[key2];
+function valueOrExisting(key, checkpoint, existing) {
+  const checkpointValue = checkpoint[key];
   if (checkpointValue !== undefined)
-    return { [key2]: checkpointValue };
-  const existingValue = existing?.[key2];
-  return existingValue === undefined ? {} : { [key2]: existingValue };
+    return { [key]: checkpointValue };
+  const existingValue = existing?.[key];
+  return existingValue === undefined ? {} : { [key]: existingValue };
 }
 function workflowChildFromDraft(draft) {
   const strict = parseWorkflowChildResult(draft.output);
@@ -11702,7 +12011,7 @@ function durableNestedRunSnapshots(backend, rootWorkflowId) {
   const handle = backend.getWorkflow(rootWorkflowId);
   if (handle === undefined)
     return [];
-  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run2) => run2.id !== rootWorkflowId);
+  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run) => run.id !== rootWorkflowId);
 }
 function checkpointDrafts(checkpoints) {
   const stageByReplayKey = new Map;
@@ -11711,8 +12020,8 @@ function checkpointDrafts(checkpoints) {
   checkpoints.forEach((checkpoint, index) => {
     const sequence = index + 1;
     if (checkpoint.kind === "stage") {
-      const existing2 = stageByReplayKey.get(checkpoint.replayKey);
-      stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing2, checkpoint, sequence));
+      const existing = stageByReplayKey.get(checkpoint.replayKey);
+      stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing, checkpoint, sequence));
       return;
     }
     if (checkpoint.kind !== "tool" || isReservedRunCheckpointHash(checkpoint.argsHash))
@@ -11913,29 +12222,29 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     }
     const stages = runDrafts.map((draft) => stageSnapshotFromDraft(draft, ids.get(draft.topology.stageId), draft.topology.parentIds.map((parentId) => ids.get(parentId))));
     const toolNodes = completedToolNodes(toolCheckpoints, runId, rootRunId, ids, drafts.firstToolSequenceByHash);
-    const run2 = runTopologyFor(runDrafts, ownedTools);
+    const run = runTopologyFor(runDrafts, ownedTools);
     const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.startedAt ?? tool.endedAt ?? fallbackCompletedAt));
     const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.endedAt ?? fallbackCompletedAt));
-    const owner2 = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
-    const status = owner2 === undefined ? "completed" : childRunStatus(owner2);
+    const owner = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
+    const status = owner === undefined ? "completed" : childRunStatus(owner);
     const terminal = status !== "running" && status !== "pending" && status !== "paused" && status !== "blocked";
-    const parentRunId = run2?.parentRunId ?? rootRunId;
+    const parentRunId = run?.parentRunId ?? rootRunId;
     const boundarySourceId = grouped.get(parentRunId)?.find((draft) => childRunIdFromDraft(draft) === runId)?.topology?.stageId;
-    const declaredParentStageId = run2?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run2.parentStageId);
+    const declaredParentStageId = run?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run.parentStageId);
     const parentStageId = declaredParentStageId ?? (boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
-    const ownerChild = owner2 === undefined ? undefined : workflowChildFromDraft(owner2);
+    const ownerChild = owner === undefined ? undefined : workflowChildFromDraft(owner);
     runs.push({
       id: runId,
-      name: run2?.runName ?? rootRunName,
+      name: run?.runName ?? rootRunName,
       inputs: {},
       status,
       stages,
       toolNodes,
       startedAt,
       ...terminal ? { endedAt, durationMs: Math.max(0, endedAt - startedAt) } : {},
-      ...run2?.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
+      ...run?.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {},
       ...parentStageId !== undefined ? { parentStageId } : {},
-      ...run2?.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {},
+      ...run?.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {},
       ...ownerChild?.exited === true ? {
         result: ownerChild.outputs,
         exited: true,
@@ -11945,13 +12254,13 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     });
     emittedRunIds.add(runId);
   }
-  for (const { parentRunId, owner: owner2, child } of syntheticChildren) {
+  for (const { parentRunId, owner, child } of syntheticChildren) {
     if (!emittedRunIds.has(parentRunId)) {
       if (policy.failClosed)
         return [];
       continue;
     }
-    const topology = owner2.topology;
+    const topology = owner.topology;
     const boundary = topology.boundary;
     const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
     if (parentStageId === undefined) {
@@ -11959,8 +12268,8 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
         return [];
       continue;
     }
-    const startedAt = owner2.startedAt ?? owner2.firstCompletedAt;
-    const endedAt = owner2.endedAt ?? owner2.firstCompletedAt;
+    const startedAt = owner.startedAt ?? owner.firstCompletedAt;
+    const endedAt = owner.endedAt ?? owner.firstCompletedAt;
     runs.push({
       id: child.runId,
       name: boundary.child.runName,
@@ -12068,7 +12377,7 @@ function syntheticCheckpointStage(checkpointCount, completedAt) {
 // dist/builtin/workflows/src/durable/completed-subtree.ts
 function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
   const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
-  if (!nested.some((run2) => run2.id === childRunId))
+  if (!nested.some((run) => run.id === childRunId))
     return;
   const intentionalExitStatuses = new Map;
   for (const checkpoint of backend.listCheckpoints(rootWorkflowId)) {
@@ -12082,22 +12391,22 @@ function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
   let priorSize = -1;
   while (priorSize !== included.size) {
     priorSize = included.size;
-    for (const run2 of nested) {
-      if (run2.parentRunId !== undefined && included.has(run2.parentRunId))
-        included.add(run2.id);
+    for (const run of nested) {
+      if (run.parentRunId !== undefined && included.has(run.parentRunId))
+        included.add(run.id);
     }
   }
-  const subtree = nested.filter((run2) => included.has(run2.id));
-  const complete = subtree.length === included.size && subtree.every((run2) => isCompleteCachedRun(run2, intentionalExitStatuses));
+  const subtree = nested.filter((run) => included.has(run.id));
+  const complete = subtree.length === included.size && subtree.every((run) => isCompleteCachedRun(run, intentionalExitStatuses));
   return complete ? subtree : undefined;
 }
-function isCompleteCachedRun(run2, intentionalExitStatuses) {
-  if (run2.endedAt === undefined || !run2.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
+function isCompleteCachedRun(run, intentionalExitStatuses) {
+  if (run.endedAt === undefined || !run.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
     return false;
   }
-  if (run2.status === "completed" || run2.exited === true)
+  if (run.status === "completed" || run.exited === true)
     return true;
-  return intentionalExitStatuses.get(run2.id) === run2.status;
+  return intentionalExitStatuses.get(run.id) === run.status;
 }
 function isTerminalStage2(status) {
   return status === "completed" || status === "failed" || status === "skipped";
@@ -12142,13 +12451,13 @@ function reciprocalWorkflowRootRunId(runById, runId) {
 }
 
 // dist/builtin/workflows/src/engine/run-durable-topology.ts
-function durableRunTopology(run2) {
+function durableRunTopology(run) {
   return {
-    runId: run2.id,
-    runName: run2.name,
-    ...run2.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
-    ...run2.parentStageId !== undefined ? { parentStageId: run2.parentStageId } : {},
-    ...run2.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {}
+    runId: run.id,
+    runName: run.name,
+    ...run.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {},
+    ...run.parentStageId !== undefined ? { parentStageId: run.parentStageId } : {},
+    ...run.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {}
   };
 }
 function createDurableStageDeps(input) {
@@ -12223,7 +12532,7 @@ function createDurableCachedStageRecorder(input) {
   return {
     record(name, replayKey, checkpoint, scope) {
       const cachedChildRunId = workflowChildRunId(checkpoint);
-      const runById = new Map(input.store.runs().map((run2) => [run2.id, run2]));
+      const runById = new Map(input.store.runs().map((run) => [run.id, run]));
       if (!runById.has(input.run.id))
         runById.set(input.run.id, input.run);
       const durableRootId = reciprocalWorkflowRootRunId(runById, input.run.id);
@@ -12239,7 +12548,7 @@ function createDurableCachedStageRecorder(input) {
           replaySourceOrders.set(replayedStage.id, sourceOrder);
         input.run.stages.sort((left, right) => (replaySourceOrders.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (replaySourceOrders.get(right.id) ?? Number.MAX_SAFE_INTEGER));
       }
-      const stage = input.store.runs().find((run2) => run2.id === input.run.id)?.stages.find((candidate) => candidate.replayKey === replayKey);
+      const stage = input.store.runs().find((run) => run.id === input.run.id)?.stages.find((candidate) => candidate.replayKey === replayKey);
       if (stage !== undefined) {
         input.backend.recordCheckpoint({
           kind: "stage",
@@ -12277,10 +12586,10 @@ function createDurableCachedStageRecorder(input) {
   };
 }
 function reconcileCachedDirectChildParentStage(input) {
-  const existingRun = input.store.runs().find((run2) => run2.id === input.checkpointChildRunId);
+  const existingRun = input.store.runs().find((run) => run.id === input.checkpointChildRunId);
   if (existingRun === undefined)
     return false;
-  const runById = new Map(input.store.runs().map((run2) => [run2.id, run2]));
+  const runById = new Map(input.store.runs().map((run) => [run.id, run]));
   const storedParentRun = runById.get(input.parentRun.id);
   if (storedParentRun !== undefined && (storedParentRun.parentRunId !== input.parentRun.parentRunId || storedParentRun.parentStageId !== input.parentRun.parentStageId))
     return false;
@@ -12304,6 +12613,61 @@ function workflowChildRunId(checkpoint) {
   return (parseWorkflowChildResult(checkpoint.output) ?? (hasCurrentIdentity ? undefined : parseLegacyWorkflowChildResult(checkpoint.output)))?.runId;
 }
 
+// dist/builtin/workflows/src/engine/run-paused-stage.ts
+function deferStageUntilRunRelease(input) {
+  let stage;
+  const current = () => {
+    input.signal.throwIfAborted();
+    if (input.isPaused())
+      throw new Error(`Workflow is paused; resume before synchronous access to stage ${input.name}`);
+    stage ??= input.create();
+    return stage;
+  };
+  const invoke = async (call) => {
+    while (input.isPaused())
+      await input.waitForRelease();
+    return call(current());
+  };
+  return {
+    name: input.name,
+    prompt: (...args) => invoke((stage) => stage.prompt(...args)),
+    complete: (...args) => invoke((stage) => stage.complete(...args)),
+    sendUserMessage: (...args) => invoke((stage) => stage.sendUserMessage(...args)),
+    steer: (...args) => invoke((stage) => stage.steer(...args)),
+    followUp: (...args) => invoke((stage) => stage.followUp(...args)),
+    subscribe: (...args) => current().subscribe(...args),
+    get sessionFile() {
+      return current().sessionFile;
+    },
+    get sessionId() {
+      return current().sessionId;
+    },
+    setModel: (...args) => invoke((stage) => stage.setModel(...args)),
+    setThinkingLevel: (...args) => current().setThinkingLevel(...args),
+    cycleModel: () => invoke((stage) => stage.cycleModel()),
+    cycleThinkingLevel: () => current().cycleThinkingLevel(),
+    get agent() {
+      return current().agent;
+    },
+    get model() {
+      return current().model;
+    },
+    get thinkingLevel() {
+      return current().thinkingLevel;
+    },
+    get messages() {
+      return current().messages;
+    },
+    get isStreaming() {
+      return current().isStreaming;
+    },
+    navigateTree: (...args) => invoke((stage) => stage.navigateTree(...args)),
+    compact: () => invoke((stage) => stage.compact()),
+    abortCompaction: () => current().abortCompaction(),
+    abort: () => invoke((stage) => stage.abort())
+  };
+}
+
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -12384,9 +12748,9 @@ function createRunTerminalEventArbiter(runId) {
 
 // dist/builtin/workflows/src/engine/run-terminal-failure.ts
 function finalizeTerminalFailure(input) {
-  const { runId, runSnapshot, store: store2, persistence, metadata, onRunEnd } = input;
+  const { runId, runSnapshot, store, persistence, metadata, onRunEnd } = input;
   const failedToolNode = metadata.failedToolNodeId === undefined ? undefined : runSnapshot.toolNodes?.find((node) => node.id === metadata.failedToolNodeId);
-  const recorded = store2.recordRunEnd(runId, "failed", undefined, metadata.errorMessage, metadata);
+  const recorded = store.recordRunEnd(runId, "failed", undefined, metadata.errorMessage, metadata);
   appendRunEndWhenRecorded(persistence, recorded, {
     runId,
     status: "failed",
@@ -12405,7 +12769,7 @@ function finalizeTerminalFailure(input) {
     ...runSnapshot.durationMs !== undefined ? { durationMs: runSnapshot.durationMs } : {},
     ts: Date.now()
   });
-  return reconcileTerminalRunResult(runId, runSnapshot, store2, { status: "failed", error: metadata.errorMessage }, onRunEnd);
+  return reconcileTerminalRunResult(runId, runSnapshot, store, { status: "failed", error: metadata.errorMessage }, onRunEnd);
 }
 
 // dist/builtin/workflows/src/engine/run-tool-admission-boundary.ts
@@ -12459,6 +12823,7 @@ function createToolAdmissionBoundary() {
 function createToolControlRegistry() {
   const byRun = new Map;
   const admissionByRun = new Map;
+  const runControls = new Map;
   const makeHandle = (registration) => ({
     runId: registration.runId,
     nodeId: registration.nodeId,
@@ -12517,9 +12882,18 @@ function createToolControlRegistry() {
     admissionBoundary(runId) {
       return admissionByRun.get(runId);
     },
+    registerRun(runId, handle) {
+      runControls.set(runId, handle);
+      return () => {
+        if (runControls.get(runId) === handle)
+          runControls.delete(runId);
+      };
+    },
+    runControl: (runId) => runControls.get(runId),
     clear() {
       byRun.clear();
       admissionByRun.clear();
+      runControls.clear();
     }
   };
 }
@@ -12533,7 +12907,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const admissions = [];
   const failures = [];
   const cancellations = [];
-  let nextAdmissionOrder2 = 0;
+  let nextAdmissionOrder = 0;
   let state = "OPEN";
   let closing;
   const abandonment = Promise.withResolvers();
@@ -12542,17 +12916,17 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const recordFailure = (admission, error, nodeId) => {
     if (admission.failure !== undefined)
       return;
-    const failure2 = { admissionOrder: admission.admissionOrder, error, ...nodeId === undefined ? {} : { nodeId } };
-    admission.failure = failure2;
-    failures.push(failure2);
-    options.onFailureObserved?.(failure2);
+    const failure = { admissionOrder: admission.admissionOrder, error, ...nodeId === undefined ? {} : { nodeId } };
+    admission.failure = failure;
+    failures.push(failure);
+    options.onFailureObserved?.(failure);
   };
   const reportDrainFailure = () => {
-    const failure2 = failures[0];
-    if (state !== "DRAINING" || failure2 === undefined || drainFailureReported)
+    const failure = failures[0];
+    if (state !== "DRAINING" || failure === undefined || drainFailureReported)
       return;
     drainFailureReported = true;
-    options.onFailureDuringDrain?.(failure2);
+    options.onFailureDuringDrain?.(failure);
   };
   const drainRecordedFailures = () => Promise.all(admissions.flatMap((admission) => admission.failure !== undefined && admission.observed !== undefined ? [admission.observed] : []));
   const closeAtFixedPoint = async () => {
@@ -12576,7 +12950,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   };
   return {
     track(execution) {
-      if (state === "CLOSED") {
+      if (state === "CLOSED" || options.signal?.aborted) {
         const error = new Error("atomic-workflows: ctx.tool admission is closed for this run");
         execution.catch(() => {
           return;
@@ -12584,7 +12958,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
         return { accepted: false, error, bindNode() {}, noteCancelled() {} };
       }
       const admission = {
-        admissionOrder: ++nextAdmissionOrder2,
+        admissionOrder: ++nextAdmissionOrder,
         nodeId: undefined,
         failure: undefined,
         cancelled: false,
@@ -12644,7 +13018,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
       return failures[0];
     },
     uniqueFailureFor(error) {
-      const matching = [...failures, ...cancellations].filter((failure2) => Object.is(failure2.error, error));
+      const matching = [...failures, ...cancellations].filter((failure) => Object.is(failure.error, error));
       return matching.length === 1 ? matching[0] : undefined;
     }
   };
@@ -12652,8 +13026,8 @@ function createAdmittedToolExecutionTracker(options = {}) {
 
 // dist/builtin/workflows/src/engine/run-tool-node-lifecycle.ts
 function createToolNodeLifecycle(input) {
-  const { store: store2, tracker, run: run2, sourceToContinuationNodeIds } = input;
-  const ownsCurrentRun = () => store2.runs().some((candidate) => candidate === run2);
+  const { store, tracker, run, sourceToContinuationNodeIds } = input;
+  const ownsCurrentRun = () => store.runs().some((candidate) => candidate === run);
   const replayedToolNodeIds = new Set;
   let pendingFrontier = input.resumeToolNode;
   return {
@@ -12671,11 +13045,11 @@ function createToolNodeLifecycle(input) {
       const sourceParents = frontier?.parentIds ?? (node.replayed === true && node.topologyState !== "unavailable" ? node.parentIds : undefined);
       const restored = sourceParents?.map((sourceId) => sourceToContinuationNodeIds.get(sourceId));
       const translated = restored?.every((id) => id !== undefined) ? restored : undefined;
-      if (run2.resumedFromRunId !== undefined && sourceParents !== undefined && translated === undefined) {
-        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run2.resumedFromRunId}`);
+      if (run.resumedFromRunId !== undefined && sourceParents !== undefined && translated === undefined) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run.resumedFromRunId}`);
       }
-      if (translated !== undefined && run2.resumedFromRunId !== undefined && !compatibleReplayedToolParents(tracker, translated, inferredParents, (parentId) => isReplayedContinuationNode(store2, run2, replayedToolNodeIds, parentId))) {
-        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run2.resumedFromRunId}`);
+      if (translated !== undefined && run.resumedFromRunId !== undefined && !compatibleReplayedToolParents(tracker, translated, inferredParents, (parentId) => isReplayedContinuationNode(store, run, replayedToolNodeIds, parentId))) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run.resumedFromRunId}`);
       }
       const parentIds = translated ?? inferredParents;
       tracker.replaceParents(node.id, parentIds);
@@ -12684,28 +13058,28 @@ function createToolNodeLifecycle(input) {
       if (node.replayed === true)
         replayedToolNodeIds.add(node.id);
       if (ownsCurrentRun())
-        store2.recordToolNodeStart(run2.id, node);
+        store.recordToolNodeStart(run.id, node);
       if (frontier !== undefined)
         pendingFrontier = undefined;
     },
     onNodeRunning: (nodeId, startedAt) => {
       if (ownsCurrentRun())
-        store2.recordToolNodeRunning(run2.id, nodeId, startedAt);
+        store.recordToolNodeRunning(run.id, nodeId, startedAt);
     },
     onNodeEnd: (nodeId, update) => {
       if (ownsCurrentRun())
-        store2.recordToolNodeEnd(run2.id, nodeId, update);
+        store.recordToolNodeEnd(run.id, nodeId, update);
     },
     onNodeSettle: (nodeId) => {
       tracker.onSettle(nodeId);
     },
-    runTopology: durableRunTopology(run2)
+    runTopology: durableRunTopology(run)
   };
 }
-function isReplayedContinuationNode(store2, run2, replayedToolNodeIds, nodeId) {
+function isReplayedContinuationNode(store, run, replayedToolNodeIds, nodeId) {
   if (replayedToolNodeIds.has(nodeId))
     return true;
-  const live = store2.runs().find((candidate) => candidate === run2);
+  const live = store.runs().find((candidate) => candidate === run);
   return live?.stages.some((stage) => stage.id === nodeId && stage.replayed === true) === true;
 }
 function compatibleReplayedToolParents(tracker, translated, inferredParents, isReplayedNode) {
@@ -12718,12 +13092,13 @@ function compatibleReplayedToolParents(tracker, translated, inferredParents, isR
 function createTrackedToolPrimitive(input) {
   let observedQuit;
   const admittedTools = createAdmittedToolExecutionTracker({
+    signal: input.controller.signal,
     onFailureObserved: ({ error, nodeId }) => {
       input.terminalEvents.selectFailure(error, nodeId);
     },
-    onFailureDuringDrain: (failure2) => {
+    onFailureDuringDrain: (failure) => {
       if (input.terminalEvents.winner()?.kind === "failure")
-        input.controller.abort(failure2.error);
+        input.controller.abort(failure.error);
     }
   });
   const lifecycle = createToolNodeLifecycle(input);
@@ -13102,7 +13477,7 @@ function createTrackedStageCaller(input) {
       if (suppressQueuedContinuation)
         runtime.state.suppressQueuedUserMessageContinuation = true;
       try {
-        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.__continuePrompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
       } finally {
         if (suppressQueuedContinuation)
           runtime.state.suppressQueuedUserMessageContinuation = false;
@@ -13207,9 +13582,9 @@ function createTrackedStageCaller(input) {
           let resolveNextTurnEnd = null;
           const unsubscribeTurnWatcher = runtime.innerCtx.subscribe((event) => {
             if (event.type === "agent_end" && resolveNextTurnEnd) {
-              const resolve9 = resolveNextTurnEnd;
+              const resolve = resolveNextTurnEnd;
               resolveNextTurnEnd = null;
-              resolve9();
+              resolve();
             }
           });
           try {
@@ -13222,15 +13597,15 @@ function createTrackedStageCaller(input) {
               runtime.state.askUserQuestionObservedThisTurn = false;
               runtime.state.chatAnswerObservedThisTurn = false;
               if (decision.message !== undefined) {
-                result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(decision.message), runtime.signal));
+                result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.__continuePrompt(decision.message), runtime.signal));
                 if (runtime.budget.enabled && typeof result === "string")
                   stageResultBeforeBudget = result;
               } else {
                 runtime.state.waitingForStageChatTurn = true;
                 try {
-                  await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve9) => {
-                    resolveNextTurnEnd = resolve9;
-                    runtime.state.wakeWaitingForStageChatTurn = resolve9;
+                  await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve) => {
+                    resolveNextTurnEnd = resolve;
+                    runtime.state.wakeWaitingForStageChatTurn = resolve;
                   }), runtime.signal));
                 } finally {
                   runtime.state.wakeWaitingForStageChatTurn = undefined;
@@ -13270,7 +13645,9 @@ function createTrackedStageCaller(input) {
         await runtime.budget.deliverWrapUp(runtime.name);
       if (afterBudget.kind === "exhausted" && runtime.budget.enabled)
         await runtime.budget.stopAtBoundaryAsync(runtime.name);
-      await runtime.innerCtx.__closeGeneration();
+      const finalizedArtifact = await runtime.innerCtx.__closeGeneration();
+      if (typeof result === "string" && finalizedArtifact !== undefined)
+        result = finalizedArtifact;
       await runtime.captureStageSessionMeta({ awaitDurable: true });
       if (trackStageLifecycle && runtime.stageFailFastScope?.failed === true && runtime.stageFailFastScope.activeStages.has(runtime.stageId)) {
         runtime.markSkippedForParallelFailFast();
@@ -13299,7 +13676,7 @@ function createTrackedStageCaller(input) {
       const budgetError = err instanceof WorkflowBudgetExceededError ? err : undefined;
       if (budgetError !== undefined && trackStageLifecycle && !runtime.state.skippedForParallelFailFast) {
         let selectedBudgetError = budgetError;
-        if (runtime.activeStore.runs().find((run2) => run2.id === runtime.runId)?.budgetState?.wrapUpCompleted !== true) {
+        if (runtime.activeStore.runs().find((run) => run.id === runtime.runId)?.budgetState?.wrapUpCompleted !== true) {
           try {
             await runtime.budget.deliverWrapUp(runtime.name);
           } catch (wrapUpError) {
@@ -13327,8 +13704,8 @@ function createTrackedStageCaller(input) {
           };
         }
       } else if (trackStageLifecycle && !runtime.signal.aborted && !runtime.state.skippedForParallelFailFast) {
-        const failure2 = runtime.classifyExecutorFailure(err);
-        applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure2);
+        const failure = runtime.classifyExecutorFailure(err);
+        applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
       }
       throw err;
     } finally {
@@ -13354,8 +13731,8 @@ function createTrackedStageCaller(input) {
       finalizationError ??= durableCheckpointError;
       if (trackStageLifecycle) {
         if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
-          const failure2 = runtime.classifyExecutorFailure(durableCheckpointError.error);
-          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure2);
+          const failure = runtime.classifyExecutorFailure(durableCheckpointError.error);
+          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
         }
         if (!runtime.state.stageFinalized)
           applyTerminalStageState?.();
@@ -13613,8 +13990,8 @@ class StageToolExecutionBuffer {
 // dist/builtin/workflows/src/runs/foreground/executor-stage-control.ts
 function createStageControlHandle(runtime) {
   const messagePreparation = () => {
-    const meta2 = runtime.innerCtx.__sessionMeta();
-    if (meta2.sessionId !== undefined || meta2.sessionFile !== undefined) {
+    const meta = runtime.innerCtx.__sessionMeta();
+    if (meta.sessionId !== undefined || meta.sessionFile !== undefined) {
       return { beforePreparation: runtime.throwIfStageMutationBlocked };
     }
     if (runtime.stageSnapshot.sessionFile !== undefined) {
@@ -13744,8 +14121,8 @@ function createStageControlHandle(runtime) {
       if (changed) {
         runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
         await runtime.scheduler.cascadePauseFrom(runtime.stageId);
-        const run2 = runtime.activeStore.runs().find((candidate) => candidate.id === runtime.runId);
-        const stillActive = run2?.stages.some((stage) => stage.status === "running" && stage.id !== runtime.stageId) ?? false;
+        const run = runtime.activeStore.runs().find((candidate) => candidate.id === runtime.runId);
+        const stillActive = run?.stages.some((stage) => stage.status === "running" && stage.id !== runtime.stageId) ?? false;
         if (!stillActive)
           runtime.activeStore.recordRunPaused(runtime.runId);
       }
@@ -13812,6 +14189,7 @@ function createStageControlHandle(runtime) {
 // dist/builtin/workflows/src/runs/foreground/executor-stage-replay.ts
 function createReplayStageContext(input) {
   const { runId, name, stageId, stageSnapshot, replaySource } = input;
+  workflowObservationRuntime(input.activeStore).replayStageIds.add(workflowActivityNodeKey(runId, stageId));
   let replayFinalized = false;
   let unregisterWorkflowExitCleanup = () => {};
   let stageStartEntryAppended = false;
@@ -13881,6 +14259,7 @@ function createReplayStageContext(input) {
   return {
     name,
     prompt: replayText,
+    __continuePrompt: replayText,
     complete: replayText,
     sendUserMessage: async () => rejectReplayMutation("send a user message"),
     __sendUserMessage: async () => rejectReplayMutation("send a user message"),
@@ -13943,13 +14322,13 @@ function createReplayStageContext(input) {
 
 // dist/builtin/workflows/src/durable/run-owner-backend.ts
 function durableRootRunIdForRun(runs, runId) {
-  return reciprocalWorkflowRootRunId(new Map(runs.map((run2) => [run2.id, run2])), runId);
+  return reciprocalWorkflowRootRunId(new Map(runs.map((run) => [run.id, run])), runId);
 }
 function durableBackendForRun(backend, runs, runId) {
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
     return;
-  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const runById = new Map(runs.map((run) => [run.id, run]));
   if (rootRunId === runId)
     return backend;
   const scopes = [];
@@ -13972,17 +14351,17 @@ function durableBackendForRun(backend, runs, runId) {
 }
 
 // dist/builtin/workflows/src/shared/pending-stage-route-capability.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var routeCapabilities = new WeakMap;
-function workflowPendingStageRouteCapability(store2, runId) {
-  let capabilities = routeCapabilities.get(store2);
+function workflowPendingStageRouteCapability(store, runId) {
+  let capabilities = routeCapabilities.get(store);
   if (capabilities === undefined) {
     capabilities = new Map;
-    routeCapabilities.set(store2, capabilities);
+    routeCapabilities.set(store, capabilities);
   }
   let capability = capabilities.get(runId);
   if (capability === undefined) {
-    capability = randomUUID4();
+    capability = randomUUID5();
     capabilities.set(runId, capability);
   }
   return capability;
@@ -14066,7 +14445,7 @@ function parseWorkflowStageTarget(target) {
 
 // dist/builtin/workflows/src/shared/pending-stage-status.ts
 function workflowBoundaryHops(runs, runId) {
-  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const runById = new Map(runs.map((run) => [run.id, run]));
   const hops = [];
   let current = runById.get(runId);
   while (current !== undefined && current.parentRunId !== undefined) {
@@ -14125,8 +14504,8 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
   let drainPromise;
   const pendingReady = () => {
     if (readyPromise === undefined) {
-      readyPromise = new Promise((resolve9, reject) => {
-        resolveReady = resolve9;
+      readyPromise = new Promise((resolve, reject) => {
+        resolveReady = resolve;
         rejectReady = reject;
       });
     }
@@ -14182,7 +14561,7 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
   ].map((entry) => entry.id));
   const runs = activeStore.runs();
   const entries = [
-    ...(runs.find((run2) => run2.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id) && entry.sticky !== true),
+    ...(runs.find((run) => run.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id) && entry.sticky !== true),
     ...stickyEntries.map((entry) => ({ entry, index: Number.MAX_SAFE_INTEGER }))
   ].sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
   const rootBackend = getDurableBackend();
@@ -14226,7 +14605,7 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
     return [];
-  const rootRun = runs.find((run2) => run2.id === rootRunId);
+  const rootRun = runs.find((run) => run.id === rootRunId);
   if (rootRun === undefined)
     return [];
   const hops = workflowBoundaryHops(runs, runId);
@@ -14244,20 +14623,20 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
     return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
   });
 }
-function claimPendingDelivery(store2, runId, stageKey, messageId) {
-  let claims = pendingDeliveryClaims.get(store2);
+function claimPendingDelivery(store, runId, stageKey, messageId) {
+  let claims = pendingDeliveryClaims.get(store);
   if (claims === undefined) {
     claims = new Set;
-    pendingDeliveryClaims.set(store2, claims);
+    pendingDeliveryClaims.set(store, claims);
   }
-  const key2 = JSON.stringify([runId, stageKey, messageId]);
-  if (claims.has(key2))
+  const key = JSON.stringify([runId, stageKey, messageId]);
+  if (claims.has(key))
     return;
-  claims.add(key2);
+  claims.add(key);
   return () => {
-    claims?.delete(key2);
+    claims?.delete(key);
     if (claims?.size === 0)
-      pendingDeliveryClaims.delete(store2);
+      pendingDeliveryClaims.delete(store);
   };
 }
 function toPendingStageSender(entry) {
@@ -14321,8 +14700,8 @@ class WorkflowModelValidationError extends Error {
 }
 function formatModelValidationError(failures) {
   const lines = ["workflows: model validation failed before starting workflow.", "Unavailable or ambiguous models:"];
-  for (const failure2 of failures) {
-    lines.push(`- ${failure2.input} (${failure2.reason})`);
+  for (const failure of failures) {
+    lines.push(`- ${failure.input} (${failure.reason})`);
   }
   return lines.join(`
 `);
@@ -14430,10 +14809,10 @@ function buildModelCandidates(input) {
       failures.push(resolved);
       continue;
     }
-    const key2 = candidateKey(resolved);
-    if (seen.has(key2))
+    const key = candidateKey(resolved);
+    if (seen.has(key))
       continue;
-    seen.add(key2);
+    seen.add(key);
     candidates.push(resolved);
   }
   if (failures.length > 0)
@@ -14526,6 +14905,89 @@ class StageDeliveryActivity {
   }
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-runner-artifact-capture.ts
+class StageArtifactCapture {
+  session;
+  seen = new WeakSet;
+  accepted = [];
+  provisional;
+  receivesMessageEvents = false;
+  closed = false;
+  reset() {
+    this.session = undefined;
+    this.seen = new WeakSet;
+    this.accepted = [];
+    this.provisional = undefined;
+    this.receivesMessageEvents = false;
+    this.closed = false;
+  }
+  beginAttempt(session) {
+    if (this.closed)
+      return;
+    if (this.session === session)
+      this.scan();
+    else {
+      this.session = session;
+      this.receivesMessageEvents = false;
+      this.rememberContext();
+    }
+    this.provisional = [];
+  }
+  settleAttempt(success) {
+    if (this.closed)
+      return;
+    this.scan();
+    if (success)
+      this.accepted.push(...this.provisional ?? []);
+    this.provisional = undefined;
+  }
+  close() {
+    this.scan();
+    this.closed = true;
+    this.session = undefined;
+    this.seen = new WeakSet;
+    this.provisional = undefined;
+  }
+  onEvent(session, event) {
+    if (session !== this.session)
+      return;
+    if (event.type === "message_end") {
+      this.receivesMessageEvents = true;
+      this.capture(event.message);
+    }
+    if (event.type === "compaction_end")
+      this.rememberContext();
+  }
+  messages() {
+    this.scan();
+    return this.accepted;
+  }
+  rememberContext(session = this.session) {
+    if (session !== this.session)
+      return;
+    for (const message of this.session?.messages ?? [])
+      this.seen.add(message);
+  }
+  scan() {
+    if (this.receivesMessageEvents)
+      return;
+    for (const message of this.session?.messages ?? [])
+      this.capture(message);
+  }
+  capture(message) {
+    if (this.seen.has(message))
+      return;
+    this.seen.add(message);
+    if (message.role !== "assistant")
+      return;
+    if (message.stopReason !== "stop" && message.stopReason !== "length")
+      return;
+    if (message.content.some((block) => block.type === "toolCall"))
+      return;
+    (this.provisional ?? this.accepted).push(structuredClone(message));
+  }
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-candidate.ts
 function effectiveCandidateReasoning(candidate, fallback) {
   return candidate.reasoningLevel ?? fallback;
@@ -14731,6 +15193,23 @@ function extractMessageText(message) {
   }
   return "";
 }
+function assistantArtifactTextForGeneration(messages) {
+  const answers = messages.flatMap((message) => {
+    if (message.role !== "assistant")
+      return [];
+    if (message.stopReason !== "stop" && message.stopReason !== "length")
+      return [];
+    if (message.content.some((block) => block.type === "toolCall"))
+      return [];
+    const text = extractMessageText(message);
+    return text.length > 0 ? [text] : [];
+  });
+  return answers.map((text, index) => index === 0 ? text : `
+
+## Supplement ${index}
+
+${text}`).join("");
+}
 function lastAssistantTextFromMessages(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
@@ -14751,7 +15230,7 @@ function structuredOutputTurnDetail(messages, startIndex) {
   }
   return "The model produced no assistant message after the prompt";
 }
-function assistantArtifactTextForToolCall(messages, toolCallId2) {
+function assistantArtifactTextForToolCall(messages, toolCallId) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
     if (message?.role !== "assistant")
@@ -14759,7 +15238,7 @@ function assistantArtifactTextForToolCall(messages, toolCallId2) {
     const { content } = message;
     if (!Array.isArray(content))
       continue;
-    if (!content.some((block) => block.type === "toolCall" && block.id === toolCallId2))
+    if (!content.some((block) => block.type === "toolCall" && block.id === toolCallId))
       continue;
     const text = extractMessageText(message);
     if (text.trim().length > 0)
@@ -14834,8 +15313,8 @@ function terminatingToolResultText(messages, terminatingToolCallIds) {
     if (!message)
       continue;
     if (message.role === "toolResult") {
-      const toolCallId2 = message.toolCallId;
-      if (typeof toolCallId2 !== "string" || !terminatingToolCallIds.has(toolCallId2)) {
+      const toolCallId = message.toolCallId;
+      if (typeof toolCallId !== "string" || !terminatingToolCallIds.has(toolCallId)) {
         return;
       }
       const text = extractMessageText(message).trim();
@@ -14868,27 +15347,27 @@ function assistantMessage(text) {
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-options.ts
 import { SessionManager } from "@bastani/atomic";
-function workflowSessionOptions(meta2) {
+function workflowSessionOptions(meta) {
   return {
     internal: true,
-    workflow: { runId: meta2.runId, stageId: meta2.stageId, stageName: meta2.stageName }
+    workflow: { runId: meta.runId, stageId: meta.stageId, stageName: meta.stageName }
   };
 }
-function workflowOrchestrationContext(meta2, stageOptions, pendingStageDelivery) {
+function workflowOrchestrationContext(meta, stageOptions, pendingStageDelivery) {
   const base = {
     kind: "workflow-stage",
-    workflowRunId: meta2.runId,
-    workflowStageId: meta2.stageId,
-    workflowStageName: meta2.stageName,
+    workflowRunId: meta.runId,
+    workflowStageId: meta.stageId,
+    workflowStageName: meta.stageName,
     constraints: { disableWorkflowTool: true }
   };
-  const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions, meta2.workflowIntercomGroup) : undefined;
+  const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions, meta.workflowIntercomGroup) : undefined;
   const context = intercomGroup ? { ...base, intercomGroup } : base;
   return pendingStageDelivery === undefined ? context : { ...context, pendingStageDelivery };
 }
-function stripWorkflowOnlyOptions(options, defaultSessionDir, meta2, pendingStageDelivery) {
-  const classification = workflowSessionOptions(meta2);
-  const orchestrationContext = workflowOrchestrationContext(meta2, options, pendingStageDelivery);
+function stripWorkflowOnlyOptions(options, defaultSessionDir, meta, pendingStageDelivery) {
+  const classification = workflowSessionOptions(meta);
+  const orchestrationContext = workflowOrchestrationContext(meta, options, pendingStageDelivery);
   if (!options) {
     return defaultSessionDir === undefined ? { orchestrationContext } : {
       orchestrationContext,
@@ -15227,30 +15706,31 @@ async function sendStageUserMessage(activeSession, content, options, beforeDeliv
   if (activeSession.sendUserMessage !== undefined) {
     beforeDelivery?.();
     let reportedAction;
-    const ownership2 = streaming ? undefined : admission === undefined ? createLocalPromptOwnershipObserver(activeSession, promptStarted) : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
-    ownership2?.arm();
-    const deliveryId2 = streaming ? undefined : activity?.start();
+    const ownership = streaming ? undefined : admission === undefined ? createLocalPromptOwnershipObserver(activeSession, promptStarted) : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
+    ownership?.arm();
+    const deliveryId = streaming ? undefined : activity?.start();
     try {
       const delivery = activeSession.sendUserMessage(content, {
         ...deliverAs === undefined ? {} : { deliverAs },
+        ...options?.expandPromptTemplates === undefined ? {} : { expandPromptTemplates: options.expandPromptTemplates },
         __workflowDelivery: {
-          promptStarted: ownership2?.observe ?? promptStarted,
-          delivered(action2) {
-            reportedAction = action2;
+          promptStarted: ownership?.observe ?? promptStarted,
+          delivered(action) {
+            reportedAction = action;
           }
         }
       });
-      ownership2?.observeStreaming();
+      ownership?.observeStreaming();
       await delivery;
       const action = reportedAction ?? (streaming ? deliverAs ?? "followUp" : "prompt");
-      ownership2?.settle(action);
+      ownership?.settle(action);
       return action;
     } catch (error) {
-      ownership2?.settle();
+      ownership?.settle();
       throw error;
     } finally {
-      ownership2?.dispose();
-      activity?.settle(deliveryId2);
+      ownership?.dispose();
+      activity?.settle(deliveryId);
     }
   }
   if (typeof content !== "string")
@@ -15550,9 +16030,25 @@ class StageSessionController {
   pendingCreationResumeMessage;
   messageAdmission = new StageMessageAdmission;
   deliveryActivity = new StageDeliveryActivity;
-  constructor(opts, meta2, effectiveStageOptions, structuredOutputCapture) {
+  artifactCapture = new StageArtifactCapture;
+  beginOutputGeneration() {
+    this.artifactCapture.reset();
+  }
+  outputGenerationMessages() {
+    return this.artifactCapture.messages();
+  }
+  async navigateTree(...args) {
+    const session = await this.ensureSession();
+    this.artifactCapture.messages();
+    try {
+      return await session.navigateTree(...args);
+    } finally {
+      this.artifactCapture.rememberContext(session);
+    }
+  }
+  constructor(opts, meta, effectiveStageOptions, structuredOutputCapture) {
     this.opts = opts;
-    this.meta = meta2;
+    this.meta = meta;
     this.effectiveStageOptions = effectiveStageOptions;
     this.structuredOutputCapture = structuredOutputCapture;
     this.hasExplicitModelFallbackConfig = effectiveStageOptions?.model !== undefined || (effectiveStageOptions?.fallbackModels?.length ?? 0) > 0;
@@ -15675,10 +16171,10 @@ class StageSessionController {
       const sessionFile = preparation?.sessionFile;
       const deliver = async (activity) => {
         const activeSession = sessionFile === undefined ? await this.ensureSession("prompt") : await this.ensureSessionFromFile(sessionFile, "prompt");
-        const pausedDelivery2 = this.pauseControl.deferRunnerOwnedDelivery(() => sendStageUserMessage(activeSession, content, options, beforeDelivery, release, this.messageAdmission, activity));
-        if (pausedDelivery2 !== undefined) {
+        const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(() => sendStageUserMessage(activeSession, content, options, beforeDelivery, release, this.messageAdmission, activity));
+        if (pausedDelivery !== undefined) {
           release();
-          return pausedDelivery2;
+          return pausedDelivery;
         }
         return sendStageUserMessage(activeSession, content, options, beforeDelivery, release, this.messageAdmission, activity);
       };
@@ -15700,18 +16196,19 @@ class StageSessionController {
     const pending = this.activeCreation ?? this.sessionPromise;
     const session = pending ? await pending : this.session;
     await session?.closeWorkflowStageGeneration?.();
+    this.artifactCapture.close();
   }
   async promptWithFallback(text, sdkOptions, consumer = "prompt") {
     if (!this.hasExplicitModelFallbackConfig) {
       try {
         const activeSession = await this.ensureSession(consumer);
-        const resumedText2 = this.pendingCreationResumeMessage;
+        const resumedText = this.pendingCreationResumeMessage;
         this.pendingCreationResumeMessage = undefined;
         const value = activeSession.model ?? "default";
         const candidate = { id: workflowModelId(value) ?? "default", value };
         this.beginAttemptUsage(activeSession);
         try {
-          await this.promptWithThrownErrorRetry(activeSession, resumedText2 ?? text, sdkOptions);
+          await this.promptWithThrownErrorRetry(activeSession, resumedText ?? text, sdkOptions);
         } catch (error) {
           await this.handleCandidateFailure(error, candidate, [candidate], 0);
           throw error;
@@ -15728,10 +16225,12 @@ class StageSessionController {
     if (candidates.length === 0) {
       try {
         const activeSession = await this.ensureSession(consumer);
-        const resumedText2 = this.pendingCreationResumeMessage;
+        const resumedText = this.pendingCreationResumeMessage;
         this.pendingCreationResumeMessage = undefined;
-        await this.promptWithThrownErrorRetry(activeSession, resumedText2 ?? text, sdkOptions);
+        await this.promptWithThrownErrorRetry(activeSession, resumedText ?? text, sdkOptions);
+        this.artifactCapture.settleAttempt(true);
       } catch (error) {
+        this.artifactCapture.settleAttempt(false);
         if (error instanceof StageSessionCreationCancelled)
           return;
         throw error;
@@ -15779,10 +16278,10 @@ class StageSessionController {
         this.recordSuccessfulAttempt(candidate);
         return;
       } catch (err) {
-        const failure2 = await this.handleCandidateFailure(err, candidate, candidates, index);
-        if (failure2 === "handled")
+        const failure = await this.handleCandidateFailure(err, candidate, candidates, index);
+        if (failure === "handled")
           return;
-        if (failure2 === "throw")
+        if (failure === "throw")
           throw err;
         index += 1;
       }
@@ -15876,14 +16375,14 @@ class StageSessionController {
     const { signal } = this.opts;
     if (!signal)
       return;
-    const abortReason3 = () => {
+    const abortReason = () => {
       const reason = signal.reason;
       if (reason instanceof Error || reason instanceof DOMException || typeof reason === "string")
         return reason;
       return new DOMException("workflow killed", "AbortError");
     };
     const onAbort = () => {
-      const reason = abortReason3();
+      const reason = abortReason();
       this.markAbort(reason);
       this.session?.abort().catch(() => {});
       this.pauseControl.reject(reason);
@@ -16023,6 +16522,7 @@ class StageSessionController {
     let retainedPrompt;
     let terminalScanStartIndex;
     while (true) {
+      this.artifactCapture.beginAttempt(activeSession);
       const messagesBeforeAttempt = [...activeSession.messages];
       try {
         if (retryAdmittedPrompt) {
@@ -16065,6 +16565,7 @@ class StageSessionController {
         const willRetry = decision !== undefined && !this.disposed && this.opts.signal?.aborted !== true && !this.capturedStructuredOutputForAttempt();
         const willContinue = continuationSession !== undefined && admittedMessages;
         if (retryableFailure && willRetry) {
+          this.artifactCapture.settleAttempt(false);
           retainedPrompt = this.restoreSessionMessages(activeSession, messagesBeforeAttempt, nextText, willContinue) ?? retainedPrompt;
         }
         if (!willRetry)
@@ -16231,9 +16732,9 @@ class StageSessionController {
     while (true) {
       try {
         if (pendingFailure !== undefined) {
-          const failure2 = pendingFailure;
+          const failure = pendingFailure;
           pendingFailure = undefined;
-          throw failure2.error;
+          throw failure.error;
         }
         return await this.createSessionObservingPause(candidate, consumer);
       } catch (error) {
@@ -16350,6 +16851,7 @@ class StageSessionController {
     }
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = result.session.subscribe((event) => {
+      this.artifactCapture.onEvent(result.session, event);
       const terminatingId = terminatingToolCallId(event);
       if (terminatingId !== undefined)
         this.terminatingToolCallIds.add(terminatingId);
@@ -16433,6 +16935,7 @@ class StageSessionController {
       const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(resumedSession, text, sdkOptions);
       const terminalFailure = latestTerminalAssistantFailureSince(resumedSession.messages, terminalScanStartIndex);
       if (terminalFailure === undefined || this.capturedStructuredOutputForAttempt()) {
+        this.artifactCapture.settleAttempt(true);
         const usage = this.takeAttemptUsage(resumedSession);
         this.modelAttempts.push({
           model: resumedLabel,
@@ -16447,17 +16950,19 @@ class StageSessionController {
       throw new WorkflowPromptModelFailure(terminalFailure);
     } catch (err) {
       if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
-        const usage2 = this.takeAttemptUsage(resumedSession);
+        this.artifactCapture.settleAttempt(true);
+        const usage = this.takeAttemptUsage(resumedSession);
         this.modelAttempts.push({
           model: resumedLabel,
           success: true,
-          ...usage2 === undefined ? {} : { usage: usage2 }
+          ...usage === undefined ? {} : { usage }
         });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
         this.notifySuccessfulModelFallbackMeta();
         return true;
       }
+      this.artifactCapture.settleAttempt(false);
       const message = errorMessage2(err);
       const usage = this.takeAttemptUsage(resumedSession);
       this.modelAttempts.push({
@@ -16492,6 +16997,7 @@ class StageSessionController {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
+    this.artifactCapture.settleAttempt(false);
     const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
@@ -16515,6 +17021,7 @@ class StageSessionController {
     return this.structuredOutputCapture?.called === true && this.opts.signal?.aborted !== true;
   }
   recordSuccessfulAttempt(candidate) {
+    this.artifactCapture.settleAttempt(true);
     const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
@@ -16722,7 +17229,7 @@ function stageOutputInstruction(outputOptions, hasStructuredOutput = false) {
   }
   return `
 
-[This stage's final message is saved verbatim as its artifact and is what later stages read. Return the complete result in that message rather than a pointer to it. Files you write yourself are not the artifact.]`;
+[This stage's completed answers are saved as its artifact and are what later stages read. Return the complete result as ordinary assistant text rather than a pointer to it. Follow-up answers within this stage are appended as numbered supplements, not replacements; state corrections explicitly. Tool-call progress is transcript-only. Files you write yourself are not the artifact.]`;
 }
 async function finalizePromptOutput(fullOutput, outputOptions, runtimeCwd, runId, messages) {
   const outputPath = resolveOutputPath(outputOptions.output, runtimeCwd, outputOptions.cwd);
@@ -16768,7 +17275,7 @@ function createStageContext2(opts) {
   const structuredOutputCapture = stageOptions?.schema ? createStructuredOutputCapture() : undefined;
   const structuredOutputExecutionCapture = stageOptions?.schema ? {} : undefined;
   const effectiveStageOptions = stageOptionsWithStructuredOutput(stageOptions, structuredOutputCapture, structuredOutputExecutionCapture);
-  const meta2 = {
+  const meta = {
     runId,
     stageId,
     stageName,
@@ -16777,21 +17284,40 @@ function createStageContext2(opts) {
     stageOptions: effectiveStageOptions,
     executionMode
   };
-  const controller = new StageSessionController(opts, meta2, effectiveStageOptions, structuredOutputCapture);
+  const controller = new StageSessionController(opts, meta, effectiveStageOptions, structuredOutputCapture);
   let lastAssistantText;
   let lastFinalizedOutput;
   let lastFinalizedMessageCount;
   let structuredArtifactFinalized = false;
   let adapterMessages = [];
+  let artifactOptions;
+  let artifactClosed = false;
+  let artifactText;
+  let continuing = false;
+  async function exportArtifact() {
+    const text = assistantArtifactTextForGeneration(controller.outputGenerationMessages());
+    if (text !== artifactText || lastFinalizedOutput === undefined) {
+      lastFinalizedOutput = await finalizePromptOutput(text, artifactOptions, runtimeCwd(), runId, controller.currentSession?.messages);
+      artifactText = text;
+      lastAssistantText = lastFinalizedOutput;
+    }
+    return lastFinalizedOutput;
+  }
   function runtimeCwd() {
     return typeof effectiveStageOptions?.cwd === "string" ? effectiveStageOptions.cwd : process.cwd();
   }
   function finalizedOutputIsCurrent() {
-    return lastFinalizedOutput !== undefined && (structuredArtifactFinalized || lastFinalizedMessageCount === undefined || controller.currentSession?.messages.length === lastFinalizedMessageCount);
+    if (lastFinalizedOutput === undefined)
+      return false;
+    if (artifactOptions !== undefined || structuredArtifactFinalized)
+      return true;
+    return lastFinalizedMessageCount === undefined || controller.currentSession?.messages.length === lastFinalizedMessageCount;
   }
   return {
     name: stageName,
     async prompt(text, options) {
+      if (continuing && artifactOptions)
+        options = { ...options, ...artifactOptions };
       const { sdkOptions, outputOptions } = splitPromptOptions(options);
       validatePromptOutputOptions(outputOptions);
       const hasOutputArtifact = typeof outputOptions.output === "string" && outputOptions.output.length > 0;
@@ -16799,15 +17325,23 @@ function createStageContext2(opts) {
       if (structuredOutputCapture?.called) {
         throw new Error("atomic-workflows: stage schema supports one prompt() call per stage context because structured_output may be called exactly once. Create a new ctx.stage(...) for each additional schema-backed prompt.");
       }
+      if (!continuing) {
+        controller.beginOutputGeneration();
+        artifactOptions = undefined;
+        artifactClosed = false;
+        artifactText = undefined;
+      }
+      if (hasOutputArtifact && !structuredOutputCapture && !adapters.prompt)
+        artifactOptions = outputOptions;
       if (adapters.prompt) {
         if (structuredOutputCapture) {
           throw new Error("atomic-workflows: stage schema requires an AgentSessionAdapter so the structured_output tool can be registered.");
         }
-        const rawText2 = await runCallback2({ kind: "workflow.stage_adapter", name: `prompt:${stageName}`, runId, stageId }, () => adapters.prompt.prompt(promptText, meta2));
-        if (typeof rawText2 !== "string")
-          return rawText2;
-        adapterMessages = assistantMessage(rawText2);
-        lastAssistantText = await finalizePromptOutput(rawText2, outputOptions, runtimeCwd(), runId, adapterMessages);
+        const rawText = await runCallback2({ kind: "workflow.stage_adapter", name: `prompt:${stageName}`, runId, stageId }, () => adapters.prompt.prompt(promptText, meta));
+        if (typeof rawText !== "string")
+          return rawText;
+        adapterMessages = assistantMessage(rawText);
+        lastAssistantText = await finalizePromptOutput(rawText, outputOptions, runtimeCwd(), runId, adapterMessages);
         lastFinalizedOutput = lastAssistantText;
         lastFinalizedMessageCount = controller.currentSession?.messages.length;
         return lastAssistantText;
@@ -16849,17 +17383,28 @@ function createStageContext2(opts) {
         return executionSnapshot.value;
       }
       await controller.promptWithFallback(promptText, sdkOptions);
+      if (artifactOptions)
+        return await exportArtifact();
       const rawText = controller.lastAssistantText(lastAssistantText) ?? "";
       lastAssistantText = await finalizePromptOutput(rawText, outputOptions, runtimeCwd(), runId, controller.currentSession?.messages);
       lastFinalizedOutput = lastAssistantText;
       lastFinalizedMessageCount = controller.currentSession?.messages.length;
       return lastAssistantText;
     },
+    async __continuePrompt(text) {
+      continuing = true;
+      try {
+        return await this.prompt(text);
+      } finally {
+        continuing = false;
+      }
+    },
     async complete(text, completeOpts) {
+      artifactOptions = undefined;
       if (adapters.complete) {
         lastFinalizedOutput = undefined;
         lastFinalizedMessageCount = undefined;
-        lastAssistantText = await runCallback2({ kind: "workflow.stage_adapter", name: `complete:${stageName}`, runId, stageId }, () => adapters.complete.complete(text, completeOpts, meta2));
+        lastAssistantText = await runCallback2({ kind: "workflow.stage_adapter", name: `complete:${stageName}`, runId, stageId }, () => adapters.complete.complete(text, completeOpts, meta));
         adapterMessages = assistantMessage(lastAssistantText);
         return lastAssistantText;
       }
@@ -16924,7 +17469,7 @@ function createStageContext2(opts) {
       return controller.currentSession?.isStreaming ?? false;
     },
     async navigateTree(targetId, options) {
-      return (await controller.ensureSession()).navigateTree(targetId, options);
+      return controller.navigateTree(targetId, options);
     },
     async compact() {
       return (await controller.ensureSession()).compact();
@@ -16955,6 +17500,11 @@ function createStageContext2(opts) {
     },
     async __closeGeneration() {
       await controller.closeGeneration();
+      if (artifactOptions && !artifactClosed) {
+        await exportArtifact();
+        artifactClosed = true;
+      }
+      return artifactOptions ? lastFinalizedOutput : undefined;
     },
     __sessionMeta() {
       return controller.sessionMeta();
@@ -16989,7 +17539,7 @@ function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEAR
   let timer;
   let generation = 0;
   let nextDeadline = 0;
-  let failure2;
+  let failure;
   let inFlight;
   let rejectFailure;
   const failureSignal = new Promise((_resolve, reject) => {
@@ -17006,14 +17556,14 @@ function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEAR
     timer = undefined;
   };
   const fail = (error) => {
-    if (failure2 !== undefined)
+    if (failure !== undefined)
       return;
-    failure2 = error;
+    failure = error;
     stopScheduling();
     rejectFailure(error);
   };
   const schedule = (scheduledGeneration) => {
-    if (!active || failure2 !== undefined || scheduledGeneration !== generation)
+    if (!active || failure !== undefined || scheduledGeneration !== generation)
       return;
     const delayMs = Math.max(0, nextDeadline - Date.now());
     timer = setTimeout(() => {
@@ -17034,12 +17584,12 @@ function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEAR
   const drain = async () => {
     stopScheduling();
     await inFlight;
-    if (failure2 !== undefined)
-      throw failure2;
+    if (failure !== undefined)
+      throw failure;
   };
   return {
     start() {
-      if (active || failure2 !== undefined)
+      if (active || failure !== undefined)
         return;
       active = true;
       generation += 1;
@@ -17050,8 +17600,8 @@ function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEAR
     drain,
     fail,
     race(work) {
-      if (failure2 !== undefined)
-        return Promise.reject(failure2);
+      if (failure !== undefined)
+        return Promise.reject(failure);
       return Promise.race([work, failureSignal]);
     }
   };
@@ -17132,16 +17682,16 @@ function createWorkflowStageFactory(input) {
         throwIfWorkflowExitSelected: input.exit.throwIfWorkflowExitSelected
       });
     }
-    const applyModelFallbackMeta = (meta2) => {
-      if (meta2.model !== undefined)
-        stageSnapshot.model = meta2.model;
-      if (meta2.attemptedModels !== undefined)
-        stageSnapshot.attemptedModels = meta2.attemptedModels;
-      if (meta2.modelAttempts !== undefined)
-        stageSnapshot.modelAttempts = meta2.modelAttempts;
-      if (meta2.warnings !== undefined) {
-        if (meta2.warnings.length > 0)
-          stageSnapshot.warnings = meta2.warnings;
+    const applyModelFallbackMeta = (meta) => {
+      if (meta.model !== undefined)
+        stageSnapshot.model = meta.model;
+      if (meta.attemptedModels !== undefined)
+        stageSnapshot.attemptedModels = meta.attemptedModels;
+      if (meta.modelAttempts !== undefined)
+        stageSnapshot.modelAttempts = meta.modelAttempts;
+      if (meta.warnings !== undefined) {
+        if (meta.warnings.length > 0)
+          stageSnapshot.warnings = meta.warnings;
         else
           delete stageSnapshot.warnings;
       }
@@ -17169,8 +17719,8 @@ function createWorkflowStageFactory(input) {
       models: input.opts.models,
       executionMode: input.opts.executionMode,
       defaultSessionDir: input.opts.defaultSessionDir,
-      onModelFallbackMetaChange(meta2) {
-        applyModelFallbackMeta(meta2);
+      onModelFallbackMetaChange(meta) {
+        applyModelFallbackMeta(meta);
         if (stageSnapshot.status === "running")
           input.activeStore.recordStageStart(input.runId, stageSnapshot);
       },
@@ -17242,13 +17792,13 @@ function createWorkflowStageFactory(input) {
       await innerCtx.__dispose();
     };
     const captureStageSessionMeta = async (checkpointOptions) => {
-      const meta2 = innerCtx.__sessionMeta();
-      if (meta2.sessionId !== undefined)
-        stageSnapshot.sessionId = meta2.sessionId;
-      if (meta2.sessionFile !== undefined)
-        stageSnapshot.sessionFile = meta2.sessionFile;
-      if (meta2.sessionId !== undefined || meta2.sessionFile !== undefined)
-        input.activeStore.recordStageSession(input.runId, stageId, meta2);
+      const meta = innerCtx.__sessionMeta();
+      if (meta.sessionId !== undefined)
+        stageSnapshot.sessionId = meta.sessionId;
+      if (meta.sessionFile !== undefined)
+        stageSnapshot.sessionFile = meta.sessionFile;
+      if (meta.sessionId !== undefined || meta.sessionFile !== undefined)
+        input.activeStore.recordStageSession(input.runId, stageId, meta);
       const pending = input.opts.onStageSession?.(input.runId, stageSnapshot, checkpointOptions);
       if (checkpointOptions?.forceDurable === true || checkpointOptions?.awaitDurable === true) {
         await pending;
@@ -17588,7 +18138,7 @@ class EngineRuntime {
 // dist/builtin/workflows/src/engine/workflow-activity.ts
 import { runCallback as runCallback4 } from "@bastani/atomic";
 function nextEventLoopTurn() {
-  return new Promise((resolve10) => setTimeout(resolve10, 0));
+  return new Promise((resolve) => setTimeout(resolve, 0));
 }
 function runWorkflowDefinitionCallback(name, runId, callback) {
   return runCallback4({ kind: "workflow.run", name, runId }, callback);
@@ -17616,7 +18166,7 @@ async function run(def, inputs, opts = {}) {
   }
   const resolvedInputs = resolveAndValidateInputs(def.inputs, inputs, `workflow "${def.name}"`);
   const runId = opts.runId ?? crypto.randomUUID();
-  const declaresBudget = (budget2) => (budget2?.maxDurationMs ?? 0) > 0 || (budget2?.maxTokens ?? 0) > 0 || (budget2?.maxCost ?? 0) > 0;
+  const declaresBudget = (budget) => (budget?.maxDurationMs ?? 0) > 0 || (budget?.maxTokens ?? 0) > 0 || (budget?.maxCost ?? 0) > 0;
   const hasBudgetDeclaration = declaresBudget(opts.budget) || declaresBudget(def.budget) || declaresBudget(opts.config?.budget);
   const priorRun = hasBudgetDeclaration && opts.rootBudget === undefined && opts.continuation === undefined && opts.runId !== undefined ? activeStore.runs().find((candidate) => candidate.id === runId) : undefined;
   const continuedBudget = opts.continuation?.source.budget ?? priorRun?.budget;
@@ -17629,21 +18179,17 @@ async function run(def, inputs, opts = {}) {
     terminalEvents.selectCancellation(ownController.signal.reason);
   }, { once: true });
   const callerSignal = opts.signal;
-  if (callerSignal) {
-    if (callerSignal.aborted)
-      ownController.abort(callerSignal.reason);
-    else
-      callerSignal.addEventListener("abort", () => {
-        ownController.abort(callerSignal.reason);
-      }, { once: true });
-  }
+  const onCallerAbort = () => {
+    workflowObservationRuntime(activeStore).control(runId, "kill");
+    ownController.abort(callerSignal?.reason);
+  };
   const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
   const backendView = opts.durableBackend ?? getDurableBackend();
   const rootBackend = opts.durableRootBackend ?? backendView;
   const durableBackend = opts.durableScope !== undefined ? new ScopedDurableBackend(backendView, opts.durableScope) : backendView;
   const inheritedElapsedMs = opts.parentRun === undefined ? inheritedRunElapsedMs({ backend: durableBackend, runId, continuationSource: opts.continuation?.source }) : undefined;
   const continuationOrigin = opts.continuation !== undefined ? opts.continuation.source.origin : opts.origin;
-  const snapshotField = (field2) => resolvedBudget[field2] > 0 || opts.budget?.[field2] !== undefined || def.budget?.[field2] !== undefined ? resolvedBudget[field2] : undefined;
+  const snapshotField = (field) => resolvedBudget[field] > 0 || opts.budget?.[field] !== undefined || def.budget?.[field] !== undefined ? resolvedBudget[field] : undefined;
   const budgetSnapshot = resolvedBudget.maxDurationMs > 0 || resolvedBudget.maxTokens > 0 || resolvedBudget.maxCost > 0 ? {
     maxDurationMs: resolvedBudget.maxDurationMs,
     ...snapshotField("maxTokens") !== undefined ? { maxTokens: snapshotField("maxTokens") } : {},
@@ -17652,7 +18198,7 @@ async function run(def, inputs, opts = {}) {
   } : undefined;
   const durableAccounting = hasBudgetDeclaration && opts.parentRun === undefined && opts.continuation === undefined && priorRun === undefined ? priorRunAccounting(durableBackend, runId) : undefined;
   const continuedBudgetState = opts.continuation?.source.budgetState ?? priorRun?.budgetState ?? (durableAccounting === undefined ? undefined : { accounting: durableAccounting });
-  const sameBudget = budgetSnapshot !== undefined && continuedBudget?.warnAtPercent === budgetSnapshot.warnAtPercent && ["maxDurationMs", "maxTokens", "maxCost"].every((field2) => (continuedBudget?.[field2] ?? 0) === (budgetSnapshot[field2] ?? 0));
+  const sameBudget = budgetSnapshot !== undefined && continuedBudget?.warnAtPercent === budgetSnapshot.warnAtPercent && ["maxDurationMs", "maxTokens", "maxCost"].every((field) => (continuedBudget?.[field] ?? 0) === (budgetSnapshot[field] ?? 0));
   const continuationBudgetState = continuedBudgetState === undefined || !sameBudget && continuedBudgetState.accounting === undefined ? undefined : sameBudget ? continuedBudgetState : { accounting: continuedBudgetState.accounting };
   const continuationSourceRunId = opts.continuation?.source.id;
   const persistedPossibleStages = coercePossibleStages(opts.possibleStages) ?? (continuationSourceRunId !== undefined ? coercePossibleStages(rootBackend.getWorkflow(continuationSourceRunId)?.possibleStages) : undefined);
@@ -17694,9 +18240,9 @@ async function run(def, inputs, opts = {}) {
       children.push(snapshot);
       childrenByParent.set(snapshot.parentRunId, children);
     }
-    const build = (run2) => {
-      const children = (childrenByParent.get(run2.id) ?? []).map(build);
-      return children.length === 0 ? { run: run2 } : { run: run2, children };
+    const build = (run) => {
+      const children = (childrenByParent.get(run.id) ?? []).map(build);
+      return children.length === 0 ? { run } : { run, children };
     };
     return build(snapshots.find((snapshot) => snapshot.id === runSnapshot.id) ?? runSnapshot);
   };
@@ -17730,28 +18276,7 @@ async function run(def, inputs, opts = {}) {
     classifiedFailures.set(error, classified);
     return classified;
   };
-  activeStore.recordRunStart(runSnapshot);
   const ownsCancellationRegistration = opts.signal === undefined && opts.cancellation !== undefined;
-  if (ownsCancellationRegistration)
-    opts.cancellation?.register(runId, ownController);
-  opts.onRunStart?.(runSnapshot);
-  if (opts.persistence) {
-    appendRunStart(opts.persistence, {
-      runId,
-      name: def.name,
-      inputs: resolvedInputs,
-      ...runSnapshot.parentRunId !== undefined ? { parentRunId: runSnapshot.parentRunId } : {},
-      ...runSnapshot.parentStageId !== undefined ? { parentStageId: runSnapshot.parentStageId } : {},
-      ...runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {},
-      ...runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {},
-      ...runSnapshot.origin !== undefined ? { origin: runSnapshot.origin } : {},
-      ...runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {},
-      ...runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {},
-      ...runSnapshot.budget !== undefined ? { budget: runSnapshot.budget } : {},
-      ...runSnapshot.budgetState !== undefined ? { budgetState: runSnapshot.budgetState } : {},
-      ts: runSnapshot.startedAt
-    });
-  }
   const tracker = new GraphFrontierTracker;
   const inputConcurrency = resolveInputConcurrency(def.inputs, resolvedInputs);
   const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCacheOwner = createGitWorktreeSetupCacheOwner(opts.gitWorktreeSetupCache);
@@ -17773,6 +18298,17 @@ async function run(def, inputs, opts = {}) {
     tracker,
     stageRegistry: () => stageRegistry
   });
+  const waitForRunRelease = async () => {
+    await scheduler.waitForRunRelease();
+    ownController.signal.throwIfAborted();
+  };
+  const whenRunning = (call) => {
+    if (scheduler.isRunPaused())
+      return waitForRunRelease().then(() => whenRunning(call));
+    if (ownController.signal.aborted)
+      return Promise.reject(ownController.signal.reason);
+    return call();
+  };
   ownController.signal.addEventListener("abort", () => scheduler.rejectReleaseBarriers(ownController.signal.reason ?? new Error("atomic-workflows: run aborted")), { once: true });
   const finalizers = createRunFinalizers({
     def,
@@ -17901,7 +18437,7 @@ async function run(def, inputs, opts = {}) {
   };
   const taskRunners = createWorkflowTaskRunners({ runtime });
   let pendingChildDurableInvocation;
-  const workflow2 = createChildWorkflowRunner({
+  const workflow = createChildWorkflowRunner({
     runtime,
     resolveWorkflowCwd,
     nextWorkflowBoundaryReplayKey,
@@ -17974,6 +18510,10 @@ async function run(def, inputs, opts = {}) {
     workflowId: runId,
     backend: durableBackend,
     nextCheckpointId: checkpointIdGenerator,
+    beforeCall: () => {
+      ownController.signal.throwIfAborted();
+      return scheduler.isRunPaused() ? waitForRunRelease() : undefined;
+    },
     ...opts.usePromptNodesForUi === true ? {
       onReplay: async (request) => getPromptNodeUi().replayDurable(request)
     } : {}
@@ -17987,6 +18527,10 @@ async function run(def, inputs, opts = {}) {
     completedStageReplayKeys,
     sourceToReplayedNodeIds: sourceToContinuationNodeIds
   });
+  const recordCachedStage = (...args) => {
+    ownController.signal.throwIfAborted();
+    cachedStage.record(...args);
+  };
   const durableIntercomGroup = (replayKey, stageId) => {
     const stages = activeStore.runs().find((candidate) => candidate.id === runId)?.stages ?? [];
     return stages.find((stage) => stageId !== undefined && stage.id === stageId || stage.replayKey === replayKey)?.intercomGroup;
@@ -17998,7 +18542,7 @@ async function run(def, inputs, opts = {}) {
     nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
     durableIntercomGroup,
     task: taskRunners.task,
-    recordCachedTask: cachedStage.record,
+    recordCachedTask: recordCachedStage,
     signal: ownController.signal,
     registerTailControl: (registration) => {
       registration.controller.signal.addEventListener("abort", () => {
@@ -18024,60 +18568,153 @@ async function run(def, inputs, opts = {}) {
     setChildDurableInvocation: (invocation) => {
       pendingChildDurableInvocation = invocation;
     },
-    recordCachedStage: cachedStage.record,
+    recordCachedStage,
     runTopology: durableRunTopology(runSnapshot),
-    workflow: workflow2
+    workflow
   });
+  const pendingChildWorkflows = new Set;
+  const durableStage = createDurableStagePrimitive({
+    workflowId: runId,
+    backend: durableBackend,
+    nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
+    durableIntercomGroup,
+    recordCachedStage,
+    stage: (name, options, replayKey) => {
+      const stage = runtime.stage(name, options);
+      const stageId = activeStore.runs().find((r) => r.id === runId)?.stages.at(-1)?.id;
+      if (stageId !== undefined)
+        completedStageReplayKeys.set(stageId, replayKey);
+      return stage;
+    }
+  });
+  const gatedTask = (...args) => whenRunning(() => durableTask(...args));
+  const chain = createChainPrimitive({ runtime, task: gatedTask });
+  const parallel = createParallelPrimitive({ runtime, task: gatedTask });
+  const ui = buildExitGatedUiContext({
+    opts,
+    throwIfWorkflowExitSelected: exit.throwIfWorkflowExitSelected,
+    durableUi: durableUiDeps,
+    baseFromPromptNodes: getPromptNodeUi
+  });
+  let pausedExit;
   const ctx = {
     inputs: resolvedInputs,
     runId,
     get cwd() {
       return resolveWorkflowCwd();
     },
-    exit: exit.exit,
-    ui: buildExitGatedUiContext({
-      opts,
-      throwIfWorkflowExitSelected: exit.throwIfWorkflowExitSelected,
-      durableUi: durableUiDeps,
-      baseFromPromptNodes: getPromptNodeUi
-    }),
-    stage: createDurableStagePrimitive({
-      workflowId: runId,
-      backend: durableBackend,
-      nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
-      durableIntercomGroup,
-      recordCachedStage: cachedStage.record,
-      stage: (name, options, replayKey) => {
-        const stage = runtime.stage(name, options);
-        const stageId = activeStore.runs().find((r) => r.id === runId)?.stages.at(-1)?.id;
-        if (stageId !== undefined)
-          completedStageReplayKeys.set(stageId, replayKey);
-        return stage;
+    exit: (options) => {
+      if (scheduler.isRunPaused()) {
+        pausedExit ??= whenRunning(async () => exit.exit(options));
+        pausedExit.catch(() => {});
+        throw new Error("Workflow exit is waiting for explicit resume");
       }
+      return exit.exit(options);
+    },
+    ui,
+    stage: (name, options) => {
+      ownController.signal.throwIfAborted();
+      if (!scheduler.isRunPaused())
+        return durableStage(name, options);
+      const replayKey = stageReplayKeyGenerator(name);
+      return deferStageUntilRunRelease({
+        name,
+        create: () => durableStage(name, options, replayKey),
+        isPaused: scheduler.isRunPaused,
+        waitForRelease: waitForRunRelease,
+        signal: ownController.signal
+      });
+    },
+    task: gatedTask,
+    chain: (...args) => whenRunning(() => chain(...args)),
+    parallel: (...args) => whenRunning(() => parallel(...args)),
+    workflow: (...args) => whenRunning(() => {
+      const pending = durableWorkflow(...args);
+      pendingChildWorkflows.add(pending);
+      const settled = () => {
+        pendingChildWorkflows.delete(pending);
+      };
+      pending.then(settled, settled);
+      return pending;
     }),
-    task: durableTask,
-    chain: createChainPrimitive({ runtime, task: durableTask }),
-    parallel: createParallelPrimitive({ runtime, task: durableTask }),
-    workflow: durableWorkflow,
-    tool,
+    tool: (...args) => {
+      if (!scheduler.isRunPaused())
+        return tool(...args);
+      const pending = whenRunning(() => tool(...args));
+      pending.catch(() => {});
+      return pending;
+    },
     ...opts.models !== undefined ? { models: opts.models } : {}
   };
+  const runtimeSettled = Promise.withResolvers();
+  let pausePersistence;
+  const persistRunControl = async (status) => {
+    ownController.signal.throwIfAborted();
+    if (opts.parentRun !== undefined || durableBackend.getWorkflow(runId) === undefined)
+      return;
+    if (!await transitionDurableWorkflowStatus(durableBackend, runId, ["running", "paused"], status, undefined, true)) {
+      throw new Error(`Workflow ${runId} refused the durable ${status} transition`);
+    }
+    recordRunTimingCheckpoint(durableBackend, runSnapshot);
+    await durableBackend.flush(runId);
+  };
+  const unregisterRunControl = toolControls.registerRun(runId, {
+    get paused() {
+      return scheduler.isRunPaused();
+    },
+    pause: () => {
+      ownController.signal.throwIfAborted();
+      scheduler.pauseRun();
+      activeStore.recordRunPaused(runId, undefined, { resumable: true });
+      pausePersistence = persistRunControl("paused");
+      return pausePersistence;
+    },
+    resume: async () => {
+      await pausePersistence;
+      await persistRunControl("running");
+      ownController.signal.throwIfAborted();
+      activeStore.recordRunResumed(runId, undefined, { source: "run_control" });
+      scheduler.releaseRun();
+    },
+    quit: () => {
+      ownController.abort(new WorkflowGracefulQuitError(runId, "workflow runtime"));
+      return runtimeSettled.promise;
+    }
+  });
   terminalEvents.register();
   try {
-    if (opts.deferWorkflowStart === true) {
-      await nextEventLoopTurn();
-      if (ownController.signal.aborted) {
-        await admittedTools.closeAndDrain();
-        const selectedExit = findWorkflowExitSignal(ownController.signal.reason, exitScope);
-        if (selectedExit !== undefined)
-          return await finalizers.finalizeWorkflowExit(selectedExit);
-        const parentExit = parentWorkflowExitAbortReason(ownController.signal.reason);
-        if (parentExit !== undefined)
-          return await finalizers.finalizeParentWorkflowExitCancellation(parentExit);
-        return finalizeKilled(runId, runSnapshot, activeStore, opts.persistence, opts.onRunEnd);
-      }
+    workflowObservationRuntime(activeStore).startRun(runId);
+    activeStore.recordRunStart(runSnapshot);
+    if (callerSignal?.aborted)
+      onCallerAbort();
+    else
+      callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+    if (ownsCancellationRegistration)
+      opts.cancellation?.register(runId, ownController);
+    opts.onRunStart?.(runSnapshot);
+    if (opts.persistence) {
+      appendRunStart(opts.persistence, {
+        runId,
+        name: def.name,
+        inputs: resolvedInputs,
+        ...runSnapshot.parentRunId !== undefined ? { parentRunId: runSnapshot.parentRunId } : {},
+        ...runSnapshot.parentStageId !== undefined ? { parentStageId: runSnapshot.parentStageId } : {},
+        ...runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {},
+        ...runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {},
+        ...runSnapshot.origin !== undefined ? { origin: runSnapshot.origin } : {},
+        ...runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {},
+        ...runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {},
+        ...runSnapshot.budget !== undefined ? { budget: runSnapshot.budget } : {},
+        ...runSnapshot.budgetState !== undefined ? { budgetState: runSnapshot.budgetState } : {},
+        ts: runSnapshot.startedAt
+      });
     }
-    await admitDurableRootRun({
+    if (opts.deferWorkflowStart === true)
+      await raceAbort2(nextEventLoopTurn(), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
+    await raceAbort2(admitDurableRootRun({
       backend: durableBackend,
       runId,
       isChildRun: opts.parentRun !== undefined,
@@ -18085,7 +18722,10 @@ async function run(def, inputs, opts = {}) {
         ...durableRootRegistration,
         ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache, runSnapshot.origin)
       }
-    });
+    }), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
     if (opts.deferWorkflowStart === true)
       opts.onWorkflowStartReady?.();
     const sourceFrontierStage = opts.continuation?.source;
@@ -18093,8 +18733,17 @@ async function run(def, inputs, opts = {}) {
     const startupFrontierStage = sourceFrontierStage?.stages.find((stage) => stage.id === sourceFrontierId)?.name ?? "workflow frontier";
     if (budget.enabled)
       await budget.stopAtBoundaryAsync(startupFrontierStage);
-    const rawResult = await runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx));
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
+    const rawResult = await raceAbort2(runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx)), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
     await admittedTools.closeAndDrain();
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    if (pausedExit !== undefined)
+      await pausedExit;
     budget.rethrowIfSystemOwnedStop(runSnapshot.stages.at(-1)?.name ?? startupFrontierStage);
     const normalTerminalEvent = terminalEvents.winner();
     if (normalTerminalEvent?.kind === "cancellation") {
@@ -18115,7 +18764,10 @@ async function run(def, inputs, opts = {}) {
     const result = normalizeWorkflowRunOutput(def.name, rawResult);
     assertWorkflowRunOutputs(def.name, result, def.outputs);
     assertWorkflowCreatedExecution(runSnapshot);
-    await durableBackend.flush(runId);
+    await raceAbort2(durableBackend.flush(runId), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
     const returned = classifyReturnedRunStatus(result, runSnapshot);
     if (returned.status === "completed")
       assertFrontierConsumed();
@@ -18135,12 +18787,26 @@ async function run(def, inputs, opts = {}) {
     durableBackend.setWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
     await durableBackend.flush(runId);
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: returned.status, result, error: returned.error }, opts.onRunEnd);
-  } catch (err) {
-    terminalEvents.selectFailure(err);
+  } catch (error) {
+    let err = error;
+    try {
+      while (scheduler.isRunPaused())
+        await waitForRunRelease();
+      if (pausedExit !== undefined)
+        await pausedExit;
+    } catch (stop) {
+      err = stop;
+    }
+    const selectedTerminalEvent = terminalEvents.selectFailure(err);
+    if (selectedTerminalEvent.kind === "failure" && ownController.signal.aborted && Object.is(err, ownController.signal.reason)) {
+      err = selectedTerminalEvent.error;
+    }
     const gracefulQuit = observedQuitCancellation() ?? observedTaskTailQuit ?? findWorkflowGracefulQuit(err) ?? findWorkflowGracefulQuit(ownController.signal.reason);
     if (gracefulQuit !== undefined)
       return suspendForGracefulQuit(gracefulQuit);
     await admittedTools.closeAndDrain();
+    if (ownController.signal.aborted)
+      await Promise.allSettled([...pendingChildWorkflows]);
     if (err instanceof WorkflowBudgetExceededError) {
       const pendingBudgetError = await budget.awaitPendingWrapUp();
       const selectedBudgetError = pendingBudgetError ?? err;
@@ -18173,15 +18839,15 @@ async function run(def, inputs, opts = {}) {
         return await finalizers.finalizeParentWorkflowExitCancellation(parentExit);
       return finalizeKilled(runId, runSnapshot, activeStore, opts.persistence, opts.onRunEnd);
     }
-    const failure2 = classifyExecutorFailure(err);
-    const selectedMetadata2 = normalizeFailureWinnerMetadata(normalizeStageLessFailureMetadata(selectRunFailureDisposition({
-      outerFailure: failure2,
+    const failure = classifyExecutorFailure(err);
+    const selectedMetadata = normalizeFailureWinnerMetadata(normalizeStageLessFailureMetadata(selectRunFailureDisposition({
+      outerFailure: failure,
       thrownError: err,
       stages: runSnapshot.stages,
       classifyFailure: classifyExecutorFailure
     }), runSnapshot.stages.length));
-    const failedToolNodeId = selectedMetadata2.failedStageId === undefined && selectedMetadata2.failureDisposition !== "terminal_killed" ? catchTerminalEvent?.kind === "failure" && Object.is(catchTerminalEvent.error, err) ? catchTerminalEvent.nodeId ?? observedAdmittedToolFailure?.nodeId : observedAdmittedToolFailure?.nodeId : undefined;
-    const metadata = failedToolNodeId === undefined ? selectedMetadata2 : { ...selectedMetadata2, failedToolNodeId };
+    const failedToolNodeId = selectedMetadata.failedStageId === undefined && selectedMetadata.failureDisposition !== "terminal_killed" ? catchTerminalEvent?.kind === "failure" && Object.is(catchTerminalEvent.error, err) ? catchTerminalEvent.nodeId ?? observedAdmittedToolFailure?.nodeId : observedAdmittedToolFailure?.nodeId : undefined;
+    const metadata = failedToolNodeId === undefined ? selectedMetadata : { ...selectedMetadata, failedToolNodeId };
     if (metadata.failureDisposition === "terminal_killed") {
       for (const failedStageId of metadata.failedStageIds)
         scheduler.blockKnownNonTerminalDescendants(failedStageId);
@@ -18209,6 +18875,10 @@ async function run(def, inputs, opts = {}) {
       onRunEnd: opts.onRunEnd
     });
   } finally {
+    callerSignal?.removeEventListener("abort", onCallerAbort);
+    workflowObservationRuntime(activeStore).finishRun(runId);
+    runtimeSettled.resolve();
+    unregisterRunControl();
     try {
       await finalizeDurableTerminalStatus({
         runId,
@@ -18246,45 +18916,45 @@ var NON_INTERACTIVE_WORKFLOW_POLICY = Object.freeze({
   allowInputPicker: false
 });
 // dist/builtin/workflows/src/workflows/registry.ts
-function makeRegistry(store2) {
+function makeRegistry(store) {
   return {
     register(definition) {
-      const next = new Map(store2);
+      const next = new Map(store);
       next.set(definition.normalizedName, definition);
       return makeRegistry(next);
     },
     merge(other) {
-      const next = new Map(store2);
+      const next = new Map(store);
       for (const def of other.all()) {
         next.set(def.normalizedName, def);
       }
       return makeRegistry(next);
     },
     get(name) {
-      return store2.get(normalizeWorkflowName(name));
+      return store.get(normalizeWorkflowName(name));
     },
     has(name) {
-      return store2.has(normalizeWorkflowName(name));
+      return store.has(normalizeWorkflowName(name));
     },
     remove(name) {
-      const key2 = normalizeWorkflowName(name);
-      if (!store2.has(key2))
+      const key = normalizeWorkflowName(name);
+      if (!store.has(key))
         return this;
-      const next = new Map(store2);
-      next.delete(key2);
+      const next = new Map(store);
+      next.delete(key);
       return makeRegistry(next);
     },
     names() {
-      return [...store2.keys()];
+      return [...store.keys()];
     },
     all() {
-      return [...store2.values()];
+      return [...store.values()];
     }
   };
 }
 function createRegistry(initial = []) {
-  const store2 = new Map(initial.map((d) => [d.normalizedName, d]));
-  return makeRegistry(store2);
+  const store = new Map(initial.map((d) => [d.normalizedName, d]));
+  return makeRegistry(store);
 }
 
 // dist/builtin/workflows/src/sdk-surface.ts