@bastani/atomic 0.9.40 → 0.9.41-alpha.2

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

@@ -11,7 +11,7 @@ ${KEEP_CONTEXT_CLOSE_TAG}`;
 }
 // dist/builtin/workflows/src/authoring/workflow.ts
 import { basename } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/builtin/workflows/src/shared/budget.ts
 function enforceDurationBudget(reading, budget, options = {}) {
@@ -87,6 +87,89 @@ function resolve_budget(layers) {
 var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15;
 var WORKFLOW_HEARTBEAT_CUSTOM_TYPE = "workflows:workflow-heartbeat";
 
+// dist/builtin/workflows/src/runs/shared/prompt-callsite.ts
+import { fileURLToPath } from "node:url";
+var PACKAGED_WORKFLOW_RUNTIME_ROOTS = ["/dist/builtin/workflows/src/"];
+function normalizeSlashes(path) {
+  return path.replace(/\\/g, "/");
+}
+function normalizeStackPath(framePath) {
+  let normalized = framePath;
+  if (normalized.startsWith("file://")) {
+    try {
+      normalized = fileURLToPath(normalized);
+    } catch {
+      try {
+        normalized = decodeURIComponent(new URL(normalized).pathname);
+      } catch {}
+    }
+  }
+  normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
+  return normalized;
+}
+function currentModuleRuntimeRoot() {
+  const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
+  const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
+  for (const marker of markers) {
+    const index = modulePath.indexOf(marker);
+    if (index >= 0)
+      return modulePath.slice(0, index + marker.length);
+  }
+  return;
+}
+var CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
+function isWorkflowRuntimeFrame(normalizedPath) {
+  const path = normalizeSlashes(normalizedPath);
+  if (path.startsWith("packages/workflows/src/"))
+    return true;
+  if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
+    return true;
+  }
+  const comparable = path.startsWith("/") ? path : `/${path}`;
+  return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
+}
+function parsePromptStackFrame(stackLine) {
+  const line = stackLine.trim();
+  if (line.length === 0)
+    return;
+  if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:"))
+    return;
+  const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
+  if (!match)
+    return;
+  const [, rawFramePath, lineNumber, columnNumber] = match;
+  if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined)
+    return;
+  const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
+  return { normalizedPath, lineNumber, columnNumber };
+}
+function normalizedPromptCallsiteFrame(stackLine) {
+  const frame = parsePromptStackFrame(stackLine);
+  if (frame === undefined)
+    return;
+  if (isWorkflowRuntimeFrame(frame.normalizedPath))
+    return;
+  return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
+}
+function selectPromptCallsiteFrame(stack) {
+  return stack.split(`
+`).slice(1).map(normalizedPromptCallsiteFrame).find((candidate) => candidate !== undefined);
+}
+
+// dist/builtin/workflows/src/shared/workflow-source.ts
+var WORKFLOW_SOURCES = new WeakMap;
+var OWN_MODULE_PATH = normalizeStackPath(import.meta.url);
+function isWorkflowRuntimeModule(path) {
+  const normalized = normalizeStackPath(path);
+  return normalized === OWN_MODULE_PATH || isWorkflowRuntimeFrame(normalized);
+}
+function recordWorkflowSource(definition, path) {
+  WORKFLOW_SOURCES.set(definition, path);
+}
+function workflowSource(definition) {
+  return WORKFLOW_SOURCES.get(definition);
+}
+
 // dist/builtin/workflows/src/workflows/identity.ts
 function normalizeWorkflowName(name) {
   if (!name || typeof name !== "string") {
@@ -123,7 +206,7 @@ function stackFilePath(line) {
   if (!rawPath.startsWith("file://"))
     return rawPath;
   try {
-    return fileURLToPath(rawPath);
+    return fileURLToPath2(rawPath);
   } catch {
     return;
   }
@@ -134,8 +217,10 @@ function isWorkflowAuthoringImplementationFrame(filePath) {
     return false;
   return normalized.includes("/packages/workflows/") || normalized.includes("/dist/builtin/workflows/") || normalized.includes("/.atomic/agent/extensions/workflows/");
 }
-function workflowNameFromCaller() {
-  const stack = new Error().stack;
+function callerSourcePath(entry) {
+  const capture = new Error;
+  Error.captureStackTrace(capture, entry);
+  const stack = capture.stack;
   if (stack === undefined)
     return;
   for (const line of stack.split(`
@@ -145,14 +230,18 @@ function workflowNameFromCaller() {
       continue;
     if (isWorkflowAuthoringImplementationFrame(filePath))
       continue;
-    const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
-    if (base.length > 0)
-      return base;
+    return isWorkflowRuntimeModule(filePath) ? undefined : filePath;
   }
   return;
 }
