@bastani/atomic 0.9.18 → 0.9.19-alpha.10

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 === "pause") && 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 {
@@ -2955,6 +3156,7 @@ class StageUiBroker {
     };
   }
   requestCustomUi(runId, stageId, factory, options, signal) {
+    signal = options?.signal ? signal ? AbortSignal.any([signal, options.signal]) : options.signal : signal;
     if (signal?.aborted) {
       return Promise.reject(signal.reason ?? new Error("atomic-workflows: stage UI request aborted"));
     }
@@ -3265,8 +3467,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 +3665,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 +3683,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 +3709,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 +3735,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 +3793,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 +3828,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 +3857,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 +4040,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 +4157,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 +4196,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 +4351,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 +4396,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)
@@ -4628,6 +4831,7 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
     ...stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {},
     ...stage.durationMs !== undefined ? { durationMs: stage.durationMs } : {},
     ...stage.model !== undefined ? { model: stage.model } : {},
+    ...stage.thinkingLevel !== undefined ? { thinkingLevel: stage.thinkingLevel } : {},
     ...stage.attemptedModels !== undefined ? { attemptedModels: [...stage.attemptedModels] } : {},
     ...stage.modelAttempts !== undefined ? { modelAttempts: [...stage.modelAttempts] } : {},
     ...stage.structured !== undefined ? { structured: stage.structured } : {},
@@ -4637,7 +4841,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 +4971,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 +5139,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 +5198,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 +5253,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 +5316,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 +5379,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 +5440,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 +5469,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 +5643,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);
@@ -5553,6 +5809,7 @@ function completeTaskResult(name, base, checkpoint) {
     ...base.sessionFile !== undefined || checkpoint.sessionFile !== undefined ? { sessionFile: base.sessionFile ?? checkpoint.sessionFile } : {},
     ...base.artifacts !== undefined || checkpoint.artifacts !== undefined ? { artifacts: [...base.artifacts ?? checkpoint.artifacts ?? []] } : {},
     ...base.model !== undefined || checkpoint.model !== undefined ? { model: base.model ?? checkpoint.model } : {},
+    ...base.thinkingLevel !== undefined || checkpoint.thinkingLevel !== undefined ? { thinkingLevel: base.thinkingLevel ?? checkpoint.thinkingLevel } : {},
     ...base.attemptedModels !== undefined || checkpoint.attemptedModels !== undefined ? { attemptedModels: [...base.attemptedModels ?? checkpoint.attemptedModels ?? []] } : {},
     ...base.modelAttempts !== undefined || checkpoint.modelAttempts !== undefined ? { modelAttempts: [...base.modelAttempts ?? checkpoint.modelAttempts ?? []] } : {},
     ...base.warnings !== undefined || checkpoint.warnings !== undefined ? { warnings: [...base.warnings ?? checkpoint.warnings ?? []] } : {}
@@ -5653,6 +5910,7 @@ function taskCheckpointMetadata(result) {
     ...result.sessionId !== undefined ? { sessionId: result.sessionId } : {},
     ...result.sessionFile !== undefined ? { sessionFile: result.sessionFile } : {},
     ...result.model !== undefined ? { model: result.model } : {},
+    ...result.thinkingLevel !== undefined ? { thinkingLevel: result.thinkingLevel } : {},
     ...result.attemptedModels !== undefined ? { attemptedModels: [...result.attemptedModels] } : {},
     ...result.modelAttempts !== undefined ? { modelAttempts: [...result.modelAttempts] } : {},
     ...result.structured !== undefined ? { structured: result.structured } : {},
@@ -5682,6 +5940,7 @@ function mergeCheckpointHydrationMetadata(replayValueCheckpoint, checkpoints) {
     ...replayValueCheckpoint.sessionId === undefined ? metadataValue(checkpoints, "sessionId") : {},
     ...replayValueCheckpoint.sessionFile === undefined ? metadataValue(checkpoints, "sessionFile") : {},
     ...replayValueCheckpoint.model === undefined ? metadataValue(checkpoints, "model") : {},
+    ...replayValueCheckpoint.thinkingLevel === undefined ? metadataValue(checkpoints, "thinkingLevel") : {},
     ...replayValueCheckpoint.attemptedModels === undefined ? metadataValue(checkpoints, "attemptedModels") : {},
     ...replayValueCheckpoint.modelAttempts === undefined ? metadataValue(checkpoints, "modelAttempts") : {},
     ...replayValueCheckpoint.structured === undefined ? metadataValue(checkpoints, "structured") : {},
@@ -5702,11 +5961,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 +6000,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);
@@ -5771,22 +6030,23 @@ function recordCachedStageIntoStore(store2, runId, name, replayKey, output, comp
     ...checkpoint?.sessionId !== undefined ? { sessionId: checkpoint.sessionId } : {},
     ...checkpoint?.sessionFile !== undefined ? { sessionFile: checkpoint.sessionFile } : {},
     ...checkpoint?.model !== undefined ? { model: checkpoint.model } : {},
+    ...checkpoint?.thinkingLevel !== undefined ? { thinkingLevel: checkpoint.thinkingLevel } : {},
     ...checkpoint?.attemptedModels !== undefined ? { attemptedModels: checkpoint.attemptedModels } : {},
     ...checkpoint?.modelAttempts !== undefined ? { modelAttempts: checkpoint.modelAttempts } : {},
     ...checkpoint?.structured !== undefined ? { structured: checkpoint.structured } : {},
     ...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 +6057,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 +6727,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 +6805,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 +6840,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 +7072,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 +7578,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 +7902,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 +8283,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 +8433,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 +8659,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 +8765,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 +9038,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 +9092,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 +9116,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 +9216,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 +9300,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 +9358,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 +9387,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 +9805,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 +9836,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 +9856,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 +9917,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 +9983,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 +10013,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 +10135,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 +10159,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 +10446,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() {
@@ -10187,7 +10468,25 @@ class ConcurrencyLimiter {
   }
 }
 function createRunLimiter(defaultConcurrency) {
-  return new ConcurrencyLimiter(defaultConcurrency ?? 4);
+  return new ConcurrencyLimiter(defaultConcurrency ?? 3);
+}
+
+// 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
@@ -10234,11 +10533,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 +10663,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 +10689,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 +10747,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 +10759,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 +10778,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 +10789,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 +10807,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 +10890,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 +10998,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 +11043,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;
       }
     });
   };
