@bastani/atomic 0.9.19-alpha.9 → 0.9.20-alpha.1

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

@@ -67164,6 +67164,13 @@ function topLevelWorkflowRuns(runs) {
 }
 
 // dist/builtin/workflows/src/shared/timing.ts
+function stageTimingFields(stage = {}) {
+  return {
+    ...stage.startedAt !== undefined ? { startedAt: stage.startedAt } : {},
+    ...stage.endedAt !== undefined ? { endedAt: stage.endedAt } : {},
+    ...stage.durationMs !== undefined ? { durationMs: stage.durationMs } : {}
+  };
+}
 function nonNegative(ms) {
   return Math.max(0, ms);
 }
@@ -67189,6 +67196,8 @@ function elapsedStageMs(stage, now = Date.now()) {
     return nonNegative(stage.durationMs);
   if (stage.startedAt === undefined)
     return;
+  if (stage.replayed && stage.endedAt === undefined)
+    return;
   const effectiveNow = stage.endedAt ?? now;
   return elapsedFromStart(stage.startedAt, effectiveNow, stage.pausedDurationMs, stage.pausedAt);
 }
@@ -68525,19 +68534,57 @@ function formatWorkflowStageTarget(rootRunId, ...segments) {
 
 // dist/builtin/workflows/src/shared/pending-stage-status.ts
 function workflowBoundarySegments(runs, runId) {
+  return createWorkflowBoundarySegmentsResolver(runs)(runId);
+}
+function createWorkflowBoundarySegmentsResolver(runs) {
   const runById = new Map(runs.map((run) => [run.id, run]));
-  const segments = [];
-  let current = runById.get(runId);
-  while (current !== undefined && current.parentRunId !== undefined) {
-    const parent = runById.get(current.parentRunId);
-    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
-    if (parent === undefined || boundary === undefined)
-      return;
-    const boundaryName = boundary.name;
-    segments.unshift(boundaryName.length > 0 && !boundaryName.includes("/") && !boundaryName.includes("*") ? boundaryName : current.id);
-    current = parent;
+  const stagesByRun = new Map;
+  const childrenByParent = new Map;
+  for (const run of runs) {
+    const byId = new Map;
+    const byName = new Map;
+    for (const stage of run.stages) {
+      const ids = byId.get(stage.id) ?? [];
+      ids.push(stage);
+      byId.set(stage.id, ids);
+      const names = byName.get(stage.name) ?? [];
+      names.push(stage);
+      byName.set(stage.name, names);
+    }
+    stagesByRun.set(run.id, { byId, byName });
+    if (run.parentRunId === undefined || run.parentStageId === undefined)
+      continue;
+    const byStage = childrenByParent.get(run.parentRunId) ?? new Map;
+    const children = byStage.get(run.parentStageId) ?? [];
+    children.push(run);
+    byStage.set(run.parentStageId, children);
+    childrenByParent.set(run.parentRunId, byStage);
   }
-  return current === undefined ? undefined : segments;
+  const cachedSegments = new Map;
+  return (runId) => {
+    if (cachedSegments.has(runId))
+      return cachedSegments.get(runId);
+    const segments = [];
+    let current = runById.get(runId);
+    while (current !== undefined && current.parentRunId !== undefined) {
+      const parent = runById.get(current.parentRunId);
+      const stages = stagesByRun.get(current.parentRunId);
+      const boundary = current.parentStageId === undefined ? undefined : stages?.byId.get(current.parentStageId)?.[0];
+      if (parent === undefined || stages === undefined || boundary === undefined) {
+        cachedSegments.set(runId, undefined);
+        return;
+      }
+      const boundaryName = boundary.name;
+      const matchingBoundaries = stages.byId.get(boundaryName) ?? stages.byName.get(boundaryName);
+      const matchingBoundary = matchingBoundaries?.length === 1 ? matchingBoundaries[0] : undefined;
+      const children = matchingBoundary === undefined ? undefined : childrenByParent.get(parent.id)?.get(matchingBoundary.id);
+      segments.unshift(boundaryName.length > 0 && !boundaryName.includes("/") && !boundaryName.includes("*") && children?.length === 1 && children[0]?.id === current.id ? boundaryName : current.id);
+      current = parent;
+    }
+    const result = current === undefined ? undefined : segments;
+    cachedSegments.set(runId, result);
+    return result;
+  };
 }
 function workflowBoundaryHops(runs, runId) {
   const runById = new Map(runs.map((run) => [run.id, run]));
@@ -68593,6 +68640,15 @@ function pendingWorkflowStageStatuses(run, resolveOwningRunStatus, resolveBounda
   });
 }
 
+// dist/builtin/workflows/src/shared/stage-startup.ts
+function formatStageStartup(startup, now = Date.now()) {
+  const observedAt = startup.state === "dispatched" ? startup.phaseStartedAt : startup.settledAt ?? now;
+  const age = Math.max(0, Math.floor((observedAt - startup.phaseStartedAt) / 1000));
+  const total = Math.max(0, Math.floor((observedAt - startup.startedAt) / 1000));
+  const recovery = startup.state === "cancelled" && startup.ownershipPending ? "; cleanup pending — do not retry in-process; stop the owning Atomic process before fresh execution" : "";
+  return `startup ${startup.phase} (${total}s total, ${age}s on current step; ${startup.state})${recovery}`;
+}
+
 // dist/builtin/workflows/src/tui/status-helpers.ts
 function statusColor(status, theme) {
   switch (status) {
@@ -68848,9 +68904,15 @@ function pendingStageRows(runId, rootRunId, runStatus, stage, width, theme, reso
   const text = hexToAnsi(theme.text);
   return wrapped.map(({ prefix, chunk }, index) => index === 0 ? `   ${muted}${pad(label, 16)}${RESET}${text}${chunk}${RESET} ` : `${prefix}${text}${chunk}${RESET} `);
 }
+function startupRows(stage, now, width, theme) {
+  if (stage.startup === undefined)
+    return [];
+  return wrapIdentifierLines(formatStageStartup(stage.startup, now), Math.max(1, width - 2), "   ", "   ").map(({ prefix, chunk }) => theme === undefined ? `${prefix}${chunk}` : `${prefix}${hexToAnsi(theme.textMuted)}${chunk}${RESET}`);
+}
 function renderStageRowsPlain(runId, rootRunId, runStatus, stage, now, width, resolveOwningRunStatus, resolveBoundarySegments) {
   const rows = [
     ` ${stageLinePlain(stage, now, Math.max(1, width - 2))} `,
+    ...startupRows(stage, now, width),
     ...pendingStageRows(runId, rootRunId, runStatus, stage, width, undefined, resolveOwningRunStatus, resolveBoundarySegments)
   ];
   if (stage.error) {
@@ -68862,6 +68924,7 @@ function renderStageRowsPlain(runId, rootRunId, runStatus, stage, now, width, re
 function renderStageRowsThemed(runId, rootRunId, runStatus, stage, now, theme, width, resolveOwningRunStatus, resolveBoundarySegments) {
   const rows = [
     ` ${stageLineThemed(stage, now, theme, Math.max(1, width - 2))} `,
+    ...startupRows(stage, now, width, theme),
     ...pendingStageRows(runId, rootRunId, runStatus, stage, width, theme, resolveOwningRunStatus, resolveBoundarySegments)
   ];
   if (stage.error) {
@@ -79145,8 +79208,26 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now(), la
   });
 }
 
+// dist/builtin/workflows/src/tui/widget-scroll-hint.ts
+import { keybindingIdentity } from "@bastani/atomic";
+import { getKeybindings, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+var legacyInputs = Array.from({ length: 128 }, (_, code) => String.fromCharCode(code)).flatMap((data) => [
+  data,
+  `\x1B${data}`
+]);
+function workflowScrollHint(bindings = getKeybindings().getResolvedBindings(), platform = process.platform) {
+  const keys = ["app.workflows.scrollUp", "app.workflows.scrollDown"].map((action) => {
+    const configured = bindings[action] ?? [];
+    return (Array.isArray(configured) ? configured : [configured]).find((key) => {
+      const inputs = legacyInputs.filter((data) => matchesKey2(data, key));
+      return !Object.entries(bindings).some(([other, values]) => other !== action && (Array.isArray(values) ? values : [values]).some((value2) => value2 !== undefined && (keybindingIdentity(value2) === keybindingIdentity(key) || inputs.some((data) => matchesKey2(data, value2)))));
+    });
+  }).filter((key) => key !== undefined);
+  const label = keys.map((key) => key.replace(/^alt\+/i, platform === "darwin" ? "Option+" : "Alt+")).join("/");
+  return ` ↑↓ scroll${label ? ` · ${label}` : ""}`;
+}
+
 // dist/builtin/workflows/src/tui/widget-viewport.ts
-import { ScrollableComponentViewport } from "@bastani/atomic";
 var WORKFLOW_WIDGET_MAX_ROWS = 10;
 
 class WorkflowWidgetViewport {
@@ -79154,53 +79235,60 @@ class WorkflowWidgetViewport {
   terminalRows;
   requestRender;
   getRunRows;
-  viewport = new ScrollableComponentViewport;
+  getHint;
+  position = 0;
+  version = 0;
+  collapsed = false;
+  state;
   lines = [];
-  scrollable = false;
   runRows = [];
-  constructor(content, terminalRows, requestRender, getRunRows) {
+  constructor(content, terminalRows, requestRender, getRunRows, getHint = () => "") {
     this.content = content;
     this.terminalRows = terminalRows;
     this.requestRender = requestRender;
     this.getRunRows = getRunRows;
-    this.viewport.setComponents([{ render: () => this.lines, invalidate() {} }]);
-    this.viewport.scrollTo(0);
+    this.getHint = getHint;
+  }
+  getScrollRequest() {
+    return { version: this.version, scrollTop: this.collapsed ? 0 : this.position };
+  }
+  onScroll(state) {
+    this.state = state;
+    if (!this.collapsed)
+      this.position = state.scrollTop;
   }
   scroll(direction) {
-    if (!this.scrollable)
+    if (this.collapsed)
       return;
-    this.viewport.scrollBy(direction);
+    const height = this.state?.viewportHeight ?? Math.max(1, Math.min(WORKFLOW_WIDGET_MAX_ROWS, Math.floor(this.terminalRows() / 3)));
+    const next = Math.max(0, Math.min(Math.max(0, this.lines.length - height), this.position + direction));
+    if (next === this.position)
+      return;
+    this.position = next;
+    this.version++;
     this.requestRender();
   }
   render(width) {
-    const cap = Math.max(1, Math.min(WORKFLOW_WIDGET_MAX_ROWS, Math.floor(this.terminalRows() / 3)));
-    const nextLines = this.content.render(width);
-    const nextRunRows = this.getRunRows?.() ?? [];
-    if (this.getRunRows && nextLines.length === 1 && nextRunRows.length === 0) {
-      this.scrollable = false;
+    const content = this.content.render(width);
+    const hint = content.length > 1 ? this.getHint() : "";
+    const nextLines = hint ? [...content, truncateToWidth2(hint, width, "…")] : content;
+    const nextRunRows = (this.getRunRows?.() ?? []).map((run, index, rows) => hint && index === rows.length - 1 ? { ...run, end: run.end + 1 } : run);
+    const collapsed = Boolean(this.getRunRows && nextLines.length === 1 && nextRunRows.length === 0);
+    if (collapsed) {
+      if (!this.collapsed)
+        this.version++;
+      this.collapsed = true;
       return nextLines;
     }
-    const previousLineCount = this.lines.length;
-    const offset = this.viewport.getMaxScroll() - this.viewport.getScrollFromBottom();
-    const anchoredOffset = this.getRunRows ? this.resolveAnchor(offset, nextRunRows) : undefined;
+    const anchoredOffset = this.getRunRows ? this.resolveAnchor(this.position, nextRunRows) : this.position;
+    if (this.collapsed || anchoredOffset !== this.position) {
+      this.position = anchoredOffset;
+      this.version++;
+    }
+    this.collapsed = false;
     this.lines = nextLines;
     this.runRows = nextRunRows;
-    if (anchoredOffset !== undefined) {
-      this.viewport.scrollTo(anchoredOffset);
-    } else if (previousLineCount <= 1 || this.lines.length < previousLineCount && this.lines.length <= cap) {
-      this.viewport.scrollTo(0);
-    }
-    this.scrollable = this.lines.length > 1;
-    this.viewport.setVisibleRows(1);
-    this.viewport.render(width);
-    if (!this.scrollable)
-      return this.lines;
-    const first = this.viewport.getMaxScroll() - this.viewport.getScrollFromBottom() + 1;
-    const visible = this.lines.slice(first - 1, first - 1 + Math.max(1, cap - 1));
-    if (cap === 1)
-      return visible;
-    const hint = ` ${first}–${first + visible.length - 1}/${this.lines.length} · Alt+PgUp/PgDn scroll workflows`;
-    return [...visible, truncateToWidth2(hint, width, "…")];
+    return nextLines;
   }
   resolveAnchor(offset, next) {
     if (offset === 0 || next.length === 0)
@@ -79272,7 +79360,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
           widgetViewports.delete(storeInstance);
         setWidget.call(ui, key, factory ? (tui, theme) => {
           const host = tui;
-          const viewport = new WorkflowWidgetViewport(factory(tui, theme), () => host?.terminal?.rows ?? 30, () => requestRender ? requestRender.call(ui) : host?.requestRender?.(), () => layout.runs);
+          const viewport = new WorkflowWidgetViewport(factory(tui, theme), () => host?.terminal?.rows ?? 30, () => requestRender ? requestRender.call(ui) : host?.requestRender?.(), () => layout.runs, workflowScrollHint);
           widgetViewports.set(storeInstance, viewport);
           return viewport;
         } : undefined, opts);
@@ -79282,6 +79370,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
     },
     key: WIDGET_KEY,
     placement: "belowEditor",
+    scroll: { maxHeight: 10, maxHeightFraction: 1 / 3 },
     timers,
     getSnapshot: () => liveWidgetSnapshot(storeInstance),
     subscribe: (listener) => subscribeStoreInvalidation(storeInstance, listener),
@@ -87809,6 +87898,7 @@ function cachedStageId(runId, replayKey) {
 function stageMetadataCheckpointId(replayKey, stage) {
   return `${stableCheckpointId("stage-meta", replayKey)}:${durableHash({
     stageId: stage.id,
+    ...stage.replayed === true ? { replayed: true } : {},
     status: stage.status,
     endedAt: stage.endedAt ?? 0,
     durationMs: stage.durationMs ?? 0,
@@ -87816,11 +87906,9 @@ function stageMetadataCheckpointId(replayKey, stage) {
   })}`;
 }
 function recordCachedStageIntoStore(store, runId, name, replayKey, output, completedStageReplayKeys, parentIds, checkpoint) {
-  const now = Date.now();
   const sourceStageId = checkpoint?.topology?.run?.runId === runId ? checkpoint.topology.stageId : undefined;
   const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
   const result = checkpoint?.result ?? (typeof output === "string" ? output : JSON.stringify(output));
-  const endedAt = checkpoint?.endedAt ?? checkpoint?.completedAt ?? now;
   const hasCurrentIdentity = checkpoint?.topology?.sourceOrder !== undefined || checkpoint?.topology?.status !== undefined || checkpoint?.topology?.occurrenceKey !== undefined || checkpoint?.topology?.boundary !== undefined;
   const childResult = parseWorkflowChildResult(output) ?? (hasCurrentIdentity ? undefined : parseLegacyWorkflowChildResult(output));
   const workflowChild = childResult === undefined ? undefined : workflowChildSnapshotFromResult(childResult);
@@ -87830,9 +87918,7 @@ function recordCachedStageIntoStore(store, runId, name, replayKey, output, compl
     name,
     status: "completed",
     parentIds: parentIds !== undefined ? Object.freeze([...parentIds]) : [],
-    startedAt: checkpoint?.startedAt ?? endedAt,
-    endedAt,
-    durationMs: checkpoint?.durationMs ?? 0,
+    ...stageTimingFields(checkpoint),
     result,
     replayKey,
     replayed: true,
@@ -88196,7 +88282,7 @@ function appendStageStart(api, payload) {
     ...payload.replayKey !== undefined ? { replayKey: payload.replayKey } : {},
     ...payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {},
     ...payload.replayed !== undefined ? { replayed: payload.replayed } : {},
-    ts: payload.ts
+    ...payload.ts !== undefined ? { ts: payload.ts } : {}
   });
 }
 function appendStageEnd(api, payload, opts) {
@@ -88207,6 +88293,7 @@ function appendStageEnd(api, payload, opts) {
     stageId: payload.stageId,
     status: payload.status,
     ...payload.durationMs !== undefined ? { durationMs: payload.durationMs } : {},
+    ...payload.endedAt !== undefined ? { endedAt: payload.endedAt } : {},
     ...payload.summary !== undefined ? { summary: payload.summary } : {},
     ...payload.error !== undefined ? { error: payload.error } : {},
     ...payload.failureKind !== undefined ? { failureKind: payload.failureKind } : {},
@@ -100857,6 +100944,26 @@ function createContinuationReplayIndex(continuation, sourceToContinuationNodeIds
 }
 
 // dist/builtin/workflows/src/runs/foreground/executor-prompt-nodes.ts
+function continuationPromptAnswer(store, sourceRun, sourceStage) {
+  let run = sourceRun;
+  let stage = sourceStage;
+  const visited = new Set;
+  while (!visited.has(stage.id)) {
+    visited.add(stage.id);
+    const answer = store.getStagePromptAnswer(run.id, stage.id);
+    if (answer !== undefined)
+      return answer;
+    if (!stage.replayed || stage.replayedFromStageId === undefined || run.resumedFromRunId === undefined)
+      break;
+    const parentRun = store.runs().find((candidate) => candidate.id === run.resumedFromRunId);
+    const parentStage = parentRun?.stages.find((candidate) => candidate.id === stage.replayedFromStageId);
+    if (parentRun === undefined || parentStage === undefined)
+      break;
+    run = parentRun;
+    stage = parentStage;
+  }
+  return;
+}
 function buildPromptNodeUiAdapter(input) {
   const ask = async (descriptor, durableReplay) => {
     input.throwIfWorkflowExitSelected();
@@ -100871,6 +100978,9 @@ function buildPromptNodeUiAdapter(input) {
     const prompt = makePrompt(descriptor);
     const replayKey = promptReplayKey(descriptor);
     const durableTopology = input.durableTopologyForReplayKey?.(replayKey);
+    if (durableTopology?.status === "completed" && durableReplay === undefined) {
+      throw new Error(`insufficient_state: missing durable UI answer for completed prompt ${durableTopology.stageId}`);
+    }
     const stageId = durableTopology?.stageId ?? crypto.randomUUID();
     const provisionalParentIds = input.tracker.onSpawn(stageId, descriptor.kind);
     const replayDecision = input.replayIndex.decide({
@@ -100884,7 +100994,7 @@ function buildPromptNodeUiAdapter(input) {
     if (!sameStringSet(parentIds, provisionalParentIds))
       input.tracker.replaceParents(stageId, parentIds);
     const replaySource = replayDecision.source;
-    const continuationAnswer = replayDecision.kind === "replay" ? input.activeStore.getStagePromptAnswer(input.opts.continuation.source.id, replayDecision.source.id) : undefined;
+    const continuationAnswer = replayDecision.kind === "replay" ? continuationPromptAnswer(input.activeStore, input.opts.continuation.source, replayDecision.source) : undefined;
     const replayAnswer = durableReplay === undefined ? continuationAnswer : { value: durableReplay.response };
     const shouldReplay = replayAnswer !== undefined;
     if (shouldReplay && durableReplay === undefined)
@@ -100897,13 +101007,11 @@ function buildPromptNodeUiAdapter(input) {
       replayKey,
       status: shouldReplay ? "completed" : "running",
       parentIds: Object.freeze(parentIds),
-      startedAt: prompt.createdAt,
+      ...shouldReplay ? stageTimingFields(durableReplay === undefined ? replaySource : input.durableTimingForStageId?.(stageId)) : { startedAt: prompt.createdAt },
       promptFootprint: { ...prompt },
       toolEvents: [],
       attachable: !shouldReplay,
       ...shouldReplay ? {
-        endedAt: prompt.createdAt,
-        durationMs: 0,
         promptAnswerState: promptAnswerStatus,
         replayedFromStageId: replaySourceId,
         replayed: true
@@ -100933,8 +101041,10 @@ function buildPromptNodeUiAdapter(input) {
         pauseGate = undefined;
         currentPauseGate?.resolve();
         stageSnapshot.status = status;
-        stageSnapshot.endedAt = Date.now();
-        stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
+        if (!shouldReplay) {
+          stageSnapshot.endedAt = Date.now();
+          stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
+        }
         input.activeStore.recordStageAttachable(input.runId, stageId, false);
         input.activeStore.recordStageEnd(input.runId, stageSnapshot);
         await input.opts.onStageEnd?.(input.runId, stageSnapshot);
@@ -100944,6 +101054,7 @@ function buildPromptNodeUiAdapter(input) {
             stageId,
             status: stageSnapshot.status,
             durationMs: stageSnapshot.durationMs,
+            endedAt: stageSnapshot.endedAt,
             ...stageSnapshot.error !== undefined ? { error: stageSnapshot.error } : {},
             ...stageSnapshot.failureKind !== undefined ? { failureKind: stageSnapshot.failureKind } : {},
             ...stageSnapshot.failureCode !== undefined ? { failureCode: stageSnapshot.failureCode } : {},
@@ -101010,7 +101121,7 @@ function buildPromptNodeUiAdapter(input) {
         name: stageSnapshot.name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
-        ts: prompt.createdAt
+        ts: stageSnapshot.startedAt
       });
     }
     if (shouldReplay) {
@@ -102281,7 +102392,7 @@ function wrapUiWithDurable(base, deps) {
 // dist/builtin/workflows/src/engine/primitives/ui.ts
 function buildExitGatedUiContext(input) {
   const base = input.opts.usePromptNodesForUi === true ? input.baseFromPromptNodes() : input.opts.executionMode === "non_interactive" && input.opts.ui === undefined ? makeHeadlessUnavailableUIContext() : normalizeUIContext(input.opts.ui);
-  const promptNodeReplay = input.opts.usePromptNodesForUi === true && input.opts.continuation !== undefined;
+  const promptNodeReplay = input.opts.usePromptNodesForUi === true && input.opts.continuation !== undefined && input.opts.continuation.source.id !== input.durableUi?.workflowId;
   const durableBase = input.durableUi !== undefined && !promptNodeReplay ? wrapUiWithDurable(base, input.durableUi) : base;
   const invoke = (call) => {
     input.throwIfWorkflowExitSelected();
@@ -102805,7 +102916,7 @@ function mergeStageDraft(existing, checkpoint, sequence) {
     ...valueOrExisting("thinkingLevel", checkpoint, existing),
     ...valueOrExisting("attemptedModels", checkpoint, existing),
     ...valueOrExisting("modelAttempts", checkpoint, existing),
-    ...checkpoint.topology !== undefined ? { topology: checkpoint.topology } : existing?.topology !== undefined ? { topology: existing.topology } : {}
+    ...existing?.topology?.run !== undefined && checkpoint.topology?.run === undefined ? { topology: existing.topology } : checkpoint.topology !== undefined ? { topology: checkpoint.topology } : existing?.topology !== undefined ? { topology: existing.topology } : {}
   };
 }
 function valueOrExisting(key, checkpoint, existing) {
@@ -103026,7 +103137,7 @@ function resolveToolResumeFrontier(source, backend) {
   if (source.failedToolNodeId === undefined && !checkpoints.some((checkpoint) => checkpoint.kind === "tool" && checkpoint.throwingFailureError === source.error && checkpoint.argsHash === frontier.argsHash && checkpoint.topology?.nodeId === frontier.id && checkpoint.topology.ordinal === frontier.ordinal))
     return fail("missing typed tool failure checkpoint for legacy frontier");
   for (const stage of source.stages) {
-    if (stage.status !== "completed" || !checkpoints.some((checkpoint) => checkpoint.kind === "stage" && checkpoint.replayKey === stage.replayKey && checkpoint.output !== undefined))
+    if (stage.status !== "completed" || !checkpoints.some((checkpoint) => checkpoint.kind === "stage" && checkpoint.replayKey === stage.replayKey && (checkpoint.output !== undefined || ["input", "confirm", "select", "editor", "custom"].includes(stage.name) && stage.replayKey?.startsWith(`prompt:${stage.name}:`) === true && checkpoint.name === stage.name && checkpoint.topology?.stageId === stage.id && checkpoint.topology.status === "completed" && checkpoint.topology.run?.runId === source.id)))
       return fail(`unfinished or missing completed stage checkpoint ${stage.id}`);
   }
   for (const tool of tools) {
@@ -104446,13 +104557,11 @@ function createWorkflowBoundaryFactory(input) {
       replayKey,
       status: replayedChild !== undefined ? "completed" : "running",
       parentIds: Object.freeze([...parentIds]),
-      startedAt,
+      ...replayedChild === undefined ? { startedAt } : stageTimingFields(replaySource),
       toolEvents: [],
       attachable: false,
       ...replaySource !== undefined ? { replayedFromStageId: replaySource.id, replayed: replayedChild !== undefined } : {},
       ...replayedChild !== undefined && replayChildSnapshot !== undefined ? {
-        endedAt: startedAt,
-        durationMs: 0,
         ...replayDecision.kind === "replay" && replayDecision.source.result !== undefined ? { result: replayDecision.source.result } : {},
         workflowChild: cloneWorkflowChildReplaySnapshot(replayChildSnapshot)
       } : {}
@@ -104469,7 +104578,7 @@ function createWorkflowBoundaryFactory(input) {
         name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
-        ts: startedAt
+        ts: stageSnapshot.startedAt
       });
     };
     const appendStageEndForSnapshot = () => {
@@ -104480,6 +104589,7 @@ function createWorkflowBoundaryFactory(input) {
         stageId,
         status: stageSnapshot.status,
         durationMs: stageSnapshot.durationMs,
+        endedAt: stageSnapshot.endedAt,
         ...stageSnapshot.error !== undefined ? { error: stageSnapshot.error } : {},
         ...stageSnapshot.failureKind !== undefined ? { failureKind: stageSnapshot.failureKind } : {},
         ...stageSnapshot.failureCode !== undefined ? { failureCode: stageSnapshot.failureCode } : {},
@@ -104516,8 +104626,10 @@ function createWorkflowBoundaryFactory(input) {
         clearBoundaryChildMetadata();
         applyFailureToStage(stageSnapshot, input.classifyExecutorFailure(failureError));
       }
-      stageSnapshot.endedAt = Date.now();
-      stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
+      if (replayedChild === undefined) {
+        stageSnapshot.endedAt = Date.now();
+        stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
+      }
       input.activeStore.recordStageEnd(input.runId, stageSnapshot);
       input.opts.onStageEnd?.(input.runId, stageSnapshot);
       appendStageEndForSnapshot();
@@ -104585,6 +104697,34 @@ function createWorkflowBoundaryFactory(input) {
 // dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts
 import { runCallback as runCallback3, runSynchronousCallback } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/shared/pending-stage-route-readiness.ts
+var owners = new WeakMap;
+function registerWorkflowPendingStageRouteReadiness(store, ready) {
+  owners.get(store)?.retire();
+  const controller = new AbortController;
+  const owner = {
+    ready(runId) {
+      const completion = ready(runId);
+      return completion === undefined ? undefined : {
+        completion: raceAbort2(completion, controller.signal),
+        assertCurrent: () => controller.signal.throwIfAborted()
+      };
+    },
+    retire() {
+      controller.abort(new Error("atomic-workflows: Intercom route authority owner retired before stage startup"));
+    }
+  };
+  owners.set(store, owner);
+  return () => {
+    owner.retire();
+    if (owners.get(store) === owner)
+      owners.delete(store);
+  };
+}
+function workflowPendingStageRouteReady(store, runId) {
+  return owners.get(store)?.ready(runId);
+}
+
 // dist/builtin/workflows/src/runs/foreground/executor-queued-user-message.ts
 function removedMessages(before, after) {
   const remaining = [...after];
@@ -105439,7 +105579,7 @@ function createReplayStageContext(input) {
       name,
       parentIds: stageSnapshot.parentIds,
       ...stageReplayFields(stageSnapshot),
-      ts: stageSnapshot.startedAt ?? Date.now()
+      ts: stageSnapshot.startedAt
     });
   };
   const appendReplayStageEnd = () => {
@@ -105449,7 +105589,8 @@ function createReplayStageContext(input) {
       runId,
       stageId,
       status: stageSnapshot.status,
-      durationMs: stageSnapshot.durationMs ?? 0,
+      durationMs: stageSnapshot.durationMs,
+      endedAt: stageSnapshot.endedAt,
       ...stageSnapshot.status === "completed" && stageSnapshot.result !== undefined ? { summary: stageSnapshot.result } : {},
       ...stageSnapshot.skippedReason !== undefined ? { skippedReason: stageSnapshot.skippedReason } : {},
       ...stageSnapshot.sessionId !== undefined ? { sessionId: stageSnapshot.sessionId } : {},
@@ -105467,8 +105608,6 @@ function createReplayStageContext(input) {
       delete stageSnapshot.result;
       stageSnapshot.skippedReason = input.workflowExitSkippedReason(reason);
     }
-    stageSnapshot.endedAt = Date.now();
-    stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
     input.activeStore.recordStageEnd(runId, stageSnapshot);
     input.opts.onStageEnd?.(runId, stageSnapshot);
     appendReplayStageEnd();
@@ -106724,16 +106863,52 @@ function stageSessionExtensionRunner(current) {
   }
   return;
 }
+var shutdowns = new WeakMap;
+function shutdownStageSession(current) {
+  if (!current)
+    return Promise.resolve();
+  const existing = shutdowns.get(current);
+  if (existing)
+    return existing;
+  const shutdown = Promise.resolve().then(async () => {
+    const runner = stageSessionExtensionRunner(current);
+    if (runner?.hasHandlers("session_shutdown"))
+      await runner.emit({ type: "session_shutdown", reason: "quit" });
+  });
+  shutdowns.set(current, shutdown);
+  return shutdown;
+}
+
+class StageSessionBindingCleanupFailure extends AggregateError {
+  constructor(bindingError, cleanupErrors) {
+    super([bindingError, ...cleanupErrors], "atomic-workflows: failed binding cleanup did not release session ownership", {
+      cause: bindingError
+    });
+    this.name = "StageSessionBindingCleanupFailure";
+  }
+}
+async function cleanupFailedStageSessionBinding(current, bindingError) {
+  const cleanupErrors = [];
+  try {
+    await shutdownStageSession(current);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  try {
+    await current.dispose();
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  if (cleanupErrors.length > 0)
+    throw new StageSessionBindingCleanupFailure(bindingError, cleanupErrors);
+}
 async function disposeStageSession(current) {
   if (!current)
     return;
-  const runner = stageSessionExtensionRunner(current);
-  if (runner?.hasHandlers("session_shutdown")) {
-    try {
-      await runner.emit({ type: "session_shutdown", reason: "quit" });
-    } catch (error) {
-      console.error("atomic-workflows: stage session_shutdown handler failed", error);
-    }
+  try {
+    await shutdownStageSession(current);
+  } catch (error) {
+    console.error("atomic-workflows: stage session_shutdown handler failed", error);
   }
   await current.dispose();
 }
@@ -107047,6 +107222,27 @@ function terminatingToolCallId(event) {
   return typeof callId === "string" && callId.length > 0 ? callId : undefined;
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-startup-wait.ts
+function waitForStageStartup(operation, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason ?? new DOMException("Stage startup cancelled", "AbortError"));
+    };
+    operation.then((value2) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(value2);
+    }, (error) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+    if (signal.aborted)
+      onAbort();
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
 function hasMeaningfulUsage(usage) {
   if (usage === undefined)
@@ -107127,9 +107323,14 @@ class StageSessionController {
   activeCreation;
   ownedCreationPromise;
   abortGeneration = 0;
+  routeAuthorityWait;
+  startupWait = new AbortController;
+  startup;
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
+  sessionShutdownPromise;
+  bindingCleanupFailure;
   reattachSessionFile;
   lastPromptStartIndex;
   attemptUsageStartIndex;
@@ -107246,8 +107447,7 @@ class StageSessionController {
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${error}. Retrying with ${candidateLabel(nextCandidate)}.`);
     this.modelWarnings.push(...this.pendingFallbackWarnings);
     this.pendingFallbackWarnings.length = 0;
-    await this.disposeCurrentSession();
-    this.activeCandidateIndex = index + 1;
+    await this.disposeCurrentSession(index + 1);
     this.notifyModelFallbackMetaChange();
     return true;
   }
@@ -107275,28 +107475,41 @@ class StageSessionController {
     this.session?.setThinkingLevel(level);
   }
   async ensureSession(consumer = "prompt") {
+    if (this.bindingCleanupFailure !== undefined)
+      throw this.bindingCleanupFailure;
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      await this.sessionShutdownPromise;
+      if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+        throw this.staleCreationReason(generation);
+    }
     if (this.disposed)
       throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
-    if (this.session !== undefined)
+    this.opts.signal?.throwIfAborted();
+    if (this.session !== undefined && this.activeCreation === undefined)
       return this.session;
     if (!this.sessionPromise) {
+      this.beginStartup();
       const pending = this.createInitialSession(consumer);
       this.sessionPromise = pending;
       this.ownedCreationPromise = pending;
-      const release = () => {
+      const release = (failed = false) => {
         if (this.ownedCreationPromise === pending)
           this.ownedCreationPromise = undefined;
+        this.settleStartup(failed);
       };
-      pending.then(release, () => {
-        release();
-        if (this.sessionPromise === pending)
+      pending.then(() => release(), () => {
+        release(true);
+        if (this.sessionPromise === pending) {
           this.sessionPromise = undefined;
+          this.activeCandidateIndex = undefined;
+        }
       });
     }
-    return this.sessionPromise;
+    return waitForStageStartup(this.sessionPromise, this.startupWait.signal);
   }
   async ensureSessionFromFile(sessionFile, consumer = "prompt") {
-    if (!this.sessionPromise && !this.session)
+    if (!this.sessionShutdownPromise && !this.sessionPromise && !this.session)
       this.reattachSessionFile = sessionFile;
     const session = await this.ensureSession(consumer);
     await session.closeWorkflowStageGeneration?.();
@@ -107341,6 +107554,10 @@ class StageSessionController {
     this.artifactCapture.close();
   }
   async promptWithFallback(text, sdkOptions, consumer = "prompt") {
+    if (this.session !== undefined && this.activeCreation === undefined && this.ownedCreationPromise === undefined && this.startupWait.signal.aborted) {
+      this.opts.signal?.throwIfAborted();
+      this.startupWait = new AbortController;
+    }
     if (!this.hasExplicitModelFallbackConfig) {
       try {
         const activeSession = await this.ensureSession(consumer);
@@ -107363,7 +107580,13 @@ class StageSessionController {
       }
       return;
     }
-    const candidates = await this.modelCandidates();
+    const readinessOwner = this.ownedCreationPromise ?? this.activeCreation;
+    if (readinessOwner !== undefined)
+      await waitForStageStartup(readinessOwner, this.startupWait.signal);
+    if (this.session === undefined)
+      this.beginStartup();
+    const startupSignal = this.startupWait.signal;
+    const candidates = await waitForStageStartup(this.modelCandidates(), startupSignal);
     if (candidates.length === 0) {
       try {
         const activeSession = await this.ensureSession(consumer);
@@ -107379,14 +107602,9 @@ class StageSessionController {
       }
       return;
     }
-    if (this.session === undefined && this.sessionPromise !== undefined) {
-      try {
-        await this.sessionPromise;
-      } catch (error) {
-        if (error instanceof StageSessionCreationCancelled)
-          return;
-      }
-    }
+    const creationOwner = this.ownedCreationPromise ?? this.activeCreation;
+    if (creationOwner !== undefined)
+      await waitForStageStartup(creationOwner, startupSignal);
     const resumedText = this.pendingCreationResumeMessage;
     this.pendingCreationResumeMessage = undefined;
     let promptText = resumedText ?? text;
@@ -107394,9 +107612,21 @@ class StageSessionController {
       return;
     let index = this.activeCandidateIndex ?? 0;
     while (index < candidates.length) {
+      if (this.ownedCreationPromise !== undefined || this.activeCreation !== undefined) {
+        try {
+          await waitForStageStartup(this.ownedCreationPromise ?? this.activeCreation, startupSignal);
+        } catch (error) {
+          if (error instanceof StageSessionCreationCancelled)
+            return;
+          throw error;
+        }
+        index = this.activeCandidateIndex ?? index;
+        promptText = this.pendingCreationResumeMessage ?? promptText;
+        this.pendingCreationResumeMessage = undefined;
+      }
       const candidate = candidates[index];
       try {
-        const created = this.session && this.activeCandidateIndex === index ? this.session : await this.createSessionWithThrownErrorRetry(candidate, consumer);
+        const created = this.session && this.activeCandidateIndex === index ? this.session : await waitForStageStartup(this.createSessionWithThrownErrorRetry(candidate, consumer), startupSignal);
         if (isSessionCreationPauseResult(created)) {
           if (created.resumeMessage === undefined)
             return;
@@ -107423,8 +107653,10 @@ class StageSessionController {
         const failure = await this.handleCandidateFailure(err, candidate, candidates, index);
         if (failure === "handled")
           return;
-        if (failure === "throw")
+        if (failure === "throw") {
+          this.settleStartup(true);
           throw err;
+        }
         index += 1;
       }
     }
@@ -107467,7 +107699,8 @@ class StageSessionController {
     this.messageAdmission.dispose();
     this.deliveryActivity.dispose();
     await this.replacement.dispose();
-    await disposeStageSession(this.session);
+    if (this.activeCreation === undefined)
+      await disposeStageSession(this.session);
   }
   async drainPendingDisposal() {
     if (!this.pendingDisposal)
@@ -107541,6 +107774,12 @@ class StageSessionController {
     this.abortGeneration += 1;
     this.abortReason = reason;
     this.abortReasonGeneration = this.abortGeneration;
+    this.routeAuthorityWait?.abort(reason);
+    this.startupWait.abort(reason);
+    if (this.startup?.state === "active") {
+      this.startup = { ...this.startup, state: "cancelled" };
+      this.opts.onStartupChange?.(this.startup);
+    }
     this.abortThrownErrorRetries(reason);
   }
   pauseThrownErrorRetries(resume) {
@@ -107781,11 +108020,15 @@ class StageSessionController {
     return this.candidatesPromise;
   }
   async createInitialSession(consumer) {
+    const generation = this.abortGeneration;
     if (!this.hasExplicitModelFallbackConfig) {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
     const candidates = await this.modelCandidates();
-    const first = candidates[0];
+    if (this.abortGeneration !== generation || this.opts.signal?.aborted || this.disposed)
+      throw this.staleCreationReason(generation);
+    const initialIndex = this.activeCandidateIndex ?? 0;
+    const first = candidates[initialIndex];
     if (first === undefined) {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
@@ -107798,9 +108041,9 @@ class StageSessionController {
       this.resumeCurrentSession = true;
       return resumed;
     }
-    this.activeCandidateIndex = 0;
+    this.activeCandidateIndex = initialIndex;
     this.selectedModel = first.id;
-    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, 0, { error }));
+    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, initialIndex, { error }));
   }
   async createInitialSessionCandidateWalk(candidates, consumer, startIndex, initialFailure) {
     let index = startIndex;
@@ -107882,11 +108125,13 @@ class StageSessionController {
         }
         return await this.createSessionObservingPause(candidate, consumer);
       } catch (error) {
+        if (error instanceof StageSessionBindingCleanupFailure)
+          throw error;
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
         const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
-        if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.capturedStructuredOutputForAttempt()) {
+        if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.startupWait.signal.aborted || this.capturedStructuredOutputForAttempt()) {
           throw error;
         }
         retryAttempt = decision.attempt;
@@ -107915,16 +108160,86 @@ class StageSessionController {
     }
   }
   createSession(candidate, consumer, resumeOptions) {
+    if (this.bindingCleanupFailure !== undefined)
+      return Promise.reject(this.bindingCleanupFailure);
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      return this.sessionShutdownPromise.then(() => {
+        if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+          throw this.staleCreationReason(generation);
+        return this.createSession(candidate, consumer, resumeOptions);
+      });
+    }
+    if (this.activeCreation !== undefined)
+      return this.activeCreation;
+    if (this.session !== undefined)
+      return Promise.resolve(this.session);
+    this.startupWait.signal.throwIfAborted();
     const creation = this.createSessionAttempt(candidate, consumer, resumeOptions);
     this.activeCreation = creation;
     creation.finally(() => {
       if (this.activeCreation === creation)
         this.activeCreation = undefined;
+      this.settleStartup();
     }).catch(() => {});
     return creation;
   }
+  settleStartup(failed = false) {
+    if (this.activeCreation !== undefined || this.ownedCreationPromise !== undefined || this.startup === undefined)
+      return;
+    if (this.startup.state === "dispatched" || this.startup.phase === "ready")
+      return;
+    if (this.startup.state === "active" && !failed && this.bindingCleanupFailure === undefined)
+      return;
+    this.startup = {
+      ...this.startup,
+      state: this.startup.state === "active" ? "failed" : this.startup.state,
+      ownershipPending: this.bindingCleanupFailure !== undefined,
+      ...this.bindingCleanupFailure === undefined ? { settledAt: Date.now() } : {}
+    };
+    this.opts.onStartupChange?.(this.startup);
+  }
+  beginStartup() {
+    if (this.activeCreation !== undefined || this.ownedCreationPromise !== undefined || this.sessionPromise !== undefined)
+      return;
+    this.opts.signal?.throwIfAborted();
+    if (this.startupWait.signal.aborted)
+      this.startupWait = new AbortController;
+    this.reportStartupPhase("model-resolution", true);
+  }
+  reportStartupPhase(phase, reset = false) {
+    if (!reset && this.startup !== undefined && this.startup.state !== "active")
+      return;
+    const now = Date.now();
+    this.startup = {
+      phase,
+      startedAt: reset ? now : this.startup?.startedAt ?? now,
+      phaseStartedAt: now,
+      state: phase === "first-dispatch" ? "dispatched" : "active",
+      ownershipPending: phase !== "first-dispatch" && phase !== "ready"
+    };
+    this.opts.onStartupChange?.(this.startup);
+  }
   async createSessionAttempt(candidate, consumer, resumeOptions) {
     const startGeneration = this.abortGeneration;
+    if (this.disposed || this.opts.signal?.aborted)
+      throw this.staleCreationReason(startGeneration);
+    this.reportStartupPhase("route-authority");
+    const authority = this.opts.routeAuthorityReady?.();
+    if (authority !== undefined) {
+      const wait = new AbortController;
+      this.routeAuthorityWait = wait;
+      try {
+        await raceAbort2(authority.completion, wait.signal);
+        authority.assertCurrent();
+        if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== startGeneration)
+          throw this.staleCreationReason(startGeneration);
+      } finally {
+        if (this.routeAuthorityWait === wait)
+          this.routeAuthorityWait = undefined;
+      }
+    }
+    this.reportStartupPhase("resource-preparation");
     this.applyCandidateThinking(candidate);
     const stageOptions = buildStageSessionOptions({
       effectiveStageOptions: this.effectiveStageOptions,
@@ -107937,10 +108252,19 @@ class StageSessionController {
     try {
       created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptions, this.opts.defaultSessionDir, this.meta, this.opts.pendingStageDelivery), {
         ...this.meta,
+        startupSignal: this.startupWait.signal,
+        onStartupPhase: (phase) => {
+          if (this.abortGeneration === startGeneration)
+            this.reportStartupPhase(phase);
+        },
         stageOptions,
         ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
       }) : missingAdapter(consumer);
     } catch (error) {
+      if (error instanceof StageSessionBindingCleanupFailure) {
+        this.bindingCleanupFailure = error;
+        throw error;
+      }
       if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
         throw this.disposed ? new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`) : this.staleCreationReason(startGeneration);
       throw error;
@@ -107951,20 +108275,28 @@ class StageSessionController {
         throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
       throw this.staleCreationReason(startGeneration);
     }
+    this.reportStartupPhase("session-attachment");
     const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
     const attachedSession = session instanceof Promise ? await session : session;
-    const pendingStageDeliveryReady = this.sharedOrchestrationContext?.pendingStageDelivery?.ready();
-    if (pendingStageDeliveryReady !== undefined) {
+    this.reportStartupPhase("delivery-readiness");
+    try {
+      await this.sharedOrchestrationContext?.pendingStageDelivery?.ready();
+      await this.opts.onSessionReady?.();
+      if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== startGeneration)
+        throw this.staleCreationReason(startGeneration);
+    } catch (reason) {
+      if (this.session === attachedSession)
+        this.session = undefined;
       try {
-        await pendingStageDeliveryReady;
+        await cleanupFailedStageSessionBinding(attachedSession, reason);
       } catch (error) {
-        if (this.session === attachedSession)
-          this.session = undefined;
-        await disposeStageSession(attachedSession).catch(() => {});
+        if (error instanceof StageSessionBindingCleanupFailure)
+          this.bindingCleanupFailure = error;
         throw error;
       }
+      throw reason;
     }
-    await this.opts.onSessionReady?.();
+    this.reportStartupPhase("ready");
     return attachedSession;
   }
   attachSession(created) {
@@ -108004,12 +108336,16 @@ class StageSessionController {
     });
     return result.session;
   }
-  async disposeCurrentSession() {
+  async disposeCurrentSession(nextCandidateIndex) {
+    if (this.sessionShutdownPromise !== undefined)
+      await this.sessionShutdownPromise;
+    const startGeneration = this.abortGeneration;
     this.abortThrownErrorRetries(new Error(`atomic-workflows: stage "${this.opts.stageName}" session was replaced`));
     const current = this.session;
     this.messageAdmission.reset();
     this.replacement.retire(current);
     this.session = undefined;
+    this.activeCandidateIndex = nextCandidateIndex;
     if (this.sessionPromise !== this.ownedCreationPromise)
       this.sessionPromise = undefined;
     this.sessionSettingsManager = undefined;
@@ -108020,6 +108356,15 @@ class StageSessionController {
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = undefined;
     this.terminatingToolCallIds.clear();
+    const shutdown = Promise.resolve().then(() => shutdownStageSession(current));
+    this.sessionShutdownPromise = shutdown;
+    shutdown.then(() => {
+      if (this.sessionShutdownPromise === shutdown)
+        this.sessionShutdownPromise = undefined;
+    }, () => {});
+    await shutdown;
+    if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
+      throw this.staleCreationReason(startGeneration);
   }
   async promptWithPauseResume(activeSession, initialText, sdkOptions) {
     let nextText = initialText;
@@ -108037,6 +108382,7 @@ class StageSessionController {
       this.lastPromptStartIndex = promptStartIndex;
       this.unresolvedContextOverflowMessage = undefined;
       try {
+        this.reportStartupPhase("first-dispatch");
         await activeSession.prompt(nextText, sdkOptions);
         const pendingPauseAfterPrompt = this.pauseControl.currentResume();
         if (pendingPauseAfterPrompt) {
@@ -108129,12 +108475,13 @@ class StageSessionController {
         throw err;
       }
       this.pendingFallbackWarnings.push(resumedOverflowNextIndex === undefined ? `[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${candidateLabel(candidates[0])}.` : `[fallback] resume on ${resumedLabel} failed: ${message}. Retrying with ${candidateLabel(candidates[resumedOverflowNextIndex])}.`);
-      await this.disposeCurrentSession();
-      this.activeCandidateIndex = resumedOverflowNextIndex;
+      await this.disposeCurrentSession(resumedOverflowNextIndex);
       return false;
     }
   }
   async handleCandidateFailure(err, candidate, candidates, index) {
+    if (err instanceof StageSessionBindingCleanupFailure)
+      throw err;
     const message = errorMessage4(err);
     const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
     if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
@@ -108150,7 +108497,7 @@ class StageSessionController {
       ...usage === undefined ? {} : { usage },
       error: message
     });
-    if (this.opts.signal?.aborted || terminalStageDelivery || !isRetryableModelFailure(err) || index === candidates.length - 1) {
+    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !isRetryableModelFailure(err) || index === candidates.length - 1) {
       this.modelWarnings.push(...this.pendingFallbackWarnings);
       this.pendingFallbackWarnings.length = 0;
       this.notifyModelFallbackMetaChange();
@@ -108158,7 +108505,7 @@ class StageSessionController {
     }
     const nextCandidate = candidates[index + 1];
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${message}. Retrying with ${candidateLabel(nextCandidate)}.`);
-    await this.disposeCurrentSession();
+    await this.disposeCurrentSession(index + 1);
     return "retry";
   }
   capturedStructuredOutputForAttempt() {
@@ -108799,9 +109146,7 @@ function createWorkflowStageFactory(input) {
       toolEvents: [],
       pendingStageDeliveryAvailable,
       ...shouldReplay ? {
-        startedAt: Date.now(),
-        endedAt: Date.now(),
-        durationMs: 0,
+        ...stageTimingFields(replaySource),
         ...replaySource.result !== undefined ? { result: replaySource.result } : {},
         ...replaySource.sessionId !== undefined ? { sessionId: replaySource.sessionId } : {},
         ...replaySource.sessionFile !== undefined ? { sessionFile: replaySource.sessionFile } : {},
@@ -108864,11 +109209,19 @@ function createWorkflowStageFactory(input) {
       signal: input.signal,
       stageOptions: stageOptionsForContext,
       ...pendingStageDeliveryAvailable ? {
+        routeAuthorityReady: () => workflowPendingStageRouteReady(input.activeStore, input.runId),
         pendingStageDelivery: createWorkflowPendingStageDelivery(input.activeStore, input.runId, stageId, name)
       } : {},
       models: input.opts.models,
       executionMode: input.opts.executionMode,
       defaultSessionDir: input.opts.defaultSessionDir,
+      onStartupChange(startup) {
+        const current = input.activeStore.runs().find((run) => run.id === input.runId);
+        if (!current?.stages.includes(stageSnapshot))
+          return;
+        stageSnapshot.startup = startup;
+        input.activeStore.recordStageStart(input.runId, stageSnapshot);
+      },
       onModelFallbackMetaChange(meta) {
         applyModelFallbackMeta(meta);
         if (stageSnapshot.status === "running")
@@ -109031,6 +109384,7 @@ function createWorkflowStageFactory(input) {
           stageId,
           status: stageSnapshot.status,
           durationMs: stageSnapshot.durationMs,
+          endedAt: stageSnapshot.endedAt,
           ...stageSnapshot.error !== undefined ? { error: stageSnapshot.error } : {},
           ...stageSnapshot.failureKind !== undefined ? { failureKind: stageSnapshot.failureKind } : {},
           ...stageSnapshot.failureCode !== undefined ? { failureCode: stageSnapshot.failureCode } : {},
@@ -109636,6 +109990,7 @@ async function run(def, inputs, opts = {}) {
     };
   };
   const resolvePromptNodeTopology = createDurableStageTopologyResolver(durableBackend, runId);
+  const priorPromptStageCheckpoints = durableBackend.listCheckpoints(runId).filter((checkpoint) => checkpoint.kind === "stage");
   let promptNodeUi;
   const getPromptNodeUi = () => {
     promptNodeUi ??= buildPromptNodeUiAdapter({
@@ -109652,6 +110007,7 @@ async function run(def, inputs, opts = {}) {
       workflowExitSkippedReason: exit.workflowExitSkippedReason,
       preserveWorkflowExitSkippedReason: exit.preserveWorkflowExitSkippedReason,
       durableTopologyForReplayKey: resolvePromptNodeTopology,
+      durableTimingForStageId: (stageId) => priorPromptStageCheckpoints.find((checkpoint) => checkpoint.topology?.stageId === stageId && checkpoint.topology.status === "completed" && (checkpoint.topology.run === undefined || checkpoint.topology.run.runId === runId)),
       onPendingStage: async (pendingRunId, snapshot) => pendingRunId === runId ? void await recordDurableActiveStage(durableStageDeps, snapshot) : undefined
     });
     return promptNodeUi;
@@ -112905,11 +113261,14 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
     return payload.handled && await payload.completion === true;
   };
   const announcedRoutes = new Map;
+  const routeCompletions = new Map;
+  const disposeReadiness = registerWorkflowPendingStageRouteReadiness(activeStore, (runId) => routeCompletions.get(runId));
   const announceRoutes = () => {
     if (disposed)
       return;
     const ownedRunIds = new Set;
     const runs = activeStore.runs();
+    const resolveBoundarySegments = createWorkflowBoundarySegmentsResolver(runs);
     for (const run of runs) {
       const rootRunId = durableRootRunIdForRun(runs, run.id);
       if (rootRunId === undefined)
@@ -112930,7 +113289,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
           ...run.stages.filter((stage) => !isNonAgentStage(stage) && workflowInvocationOwnsGroup(workflowInvocationIntercomGroup(rootRunId), stage.intercomGroup ?? workflowInvocationIntercomGroup(rootRunId))).map((stage) => ({
             stageId: stage.id,
             stageName: stage.name,
-            target: stageRouteTarget(runs, rootRunId, run.id, stage.id),
+            target: stageRouteTarget(runs, rootRunId, run.id, stage.id, resolveBoundarySegments),
             lifecycle: stage.sessionId === undefined && stage.sessionFile === undefined ? "pending" : "running",
             routeEligible: stage.pendingStageDeliveryAvailable === true && (stage.status === "pending" || stage.status === "running" || stage.status === "awaiting_input" || stage.status === "paused" || stage.status === "blocked"),
             group: stage.intercomGroup ?? workflowInvocationIntercomGroup(rootRunId)
@@ -112938,7 +113297,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
           ...nonAgentNodes(run).map((node) => ({
             stageId: node.id,
             stageName: node.name,
-            target: stageRouteTarget(runs, rootRunId, run.id, node.id),
+            target: stageRouteTarget(runs, rootRunId, run.id, node.id, resolveBoundarySegments),
             lifecycle: "pending",
             routeEligible: false,
             recipientPurpose: "control",
@@ -112957,12 +113316,17 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
       } catch (error) {
         if (announcedRoutes.get(run.id) === entry)
           announcedRoutes.delete(run.id);
+        const failure = Promise.reject(error);
+        failure.catch(() => {});
+        routeCompletions.set(run.id, failure);
         throw error;
       }
       const completion = announcement.completion;
       if (completion === undefined) {
         announcedRoutes.delete(run.id);
+        routeCompletions.delete(run.id);
       } else {
+        routeCompletions.set(run.id, completion);
         completion.catch(() => {
           if (announcedRoutes.get(run.id) === entry)
             announcedRoutes.delete(run.id);
@@ -112973,6 +113337,10 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
       if (!ownedRunIds.has(runId))
         announcedRoutes.delete(runId);
     }
+    for (const runId of routeCompletions.keys()) {
+      if (!ownedRunIds.has(runId))
+        routeCompletions.delete(runId);
+    }
     sweepPromise = sweepPromise.then(() => settleUndeliverablePendingStageMessages(activeStore, notifyUndeliverable)).then(() => {
       return;
     }).catch((error) => reportWarning(`atomic-workflows: pending stage delivery sweep failed: ${error.message}`));
@@ -113051,6 +113419,8 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
   });
   const dispose = () => {
     disposed = true;
+    disposeReadiness();
+    routeCompletions.clear();
     unsubscribeStore();
     if (typeof subscription === "function")
       subscription();
@@ -113061,8 +113431,8 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
   pi.on?.("session_shutdown", dispose);
   return dispose;
 }
-function stageRouteTarget(runs, rootRunId, runId, stageId) {
-  const boundarySegments = runId === rootRunId ? [] : workflowBoundarySegments(runs, runId);
+function stageRouteTarget(runs, rootRunId, runId, stageId, resolveBoundarySegments = (id) => workflowBoundarySegments(runs, id)) {
+  const boundarySegments = runId === rootRunId ? [] : resolveBoundarySegments(runId);
   return formatWorkflowStageTarget(rootRunId, ...boundarySegments ?? [runId], stageId);
 }
 function possibleStageRows(runs, rootRunId, rootRun) {
@@ -113537,6 +113907,8 @@ function resolveSessionCwd(options) {
   return options?.cwd ?? options?.sessionManager?.getCwd() ?? process.cwd();
 }
 async function prepareAtomicStageSessionOptions(options, sdk, prepareOptions = {}) {
+  prepareOptions.signal?.throwIfAborted();
+  prepareOptions.onStartupPhase?.("resource-preparation");
   const atomicOptions = options;
   if (atomicOptions?.resourceLoader !== undefined)
     return atomicOptions;
@@ -113555,7 +113927,8 @@ async function prepareAtomicStageSessionOptions(options, sdk, prepareOptions = {
     resourceLoaderInheritanceSnapshot: inheritanceSnapshot,
     builtinPackagePaths: stageBuiltinPackagePaths(builtinPackagePaths)
   });
-  await reloadWorkflowStageResources(resourceLoader);
+  await reloadWorkflowStageResources(resourceLoader, prepareOptions);
+  prepareOptions.signal?.throwIfAborted();
   return {
     ...atomicOptions,
     cwd,
@@ -113592,8 +113965,13 @@ function stageBuiltinPackagePaths(paths) {
   });
 }
 var workflowStageResourceReloadQueue = Promise.resolve();
-async function reloadWorkflowStageResources(resourceLoader) {
-  const queuedReload = workflowStageResourceReloadQueue.then(() => resourceLoader.reload());
+async function reloadWorkflowStageResources(resourceLoader, options) {
+  options.onStartupPhase?.("reload-queued");
+  const queuedReload = workflowStageResourceReloadQueue.then(() => {
+    options.signal?.throwIfAborted();
+    options.onStartupPhase?.("reload-active");
+    return resourceLoader.reload();
+  });
   workflowStageResourceReloadQueue = queuedReload.catch(() => {
     return;
   });
@@ -113628,8 +114006,8 @@ function attachSettingsManager(error, settingsManager) {
   });
   return wrapped;
 }
-async function createPiSdkAgentSession(options, prepareOptions) {
-  const sdk = await import("@bastani/atomic");
+async function createPiSdkAgentSession(options, prepareOptions, injectedSdk) {
+  const sdk = injectedSdk ?? await import("@bastani/atomic");
   let settingsManager;
   try {
     const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk, {
@@ -113640,6 +114018,8 @@ async function createPiSdkAgentSession(options, prepareOptions) {
       }
     });
     settingsManager = sessionOptions?.settingsManager ?? settingsManager;
+    prepareOptions?.signal?.throwIfAborted();
+    prepareOptions?.onStartupPhase?.("sdk-creation");
     const result = await sdk.createAgentSession(sessionOptions);
     const resultSettingsManager = result.session.settingsManager;
     settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager ?? settingsManager;
@@ -113899,18 +114279,28 @@ function makeStageExtensionUiContext(ui, meta, broker) {
   };
 }
 function buildRuntimeAdapters(pi, options = {}) {
-  const createSession = options.createAgentSession ?? pi.createAgentSession ?? (isTestContext() ? createTestAgentSession : (sessionOptions) => createPiSdkAgentSession(sessionOptions, {
-    resourceLoaderInheritanceSnapshot: pi.getResourceLoaderInheritanceSnapshot?.()
-  }));
+  const createSession = options.createAgentSession ?? pi.createAgentSession ?? (isTestContext() && options.sdk === undefined ? createTestAgentSession : (sessionOptions, prepareOptions) => createPiSdkAgentSession(sessionOptions, {
+    resourceLoaderInheritanceSnapshot: pi.getResourceLoaderInheritanceSnapshot?.(),
+    ...prepareOptions
+  }, options.sdk));
   const broker = options.stageUiBroker ?? stageUiBroker;
   const adapters = {
     agentSession: {
       async create(stageOptions, meta) {
         const sessionOptions = withWorkflowStageSessionOptions(stripWorkflowOnlyOptions2(stageOptions) ?? {}, meta, pi);
-        const result = await createSession(sessionOptions);
+        const signal = meta?.startupSignal ?? meta?.signal;
+        const result = await createSession(sessionOptions, { signal, onStartupPhase: meta?.onStartupPhase });
         const bindable = result.session;
-        if (typeof bindable.bindExtensions === "function") {
-          await bindable.bindExtensions(shouldBindStageUiContext(pi, meta) ? { uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta, broker) } : {});
+        try {
+          signal?.throwIfAborted();
+          meta?.onStartupPhase?.("extension-binding");
+          if (typeof bindable.bindExtensions === "function") {
+            await bindable.bindExtensions(shouldBindStageUiContext(pi, meta) ? { uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta, broker) } : {});
+          }
+          signal?.throwIfAborted();
+        } catch (error) {
+          await cleanupFailedStageSessionBinding(result.session, error);
+          throw error;
         }
         return result;
       }
@@ -115475,7 +115865,21 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
         return true;
       runId = picked.runId;
     } else if (action === "resume") {
-      const backend = getDurableBackend();
+      let backend;
+      try {
+        try {
+          backend = getDurableBackend();
+        } catch (error) {
+          if (!(error instanceof DbosNotReadyError))
+            throw error;
+          await ensureWorkflowResourcesVisible();
+          await deps.runtimeForContext(ctx).prepareDurableResumable(target);
+          backend = getDurableBackend();
+        }
+      } catch (error) {
+        fail(`Failed to resolve workflow resume target: ${error instanceof Error ? error.message : String(error)}`);
+        return true;
+      }
       const localResolution = resolveRunId(target);
       const localBeforePreparation = localResolution.kind === "exact" ? store.runs().find((run) => run.id === localResolution.runId) : undefined;
       const exactBeforePreparation = localBeforePreparation?.id === target ? localBeforePreparation : undefined;
@@ -116329,6 +116733,8 @@ function renderStagesToolContent(result) {
   lines.push("stages:");
   result.stages.forEach((stage, index) => {
     lines.push(`[${index + 1}] ${stage.name} (${stage.id}) ${stage.status}`);
+    if (stage.startup)
+      lines.push(formatStageStartup(stage.startup));
     if (stage.sessionId)
       lines.push(`sessionId: ${stage.sessionId}`);
     if (stage.sessionFile)
@@ -116369,6 +116775,8 @@ function renderStageToolContent(result) {
 `);
   }
   lines.push("stage:");
+  if (result.stage.startup)
+    lines.push(formatStageStartup(result.stage.startup));
   lines.push(JSON.stringify(result.stage, null, 2));
   if (result.stage.sessionFile) {
     lines.push(`transcriptPath: ${result.stage.sessionFile}`);
@@ -116847,6 +117255,7 @@ function summarizeStage(stage) {
     id: stage.id,
     name: stage.name,
     status: stage.status,
+    ...stage.startup === undefined ? {} : { startup: { ...stage.startup } },
     sessionId: stage.sessionId,
     sessionFile: stage.sessionFile,
     transcriptPath: stage.sessionFile,
@@ -117845,10 +118254,14 @@ function registerWorkflowShortcut(pi, overlay) {
   });
   pi.registerShortcut("alt+pageUp", {
     description: "Scroll background workflows up",
+    keybinding: "app.workflows.scrollUp",
+    preferEditor: true,
     handler: () => scrollStoreWidget(store, -1)
   });
   pi.registerShortcut("alt+pageDown", {
     description: "Scroll background workflows down",
+    keybinding: "app.workflows.scrollDown",
+    preferEditor: true,
     handler: () => scrollStoreWidget(store, 1)
   });
 }