@bastani/atomic 0.9.19 → 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();
@@ -15673,6 +15710,21 @@ class StageSessionBindingCleanupFailure extends AggregateError {
     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;
@@ -15993,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)
@@ -16073,6 +16146,9 @@ class StageSessionController {
   activeCreation;
   ownedCreationPromise;
   abortGeneration = 0;
+  routeAuthorityWait;
+  startupWait = new AbortController;
+  startup;
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
@@ -16232,25 +16308,28 @@ class StageSessionController {
     }
     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();
+      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.sessionShutdownPromise && !this.sessionPromise && !this.session)
@@ -16298,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);
@@ -16320,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);
@@ -16336,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;
@@ -16351,9 +16435,9 @@ class StageSessionController {
       return;
     let index = this.activeCandidateIndex ?? 0;
     while (index < candidates.length) {
-      if (this.session === undefined && this.ownedCreationPromise !== undefined) {
+      if (this.ownedCreationPromise !== undefined || this.activeCreation !== undefined) {
         try {
-          await this.ownedCreationPromise;
+          await waitForStageStartup(this.ownedCreationPromise ?? this.activeCreation, startupSignal);
         } catch (error) {
           if (error instanceof StageSessionCreationCancelled)
             return;
@@ -16365,7 +16449,7 @@ class StageSessionController {
       }
       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;
@@ -16392,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;
       }
     }
@@ -16436,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)
@@ -16510,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) {
@@ -16750,10 +16843,13 @@ 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();
+    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) {
@@ -16858,7 +16954,7 @@ class StageSessionController {
         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;
@@ -16901,16 +16997,72 @@ class StageSessionController {
       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,
@@ -16923,6 +17075,11 @@ 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);
@@ -16941,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) {
@@ -17040,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) {
@@ -17154,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();
@@ -17803,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 } : {},
@@ -17868,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")
@@ -18035,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 } : {},
@@ -18640,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({
@@ -18656,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;

package/docs/background-tasks.md

@@ -112,6 +112,8 @@ Completion creates a shaded notification card in the owning chat without dependi
 
 The parent model also receives the result context. The internal receipt stays in structured message details, rather than becoming raw JSON in chat. The same persisted completion identity handles delivery retries without relaunching the child. Workflow completions remain in their owning stage chat, not the main conversation.
 
+Supervisor progress messages are labelled **Historical supervisor update** with their original `Sent:` timestamp. They describe the child's state when sent, not its current status, and can arrive after completion. Prefer a later correction or final result over an earlier progress hypothesis; use `/tasks` for the current task state.
+
 Stopping a subagent through `/tasks` (`x`, then `y`) also delivers a **stopped** card and stop context to the parent model. The notice arrives after termination is confirmed, not while the task is merely **Stopping**, and does not require a final response from the child. Cancelling queued work notifies without starting it. Repeated stop requests or late child results do not duplicate the notice or overwrite the recorded outcome; a task that finished before cancellation keeps its actual result. Closing the owning session or workflow stage still suppresses late notices.
 
 Restored completions may have only an outcome and task identity if the original live task or transcript is unavailable. Atomic does not invent missing output. Excerpts are bounded; inspect retained history for more detail.