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

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

@@ -2304,6 +2304,13 @@ function isTopLevelWorkflowRun(run) {
 }
 
 // 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);
 }
@@ -2329,6 +2336,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);
 }
@@ -5994,6 +6003,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,
@@ -6001,11 +6011,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);
@@ -6015,9 +6023,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,
@@ -8908,7 +8914,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) {
@@ -8919,6 +8925,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 } : {},
@@ -9622,6 +9629,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();
@@ -9636,6 +9663,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({
@@ -9649,7 +9679,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)
@@ -9662,13 +9692,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
@@ -9698,8 +9726,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);
@@ -9709,6 +9739,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 } : {},
@@ -9775,7 +9806,7 @@ function buildPromptNodeUiAdapter(input) {
         name: stageSnapshot.name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
-        ts: prompt.createdAt
+        ts: stageSnapshot.startedAt
       });
     }
     if (shouldReplay) {
@@ -11312,7 +11343,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();
@@ -11935,7 +11966,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) {
@@ -13226,13 +13257,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)
       } : {}
@@ -13249,7 +13278,7 @@ function createWorkflowBoundaryFactory(input) {
         name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
-        ts: startedAt
+        ts: stageSnapshot.startedAt
       });
     };
     const appendStageEndForSnapshot = () => {
@@ -13260,6 +13289,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 } : {},
@@ -13296,8 +13326,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();
@@ -13365,6 +13397,12 @@ 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 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];
@@ -14259,7 +14297,7 @@ function createReplayStageContext(input) {
       name,
       parentIds: stageSnapshot.parentIds,
       ...stageReplayFields(stageSnapshot),
-      ts: stageSnapshot.startedAt ?? Date.now()
+      ts: stageSnapshot.startedAt
     });
   };
   const appendReplayStageEnd = () => {
@@ -14269,7 +14307,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 } : {},
@@ -14287,8 +14326,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();
@@ -15649,16 +15686,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();
 }
@@ -15972,6 +16045,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((value) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(value);
+    }, (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)
@@ -16052,9 +16146,14 @@ class StageSessionController {
   activeCreation;
   ownedCreationPromise;
   abortGeneration = 0;
+  routeAuthorityWait;
+  startupWait = new AbortController;
+  startup;
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
+  sessionShutdownPromise;
+  bindingCleanupFailure;
   reattachSessionFile;
   lastPromptStartIndex;
   attemptUsageStartIndex;
@@ -16171,8 +16270,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;
   }
@@ -16200,28 +16298,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?.();
@@ -16266,6 +16377,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);
@@ -16288,7 +16403,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);
@@ -16304,14 +16425,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;
@@ -16319,9 +16435,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;
@@ -16348,8 +16476,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;
       }
     }
@@ -16392,7 +16522,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)
@@ -16466,6 +16597,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) {
@@ -16706,11 +16843,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 }));
     }
@@ -16723,9 +16864,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;
@@ -16807,11 +16948,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;
@@ -16840,16 +16983,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,
@@ -16862,10 +17075,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;
@@ -16876,20 +17098,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) {
@@ -16929,12 +17159,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;
@@ -16945,6 +17179,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;
@@ -16962,6 +17205,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) {
@@ -17054,12 +17298,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 = errorMessage2(err);
     const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
     if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
@@ -17075,7 +17320,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();
@@ -17083,7 +17328,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() {
@@ -17724,9 +17969,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 } : {},
@@ -17789,11 +18032,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")
@@ -17956,6 +18207,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 } : {},
@@ -18561,6 +18813,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({
@@ -18577,6 +18830,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;