@bastani/atomic 0.9.40 → 0.9.41-alpha.2

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

@@ -38933,10 +38933,23 @@ function runIndicatorStatus(run, allRuns = [run]) {
   }
   return status;
 }
+function createRunIndicatorStatusResolver(allRuns) {
+  let runsWithPendingDescendants;
+  return (run) => {
+    const status = effectiveRunStatus(run);
+    if (TERMINAL_OR_BLOCKED.has(status))
+      return status;
+    if (runHasPendingInput(run))
+      return "awaiting_input";
+    runsWithPendingDescendants ??= ancestorsOfPendingInputRuns(allRuns);
+    return runsWithPendingDescendants.has(run.id) ? "awaiting_input" : status;
+  };
+}
 function resolveRunIndicatorStatuses(runs, allRuns) {
+  const statusOf = createRunIndicatorStatusResolver(allRuns);
   const statuses = {};
   for (const run of runs)
-    statuses[run.id] = runIndicatorStatus(run, allRuns);
+    statuses[run.id] = statusOf(run);
   return statuses;
 }
 function runHasPendingInput(run) {
@@ -38944,6 +38957,30 @@ function runHasPendingInput(run) {
     return true;
   return run.stages.some((stage) => stage.status === "awaiting_input" || stage.awaitingInputSince !== undefined || stage.pendingPrompt !== undefined || stage.inputRequest !== undefined);
 }
+function ancestorsOfPendingInputRuns(allRuns) {
+  const runsById = new Map(allRuns.map((candidate) => [candidate.id, candidate]));
+  const ancestors = new Set;
+  for (const candidate of allRuns) {
+    if (TERMINAL_OR_BLOCKED.has(effectiveRunStatus(candidate)) || !runHasPendingInput(candidate))
+      continue;
+    const mark = (ancestorId) => {
+      if (ancestorId !== candidate.id)
+        ancestors.add(ancestorId);
+    };
+    if (candidate.rootRunId !== undefined)
+      mark(candidate.rootRunId);
+    const visited = new Set;
+    let current = candidate;
+    while (current !== undefined && current.parentRunId !== undefined) {
+      mark(current.parentRunId);
+      if (visited.has(current.id))
+        break;
+      visited.add(current.id);
+      current = runsById.get(current.parentRunId);
+    }
+  }
+  return ancestors;
+}
 function runBelongsTo(candidate, ancestor, runsById) {
   if (candidate.rootRunId === ancestor.id)
     return true;
@@ -38960,16 +38997,58 @@ function runBelongsTo(candidate, ancestor, runsById) {
   return false;
 }
 
+// dist/builtin/workflows/src/shared/run-order.ts
+var ACTIVE_RANK = {
+  awaiting_input: 0,
+  blocked: 0,
+  running: 1,
+  paused: 2
+};
+var OTHER_ACTIVE_RANK = 3;
+var TERMINAL_RANK = {
+  blocked: 0,
+  failed: 1,
+  killed: 1,
+  cancelled: 2,
+  skipped: 3,
+  completed: 4
+};
+var OTHER_TERMINAL_RANK = 5;
+function isQuitRun(run) {
+  return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
+}
+function statusRank(run, statusOf) {
+  if (run.endedAt !== undefined)
+    return TERMINAL_RANK[statusOf(run)] ?? OTHER_TERMINAL_RANK;
+  if (isQuitRun(run))
+    return ACTIVE_RANK.paused ?? OTHER_ACTIVE_RANK;
+  return ACTIVE_RANK[statusOf(run)] ?? OTHER_ACTIVE_RANK;
+}
+function sortRunsByStatus(items, runOf, statusOf) {
+  return items.map((item) => {
+    const run = runOf(item);
+    return { item, run, rank: statusRank(run, statusOf) };
+  }).sort((a, b) => {
+    const aEnded = a.run.endedAt !== undefined;
+    if (aEnded !== (b.run.endedAt !== undefined))
+      return aEnded ? 1 : -1;
+    const rankDelta = a.rank - b.rank;
+    if (rankDelta !== 0)
+      return rankDelta;
+    return aEnded ? (b.run.endedAt ?? 0) - (a.run.endedAt ?? 0) : b.run.startedAt - a.run.startedAt;
+  }).map((entry) => entry.item);
+}
+
 // dist/builtin/workflows/src/tui/status-list.ts
 var STAGE_LABEL_BUDGET = 24;
-function isQuitRun(run) {
+function isQuitRun2(run) {
   return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
 }
 function renderStatusList(runs, opts = {}) {
   const now = opts.now ?? Date.now();
   const width = effectiveWidth2(opts.width);
   const cardWidth = Math.max(20, width - 4);
-  const sorted = sortRuns(runs);
+  const sorted = sortRuns(runs, opts);
   const resolveBoundarySegments = opts.resolveBoundarySegments ?? ((runId) => workflowBoundarySegments(runs, runId));
   const counts = countBuckets(runs);
   const subtitle = `${sorted.length} run${sorted.length === 1 ? "" : "s"}`;
@@ -39094,12 +39173,12 @@ function pendingStageLine(line, width, theme) {
 function runAccent(run, theme, indicatorStatus) {
   if (!theme)
     return "#000000";
-  if (isQuitRun(run))
+  if (isQuitRun2(run))
     return theme.warning;
   return statusColor(indicatorStatus, theme);
 }
 function runTrailing(run, theme) {
-  if (isQuitRun(run))
+  if (isQuitRun2(run))
     return { text: "○ quit", fg: theme?.warning };
   switch (effectiveRunStatus(run)) {
     case "completed":
@@ -39128,7 +39207,7 @@ function runCardMeta(run, now) {
   const total = run.stages.length;
   const done = run.stages.filter((s) => s.status === "completed" || s.status === "failed" || s.status === "skipped").length;
   const ago = run.endedAt !== undefined ? `${fmtDuration(now - run.endedAt)} ago` : run.startedAt != null ? fmtDuration(elapsedRunMs(run, now)) : undefined;
-  if (isQuitRun(run))
+  if (isQuitRun2(run))
     return run.resumable === false ? "not resumable" : "resumable via /workflow resume";
   if (effectiveRunStatus(run) === "running") {
     if (isChain)
@@ -39242,7 +39321,7 @@ function countBuckets(runs) {
   const c = { active: 0, paused: 0, quit: 0, completed: 0, blocked: 0, failed: 0, pending: 0 };
   for (const r of runs) {
     const status = effectiveRunStatus(r);
-    if (isQuitRun(r))
+    if (isQuitRun2(r))
       c.quit++;
     else if (r.endedAt === undefined) {
       if (status === "pending")
@@ -39304,11 +39383,9 @@ function plainBadges(c) {
     out.push({ text: `⊘ ${c.failed}` });
   return out;
 }
-function sortRuns(runs) {
-  const active = runs.filter((r) => r.endedAt === undefined);
-  const ended = runs.filter((r) => r.endedAt !== undefined);
-  const byStart = (a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0);
-  return [...[...active].sort(byStart), ...[...ended].sort(byStart)];
+function sortRuns(runs, opts) {
+  const statusOf = createRunIndicatorStatusResolver(opts.allRuns ?? runs);
+  return sortRunsByStatus(runs, (run) => run, (run) => opts.indicatorStatuses?.[run.id] ?? statusOf(run));
 }
 function renderStatusHintRows(id, theme, width) {
   const budget = Math.max(1, width - 4);
@@ -39350,7 +39427,7 @@ function emptyStateLine(theme) {
   return `  ${hexToAnsi(theme.dim)}no workflow runs in current session${RESET}`;
 }
 function statusIconForRun(run, indicatorStatus) {
-  if (isQuitRun(run))
+  if (isQuitRun2(run))
     return statusIcon("pending");
   return statusIcon(indicatorStatus);
 }
@@ -50249,7 +50326,7 @@ function isDisplayablePrompt(message) {
 function isTerminalOrBlockedRun(run) {
   return TERMINAL_OR_BLOCKED2.has(effectiveRunStatus(run)) || run.endedAt !== undefined;
 }
-function isQuitRun2(run) {
+function isQuitRun3(run) {
   return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
 }
 function hasLiveAncestry(candidate, visibleRun, runsById) {
@@ -50265,7 +50342,7 @@ function hasLiveAncestry(candidate, visibleRun, runsById) {
       return false;
     const parent = runsById.get(parentRunId);
     const boundary = parent?.stages.find((stage) => stage.id === parentStageId);
-    if (parent === undefined || isTerminalOrBlockedRun(parent) || isQuitRun2(parent) || boundary === undefined || boundary.status !== "running" && boundary.status !== "awaiting_input") {
+    if (parent === undefined || isTerminalOrBlockedRun(parent) || isQuitRun3(parent) || boundary === undefined || boundary.status !== "running" && boundary.status !== "awaiting_input") {
       return false;
     }
     current = parent;
@@ -50273,12 +50350,12 @@ function hasLiveAncestry(candidate, visibleRun, runsById) {
   return true;
 }
 function visibleRunTreeMembers(visibleRun, allRuns) {
-  if (isTerminalOrBlockedRun(visibleRun) || isQuitRun2(visibleRun))
+  if (isTerminalOrBlockedRun(visibleRun) || isQuitRun3(visibleRun))
     return [];
   const runsById = new Map;
   const ambiguousRunIds = new Set;
   for (const candidate of allRuns) {
-    if (isTerminalOrBlockedRun(candidate) || isQuitRun2(candidate))
+    if (isTerminalOrBlockedRun(candidate) || isQuitRun3(candidate))
       continue;
     if (runsById.has(candidate.id))
       ambiguousRunIds.add(candidate.id);
@@ -50291,7 +50368,7 @@ function visibleRunTreeMembers(visibleRun, allRuns) {
     return [];
   const members = [visibleRun];
   for (const candidate of allRuns) {
-    if (isTerminalOrBlockedRun(candidate) || isQuitRun2(candidate))
+    if (isTerminalOrBlockedRun(candidate) || isQuitRun3(candidate))
       continue;
     if (candidate.id === visibleRun.id || ambiguousRunIds.has(candidate.id))
       continue;
@@ -50361,7 +50438,7 @@ function runPromptOccurrenceForStage(run, stage, prompt) {
   return descriptorOccurrence(run, stage.id, prompt.id, message, isDisplayablePrompt(message));
 }
 function pendingInputOccurrences(run) {
-  if (isTerminalOrBlockedRun(run) || isQuitRun2(run))
+  if (isTerminalOrBlockedRun(run) || isQuitRun3(run))
     return [];
   const occurrences = run.pendingPrompt === undefined ? [] : [runPromptOccurrence(run, run.pendingPrompt)];
   return occurrences.concat(stagePromptOccurrences(run));
@@ -50404,17 +50481,17 @@ function formatDuration(ms) {
   const rmin = minutes % 60;
   return `${hours}h${rmin > 0 ? ` ${rmin}m` : ""}`;
 }
-function isQuitRun3(run) {
+function isQuitRun4(run) {
   return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
 }
 function isActive(run) {
-  return run.endedAt === undefined && !isQuitRun3(run);
+  return run.endedAt === undefined && !isQuitRun4(run);
 }
 function recentlyEnded(run, now) {
   return run.endedAt !== undefined && now - run.endedAt <= RECENT_ENDED_WINDOW_MS;
 }
 function recentlyQuit(run, now) {
-  return isQuitRun3(run) && run.quitAt !== undefined && now - run.quitAt <= RECENT_ENDED_WINDOW_MS;
+  return isQuitRun4(run) && run.quitAt !== undefined && now - run.quitAt <= RECENT_ENDED_WINDOW_MS;
 }
 function subtreeAwaitsInput(root, allRuns) {
   return runIndicatorStatus(root, allRuns) === "awaiting_input";
@@ -50423,7 +50500,7 @@ function countRuns(runs, allRuns = runs) {
   const counts = { active: 0, paused: 0, quit: 0, done: 0, blocked: 0, failed: 0, awaiting: 0 };
   for (const r of runs) {
     const status = effectiveRunStatus(r);
-    if (isQuitRun3(r))
+    if (isQuitRun4(r))
       counts.quit++;
     else if (status === "blocked")
       counts.blocked++;
@@ -50435,7 +50512,7 @@ function countRuns(runs, allRuns = runs) {
       counts.done++;
     else if (status === "failed" || status === "killed")
       counts.failed++;
-    if (r.endedAt === undefined && !isQuitRun3(r) && subtreeAwaitsInput(r, allRuns))
+    if (r.endedAt === undefined && !isQuitRun4(r) && subtreeAwaitsInput(r, allRuns))
       counts.awaiting++;
   }
   return counts;
@@ -50448,7 +50525,7 @@ function nextWidgetRefreshDelayMs(snap, now = Date.now()) {
   for (const run of display) {
     if (run.endedAt !== undefined) {
       delays.push(Math.max(1, run.endedAt + RECENT_ENDED_WINDOW_MS - now + 1));
-    } else if (isQuitRun3(run) && run.quitAt !== undefined) {
+    } else if (isQuitRun4(run) && run.quitAt !== undefined) {
       delays.push(Math.max(1, run.quitAt + RECENT_ENDED_WINDOW_MS - now + 1));
     }
   }
@@ -50468,12 +50545,12 @@ function selectDisplayRuns(snap, now) {
   return [...sort(active), ...sort(recent)];
 }
 function statusGlyph2(run, allRuns) {
-  if (isQuitRun3(run))
+  if (isQuitRun4(run))
     return statusIcon("pending");
   return statusIcon(runIndicatorStatus(run, allRuns));
 }
 function statusFg(run, theme, allRuns) {
-  if (isQuitRun3(run))
+  if (isQuitRun4(run))
     return theme.warning;
   const indicatorStatus = runIndicatorStatus(run, allRuns);
   if (indicatorStatus === "awaiting_input")
@@ -50559,7 +50636,7 @@ function metaLine(run, expandGraph, now, width = Number.POSITIVE_INFINITY, resol
   if (run.endedAt !== undefined) {
     return elapsedLabel(run, now);
   }
-  if (isQuitRun3(run))
+  if (isQuitRun4(run))
     return run.resumable === false ? "quit · not resumable" : "quit · resumable via /workflow resume";
   if (effectiveRunStatus(run) === "blocked")
     return "blocked · resumable via /workflow resume";
@@ -50708,8 +50785,8 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now(), la
   const displayCounts = countRuns(display, snap.runs);
   const visibleCounts = {
     active: display.filter((r) => r.endedAt === undefined && effectiveRunStatus(r) === "running").length,
-    paused: display.filter((r) => r.endedAt === undefined && effectiveRunStatus(r) === "paused" && !isQuitRun3(r)).length,
-    quit: display.filter(isQuitRun3).length,
+    paused: display.filter((r) => r.endedAt === undefined && effectiveRunStatus(r) === "paused" && !isQuitRun4(r)).length,
+    quit: display.filter(isQuitRun4).length,
     done: display.filter((r) => r.endedAt !== undefined && ["completed", "skipped", "cancelled"].includes(effectiveRunStatus(r))).length,
     blocked: display.filter((r) => effectiveRunStatus(r) === "blocked").length,
     failed: display.filter((r) => r.endedAt !== undefined && ["failed", "killed"].includes(effectiveRunStatus(r))).length,
@@ -50734,7 +50811,7 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now(), la
   for (let i = 0;i < display.length; i++) {
     const run = display[i];
     const affordance = pendingInputAffordance(run, snap.runs);
-    const runLines = !isQuitRun3(run) && affordance !== undefined ? awaitingRunLines(run, now, themed ? graphTheme : undefined, snap.runs, affordance, bodyWidth, expandGraph) : themed ? themedRunLines(run, now, graphTheme, snap.runs, width, expandGraph) : plainRunLines(run, now, snap.runs, width, expandGraph);
+    const runLines = !isQuitRun4(run) && affordance !== undefined ? awaitingRunLines(run, now, themed ? graphTheme : undefined, snap.runs, affordance, bodyWidth, expandGraph) : themed ? themedRunLines(run, now, graphTheme, snap.runs, width, expandGraph) : plainRunLines(run, now, snap.runs, width, expandGraph);
     body.push(...runLines);
     layout?.runs.push({
       id: run.id,
@@ -52374,7 +52451,7 @@ function compareDraftSourceOrder(left, right) {
 function runTopologyFor(drafts, tools) {
   return drafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run ?? tools.find((checkpoint) => checkpoint.topology?.run !== undefined)?.topology?.run;
 }
-function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
+function validateRunGroups(grouped, rootRunId, tools, checkpoints, allowPendingChildren = false) {
   const toolsFor = (runId) => tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
   const owners = new Map;
   const syntheticChildIds = new Set;
@@ -52386,6 +52463,11 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
       if (childRunId === parentRunId || owners.has(childRunId))
         return false;
       if (!grouped.has(childRunId)) {
+        if (allowPendingChildren && isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) && !childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId)) {
+          syntheticChildIds.add(childRunId);
+          owners.set(childRunId, draft);
+          continue;
+        }
         if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId))
           return false;
         syntheticChildIds.add(childRunId);
@@ -52418,6 +52500,10 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
   }
   return true;
 }
+function isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) {
+  const boundary = draft.topology?.boundary;
+  return workflowChildFromDraft(draft) === undefined && boundary?.event === "start" && boundary.status === "running" && boundary.child.runId === childRunId && boundary.child.parentRunId === parentRunId && boundary.child.parentStageId === draft.topology?.stageId && boundary.child.rootRunId === rootRunId;
+}
 function isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) {
   const child = workflowChildFromDraft(draft);
   const boundary = draft.topology?.boundary;
@@ -53060,6 +53146,13 @@ class PromptReservationState {
 
 // 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/values.ts
 function validateText(field, value2) {
@@ -53405,6 +53498,8 @@ class JournalDurableBackend {
   persistent;
   projection = createJournalProjection();
   sequences = new Map;
+  foldedAt = new Map;
+  catalogToken;
   leases = new Map;
   executions = new Map;
   executionContext = new AsyncLocalStorage;
@@ -53448,7 +53543,7 @@ class JournalDurableBackend {
     try {
       this.ensureOpen();
       if (requiresActiveExecution)
-        this.assertExecutionActive(runId);
+        this.assertExecutionActive();
     } catch (error) {
       return Promise.reject(error);
     }
@@ -53501,6 +53596,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 () => {
@@ -53514,6 +53610,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);
@@ -53526,7 +53623,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;
@@ -53545,14 +53642,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;
@@ -53612,7 +53709,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,
@@ -53836,11 +53933,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();
@@ -53858,6 +53980,7 @@ class JournalDurableBackend {
     }
     this.leases.delete(runId);
     this.sequences.delete(runId);
+    this.foldedAt.delete(runId);
     this.prompts.delete(runId);
     this.projection.deleteWorkflow(runId);
   }
@@ -53950,7 +54073,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)
@@ -53985,7 +54108,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) {
@@ -54078,6 +54201,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));
@@ -54111,6 +54238,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);
   }
@@ -54161,6 +54291,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);
@@ -54259,6 +54393,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;
@@ -55656,6 +55811,10 @@ function deriveInputFields(schema) {
 
 // dist/builtin/workflows/src/runs/shared/validate-inputs.ts
 import { Value as Value2 } from "typebox/value";
+function firstSchemaError(def, value2, kind) {
+  const first = [...Value2.Errors(def, value2)][0];
+  return first === undefined ? `does not match ${kind} schema` : first.message;
+}
 function validateInputs(schema, inputs) {
   const errors = [];
   for (const key of Object.keys(inputs)) {
@@ -55684,12 +55843,16 @@ function validateInputs(schema, inputs) {
         if (typeof value2 !== "number" || !Number.isFinite(value2)) {
           errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value2)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value2)) {
+          errors.push({ key, reason: firstSchemaError(def, value2, kind) });
         }
         break;
       case "integer":
         if (typeof value2 !== "number" || !Number.isInteger(value2)) {
           errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value2)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value2)) {
+          errors.push({ key, reason: firstSchemaError(def, value2, kind) });
         }
         break;
       case "boolean":
@@ -55860,6 +56023,20 @@ function resolve_budget(layers) {
 var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15;
 var WORKFLOW_HEARTBEAT_CUSTOM_TYPE = "workflows:workflow-heartbeat";
 
+// dist/builtin/workflows/src/shared/workflow-source.ts
+var WORKFLOW_SOURCES = new WeakMap;
+var OWN_MODULE_PATH = normalizeStackPath(import.meta.url);
+function isWorkflowRuntimeModule(path) {
+  const normalized = normalizeStackPath(path);
+  return normalized === OWN_MODULE_PATH || isWorkflowRuntimeFrame(normalized);
+}
+function recordWorkflowSource(definition, path) {
+  WORKFLOW_SOURCES.set(definition, path);
+}
+function workflowSource(definition) {
+  return WORKFLOW_SOURCES.get(definition);
+}
+
 // dist/builtin/workflows/src/workflows/identity.ts
 function normalizeWorkflowName(name) {
   if (!name || typeof name !== "string") {
@@ -55907,8 +56084,10 @@ function isWorkflowAuthoringImplementationFrame(filePath) {
     return false;
   return normalized.includes("/packages/workflows/") || normalized.includes("/dist/builtin/workflows/") || normalized.includes("/.atomic/agent/extensions/workflows/");
 }
-function workflowNameFromCaller() {
-  const stack = new Error().stack;
+function callerSourcePath(entry) {
+  const capture = new Error;
+  Error.captureStackTrace(capture, entry);
+  const stack = capture.stack;
   if (stack === undefined)
     return;
   for (const line of stack.split(`
@@ -55918,14 +56097,18 @@ function workflowNameFromCaller() {
       continue;
     if (isWorkflowAuthoringImplementationFrame(filePath))
       continue;
-    const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
-    if (base.length > 0)
-      return base;
+    return isWorkflowRuntimeModule(filePath) ? undefined : filePath;
   }
   return;
 }
-function resolveWorkflowName(name) {
-  const resolved = name ?? workflowNameFromCaller();
+function workflowNameFromSourcePath(filePath) {
+  if (filePath === undefined)
+    return;
+  const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
+  return base.length > 0 ? base : undefined;
+}
+function resolveWorkflowName(name, sourcePath) {
+  const resolved = name ?? workflowNameFromSourcePath(sourcePath);
   if (resolved === undefined) {
     throw new TypeError("workflow: name must be provided when caller filename cannot be inferred");
   }
@@ -55961,7 +56144,8 @@ function workflow(spec) {
     throw new TypeError("workflow: heartbeatIntervalMinutes must be a non-negative finite number");
   }
   assertWorkflowBudget(spec.budget, "workflow: budget");
-  const name = resolveWorkflowName(spec.name);
+  const source = callerSourcePath(workflow);
+  const name = resolveWorkflowName(spec.name, source);
   const normalizedName = normalizeWorkflowName(name);
   requireNonEmptyString(normalizedName, "normalized name");
   const frozenInputs = freezeSchemaMap(spec.inputs ?? {});
@@ -55983,6 +56167,8 @@ function workflow(spec) {
     run
   };
   const branded = stampWorkflowDefinition(definition);
+  if (source !== undefined)
+    recordWorkflowSource(branded, source);
   return Object.freeze(branded);
 }
 
@@ -60197,7 +60383,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;
 }
@@ -61672,13 +61863,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() {
@@ -61689,8 +61891,8 @@ class ConcurrencyLimiter {
       this._running--;
     }
   }
-  async run(fn) {
-    await this.acquire();
+  async run(fn, signal) {
+    await this.acquire(signal);
     try {
       return await fn();
     } finally {
@@ -63415,6 +63617,7 @@ function createWorkflowExitManager(input) {
       ...outputSnapshot !== undefined ? { outputSnapshot } : {},
       ...validationError !== undefined ? { validationError } : {}
     }));
+    input.onExitSelected?.(selectedExit);
     input.controller.abort(selectedExit);
     runWorkflowExitCleanups(reason);
     throw selectedExit;
@@ -64226,14 +64429,40 @@ 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/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) {
@@ -64243,7 +64472,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" ? {
@@ -64261,6 +64490,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":
@@ -64648,6 +64887,402 @@ function deferStageUntilRunRelease(input) {
   };
 }
 
+// dist/builtin/workflows/src/engine/run-rejection-boundary.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { inspect } from "node:util";
+var EVENT = "unhandledRejection";
+var BOUNDARY_KEY = Symbol.for("atomic-workflows/run-rejection-boundary@5");
+var FLAG = "--unhandled-rejections";
+var MAX_CAUSE_DEPTH2 = 8;
+var MAX_PRIMITIVES_PER_RUN = 64;
+var MAX_STOP_STRINGS = 64;
+var ENDED_RUN_GRACE_MS = 30000;
+var NATIVE_REPORTING_MODES = new Set(["throw", "warn-with-error-code"]);
+function boundaryBag() {
+  return globalThis;
+}
+function sharedBoundary() {
+  const bag = boundaryBag();
+  const existing = bag[BOUNDARY_KEY];
+  if (existing !== undefined && existing.version === 5)
+    return existing;
+  const created = {
+    version: 5,
+    store: new AsyncLocalStorage3,
+    owners: new WeakMap,
+    promises: new WeakMap,
+    scopes: new Set,
+    runs: new Map,
+    ended: new Map,
+    stops: new Set,
+    listener: undefined
+  };
+  bag[BOUNDARY_KEY] = created;
+  return created;
+}
+function isObject(value2) {
+  return typeof value2 === "object" && value2 !== null || typeof value2 === "function";
+}
+function isPrimitive(value2) {
+  return !isObject(value2);
+}
+function safeField3(value2, key) {
+  try {
+    return value2[key];
+  } catch {
+    return;
+  }
+}
+function strongerEffect(left, right) {
+  return left === "fail-run" || right === "fail-run" ? "fail-run" : "ignore";
+}
+function addAttribution(into, scope, effect) {
+  into.set(scope, strongerEffect(into.get(scope), effect));
+}
+function recordedOwners(boundary, reason) {
+  const owners = new Map;
+  let stopped = false;
+  const seen = new Set;
+  const pending = [{ value: reason, depth: 0 }];
+  while (pending.length > 0) {
+    const { value: value2, depth } = pending.pop();
+    if (depth > MAX_CAUSE_DEPTH2)
+      continue;
+    if (isPrimitive(value2)) {
+      if (depth === 0 || value2 !== undefined && value2 !== null) {
+        for (const scope of boundary.scopes) {
+          const entry = scope.primitives.get(value2);
+          if (entry !== undefined)
+            addAttribution(owners, scope, entry.effect);
+        }
+        if (typeof value2 === "string" && boundary.stops.has(value2))
+          stopped = true;
+      }
+      continue;
+    }
+    if (seen.has(value2))
+      continue;
+    seen.add(value2);
+    for (const [scope, effect] of boundary.owners.get(value2) ?? [])
+      addAttribution(owners, scope, effect);
+    pending.push({ value: safeField3(value2, "cause"), depth: depth + 1 });
+    const errors = safeField3(value2, "errors");
+    if (Array.isArray(errors))
+      for (const entry of errors)
+        pending.push({ value: entry, depth: depth + 1 });
+  }
+  return { owners, stopped };
+}
+function pruneEndedSources(boundary) {
+  const now = Date.now();
+  for (const [source, trees] of boundary.ended) {
+    for (const [rootRunId, endedAt] of trees)
+      if (now - endedAt > ENDED_RUN_GRACE_MS)
+        trees.delete(rootRunId);
+    if (trees.size === 0)
+      boundary.ended.delete(source);
+  }
+}
+function recordEndedRun(boundary, scope) {
+  if (scope.source === undefined)
+    return;
+  const trees = boundary.ended.get(scope.source) ?? new Map;
+  trees.set(scope.rootRunId, Date.now());
+  boundary.ended.set(scope.source, trees);
+}
+function endedInAnotherRunTree(boundary, source, live) {
+  for (const endedRoot of boundary.ended.get(source)?.keys() ?? [])
+    if (endedRoot !== live.rootRunId)
+      return true;
+  return false;
+}
+function recognizedSources(boundary) {
+  pruneEndedSources(boundary);
+  const sources = new Set(boundary.ended.keys());
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source !== undefined)
+      sources.add(scope.source);
+  return sources;
+}
+function authoringSource(reason, sources) {
+  if (sources.size === 0 || !isObject(reason))
+    return;
+  const stack = safeField3(reason, "stack");
+  if (typeof stack !== "string")
+    return;
+  for (const line of stack.split(`
+`)) {
+    if (!line.trimStart().startsWith("at "))
+      continue;
+    const path = parsePromptStackFrame(line)?.normalizedPath;
+    if (path === undefined)
+      continue;
+    if (isWorkflowRuntimeModule(path))
+      return;
+    if (/\/node_modules\//.test(path))
+      continue;
+    if (sources.has(path))
+      return path;
+  }
+  return;
+}
+function hasAncestorIn(scope, candidates) {
+  for (let ancestor = scope.parent;ancestor !== undefined; ancestor = ancestor.parent) {
+    if (candidates.has(ancestor))
+      return true;
+  }
+  return false;
+}
+function outermostLiveRuns(boundary, source) {
+  const matching = new Set;
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source === source)
+      matching.add(scope);
+  const outermost = new Set;
+  for (const scope of matching)
+    if (!hasAncestorIn(scope, matching))
+      outermost.add(scope);
+  return outermost;
+}
+function runOfSource(boundary, source) {
+  const [only, ...others] = outermostLiveRuns(boundary, source);
+  if (only === undefined)
+    return new Map;
+  if (others.length > 0 || only.sharedSource)
+    return;
+  if (endedInAnotherRunTree(boundary, source, only))
+    return;
+  return new Map([[only, "fail-run"]]);
+}
+function markSharedSource(boundary, source) {
+  const runs = outermostLiveRuns(boundary, source);
+  if (runs.size > 1)
+    for (const run of runs)
+      run.sharedSource = true;
+}
+function rejectingRun(boundary, recorded, promise, scoped) {
+  const tracked = promise === undefined ? undefined : boundary.promises.get(promise);
+  if (tracked !== undefined && recorded.has(tracked))
+    return tracked;
+  if (scoped !== undefined && recorded.has(scoped))
+    return scoped;
+  return;
+}
+function attribute(boundary, reason, promise) {
+  const { owners: recorded, stopped } = recordedOwners(boundary, reason);
+  const scoped = boundary.store.getStore();
+  if (recorded.size > 1) {
+    const rejecting = rejectingRun(boundary, recorded, promise, scoped);
+    if (rejecting !== undefined)
+      return new Map([[rejecting, recorded.get(rejecting) ?? "fail-run"]]);
+  }
+  if (recorded.size > 0)
+    return recorded;
+  if (stopped)
+    return new Map;
+  if (scoped !== undefined && boundary.scopes.has(scoped))
+    return new Map([[scoped, "fail-run"]]);
+  const origin = authoringSource(reason, recognizedSources(boundary));
+  if (origin === undefined)
+    return;
+  if (scoped !== undefined)
+    return new Map([[scoped, "ignore"]]);
+  return runOfSource(boundary, origin);
+}
+function unhandledRejectionError(reason) {
+  return Object.assign(new Error("This error originated either by throwing inside of an async function without a catch block, " + `or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${inspect(reason)}".`), { code: "ERR_UNHANDLED_REJECTION" });
+}
+function unhandledRejectionsMode() {
+  const args = [...(process.env.NODE_OPTIONS ?? "").split(/\s+/), ...process.execArgv];
+  let mode = "throw";
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg.startsWith(`${FLAG}=`))
+      mode = arg.slice(FLAG.length + 1);
+    else if (arg === FLAG && args[index + 1] !== undefined)
+      mode = args[index + 1] ?? mode;
+  }
+  return mode;
+}
+function surfaceNatively(boundary, reason) {
+  const listener = boundary.listener;
+  if (listener === undefined || process.listenerCount(EVENT) > 1)
+    return;
+  if (!NATIVE_REPORTING_MODES.has(unhandledRejectionsMode()))
+    return;
+  process.nextTick(() => {
+    process.removeListener(EVENT, listener);
+    Promise.reject(reason);
+    setImmediate(() => {
+      if (!process.listeners(EVENT).includes(listener))
+        process.on(EVENT, listener);
+    });
+  });
+}
+function onUnhandledRejection(reason, promise) {
+  const boundary = sharedBoundary();
+  const owners = attribute(boundary, reason, promise);
+  if (owners === undefined) {
+    surfaceNatively(boundary, reason);
+    return;
+  }
+  const error = isObject(reason) ? reason : unhandledRejectionError(reason);
+  for (const [scope, effect] of owners) {
+    if (effect !== "fail-run" || !scope.live)
+      continue;
+    try {
+      scope.fail(error);
+    } catch {}
+  }
+}
+function ensureInstalled(boundary) {
+  if (boundary.listener !== undefined)
+    return;
+  boundary.listener = onUnhandledRejection;
+  process.on(EVENT, onUnhandledRejection);
+}
+function record(boundary, scope, reason, effect) {
+  if (isPrimitive(reason)) {
+    recordPrimitive(scope, reason, effect);
+    return;
+  }
+  const owners = boundary.owners.get(reason);
+  if (owners === undefined)
+    boundary.owners.set(reason, new Map([[scope, effect]]));
+  else
+    addAttribution(owners, scope, effect);
+}
+function recordStop(boundary, reason) {
+  boundary.stops.delete(reason);
+  boundary.stops.add(reason);
+  if (boundary.stops.size <= MAX_STOP_STRINGS)
+    return;
+  const oldest = boundary.stops.values().next();
+  if (!oldest.done)
+    boundary.stops.delete(oldest.value);
+}
+function recordPrimitive(scope, reason, effect) {
+  if (!scope.live)
+    return;
+  if (scope.primitives.size >= MAX_PRIMITIVES_PER_RUN && !scope.primitives.has(reason)) {
+    const oldest = scope.primitives.keys().next();
+    if (!oldest.done)
+      scope.primitives.delete(oldest.value);
+  }
+  scope.generation += 1;
+  const generation = scope.generation;
+  scope.primitives.set(reason, { effect: strongerEffect(scope.primitives.get(reason)?.effect, effect), generation });
+  afterPendingRejectionReports().then(() => {
+    if (scope.primitives.get(reason)?.generation === generation)
+      scope.primitives.delete(reason);
+  });
+}
+function discardFailure() {}
+function afterPendingRejectionReports() {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel;
+    port1.onmessage = () => {
+      port1.close();
+      port2.close();
+      resolve();
+    };
+    port2.postMessage(undefined);
+  });
+}
+function openRunRejectionScope(options) {
+  const boundary = sharedBoundary();
+  ensureInstalled(boundary);
+  pruneEndedSources(boundary);
+  const parent = options.parentRunId === undefined ? undefined : boundary.runs.get(options.parentRunId);
+  const scope = {
+    runId: options.runId,
+    rootRunId: parent?.rootRunId ?? options.runId,
+    source: options.source === undefined ? undefined : normalizeStackPath(options.source),
+    parent,
+    fail: options.fail,
+    primitives: new Map,
+    generation: 0,
+    live: true,
+    sharedSource: false
+  };
+  boundary.scopes.add(scope);
+  boundary.runs.set(scope.runId, scope);
+  if (scope.source !== undefined)
+    markSharedSource(boundary, scope.source);
+  return {
+    run: (callback) => boundary.store.run(scope, callback),
+    contain: (promise, effect = "fail-run") => {
+      boundary.promises.set(promise, scope);
+      promise.then(undefined, (reason) => record(boundary, scope, reason, effect));
+      return promise;
+    },
+    watch: (promise) => {
+      const watched = promise.then(undefined, (reason) => {
+        record(boundary, scope, reason, "fail-run");
+        throw reason;
+      });
+      boundary.promises.set(watched, scope);
+      return watched;
+    },
+    ignore: (reason) => {
+      if (typeof reason === "string")
+        recordStop(boundary, reason);
+      else
+        record(boundary, scope, reason, "ignore");
+    },
+    settle: afterPendingRejectionReports,
+    close: () => {
+      scope.live = false;
+      scope.fail = discardFailure;
+      recordEndedRun(boundary, scope);
+      afterPendingRejectionReports().then(() => {
+        scope.primitives.clear();
+        scope.parent = undefined;
+        boundary.scopes.delete(scope);
+        if (boundary.runs.get(scope.runId) === scope)
+          boundary.runs.delete(scope.runId);
+      });
+    }
+  };
+}
+var WATCHED_STAGE_METHODS = [
+  "prompt",
+  "complete",
+  "sendUserMessage",
+  "steer",
+  "followUp",
+  "setModel",
+  "setThinkingLevel",
+  "cycleModel",
+  "cycleThinkingLevel",
+  "navigateTree",
+  "compact",
+  "abort"
+];
+function containStageRejections(stage, scope) {
+  const contained = Object.create(stage);
+  const descriptors = {};
+  for (const name of WATCHED_STAGE_METHODS) {
+    descriptors[name] = {
+      value: (...args) => {
+        const result = Reflect.apply(stage[name], stage, args);
+        return result instanceof Promise ? scope.watch(result) : result;
+      }
+    };
+  }
+  Object.defineProperties(contained, descriptors);
+  return contained;
+}
+function containUiRejections(ui, scope) {
+  return {
+    input: (prompt) => scope.watch(ui.input(prompt)),
+    confirm: (message) => scope.watch(ui.confirm(message)),
+    select: (message, options) => scope.watch(ui.select(message, options)),
+    editor: (initial) => scope.watch(ui.editor(initial)),
+    custom: (factory, options) => scope.watch(ui.custom(factory, options))
+  };
+}
+
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -66638,7 +67273,9 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 import {
   AutoRoutingInferenceError,
   convertToLlm,
+  isExtensionStartupFailure,
   isModelRoutingDebugEnabled,
+  isTransientExtensionStartupFailure,
   parseModelConstraints,
   setsProviders
 } from "@bastani/atomic";
@@ -66909,6 +67546,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;
@@ -67399,6 +68053,7 @@ async function stripWorkflowOnlyOptions(options, defaultSessionDir, meta, pendin
   }
   const {
     schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
     mcp: _mcp,
     fallbackModels,
     modelConstraints: _modelConstraints,
@@ -67732,6 +68387,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")
@@ -67895,7 +68559,7 @@ function isWorkflowStructuredOutputContractError(error) {
   return error instanceof Error && "code" in error && error.code === "ATOMIC_WORKFLOW_STRUCTURED_OUTPUT_CONTRACT";
 }
 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) {
@@ -67947,7 +68611,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 = {
@@ -68037,6 +68702,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;
@@ -68288,7 +68963,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.");
@@ -68300,7 +68975,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,
@@ -68321,7 +68996,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: ${errorMessage3(error)}`);
+      });
+      this.routingPromise = routing;
     }
     await this.routingPromise;
   }
@@ -69076,7 +69761,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;
         }
@@ -69488,10 +70173,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];
@@ -70613,13 +71299,13 @@ class EngineRuntime {
 
 // dist/builtin/workflows/src/engine/session-closed-error.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError5 } from "@bastani/atomic";
-var MAX_CAUSE_DEPTH = 8;
+var MAX_CAUSE_DEPTH3 = 8;
 function reportsClosedSession(error) {
   return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError5(error);
 }
 function isSessionClosedError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH && current !== undefined; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH3 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -70691,7 +71377,12 @@ async function executeRun(def, resolvedInputs, opts) {
     workflowObservationRuntime(activeStore).control(runId, "kill");
     ownController.abort(callerSignal?.reason);
   };
-  const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
+  const exit = createWorkflowExitManager({
+    runId,
+    exitScope,
+    controller: ownController,
+    onExitSelected: (signal) => rejectionScope.ignore(signal)
+  });
   const sourceBackend = opts.durableBackend;
   const backendView = sourceBackend;
   const rootBackend = opts.durableRootBackend ?? backendView;
@@ -71205,6 +71896,22 @@ async function executeRun(def, resolvedInputs, opts) {
     baseFromPromptNodes: getPromptNodeUi
   });
   let pausedExit;
+  const authoredIn = workflowSource(def);
+  const rejectionScope = openRunRejectionScope({
+    runId,
+    ...opts.parentRun !== undefined ? { parentRunId: opts.parentRun.runId } : {},
+    ...authoredIn !== undefined ? { source: authoredIn } : {},
+    fail: (error) => {
+      if (findWorkflowGracefulQuit(error) !== undefined)
+        return;
+      const selected = terminalEvents.selectFailure(error);
+      if (selected.kind === "failure" && !ownController.signal.aborted)
+        ownController.abort(selected.error);
+    }
+  });
+  ownController.signal.addEventListener("abort", () => rejectionScope.ignore(ownController.signal.reason), {
+    once: true
+  });
   const ctx = {
     inputs: resolvedInputs,
     runId,
@@ -71215,28 +71922,30 @@ async function executeRun(def, resolvedInputs, opts) {
       if (scheduler.isRunPaused()) {
         pausedExit ??= whenRunning(async () => exit.exit(options));
         pausedExit.catch(() => {});
-        throw new Error("Workflow exit is waiting for explicit resume");
+        const waiting = new Error("Workflow exit is waiting for explicit resume");
+        rejectionScope.ignore(waiting);
+        throw waiting;
       }
       return exit.exit(options);
     },
-    ui,
+    ui: containUiRejections(ui, rejectionScope),
     stage: (name, options) => {
       ownController.signal.throwIfAborted();
       if (!scheduler.isRunPaused())
-        return durableStage(name, options);
+        return containStageRejections(durableStage(name, options), rejectionScope);
       const replayKey = stageReplayKeyGenerator(name);
-      return deferStageUntilRunRelease({
+      return containStageRejections(deferStageUntilRunRelease({
         name,
         create: () => durableStage(name, options, replayKey),
         isPaused: scheduler.isRunPaused,
         waitForRelease: waitForRunRelease,
         signal: ownController.signal
-      });
+      }), rejectionScope);
     },
-    task: gatedTask,
-    chain: (...args) => whenRunning(() => chain(...args)),
-    parallel: (...args) => whenRunning(() => parallel(...args)),
-    workflow: (...args) => whenRunning(() => {
+    task: (...args) => rejectionScope.watch(gatedTask(...args)),
+    chain: (...args) => rejectionScope.watch(whenRunning(() => chain(...args))),
+    parallel: (...args) => rejectionScope.watch(whenRunning(() => parallel(...args))),
+    workflow: (...args) => rejectionScope.watch(whenRunning(() => {
       const pending = durableWorkflow(...args);
       pendingChildWorkflows.add(pending);
       const settled = () => {
@@ -71244,18 +71953,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();
@@ -71401,7 +72109,7 @@ async function executeRun(def, resolvedInputs, opts) {
     while (scheduler.isRunPaused())
       await waitForRunRelease();
     ownController.signal.throwIfAborted();
-    const rawResult = await raceAbort(runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx)), ownController.signal);
+    const rawResult = await raceAbort(runWorkflowDefinitionCallback(def.name, runId, () => rejectionScope.run(() => def.run(ctx))), ownController.signal);
     await drainCachedStagePersistence();
     while (scheduler.isRunPaused())
       await waitForRunRelease();
@@ -71411,6 +72119,7 @@ async function executeRun(def, resolvedInputs, opts) {
     if (pausedExit !== undefined)
       await pausedExit;
     budget.rethrowIfSystemOwnedStop(runSnapshot.stages.at(-1)?.name ?? startupFrontierStage);
+    await rejectionScope.settle();
     const normalTerminalEvent = terminalEvents.winner();
     if (normalTerminalEvent?.kind === "cancellation") {
       const gracefulQuit = findWorkflowGracefulQuit(normalTerminalEvent.reason);
@@ -71445,6 +72154,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,
@@ -71479,6 +72189,9 @@ async function executeRun(def, resolvedInputs, opts) {
     }
     if (ownerClosing && err instanceof Error && isSessionClosedError(err))
       return await suspendForClosedSession(err);
+    if (selectedTerminalEvent.kind === "failure" && pendingChildWorkflows.size > 0 && !ownController.signal.aborted) {
+      ownController.abort(err);
+    }
     await admittedTools.closeAndDrain();
     if (ownController.signal.aborted)
       await Promise.allSettled([...pendingChildWorkflows]);
@@ -71553,6 +72266,7 @@ async function executeRun(def, resolvedInputs, opts) {
     });
     return failed;
   } finally {
+    rejectionScope.close();
     callerSignal?.removeEventListener("abort", onCallerAbort);
     workflowObservationRuntime(activeStore).finishRun(runId);
     runtimeSettled.resolve();
@@ -71566,7 +72280,9 @@ async function executeRun(def, resolvedInputs, opts) {
           runId,
           runSnapshot,
           isRoot: opts.parentRun === undefined,
-          durableBackend
+          durableBackend,
+          terminalStatusCommitted,
+          store: activeStore
         });
       }
     } finally {
@@ -71645,11 +72361,17 @@ function runDetached(def, inputs, opts = {}) {
       opts.onWorkflowStartReady?.();
     }
   };
-  let settleJob = () => {};
-  const voidPromise = new Promise((resolve) => {
-    settleJob = resolve;
-  });
-  const jobEntry = { runId, controller, promise: voidPromise };
+  const jobSettled = Promise.withResolvers();
+  const jobOutcome = Promise.withResolvers();
+  jobOutcome.promise.catch(() => {});
+  const settleJob = (failure) => {
+    jobSettled.resolve();
+    if (failure === undefined)
+      jobOutcome.resolve();
+    else
+      jobOutcome.reject(failure.error);
+  };
+  const jobEntry = { runId, controller, promise: jobSettled.promise, outcome: jobOutcome.promise };
   try {
     opts.startupSignal?.addEventListener("abort", cancelStartup, { once: true });
     registry.register(runId, controller);
@@ -71697,6 +72419,7 @@ function runDetached(def, inputs, opts = {}) {
     throw error;
   }
   const settle = async (...args) => {
+    const [ok, , error] = args;
     try {
       if (!observed)
         await observe(...args);
@@ -71704,7 +72427,7 @@ function runDetached(def, inputs, opts = {}) {
       detachStartup();
       registry.unregister(runId, controller);
       tracker.unregister(runId, jobEntry);
-      settleJob();
+      settleJob(ok ? undefined : { error });
     }
   };
   backgroundPromise.then((result) => {
@@ -72658,11 +73381,17 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   retainReachableRunGroups(grouped, rootRunId);
   if (policy.failOnUnreachable && grouped.size !== groupedCount)
     return [];
-  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints))
+  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints, policy.retainActive))
     return [];
   const syntheticChildren = [];
+  const pendingChildren = [];
   for (const [parentRunId, runDrafts] of grouped) {
     for (const draft of runDrafts) {
+      const pendingChildRunId = childRunIdFromDraft(draft);
+      if (policy.retainActive && pendingChildRunId !== undefined && !grouped.has(pendingChildRunId) && isPendingChildBoundary(draft, parentRunId, pendingChildRunId, rootRunId)) {
+        pendingChildren.push({ parentRunId, owner: draft });
+        continue;
+      }
       const child = workflowChildFromDraft(draft);
       if (child?.exited !== true || grouped.has(child.runId))
         continue;
@@ -72771,6 +73500,28 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       resumable: false
     });
   }
+  for (const { parentRunId, owner } of pendingChildren) {
+    if (!emittedRunIds.has(parentRunId))
+      return [];
+    const topology = owner.topology;
+    const boundary = topology.boundary;
+    const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
+    if (parentStageId === undefined)
+      return [];
+    runs.push({
+      id: boundary.child.runId,
+      name: boundary.child.runName,
+      inputs: {},
+      status: "running",
+      stages: [],
+      toolNodes: [],
+      startedAt: owner.startedAt ?? owner.firstCompletedAt,
+      parentRunId,
+      parentStageId,
+      rootRunId: boundary.child.rootRunId,
+      resumable: false
+    });
+  }
   return runs;
 }
 function stageSnapshotFromDraft(draft, id, parentIds) {
@@ -73285,6 +74036,43 @@ function isDormantMessageEvent(value2) {
 // dist/builtin/workflows/src/extension/extension-lifecycle.ts
 import { registerExtensionContextRetirementEffect, sessionScopedExtensionState as sessionScopedExtensionState2 } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/runs/background/ended-run-settlement.ts
+var ENDED_RUN_SETTLEMENT_TIMEOUT_MS = 1e4;
+function awaitJobSettlement(job) {
+  return job.outcome ?? job.promise;
+}
+async function settleEndedRuns(opts) {
+  const timeoutMs = opts.timeoutMs ?? ENDED_RUN_SETTLEMENT_TIMEOUT_MS;
+  const ending = topLevelWorkflowRuns(opts.store.runs()).flatMap((run) => {
+    const job = run.endedAt === undefined ? undefined : opts.jobs.get(run.id);
+    return job === undefined ? [] : [{ runId: run.id, job }];
+  });
+  if (ending.length === 0)
+    return [];
+  const deadline = Promise.withResolvers();
+  const timer = setTimeout(deadline.resolve, timeoutMs);
+  timer.unref?.();
+  try {
+    const settled = await Promise.all(ending.map(({ runId, job }) => Promise.race([
+      awaitJobSettlement(job).then(() => {
+        return;
+      }, (error) => ({
+        runId,
+        reason: "failed",
+        message: describeErrorWithCauses(error)
+      })),
+      deadline.promise.then(() => ({
+        runId,
+        reason: "timed_out",
+        message: `still recording its ending after ${timeoutMs} ms`
+      }))
+    ])));
+    return settled.filter((failure) => failure !== undefined);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // dist/builtin/workflows/src/runs/background/workflow-lifecycle-aggregate.ts
 function expandedControlRunIds(store, runId) {
   const graph = expandWorkflowGraph(readGraphStoreSnapshot(store), runId);
@@ -76545,6 +77333,13 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
       if (failures.length > 0)
         throw new Error(failures.map((result) => `${result.runId}: ${result.reason}${"message" in result ? ` (${result.message})` : ""}`).join("; "));
     },
+    async () => {
+      if (boundary !== "quit")
+        return;
+      const failures = await settleEndedRuns({ store, jobs });
+      if (failures.length > 0)
+        throw new Error(failures.map((failure) => `${failure.runId}: ended but its ending was not recorded (${failure.message})`).join("; "));
+    },
     () => stageControlRegistry.clear()
   ]);
   lifetime.generations.add(quitAndCheckpointRuns);
@@ -83295,6 +84090,7 @@ import { join as join28 } from "node:path";
 import {
   isStaleExtensionContextError as isStaleExtensionContextError6,
   ModelRuntime,
+  noOpUIContext,
   resolveRestoredModelReference
 } from "@bastani/atomic";
 
@@ -83621,7 +84417,14 @@ function stripWorkflowOnlyOptions2(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) {
@@ -83738,6 +84541,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     notify: ui.notify ?? (() => {
       return;
     }),
+    requestRender: noOpUIContext.requestRender,
     onTerminalInput: ui.onTerminalInput ?? (() => () => {
       return;
     }),
@@ -83797,7 +84601,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;
@@ -83807,9 +84611,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) {
@@ -85912,6 +86715,7 @@ function workflowModelCatalogFromContext(ctx, resolveLiveContext) {
           model: current.model,
           getRouterModel: () => current.getRouterModel(),
           ...current.getModelRouting ? { getModelRouting: () => current.getModelRouting() } : {},
+          ...current.getHttpIdleTimeoutMs ? { getHttpIdleTimeoutMs: () => current.getHttpIdleTimeoutMs() } : {},
           modelRegistry: {
             getAvailable: () => registry.getAvailable(),
             getAll: () => registry.getAll(),
@@ -85929,7 +86733,8 @@ function workflowModelCatalogFromContext(ctx, resolveLiveContext) {
         signal: input.signal,
         selection: input.selection,
         ...input.taskNeeds ? { taskNeeds: input.taskNeeds } : {},
-        ...input.overrideProviderSettings ? { overrideProviderSettings: true } : {}
+        ...input.overrideProviderSettings ? { overrideProviderSettings: true } : {},
+        ...input.inference ? { inference: input.inference } : {}
       });
     },
     listModels: async () => {
@@ -86708,7 +87513,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
       const entry = { signature };
       announcedRoutes.set(run.id, entry);
       try {
-        pi.events?.emit?.(PENDING_STAGE_ROUTE_EVENT2, announcement);
+        outsideWorkflowExecutions(() => pi.events?.emit?.(PENDING_STAGE_ROUTE_EVENT2, announcement));
       } catch (error) {
         if (announcedRoutes.get(run.id) === entry)
           announcedRoutes.delete(run.id);
@@ -86747,7 +87552,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
     announcedRoutes.clear();
     announceRoutes();
   });
-  const subscription = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT2, (payload) => {
+  const routePendingStageMessage = (payload) => {
     if (disposed || !isPendingStageMessageEvent(payload) || payload.handled)
       return;
     const runs = activeStore.runs();
@@ -86810,12 +87615,13 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
     }
     payload.handled = true;
     payload.completion = queueAndPersist(activeStore, resolvedEvent, workflowInvocationIntercomGroup(rootRunId), stage.pendingStageDeliveryAvailable === true);
-  });
+  };
+  const subscription = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT2, (payload) => outsideWorkflowExecutions(() => routePendingStageMessage(payload)));
   const stickySubscription = pi.events?.on?.(STICKY_LIVE_DELIVERED_EVENT, (payload) => {
     if (disposed || !isStickyLiveDeliveredEvent(payload) || payload.handled)
       return;
     payload.handled = true;
-    payload.completion = recordConfirmedStickyDeliveries(activeStore, payload);
+    payload.completion = outsideWorkflowExecutions(() => recordConfirmedStickyDeliveries(activeStore, payload));
   });
   const dispose = () => {
     disposed = true;
@@ -87595,7 +88401,7 @@ function openInputsPicker(ui, opts) {
 // dist/builtin/workflows/src/tui/session-picker.ts
 import { keyText as keyText3 } from "@bastani/atomic";
 var ESCAPE_CODE = 27;
-function isQuitRun4(run) {
+function isQuitRun5(run) {
   return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
 }
 var DOUBLE_ESCAPE_SEQUENCE = String.fromCharCode(ESCAPE_CODE, ESCAPE_CODE);
@@ -87632,8 +88438,7 @@ function selectRunsForPicker(runs, query, includeAll, now = Date.now(), intent =
       return true;
     return r.name.toLowerCase().includes(q) || r.id.startsWith(q);
   };
-  const active = [];
-  const terminal = [];
+  const rows = [];
   for (const r of runs) {
     if (!isTopLevelWorkflowRun(r))
       continue;
@@ -87646,16 +88451,30 @@ function selectRunsForPicker(runs, query, includeAll, now = Date.now(), intent =
     }
     const endedAt = r.endedAt;
     if (endedAt === undefined) {
-      active.push({ run: r, bucket: "active" });
+      rows.push({ run: r, bucket: "active" });
       continue;
     }
     if (includeAll || now - endedAt <= RECENT_WINDOW_MS) {
-      terminal.push({ run: r, bucket: "terminal" });
+      rows.push({ run: r, bucket: "terminal" });
     }
   }
-  active.sort((a, b) => a.run.startedAt - b.run.startedAt);
-  terminal.sort((a, b) => (b.run.endedAt ?? 0) - (a.run.endedAt ?? 0));
-  return [...active, ...terminal];
+  return sortRunsByStatus(rows, (row) => row.run, createRunIndicatorStatusResolver(runs));
+}
+function syncSessionPickerSelection(state, rows) {
+  if (state.selectedRunId !== undefined) {
+    const index = rows.findIndex((row) => row.run.id === state.selectedRunId);
+    if (index >= 0)
+      state.selectedIndex = index;
+  }
+  state.selectedRunId = rows[state.selectedIndex]?.run.id;
+}
+function selectIndex2(state, rows, index) {
+  state.selectedIndex = index;
+  state.selectedRunId = rows[index]?.run.id;
+}
+function resetSelection(state) {
+  state.selectedIndex = 0;
+  state.selectedRunId = undefined;
 }
 var TITLE = "Connect to workflow run";
 function renderHeader3(width, theme) {
@@ -87736,7 +88555,7 @@ function renderRunRow(row, isSelected, inner, theme, now, allRuns) {
   const border = hexToAnsi(theme.border);
   const panelBg = hexBg(theme.bg);
   const run = row.run;
-  const indicatorStatus = isQuitRun4(run) ? run.status : runIndicatorStatus(run, allRuns);
+  const indicatorStatus = isQuitRun5(run) ? run.status : runIndicatorStatus(run, allRuns);
   const icon = statusIcon(indicatorStatus);
   const iconColor = hexToAnsi(statusColor(indicatorStatus, theme));
   const dim = hexToAnsi(theme.dim);
@@ -87828,12 +88647,12 @@ function handleSessionPickerInput(data, state, rows) {
     }
     if (matchesKey(data, Key.backspace)) {
       state.query = state.query.slice(0, -1);
-      state.selectedIndex = 0;
+      resetSelection(state);
       return { kind: "noop" };
     }
     if (data.length === 1 && data >= " " && data <= "~") {
       state.query += data;
-      state.selectedIndex = 0;
+      resetSelection(state);
       return { kind: "noop" };
     }
     return { kind: "noop" };
@@ -87848,17 +88667,17 @@ function handleSessionPickerInput(data, state, rows) {
     return { kind: "close" };
   if (matchesKey(data, "a") || matchesKey(data, Key.shift("a"))) {
     state.includeAll = !state.includeAll;
-    state.selectedIndex = 0;
+    resetSelection(state);
     return { kind: "noop" };
   }
   if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
-    state.selectedIndex = Math.min(state.selectedIndex + 1, Math.max(0, rows.length - 1));
+    selectIndex2(state, rows, Math.min(state.selectedIndex + 1, Math.max(0, rows.length - 1)));
     return { kind: "noop" };
   }
   if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
     if (rows.length > 0 && state.selectedIndex === 0)
       return { kind: "noop" };
-    state.selectedIndex = Math.max(state.selectedIndex - 1, 0);
+    selectIndex2(state, rows, Math.max(state.selectedIndex - 1, 0));
     return { kind: "noop" };
   }
   if (matchesKey(data, Key.enter)) {
@@ -88185,10 +89004,12 @@ function openSessionPicker(ui, store, theme, intent = "connect") {
       return {
         render: (width) => {
           const rows = selectRows();
+          syncSessionPickerSelection(state, rows);
           return renderSessionPicker({ width, theme, rows, state, allRuns: store.runs() });
         },
         handleInput: (data) => {
           const rows = selectRows();
+          syncSessionPickerSelection(state, rows);
           const consumed = isSessionPickerKey(data, state, rows);
           const action = handleSessionPickerInput(data, state, rows);
           if (action.kind === "noop") {
@@ -89221,6 +90042,18 @@ function createSessionRunControl(host) {
     async quit(runId) {
       return controlOutcome(await request({ action: "quit", ...target(runId) }));
     },
+    async waitForSettled(runId) {
+      const job = (host.jobs ?? currentJobTracker()).get(runId);
+      if (job === undefined)
+        return;
+      try {
+        await awaitJobSettlement(job);
+      } catch (error) {
+        const cause = error instanceof Error ? error : new Error(String(error));
+        const code = error instanceof JournalError ? "storage_unavailable" : classifyControlError(error);
+        throw failure3(code, `Run ${runId} did not settle cleanly: ${describeErrorWithCauses(error)}`, runId, cause);
+      }
+    },
     async resume(runId, options) {
       return controlOutcome(await request({
         action: "resume",
@@ -91664,6 +92497,7 @@ function factory(pi) {
     execute: executeWorkflowTool,
     context: () => sessionContext,
     store: owner.store,
+    jobs: runState.jobs,
     catalog: async () => {
       const runtime = runtimeState.runtimeForContext(sessionContext);
       return await runtime.prepareDurableCatalog?.() ?? { resumable: [], completed: [] };