@bastani/atomic 0.9.13-alpha.2 → 0.9.13-alpha.3

package/dist/builtin/workflows/src/extension/runtime-durable-resume.ts

@@ -13,6 +13,7 @@ import {
 	type ResumeDurableResult,
 	resumeDurableWorkflow as resumeDurableWorkflowAdapter,
 } from "../durable/resume-runtime.js";
+import { inspectTargetedDurableWorkflow, type TargetedDurableInspection } from "../durable/targeted-inspection.js";
 import type { ResumableWorkflowEntry } from "../durable/types.js";
 import type { JobTracker } from "../runs/background/job-tracker.js";
 import type { RunOpts } from "../runs/foreground/executor.js";
@@ -28,6 +29,7 @@ export interface DurableResumeRuntime {
 		workflowId: string,
 		options?: { readonly policy?: WorkflowExecutionPolicy; readonly actor?: WorkflowActor },
 	): Promise<ResumeDurableResult>;
+	inspectDurableWorkflow(workflowId: string): Promise<TargetedDurableInspection>;
 	listDurableResumable(): readonly ResumableWorkflowEntry[];
 	prepareDurableResumable(workflowId?: string): Promise<readonly ResumableWorkflowEntry[]>;
 	prepareDurableCatalog?(): Promise<DurableWorkflowCatalogEntries>;