@@ -10791,6 +11090,7 @@ function createTaskPrimitive(runtime) {
         ...sessionId !== undefined ? { sessionId } : {},
         ...stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {},
         ...stageMeta.model !== undefined ? { model: stageMeta.model } : {},
+        ...stageMeta.thinkingLevel !== undefined ? { thinkingLevel: stageMeta.thinkingLevel } : {},
         ...stageMeta.attemptedModels !== undefined ? { attemptedModels: stageMeta.attemptedModels } : {},
         ...stageMeta.modelAttempts !== undefined ? { modelAttempts: stageMeta.modelAttempts } : {},
         ...stageMeta.warnings !== undefined ? { warnings: stageMeta.warnings } : {}
@@ -10896,6 +11196,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 +11217,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 +11238,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 +11259,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 +11280,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 +11314,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 +11589,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 +11608,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 +11620,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 +11877,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) {
@@ -11616,17 +11932,18 @@ function mergeStageDraft(existing, checkpoint, sequence) {
     ...valueOrExisting("endedAt", checkpoint, existing),
     ...valueOrExisting("durationMs", checkpoint, existing),
     ...valueOrExisting("model", checkpoint, existing),
+    ...valueOrExisting("thinkingLevel", checkpoint, existing),
     ...valueOrExisting("attemptedModels", checkpoint, existing),
     ...valueOrExisting("modelAttempts", checkpoint, existing),
     ...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 +12019,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 +12028,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 +12230,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 +12262,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 +12276,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,
@@ -12012,6 +12329,7 @@ function stageSnapshotFromDraft(draft, id, parentIds) {
     ...draft.sessionId !== undefined ? { sessionId: draft.sessionId } : {},
     ...draft.sessionFile !== undefined ? { sessionFile: draft.sessionFile } : {},
     ...draft.model !== undefined ? { model: draft.model } : {},
+    ...draft.thinkingLevel !== undefined ? { thinkingLevel: draft.thinkingLevel } : {},
     ...draft.attemptedModels !== undefined ? { attemptedModels: draft.attemptedModels } : {},
     ...draft.modelAttempts !== undefined ? { modelAttempts: draft.modelAttempts } : {}
   };
@@ -12068,7 +12386,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 +12400,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 +12460,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 +12541,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 +12557,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 +12595,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 +12622,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 +12757,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 +12778,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 +12832,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 +12891,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 +12916,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 +12925,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 +12959,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 +12967,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
         return { accepted: false, error, bindNode() {}, noteCancelled() {} };
       }
       const admission = {
-        admissionOrder: ++nextAdmissionOrder2,
+        admissionOrder: ++nextAdmissionOrder,
         nodeId: undefined,
         failure: undefined,
         cancelled: false,
@@ -12644,7 +13027,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 +13035,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 +13054,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 +13067,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 +13101,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);
@@ -13046,21 +13430,17 @@ function throwFinalizationError(error) {
 function createTrackedStageCaller(input) {
   const { runtime } = input;
   const readinessGateEnabled = runtime.opts.confirmStageReadiness !== undefined || runtime.opts.usePromptNodesForUi === true;
-  const confirmReadiness = async () => {
-    try {
-      if (runtime.opts.confirmStageReadiness !== undefined) {
-        const ready = await runtime.opts.confirmStageReadiness({
-          runId: runtime.runId,
-          stageId: runtime.stageId,
-          stageName: runtime.name,
-          signal: runtime.signal
-        });
-        return ready ? { action: "advance" } : { action: "stay" };
-      }
-      return await askReadinessViaStageBroker(runtime.runId, runtime.stageId, runtime.signal);
-    } catch {
-      return { action: "advance" };
-    }
+  const confirmReadiness = async (signal) => {
+    if (runtime.opts.confirmStageReadiness !== undefined) {
+      const ready = await raceAbort(runtime.opts.confirmStageReadiness({
+        runId: runtime.runId,
+        stageId: runtime.stageId,
+        stageName: runtime.name,
+        signal
+      }), signal);
+      return ready ? { action: "advance" } : { action: "stay" };
+    }
+    return await askReadinessViaStageBroker(runtime.runId, runtime.stageId, signal);
   };
   const suppressReadinessForCurrentTurn = () => {
     runtime.state.askUserQuestionObservedThisTurn = false;
@@ -13102,7 +13482,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,30 +13587,56 @@ 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 {
             while (runtime.state.askUserQuestionObservedThisTurn || repeatReadinessAfterChatTurn) {
-              const decision = await confirmReadiness();
+              runtime.signal.throwIfAborted();
+              if (runtime.stageSnapshot.status === "paused" || runtime.stageSnapshot.status === "blocked") {
+                await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                continue;
+              }
+              const controller = new AbortController;
+              runtime.state.readinessController = controller;
+              let decision;
+              try {
+                decision = await confirmReadiness(AbortSignal.any([runtime.signal, controller.signal]));
+                if (decision.action === "advance" || decision.message !== undefined) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                }
+                runtime.signal.throwIfAborted();
+                if (controller.signal.aborted) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                  continue;
+                }
+              } catch (error) {
+                runtime.signal.throwIfAborted();
+                if (controller.signal.aborted) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                  continue;
+                }
+                throw error;
+              }
               if (decision.action === "advance")
                 break;
+              delete runtime.state.readinessController;
               if (runtime.signal.aborted)
                 break;
               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 +13676,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 +13707,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 +13735,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,12 +13762,20 @@ 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?.();
         try {
+          if (terminalStateIsSuccess && runtime.state.readinessController !== undefined) {
+            let pauseVersion;
+            do {
+              pauseVersion = runtime.state.readinessPauseVersion;
+              await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+            } while (pauseVersion !== runtime.state.readinessPauseVersion);
+            runtime.signal.throwIfAborted();
+          }
+          if (!runtime.state.stageFinalized)
+            applyTerminalStageState?.();
           await runtime.finalizeStageSnapshot();
         } catch (err) {
           finalizationError ??= { thrown: true, error: err };
@@ -13377,6 +13793,9 @@ function createTrackedStageCaller(input) {
       input.limiter.release();
       if (finalizationError !== undefined)
         throwFinalizationError(finalizationError.error);
+      delete runtime.state.readinessController;
+      if (terminalStateIsSuccess && readinessGateEnabled)
+        runtime.signal.throwIfAborted();
     }
   };
 }
@@ -13613,8 +14032,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) {
@@ -13737,15 +14156,29 @@ function createStageControlHandle(runtime) {
     async pause() {
       runtime.throwIfStageMutationBlocked();
       const statusBeforePause = runtime.stageSnapshot.status;
+      let readinessPauseVersion;
+      if (runtime.state.readinessController !== undefined) {
+        runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
+        readinessPauseVersion = (runtime.state.readinessPauseVersion ?? 0) + 1;
+        runtime.state.readinessPauseVersion = readinessPauseVersion;
+      }
       if (statusBeforePause === "pending" || statusBeforePause === "running" || runtime.innerCtx.isStreaming) {
-        await runtime.innerCtx.__requestPause();
+        try {
+          await runtime.innerCtx.__requestPause();
+        } catch (error) {
+          if (readinessPauseVersion !== undefined && runtime.state.readinessPauseVersion === readinessPauseVersion && runtime.stageSnapshot.status !== "paused" && runtime.stageSnapshot.status !== "blocked" && !runtime.scheduler.hasCascadePauseOwners(runtime.stageId)) {
+            runtime.scheduler.releaseStageBarrier(runtime.stageId);
+          }
+          throw error;
+        }
       }
       const changed = runtime.activeStore.recordStagePaused(runtime.runId, runtime.stageId);
       if (changed) {
         runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
+        runtime.state.readinessController?.abort(new Error("atomic-workflows: readiness paused"));
         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 +14245,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 +14315,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"),
@@ -13905,7 +14340,7 @@ function createReplayStageContext(input) {
       return replaySource.model;
     },
     get thinkingLevel() {
-      return;
+      return replaySource.thinkingLevel;
     },
     get messages() {
       return [];
@@ -13931,6 +14366,7 @@ function createReplayStageContext(input) {
     __pendingMessageCount: () => 0,
     __modelFallbackMeta: () => ({
       ...replaySource.model !== undefined ? { model: replaySource.model } : {},
+      ...replaySource.thinkingLevel !== undefined ? { thinkingLevel: replaySource.thinkingLevel } : {},
       ...replaySource.attemptedModels !== undefined ? { attemptedModels: replaySource.attemptedModels } : {},
       ...replaySource.modelAttempts !== undefined ? { modelAttempts: replaySource.modelAttempts } : {}
     }),
@@ -13943,13 +14379,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 +14408,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 +14502,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 +14561,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 +14618,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 +14662,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 +14680,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 +14757,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 +14866,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 +14962,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 +15250,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 +15287,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 +15295,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 +15370,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 +15404,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,
@@ -14969,7 +15505,8 @@ class StageSessionPause {
       abortBoundary: Promise.withResolvers(),
       runnerOwnedDeliveries: new Set,
       confirmed: false,
-      ...nativeQueuePause === undefined ? {} : { nativeQueuePause }
+      ...nativeQueuePause === undefined ? {} : { nativeQueuePause },
+      ...session?.pauseTasks && session.resumeTasks ? { taskControl: session } : {}
     };
     request.deferred.promise.catch(() => {});
     request.abortBoundary.promise.catch(() => {});
@@ -14977,7 +15514,11 @@ class StageSessionPause {
     let failed = false;
     try {
       request.nativeQueuePause?.pauseQueuedMessages();
-      await session?.abort();
+      const tasks = request.taskControl?.pauseTasks?.();
+      const settled = await Promise.allSettled([tasks, (async () => session?.abort())()]);
+      for (const result of settled)
+        if (result.status === "rejected")
+          throw result.reason;
       request.abortBoundary.resolve();
       await request.abortBoundary.promise;
       request.confirmed = true;
@@ -14985,6 +15526,7 @@ class StageSessionPause {
       failed = true;
       request.abortBoundary.reject(error);
       request.deferred.reject(error);
+      request.taskControl?.resumeTasks?.();
       await this.rollbackNativePause(request.nativeQueuePause);
       throw error;
     } finally {
@@ -15052,6 +15594,7 @@ class StageSessionPause {
       if (releaseAdmitted)
         return;
       beforeRelease?.();
+      request.taskControl?.resumeTasks?.();
       releaseAdmitted = true;
     };
     let releasedQueuedMessages;
@@ -15106,16 +15649,37 @@ function stageSessionExtensionRunner(current) {
   }
   return;
 }
+var shutdowns = new WeakMap;
+function shutdownStageSession(current) {
+  if (!current)
+    return Promise.resolve();
+  const existing = shutdowns.get(current);
+  if (existing)
+    return existing;
+  const shutdown = Promise.resolve().then(async () => {
+    const runner = stageSessionExtensionRunner(current);
+    if (runner?.hasHandlers("session_shutdown"))
+      await runner.emit({ type: "session_shutdown", reason: "quit" });
+  });
+  shutdowns.set(current, shutdown);
+  return shutdown;
+}
+
+class StageSessionBindingCleanupFailure extends AggregateError {
+  constructor(bindingError, cleanupErrors) {
+    super([bindingError, ...cleanupErrors], "atomic-workflows: failed binding cleanup did not release session ownership", {
+      cause: bindingError
+    });
+    this.name = "StageSessionBindingCleanupFailure";
+  }
+}
 async function disposeStageSession(current) {
   if (!current)
     return;
-  const runner = stageSessionExtensionRunner(current);
-  if (runner?.hasHandlers("session_shutdown")) {
-    try {
-      await runner.emit({ type: "session_shutdown", reason: "quit" });
-    } catch (error) {
-      console.error("atomic-workflows: stage session_shutdown handler failed", error);
-    }
+  try {
+    await shutdownStageSession(current);
+  } catch (error) {
+    console.error("atomic-workflows: stage session_shutdown handler failed", error);
   }
   await current.dispose();
 }
@@ -15148,6 +15712,9 @@ async function rejectDisposedCreatedSession(result, stageName) {
 class StageSessionReplacement {
   previous;
   cleanups = new Set;
+  get retiringSession() {
+    return this.previous;
+  }
   retire(session) {
     this.previous = session;
   }
@@ -15227,30 +15794,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")
@@ -15508,6 +16076,8 @@ class StageSessionController {
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
+  sessionShutdownPromise;
+  bindingCleanupFailure;
   reattachSessionFile;
   lastPromptStartIndex;
   attemptUsageStartIndex;
@@ -15531,7 +16101,7 @@ class StageSessionController {
   pendingThinkingLevel;
   pendingListeners = new Set;
   listenerUnsubscribes = new Map;
-  pauseControl = new StageSessionPause(() => this.session);
+  pauseControl = new StageSessionPause(() => this.session ?? this.replacement.retiringSession);
   hasExplicitModelFallbackConfig;
   candidatesPromise;
   activeCandidateIndex;
@@ -15550,9 +16120,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;
@@ -15608,8 +16194,7 @@ class StageSessionController {
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${error}. Retrying with ${candidateLabel(nextCandidate)}.`);
     this.modelWarnings.push(...this.pendingFallbackWarnings);
     this.pendingFallbackWarnings.length = 0;
-    await this.disposeCurrentSession();
-    this.activeCandidateIndex = index + 1;
+    await this.disposeCurrentSession(index + 1);
     this.notifyModelFallbackMetaChange();
     return true;
   }
@@ -15637,6 +16222,14 @@ class StageSessionController {
     this.session?.setThinkingLevel(level);
   }
   async ensureSession(consumer = "prompt") {
+    if (this.bindingCleanupFailure !== undefined)
+      throw this.bindingCleanupFailure;
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      await this.sessionShutdownPromise;
+      if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+        throw this.staleCreationReason(generation);
+    }
     if (this.disposed)
       throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
     if (this.session !== undefined)
@@ -15651,14 +16244,16 @@ class StageSessionController {
       };
       pending.then(release, () => {
         release();
-        if (this.sessionPromise === pending)
+        if (this.sessionPromise === pending) {
           this.sessionPromise = undefined;
+          this.activeCandidateIndex = undefined;
+        }
       });
     }
     return this.sessionPromise;
   }
   async ensureSessionFromFile(sessionFile, consumer = "prompt") {
-    if (!this.sessionPromise && !this.session)
+    if (!this.sessionShutdownPromise && !this.sessionPromise && !this.session)
       this.reattachSessionFile = sessionFile;
     const session = await this.ensureSession(consumer);
     await session.closeWorkflowStageGeneration?.();
@@ -15675,10 +16270,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 +16295,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 +16324,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;
@@ -15753,6 +16351,18 @@ class StageSessionController {
       return;
     let index = this.activeCandidateIndex ?? 0;
     while (index < candidates.length) {
+      if (this.session === undefined && this.ownedCreationPromise !== undefined) {
+        try {
+          await this.ownedCreationPromise;
+        } catch (error) {
+          if (error instanceof StageSessionCreationCancelled)
+            return;
+          throw error;
+        }
+        index = this.activeCandidateIndex ?? index;
+        promptText = this.pendingCreationResumeMessage ?? promptText;
+        this.pendingCreationResumeMessage = undefined;
+      }
       const candidate = candidates[index];
       try {
         const created = this.session && this.activeCandidateIndex === index ? this.session : await this.createSessionWithThrownErrorRetry(candidate, consumer);
@@ -15779,10 +16389,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;
       }
@@ -15791,8 +16401,10 @@ class StageSessionController {
   currentModelFallbackMeta() {
     const attemptedModels = this.modelAttempts.map((attempt) => attempt.model);
     const model = this.selectedModel ?? workflowModelId(this.session?.model);
+    const thinkingLevel = this.session?.thinkingLevel ?? this.pendingThinkingLevel;
     return {
       ...model !== undefined ? { model } : {},
+      ...thinkingLevel !== undefined ? { thinkingLevel } : {},
       ...attemptedModels.length > 0 ? { attemptedModels } : {},
       ...this.modelAttempts.length > 0 ? { modelAttempts: [...this.modelAttempts] } : {},
       ...this.modelWarnings.length > 0 ? { warnings: [...this.modelWarnings] } : {}
@@ -15876,14 +16488,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 +16635,7 @@ class StageSessionController {
     let retainedPrompt;
     let terminalScanStartIndex;
     while (true) {
+      this.artifactCapture.beginAttempt(activeSession);
       const messagesBeforeAttempt = [...activeSession.messages];
       try {
         if (retryAdmittedPrompt) {
@@ -16065,6 +16678,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)
@@ -16140,7 +16754,8 @@ class StageSessionController {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
     const candidates = await this.modelCandidates();
-    const first = candidates[0];
+    const initialIndex = this.activeCandidateIndex ?? 0;
+    const first = candidates[initialIndex];
     if (first === undefined) {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
@@ -16153,9 +16768,9 @@ class StageSessionController {
       this.resumeCurrentSession = true;
       return resumed;
     }
-    this.activeCandidateIndex = 0;
+    this.activeCandidateIndex = initialIndex;
     this.selectedModel = first.id;
-    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, 0, { error }));
+    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, initialIndex, { error }));
   }
   async createInitialSessionCandidateWalk(candidates, consumer, startIndex, initialFailure) {
     let index = startIndex;
@@ -16231,12 +16846,14 @@ 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) {
+        if (error instanceof StageSessionBindingCleanupFailure)
+          throw error;
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
@@ -16270,6 +16887,20 @@ class StageSessionController {
     }
   }
   createSession(candidate, consumer, resumeOptions) {
+    if (this.bindingCleanupFailure !== undefined)
+      return Promise.reject(this.bindingCleanupFailure);
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      return this.sessionShutdownPromise.then(() => {
+        if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+          throw this.staleCreationReason(generation);
+        return this.createSession(candidate, consumer, resumeOptions);
+      });
+    }
+    if (this.activeCreation !== undefined)
+      return this.activeCreation;
+    if (this.session !== undefined)
+      return Promise.resolve(this.session);
     const creation = this.createSessionAttempt(candidate, consumer, resumeOptions);
     this.activeCreation = creation;
     creation.finally(() => {
@@ -16296,6 +16927,10 @@ class StageSessionController {
         ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
       }) : missingAdapter(consumer);
     } catch (error) {
+      if (error instanceof StageSessionBindingCleanupFailure) {
+        this.bindingCleanupFailure = error;
+        throw error;
+      }
       if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
         throw this.disposed ? new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`) : this.staleCreationReason(startGeneration);
       throw error;
@@ -16350,6 +16985,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);
@@ -16358,12 +16994,16 @@ class StageSessionController {
     });
     return result.session;
   }
-  async disposeCurrentSession() {
+  async disposeCurrentSession(nextCandidateIndex) {
+    if (this.sessionShutdownPromise !== undefined)
+      await this.sessionShutdownPromise;
+    const startGeneration = this.abortGeneration;
     this.abortThrownErrorRetries(new Error(`atomic-workflows: stage "${this.opts.stageName}" session was replaced`));
     const current = this.session;
     this.messageAdmission.reset();
     this.replacement.retire(current);
     this.session = undefined;
+    this.activeCandidateIndex = nextCandidateIndex;
     if (this.sessionPromise !== this.ownedCreationPromise)
       this.sessionPromise = undefined;
     this.sessionSettingsManager = undefined;
@@ -16374,6 +17014,15 @@ class StageSessionController {
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = undefined;
     this.terminatingToolCallIds.clear();
+    const shutdown = Promise.resolve().then(() => shutdownStageSession(current));
+    this.sessionShutdownPromise = shutdown;
+    shutdown.then(() => {
+      if (this.sessionShutdownPromise === shutdown)
+        this.sessionShutdownPromise = undefined;
+    }, () => {});
+    await shutdown;
+    if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
+      throw this.staleCreationReason(startGeneration);
   }
   async promptWithPauseResume(activeSession, initialText, sdkOptions) {
     let nextText = initialText;
@@ -16433,6 +17082,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 +17097,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({
@@ -16480,18 +17132,20 @@ class StageSessionController {
         throw err;
       }
       this.pendingFallbackWarnings.push(resumedOverflowNextIndex === undefined ? `[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${candidateLabel(candidates[0])}.` : `[fallback] resume on ${resumedLabel} failed: ${message}. Retrying with ${candidateLabel(candidates[resumedOverflowNextIndex])}.`);
-      await this.disposeCurrentSession();
-      this.activeCandidateIndex = resumedOverflowNextIndex;
+      await this.disposeCurrentSession(resumedOverflowNextIndex);
       return false;
     }
   }
   async handleCandidateFailure(err, candidate, candidates, index) {
+    if (err instanceof StageSessionBindingCleanupFailure)
+      throw err;
     const message = errorMessage2(err);
     const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
     if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
+    this.artifactCapture.settleAttempt(false);
     const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
@@ -16508,13 +17162,14 @@ class StageSessionController {
     }
     const nextCandidate = candidates[index + 1];
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${message}. Retrying with ${candidateLabel(nextCandidate)}.`);
-    await this.disposeCurrentSession();
+    await this.disposeCurrentSession(index + 1);
     return "retry";
   }
   capturedStructuredOutputForAttempt() {
     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 +17377,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 +17423,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 +17432,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 +17473,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 +17531,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 +17617,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 +17648,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 +17687,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 +17704,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 +17732,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 +17748,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]);
     }
   };
@@ -17111,6 +17809,8 @@ function createWorkflowStageFactory(input) {
         ...replaySource.result !== undefined ? { result: replaySource.result } : {},
         ...replaySource.sessionId !== undefined ? { sessionId: replaySource.sessionId } : {},
         ...replaySource.sessionFile !== undefined ? { sessionFile: replaySource.sessionFile } : {},
+        ...replaySource.model !== undefined ? { model: replaySource.model } : {},
+        ...replaySource.thinkingLevel !== undefined ? { thinkingLevel: replaySource.thinkingLevel } : {},
         replayedFromStageId: replaySource.id,
         replayed: true
       } : {},
@@ -17132,16 +17832,20 @@ 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.thinkingLevel !== undefined)
+        stageSnapshot.thinkingLevel = meta.thinkingLevel;
+      else
+        delete stageSnapshot.thinkingLevel;
+      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 +17873,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 +17946,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 +18292,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 +18320,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 +18333,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 +18352,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 +18394,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 +18430,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 +18452,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 +18591,7 @@ async function run(def, inputs, opts = {}) {
   };
   const taskRunners = createWorkflowTaskRunners({ runtime });
   let pendingChildDurableInvocation;
-  const workflow2 = createChildWorkflowRunner({
+  const workflow = createChildWorkflowRunner({
     runtime,
     resolveWorkflowCwd,
     nextWorkflowBoundaryReplayKey,
@@ -17974,6 +18664,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 +18681,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 +18696,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 +18722,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 +18876,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 +18887,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 +18918,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 +18941,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 +18993,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 +19029,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 +19070,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