@bastani/atomic 0.9.40-alpha.2 → 0.9.41-alpha.1

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,
@@ -53060,6 +53137,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 +53489,8 @@ class JournalDurableBackend {
   persistent;
   projection = createJournalProjection();
   sequences = new Map;
+  foldedAt = new Map;
+  catalogToken;
   leases = new Map;
   executions = new Map;
   executionContext = new AsyncLocalStorage;
@@ -53448,7 +53534,7 @@ class JournalDurableBackend {
     try {
       this.ensureOpen();
       if (requiresActiveExecution)
-        this.assertExecutionActive(runId);
+        this.assertExecutionActive();
     } catch (error) {
       return Promise.reject(error);
     }
@@ -53501,6 +53587,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 +53601,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 +53614,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 +53633,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 +53700,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 +53924,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 +53971,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 +54064,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 +54099,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 +54192,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 +54229,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 +54282,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 +54384,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 +55802,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 +55834,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":
@@ -60197,7 +60351,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 +61831,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 +61859,8 @@ class ConcurrencyLimiter {
       this._running--;
     }
   }
-  async run(fn) {
-    await this.acquire();
+  async run(fn, signal) {
+    await this.acquire(signal);
     try {
       return await fn();
     } finally {
@@ -64226,14 +64396,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 +64439,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 +64457,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":
@@ -66638,7 +66844,9 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 import {
   AutoRoutingInferenceError,
   convertToLlm,
+  isExtensionStartupFailure,
   isModelRoutingDebugEnabled,
+  isTransientExtensionStartupFailure,
   parseModelConstraints,
   setsProviders
 } from "@bastani/atomic";
@@ -66909,6 +67117,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 +67624,7 @@ async function stripWorkflowOnlyOptions(options, defaultSessionDir, meta, pendin
   }
   const {
     schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
     mcp: _mcp,
     fallbackModels,
     modelConstraints: _modelConstraints,
@@ -67732,6 +67958,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 +68130,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 +68182,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 +68273,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 +68534,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 +68546,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 +68567,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 +69332,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 +69744,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 +70870,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_DEPTH2 = 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_DEPTH2 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -71256,6 +71513,7 @@ async function executeRun(def, resolvedInputs, opts) {
   };
   const runtimeSettled = Promise.withResolvers();
   let durableRootAdmitted = false;
+  let terminalStatusCommitted = false;
   let pausePersistence;
   let resumePersistence;
   let controlSettlements = Promise.resolve();
@@ -71445,6 +71703,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,
@@ -71566,7 +71825,9 @@ async function executeRun(def, resolvedInputs, opts) {
           runId,
           runSnapshot,
           isRoot: opts.parentRun === undefined,
-          durableBackend
+          durableBackend,
+          terminalStatusCommitted,
+          store: activeStore
         });
       }
     } finally {
@@ -71645,11 +71906,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 +71964,7 @@ function runDetached(def, inputs, opts = {}) {
     throw error;
   }
   const settle = async (...args) => {
+    const [ok, , error] = args;
     try {
       if (!observed)
         await observe(...args);
@@ -71704,7 +71972,7 @@ function runDetached(def, inputs, opts = {}) {
       detachStartup();
       registry.unregister(runId, controller);
       tracker.unregister(runId, jobEntry);
-      settleJob();
+      settleJob(ok ? undefined : { error });
     }
   };
   backgroundPromise.then((result) => {
@@ -73285,6 +73553,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 +76850,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 +83607,7 @@ import { join as join28 } from "node:path";
 import {
   isStaleExtensionContextError as isStaleExtensionContextError6,
   ModelRuntime,
+  noOpUIContext,
   resolveRestoredModelReference
 } from "@bastani/atomic";
 
@@ -83621,7 +83934,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 +84058,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     notify: ui.notify ?? (() => {
       return;
     }),
+    requestRender: noOpUIContext.requestRender,
     onTerminalInput: ui.onTerminalInput ?? (() => () => {
       return;
     }),
@@ -83797,7 +84118,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 +84128,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 +86232,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 +86250,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 +87030,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 +87069,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 +87132,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 +87918,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 +87955,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 +87968,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 +88072,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 +88164,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 +88184,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 +88521,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 +89559,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 +92014,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: [] };