@@ -65,6 +67,10 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 	};
 	let preparedCatalog: readonly ResumableWorkflowEntry[] = [];
 	return {
+		async inspectDurableWorkflow(workflowId) {
+			await deps.ensureReady();
+			return await inspectTargetedDurableWorkflow(getDurableBackend(), workflowId);
+		},
 		async resumeDurableWorkflow(workflowId, options): Promise<ResumeDurableResult> {
 			await deps.ensureReady();
 			const backend = getDurableBackend();

package/dist/builtin/workflows/src/extension/ui-surface.ts

@@ -209,6 +209,8 @@ export interface PiHostSessionPickerRow {
 	modifiedAt: number;
 	messageCount: number;
 	firstMessage: string;
+	/** Generated resume summary. Absent when never generated, or stale against the latest message. */
+	summary?: string;
 	allMessagesText?: string;
 	name?: string;
 	/** Optional semantic color for synthetic selector rows. */

package/dist/builtin/workflows/src/extension/workflow-command-registration.ts

@@ -153,7 +153,12 @@ async function workflowSlashHandler(
 		if (target && !target.startsWith("--")) {
 			const resolved = resolveRunId(target);
 			if (resolved.kind === "malformed") return fail(resolved.message);
-			if (resolved.kind === "not_found") return fail(`Run not found: ${target}`);
+			if (resolved.kind === "not_found") {
+				const durable = await deps.runtimeForContext(ctx).inspectDurableWorkflow(target);
+				if (durable.kind !== "found") return fail(durable.message);
+				emitChatSurface(pi, { kind: "detail", detail: durable.detail });
+				return;
+			}
 			const inspected = inspectRun(resolved.runId);
 			if (!inspected.ok) return fail(`Run not found: ${target}`);
 			emitChatSurface(pi, { kind: "detail", detail: inspected.detail });

package/dist/builtin/workflows/src/extension/workflow-targets.ts

@@ -7,7 +7,7 @@ import {
 } from "../shared/expanded-workflow-graph.js";
 import { isFullRunId, malformedRunIdMessage, RUN_ID_LENGTH } from "../shared/run-id.js";
 import { topLevelWorkflowRuns } from "../shared/run-visibility.js";
-import { store } from "../shared/store.js";
+import { type Store, store } from "../shared/store.js";
 import { readGraphStoreSnapshot } from "../shared/store-observation.js";
 import type { RunStatus } from "../shared/store-types.js";
 import type { OverlayPiSurface } from "../tui/overlay-adapter.js";
@@ -87,9 +87,9 @@ export type RunIdResolution =
 	| { kind: "malformed"; message: string }
 	| { kind: "not_found" };
 
-export function resolveRunId(target: string): RunIdResolution {
+export function resolveRunId(target: string, activeStore: Store = store): RunIdResolution {
 	if (!isFullRunId(target)) return { kind: "malformed", message: malformedRunIdMessage(target) };
-	const exact = store.runs().find((r) => r.id === target);
+	const exact = activeStore.runs().find((r) => r.id === target);
 	if (exact) return { kind: "exact", runId: exact.id };
 	return { kind: "not_found" };
 }
@@ -100,12 +100,16 @@ export type ToolRunTarget =
 	| { kind: "malformed"; target: string; message: string }
 	| { kind: "not_found"; target: string; message: string };
 
-export function resolveToolRunTarget(args: WorkflowToolArgs, emptyMessage: string): ToolRunTarget {
+export function resolveToolRunTarget(
+	args: WorkflowToolArgs,
+	emptyMessage: string,
+	activeStore: Store = store,
+): ToolRunTarget {
 	const rawTarget = args.runId?.trim() ?? "";
 	if (args.all === true || rawTarget === "--all") return { kind: "all" };
-	const target = rawTarget || store.activeRunId() || "";
+	const target = rawTarget || activeStore.activeRunId() || "";
 	if (!target) return { kind: "not_found", target: rawTarget, message: emptyMessage };
-	const resolved = resolveRunId(target);
+	const resolved = resolveRunId(target, activeStore);
 	if (resolved.kind === "exact") return { kind: "run", runId: resolved.runId };
 	if (resolved.kind === "malformed") return { kind: "malformed", target, message: resolved.message };
 	return { kind: "not_found", target, message: `Run not found: ${target}` };
@@ -113,10 +117,10 @@ export function resolveToolRunTarget(args: WorkflowToolArgs, emptyMessage: strin
 
 export type ToolStageTarget = { ok: true; runId?: string; stageId?: string } | { ok: false; message: string };
 
-export function resolveStageTarget(runId: string, stageTarget?: string): ToolStageTarget {
+export function resolveStageTarget(runId: string, stageTarget?: string, activeStore: Store = store): ToolStageTarget {
 	const target = stageTarget?.trim();
 	if (!target) return { ok: true, runId };
-	const graph = expandWorkflowGraph(readGraphStoreSnapshot(store), runId);
+	const graph = expandWorkflowGraph(readGraphStoreSnapshot(activeStore), runId);
 	const exactVirtualIds = graph.stages.filter((stage) => stage.id === target);
 	if (exactVirtualIds.length === 1) return resolvedStageTarget(exactVirtualIds[0]!);
 	if (exactVirtualIds.length > 1) return ambiguousStageTarget(target, exactVirtualIds);
@@ -147,8 +151,12 @@ function ambiguousStageTarget(target: string, stages: readonly ExpandedWorkflowS
 	};
 }
 
-export function resolveToolStageTarget(runId: string, stageTarget?: string): ToolStageTarget {
-	return resolveStageTarget(runId, stageTarget);
+export function resolveToolStageTarget(
+	runId: string,
+	stageTarget?: string,
+	activeStore: Store = store,
+): ToolStageTarget {
+	return resolveStageTarget(runId, stageTarget, activeStore);
 }
 
 /**

package/dist/builtin/workflows/src/extension/workflow-tool-inspection.ts

@@ -1,5 +1,7 @@
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
-import { store } from "../shared/store.js";
+import { expandWorkflowGraph } from "../shared/expanded-workflow-graph.js";
+import { type Store, store } from "../shared/store.js";
+import { readGraphStoreSnapshot } from "../shared/store-observation.js";
 import type { WorkflowToolArgs } from "./public-types.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import {
@@ -14,8 +16,14 @@ import {
 } from "./workflow-stage-results.js";
 import { resolveToolRunTarget, resolveToolStageTarget } from "./workflow-targets.js";
 
-export function workflowStagesResult(args: WorkflowToolArgs): WorkflowToolResult {
-	const target = resolveToolRunTarget(args, "No active run to inspect.");
+export interface WorkflowInspectionSource {
+	readonly store?: Store;
+	readonly allowLiveHandles?: boolean;
+}
+
+export function workflowStagesResult(args: WorkflowToolArgs, source?: WorkflowInspectionSource): WorkflowToolResult {
+	const activeStore = source?.store ?? store;
+	const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
 	const filter = args.statusFilter ?? "all";
 	if (target.kind === "all") {
 		return {
@@ -35,22 +43,24 @@ export function workflowStagesResult(args: WorkflowToolArgs): WorkflowToolResult
 			error: target.message,
 		};
 	}
-	const run = store.runs().find((r) => r.id === target.runId);
-	const stages = (run?.stages ?? [])
-		.filter((stage) => filter === "all" || stage.status === filter)
-		.map(summarizeStage);
+	const stageSnapshots =
+		source?.store === undefined
+			? (activeStore.runs().find((run) => run.id === target.runId)?.stages ?? [])
+			: expandWorkflowGraph(readGraphStoreSnapshot(activeStore), target.runId).stages;
+	const stages = stageSnapshots.filter((stage) => filter === "all" || stage.status === filter).map(summarizeStage);
 	return { action: "stages", runId: target.runId, filter, stages };
 }
 
-export function workflowStageResult(args: WorkflowToolArgs): WorkflowToolResult {
-	const target = resolveToolRunTarget(args, "No active run to inspect.");
+export function workflowStageResult(args: WorkflowToolArgs, source?: WorkflowInspectionSource): WorkflowToolResult {
+	const activeStore = source?.store ?? store;
+	const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
 	if (target.kind === "all") {
 		return { action: "stage", runId: "--all", error: "Stage inspection requires a single run." };
 	}
 	if (target.kind === "malformed" || target.kind === "not_found") {
 		return { action: "stage", runId: target.target, error: target.message };
 	}
-	const stage = resolveToolStageTarget(target.runId, args.stageId);
+	const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
 	if (!stage.ok || stage.stageId === undefined) {
 		return {
 			action: "stage",
@@ -59,7 +69,7 @@ export function workflowStageResult(args: WorkflowToolArgs): WorkflowToolResult
 		};
 	}
 	const stageRunId = stage.runId ?? target.runId;
-	const run = store.runs().find((r) => r.id === stageRunId);
+	const run = activeStore.runs().find((r) => r.id === stageRunId);
 	const snapshot = run?.stages.find((s) => s.id === stage.stageId);
 	return snapshot
 		? { action: "stage", runId: stageRunId, stage: cloneStage(snapshot) }
@@ -70,8 +80,12 @@ export function workflowStageResult(args: WorkflowToolArgs): WorkflowToolResult
 			};
 }
 
-export function workflowTranscriptResult(args: WorkflowToolArgs): WorkflowToolResult {
-	const target = resolveToolRunTarget(args, "No active run to inspect.");
+export function workflowTranscriptResult(
+	args: WorkflowToolArgs,
+	source?: WorkflowInspectionSource,
+): WorkflowToolResult {
+	const activeStore = source?.store ?? store;
+	const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
 	if (target.kind === "all") {
 		return {
 			action: "transcript",
@@ -92,7 +106,7 @@ export function workflowTranscriptResult(args: WorkflowToolArgs): WorkflowToolRe
 			truncated: false,
 		};
 	}
-	const stage = resolveToolStageTarget(target.runId, args.stageId);
+	const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
 	if (!stage.ok || stage.stageId === undefined) {
 		return {
 			action: "transcript",
@@ -104,9 +118,10 @@ export function workflowTranscriptResult(args: WorkflowToolArgs): WorkflowToolRe
 		};
 	}
 	const stageRunId = stage.runId ?? target.runId;
-	const run = store.runs().find((r) => r.id === stageRunId);
+	const run = activeStore.runs().find((r) => r.id === stageRunId);
 	const snapshot = run?.stages.find((s) => s.id === stage.stageId);
-	const liveHandle = stageControlRegistry.get(stageRunId, stage.stageId);
+	const liveHandle =
+		source?.allowLiveHandles === false ? undefined : stageControlRegistry.get(stageRunId, stage.stageId);
 	if (liveHandle !== undefined) {
 		const sessionFile = liveHandle.sessionFile ?? snapshot?.sessionFile;
 		const sessionId = liveHandle.sessionId ?? snapshot?.sessionId;

package/dist/builtin/workflows/src/extension/workflow-tool-send.ts

@@ -5,15 +5,20 @@ import {
 import type { DetachedStageHandleLease, StageControlHandle } from "../runs/foreground/stage-control-registry.js";
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import type { StageUserMessageDeliveryAction } from "../runs/foreground/stage-runner-types.js";
+import {
+	type ExpandedWorkflowStage,
+	expandedStageLabel,
+	expandWorkflowGraph,
+} from "../shared/expanded-workflow-graph.js";
 import { coerceStageInputAnswer, hasStageInputAnswerContent, type StageInputAnswer } from "../shared/stage-prompt.js";
 import { stageUiBroker } from "../shared/stage-ui-broker.js";
 import { store } from "../shared/store.js";
 import { isTerminalRunStatus } from "../shared/store-internal.js";
-import { subscribeStoreInvalidation } from "../shared/store-observation.js";
+import { readGraphStoreSnapshot, subscribeStoreInvalidation } from "../shared/store-observation.js";
 import { reciprocalWorkflowRootRunId } from "../shared/workflow-run-ownership.js";
 import type { WorkflowToolArgs } from "./public-types.js";
 import type { WorkflowToolResult } from "./render-result.js";
-import { resolveToolRunTarget, resolveToolStageTarget } from "./workflow-targets.js";
+import { resolveToolRunTarget, resolveToolStageTarget, type ToolStageTarget } from "./workflow-targets.js";
 
 /**
  * Optional dependencies enabling `workflow send` to revive an eligible
@@ -49,6 +54,69 @@ function brokerAnswerFromArgs(args: WorkflowToolArgs): StageInputAnswer {
 	return text !== undefined ? { text } : {};
 }
 
+/**
+ * Whether this delivery is one whose destination a pending prompt determines.
+ *
+ * `answer` and `auto` are both documented as answering pending prompts first,
+ * and an explicit `promptId` names a prompt without naming its stage. Steering
+ * deliveries are excluded: a live stage is a destination in its own right, so
+ * there is nothing for a prompt to disambiguate.
+ */
+function answersPendingPrompt(delivery: string, promptId: string | undefined): boolean {
+	return delivery === "answer" || delivery === "auto" || promptId !== undefined;
+}
+
+/**
+ * Ids of the prompts an `answer` delivery could resolve on this stage.
+ *
+ * Covers the same three prompt kinds the delivery path dispatches on —
+ * brokered, custom-footprint, and plain pending prompts — so a stage counted
+ * here is one the send would actually act on rather than merely mention.
+ */
+function answerablePromptIds(stage: ExpandedWorkflowStage): string[] {
+	const target = stage.workflowGraphTarget;
+	const ids: string[] = [];
+	const brokered = stageUiBroker.peekStagePrompt(target.runId, target.stageId);
+	if (brokered !== undefined) ids.push(brokered.id);
+	if (stage.pendingPrompt !== undefined) ids.push(stage.pendingPrompt.id);
+	if (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom") {
+		ids.push(stage.promptFootprint.id);
+	}
+	return ids;
+}
+
+/**
+ * Resolve the stage an answer is for when the caller named a prompt but no stage.
+ *
+ * A named `promptId` already identifies its stage, so it narrows the candidates
+ * before uniqueness is decided — otherwise naming one of two pending prompts
+ * would be rejected as ambiguous, and naming an unknown one would target the
+ * unrelated stage that happened to be the only one waiting.
+ *
+ * Returns the target unchanged when nothing is pending, so a run with no prompt
+ * still reports that a stage is required rather than inventing a destination.
+ */
+function inferPromptStageTarget(runId: string, delivery: string, promptId: string | undefined): ToolStageTarget {
+	if (!answersPendingPrompt(delivery, promptId)) return { ok: true, runId };
+	const pending = expandWorkflowGraph(readGraphStoreSnapshot(store), runId).stages.filter((stage) => {
+		const ids = answerablePromptIds(stage);
+		return promptId === undefined ? ids.length > 0 : ids.includes(promptId);
+	});
+	const only = pending[0];
+	if (pending.length === 1 && only !== undefined) {
+		return { ok: true, runId: only.workflowGraphTarget.runId, stageId: only.workflowGraphTarget.stageId };
+	}
+	if (pending.length === 0) {
+		return promptId === undefined
+			? { ok: true, runId }
+			: { ok: false, message: `No pending prompt ${promptId} in run ${runId}.` };
+	}
+	return {
+		ok: false,
+		message: `${pending.length} prompts pending; pass stageId: ${pending.map(expandedStageLabel).join(", ")}`,
+	};
+}
+
 type WorkflowSendToolResult = Extract<WorkflowToolResult, { action: "send" }>;
 
 function workflowSendResult(
@@ -131,7 +199,11 @@ export async function workflowSendAction(
 	if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
 		return terminalWorkflowSendResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
 	}
-	const stage = resolveToolStageTarget(target.runId, args.stageId);
+	const requested = resolveToolStageTarget(target.runId, args.stageId);
+	const stage =
+		requested.ok && requested.stageId === undefined
+			? inferPromptStageTarget(target.runId, requestedDelivery, args.promptId)
+			: requested;
 	if (!stage.ok || stage.stageId === undefined) {
 		return workflowSendResult(
 			target.runId,

package/dist/builtin/workflows/src/extension/workflow-tool.ts

@@ -18,9 +18,49 @@ import {
 	workflowReloadAction,
 	workflowResumeAction,
 } from "./workflow-tool-control.js";
-import { workflowStageResult, workflowStagesResult, workflowTranscriptResult } from "./workflow-tool-inspection.js";
+import {
+	type WorkflowInspectionSource,
+	workflowStageResult,
+	workflowStagesResult,
+	workflowTranscriptResult,
+} from "./workflow-tool-inspection.js";
 import { type WorkflowSendDeps, workflowSendAction } from "./workflow-tool-send.js";
 
+type DurableInspectionSourceResolution =
+	| { readonly kind: "local" }
+	| { readonly kind: "durable"; readonly source: WorkflowInspectionSource }
+	| { readonly kind: "error"; readonly message: string };
+
+async function resolveDurableInspectionSource(
+	args: WorkflowToolArgs,
+	runtime: ExtensionRuntime,
+): Promise<DurableInspectionSourceResolution> {
+	const target = args.runId?.trim();
+	if (args.all === true || target === undefined || target.length === 0 || target === "--all") return { kind: "local" };
+	const local = resolveRunId(target);
+	if (local.kind !== "not_found") return { kind: "local" };
+	const durable = await runtime.inspectDurableWorkflow(target);
+	if (durable.kind !== "found") return { kind: "error", message: durable.message };
+	return { kind: "durable", source: { store: durable.store, allowLiveHandles: false } };
+}
+
+function durableInspectionError(
+	action: "stages" | "stage" | "transcript",
+	runId: string,
+	message: string,
+): WorkflowToolResult {
+	if (action === "stages") return { action, runId, filter: "all", stages: [], error: message };
+	if (action === "stage") return { action, runId, error: message };
+	return {
+		action,
+		runId,
+		stageId: "",
+		source: "error",
+		entries: [{ role: "notice", text: message }],
+		truncated: false,
+	};
+}
+
 export function makeExecuteWorkflowTool(
 	runtime: ExtensionRuntime | ((ctx: PiExecuteContext) => ExtensionRuntime),
 	reloadWorkflowResources: () => Promise<WorkflowReloadReport | undefined> | undefined,
@@ -87,7 +127,10 @@ export function makeExecuteWorkflowTool(
 						return { action: "statusDetail", runId: target, error: resolved.message };
 					}
 					if (resolved.kind === "not_found") {
-						return { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+						const durable = await getRuntime().inspectDurableWorkflow(target);
+						return durable.kind === "found"
+							? { action: "statusDetail", runId: target, detail: durable.detail }
+							: { action: "statusDetail", runId: target, error: durable.message };
 					}
 					const result = inspectRun(resolved.runId);
 					return result.ok
@@ -105,11 +148,15 @@ export function makeExecuteWorkflowTool(
 				return result;
 			}
 			case "stages":
-				return workflowStagesResult(args);
 			case "stage":
-				return workflowStageResult(args);
-			case "transcript":
-				return workflowTranscriptResult(args);
+			case "transcript": {
+				const resolved = await resolveDurableInspectionSource(args, getRuntime());
+				if (resolved.kind === "error") return durableInspectionError(action, args.runId ?? "", resolved.message);
+				const source = resolved.kind === "durable" ? resolved.source : undefined;
+				if (action === "stages") return workflowStagesResult(args, source);
+				if (action === "stage") return workflowStageResult(args, source);
+				return workflowTranscriptResult(args, source);
+			}
 			case "send":
 				return workflowSendAction(args, sendDeps);
 			case "pause":

package/dist/builtin/workflows/src/runs/background/run-inspect.ts

@@ -28,7 +28,7 @@ import type { WorkflowInputValues, WorkflowOutputValues } from "../../shared/typ
 export interface RunDetail {
 	readonly runId: string;
 	readonly name: string;
-	readonly status: RunStatus;
+	readonly status: RunStatus | "crashed";
 	readonly mode: "single" | "chain";
 	readonly startedAt: number;
 	readonly endedAt?: number;
@@ -54,6 +54,10 @@ export interface RunDetail {
 	readonly failedToolNodeId?: string;
 	readonly resumable?: boolean;
 	readonly retryAfterMs?: number;
+	/** Actionable guidance for a snapshot hydrated from durable storage. */
+	readonly resumeGuidance?: string;
+	/** True when a fresh durable owner is active in another Atomic process. */
+	readonly ownerActiveElsewhere?: boolean;
 	readonly blockedAt?: number;
 }
 

package/dist/builtin/workflows/src/runs/foreground/executor-stage-call.ts

@@ -107,7 +107,9 @@ export function createTrackedStageCaller(input: {
 			const suppressQueuedContinuation = reason === "paused-queued-user-message";
 			if (suppressQueuedContinuation) runtime.state.suppressQueuedUserMessageContinuation = true;
 			try {
-				result = (await raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal)) as T;
+				result = (await runtime.raceStageSessionHeartbeat(
+					raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal),
+				)) as T;
 			} finally {
 				if (suppressQueuedContinuation) runtime.state.suppressQueuedUserMessageContinuation = false;
 			}
@@ -134,61 +136,69 @@ export function createTrackedStageCaller(input: {
 		}
 
 		const trackStageLifecycle = !runtime.state.stageFinalized;
-		let refreshedParentIds: readonly string[] | undefined;
-		if (
-			trackStageLifecycle &&
-			!input.hasContinuation &&
-			runtime.stageSnapshot.startedAt === undefined &&
-			!input.hasScopedParents
-		) {
-			const actualParentIds = runtime.scheduler.tracker.currentParents();
-			const sameParents =
-				actualParentIds.length === runtime.stageSnapshot.parentIds.length &&
-				actualParentIds.every((value) => runtime.stageSnapshot.parentIds.includes(value));
-			if (!sameParents) {
-				runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
-				refreshedParentIds = actualParentIds;
-			}
-		}
-		if (trackStageLifecycle) {
-			const now = Date.now();
-			const hasNoExplicitModelConfig =
-				input.options?.model === undefined && input.options?.fallbackModels === undefined;
-			const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
+		let applyTerminalStageState: (() => void) | undefined;
+		// Set only alongside the successful "completed" terminal state, so a failed
+		// final durable checkpoint can replace it without touching a real
+		// failure/skip classification recorded by the catch block.
+		let terminalStateIsSuccess = false;
+		try {
+			let refreshedParentIds: readonly string[] | undefined;
 			if (
-				callOptions.eagerSession &&
-				!promptAdapterHandlesInitialPrompt &&
-				(hasNoExplicitModelConfig ||
-					(await hasExplicitFastModeCandidate({
-						model: input.options?.model,
-						fallbackModels: input.options?.fallbackModels,
-						models: runtime.opts.models,
-					})))
+				trackStageLifecycle &&
+				!input.hasContinuation &&
+				runtime.stageSnapshot.startedAt === undefined &&
+				!input.hasScopedParents
 			) {
-				try {
-					await runtime.innerCtx.__ensureSession();
-					runtime.captureStageSessionMeta();
-				} catch (err) {
-					if (!(err instanceof Error && err.message.includes("prompt adapter not configured"))) throw err;
+				const actualParentIds = runtime.scheduler.tracker.currentParents();
+				const sameParents =
+					actualParentIds.length === runtime.stageSnapshot.parentIds.length &&
+					actualParentIds.every((value) => runtime.stageSnapshot.parentIds.includes(value));
+				if (!sameParents) {
+					runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
+					refreshedParentIds = actualParentIds;
 				}
 			}
-			if (refreshedParentIds !== undefined) {
-				runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+			if (trackStageLifecycle) {
+				const now = Date.now();
+				const hasNoExplicitModelConfig =
+					input.options?.model === undefined && input.options?.fallbackModels === undefined;
+				const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
+				if (
+					callOptions.eagerSession &&
+					!promptAdapterHandlesInitialPrompt &&
+					(hasNoExplicitModelConfig ||
+						(await hasExplicitFastModeCandidate({
+							model: input.options?.model,
+							fallbackModels: input.options?.fallbackModels,
+							models: runtime.opts.models,
+						})))
+				) {
+					try {
+						await runtime.innerCtx.__ensureSession();
+					} catch (err) {
+						if (!(err instanceof Error && err.message.includes("prompt adapter not configured"))) throw err;
+					}
+				}
+				if (refreshedParentIds !== undefined) {
+					runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+				}
+				runtime.stageSnapshot.status = "running";
+				runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
+				runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
+				// Publish every graph-visible live write before this task can yield.
+				runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
+				runtime.appendStageStartOnce();
+				const sessionMeta = runtime.innerCtx.__sessionMeta();
+				if (sessionMeta.sessionId !== undefined || sessionMeta.sessionFile !== undefined) {
+					await runtime.captureStageSessionMeta({ awaitDurable: true });
+				}
+				runtime.startStageSessionHeartbeat();
+			} else {
+				runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
 			}
-			runtime.stageSnapshot.status = "running";
-			runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
-			runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-			// Publish every graph-visible live write before this task can yield.
-			runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
-			runtime.appendStageStartOnce();
-		} else {
-			runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-		}
 
-		runtime.mcpScope.apply();
+			runtime.mcpScope.apply();
 
-		let applyTerminalStageState: (() => void) | undefined;
-		try {
 			const abortSession = (): void => {
 				void runtime.innerCtx.abort().catch(() => {});
 			};
@@ -198,7 +208,7 @@ export function createTrackedStageCaller(input: {
 			try {
 				runtime.state.askUserQuestionObservedThisTurn = false;
 				runtime.state.chatAnswerObservedThisTurn = false;
-				result = await raceAbort(call(), runtime.signal);
+				result = await runtime.raceStageSessionHeartbeat(raceAbort(call(), runtime.signal));
 				const initialDrain = await drainResumeContinuations(result);
 				result = initialDrain.result;
 				let repeatReadinessAfterChatTurn = initialDrain.chatAnswerObserved;
@@ -226,12 +236,14 @@ export function createTrackedStageCaller(input: {
 							runtime.state.chatAnswerObservedThisTurn = false;
 							runtime.state.waitingForStageChatTurn = true;
 							try {
-								await raceAbort(
-									new Promise<void>((resolve) => {
-										resolveNextTurnEnd = resolve;
-										runtime.state.wakeWaitingForStageChatTurn = resolve;
-									}),
-									runtime.signal,
+								await runtime.raceStageSessionHeartbeat(
+									raceAbort(
+										new Promise<void>((resolve) => {
+											resolveNextTurnEnd = resolve;
+											runtime.state.wakeWaitingForStageChatTurn = resolve;
+										}),
+										runtime.signal,
+									),
 								);
 							} finally {
 								runtime.state.wakeWaitingForStageChatTurn = undefined;
@@ -254,7 +266,7 @@ export function createTrackedStageCaller(input: {
 				runtime.signal.removeEventListener("abort", abortSession);
 			}
 			await runtime.innerCtx.__closeGeneration();
-			runtime.captureStageSessionMeta();
+			await runtime.captureStageSessionMeta({ awaitDurable: true });
 			runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
 			if (
 				trackStageLifecycle &&
@@ -267,6 +279,7 @@ export function createTrackedStageCaller(input: {
 			if (trackStageLifecycle && runtime.state.stageFinalized) throw runtime.parallelFailFastError();
 			if (trackStageLifecycle) {
 				const assistantText = runtime.innerCtx.__getLastAssistantText();
+				terminalStateIsSuccess = true;
 				applyTerminalStageState = () => {
 					runtime.stageSnapshot.status = "completed";
 					if (assistantText !== undefined) runtime.stageSnapshot.result = assistantText;
@@ -294,15 +307,36 @@ export function createTrackedStageCaller(input: {
 			// If finalizeStageSnapshot() throws, the limiter must still be released
 			// so the concurrency semaphore is not leaked.
 			// cross-ref: issue #1498 — durable finalization failures must not leak the stage limiter.
-			runtime.mcpScope.clear();
 			let finalizationError: { readonly thrown: true; readonly error: unknown } | undefined;
+			// Tracked separately from `finalizationError`: only a failed final durable
+			// checkpoint may rewrite an otherwise-successful terminal stage state.
+			let durableCheckpointError: { readonly thrown: true; readonly error: unknown } | undefined;
 			try {
-				await runtime.innerCtx.__closeGeneration();
-				runtime.captureStageSessionMeta();
+				runtime.mcpScope.clear();
 			} catch (err) {
 				finalizationError = { thrown: true, error: err };
 			}
+			try {
+				// Drain rather than stop: a checkpoint still in flight must be awaited
+				// here, or its late rejection is discarded with the cancelled timer.
+				await runtime.drainStageSessionHeartbeat();
+			} catch (err) {
+				durableCheckpointError = { thrown: true, error: err };
+			}
+			try {
+				await runtime.innerCtx.__closeGeneration();
+				await runtime.captureStageSessionMeta({ awaitDurable: true });
+			} catch (err) {
+				durableCheckpointError ??= { thrown: true, error: err };
+			}
+			finalizationError ??= durableCheckpointError;
 			if (trackStageLifecycle) {
+				// A stage whose final durability checkpoint failed must never be
+				// persisted as `completed` while its caller receives that rejection.
+				if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
+					const failure = runtime.classifyExecutorFailure(durableCheckpointError.error);
+					applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
+				}
 				if (!runtime.state.stageFinalized) applyTerminalStageState?.();
 				// `finalizeStageSnapshot` calls the version-bumping `recordStageEnd`
 				// before its first yield, so the live write cannot outpace the cache.

package/dist/builtin/workflows/src/runs/foreground/executor-stage-context.ts

@@ -52,7 +52,7 @@ export function createStageContext(input: {
 			try {
 				runtime.mcpScope.clear();
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 				runtime.applyModelFallbackMeta(innerCtx.__modelFallbackMeta());
 			}
 		}