-function resolveWorkflowName(name) {
-  const resolved = name ?? workflowNameFromCaller();
+function workflowNameFromSourcePath(filePath) {
+  if (filePath === undefined)
+    return;
+  const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
+  return base.length > 0 ? base : undefined;
+}
+function resolveWorkflowName(name, sourcePath) {
+  const resolved = name ?? workflowNameFromSourcePath(sourcePath);
   if (resolved === undefined) {
     throw new TypeError("workflow: name must be provided when caller filename cannot be inferred");
   }
@@ -188,7 +277,8 @@ function workflow(spec) {
     throw new TypeError("workflow: heartbeatIntervalMinutes must be a non-negative finite number");
   }
   assertWorkflowBudget(spec.budget, "workflow: budget");
-  const name = resolveWorkflowName(spec.name);
+  const source = callerSourcePath(workflow);
+  const name = resolveWorkflowName(spec.name, source);
   const normalizedName = normalizeWorkflowName(name);
   requireNonEmptyString(normalizedName, "normalized name");
   const frozenInputs = freezeSchemaMap(spec.inputs ?? {});
@@ -210,6 +300,8 @@ function workflow(spec) {
     run
   };
   const branded = stampWorkflowDefinition(definition);
+  if (source !== undefined)
+    recordWorkflowSource(branded, source);
   return Object.freeze(branded);
 }
 // dist/builtin/workflows/src/durable/journal/conformance.ts
@@ -823,6 +915,13 @@ function registerRunJournalConformance(runner, name, open, observeRead) {
 }
 // dist/builtin/workflows/src/durable/journal/internal.ts
 var JOURNAL_READ_PAGE_SIZE = 256;
+var versionReaders = new WeakMap;
+function registerRunJournalVersions(journal, versions) {
+  versionReaders.set(journal, versions);
+}
+function runJournalVersions(journal) {
+  return versionReaders.get(journal);
+}
 
 // dist/builtin/workflows/src/durable/journal/lease-expiry.ts
 function isWorkflowLeaseExpired(renewedAt, staleAfterMs, now = Date.now()) {
@@ -1107,6 +1206,10 @@ var LEGACY_COLUMNS = {
 var PENDING_LEGACY_RUNS = `SELECT ${JOURNAL_COLUMNS.runId}, ${JOURNAL_COLUMNS.headerJson}, ${JOURNAL_COLUMNS.status} FROM ${JOURNAL_TABLES.runs}
 	WHERE ${JOURNAL_COLUMNS.runId} NOT IN (SELECT ${JOURNAL_COLUMNS.runId} FROM ${CURRENT.runs})
 	AND ${JOURNAL_COLUMNS.runId} NOT IN (SELECT ${JOURNAL_COLUMNS.runId} FROM ${CURRENT.legacyDeleted})`;
+function latestEventColumns(events, runs) {
+  const latest = (column) => `COALESCE((SELECT ${column} FROM ${events} AS latest WHERE latest.${JOURNAL_COLUMNS.runId} = ${runs}.${JOURNAL_COLUMNS.runId} ORDER BY latest.${JOURNAL_COLUMNS.seq} DESC LIMIT 1), 0) AS ${column}`;
+  return `${latest(JOURNAL_COLUMNS.seq)}, ${latest(JOURNAL_COLUMNS.at)}`;
+}
 async function hasLegacyTable(tx, table) {
   const columns = await tx.all("SELECT name FROM pragma_table_info(?)", JOURNAL_TABLES[table]);
   const names = new Set(columns.map((column) => column.name));
@@ -1140,6 +1243,9 @@ class LegacyJournalRuns {
   async find(executor, runId) {
     return executor.get(`${PENDING_LEGACY_RUNS} AND ${JOURNAL_COLUMNS.runId} = ?`, runId);
   }
+  async versions(executor) {
+    return executor.all(`SELECT pending.${JOURNAL_COLUMNS.runId}, ${latestEventColumns(JOURNAL_TABLES.events, "pending")} FROM (${PENDING_LEGACY_RUNS}) AS pending`);
+  }
   async events(executor, runId, fromSeq, limit) {
     return executor.all(`SELECT ${LEGACY_COLUMNS.events.join(", ")} FROM ${JOURNAL_TABLES.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.seq} >= ? ORDER BY ${JOURNAL_COLUMNS.seq} LIMIT ?`, runId, fromSeq, limit);
   }
@@ -1190,6 +1296,10 @@ class SqlRunJournal {
     this.database = database;
     this.tables = tables;
     this.legacy = legacy;
+    registerRunJournalVersions(this, {
+      changeToken: () => this.changeToken(),
+      runVersions: () => this.runVersions()
+    });
   }
   static async open(database, options = {}) {
     const t = renderStorageIdentifiers2("journal", JOURNAL_TABLES, options.prefix);
@@ -1288,6 +1398,27 @@ class SqlRunJournal {
       return [...rows, ...legacy].map((row) => ({ ...JSON.parse(row[JOURNAL_COLUMNS.headerJson]), status: row[JOURNAL_COLUMNS.status] })).sort((left, right) => left.runId < right.runId ? -1 : left.runId > right.runId ? 1 : 0);
     });
   }
+  async changeToken() {
+    this.assertOpen();
+    return this.operation(async () => {
+      const row = await this.database.get(`SELECT data_version, total_changes() AS changes,
+					(SELECT count(*) FROM ${this.tables.runs}) AS runs,
+					(SELECT max(rowid) FROM ${this.tables.events}) AS last_event
+				FROM pragma_data_version`);
+      return JSON.stringify(Object.values(row ?? {}).map(String));
+    });
+  }
+  async runVersions() {
+    this.assertOpen();
+    return this.operation(async () => {
+      const rows = await this.database.all(`SELECT runs.${JOURNAL_COLUMNS.runId}, ${latestEventColumns(this.tables.events, "runs")} FROM ${this.tables.runs} AS runs`);
+      const legacy = await this.legacy?.versions(this.database) ?? [];
+      return new Map([...rows, ...legacy].map((row) => [
+        row[JOURNAL_COLUMNS.runId],
+        { seq: journalCounter(row[JOURNAL_COLUMNS.runId], "seq", row[JOURNAL_COLUMNS.seq]), at: Number(row[JOURNAL_COLUMNS.at]) }
+      ]));
+    });
+  }
   async requireRun(tx, runId) {
     if (await tx.get(`SELECT ${JOURNAL_COLUMNS.runId} FROM ${this.tables.runs} WHERE ${JOURNAL_COLUMNS.runId} = ?`, runId))
       return;
@@ -1669,6 +1800,7 @@ import { join as join3 } from "node:path";
 import {
   isStaleExtensionContextError,
   ModelRuntime,
+  noOpUIContext,
   resolveRestoredModelReference
 } from "@bastani/atomic";
 
@@ -4978,7 +5110,14 @@ function stripWorkflowOnlyOptions(options) {
   if (!options)
     return options;
   const maybeWorkflowOptions = options;
-  const { schema: _schema, mcp: _mcp, fallbackModels, group: _group, ...sessionOptions } = maybeWorkflowOptions;
+  const {
+    schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
+    mcp: _mcp,
+    fallbackModels,
+    group: _group,
+    ...sessionOptions
+  } = maybeWorkflowOptions;
   return fallbackModels?.length === 0 ? { ...sessionOptions, fallbackModels: [] } : sessionOptions;
 }
 function emitLateIntercomRoute(pi, meta, messages, options, batch) {
@@ -5095,6 +5234,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     notify: ui.notify ?? (() => {
       return;
     }),
+    requestRender: noOpUIContext.requestRender,
     onTerminalInput: ui.onTerminalInput ?? (() => () => {
       return;
     }),
@@ -5154,7 +5294,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     getEditorComponent: ui.getEditorComponent ?? (() => {
       return;
     }),
-    theme: ui.theme,
+    theme: ui.theme ?? noOpUIContext.theme,
     getAllThemes: ui.getAllThemes ?? (() => []),
     getTheme: ui.getTheme ?? (() => {
       return;
@@ -5164,9 +5304,8 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     setToolsExpanded: ui.setToolsExpanded ?? (() => {
       return;
     }),
-    getChatRenderSettings: ui.getChatRenderSettings ?? (() => {
-      return;
-    })
+    getFooterDataProvider: noOpUIContext.getFooterDataProvider,
+    getChatRenderSettings: ui.getChatRenderSettings ?? noOpUIContext.getChatRenderSettings
   };
 }
 function findStageModel(runtime, reference) {
@@ -5909,75 +6048,6 @@ function buildStagePromptAdapter(id, kind, args, createdAt) {
   };
 }
 
-// dist/builtin/workflows/src/runs/shared/prompt-callsite.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-var PACKAGED_WORKFLOW_RUNTIME_ROOTS = ["/dist/builtin/workflows/src/"];
-function normalizeSlashes(path) {
-  return path.replace(/\\/g, "/");
-}
-function normalizeStackPath(framePath) {
-  let normalized = framePath;
-  if (normalized.startsWith("file://")) {
-    try {
-      normalized = fileURLToPath2(normalized);
-    } catch {
-      try {
-        normalized = decodeURIComponent(new URL(normalized).pathname);
-      } catch {}
-    }
-  }
-  normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
-  return normalized;
-}
-function currentModuleRuntimeRoot() {
-  const modulePath = normalizeStackPath(fileURLToPath2(import.meta.url));
-  const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
-  for (const marker of markers) {
-    const index = modulePath.indexOf(marker);
-    if (index >= 0)
-      return modulePath.slice(0, index + marker.length);
-  }
-  return;
-}
-var CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
-function isWorkflowRuntimeFrame(normalizedPath) {
-  const path = normalizeSlashes(normalizedPath);
-  if (path.startsWith("packages/workflows/src/"))
-    return true;
-  if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
-    return true;
-  }
-  const comparable = path.startsWith("/") ? path : `/${path}`;
-  return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
-}
-function parsePromptStackFrame(stackLine) {
-  const line = stackLine.trim();
-  if (line.length === 0)
-    return;
-  if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:"))
-    return;
-  const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
-  if (!match)
-    return;
-  const [, rawFramePath, lineNumber, columnNumber] = match;
-  if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined)
-    return;
-  const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
-  return { normalizedPath, lineNumber, columnNumber };
-}
-function normalizedPromptCallsiteFrame(stackLine) {
-  const frame = parsePromptStackFrame(stackLine);
-  if (frame === undefined)
-    return;
-  if (isWorkflowRuntimeFrame(frame.normalizedPath))
-    return;
-  return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
-}
-function selectPromptCallsiteFrame(stack) {
-  return stack.split(`
-`).slice(1).map(normalizedPromptCallsiteFrame).find((candidate) => candidate !== undefined);
-}
-
 // dist/builtin/workflows/src/shared/resume-continuation.ts
 var RESUME_CONTINUATION_PROMPT = "Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";
 
@@ -6331,6 +6401,10 @@ function schemaIsRequired(schema) {
 
 // dist/builtin/workflows/src/runs/shared/validate-inputs.ts
 import { Value as Value2 } from "typebox/value";
+function firstSchemaError(def, value, kind) {
+  const first = [...Value2.Errors(def, value)][0];
+  return first === undefined ? `does not match ${kind} schema` : first.message;
+}
 function validateInputs(schema, inputs) {
   const errors = [];
   for (const key of Object.keys(inputs)) {
@@ -6359,12 +6433,16 @@ function validateInputs(schema, inputs) {
         if (typeof value !== "number" || !Number.isFinite(value)) {
           errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value)) {
+          errors.push({ key, reason: firstSchemaError(def, value, kind) });
         }
         break;
       case "integer":
         if (typeof value !== "number" || !Number.isInteger(value)) {
           errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value)) {
+          errors.push({ key, reason: firstSchemaError(def, value, kind) });
         }
         break;
       case "boolean":
@@ -9492,6 +9570,8 @@ class JournalDurableBackend {
   persistent;
   projection = createJournalProjection();
   sequences = new Map;
+  foldedAt = new Map;
+  catalogToken;
   leases = new Map;
   executions = new Map;
   executionContext = new AsyncLocalStorage2;
@@ -9535,7 +9615,7 @@ class JournalDurableBackend {
     try {
       this.ensureOpen();
       if (requiresActiveExecution)
-        this.assertExecutionActive(runId);
+        this.assertExecutionActive();
     } catch (error) {
       return Promise.reject(error);
     }
@@ -9588,6 +9668,7 @@ class JournalDurableBackend {
         this.projection.applyWorkflowSnapshot({ ...handle, pendingStageMessages: messages });
     }
     this.sequences.set(entry.runId, entry.seq);
+    this.foldedAt.set(entry.runId, entry.at);
   }
   *entries(runId, fromSeq) {
     return yield* invoke(async () => {
@@ -9601,6 +9682,7 @@ class JournalDurableBackend {
     const entries = yield* this.entries(runId);
     this.projection.deleteWorkflow(runId);
     this.sequences.delete(runId);
+    this.foldedAt.delete(runId);
     this.prompts.delete(runId);
     for (const entry of entries)
       this.fold(entry);
@@ -9613,7 +9695,7 @@ class JournalDurableBackend {
   }
   *current(runId) {
     this.ensureOpen();
-    this.assertExecutionActive(runId, true);
+    this.assertExecutionActive(true);
     yield* this.refresh(runId);
     if (this.projection.getWorkflow(runId) === undefined)
       return;
@@ -9632,14 +9714,14 @@ class JournalDurableBackend {
     if (this.state === "closed" || this.state === "closing" && !this.mutationContext.getStore())
       throw new JournalBackendClosedError;
   }
-  assertExecutionActive(runId, admitted = false) {
+  assertExecutionActive(admitted = false) {
     for (const [executionRunId, execution] of this.executionContext.getStore() ?? [])
       if (execution.retired && !(admitted && this.mutationContext.getStore()?.has(execution)))
-        throw new JournalExecutionRetiredError(typeof runId === "string" ? runId : executionRunId);
+        throw new JournalExecutionRetiredError(executionRunId);
   }
   *ownership(runId) {
     this.ensureOpen();
-    this.assertExecutionActive(runId, true);
+    this.assertExecutionActive(true);
     const lost = this.lost.get(runId);
     if (lost)
       throw lost;
@@ -9699,7 +9781,7 @@ class JournalDurableBackend {
     return this.serialize(input.workflowId, () => this.register(input));
   }
   *register(input) {
-    this.assertExecutionActive(input.workflowId, true);
+    this.assertExecutionActive(true);
     this.ensureOpen();
     const header = {
       runId: input.workflowId,
@@ -9923,11 +10005,36 @@ class JournalDurableBackend {
   }
   hydrateResumableWorkflows() {
     return this.serialize(this.catalogQueue, () => invoke(async () => {
-      const runs = await this.journal.listRuns();
-      for (const runId of new Set([...this.sequences.keys(), ...runs.map((run) => run.runId)]))
-        await this.hydrateWorkflow(runId);
+      const journal = runJournalVersions(this.journal);
+      if (journal === undefined) {
+        const runs = await this.journal.listRuns();
+        for (const runId of new Set([...this.sequences.keys(), ...runs.map((run) => run.runId)]))
+          await this.hydrateWorkflow(runId);
+        return;
+      }
+      const token = await journal.changeToken();
+      if (token === this.catalogToken)
+        return;
+      const versions = await journal.runVersions();
+      for (const runId of new Set([...this.sequences.keys(), ...versions.keys()]))
+        await this.serialize(runId, () => this.catchUp(runId, versions.get(runId)), false);
+      this.catalogToken = token;
     }));
   }
+  *catchUp(runId, version) {
+    const folded = this.sequences.get(runId) ?? 0;
+    if (version !== undefined && version.seq === folded && version.at === (this.foldedAt.get(runId) ?? 0))
+      return;
+    if (version !== undefined && folded > 0 && version.seq > folded) {
+      const entries = yield* this.entries(runId, folded);
+      if (entries[0]?.seq === folded && entries[0].at === this.foldedAt.get(runId)) {
+        for (const entry of entries)
+          this.fold(entry);
+        return;
+      }
+    }
+    yield* this.rebuild(runId);
+  }
   async prepareWorkflowCatalog() {
     await this.hydrateResumableWorkflows();
     return this.projection.prepareWorkflowCatalog();
@@ -9945,6 +10052,7 @@ class JournalDurableBackend {
     }
     this.leases.delete(runId);
     this.sequences.delete(runId);
+    this.foldedAt.delete(runId);
     this.prompts.delete(runId);
     this.projection.deleteWorkflow(runId);
   }
@@ -10037,7 +10145,7 @@ class JournalDurableBackend {
   }
   async withWorkflowLease(runId, action) {
     this.ensureOpen();
-    this.assertExecutionActive(runId);
+    this.assertExecutionActive();
     const context = this.executionContext.getStore();
     const active = this.executions.get(runId);
     if (active !== undefined && context?.get(runId) !== active)
@@ -10072,7 +10180,7 @@ class JournalDurableBackend {
     return this.serialize(runId, () => this.release(runId, execution), false);
   }
   releaseWorkflow(runId) {
-    this.assertExecutionActive(runId);
+    this.assertExecutionActive();
     return this.serialize(runId, () => this.release(runId));
   }
   *release(runId, execution) {
@@ -12574,7 +12682,12 @@ async function mapParallelSteps(steps, concurrency, failFast, mapper, onFirstFai
       if (selectedFailure !== undefined)
         throw selectedFailure;
     }
-    throw new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    const aggregate = new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    if (failFastEnabled)
+      throw aggregate;
+    const failedIndexes = new Set(failures.map((failure) => failure.index));
+    const partialResults = Array.from({ length: steps.length }, (_, index) => failedIndexes.has(index) ? undefined : results[index]);
+    throw Object.assign(aggregate, { partialResults });
   }
   return results;
 }
@@ -14374,13 +14487,24 @@ class ConcurrencyLimiter {
   get queued() {
     return this._queue.length;
   }
-  acquire() {
+  acquire(signal) {
+    if (signal?.aborted)
+      return Promise.reject(signal.reason);
     if (this._running < this.limit) {
       this._running++;
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
-      this._queue.push(resolve);
+    return new Promise((resolve, reject) => {
+      const grant = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      const onAbort = () => {
+        this._queue.splice(this._queue.indexOf(grant), 1);
+        reject(signal?.reason);
+      };
+      this._queue.push(grant);
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
   }
   release() {
@@ -14391,8 +14515,8 @@ class ConcurrencyLimiter {
       this._running--;
     }
   }
-  async run(fn) {
-    await this.acquire();
+  async run(fn, signal) {
+    await this.acquire(signal);
     try {
       return await fn();
     } finally {
@@ -14592,6 +14716,7 @@ function createWorkflowExitManager(input) {
       ...outputSnapshot !== undefined ? { outputSnapshot } : {},
       ...validationError !== undefined ? { validationError } : {}
     }));
+    input.onExitSelected?.(selectedExit);
     input.controller.abort(selectedExit);
     runWorkflowExitCleanups(reason);
     throw selectedExit;
@@ -15355,6 +15480,22 @@ function createChildWorkflowRunner(input) {
     }
   };
 }
+// dist/builtin/workflows/src/shared/error-with-causes.ts
+var MAX_CAUSE_DEPTH = 5;
+function describeErrorWithCauses(error) {
+  const messages = [];
+  const visited = new Set;
+  let current = error;
+  for (let depth = 0;current !== undefined && depth < MAX_CAUSE_DEPTH && !visited.has(current); depth++) {
+    visited.add(current);
+    const message = current instanceof Error ? current.message : String(current);
+    if (!messages.includes(message))
+      messages.push(message);
+    current = current instanceof Error ? current.cause : undefined;
+  }
+  return messages.join(": ");
+}
+
 // dist/builtin/workflows/src/shared/returned-run-status.ts
 var RETURNED_BLOCKED_STATUSES = new Set([
   "blocked",
@@ -15452,12 +15593,22 @@ function stringResultField(result, key) {
 
 // dist/builtin/workflows/src/engine/run-durable-finalize.ts
 async function finalizeDurableTerminalStatus(input) {
+  try {
+    await commitDurableTerminalStatus(input);
+  } catch (error) {
+    if (input.store !== undefined)
+      recordDurableEndingFailure(input.store, input.runSnapshot, error);
+    throw error;
+  }
+}
+async function commitDurableTerminalStatus(input) {
   if (!input.isRoot)
     return;
   const status = effectiveRunStatus(input.runSnapshot);
   const isExitTerminal = input.runSnapshot.exited === true && status !== "running";
   const isBlocked = status === "blocked" && (input.runSnapshot.endedAt !== undefined || input.runSnapshot.blockedAt !== undefined);
-  if (status !== "failed" && status !== "killed" && !isExitTerminal && !isBlocked)
+  const isUncommittedCompletion = status === "completed" && input.terminalStatusCommitted === false;
+  if (status !== "failed" && status !== "killed" && !isExitTerminal && !isBlocked && !isUncommittedCompletion)
     return;
   const durableStatus = toDurableStatus(status);
   if (durableStatus !== undefined) {
@@ -15467,7 +15618,7 @@ async function finalizeDurableTerminalStatus(input) {
       if (input.runSnapshot.result !== undefined)
         throw error;
     }
-    if (durableStatus === "failed" || durableStatus === "blocked") {
+    if (durableStatus === "failed" || durableStatus === "blocked" || isUncommittedCompletion) {
       await recordRunTimingCheckpointAsync(input.durableBackend, input.runSnapshot);
     }
     const failure = durableStatus === "failed" ? {
@@ -15485,6 +15636,16 @@ async function finalizeDurableTerminalStatus(input) {
     await input.durableBackend.commitWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure);
   }
 }
+function recordDurableEndingFailure(store, runSnapshot, error) {
+  const detail = describeErrorWithCauses(error);
+  store.recordNotice({
+    id: `workflow-durable-ending-failed:${runSnapshot.id}`,
+    runId: runSnapshot.id,
+    level: "error",
+    message: `Workflow "${runSnapshot.name}" ended ${runSnapshot.status}, but its final state could not be saved to the workflow journal: ${detail}. Readers of the journal may report it as crashed.`,
+    createdAt: Date.now()
+  });
+}
 function toDurableStatus(status) {
   switch (status) {
     case "completed":
@@ -15777,7 +15938,7 @@ function compareDraftSourceOrder(left, right) {
 function runTopologyFor(drafts, tools) {
   return drafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run ?? tools.find((checkpoint) => checkpoint.topology?.run !== undefined)?.topology?.run;
 }
-function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
+function validateRunGroups(grouped, rootRunId, tools, checkpoints, allowPendingChildren = false) {
   const toolsFor = (runId) => tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
   const owners = new Map;
   const syntheticChildIds = new Set;
@@ -15789,6 +15950,11 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
       if (childRunId === parentRunId || owners.has(childRunId))
         return false;
       if (!grouped.has(childRunId)) {
+        if (allowPendingChildren && isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) && !childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId)) {
+          syntheticChildIds.add(childRunId);
+          owners.set(childRunId, draft);
+          continue;
+        }
         if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId))
           return false;
         syntheticChildIds.add(childRunId);
@@ -15821,6 +15987,10 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
   }
   return true;
 }
+function isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) {
+  const boundary = draft.topology?.boundary;
+  return workflowChildFromDraft(draft) === undefined && boundary?.event === "start" && boundary.status === "running" && boundary.child.runId === childRunId && boundary.child.parentRunId === parentRunId && boundary.child.parentStageId === draft.topology?.stageId && boundary.child.rootRunId === rootRunId;
+}
 function isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) {
   const child = workflowChildFromDraft(draft);
   const boundary = draft.topology?.boundary;
@@ -16236,11 +16406,17 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   retainReachableRunGroups(grouped, rootRunId);
   if (policy.failOnUnreachable && grouped.size !== groupedCount)
     return [];
-  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints))
+  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints, policy.retainActive))
     return [];
   const syntheticChildren = [];
+  const pendingChildren = [];
   for (const [parentRunId, runDrafts] of grouped) {
     for (const draft of runDrafts) {
+      const pendingChildRunId = childRunIdFromDraft(draft);
+      if (policy.retainActive && pendingChildRunId !== undefined && !grouped.has(pendingChildRunId) && isPendingChildBoundary(draft, parentRunId, pendingChildRunId, rootRunId)) {
+        pendingChildren.push({ parentRunId, owner: draft });
+        continue;
+      }
       const child = workflowChildFromDraft(draft);
       if (child?.exited !== true || grouped.has(child.runId))
         continue;
@@ -16349,6 +16525,28 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       resumable: false
     });
   }
+  for (const { parentRunId, owner } of pendingChildren) {
+    if (!emittedRunIds.has(parentRunId))
+      return [];
+    const topology = owner.topology;
+    const boundary = topology.boundary;
+    const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
+    if (parentStageId === undefined)
+      return [];
+    runs.push({
+      id: boundary.child.runId,
+      name: boundary.child.runName,
+      inputs: {},
+      status: "running",
+      stages: [],
+      toolNodes: [],
+      startedAt: owner.startedAt ?? owner.firstCompletedAt,
+      parentRunId,
+      parentStageId,
+      rootRunId: boundary.child.rootRunId,
+      resumable: false
+    });
+  }
   return runs;
 }
 function stageSnapshotFromDraft(draft, id, parentIds) {
@@ -16664,6 +16862,402 @@ function deferStageUntilRunRelease(input) {
   };
 }
 
+// dist/builtin/workflows/src/engine/run-rejection-boundary.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { inspect } from "node:util";
+var EVENT = "unhandledRejection";
+var BOUNDARY_KEY = Symbol.for("atomic-workflows/run-rejection-boundary@5");
+var FLAG = "--unhandled-rejections";
+var MAX_CAUSE_DEPTH2 = 8;
+var MAX_PRIMITIVES_PER_RUN = 64;
+var MAX_STOP_STRINGS = 64;
+var ENDED_RUN_GRACE_MS = 30000;
+var NATIVE_REPORTING_MODES = new Set(["throw", "warn-with-error-code"]);
+function boundaryBag() {
+  return globalThis;
+}
+function sharedBoundary() {
+  const bag = boundaryBag();
+  const existing = bag[BOUNDARY_KEY];
+  if (existing !== undefined && existing.version === 5)
+    return existing;
+  const created = {
+    version: 5,
+    store: new AsyncLocalStorage3,
+    owners: new WeakMap,
+    promises: new WeakMap,
+    scopes: new Set,
+    runs: new Map,
+    ended: new Map,
+    stops: new Set,
+    listener: undefined
+  };
+  bag[BOUNDARY_KEY] = created;
+  return created;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPrimitive(value) {
+  return !isObject(value);
+}
+function safeField3(value, key) {
+  try {
+    return value[key];
+  } catch {
+    return;
+  }
+}
+function strongerEffect(left, right) {
+  return left === "fail-run" || right === "fail-run" ? "fail-run" : "ignore";
+}
+function addAttribution(into, scope, effect) {
+  into.set(scope, strongerEffect(into.get(scope), effect));
+}
+function recordedOwners(boundary, reason) {
+  const owners = new Map;
+  let stopped = false;
+  const seen = new Set;
+  const pending = [{ value: reason, depth: 0 }];
+  while (pending.length > 0) {
+    const { value, depth } = pending.pop();
+    if (depth > MAX_CAUSE_DEPTH2)
+      continue;
+    if (isPrimitive(value)) {
+      if (depth === 0 || value !== undefined && value !== null) {
+        for (const scope of boundary.scopes) {
+          const entry = scope.primitives.get(value);
+          if (entry !== undefined)
+            addAttribution(owners, scope, entry.effect);
+        }
+        if (typeof value === "string" && boundary.stops.has(value))
+          stopped = true;
+      }
+      continue;
+    }
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    for (const [scope, effect] of boundary.owners.get(value) ?? [])
+      addAttribution(owners, scope, effect);
+    pending.push({ value: safeField3(value, "cause"), depth: depth + 1 });
+    const errors = safeField3(value, "errors");
+    if (Array.isArray(errors))
+      for (const entry of errors)
+        pending.push({ value: entry, depth: depth + 1 });
+  }
+  return { owners, stopped };
+}
+function pruneEndedSources(boundary) {
+  const now = Date.now();
+  for (const [source, trees] of boundary.ended) {
+    for (const [rootRunId, endedAt] of trees)
+      if (now - endedAt > ENDED_RUN_GRACE_MS)
+        trees.delete(rootRunId);
+    if (trees.size === 0)
+      boundary.ended.delete(source);
+  }
+}
+function recordEndedRun(boundary, scope) {
+  if (scope.source === undefined)
+    return;
+  const trees = boundary.ended.get(scope.source) ?? new Map;
+  trees.set(scope.rootRunId, Date.now());
+  boundary.ended.set(scope.source, trees);
+}
+function endedInAnotherRunTree(boundary, source, live) {
+  for (const endedRoot of boundary.ended.get(source)?.keys() ?? [])
+    if (endedRoot !== live.rootRunId)
+      return true;
+  return false;
+}
+function recognizedSources(boundary) {
+  pruneEndedSources(boundary);
+  const sources = new Set(boundary.ended.keys());
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source !== undefined)
+      sources.add(scope.source);
+  return sources;
+}
+function authoringSource(reason, sources) {
+  if (sources.size === 0 || !isObject(reason))
+    return;
+  const stack = safeField3(reason, "stack");
+  if (typeof stack !== "string")
+    return;
+  for (const line of stack.split(`
+`)) {
+    if (!line.trimStart().startsWith("at "))
+      continue;
+    const path = parsePromptStackFrame(line)?.normalizedPath;
+    if (path === undefined)
+      continue;
+    if (isWorkflowRuntimeModule(path))
+      return;
+    if (/\/node_modules\//.test(path))
+      continue;
+    if (sources.has(path))
+      return path;
+  }
+  return;
+}
+function hasAncestorIn(scope, candidates) {
+  for (let ancestor = scope.parent;ancestor !== undefined; ancestor = ancestor.parent) {
+    if (candidates.has(ancestor))
+      return true;
+  }
+  return false;
+}
+function outermostLiveRuns(boundary, source) {
+  const matching = new Set;
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source === source)
+      matching.add(scope);
+  const outermost = new Set;
+  for (const scope of matching)
+    if (!hasAncestorIn(scope, matching))
+      outermost.add(scope);
+  return outermost;
+}
+function runOfSource(boundary, source) {
+  const [only, ...others] = outermostLiveRuns(boundary, source);
+  if (only === undefined)
+    return new Map;
+  if (others.length > 0 || only.sharedSource)
+    return;
+  if (endedInAnotherRunTree(boundary, source, only))
+    return;
+  return new Map([[only, "fail-run"]]);
+}
+function markSharedSource(boundary, source) {
+  const runs = outermostLiveRuns(boundary, source);
+  if (runs.size > 1)
+    for (const run of runs)
+      run.sharedSource = true;
+}
+function rejectingRun(boundary, recorded, promise, scoped) {
+  const tracked = promise === undefined ? undefined : boundary.promises.get(promise);
+  if (tracked !== undefined && recorded.has(tracked))
+    return tracked;
+  if (scoped !== undefined && recorded.has(scoped))
+    return scoped;
+  return;
+}
+function attribute(boundary, reason, promise) {
+  const { owners: recorded, stopped } = recordedOwners(boundary, reason);
+  const scoped = boundary.store.getStore();
+  if (recorded.size > 1) {
+    const rejecting = rejectingRun(boundary, recorded, promise, scoped);
+    if (rejecting !== undefined)
+      return new Map([[rejecting, recorded.get(rejecting) ?? "fail-run"]]);
+  }
+  if (recorded.size > 0)
+    return recorded;
+  if (stopped)
+    return new Map;
+  if (scoped !== undefined && boundary.scopes.has(scoped))
+    return new Map([[scoped, "fail-run"]]);
+  const origin = authoringSource(reason, recognizedSources(boundary));
+  if (origin === undefined)
+    return;
+  if (scoped !== undefined)
+    return new Map([[scoped, "ignore"]]);
+  return runOfSource(boundary, origin);
+}
+function unhandledRejectionError(reason) {
+  return Object.assign(new Error("This error originated either by throwing inside of an async function without a catch block, " + `or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${inspect(reason)}".`), { code: "ERR_UNHANDLED_REJECTION" });
+}
+function unhandledRejectionsMode() {
+  const args = [...(process.env.NODE_OPTIONS ?? "").split(/\s+/), ...process.execArgv];
+  let mode = "throw";
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg.startsWith(`${FLAG}=`))
+      mode = arg.slice(FLAG.length + 1);
+    else if (arg === FLAG && args[index + 1] !== undefined)
+      mode = args[index + 1] ?? mode;
+  }
+  return mode;
+}
+function surfaceNatively(boundary, reason) {
+  const listener = boundary.listener;
+  if (listener === undefined || process.listenerCount(EVENT) > 1)
+    return;
+  if (!NATIVE_REPORTING_MODES.has(unhandledRejectionsMode()))
+    return;
+  process.nextTick(() => {
+    process.removeListener(EVENT, listener);
+    Promise.reject(reason);
+    setImmediate(() => {
+      if (!process.listeners(EVENT).includes(listener))
+        process.on(EVENT, listener);
+    });
+  });
+}
+function onUnhandledRejection(reason, promise) {
+  const boundary = sharedBoundary();
+  const owners = attribute(boundary, reason, promise);
+  if (owners === undefined) {
+    surfaceNatively(boundary, reason);
+    return;
+  }
+  const error = isObject(reason) ? reason : unhandledRejectionError(reason);
+  for (const [scope, effect] of owners) {
+    if (effect !== "fail-run" || !scope.live)
+      continue;
+    try {
+      scope.fail(error);
+    } catch {}
+  }
+}
+function ensureInstalled(boundary) {
+  if (boundary.listener !== undefined)
+    return;
+  boundary.listener = onUnhandledRejection;
+  process.on(EVENT, onUnhandledRejection);
+}
+function record(boundary, scope, reason, effect) {
+  if (isPrimitive(reason)) {
+    recordPrimitive(scope, reason, effect);
+    return;
+  }
+  const owners = boundary.owners.get(reason);
+  if (owners === undefined)
+    boundary.owners.set(reason, new Map([[scope, effect]]));
+  else
+    addAttribution(owners, scope, effect);
+}
+function recordStop(boundary, reason) {
+  boundary.stops.delete(reason);
+  boundary.stops.add(reason);
+  if (boundary.stops.size <= MAX_STOP_STRINGS)
+    return;
+  const oldest = boundary.stops.values().next();
+  if (!oldest.done)
+    boundary.stops.delete(oldest.value);
+}
+function recordPrimitive(scope, reason, effect) {
+  if (!scope.live)
+    return;
+  if (scope.primitives.size >= MAX_PRIMITIVES_PER_RUN && !scope.primitives.has(reason)) {
+    const oldest = scope.primitives.keys().next();
+    if (!oldest.done)
+      scope.primitives.delete(oldest.value);
+  }
+  scope.generation += 1;
+  const generation = scope.generation;
+  scope.primitives.set(reason, { effect: strongerEffect(scope.primitives.get(reason)?.effect, effect), generation });
+  afterPendingRejectionReports().then(() => {
+    if (scope.primitives.get(reason)?.generation === generation)
+      scope.primitives.delete(reason);
+  });
+}
+function discardFailure() {}
+function afterPendingRejectionReports() {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel;
+    port1.onmessage = () => {
+      port1.close();
+      port2.close();
+      resolve();
+    };
+    port2.postMessage(undefined);
+  });
+}
+function openRunRejectionScope(options) {
+  const boundary = sharedBoundary();
+  ensureInstalled(boundary);
+  pruneEndedSources(boundary);
+  const parent = options.parentRunId === undefined ? undefined : boundary.runs.get(options.parentRunId);
+  const scope = {
+    runId: options.runId,
+    rootRunId: parent?.rootRunId ?? options.runId,
+    source: options.source === undefined ? undefined : normalizeStackPath(options.source),
+    parent,
+    fail: options.fail,
+    primitives: new Map,
+    generation: 0,
+    live: true,
+    sharedSource: false
+  };
+  boundary.scopes.add(scope);
+  boundary.runs.set(scope.runId, scope);
+  if (scope.source !== undefined)
+    markSharedSource(boundary, scope.source);
+  return {
+    run: (callback) => boundary.store.run(scope, callback),
+    contain: (promise, effect = "fail-run") => {
+      boundary.promises.set(promise, scope);
+      promise.then(undefined, (reason) => record(boundary, scope, reason, effect));
+      return promise;
+    },
+    watch: (promise) => {
+      const watched = promise.then(undefined, (reason) => {
+        record(boundary, scope, reason, "fail-run");
+        throw reason;
+      });
+      boundary.promises.set(watched, scope);
+      return watched;
+    },
+    ignore: (reason) => {
+      if (typeof reason === "string")
+        recordStop(boundary, reason);
+      else
+        record(boundary, scope, reason, "ignore");
+    },
+    settle: afterPendingRejectionReports,
+    close: () => {
+      scope.live = false;
+      scope.fail = discardFailure;
+      recordEndedRun(boundary, scope);
+      afterPendingRejectionReports().then(() => {
+        scope.primitives.clear();
+        scope.parent = undefined;
+        boundary.scopes.delete(scope);
+        if (boundary.runs.get(scope.runId) === scope)
+          boundary.runs.delete(scope.runId);
+      });
+    }
+  };
+}
+var WATCHED_STAGE_METHODS = [
+  "prompt",
+  "complete",
+  "sendUserMessage",
+  "steer",
+  "followUp",
+  "setModel",
+  "setThinkingLevel",
+  "cycleModel",
+  "cycleThinkingLevel",
+  "navigateTree",
+  "compact",
+  "abort"
+];
+function containStageRejections(stage, scope) {
+  const contained = Object.create(stage);
+  const descriptors = {};
+  for (const name of WATCHED_STAGE_METHODS) {
+    descriptors[name] = {
+      value: (...args) => {
+        const result = Reflect.apply(stage[name], stage, args);
+        return result instanceof Promise ? scope.watch(result) : result;
+      }
+    };
+  }
+  Object.defineProperties(contained, descriptors);
+  return contained;
+}
+function containUiRejections(ui, scope) {
+  return {
+    input: (prompt) => scope.watch(ui.input(prompt)),
+    confirm: (message) => scope.watch(ui.confirm(message)),
+    select: (message, options) => scope.watch(ui.select(message, options)),
+    editor: (initial) => scope.watch(ui.editor(initial)),
+    custom: (factory, options) => scope.watch(ui.custom(factory, options))
+  };
+}
+
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -18760,7 +19354,9 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 import {
   AutoRoutingInferenceError,
   convertToLlm,
+  isExtensionStartupFailure,
   isModelRoutingDebugEnabled,
+  isTransientExtensionStartupFailure,
   parseModelConstraints,
   setsProviders
 } from "@bastani/atomic";
@@ -19031,6 +19627,23 @@ class StageDeliveryActivity {
   }
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-routing.ts
+var STAGE_ROUTING_CONCURRENCY = 8;
+var STAGE_ROUTING_DEADLINE_MS = 300000;
+var routingLimiter = new ConcurrencyLimiter(STAGE_ROUTING_CONCURRENCY);
+async function routeStageModel(route, input) {
+  const deadline = new AbortController;
+  const timer = setTimeout(() => deadline.abort(new Error("stage routing deadline")), STAGE_ROUTING_DEADLINE_MS);
+  try {
+    return await route({
+      ...input,
+      inference: { deadline: deadline.signal, limit: (run, signal) => routingLimiter.run(run, signal) }
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-artifact-capture.ts
 class StageArtifactCapture {
   session;
@@ -19521,6 +20134,7 @@ async function stripWorkflowOnlyOptions2(options, defaultSessionDir, meta, pendi
   }
   const {
     schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
     mcp: _mcp,
     fallbackModels,
     modelConstraints: _modelConstraints,
@@ -19768,6 +20382,15 @@ class StageSessionReplacement {
     this.previous = undefined;
     await Promise.allSettled([...previous ? [disposeStageSession(previous)] : [], ...this.cleanups]);
   }
+  async disposeRetired() {
+    const previous = this.previous;
+    this.previous = undefined;
+    if (!previous)
+      return;
+    await disposeStageSession(previous).catch((error) => {
+      console.error("atomic-workflows: retired stage session disposal failed", error);
+    });
+  }
   async disposeAfterIdle(session) {
     const agent = session.agent;
     if (typeof agent?.waitForIdle === "function")
@@ -19894,7 +20517,7 @@ class WorkflowStructuredOutputContractError extends Error {
   }
 }
 function isStructuredOutputContractFailure(message) {
-  return message.startsWith(STRUCTURED_OUTPUT_MISSING_ERROR) || message.startsWith('Validation failed for tool "structured_output":') || message.startsWith("Invalid structured output: response does not match the decision schema.") || message.startsWith("Invalid structured output: non-JSON decision.") || message.startsWith("Structured output requires one structured_output call.") || message.startsWith("Structured output requires exactly one structured_output call and no provider fallback.") || message === "Structured output requires complete judgment instructions." || message === "Structured output requires a nonempty named state object containing the task and relevant context text." || message === "Structured output inputs must be finite, acyclic JSON data." || message === "Structured output inputs must be plain JSON objects." || message === "structured_output tool call failed schema validation.";
+  return message.startsWith(STRUCTURED_OUTPUT_MISSING_ERROR) || message.startsWith('Validation failed for tool "structured_output":') || message.startsWith("Invalid structured output: response does not match the decision schema.") || message.startsWith("Invalid structured output: non-JSON decision.") || message.startsWith("Invalid structured output: tool call arguments were not valid JSON.") || message.startsWith("Structured output requires one structured_output call.") || message.startsWith("Structured output requires exactly one structured_output call and no provider fallback.") || message === "Structured output requires complete judgment instructions." || message === "Structured output requires a nonempty named state object containing the task and relevant context text." || message === "Structured output inputs must be finite, acyclic JSON data." || message === "Structured output inputs must be plain JSON objects." || message === "structured_output tool call failed schema validation.";
 }
 var STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
 function toolResultText(content) {
@@ -19946,7 +20569,8 @@ function stageOptionsWithStructuredOutput(options, capture, executionCapture) {
     return options;
   const structuredOutputTool = createStructuredOutputTool({
     schema: options.schema,
-    capture
+    capture,
+    ...options.schemaTimeoutMs === undefined ? {} : { timeoutMs: options.schemaTimeoutMs }
   });
   const executeStructuredOutput = structuredOutputTool.execute;
   const capturedStructuredOutputTool = {
@@ -20036,6 +20660,16 @@ function waitForStageStartup(operation, signal) {
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
 var WORKFLOW_STAGE_CLOSED_FOR_GOOD_STATE = "atomic:workflow-stage-closed-for-good";
 var WORKFLOW_STAGE_END_CHILDREN_STATE = "atomic:workflow-stage-end-children";
+function isRetryableSameCandidateFailure(error) {
+  if (isExtensionStartupFailure(error))
+    return isTransientExtensionStartupFailure(error);
+  return isRetryableSameModelFailure(error);
+}
+function mayAdvanceToNextCandidate(error) {
+  if (isExtensionStartupFailure(error))
+    return isTransientExtensionStartupFailure(error);
+  return isRetryableModelFailure(error);
+}
 function hasMeaningfulUsage(usage) {
   if (usage === undefined)
     return false;
@@ -20287,7 +20921,7 @@ class StageSessionController {
       return;
     if (!this.routingPromise) {
       this.beginStartup();
-      this.routingPromise = (async () => {
+      const routing = (async () => {
         const route = this.modelCatalog?.routeModel;
         if (!route)
           throw new Error("Workflow stage auto routing requires a routing-capable model catalog.");
@@ -20299,7 +20933,7 @@ class StageSessionController {
           ...thinking === undefined ? [] : [{ allowedEfforts: [thinking] }]
         ].filter((c) => c !== undefined);
         try {
-          this.modelRoute = await route({
+          this.modelRoute = await routeStageModel(route, {
             task: text,
             stageName: this.opts.stageName,
             constraints,
@@ -20320,7 +20954,17 @@ class StageSessionController {
         this.modelRoute.assertCurrent();
         this.meta.stageOptions = { ...options, model: this.modelRoute.modelOverride };
         this.opts.onModelFallbackMetaChange?.(this.currentModelFallbackMeta());
-      })();
+      })().catch((error) => {
+        if (this.routingPromise === routing) {
+          this.routingPromise = undefined;
+          this.modelRoute = undefined;
+        }
+        if (this.startupWait.signal.aborted || this.opts.signal?.aborted)
+          throw error;
+        this.settleStartup(true);
+        throw new Error(`atomic-workflows: stage "${this.opts.stageName}" failed during startup phase model-resolution: ${errorMessage2(error)}`);
+      });
+      this.routingPromise = routing;
     }
     await this.routingPromise;
   }
@@ -21075,7 +21719,7 @@ class StageSessionController {
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
-        const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
+        const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameCandidateFailure(error));
         if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.startupWait.signal.aborted || this.capturedStructuredOutputForAttempt()) {
           throw error;
         }
@@ -21487,10 +22131,11 @@ class StageSessionController {
       ...usage === undefined ? {} : { usage },
       error: message
     });
-    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !isRetryableModelFailure(err) || index === candidates.length - 1) {
+    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !mayAdvanceToNextCandidate(err) || index === candidates.length - 1) {
       this.modelWarnings.push(...this.pendingFallbackWarnings);
       this.pendingFallbackWarnings.length = 0;
       this.notifyModelFallbackMetaChange();
+      await this.replacement.disposeRetired();
       return "throw";
     }
     const nextCandidate = candidates[index + 1];
@@ -22612,13 +23257,13 @@ class EngineRuntime {
 
 // dist/builtin/workflows/src/engine/session-closed-error.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
-var MAX_CAUSE_DEPTH = 8;
+var MAX_CAUSE_DEPTH3 = 8;
 function reportsClosedSession(error) {
   return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError2(error);
 }
 function isSessionClosedError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH && current !== undefined; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH3 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -22690,7 +23335,12 @@ async function executeRun(def, resolvedInputs, opts) {
     workflowObservationRuntime(activeStore).control(runId, "kill");
     ownController.abort(callerSignal?.reason);
   };
-  const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
+  const exit = createWorkflowExitManager({
+    runId,
+    exitScope,
+    controller: ownController,
+    onExitSelected: (signal) => rejectionScope.ignore(signal)
+  });
   const sourceBackend = opts.durableBackend;
   const backendView = sourceBackend;
   const rootBackend = opts.durableRootBackend ?? backendView;
@@ -23204,6 +23854,22 @@ async function executeRun(def, resolvedInputs, opts) {
     baseFromPromptNodes: getPromptNodeUi
   });
   let pausedExit;
+  const authoredIn = workflowSource(def);
+  const rejectionScope = openRunRejectionScope({
+    runId,
+    ...opts.parentRun !== undefined ? { parentRunId: opts.parentRun.runId } : {},
+    ...authoredIn !== undefined ? { source: authoredIn } : {},
+    fail: (error) => {
+      if (findWorkflowGracefulQuit(error) !== undefined)
+        return;
+      const selected = terminalEvents.selectFailure(error);
+      if (selected.kind === "failure" && !ownController.signal.aborted)
+        ownController.abort(selected.error);
+    }
+  });
+  ownController.signal.addEventListener("abort", () => rejectionScope.ignore(ownController.signal.reason), {
+    once: true
+  });
   const ctx = {
     inputs: resolvedInputs,
     runId,
@@ -23214,28 +23880,30 @@ async function executeRun(def, resolvedInputs, opts) {
       if (scheduler.isRunPaused()) {
         pausedExit ??= whenRunning(async () => exit.exit(options));
         pausedExit.catch(() => {});
-        throw new Error("Workflow exit is waiting for explicit resume");
+        const waiting = new Error("Workflow exit is waiting for explicit resume");
+        rejectionScope.ignore(waiting);
+        throw waiting;
       }
       return exit.exit(options);
     },
-    ui,
+    ui: containUiRejections(ui, rejectionScope),
     stage: (name, options) => {
       ownController.signal.throwIfAborted();
       if (!scheduler.isRunPaused())
-        return durableStage(name, options);
+        return containStageRejections(durableStage(name, options), rejectionScope);
       const replayKey = stageReplayKeyGenerator(name);
-      return deferStageUntilRunRelease({
+      return containStageRejections(deferStageUntilRunRelease({
         name,
         create: () => durableStage(name, options, replayKey),
         isPaused: scheduler.isRunPaused,
         waitForRelease: waitForRunRelease,
         signal: ownController.signal
-      });
+      }), rejectionScope);
     },
-    task: gatedTask,
-    chain: (...args) => whenRunning(() => chain(...args)),
-    parallel: (...args) => whenRunning(() => parallel(...args)),
-    workflow: (...args) => whenRunning(() => {
+    task: (...args) => rejectionScope.watch(gatedTask(...args)),
+    chain: (...args) => rejectionScope.watch(whenRunning(() => chain(...args))),
+    parallel: (...args) => rejectionScope.watch(whenRunning(() => parallel(...args))),
+    workflow: (...args) => rejectionScope.watch(whenRunning(() => {
       const pending = durableWorkflow(...args);
       pendingChildWorkflows.add(pending);
       const settled = () => {
@@ -23243,18 +23911,17 @@ async function executeRun(def, resolvedInputs, opts) {
       };
       pending.then(settled, settled);
       return pending;
-    }),
+    })),
     tool: (...args) => {
       if (admittedTools.closed)
-        return tool(...args);
-      const pending = whenRunning(() => tool(...args));
-      pending.catch(() => {});
-      return pending;
+        return rejectionScope.contain(tool(...args), "ignore");
+      return rejectionScope.contain(whenRunning(() => tool(...args)));
     },
     ...opts.models !== undefined ? { models: opts.models } : {}
   };
   const runtimeSettled = Promise.withResolvers();
   let durableRootAdmitted = false;
+  let terminalStatusCommitted = false;
   let pausePersistence;
   let resumePersistence;
   let controlSettlements = Promise.resolve();
@@ -23400,7 +24067,7 @@ async function executeRun(def, resolvedInputs, opts) {
     while (scheduler.isRunPaused())
       await waitForRunRelease();
     ownController.signal.throwIfAborted();
-    const rawResult = await raceAbort2(runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx)), ownController.signal);
+    const rawResult = await raceAbort2(runWorkflowDefinitionCallback(def.name, runId, () => rejectionScope.run(() => def.run(ctx))), ownController.signal);
     await drainCachedStagePersistence();
     while (scheduler.isRunPaused())
       await waitForRunRelease();
@@ -23410,6 +24077,7 @@ async function executeRun(def, resolvedInputs, opts) {
     if (pausedExit !== undefined)
       await pausedExit;
     budget.rethrowIfSystemOwnedStop(runSnapshot.stages.at(-1)?.name ?? startupFrontierStage);
+    await rejectionScope.settle();
     const normalTerminalEvent = terminalEvents.winner();
     if (normalTerminalEvent?.kind === "cancellation") {
       const gracefulQuit = findWorkflowGracefulQuit(normalTerminalEvent.reason);
@@ -23444,6 +24112,7 @@ async function executeRun(def, resolvedInputs, opts) {
       await recordRunResultCheckpointAsync(durableBackend, runSnapshot);
     }
     await durableBackend.commitWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
+    terminalStatusCommitted = true;
     await appendRunEndWhenRecorded(opts.persistence, recorded, {
       runId,
       status: returned.status,
@@ -23478,6 +24147,9 @@ async function executeRun(def, resolvedInputs, opts) {
     }
     if (ownerClosing && err instanceof Error && isSessionClosedError(err))
       return await suspendForClosedSession(err);
+    if (selectedTerminalEvent.kind === "failure" && pendingChildWorkflows.size > 0 && !ownController.signal.aborted) {
+      ownController.abort(err);
+    }
     await admittedTools.closeAndDrain();
     if (ownController.signal.aborted)
       await Promise.allSettled([...pendingChildWorkflows]);
@@ -23552,6 +24224,7 @@ async function executeRun(def, resolvedInputs, opts) {
     });
     return failed;
   } finally {
+    rejectionScope.close();
     callerSignal?.removeEventListener("abort", onCallerAbort);
     workflowObservationRuntime(activeStore).finishRun(runId);
     runtimeSettled.resolve();
@@ -23565,7 +24238,9 @@ async function executeRun(def, resolvedInputs, opts) {
           runId,
           runSnapshot,
           isRoot: opts.parentRun === undefined,
-          durableBackend
+          durableBackend,
+          terminalStatusCommitted,
+          store: activeStore
         });
       }
     } finally {