@bastani/atomic 0.9.19-alpha.1 → 0.9.19-alpha.3

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

@@ -302,7 +302,7 @@ function createSessionScopedSingleton(key, createLocal) {
   const live = () => shared.instance ?? instance;
   const current = () => live();
   const adoptWithResult = (scope, options) => {
-    const current2 = live();
+    const current = live();
     let targetCreated = false;
     const target = sessionScopedExtensionState(scope, key, () => {
       targetCreated = true;
@@ -311,8 +311,8 @@ function createSessionScopedSingleton(key, createLocal) {
       shared.localClaimed = true;
       return shared.local;
     });
-    const preservedCurrent = !targetCreated && target !== current2 && options?.preserveCurrentWhenTargetExists?.(current2, target) === true;
-    shared.instance = preservedCurrent ? current2 : target;
+    const preservedCurrent = !targetCreated && target !== current && options?.preserveCurrentWhenTargetExists?.(current, target) === true;
+    shared.instance = preservedCurrent ? current : target;
     instance = shared.instance;
     return { instance: shared.instance, preservedCurrent };
   };
@@ -569,17 +569,17 @@ function cloneWorkflowExitSnapshotValue(value, seen, stack = new Set) {
     return stack.has(objectValue) ? makeWorkflowExitSnapshotInvalidValue("circular object") : previousClone;
   }
   if (Array.isArray(value)) {
-    const clone2 = [];
-    seen.set(objectValue, clone2);
+    const clone = [];
+    seen.set(objectValue, clone);
     stack.add(objectValue);
     try {
       for (let index = 0;index < value.length; index += 1) {
-        clone2[index] = cloneWorkflowExitSnapshotValue(value[index], seen, stack);
+        clone[index] = cloneWorkflowExitSnapshotValue(value[index], seen, stack);
       }
     } finally {
       stack.delete(objectValue);
     }
-    return clone2;
+    return clone;
   }
   if (!isPlainWorkflowExitSnapshotObject(objectValue)) {
     return makeWorkflowExitSnapshotInvalidValue(workflowSerializableTypeName(value));
@@ -952,7 +952,7 @@ function buildStagePromptAdapter(id, kind, args, createdAt) {
 }
 
 // dist/builtin/workflows/src/shared/stage-ui-broker.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/pending-stage-delivery.ts
 var PENDING_STAGE_MESSAGE_LIMIT = 50;
@@ -963,7 +963,7 @@ function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity
   }
   const messageId = input.message.id;
   const queued = pendingStageMessagesFor(messages, input.runId, input.stageKey, stageIdentity);
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing, stageIdentity) !== pendingStageMessageSignature(input, stageIdentity)) {
       return {
@@ -1013,7 +1013,7 @@ function queueStickyStageMessage(messages, input, senderGroup, runGroup) {
     return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.targetPath };
   }
   const messageId = input.message.id;
-  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  const existing = messages.find((entry) => entry.runId === input.runId && entry.id === messageId);
   if (existing !== undefined) {
     if (pendingStageMessageSignature(existing) !== pendingStageMessageSignature(input)) {
       return {
@@ -1064,7 +1064,7 @@ function queuedStickyCount(messages, runId, targetPath) {
   return messages.filter((entry) => entry.runId === runId && entry.sticky === true && entry.targetPath === targetPath && entry.status === "queued").length;
 }
 function recordPendingStageMessageDeliveries(messages, runId, messageId, records, deliveredAt) {
-  const index = messages.findIndex((entry2) => entry2.runId === runId && entry2.id === messageId && entry2.sticky === true && entry2.status === "queued");
+  const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued");
   if (index < 0)
     return messages;
   const entry = messages[index];
@@ -1507,6 +1507,7 @@ function compactStage(stage) {
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
+    structured: _structured,
     ...metadata
   } = stage;
   return {
@@ -1565,6 +1566,173 @@ function deepFreezeGraphValue(value) {
   }
 }
 
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+import { randomUUID } from "node:crypto";
+
+// dist/builtin/workflows/src/shared/workflow-activity.ts
+function workflowActivityNodeKey(runId, nodeId) {
+  return `${runId}:${nodeId}`;
+}
+
+// dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
+class WorkflowObservationRuntime {
+  runs;
+  invalidate;
+  liveRunIds = new Set;
+  executingStageIds = new Set;
+  executingToolNodeIds = new Set;
+  stoppingRunIds = new Set;
+  retryingStageIds = new Set;
+  acknowledgedFailureRunIds = new Set;
+  listeners = new Set;
+  replayStageIds = new Set;
+  previous = new Map;
+  recoveryDepth = 0;
+  constructor(runs, invalidate) {
+    this.runs = runs;
+    this.invalidate = invalidate;
+  }
+  get recovering() {
+    return this.recoveryDepth > 0;
+  }
+  startRun(runId) {
+    this.liveRunIds.add(runId);
+    this.stoppingRunIds.delete(runId);
+  }
+  finishRun(runId) {
+    this.liveRunIds.delete(runId);
+    this.stoppingRunIds.delete(runId);
+    for (const ids of [
+      this.executingStageIds,
+      this.executingToolNodeIds,
+      this.retryingStageIds,
+      this.replayStageIds
+    ]) {
+      for (const id of ids)
+        if (id.startsWith(`${runId}:`))
+          ids.delete(id);
+    }
+    this.invalidate();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  rootRunId(run) {
+    if (run.rootRunId !== undefined)
+      return run.rootRunId;
+    if (run.parentRunId === undefined)
+      return run.id;
+    const parent = this.runs().find((candidate) => candidate.id === run.parentRunId);
+    return parent ? this.rootRunId(parent) : run.parentRunId;
+  }
+  lifecycle(target, attribution = "unknown") {
+    if (this.recovering && !this.liveRunIds.has(target.runId))
+      return;
+    const run = this.runs().find((candidate) => candidate.id === target.runId);
+    if (!run)
+      return;
+    const rootRunId = this.rootRunId(run);
+    const now = Date.now();
+    this.emit({
+      kind: "lifecycle",
+      event: {
+        type: "workflow_lifecycle",
+        eventId: randomUUID(),
+        runId: run.id,
+        rootRunId,
+        occurredAt: now,
+        observedAt: now,
+        target: canonicalTarget(target, rootRunId),
+        attribution,
+        delivery: target.kind === "stage" && this.replayStageIds.has(workflowActivityNodeKey(run.id, target.stageId)) ? "replay" : "live"
+      }
+    });
+  }
+  control(runId, action, attribution = "unknown") {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (!run)
+      return;
+    if ((action === "quit" || action === "kill" || action === "interrupt") && this.liveRunIds.has(runId))
+      this.stoppingRunIds.add(runId);
+    if (action === "resume")
+      this.stoppingRunIds.delete(runId);
+    this.lifecycle({ kind: "run", runId, status: run.status, action }, attribution);
+    this.invalidate();
+  }
+  heartbeat(runId, scheduledAt, intervalMinutes) {
+    const run = this.runs().find((candidate) => candidate.id === runId);
+    if (run)
+      this.emit({
+        kind: "heartbeat",
+        event: { type: "workflow_heartbeat", runId, rootRunId: this.rootRunId(run), scheduledAt, intervalMinutes }
+      });
+  }
+  beginRecovery() {
+    this.recoveryDepth++;
+    if (this.recoveryDepth === 1)
+      this.emit({ kind: "availability" });
+    let ended = false;
+    return () => {
+      if (ended)
+        return;
+      ended = true;
+      this.capture();
+      this.recoveryDepth--;
+      if (!this.recovering)
+        this.emit({ kind: "availability" });
+    };
+  }
+  capture() {
+    const next = new Map;
+    const visit = (key, target, historical = false) => {
+      next.set(key, target);
+      const previous = this.previous.get(key);
+      if (!historical && this.liveRunIds.has(target.runId) && previous?.status !== target.status) {
+        this.lifecycle(previous && previous.kind !== "prompt" && target.kind !== "prompt" ? { ...target, previousStatus: previous.status } : target, this.runs().find((run) => run.id === target.runId)?.origin);
+      }
+    };
+    for (const run of this.runs()) {
+      const existing = this.previous.has(`run:${run.id}`);
+      visit(`run:${run.id}`, { kind: "run", runId: run.id, status: run.status });
+      for (const stage of run.stages) {
+        visit(`stage:${workflowActivityNodeKey(run.id, stage.id)}`, { kind: "stage", runId: run.id, stageId: stage.id, stageName: stage.name, status: stage.status }, !existing);
+        if (stage.pendingPrompt)
+          visit(`prompt:${stage.pendingPrompt.id}`, {
+            kind: "prompt",
+            runId: run.id,
+            stageId: stage.id,
+            promptId: stage.pendingPrompt.id,
+            status: "opened"
+          }, !existing);
+      }
+      for (const tool of run.toolNodes ?? [])
+        visit(`tool:${workflowActivityNodeKey(run.id, tool.id)}`, { kind: "tool", runId: run.id, toolNodeId: tool.id, toolName: tool.name, status: tool.status }, !existing);
+      if (run.pendingPrompt)
+        visit(`prompt:${run.pendingPrompt.id}`, { kind: "prompt", runId: run.id, promptId: run.pendingPrompt.id, status: "opened" }, !existing);
+    }
+    this.previous = next;
+  }
+}
+var workflowObservationRuntimeKey = Symbol.for("atomic-workflows/store-observation-runtime@1");
+function canonicalTarget(target, rootRunId) {
+  if (target.runId === rootRunId)
+    return target;
+  switch (target.kind) {
+    case "stage":
+      return { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "tool":
+      return { ...target, toolNodeId: workflowActivityNodeKey(target.runId, target.toolNodeId) };
+    case "prompt":
+      return target.stageId === undefined ? target : { ...target, stageId: workflowActivityNodeKey(target.runId, target.stageId) };
+    case "run":
+      return target;
+  }
+}
+
 // dist/builtin/workflows/src/shared/store-internal.ts
 var TERMINAL_STATUSES = new Set([
   "completed",
@@ -1667,6 +1835,7 @@ function createStoreState() {
 function createStoreContext(state = createStoreState()) {
   let cachedGraphVersion = -1;
   let cachedGraphSnapshot;
+  const observation = new WorkflowObservationRuntime(() => state.runs, bumpAndNotify);
   function snapshot() {
     return JSON.parse(JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }));
   }
@@ -1678,6 +1847,7 @@ function createStoreContext(state = createStoreState()) {
     return cachedGraphSnapshot;
   }
   function notify() {
+    observation.capture();
     for (const fn of state.invalidationListeners) {
       try {
         fn();
@@ -1733,6 +1903,7 @@ function createStoreContext(state = createStoreState()) {
     const prompt = stage.pendingPrompt;
     if (!prompt)
       return;
+    observation.lifecycle({ kind: "prompt", runId, stageId: stage.id, promptId: prompt.id, status: "cancelled" });
     stage.pendingPrompt = undefined;
     state.stagePromptDrafts.delete(stagePromptDraftKey(runId, stage.id, prompt.id));
     rejectPrompt(prompt.id, reason);
@@ -1744,6 +1915,7 @@ function createStoreContext(state = createStoreState()) {
   }
   return {
     state,
+    observation,
     snapshot,
     graphSnapshot,
     notify,
@@ -1913,8 +2085,8 @@ function createPendingStageDeliveryStoreMethods(context) {
   };
 }
 function resolvePendingStageIdentity(run, stageKey) {
-  const exactIds = run.stages.filter((stage2) => stage2.id === stageKey);
-  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage2) => stage2.name === stageKey);
+  const exactIds = run.stages.filter((stage) => stage.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage) => stage.name === stageKey);
   if (candidates.length !== 1)
     return;
   const stage = candidates[0];
@@ -1953,6 +2125,7 @@ function createPromptStoreMethods(context) {
       const pending = run.pendingPrompt;
       if (!pending || pending.id !== promptId)
         return false;
+      context.observation.lifecycle({ kind: "prompt", runId, promptId, status: "answered" });
       run.pendingPrompt = undefined;
       context.bumpAndNotify();
       const entry = state.resolvers.get(promptId);
@@ -2023,6 +2196,13 @@ function createPromptStoreMethods(context) {
         state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stageId));
         delete stage.promptAnswerState;
       }
+      context.observation.lifecycle({
+        kind: "prompt",
+        runId,
+        stageId,
+        promptId,
+        status: options.recordAnswer === false ? "cancelled" : "answered"
+      });
       stage.pendingPrompt = undefined;
       if (stage.status === "awaiting_input") {
         stage.status = "running";
@@ -2239,6 +2419,7 @@ function createRunStoreMethods(context) {
       }
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         run.pendingPrompt = undefined;
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
       }
@@ -2320,6 +2501,7 @@ function createRunStoreMethods(context) {
       const run = state.runs[index];
       const pending = run.pendingPrompt;
       if (pending) {
+        context.observation.lifecycle({ kind: "prompt", runId, promptId: pending.id, status: "cancelled" });
         context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
       }
       context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
@@ -2480,6 +2662,8 @@ function createToolNodeStoreMethods(context) {
         return false;
       node.status = "running";
       node.startedAt = startedAt;
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingToolNodeIds.add(workflowActivityNodeKey(runId, nodeId));
       context.bumpAndNotify();
       return true;
     },
@@ -2487,6 +2671,7 @@ function createToolNodeStoreMethods(context) {
       const node = context.findRun(runId)?.toolNodes?.find((candidate) => candidate.id === nodeId);
       if (node === undefined || node.status === "completed" || node.status === "failed" || node.status === "cached" || node.status === "cancelled")
         return false;
+      context.observation.executingToolNodeIds.delete(workflowActivityNodeKey(runId, nodeId));
       node.status = update.status;
       if (update.endedAt !== undefined)
         node.endedAt = update.endedAt;
@@ -2516,6 +2701,9 @@ function createStageStoreMethods(context) {
       if (!run.stages.some((s) => s.id === stage.id)) {
         run.stages.push(stage);
       }
+      if (stage.status === "running" && context.observation.liveRunIds.has(runId)) {
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stage.id));
+      }
       context.bumpAndNotify();
     },
     recordStageWorkflowChildRun(runId, stageId, ref) {
@@ -2525,8 +2713,12 @@ function createStageStoreMethods(context) {
       const stage = context.findStage(run, stageId);
       if (!stage)
         return false;
-      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow)
+      const released = context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
+      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow) {
+        if (released)
+          context.bumpAndNotify();
         return false;
+      }
       stage.workflowChildRun = { ...ref };
       context.bumpAndNotify();
       return true;
@@ -2565,6 +2757,7 @@ function createStageStoreMethods(context) {
       const existing = context.findStage(run, stage.id);
       if (!existing)
         return;
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stage.id));
       existing.status = stage.status;
       existing.endedAt = stage.endedAt;
       if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
@@ -2788,6 +2981,7 @@ function createStageStoreMethods(context) {
         context.bumpAndNotify();
         return false;
       }
+      context.observation.executingStageIds.delete(workflowActivityNodeKey(runId, stageId));
       stage.status = "paused";
       stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
       stage.resumedAt = undefined;
@@ -2820,6 +3014,8 @@ function createStageStoreMethods(context) {
         return false;
       }
       const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
+      if (context.observation.liveRunIds.has(runId))
+        context.observation.executingStageIds.add(workflowActivityNodeKey(runId, stageId));
       stage.status = "running";
       if (stage.startedAt !== undefined) {
         stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
@@ -2842,13 +3038,18 @@ function createStageStoreMethods(context) {
 // dist/builtin/workflows/src/shared/store-factory.ts
 function createStore() {
   const context = createStoreContext();
-  return {
+  const created = {
+    [workflowObservationRuntimeKey]: context.observation,
     ...createRunStoreMethods(context),
     ...createPendingStageDeliveryStoreMethods(context),
     ...createStageStoreMethods(context),
     ...createToolNodeStoreMethods(context),
     ...createPromptStoreMethods(context)
   };
+  return created;
+}
+function workflowObservationRuntime(activeStore) {
+  return activeStore[workflowObservationRuntimeKey];
 }
 var SESSION_KEY2 = "workflows:store:v1";
 var singleton2 = createSessionScopedSingleton(SESSION_KEY2, createStore);
@@ -2858,7 +3059,7 @@ function key(runId, stageId) {
   return `${runId}\x00${stageId}`;
 }
 function nextRequestId() {
-  return `stage-ui-${randomUUID()}`;
+  return `stage-ui-${randomUUID2()}`;
 }
 
 class StageUiBroker {
@@ -3265,8 +3466,8 @@ function normalizeUIContext(adapter) {
   };
 }
 function stringField(value, keys) {
-  for (const key2 of keys) {
-    const candidate = value[key2];
+  for (const key of keys) {
+    const candidate = value[key];
     if (typeof candidate === "string" && candidate.length > 0)
       return candidate;
   }
@@ -3463,17 +3664,17 @@ function schemaIsRequired(schema) {
 import { Value as Value2 } from "typebox/value";
 function validateInputs(schema, inputs) {
   const errors = [];
-  for (const key2 of Object.keys(inputs)) {
-    if (!(key2 in schema)) {
-      errors.push({ key: key2, reason: "unknown input key (not declared by this workflow)" });
+  for (const key of Object.keys(inputs)) {
+    if (!(key in schema)) {
+      errors.push({ key, reason: "unknown input key (not declared by this workflow)" });
     }
   }
-  for (const [key2, def] of Object.entries(schema)) {
-    const value = inputs[key2];
+  for (const [key, def] of Object.entries(schema)) {
+    const value = inputs[key];
     let hasTypeError = false;
     if (value === undefined) {
       if (schemaIsRequired(def)) {
-        errors.push({ key: key2, reason: "required input is missing" });
+        errors.push({ key, reason: "required input is missing" });
       }
       continue;
     }
@@ -3481,25 +3682,25 @@ function validateInputs(schema, inputs) {
     switch (kind) {
       case "text":
         if (typeof value !== "string") {
-          errors.push({ key: key2, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "number":
         if (typeof value !== "number" || !Number.isFinite(value)) {
-          errors.push({ key: key2, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "integer":
         if (typeof value !== "number" || !Number.isInteger(value)) {
-          errors.push({ key: key2, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
       case "boolean":
         if (typeof value !== "boolean") {
-          errors.push({ key: key2, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         }
         break;
@@ -3507,24 +3708,24 @@ function validateInputs(schema, inputs) {
         const choices = schemaChoices(def) ?? [];
         const allowed = choices.join(", ");
         if (typeof value !== "string") {
-          errors.push({ key: key2, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
+          errors.push({ key, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
         } else if (!choices.includes(value)) {
-          errors.push({ key: key2, reason: `must be one of [${allowed}]` });
+          errors.push({ key, reason: `must be one of [${allowed}]` });
         }
         break;
       }
       default:
         if (!Value2.Check(def, value)) {
           const first = [...Value2.Errors(def, value)][0];
-          errors.push({ key: key2, reason: first === undefined ? `does not match ${kind} schema` : first.message });
+          errors.push({ key, reason: first === undefined ? `does not match ${kind} schema` : first.message });
           hasTypeError = true;
         }
         break;
     }
-    const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key2}"`);
+    const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key}"`);
     if (serializableError !== undefined) {
-      errors.push({ key: key2, reason: serializableError.replace(/^input "[^"]+" /, "") });
+      errors.push({ key, reason: serializableError.replace(/^input "[^"]+" /, "") });
     }
   }
   return errors;
@@ -3533,18 +3734,19 @@ function validateInputs(schema, inputs) {
 // dist/builtin/workflows/src/runs/foreground/executor-inputs.ts
 function resolveInputs(schema, provided) {
   const resolved = {};
-  for (const [key2, value] of Object.entries(provided)) {
+  for (const [key, value] of Object.entries(provided)) {
     if (value !== undefined)
-      resolved[key2] = value;
+      resolved[key] = value;
   }
-  const withDefaults = Value3.Default(Type2.Object(schema, { additionalProperties: true }), resolved);
-  for (const [key2, value] of Object.entries(withDefaults)) {
+  const ownedInputs = Value3.Clone(resolved);
+  const withDefaults = Value3.Default(Type2.Object(schema, { additionalProperties: true }), ownedInputs);
+  for (const [key, value] of Object.entries(withDefaults)) {
     if (value !== undefined)
-      resolved[key2] = value;
+      resolved[key] = value;
   }
-  for (const [key2, schemaDef] of Object.entries(schema)) {
-    if (schemaIsRequired(schemaDef) && resolved[key2] === undefined) {
-      throw new TypeError(`atomic-workflows: required input "${key2}" not provided`);
+  for (const [key, schemaDef] of Object.entries(schema)) {
+    if (schemaIsRequired(schemaDef) && resolved[key] === undefined) {
+      throw new TypeError(`atomic-workflows: required input "${key}" not provided`);
     }
   }
   return resolved;
@@ -3590,12 +3792,12 @@ ${formatValidationErrors(errors)}`);
 function asRecord(value) {
   return value !== null && typeof value === "object" ? value : undefined;
 }
-function field(value, key2) {
-  return asRecord(value)?.[key2];
+function field(value, key) {
+  return asRecord(value)?.[key];
 }
-function safeField(value, key2) {
+function safeField(value, key) {
   try {
-    return field(value, key2);
+    return field(value, key);
   } catch {
     return;
   }
@@ -3625,8 +3827,8 @@ function findProcessFailureError(value, seen, depth) {
     return value;
   if (nonEmptyProcessOutput(safeField(value, "stderr")))
     return value;
-  for (const key2 of ["cause", "error", "response", "body"]) {
-    const selected = findProcessFailureError(safeField(value, key2), seen, depth + 1);
+  for (const key of ["cause", "error", "response", "body"]) {
+    const selected = findProcessFailureError(safeField(value, key), seen, depth + 1);
     if (selected !== undefined)
       return selected;
   }
@@ -3654,8 +3856,8 @@ function selectProcessFailureError(error) {
 function hasProcessFailureEvidence(error) {
   return findProcessFailureError(error, new Set, 0) !== undefined;
 }
-function stringField2(value, key2) {
-  const raw = field(value, key2);
+function stringField2(value, key) {
+  const raw = field(value, key);
   return typeof raw === "string" && raw.length > 0 ? raw : undefined;
 }
 function errorMessage(error) {
@@ -3837,15 +4039,15 @@ function redactSensitiveText(value) {
 var TOOL_FAILURE_TEXT_LIMIT_BYTES = 16384;
 var TRUNCATION_PREFIX = `[workflow tool output truncated; showing final bytes]
 `;
-function safeField2(error, key2) {
+function safeField2(error, key) {
   try {
-    return field(error, key2);
+    return field(error, key);
   } catch {
     return;
   }
 }
-function exposedText(error, key2) {
-  const value = safeField2(error, key2);
+function exposedText(error, key) {
+  const value = safeField2(error, key);
   if (typeof value === "string")
     return value;
   try {
@@ -3954,7 +4156,7 @@ function canonicalJsonString(value) {
     return `[${value.map(canonicalJsonString).join(",")}]`;
   const object = value;
   const keys = Object.keys(object).sort();
-  return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalJsonString(object[key2])}`).join(",")}}`;
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJsonString(object[key])}`).join(",")}}`;
 }
 // dist/builtin/workflows/src/durable/backend.ts
 function pendingStageMessagesForDurableRun(backend, logicalRunId, rootWorkflowId = logicalRunId) {
@@ -3993,13 +4195,13 @@ function cloneWorkflowChildReplaySnapshot(snapshot) {
 }
 function workflowChildReplaySnapshot(alias, childResult) {
   const outputs = {};
-  for (const [key2, value] of Object.entries(childResult.outputs)) {
+  for (const [key, value] of Object.entries(childResult.outputs)) {
     if (value === undefined)
       continue;
     try {
-      outputs[key2] = cloneWorkflowChildValue(value);
+      outputs[key] = cloneWorkflowChildValue(value);
     } catch (err) {
-      throw new Error(`atomic-workflows: child workflow "${alias}" (${childResult.workflow}) exposed output "${key2}" is not serializable for continuation replay: ${workflowChildSerializationMessage(err)}`, { cause: err });
+      throw new Error(`atomic-workflows: child workflow "${alias}" (${childResult.workflow}) exposed output "${key}" is not serializable for continuation replay: ${workflowChildSerializationMessage(err)}`, { cause: err });
     }
   }
   const exitReason = childResult.exited === true ? childResult.exitReason : undefined;
@@ -4148,10 +4350,10 @@ function durableStageGroupKey(stage, stages = [stage]) {
 function groupByDurableStageKey(stages) {
   const groups = new Map;
   for (const stage of stages) {
-    const key2 = durableStageGroupKey(stage, stages);
-    const group = groups.get(key2) ?? [];
+    const key = durableStageGroupKey(stage, stages);
+    const group = groups.get(key) ?? [];
     group.push(stage);
-    groups.set(key2, group);
+    groups.set(key, group);
   }
   return groups;
 }
@@ -4193,13 +4395,13 @@ function hasCycle(topologies) {
 function parseWorkflowChildResult(value) {
   if (!isOrdinaryObject(value))
     return;
-  const workflow2 = value.workflow;
+  const workflow = value.workflow;
   const runId = value.runId;
   const status = value.status;
   const exited = value.exited;
   const outputs = value.outputs;
   const exitReason = value.exitReason;
-  if (typeof workflow2 !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
+  if (typeof workflow !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
     return;
   if (exited === false) {
     if (status !== "completed" || exitReason !== undefined)
@@ -4637,7 +4839,7 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
 }
 
 // dist/builtin/workflows/src/durable/tool-primitive.ts
-import { runCallback } from "@bastani/atomic";
+import { collectAgentTasks, runCallback } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/engine/workflow-tool-abort.ts
 class WorkflowToolAbortError extends Error {
@@ -4767,6 +4969,58 @@ function captureCallbackSource(fn) {
     return;
   }
 }
+async function awaitTerminalTask(task) {
+  for (;; ) {
+    const observed = await task.host.waitForTask(task.taskId);
+    if (!observed.ok)
+      throw new Error(`${observed.error.code}: ${observed.error.message}`);
+    if (observed.value.kind === "settled")
+      return observed.value.result;
+  }
+}
+function replaceTaskObservations(value, terminal) {
+  if (!value || typeof value !== "object")
+    return value;
+  if (Array.isArray(value)) {
+    const next = value.map((item) => replaceTaskObservations(item, terminal));
+    return next.some((item, index) => item !== value[index]) ? next : value;
+  }
+  const object = value;
+  if (object.kind === "yielded" && typeof object.taskId === "string") {
+    const result = terminal.get(object.taskId);
+    if (result)
+      return { kind: "settled", taskId: object.taskId, result };
+  }
+  let changed = false;
+  const next = {};
+  for (const [key, item] of Object.entries(object)) {
+    next[key] = replaceTaskObservations(item, terminal);
+    changed ||= next[key] !== item;
+  }
+  if (changed && next.details !== object.details && next.details && typeof next.details === "object" && !Array.isArray(next.details) && Array.isArray(object.content)) {
+    const details = next.details;
+    const original = object.details;
+    if (details.taskResponse !== undefined && details.taskResponse !== original.taskResponse) {
+      const before = JSON.stringify(original.taskResponse);
+      next.content = object.content.map((part) => {
+        if (!part || typeof part !== "object" || Array.isArray(part))
+          return part;
+        const content = part;
+        return content.type === "text" && content.text === before ? { ...content, text: JSON.stringify(details.taskResponse) } : part;
+      });
+    }
+  }
+  return changed ? next : value;
+}
+function invokeTaskCallback(fn, signal) {
+  return collectAgentTasks(signal, () => fn({ signal }), async (value, tasks) => {
+    if (tasks.length === 0)
+      return value;
+    const terminal = new Map;
+    await Promise.all(tasks.map(async (task) => terminal.set(task.taskId, await awaitTerminalTask(task))));
+    return replaceTaskObservations(value, terminal);
+  });
+}
 function createToolPrimitive(input) {
   const ordinals = new Map;
   return (name, args, fn, options) => {
@@ -4883,11 +5137,11 @@ async function executeToolInvocation(input, ordinals, name, args, fn, options, c
         control.noteCancelled();
       else
         input.onFailureObserved?.(error, node.id);
-      const endedAt2 = Date.now();
+      const endedAt = Date.now();
       input.onNodeEnd?.(node.id, {
         status: cancelled ? "cancelled" : "failed",
-        endedAt: endedAt2,
-        ...node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt2 - node.startedAt) } : {},
+        endedAt,
+        ...node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt - node.startedAt) } : {},
         error: error instanceof Error ? error.message : String(error)
       });
       input.onNodeSettle?.(node.id);
@@ -4942,7 +5196,7 @@ async function executeTimedToolAttempt(toolName, runId, fn, baseSignal, timeoutM
   const timeoutController = new AbortController;
   const attemptSignal = AbortSignal.any([baseSignal, timeoutController.signal]);
   return runCallback({ kind: "workflow.ctx_tool", name: toolName, runId }, async () => {
-    const callbackResult = Promise.resolve().then(() => fn({ signal: attemptSignal })).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error }));
+    const callbackResult = Promise.resolve().then(() => invokeTaskCallback(fn, attemptSignal)).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error }));
     let cancelDeadline;
     let onAbort;
     let timeoutError;
@@ -4997,7 +5251,7 @@ async function executeLiveToolInvocation(live) {
   try {
     const result = await executeWithRetries(() => {
       attempts += 1;
-      const callback = options?.timeoutMs === undefined ? runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () => fn({ signal: toolSignal })) : executeTimedToolAttempt(name, input.workflowId, fn, toolSignal, options.timeoutMs);
+      const callback = options?.timeoutMs === undefined ? runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () => invokeTaskCallback(fn, toolSignal)) : executeTimedToolAttempt(name, input.workflowId, fn, toolSignal, options.timeoutMs);
       return callback.catch((error) => {
         callbackError = error;
         throw error;
@@ -5060,12 +5314,12 @@ async function executeLiveToolInvocation(live) {
     const callbackFailure = callbackError ?? error;
     if (returnFailure && !callbackCompleted && isExplicitCallbackCancellation(callbackFailure)) {
       input.onFailureObserved?.(callbackFailure, node.id);
-      const failure3 = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, callbackFailure, attempts);
+      const failure = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, callbackFailure, attempts);
       input.onNodeEnd?.(node.id, {
         status: "failed",
-        endedAt: failure3.failedAt,
-        durationMs: Math.max(0, failure3.failedAt - startedAt),
-        error: failure3.message
+        endedAt: failure.failedAt,
+        durationMs: Math.max(0, failure.failedAt - startedAt),
+        error: failure.message
       });
       input.onNodeSettle?.(node.id);
       throw callbackFailure;
@@ -5123,12 +5377,12 @@ async function executeLiveToolInvocation(live) {
     }
     const reportedFailure = timeoutFailure ? callbackError : error;
     input.onFailureObserved?.(reportedFailure, node.id);
-    const failure2 = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, reportedFailure, attempts);
+    const failure = await recordThrowingToolFailure(input, node, { name, args, ...source !== undefined ? { source } : {}, argsHash, ordinal, startedAt }, reportedFailure, attempts);
     input.onNodeEnd?.(node.id, {
       status: "failed",
-      endedAt: failure2.failedAt,
-      durationMs: Math.max(0, failure2.failedAt - startedAt),
-      error: failure2.message
+      endedAt: failure.failedAt,
+      durationMs: Math.max(0, failure.failedAt - startedAt),
+      error: failure.message
     });
     input.onNodeSettle?.(node.id);
     throw reportedFailure;
@@ -5184,9 +5438,9 @@ var CALLBACK_CANCELLATION_CODES = new Set([
   "err_cancelled"
 ]);
 var CALLBACK_CANCELLATION_STOP_REASONS = new Set(["aborted", "canceled", "cancelled"]);
-function safeCancellationField(error, key2) {
+function safeCancellationField(error, key) {
   try {
-    return field(error, key2);
+    return field(error, key);
   } catch {
     return;
   }
@@ -5213,16 +5467,16 @@ function isExplicitCallbackCancellation(error) {
       return true;
     if (!hasProcessFailure && hasCancellationMarker(CALLBACK_CANCELLATION_CODES, safeCancellationField(current.value, "code")))
       return true;
-    for (const key2 of ["cause", "error", "response", "body"]) {
-      pending.push({ value: safeCancellationField(current.value, key2), depth: current.depth + 1 });
+    for (const key of ["cause", "error", "response", "body"]) {
+      pending.push({ value: safeCancellationField(current.value, key), depth: current.depth + 1 });
     }
-    for (const key2 of ["diagnostics", "errors"]) {
-      const entries = safeCancellationField(current.value, key2);
+    for (const key of ["diagnostics", "errors"]) {
+      const entries = safeCancellationField(current.value, key);
       if (!Array.isArray(entries))
         continue;
       for (const entry of entries) {
         pending.push({
-          value: key2 === "diagnostics" ? safeCancellationField(entry, "error") ?? entry : entry,
+          value: key === "diagnostics" ? safeCancellationField(entry, "error") ?? entry : entry,
           depth: current.depth + 1
         });
       }
@@ -5702,11 +5956,11 @@ function preferredHydrationTopology(replayValueCheckpoint, checkpoints) {
   }
   return replayValueCheckpoint.topology === undefined ? metadataValue(checkpoints, "topology") : {};
 }
-function metadataValue(checkpoints, key2) {
+function metadataValue(checkpoints, key) {
   for (let index = checkpoints.length - 1;index >= 0; index -= 1) {
-    const value = checkpoints[index]?.[key2];
+    const value = checkpoints[index]?.[key];
     if (value !== undefined)
-      return { [key2]: value };
+      return { [key]: value };
   }
   return {};
 }
@@ -5741,7 +5995,7 @@ function stageMetadataCheckpointId(replayKey, stage) {
     result: stage.result ?? ""
   })}`;
 }
-function recordCachedStageIntoStore(store2, runId, name, replayKey, output, completedStageReplayKeys, parentIds, checkpoint) {
+function recordCachedStageIntoStore(store, runId, name, replayKey, output, completedStageReplayKeys, parentIds, checkpoint) {
   const now = Date.now();
   const sourceStageId = checkpoint?.topology?.run?.runId === runId ? checkpoint.topology.stageId : undefined;
   const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
@@ -5777,16 +6031,16 @@ function recordCachedStageIntoStore(store2, runId, name, replayKey, output, comp
     ...checkpoint?.artifacts !== undefined ? { artifacts: checkpoint.artifacts } : {},
     ...checkpoint?.warnings !== undefined ? { warnings: checkpoint.warnings } : {}
   };
-  store2.recordStageStart(runId, snapshot);
-  store2.recordStageEnd(runId, snapshot);
+  store.recordStageStart(runId, snapshot);
+  store.recordStageEnd(runId, snapshot);
   completedStageReplayKeys.set(stageId, replayKey);
 }
-function recordCachedStageWithTracker(store2, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys, stageFailFastScope, sourceToReplayedNodeIds) {
+function recordCachedStageWithTracker(store, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys, stageFailFastScope, sourceToReplayedNodeIds) {
   const sourceStageId = checkpoint.topology?.run?.runId === runId ? checkpoint.topology.stageId : undefined;
   const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
   let parentIds = tracker.onSpawn(stageId, name);
   const sourceParents = sourceStageId === undefined ? undefined : checkpoint.topology?.parentIds;
-  const run = store2.runs().find((candidate) => candidate.id === runId);
+  const run = store.runs().find((candidate) => candidate.id === runId);
   const restored = sourceParents?.map((sourceId) => sourceToReplayedNodeIds?.get(sourceId) ?? run?.stages.find((stage) => stage.id === sourceId || stage.replayedFromStageId === sourceId)?.id);
   if (restored?.every((id) => id !== undefined)) {
     parentIds = restored;
@@ -5797,7 +6051,7 @@ function recordCachedStageWithTracker(store2, tracker, runId, name, replayKey, c
   }
   if (checkpoint.topology?.run?.runId === runId)
     sourceToReplayedNodeIds?.set(checkpoint.topology.stageId, stageId);
-  recordCachedStageIntoStore(store2, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
+  recordCachedStageIntoStore(store, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
   tracker.onSettle(stageId);
 }
 function isWorkflowTaskResult(value) {
@@ -6545,9 +6799,9 @@ function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
 function getDurableBackend() {
-  const owner2 = getDurableBackendProcessOwner();
-  const memoized = owner2.initializedBackend !== undefined && isMemoizedBackendUsable(owner2.initializedBackend) ? owner2.initializedBackend : undefined;
-  const backend = owner2.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  const owner = getDurableBackendProcessOwner();
+  const memoized = owner.initializedBackend !== undefined && isMemoizedBackendUsable(owner.initializedBackend) ? owner.initializedBackend : undefined;
+  const backend = owner.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
@@ -6580,7 +6834,7 @@ function restoreBudgetState(value) {
     if (restored !== undefined)
       warnings[dimension] = restored;
   }
-  const requiredNumbers = (candidate, fields) => isRecord(candidate) && fields.every((field2) => numericDuration(candidate[field2]) !== undefined);
+  const requiredNumbers = (candidate, fields) => isRecord(candidate) && fields.every((field) => numericDuration(candidate[field]) !== undefined);
   const accountingValue = value.accounting;
   const accounting = isRecord(accountingValue) && requiredNumbers(accountingValue, ["tokens", "cost"]) && requiredNumbers(accountingValue.baseline, ["input", "output", "cacheRead", "cacheWrite", "cost"]) && requiredNumbers(accountingValue.perCounter, ["input", "output", "cacheRead", "cacheWrite"]) ? accountingValue : undefined;
   const state = {
@@ -6812,8 +7066,8 @@ class ScopedDurableBackend {
       scope
     };
   }
-  scopeKey(key2) {
-    return `${this.scope.scopePrefix}:${key2}`;
+  scopeKey(key) {
+    return `${this.scope.scopePrefix}:${key}`;
   }
   remap(checkpoint) {
     const workflowId = this.scope.rootWorkflowId;
@@ -7318,31 +7572,31 @@ function createGitWorktreeSetupCache() {
     get(options) {
       if (disposed)
         throw new Error("Git worktree setup cache is already disposed");
-      const key2 = gitWorktreeSetupCacheKey(options);
-      const cached = results.get(key2);
+      const key = gitWorktreeSetupCacheKey(options);
+      const cached = results.get(key);
       if (cached !== undefined) {
         assertCachedGitWorktreeIdentity(cached, options);
         return cached.result;
       }
       const result = setupGitWorktree(options);
-      results.set(key2, { result, identity: captureGitWorktreeIdentity(result) });
+      results.set(key, { result, identity: captureGitWorktreeIdentity(result) });
       return result;
     },
     dispose() {
       if (disposed)
         return;
       disposed = true;
-      let firstError2;
+      let firstError;
       for (const cached of results.values()) {
         try {
           cached.identity.generation.dispose();
         } catch (error) {
-          firstError2 ??= error instanceof Error ? error : new Error(String(error));
+          firstError ??= error instanceof Error ? error : new Error(String(error));
         }
       }
       results.clear();
-      if (firstError2 !== undefined)
-        throw firstError2;
+      if (firstError !== undefined)
+        throw firstError;
     }
   };
 }
@@ -7642,24 +7896,24 @@ function safePatchAgentName(agent) {
 }
 function removeSyntheticPath(worktree, syntheticPath) {
   const resolved = path4.resolve(worktree.path, syntheticPath);
-  const relative3 = path4.relative(worktree.path, resolved);
-  if (!relative3 || relative3 === "." || relative3 === ".." || relative3.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative3)) {
+  const relative = path4.relative(worktree.path, resolved);
+  if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative)) {
     return;
   }
-  let stat2;
+  let stat;
   try {
-    stat2 = fs4.lstatSync(resolved);
+    stat = fs4.lstatSync(resolved);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT")
       return;
     throw error;
   }
-  if (stat2.isSymbolicLink()) {
+  if (stat.isSymbolicLink()) {
     fs4.unlinkSync(resolved);
     return;
   }
-  if (stat2.isDirectory()) {
+  if (stat.isDirectory()) {
     fs4.rmSync(resolved, { recursive: true, force: true });
     return;
   }
@@ -8023,14 +8277,14 @@ function normalizeSyntheticPath(worktreePath, rawPath) {
   if (path6.isAbsolute(trimmed))
     throw new Error(`synthetic path must be relative: ${rawPath}`);
   const resolved = path6.resolve(worktreePath, trimmed);
-  const relative4 = path6.relative(worktreePath, resolved);
-  if (!relative4 || relative4 === ".") {
+  const relative = path6.relative(worktreePath, resolved);
+  if (!relative || relative === ".") {
     throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
   }
-  if (relative4 === ".." || relative4.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative4)) {
+  if (relative === ".." || relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative)) {
     throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
   }
-  return path6.normalize(relative4);
+  return path6.normalize(relative);
 }
 function hasTrackedEntries(worktreePath, relativePath) {
   const result = runGit(worktreePath, ["ls-files", "--", relativePath]);
@@ -8173,15 +8427,15 @@ function cleanupWorktrees(setup) {
 import { lstatSync as lstatSync4, realpathSync as realpathSync4 } from "node:fs";
 import { dirname as dirname6, isAbsolute as isAbsolute5, relative as relative4, resolve as resolve6, sep as sep5 } from "node:path";
 function relativePathWithin(root, candidate) {
-  const path7 = relative4(root, candidate);
-  return path7 === ".." || path7.startsWith(`..${sep5}`) || isAbsolute5(path7) ? undefined : path7;
+  const path = relative4(root, candidate);
+  return path === ".." || path.startsWith(`..${sep5}`) || isAbsolute5(path) ? undefined : path;
 }
-function existingRealPath(path7, description) {
+function existingRealPath(path, description) {
   try {
-    return realpathSync4.native(path7);
+    return realpathSync4.native(path);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`atomic-workflows: cannot resolve ${description} ${path7}: ${message}`);
+    throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
   }
 }
 function resolveWorktreeStageCwd(cwd, setup) {
@@ -8399,7 +8653,7 @@ function truncateTaskOutput(text, maxOutput) {
 [workflow output truncated; limits: ${limits.bytes} bytes, ${limits.lines} lines]`;
 }
 function withoutUndefinedProperties(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, field2]) => field2 !== undefined));
+  return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined));
 }
 function sharedTaskDefaultsFromOptions(options) {
   const {
@@ -8505,7 +8759,7 @@ async function mapParallelSteps(steps, concurrency, failFast, mapper, onFirstFai
       if (selectedFailure !== undefined)
         throw selectedFailure;
     }
-    throw new AggregateError(failures.map((failure2) => failure2.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    throw new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
   }
   return results;
 }
@@ -8778,32 +9032,32 @@ function reconcileTerminalRunResult(runId, runSnapshot, activeStore, fallback, o
   onRunEnd?.(runId, result.status, result.result, result.error, result.exitReason);
   return result;
 }
-function applyFailureToStage(stage, failure2) {
+function applyFailureToStage(stage, failure) {
   stage.status = "failed";
-  stage.error = failure2.userMessage;
-  stage.failureKind = failure2.kind;
-  stage.failureCode = failure2.code;
-  stage.failureRecoverability = failure2.recoverability;
-  stage.failureDisposition = failure2.disposition;
-  stage.retryAfterMs = failure2.retryAfterMs;
-  stage.failureMessage = failure2.message;
-}
-function runFailureMetadata(failure2, stages) {
+  stage.error = failure.userMessage;
+  stage.failureKind = failure.kind;
+  stage.failureCode = failure.code;
+  stage.failureRecoverability = failure.recoverability;
+  stage.failureDisposition = failure.disposition;
+  stage.retryAfterMs = failure.retryAfterMs;
+  stage.failureMessage = failure.message;
+}
+function runFailureMetadata(failure, stages) {
   const failedStage = stages.find((stage) => stage.status === "failed");
-  const failureKind = failedStage?.failureKind ?? failure2.kind;
-  const failureCode = failedStage?.failureCode ?? failure2.code;
-  const failureRecoverability = failedStage?.failureRecoverability ?? failure2.recoverability;
-  const failureDisposition = failedStage?.failureDisposition ?? failure2.disposition;
-  const retryAfterMs = failedStage?.retryAfterMs ?? failure2.retryAfterMs;
+  const failureKind = failedStage?.failureKind ?? failure.kind;
+  const failureCode = failedStage?.failureCode ?? failure.code;
+  const failureRecoverability = failedStage?.failureRecoverability ?? failure.recoverability;
+  const failureDisposition = failedStage?.failureDisposition ?? failure.disposition;
+  const retryAfterMs = failedStage?.retryAfterMs ?? failure.retryAfterMs;
   return {
-    errorMessage: failedStage?.error ?? failure2.userMessage,
+    errorMessage: failedStage?.error ?? failure.userMessage,
     failureKind,
     ...failureCode !== undefined ? { failureCode } : {},
     failureRecoverability,
     failureDisposition,
-    failureMessage: failedStage?.failureMessage ?? failure2.message,
+    failureMessage: failedStage?.failureMessage ?? failure.message,
     ...failedStage !== undefined ? { failedStageId: failedStage.id } : {},
-    resumable: failure2.resumable,
+    resumable: failure.resumable,
     ...retryAfterMs !== undefined ? { retryAfterMs } : {}
   };
 }
@@ -8832,17 +9086,17 @@ function runFailureMetadataFromStage(fallbackFailure, stage) {
     ...retryAfterMs !== undefined ? { retryAfterMs } : {}
   };
 }
-function runFailureMetadataFromFailure(failure2, failedStage) {
+function runFailureMetadataFromFailure(failure, failedStage) {
   return {
-    errorMessage: failedStage?.error ?? failure2.userMessage,
-    failureKind: failure2.kind,
-    ...failure2.code !== undefined ? { failureCode: failure2.code } : {},
-    failureRecoverability: failure2.recoverability,
-    failureDisposition: failure2.disposition,
-    failureMessage: failedStage?.failureMessage ?? failure2.message,
+    errorMessage: failedStage?.error ?? failure.userMessage,
+    failureKind: failure.kind,
+    ...failure.code !== undefined ? { failureCode: failure.code } : {},
+    failureRecoverability: failure.recoverability,
+    failureDisposition: failure.disposition,
+    failureMessage: failedStage?.failureMessage ?? failure.message,
     ...failedStage !== undefined ? { failedStageId: failedStage.id } : {},
-    resumable: failure2.resumable,
-    ...failure2.retryAfterMs !== undefined ? { retryAfterMs: failure2.retryAfterMs } : {}
+    resumable: failure.resumable,
+    ...failure.retryAfterMs !== undefined ? { retryAfterMs: failure.retryAfterMs } : {}
   };
 }
 function aggregateInnerFailures(error, classifyFailure) {
@@ -8856,20 +9110,20 @@ function stageFailureCandidate(stage) {
     recoverability: stage.failureRecoverability ?? "unknown"
   };
 }
-function aggregateFailureCandidate(failure2) {
+function aggregateFailureCandidate(failure) {
   return {
     source: "aggregate",
-    failure: failure2,
-    disposition: failure2.disposition,
-    recoverability: failure2.recoverability
+    failure,
+    disposition: failure.disposition,
+    recoverability: failure.recoverability
   };
 }
-function outerFailureCandidate(failure2) {
+function outerFailureCandidate(failure) {
   return {
     source: "outer",
-    failure: failure2,
-    disposition: failure2.disposition,
-    recoverability: failure2.recoverability
+    failure,
+    disposition: failure.disposition,
+    recoverability: failure.recoverability
   };
 }
 function isRecoverableActiveBlockedCandidate(candidate) {
@@ -8956,24 +9210,24 @@ function stageReplayFields(stage) {
   };
 }
 function finalizeKilled(runId, runSnapshot, activeStore, persistence, onRunEnd) {
-  const errorMessage2 = "workflow killed";
+  const errorMessage = "workflow killed";
   const metadata = {
     failureKind: "cancelled",
     failureCode: "cancelled",
     failureRecoverability: "non_recoverable",
     failureDisposition: "terminal_killed",
-    failureMessage: errorMessage2,
+    failureMessage: errorMessage,
     resumable: false
   };
-  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage2, metadata);
+  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage, metadata);
   appendRunEndWhenRecorded(persistence, recorded, {
     runId,
     status: "killed",
-    error: errorMessage2,
+    error: errorMessage,
     ...metadata,
     ts: Date.now()
   });
-  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage2 }, onRunEnd);
+  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage }, onRunEnd);
 }
 function finalizeKilledByFailure(runId, runSnapshot, activeStore, persistence, onRunEnd, metadata) {
   const recorded = activeStore.recordRunEnd(runId, "killed", undefined, metadata.errorMessage, metadata);
@@ -9040,32 +9294,32 @@ function recordActiveBlockedFailure(runId, runSnapshot, activeStore, persistence
 
 // dist/builtin/workflows/src/runs/foreground/executor-outputs.ts
 import { Value as Value5 } from "typebox/value";
-function hasOwnWorkflowOutput(record, key2) {
-  return Object.hasOwn(record, key2);
+function hasOwnWorkflowOutput(record, key) {
+  return Object.hasOwn(record, key);
 }
 function assertWorkflowOutputsExplicit(scope, sourceOutput, declarations, missingOutputSuffix = "") {
-  for (const key2 of Object.keys(sourceOutput)) {
-    if (!hasOwnWorkflowOutput(declarations, key2)) {
-      throw new Error(`atomic-workflows: ${scope} returned undeclared output "${key2}"; declare it in outputs: { "${key2}": Type.... } or remove it from the .run() return`);
+  for (const key of Object.keys(sourceOutput)) {
+    if (!hasOwnWorkflowOutput(declarations, key)) {
+      throw new Error(`atomic-workflows: ${scope} returned undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from the .run() return`);
     }
   }
-  for (const [key2, schema] of Object.entries(declarations)) {
-    if (!(key2 in sourceOutput)) {
+  for (const [key, schema] of Object.entries(declarations)) {
+    if (!(key in sourceOutput)) {
       if (schemaIsRequired(schema)) {
-        throw new Error(`atomic-workflows: ${scope} missing output "${key2}"${missingOutputSuffix}`);
+        throw new Error(`atomic-workflows: ${scope} missing output "${key}"${missingOutputSuffix}`);
       }
       continue;
     }
-    const value = sourceOutput[key2];
+    const value = sourceOutput[key];
     const kind = schemaFieldKind(schema);
     if (!Value5.Check(schema, value)) {
       const choices = schemaChoices(schema);
       if (kind === "select" && choices !== undefined && typeof value === "string") {
-        throw new Error(`atomic-workflows: ${scope} output "${key2}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
+        throw new Error(`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
       }
-      throw new Error(`atomic-workflows: ${scope} output "${key2}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
+      throw new Error(`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
     }
-    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key2}"`);
+    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
     if (serializableError !== undefined)
       throw new Error(`atomic-workflows: ${serializableError}`);
   }
@@ -9098,27 +9352,27 @@ function assertWorkflowExitOutputs(workflowName, result, declaredOutputs) {
   const declarations = declaredOutputs ?? {};
   const sourceOutput = result ?? {};
   const scope = `workflow "${workflowName}" ctx.exit()`;
-  for (const key2 of Object.keys(sourceOutput)) {
-    if (!hasOwnWorkflowOutput(declarations, key2)) {
-      throw new Error(`atomic-workflows: ${scope} provided undeclared output "${key2}"; declare it in outputs: { "${key2}": Type.... } or remove it from ctx.exit({ outputs })`);
+  for (const key of Object.keys(sourceOutput)) {
+    if (!hasOwnWorkflowOutput(declarations, key)) {
+      throw new Error(`atomic-workflows: ${scope} provided undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from ctx.exit({ outputs })`);
     }
   }
-  for (const [key2, schema] of Object.entries(declarations)) {
-    if (!(key2 in sourceOutput))
+  for (const [key, schema] of Object.entries(declarations)) {
+    if (!(key in sourceOutput))
       continue;
-    const value = sourceOutput[key2];
-    const invalidSnapshotValue = workflowExitSnapshotInvalidValueMessage(`${scope} output "${key2}"`, value);
+    const value = sourceOutput[key];
+    const invalidSnapshotValue = workflowExitSnapshotInvalidValueMessage(`${scope} output "${key}"`, value);
     if (invalidSnapshotValue !== undefined)
       throw new Error(`atomic-workflows: ${invalidSnapshotValue}`);
     const kind = schemaFieldKind(schema);
     if (!Value5.Check(schema, value)) {
       const choices = schemaChoices(schema);
       if (kind === "select" && choices !== undefined && typeof value === "string") {
-        throw new Error(`atomic-workflows: ${scope} output "${key2}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
+        throw new Error(`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`);
       }
-      throw new Error(`atomic-workflows: ${scope} output "${key2}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
+      throw new Error(`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`);
     }
-    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key2}"`);
+    const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
     if (serializableError !== undefined)
       throw new Error(`atomic-workflows: ${serializableError}`);
   }
@@ -9127,10 +9381,10 @@ function selectWorkflowOutputs(child, rawOutput) {
   const declarations = child.outputs ?? {};
   const sourceOutput = rawOutput ?? {};
   const selected = {};
-  for (const key2 of Object.keys(declarations)) {
-    const value = sourceOutput[key2];
+  for (const key of Object.keys(declarations)) {
+    const value = sourceOutput[key];
     if (value !== undefined)
-      selected[key2] = value;
+      selected[key] = value;
   }
   return selected;
 }
@@ -9545,8 +9799,8 @@ function buildPromptNodeUiAdapter(input) {
       try {
         if (mergedSignal.signal.aborted)
           throw hilAbortError(mergedSignal.signal);
-        const accepted3 = input.activeStore.recordStageAwaitingInput(input.runId, stageId, true, prompt.createdAt);
-        if (!accepted3) {
+        const accepted = input.activeStore.recordStageAwaitingInput(input.runId, stageId, true, prompt.createdAt);
+        if (!accepted) {
           const error = new Error("atomic-workflows: ctx.ui.custom prompt node is unavailable");
           stageSnapshot.skippedReason = "prompt-unavailable";
           await finalizePromptStage("skipped");
@@ -9576,15 +9830,15 @@ function buildPromptNodeUiAdapter(input) {
         mergedSignal.dispose();
       }
     }
-    const accepted2 = input.activeStore.recordStagePendingPrompt(input.runId, stageId, prompt);
-    if (!accepted2) {
+    const accepted = input.activeStore.recordStagePendingPrompt(input.runId, stageId, prompt);
+    if (!accepted) {
       stageSnapshot.skippedReason = "prompt-unavailable";
       await finalizePromptStage("skipped");
       return fallbackForPromptDescriptor(descriptor);
     }
     const waiter = input.activeStore.awaitStagePendingPrompt(input.runId, stageId, prompt.id);
     try {
-      const response = await new Promise((resolve9, reject) => {
+      const response = await new Promise((resolve, reject) => {
         const onAbort = () => {
           input.activeStore.resolveStagePendingPrompt(input.runId, stageId, prompt.id, fallbackForPromptDescriptor(descriptor), { recordAnswer: false });
           reject(hilAbortError(input.signal));
@@ -9596,7 +9850,7 @@ function buildPromptNodeUiAdapter(input) {
         input.signal.addEventListener("abort", onAbort, { once: true });
         waiter.then((value) => {
           input.signal.removeEventListener("abort", onAbort);
-          resolve9(value);
+          resolve(value);
         }, (err) => {
           input.signal.removeEventListener("abort", onAbort);
           reject(err);
@@ -9657,8 +9911,8 @@ function buildPromptNodeUiAdapter(input) {
 // dist/builtin/workflows/src/runs/foreground/executor-run-finalizers.ts
 function createRunFinalizers(input) {
   const finalizeWorkflowExitValidationFailure = (err, exitReason) => {
-    const failure2 = input.classifyExecutorFailure(err);
-    const classifiedMetadata = runFailureMetadata(failure2, input.runSnapshot.stages);
+    const failure = input.classifyExecutorFailure(err);
+    const classifiedMetadata = runFailureMetadata(failure, input.runSnapshot.stages);
     const metadata = {
       ...classifiedMetadata,
       resumable: false,
@@ -9723,8 +9977,8 @@ function createRunFinalizers(input) {
       ...signal.reason !== undefined ? { exitReason: signal.reason } : {}
     }, input.opts.onRunEnd);
   };
-  const finalizeParentWorkflowExitCancellation = async (abortReason3) => {
-    const parentReason = abortReason3.workflowExitReason;
+  const finalizeParentWorkflowExitCancellation = async (abortReason) => {
+    const parentReason = abortReason.workflowExitReason;
     await input.drainWorkflowExitCleanups(parentReason);
     const exitReason = parentWorkflowExitRunReason(parentReason);
     const metadata = { resumable: false, exited: true, exitReason };
@@ -10186,8 +10440,8 @@ class ConcurrencyLimiter {
       this._running++;
       return Promise.resolve();
     }
-    return new Promise((resolve9) => {
-      this._queue.push(resolve9);
+    return new Promise((resolve) => {
+      this._queue.push(resolve);
     });
   }
   release() {
@@ -10208,7 +10462,7 @@ class ConcurrencyLimiter {
   }
 }
 function createRunLimiter(defaultConcurrency) {
-  return new ConcurrencyLimiter(defaultConcurrency ?? 4);
+  return new ConcurrencyLimiter(defaultConcurrency ?? 3);
 }
 
 // dist/builtin/workflows/src/shared/abort.ts
@@ -10273,11 +10527,11 @@ function createWorkflowExitManager(input) {
   const trackWorkflowExitCleanup = (operation) => {
     if (operation === undefined)
       return;
-    let tracked2;
-    tracked2 = Promise.resolve(operation).catch(() => {}).finally(() => {
-      workflowExitCleanupPromises.delete(tracked2);
+    let tracked;
+    tracked = Promise.resolve(operation).catch(() => {}).finally(() => {
+      workflowExitCleanupPromises.delete(tracked);
     });
-    workflowExitCleanupPromises.add(tracked2);
+    workflowExitCleanupPromises.add(tracked);
   };
   const invokeWorkflowExitCleanup = (cleanup, reason) => {
     try {
@@ -10403,10 +10657,10 @@ function createWorkflowExitManager(input) {
   };
 }
 // dist/builtin/workflows/src/engine/primitives/parallel.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/intercom-group.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var DEFAULT_INTERCOM_GROUP = "default";
 function workflowInvocationIntercomGroup(rootRunId) {
   return `workflow:${rootRunId}`;
@@ -10429,22 +10683,22 @@ function resolveStageGroup(stageOptions, workflowGroup) {
   const group = stageOptions.group;
   if (group === undefined)
     return workflowGroup;
-  const authored = group === true ? randomUUID2() : group.trim();
+  const authored = group === true ? randomUUID3() : group.trim();
   if (authored.length === 0)
     return;
   if (workflowGroup === undefined || authored === DEFAULT_INTERCOM_GROUP)
     return authored;
-  const owner2 = normalizeGroup(workflowGroup);
-  if (authored === owner2 || authored.startsWith(`${owner2}/`))
+  const owner = normalizeGroup(workflowGroup);
+  if (authored === owner || authored.startsWith(`${owner}/`))
     return authored;
-  return `${owner2}/${authored}`;
+  return `${owner}/${authored}`;
 }
 function workflowInvocationOwnsGroup(workflowGroup, candidate) {
   if (workflowGroup === undefined || candidate === undefined)
     return false;
-  const owner2 = normalizeGroup(workflowGroup);
+  const owner = normalizeGroup(workflowGroup);
   const group = normalizeGroup(candidate);
-  return group === owner2 || group.startsWith(`${owner2}/`);
+  return group === owner || group.startsWith(`${owner}/`);
 }
 function stageHasIntercomAccess(_stageOptions) {
   return true;
@@ -10487,7 +10741,7 @@ function fold_usage(results) {
 
 // dist/builtin/workflows/src/shared/budget-meter.ts
 var usageFields = ["input", "output", "cacheRead", "cacheWrite", "cost"];
-var addUsage = (left, right) => Object.fromEntries(usageFields.map((field2) => [field2, left[field2] + right[field2]]));
+var addUsage = (left, right) => Object.fromEntries(usageFields.map((field) => [field, left[field] + right[field]]));
 function foldTreeUsage(tree) {
   const run = "run" in tree ? tree.run : tree;
   const folded = fold_usage(run.stages.filter((stage) => stage.replayed !== true).map((stage) => ({ stageName: stage.name, text: stage.result ?? "", modelAttempts: stage.modelAttempts })));
@@ -10499,7 +10753,7 @@ function meter_run(tree, now) {
     durationMs: elapsedRunMs("run" in tree ? tree.run : tree, now),
     tokens: usage.input + usage.output,
     cost: usage.cost,
-    perCounter: Object.fromEntries(usageFields.filter((field2) => field2 !== "cost").map((field2) => [field2, usage[field2]]))
+    perCounter: Object.fromEntries(usageFields.filter((field) => field !== "cost").map((field) => [field, usage[field]]))
   };
 }
 
@@ -10518,7 +10772,7 @@ class WorkflowBudgetExceededError extends Error {
 var withFrontier = (report, frontierStage, summary, usage) => Object.assign({ ...report, frontierStage: frontierStage ?? "workflow frontier" }, summary === undefined ? {} : { wrapUpSummary: summary }, usage === undefined ? {} : { wrapUpUsage: usage });
 var usageFields2 = ["input", "output", "cacheRead", "cacheWrite", "cost"];
 var counterFields = ["input", "output", "cacheRead", "cacheWrite"];
-var mapFields = (fields, fn = () => 0) => Object.fromEntries(fields.map((field2) => [field2, fn(field2)]));
+var mapFields = (fields, fn = () => 0) => Object.fromEntries(fields.map((field) => [field, fn(field)]));
 function createRunBudgetController(input) {
   const { run, budget } = input;
   const ownEnabled = budget.maxDurationMs > 0 || budget.maxTokens > 0 || budget.maxCost > 0;
@@ -10529,7 +10783,7 @@ function createRunBudgetController(input) {
   const previousAccounting = state?.accounting;
   const initial = previousAccounting && usageEnabled ? meter_run(input.usageTree?.() ?? { run }, Date.now()) : undefined;
   const initialAccounting = initial === undefined ? undefined : { ...initial.perCounter, cost: initial.cost };
-  let baseline = mapFields(usageFields2, (field2) => initialAccounting?.[field2] ?? 0);
+  let baseline = mapFields(usageFields2, (field) => initialAccounting?.[field] ?? 0);
   let charged = {
     baseline,
     tokens: previousAccounting?.tokens ?? 0,
@@ -10547,13 +10801,13 @@ function createRunBudgetController(input) {
   };
   const accountUsage = (meters) => {
     const current = { ...meters.perCounter, cost: meters.cost };
-    const delta = mapFields(usageFields2, (field2) => Math.max(0, current[field2] - baseline[field2]));
-    baseline = mapFields(usageFields2, (field2) => Math.max(baseline[field2], current[field2]));
+    const delta = mapFields(usageFields2, (field) => Math.max(0, current[field] - baseline[field]));
+    baseline = mapFields(usageFields2, (field) => Math.max(baseline[field], current[field]));
     charged = {
       baseline,
       tokens: charged.tokens + delta.input + delta.output,
       cost: charged.cost + delta.cost,
-      perCounter: mapFields(counterFields, (field2) => charged.perCounter[field2] + delta[field2])
+      perCounter: mapFields(counterFields, (field) => charged.perCounter[field] + delta[field])
     };
     updateState({ accounting: charged });
     return Object.assign(meters, { tokens: charged.tokens, cost: charged.cost, perCounter: charged.perCounter });
@@ -10630,21 +10884,21 @@ function createRunBudgetController(input) {
     return { check: ownCheckpoint(frontierStage) };
   };
   const checkpoint = (frontierStage) => boundaryCheckpoint(frontierStage).check;
-  const finishBoundary = (owner2, frontierStage) => {
-    throw owner2?.finishWrapUp(frontierStage, undefined, undefined, false) ?? finishWrapUp(frontierStage, undefined, undefined, false);
+  const finishBoundary = (owner, frontierStage) => {
+    throw owner?.finishWrapUp(frontierStage, undefined, undefined, false) ?? finishWrapUp(frontierStage, undefined, undefined, false);
   };
-  const deliverBoundary = (owner2, frontierStage) => {
-    owner2?.deliverWrapUp(frontierStage) ?? deliverWrapUp(frontierStage);
+  const deliverBoundary = (owner, frontierStage) => {
+    owner?.deliverWrapUp(frontierStage) ?? deliverWrapUp(frontierStage);
   };
   const stopAtBoundary = (frontierStage) => {
     const resolvedFrontierStage = frontierStage ?? handlers.at(-1)?.frontierStage;
-    const { check, owner: owner2 } = boundaryCheckpoint(resolvedFrontierStage);
+    const { check, owner } = boundaryCheckpoint(resolvedFrontierStage);
     if (check.kind === "wrap_up") {
-      deliverBoundary(owner2, resolvedFrontierStage ?? "workflow frontier");
-      finishBoundary(owner2, resolvedFrontierStage);
+      deliverBoundary(owner, resolvedFrontierStage ?? "workflow frontier");
+      finishBoundary(owner, resolvedFrontierStage);
     }
     if (check.kind === "exhausted")
-      finishBoundary(owner2, resolvedFrontierStage);
+      finishBoundary(owner, resolvedFrontierStage);
   };
   const rethrowIfSystemOwnedStop = (frontierStage) => {
     root?.rethrowIfSystemOwnedStop(frontierStage);
@@ -10738,11 +10992,11 @@ function createRunBudgetController(input) {
 function createParallelPrimitive(input) {
   return async (steps, options = {}) => {
     input.runtime.exit.throwIfWorkflowExitSelected();
-    const normalizeGroup2 = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
-    const normalizedOptions = normalizeGroup2(options);
-    const normalizedSteps = steps.map(normalizeGroup2);
+    const normalizeGroup = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
+    const normalizedOptions = normalizeGroup(options);
+    const normalizedSteps = steps.map(normalizeGroup);
     const needsAutoGroup = normalizedOptions.group === true || normalizedSteps.some((step) => step.group === true);
-    const autoGroup = needsAutoGroup ? randomUUID3() : undefined;
+    const autoGroup = needsAutoGroup ? randomUUID4() : undefined;
     const resolveAutoGroup = (value) => value.group === true && autoGroup ? { ...value, group: autoGroup } : value;
     const resolvedOptions = resolveAutoGroup(normalizedOptions);
     const resolvedSteps = normalizedSteps.map(resolveAutoGroup);
@@ -10783,9 +11037,9 @@ function createParallelPrimitive(input) {
       beforeMap: input.runtime.exit.throwIfWorkflowExitSelected,
       isControlSignal: (error) => findWorkflowExitSignal(error, input.runtime.exit.exitScope) !== undefined,
       selectSettledFailure: (failures) => {
-        if (!everyStepCompleted() || !failures.every((failure2) => failure2.error instanceof WorkflowBudgetExceededError))
+        if (!everyStepCompleted() || !failures.every((failure) => failure.error instanceof WorkflowBudgetExceededError))
           return;
-        return failures.reduce((selected, failure2) => failure2.index < selected.index ? failure2 : selected).error;
+        return failures.reduce((selected, failure) => failure.index < selected.index ? failure : selected).error;
       }
     });
   };
@@ -11328,8 +11582,8 @@ function structuredRecoverableFailureFromSnapshot(snapshot, failedStageId) {
 function isRecoverableProviderFailureKind(kind) {
   return kind === "auth" || kind === "rate_limit" || kind === "provider";
 }
-function stringResultField(result, key2) {
-  const value = result?.[key2];
+function stringResultField(result, key) {
+  const value = result?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
@@ -11347,7 +11601,7 @@ async function finalizeDurableTerminalStatus(input) {
     if (durableStatus === "failed" || durableStatus === "blocked") {
       recordRunTimingCheckpoint(input.durableBackend, input.runSnapshot);
     }
-    const failure2 = durableStatus === "failed" ? {
+    const failure = durableStatus === "failed" ? {
       ...input.runSnapshot.error !== undefined ? { error: input.runSnapshot.error } : {},
       ...input.runSnapshot.exited === true ? {
         exited: true,
@@ -11359,7 +11613,7 @@ async function finalizeDurableTerminalStatus(input) {
       ...input.runSnapshot.failureDisposition !== undefined ? { failureDisposition: input.runSnapshot.failureDisposition } : {},
       ...input.runSnapshot.failedToolNodeId !== undefined ? { failedToolNodeId: input.runSnapshot.failedToolNodeId } : {}
     } : undefined;
-    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure2);
+    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure);
   }
   await input.durableBackend.flush(input.runId);
 }
@@ -11616,17 +11870,17 @@ function childRunIdFromDraft(draft) {
 }
 function boundaryOwner(grouped, childRunId) {
   for (const drafts of grouped.values()) {
-    const owner2 = drafts.find((draft) => childRunIdFromDraft(draft) === childRunId);
-    if (owner2 !== undefined)
-      return owner2;
+    const owner = drafts.find((draft) => childRunIdFromDraft(draft) === childRunId);
+    if (owner !== undefined)
+      return owner;
   }
   return;
 }
-function childRunStatus(owner2) {
-  const child = workflowChildFromDraft(owner2);
+function childRunStatus(owner) {
+  const child = workflowChildFromDraft(owner);
   if (child !== undefined)
     return child.status;
-  const status = owner2.topology?.boundary?.status;
+  const status = owner.topology?.boundary?.status;
   return status === "failed" || status === "skipped" || status === "completed" ? status : "running";
 }
 function mergeStageGroup(records, allStages, allCheckpoints) {
@@ -11676,12 +11930,12 @@ function mergeStageDraft(existing, checkpoint, sequence) {
     ...checkpoint.topology !== undefined ? { topology: checkpoint.topology } : existing?.topology !== undefined ? { topology: existing.topology } : {}
   };
 }
-function valueOrExisting(key2, checkpoint, existing) {
-  const checkpointValue = checkpoint[key2];
+function valueOrExisting(key, checkpoint, existing) {
+  const checkpointValue = checkpoint[key];
   if (checkpointValue !== undefined)
-    return { [key2]: checkpointValue };
-  const existingValue = existing?.[key2];
-  return existingValue === undefined ? {} : { [key2]: existingValue };
+    return { [key]: checkpointValue };
+  const existingValue = existing?.[key];
+  return existingValue === undefined ? {} : { [key]: existingValue };
 }
 function workflowChildFromDraft(draft) {
   const strict = parseWorkflowChildResult(draft.output);
@@ -11757,7 +12011,7 @@ function durableNestedRunSnapshots(backend, rootWorkflowId) {
   const handle = backend.getWorkflow(rootWorkflowId);
   if (handle === undefined)
     return [];
-  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run2) => run2.id !== rootWorkflowId);
+  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run) => run.id !== rootWorkflowId);
 }
 function checkpointDrafts(checkpoints) {
   const stageByReplayKey = new Map;
@@ -11766,8 +12020,8 @@ function checkpointDrafts(checkpoints) {
   checkpoints.forEach((checkpoint, index) => {
     const sequence = index + 1;
     if (checkpoint.kind === "stage") {
-      const existing2 = stageByReplayKey.get(checkpoint.replayKey);
-      stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing2, checkpoint, sequence));
+      const existing = stageByReplayKey.get(checkpoint.replayKey);
+      stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing, checkpoint, sequence));
       return;
     }
     if (checkpoint.kind !== "tool" || isReservedRunCheckpointHash(checkpoint.argsHash))
@@ -11968,29 +12222,29 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     }
     const stages = runDrafts.map((draft) => stageSnapshotFromDraft(draft, ids.get(draft.topology.stageId), draft.topology.parentIds.map((parentId) => ids.get(parentId))));
     const toolNodes = completedToolNodes(toolCheckpoints, runId, rootRunId, ids, drafts.firstToolSequenceByHash);
-    const run2 = runTopologyFor(runDrafts, ownedTools);
+    const run = runTopologyFor(runDrafts, ownedTools);
     const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.startedAt ?? tool.endedAt ?? fallbackCompletedAt));
     const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.endedAt ?? fallbackCompletedAt));
-    const owner2 = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
-    const status = owner2 === undefined ? "completed" : childRunStatus(owner2);
+    const owner = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
+    const status = owner === undefined ? "completed" : childRunStatus(owner);
     const terminal = status !== "running" && status !== "pending" && status !== "paused" && status !== "blocked";
-    const parentRunId = run2?.parentRunId ?? rootRunId;
+    const parentRunId = run?.parentRunId ?? rootRunId;
     const boundarySourceId = grouped.get(parentRunId)?.find((draft) => childRunIdFromDraft(draft) === runId)?.topology?.stageId;
-    const declaredParentStageId = run2?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run2.parentStageId);
+    const declaredParentStageId = run?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run.parentStageId);
     const parentStageId = declaredParentStageId ?? (boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
-    const ownerChild = owner2 === undefined ? undefined : workflowChildFromDraft(owner2);
+    const ownerChild = owner === undefined ? undefined : workflowChildFromDraft(owner);
     runs.push({
       id: runId,
-      name: run2?.runName ?? rootRunName,
+      name: run?.runName ?? rootRunName,
       inputs: {},
       status,
       stages,
       toolNodes,
       startedAt,
       ...terminal ? { endedAt, durationMs: Math.max(0, endedAt - startedAt) } : {},
-      ...run2?.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
+      ...run?.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {},
       ...parentStageId !== undefined ? { parentStageId } : {},
-      ...run2?.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {},
+      ...run?.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {},
       ...ownerChild?.exited === true ? {
         result: ownerChild.outputs,
         exited: true,
@@ -12000,13 +12254,13 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     });
     emittedRunIds.add(runId);
   }
-  for (const { parentRunId, owner: owner2, child } of syntheticChildren) {
+  for (const { parentRunId, owner, child } of syntheticChildren) {
     if (!emittedRunIds.has(parentRunId)) {
       if (policy.failClosed)
         return [];
       continue;
     }
-    const topology = owner2.topology;
+    const topology = owner.topology;
     const boundary = topology.boundary;
     const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
     if (parentStageId === undefined) {
@@ -12014,8 +12268,8 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
         return [];
       continue;
     }
-    const startedAt = owner2.startedAt ?? owner2.firstCompletedAt;
-    const endedAt = owner2.endedAt ?? owner2.firstCompletedAt;
+    const startedAt = owner.startedAt ?? owner.firstCompletedAt;
+    const endedAt = owner.endedAt ?? owner.firstCompletedAt;
     runs.push({
       id: child.runId,
       name: boundary.child.runName,
@@ -12123,7 +12377,7 @@ function syntheticCheckpointStage(checkpointCount, completedAt) {
 // dist/builtin/workflows/src/durable/completed-subtree.ts
 function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
   const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
-  if (!nested.some((run2) => run2.id === childRunId))
+  if (!nested.some((run) => run.id === childRunId))
     return;
   const intentionalExitStatuses = new Map;
   for (const checkpoint of backend.listCheckpoints(rootWorkflowId)) {
@@ -12137,22 +12391,22 @@ function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
   let priorSize = -1;
   while (priorSize !== included.size) {
     priorSize = included.size;
-    for (const run2 of nested) {
-      if (run2.parentRunId !== undefined && included.has(run2.parentRunId))
-        included.add(run2.id);
+    for (const run of nested) {
+      if (run.parentRunId !== undefined && included.has(run.parentRunId))
+        included.add(run.id);
     }
   }
-  const subtree = nested.filter((run2) => included.has(run2.id));
-  const complete = subtree.length === included.size && subtree.every((run2) => isCompleteCachedRun(run2, intentionalExitStatuses));
+  const subtree = nested.filter((run) => included.has(run.id));
+  const complete = subtree.length === included.size && subtree.every((run) => isCompleteCachedRun(run, intentionalExitStatuses));
   return complete ? subtree : undefined;
 }
-function isCompleteCachedRun(run2, intentionalExitStatuses) {
-  if (run2.endedAt === undefined || !run2.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
+function isCompleteCachedRun(run, intentionalExitStatuses) {
+  if (run.endedAt === undefined || !run.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
     return false;
   }
-  if (run2.status === "completed" || run2.exited === true)
+  if (run.status === "completed" || run.exited === true)
     return true;
-  return intentionalExitStatuses.get(run2.id) === run2.status;
+  return intentionalExitStatuses.get(run.id) === run.status;
 }
 function isTerminalStage2(status) {
   return status === "completed" || status === "failed" || status === "skipped";
@@ -12197,13 +12451,13 @@ function reciprocalWorkflowRootRunId(runById, runId) {
 }
 
 // dist/builtin/workflows/src/engine/run-durable-topology.ts
-function durableRunTopology(run2) {
+function durableRunTopology(run) {
   return {
-    runId: run2.id,
-    runName: run2.name,
-    ...run2.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
-    ...run2.parentStageId !== undefined ? { parentStageId: run2.parentStageId } : {},
-    ...run2.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {}
+    runId: run.id,
+    runName: run.name,
+    ...run.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {},
+    ...run.parentStageId !== undefined ? { parentStageId: run.parentStageId } : {},
+    ...run.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {}
   };
 }
 function createDurableStageDeps(input) {
@@ -12278,7 +12532,7 @@ function createDurableCachedStageRecorder(input) {
   return {
     record(name, replayKey, checkpoint, scope) {
       const cachedChildRunId = workflowChildRunId(checkpoint);
-      const runById = new Map(input.store.runs().map((run2) => [run2.id, run2]));
+      const runById = new Map(input.store.runs().map((run) => [run.id, run]));
       if (!runById.has(input.run.id))
         runById.set(input.run.id, input.run);
       const durableRootId = reciprocalWorkflowRootRunId(runById, input.run.id);
@@ -12294,7 +12548,7 @@ function createDurableCachedStageRecorder(input) {
           replaySourceOrders.set(replayedStage.id, sourceOrder);
         input.run.stages.sort((left, right) => (replaySourceOrders.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (replaySourceOrders.get(right.id) ?? Number.MAX_SAFE_INTEGER));
       }
-      const stage = input.store.runs().find((run2) => run2.id === input.run.id)?.stages.find((candidate) => candidate.replayKey === replayKey);
+      const stage = input.store.runs().find((run) => run.id === input.run.id)?.stages.find((candidate) => candidate.replayKey === replayKey);
       if (stage !== undefined) {
         input.backend.recordCheckpoint({
           kind: "stage",
@@ -12332,10 +12586,10 @@ function createDurableCachedStageRecorder(input) {
   };
 }
 function reconcileCachedDirectChildParentStage(input) {
-  const existingRun = input.store.runs().find((run2) => run2.id === input.checkpointChildRunId);
+  const existingRun = input.store.runs().find((run) => run.id === input.checkpointChildRunId);
   if (existingRun === undefined)
     return false;
-  const runById = new Map(input.store.runs().map((run2) => [run2.id, run2]));
+  const runById = new Map(input.store.runs().map((run) => [run.id, run]));
   const storedParentRun = runById.get(input.parentRun.id);
   if (storedParentRun !== undefined && (storedParentRun.parentRunId !== input.parentRun.parentRunId || storedParentRun.parentStageId !== input.parentRun.parentStageId))
     return false;
@@ -12376,11 +12630,11 @@ function deferStageUntilRunRelease(input) {
   };
   return {
     name: input.name,
-    prompt: (...args) => invoke((stage2) => stage2.prompt(...args)),
-    complete: (...args) => invoke((stage2) => stage2.complete(...args)),
-    sendUserMessage: (...args) => invoke((stage2) => stage2.sendUserMessage(...args)),
-    steer: (...args) => invoke((stage2) => stage2.steer(...args)),
-    followUp: (...args) => invoke((stage2) => stage2.followUp(...args)),
+    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;
@@ -12388,9 +12642,9 @@ function deferStageUntilRunRelease(input) {
     get sessionId() {
       return current().sessionId;
     },
-    setModel: (...args) => invoke((stage2) => stage2.setModel(...args)),
+    setModel: (...args) => invoke((stage) => stage.setModel(...args)),
     setThinkingLevel: (...args) => current().setThinkingLevel(...args),
-    cycleModel: () => invoke((stage2) => stage2.cycleModel()),
+    cycleModel: () => invoke((stage) => stage.cycleModel()),
     cycleThinkingLevel: () => current().cycleThinkingLevel(),
     get agent() {
       return current().agent;
@@ -12407,10 +12661,10 @@ function deferStageUntilRunRelease(input) {
     get isStreaming() {
       return current().isStreaming;
     },
-    navigateTree: (...args) => invoke((stage2) => stage2.navigateTree(...args)),
-    compact: () => invoke((stage2) => stage2.compact()),
+    navigateTree: (...args) => invoke((stage) => stage.navigateTree(...args)),
+    compact: () => invoke((stage) => stage.compact()),
     abortCompaction: () => current().abortCompaction(),
-    abort: () => invoke((stage2) => stage2.abort())
+    abort: () => invoke((stage) => stage.abort())
   };
 }
 
@@ -12494,9 +12748,9 @@ function createRunTerminalEventArbiter(runId) {
 
 // dist/builtin/workflows/src/engine/run-terminal-failure.ts
 function finalizeTerminalFailure(input) {
-  const { runId, runSnapshot, store: store2, persistence, metadata, onRunEnd } = input;
+  const { runId, runSnapshot, store, persistence, metadata, onRunEnd } = input;
   const failedToolNode = metadata.failedToolNodeId === undefined ? undefined : runSnapshot.toolNodes?.find((node) => node.id === metadata.failedToolNodeId);
-  const recorded = store2.recordRunEnd(runId, "failed", undefined, metadata.errorMessage, metadata);
+  const recorded = store.recordRunEnd(runId, "failed", undefined, metadata.errorMessage, metadata);
   appendRunEndWhenRecorded(persistence, recorded, {
     runId,
     status: "failed",
@@ -12515,7 +12769,7 @@ function finalizeTerminalFailure(input) {
     ...runSnapshot.durationMs !== undefined ? { durationMs: runSnapshot.durationMs } : {},
     ts: Date.now()
   });
-  return reconcileTerminalRunResult(runId, runSnapshot, store2, { status: "failed", error: metadata.errorMessage }, onRunEnd);
+  return reconcileTerminalRunResult(runId, runSnapshot, store, { status: "failed", error: metadata.errorMessage }, onRunEnd);
 }
 
 // dist/builtin/workflows/src/engine/run-tool-admission-boundary.ts
@@ -12653,7 +12907,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const admissions = [];
   const failures = [];
   const cancellations = [];
-  let nextAdmissionOrder2 = 0;
+  let nextAdmissionOrder = 0;
   let state = "OPEN";
   let closing;
   const abandonment = Promise.withResolvers();
@@ -12662,17 +12916,17 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const recordFailure = (admission, error, nodeId) => {
     if (admission.failure !== undefined)
       return;
-    const failure2 = { admissionOrder: admission.admissionOrder, error, ...nodeId === undefined ? {} : { nodeId } };
-    admission.failure = failure2;
-    failures.push(failure2);
-    options.onFailureObserved?.(failure2);
+    const failure = { admissionOrder: admission.admissionOrder, error, ...nodeId === undefined ? {} : { nodeId } };
+    admission.failure = failure;
+    failures.push(failure);
+    options.onFailureObserved?.(failure);
   };
   const reportDrainFailure = () => {
-    const failure2 = failures[0];
-    if (state !== "DRAINING" || failure2 === undefined || drainFailureReported)
+    const failure = failures[0];
+    if (state !== "DRAINING" || failure === undefined || drainFailureReported)
       return;
     drainFailureReported = true;
-    options.onFailureDuringDrain?.(failure2);
+    options.onFailureDuringDrain?.(failure);
   };
   const drainRecordedFailures = () => Promise.all(admissions.flatMap((admission) => admission.failure !== undefined && admission.observed !== undefined ? [admission.observed] : []));
   const closeAtFixedPoint = async () => {
@@ -12704,7 +12958,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
         return { accepted: false, error, bindNode() {}, noteCancelled() {} };
       }
       const admission = {
-        admissionOrder: ++nextAdmissionOrder2,
+        admissionOrder: ++nextAdmissionOrder,
         nodeId: undefined,
         failure: undefined,
         cancelled: false,
@@ -12764,7 +13018,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
       return failures[0];
     },
     uniqueFailureFor(error) {
-      const matching = [...failures, ...cancellations].filter((failure2) => Object.is(failure2.error, error));
+      const matching = [...failures, ...cancellations].filter((failure) => Object.is(failure.error, error));
       return matching.length === 1 ? matching[0] : undefined;
     }
   };
@@ -12772,8 +13026,8 @@ function createAdmittedToolExecutionTracker(options = {}) {
 
 // dist/builtin/workflows/src/engine/run-tool-node-lifecycle.ts
 function createToolNodeLifecycle(input) {
-  const { store: store2, tracker, run: run2, sourceToContinuationNodeIds } = input;
-  const ownsCurrentRun = () => store2.runs().some((candidate) => candidate === run2);
+  const { store, tracker, run, sourceToContinuationNodeIds } = input;
+  const ownsCurrentRun = () => store.runs().some((candidate) => candidate === run);
   const replayedToolNodeIds = new Set;
   let pendingFrontier = input.resumeToolNode;
   return {
@@ -12791,11 +13045,11 @@ function createToolNodeLifecycle(input) {
       const sourceParents = frontier?.parentIds ?? (node.replayed === true && node.topologyState !== "unavailable" ? node.parentIds : undefined);
       const restored = sourceParents?.map((sourceId) => sourceToContinuationNodeIds.get(sourceId));
       const translated = restored?.every((id) => id !== undefined) ? restored : undefined;
-      if (run2.resumedFromRunId !== undefined && sourceParents !== undefined && translated === undefined) {
-        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run2.resumedFromRunId}`);
+      if (run.resumedFromRunId !== undefined && sourceParents !== undefined && translated === undefined) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run.resumedFromRunId}`);
       }
-      if (translated !== undefined && run2.resumedFromRunId !== undefined && !compatibleReplayedToolParents(tracker, translated, inferredParents, (parentId) => isReplayedContinuationNode(store2, run2, replayedToolNodeIds, parentId))) {
-        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run2.resumedFromRunId}`);
+      if (translated !== undefined && run.resumedFromRunId !== undefined && !compatibleReplayedToolParents(tracker, translated, inferredParents, (parentId) => isReplayedContinuationNode(store, run, replayedToolNodeIds, parentId))) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for tool "${node.name}" (node "${node.id}") in source run ${run.resumedFromRunId}`);
       }
       const parentIds = translated ?? inferredParents;
       tracker.replaceParents(node.id, parentIds);
@@ -12804,28 +13058,28 @@ function createToolNodeLifecycle(input) {
       if (node.replayed === true)
         replayedToolNodeIds.add(node.id);
       if (ownsCurrentRun())
-        store2.recordToolNodeStart(run2.id, node);
+        store.recordToolNodeStart(run.id, node);
       if (frontier !== undefined)
         pendingFrontier = undefined;
     },
     onNodeRunning: (nodeId, startedAt) => {
       if (ownsCurrentRun())
-        store2.recordToolNodeRunning(run2.id, nodeId, startedAt);
+        store.recordToolNodeRunning(run.id, nodeId, startedAt);
     },
     onNodeEnd: (nodeId, update) => {
       if (ownsCurrentRun())
-        store2.recordToolNodeEnd(run2.id, nodeId, update);
+        store.recordToolNodeEnd(run.id, nodeId, update);
     },
     onNodeSettle: (nodeId) => {
       tracker.onSettle(nodeId);
     },
-    runTopology: durableRunTopology(run2)
+    runTopology: durableRunTopology(run)
   };
 }
-function isReplayedContinuationNode(store2, run2, replayedToolNodeIds, nodeId) {
+function isReplayedContinuationNode(store, run, replayedToolNodeIds, nodeId) {
   if (replayedToolNodeIds.has(nodeId))
     return true;
-  const live = store2.runs().find((candidate) => candidate === run2);
+  const live = store.runs().find((candidate) => candidate === run);
   return live?.stages.some((stage) => stage.id === nodeId && stage.replayed === true) === true;
 }
 function compatibleReplayedToolParents(tracker, translated, inferredParents, isReplayedNode) {
@@ -12842,9 +13096,9 @@ function createTrackedToolPrimitive(input) {
     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);
@@ -13223,7 +13477,7 @@ function createTrackedStageCaller(input) {
       if (suppressQueuedContinuation)
         runtime.state.suppressQueuedUserMessageContinuation = true;
       try {
-        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.__continuePrompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
       } finally {
         if (suppressQueuedContinuation)
           runtime.state.suppressQueuedUserMessageContinuation = false;
@@ -13328,9 +13582,9 @@ function createTrackedStageCaller(input) {
           let resolveNextTurnEnd = null;
           const unsubscribeTurnWatcher = runtime.innerCtx.subscribe((event) => {
             if (event.type === "agent_end" && resolveNextTurnEnd) {
-              const resolve9 = resolveNextTurnEnd;
+              const resolve = resolveNextTurnEnd;
               resolveNextTurnEnd = null;
-              resolve9();
+              resolve();
             }
           });
           try {
@@ -13343,15 +13597,15 @@ function createTrackedStageCaller(input) {
               runtime.state.askUserQuestionObservedThisTurn = false;
               runtime.state.chatAnswerObservedThisTurn = false;
               if (decision.message !== undefined) {
-                result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(decision.message), runtime.signal));
+                result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.__continuePrompt(decision.message), runtime.signal));
                 if (runtime.budget.enabled && typeof result === "string")
                   stageResultBeforeBudget = result;
               } else {
                 runtime.state.waitingForStageChatTurn = true;
                 try {
-                  await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve9) => {
-                    resolveNextTurnEnd = resolve9;
-                    runtime.state.wakeWaitingForStageChatTurn = resolve9;
+                  await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve) => {
+                    resolveNextTurnEnd = resolve;
+                    runtime.state.wakeWaitingForStageChatTurn = resolve;
                   }), runtime.signal));
                 } finally {
                   runtime.state.wakeWaitingForStageChatTurn = undefined;
@@ -13391,7 +13645,9 @@ function createTrackedStageCaller(input) {
         await runtime.budget.deliverWrapUp(runtime.name);
       if (afterBudget.kind === "exhausted" && runtime.budget.enabled)
         await runtime.budget.stopAtBoundaryAsync(runtime.name);
-      await runtime.innerCtx.__closeGeneration();
+      const finalizedArtifact = await runtime.innerCtx.__closeGeneration();
+      if (typeof result === "string" && finalizedArtifact !== undefined)
+        result = finalizedArtifact;
       await runtime.captureStageSessionMeta({ awaitDurable: true });
       if (trackStageLifecycle && runtime.stageFailFastScope?.failed === true && runtime.stageFailFastScope.activeStages.has(runtime.stageId)) {
         runtime.markSkippedForParallelFailFast();
@@ -13420,7 +13676,7 @@ function createTrackedStageCaller(input) {
       const budgetError = err instanceof WorkflowBudgetExceededError ? err : undefined;
       if (budgetError !== undefined && trackStageLifecycle && !runtime.state.skippedForParallelFailFast) {
         let selectedBudgetError = budgetError;
-        if (runtime.activeStore.runs().find((run2) => run2.id === runtime.runId)?.budgetState?.wrapUpCompleted !== true) {
+        if (runtime.activeStore.runs().find((run) => run.id === runtime.runId)?.budgetState?.wrapUpCompleted !== true) {
           try {
             await runtime.budget.deliverWrapUp(runtime.name);
           } catch (wrapUpError) {
@@ -13448,8 +13704,8 @@ function createTrackedStageCaller(input) {
           };
         }
       } else if (trackStageLifecycle && !runtime.signal.aborted && !runtime.state.skippedForParallelFailFast) {
-        const failure2 = runtime.classifyExecutorFailure(err);
-        applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure2);
+        const failure = runtime.classifyExecutorFailure(err);
+        applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
       }
       throw err;
     } finally {
@@ -13475,8 +13731,8 @@ function createTrackedStageCaller(input) {
       finalizationError ??= durableCheckpointError;
       if (trackStageLifecycle) {
         if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
-          const failure2 = runtime.classifyExecutorFailure(durableCheckpointError.error);
-          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure2);
+          const failure = runtime.classifyExecutorFailure(durableCheckpointError.error);
+          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
         }
         if (!runtime.state.stageFinalized)
           applyTerminalStageState?.();
@@ -13734,8 +13990,8 @@ class StageToolExecutionBuffer {
 // dist/builtin/workflows/src/runs/foreground/executor-stage-control.ts
 function createStageControlHandle(runtime) {
   const messagePreparation = () => {
-    const meta2 = runtime.innerCtx.__sessionMeta();
-    if (meta2.sessionId !== undefined || meta2.sessionFile !== undefined) {
+    const meta = runtime.innerCtx.__sessionMeta();
+    if (meta.sessionId !== undefined || meta.sessionFile !== undefined) {
       return { beforePreparation: runtime.throwIfStageMutationBlocked };
     }
     if (runtime.stageSnapshot.sessionFile !== undefined) {
@@ -13865,8 +14121,8 @@ function createStageControlHandle(runtime) {
       if (changed) {
         runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
         await runtime.scheduler.cascadePauseFrom(runtime.stageId);
-        const run2 = runtime.activeStore.runs().find((candidate) => candidate.id === runtime.runId);
-        const stillActive = run2?.stages.some((stage) => stage.status === "running" && stage.id !== runtime.stageId) ?? false;
+        const run = runtime.activeStore.runs().find((candidate) => candidate.id === runtime.runId);
+        const stillActive = run?.stages.some((stage) => stage.status === "running" && stage.id !== runtime.stageId) ?? false;
         if (!stillActive)
           runtime.activeStore.recordRunPaused(runtime.runId);
       }
@@ -13933,6 +14189,7 @@ function createStageControlHandle(runtime) {
 // dist/builtin/workflows/src/runs/foreground/executor-stage-replay.ts
 function createReplayStageContext(input) {
   const { runId, name, stageId, stageSnapshot, replaySource } = input;
+  workflowObservationRuntime(input.activeStore).replayStageIds.add(workflowActivityNodeKey(runId, stageId));
   let replayFinalized = false;
   let unregisterWorkflowExitCleanup = () => {};
   let stageStartEntryAppended = false;
@@ -14002,6 +14259,7 @@ function createReplayStageContext(input) {
   return {
     name,
     prompt: replayText,
+    __continuePrompt: replayText,
     complete: replayText,
     sendUserMessage: async () => rejectReplayMutation("send a user message"),
     __sendUserMessage: async () => rejectReplayMutation("send a user message"),
@@ -14064,13 +14322,13 @@ function createReplayStageContext(input) {
 
 // dist/builtin/workflows/src/durable/run-owner-backend.ts
 function durableRootRunIdForRun(runs, runId) {
-  return reciprocalWorkflowRootRunId(new Map(runs.map((run2) => [run2.id, run2])), runId);
+  return reciprocalWorkflowRootRunId(new Map(runs.map((run) => [run.id, run])), runId);
 }
 function durableBackendForRun(backend, runs, runId) {
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
     return;
-  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const runById = new Map(runs.map((run) => [run.id, run]));
   if (rootRunId === runId)
     return backend;
   const scopes = [];
@@ -14093,17 +14351,17 @@ function durableBackendForRun(backend, runs, runId) {
 }
 
 // dist/builtin/workflows/src/shared/pending-stage-route-capability.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var routeCapabilities = new WeakMap;
-function workflowPendingStageRouteCapability(store2, runId) {
-  let capabilities = routeCapabilities.get(store2);
+function workflowPendingStageRouteCapability(store, runId) {
+  let capabilities = routeCapabilities.get(store);
   if (capabilities === undefined) {
     capabilities = new Map;
-    routeCapabilities.set(store2, capabilities);
+    routeCapabilities.set(store, capabilities);
   }
   let capability = capabilities.get(runId);
   if (capability === undefined) {
-    capability = randomUUID4();
+    capability = randomUUID5();
     capabilities.set(runId, capability);
   }
   return capability;
@@ -14187,7 +14445,7 @@ function parseWorkflowStageTarget(target) {
 
 // dist/builtin/workflows/src/shared/pending-stage-status.ts
 function workflowBoundaryHops(runs, runId) {
-  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const runById = new Map(runs.map((run) => [run.id, run]));
   const hops = [];
   let current = runById.get(runId);
   while (current !== undefined && current.parentRunId !== undefined) {
@@ -14246,8 +14504,8 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
   let drainPromise;
   const pendingReady = () => {
     if (readyPromise === undefined) {
-      readyPromise = new Promise((resolve9, reject) => {
-        resolveReady = resolve9;
+      readyPromise = new Promise((resolve, reject) => {
+        resolveReady = resolve;
         rejectReady = reject;
       });
     }
@@ -14303,7 +14561,7 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
   ].map((entry) => entry.id));
   const runs = activeStore.runs();
   const entries = [
-    ...(runs.find((run2) => run2.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id) && entry.sticky !== true),
+    ...(runs.find((run) => run.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id) && entry.sticky !== true),
     ...stickyEntries.map((entry) => ({ entry, index: Number.MAX_SAFE_INTEGER }))
   ].sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
   const rootBackend = getDurableBackend();
@@ -14347,7 +14605,7 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
     return [];
-  const rootRun = runs.find((run2) => run2.id === rootRunId);
+  const rootRun = runs.find((run) => run.id === rootRunId);
   if (rootRun === undefined)
     return [];
   const hops = workflowBoundaryHops(runs, runId);
@@ -14365,20 +14623,20 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
     return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
   });
 }
-function claimPendingDelivery(store2, runId, stageKey, messageId) {
-  let claims = pendingDeliveryClaims.get(store2);
+function claimPendingDelivery(store, runId, stageKey, messageId) {
+  let claims = pendingDeliveryClaims.get(store);
   if (claims === undefined) {
     claims = new Set;
-    pendingDeliveryClaims.set(store2, claims);
+    pendingDeliveryClaims.set(store, claims);
   }
-  const key2 = JSON.stringify([runId, stageKey, messageId]);
-  if (claims.has(key2))
+  const key = JSON.stringify([runId, stageKey, messageId]);
+  if (claims.has(key))
     return;
-  claims.add(key2);
+  claims.add(key);
   return () => {
-    claims?.delete(key2);
+    claims?.delete(key);
     if (claims?.size === 0)
-      pendingDeliveryClaims.delete(store2);
+      pendingDeliveryClaims.delete(store);
   };
 }
 function toPendingStageSender(entry) {
@@ -14442,8 +14700,8 @@ class WorkflowModelValidationError extends Error {
 }
 function formatModelValidationError(failures) {
   const lines = ["workflows: model validation failed before starting workflow.", "Unavailable or ambiguous models:"];
-  for (const failure2 of failures) {
-    lines.push(`- ${failure2.input} (${failure2.reason})`);
+  for (const failure of failures) {
+    lines.push(`- ${failure.input} (${failure.reason})`);
   }
   return lines.join(`
 `);
@@ -14551,10 +14809,10 @@ function buildModelCandidates(input) {
       failures.push(resolved);
       continue;
     }
-    const key2 = candidateKey(resolved);
-    if (seen.has(key2))
+    const key = candidateKey(resolved);
+    if (seen.has(key))
       continue;
-    seen.add(key2);
+    seen.add(key);
     candidates.push(resolved);
   }
   if (failures.length > 0)
@@ -14647,6 +14905,89 @@ class StageDeliveryActivity {
   }
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-runner-artifact-capture.ts
+class StageArtifactCapture {
+  session;
+  seen = new WeakSet;
+  accepted = [];
+  provisional;
+  receivesMessageEvents = false;
+  closed = false;
+  reset() {
+    this.session = undefined;
+    this.seen = new WeakSet;
+    this.accepted = [];
+    this.provisional = undefined;
+    this.receivesMessageEvents = false;
+    this.closed = false;
+  }
+  beginAttempt(session) {
+    if (this.closed)
+      return;
+    if (this.session === session)
+      this.scan();
+    else {
+      this.session = session;
+      this.receivesMessageEvents = false;
+      this.rememberContext();
+    }
+    this.provisional = [];
+  }
+  settleAttempt(success) {
+    if (this.closed)
+      return;
+    this.scan();
+    if (success)
+      this.accepted.push(...this.provisional ?? []);
+    this.provisional = undefined;
+  }
+  close() {
+    this.scan();
+    this.closed = true;
+    this.session = undefined;
+    this.seen = new WeakSet;
+    this.provisional = undefined;
+  }
+  onEvent(session, event) {
+    if (session !== this.session)
+      return;
+    if (event.type === "message_end") {
+      this.receivesMessageEvents = true;
+      this.capture(event.message);
+    }
+    if (event.type === "compaction_end")
+      this.rememberContext();
+  }
+  messages() {
+    this.scan();
+    return this.accepted;
+  }
+  rememberContext(session = this.session) {
+    if (session !== this.session)
+      return;
+    for (const message of this.session?.messages ?? [])
+      this.seen.add(message);
+  }
+  scan() {
+    if (this.receivesMessageEvents)
+      return;
+    for (const message of this.session?.messages ?? [])
+      this.capture(message);
+  }
+  capture(message) {
+    if (this.seen.has(message))
+      return;
+    this.seen.add(message);
+    if (message.role !== "assistant")
+      return;
+    if (message.stopReason !== "stop" && message.stopReason !== "length")
+      return;
+    if (message.content.some((block) => block.type === "toolCall"))
+      return;
+    (this.provisional ?? this.accepted).push(structuredClone(message));
+  }
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-candidate.ts
 function effectiveCandidateReasoning(candidate, fallback) {
   return candidate.reasoningLevel ?? fallback;
@@ -14852,6 +15193,23 @@ function extractMessageText(message) {
   }
   return "";
 }
+function assistantArtifactTextForGeneration(messages) {
+  const answers = messages.flatMap((message) => {
+    if (message.role !== "assistant")
+      return [];
+    if (message.stopReason !== "stop" && message.stopReason !== "length")
+      return [];
+    if (message.content.some((block) => block.type === "toolCall"))
+      return [];
+    const text = extractMessageText(message);
+    return text.length > 0 ? [text] : [];
+  });
+  return answers.map((text, index) => index === 0 ? text : `
+
+## Supplement ${index}
+
+${text}`).join("");
+}
 function lastAssistantTextFromMessages(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
@@ -14872,7 +15230,7 @@ function structuredOutputTurnDetail(messages, startIndex) {
   }
   return "The model produced no assistant message after the prompt";
 }
-function assistantArtifactTextForToolCall(messages, toolCallId2) {
+function assistantArtifactTextForToolCall(messages, toolCallId) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
     if (message?.role !== "assistant")
@@ -14880,7 +15238,7 @@ function assistantArtifactTextForToolCall(messages, toolCallId2) {
     const { content } = message;
     if (!Array.isArray(content))
       continue;
-    if (!content.some((block) => block.type === "toolCall" && block.id === toolCallId2))
+    if (!content.some((block) => block.type === "toolCall" && block.id === toolCallId))
       continue;
     const text = extractMessageText(message);
     if (text.trim().length > 0)
@@ -14955,8 +15313,8 @@ function terminatingToolResultText(messages, terminatingToolCallIds) {
     if (!message)
       continue;
     if (message.role === "toolResult") {
-      const toolCallId2 = message.toolCallId;
-      if (typeof toolCallId2 !== "string" || !terminatingToolCallIds.has(toolCallId2)) {
+      const toolCallId = message.toolCallId;
+      if (typeof toolCallId !== "string" || !terminatingToolCallIds.has(toolCallId)) {
         return;
       }
       const text = extractMessageText(message).trim();
@@ -14989,27 +15347,27 @@ function assistantMessage(text) {
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-options.ts
 import { SessionManager } from "@bastani/atomic";
-function workflowSessionOptions(meta2) {
+function workflowSessionOptions(meta) {
   return {
     internal: true,
-    workflow: { runId: meta2.runId, stageId: meta2.stageId, stageName: meta2.stageName }
+    workflow: { runId: meta.runId, stageId: meta.stageId, stageName: meta.stageName }
   };
 }
-function workflowOrchestrationContext(meta2, stageOptions, pendingStageDelivery) {
+function workflowOrchestrationContext(meta, stageOptions, pendingStageDelivery) {
   const base = {
     kind: "workflow-stage",
-    workflowRunId: meta2.runId,
-    workflowStageId: meta2.stageId,
-    workflowStageName: meta2.stageName,
+    workflowRunId: meta.runId,
+    workflowStageId: meta.stageId,
+    workflowStageName: meta.stageName,
     constraints: { disableWorkflowTool: true }
   };
-  const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions, meta2.workflowIntercomGroup) : undefined;
+  const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions, meta.workflowIntercomGroup) : undefined;
   const context = intercomGroup ? { ...base, intercomGroup } : base;
   return pendingStageDelivery === undefined ? context : { ...context, pendingStageDelivery };
 }
-function stripWorkflowOnlyOptions(options, defaultSessionDir, meta2, pendingStageDelivery) {
-  const classification = workflowSessionOptions(meta2);
-  const orchestrationContext = workflowOrchestrationContext(meta2, options, pendingStageDelivery);
+function stripWorkflowOnlyOptions(options, defaultSessionDir, meta, pendingStageDelivery) {
+  const classification = workflowSessionOptions(meta);
+  const orchestrationContext = workflowOrchestrationContext(meta, options, pendingStageDelivery);
   if (!options) {
     return defaultSessionDir === undefined ? { orchestrationContext } : {
       orchestrationContext,
@@ -15090,7 +15448,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(() => {});
@@ -15098,7 +15457,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;
@@ -15106,6 +15469,7 @@ class StageSessionPause {
       failed = true;
       request.abortBoundary.reject(error);
       request.deferred.reject(error);
+      request.taskControl?.resumeTasks?.();
       await this.rollbackNativePause(request.nativeQueuePause);
       throw error;
     } finally {
@@ -15173,6 +15537,7 @@ class StageSessionPause {
       if (releaseAdmitted)
         return;
       beforeRelease?.();
+      request.taskControl?.resumeTasks?.();
       releaseAdmitted = true;
     };
     let releasedQueuedMessages;
@@ -15269,6 +15634,9 @@ async function rejectDisposedCreatedSession(result, stageName) {
 class StageSessionReplacement {
   previous;
   cleanups = new Set;
+  get retiringSession() {
+    return this.previous;
+  }
   retire(session) {
     this.previous = session;
   }
@@ -15348,30 +15716,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")
@@ -15652,7 +16021,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;
@@ -15671,9 +16040,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;
@@ -15796,10 +16181,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);
       };
@@ -15821,18 +16206,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;
@@ -15849,10 +16235,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;
@@ -15900,10 +16288,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;
       }
@@ -15997,14 +16385,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);
@@ -16144,6 +16532,7 @@ class StageSessionController {
     let retainedPrompt;
     let terminalScanStartIndex;
     while (true) {
+      this.artifactCapture.beginAttempt(activeSession);
       const messagesBeforeAttempt = [...activeSession.messages];
       try {
         if (retryAdmittedPrompt) {
@@ -16186,6 +16575,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)
@@ -16352,9 +16742,9 @@ class StageSessionController {
     while (true) {
       try {
         if (pendingFailure !== undefined) {
-          const failure2 = pendingFailure;
+          const failure = pendingFailure;
           pendingFailure = undefined;
-          throw failure2.error;
+          throw failure.error;
         }
         return await this.createSessionObservingPause(candidate, consumer);
       } catch (error) {
@@ -16471,6 +16861,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);
@@ -16554,6 +16945,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,
@@ -16568,17 +16960,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({
@@ -16613,6 +17007,7 @@ class StageSessionController {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
+    this.artifactCapture.settleAttempt(false);
     const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
@@ -16636,6 +17031,7 @@ class StageSessionController {
     return this.structuredOutputCapture?.called === true && this.opts.signal?.aborted !== true;
   }
   recordSuccessfulAttempt(candidate) {
+    this.artifactCapture.settleAttempt(true);
     const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
@@ -16843,7 +17239,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);
@@ -16889,7 +17285,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,
@@ -16898,21 +17294,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;
@@ -16920,15 +17335,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;
@@ -16970,17 +17393,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;
       }
@@ -17045,7 +17479,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();
@@ -17076,6 +17510,11 @@ function createStageContext2(opts) {
     },
     async __closeGeneration() {
       await controller.closeGeneration();
+      if (artifactOptions && !artifactClosed) {
+        await exportArtifact();
+        artifactClosed = true;
+      }
+      return artifactOptions ? lastFinalizedOutput : undefined;
     },
     __sessionMeta() {
       return controller.sessionMeta();
@@ -17110,7 +17549,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) => {
@@ -17127,14 +17566,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(() => {
@@ -17155,12 +17594,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;
@@ -17171,8 +17610,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]);
     }
   };
@@ -17253,16 +17692,16 @@ function createWorkflowStageFactory(input) {
         throwIfWorkflowExitSelected: input.exit.throwIfWorkflowExitSelected
       });
     }
-    const applyModelFallbackMeta = (meta2) => {
-      if (meta2.model !== undefined)
-        stageSnapshot.model = meta2.model;
-      if (meta2.attemptedModels !== undefined)
-        stageSnapshot.attemptedModels = meta2.attemptedModels;
-      if (meta2.modelAttempts !== undefined)
-        stageSnapshot.modelAttempts = meta2.modelAttempts;
-      if (meta2.warnings !== undefined) {
-        if (meta2.warnings.length > 0)
-          stageSnapshot.warnings = meta2.warnings;
+    const applyModelFallbackMeta = (meta) => {
+      if (meta.model !== undefined)
+        stageSnapshot.model = meta.model;
+      if (meta.attemptedModels !== undefined)
+        stageSnapshot.attemptedModels = meta.attemptedModels;
+      if (meta.modelAttempts !== undefined)
+        stageSnapshot.modelAttempts = meta.modelAttempts;
+      if (meta.warnings !== undefined) {
+        if (meta.warnings.length > 0)
+          stageSnapshot.warnings = meta.warnings;
         else
           delete stageSnapshot.warnings;
       }
@@ -17290,8 +17729,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);
       },
@@ -17363,13 +17802,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;
@@ -17709,7 +18148,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);
@@ -17737,7 +18176,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;
@@ -17750,14 +18189,17 @@ async function run(def, inputs, opts = {}) {
     terminalEvents.selectCancellation(ownController.signal.reason);
   }, { once: true });
   const callerSignal = opts.signal;
-  const onCallerAbort = () => ownController.abort(callerSignal?.reason);
+  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") } : {},
@@ -17766,7 +18208,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);
@@ -17808,9 +18250,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);
   };
@@ -18005,7 +18447,7 @@ async function run(def, inputs, opts = {}) {
   };
   const taskRunners = createWorkflowTaskRunners({ runtime });
   let pendingChildDurableInvocation;
-  const workflow2 = createChildWorkflowRunner({
+  const workflow = createChildWorkflowRunner({
     runtime,
     resolveWorkflowCwd,
     nextWorkflowBoundaryReplayKey,
@@ -18138,7 +18580,7 @@ async function run(def, inputs, opts = {}) {
     },
     recordCachedStage,
     runTopology: durableRunTopology(runSnapshot),
-    workflow: workflow2
+    workflow
   });
   const pendingChildWorkflows = new Set;
   const durableStage = createDurableStagePrimitive({
@@ -18251,11 +18693,12 @@ async function run(def, inputs, opts = {}) {
   });
   terminalEvents.register();
   try {
+    workflowObservationRuntime(activeStore).startRun(runId);
+    activeStore.recordRunStart(runSnapshot);
     if (callerSignal?.aborted)
       onCallerAbort();
     else
       callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
-    activeStore.recordRunStart(runSnapshot);
     if (ownsCancellationRegistration)
       opts.cancellation?.register(runId, ownController);
     opts.onRunStart?.(runSnapshot);
@@ -18406,15 +18849,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);
@@ -18443,6 +18886,7 @@ async function run(def, inputs, opts = {}) {
     });
   } finally {
     callerSignal?.removeEventListener("abort", onCallerAbort);
+    workflowObservationRuntime(activeStore).finishRun(runId);
     runtimeSettled.resolve();
     unregisterRunControl();
     try {
@@ -18482,45 +18926,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