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

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());
 			}
 		}

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

@@ -28,7 +28,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 		const sessionFile = messagePreparation().sessionFile;
 		if (sessionFile === undefined) return;
 		await runtime.innerCtx.__ensureSessionFromFile(sessionFile);
-		runtime.captureStageSessionMeta();
+		await runtime.captureStageSessionMeta({ awaitDurable: true });
 	};
 	const toolExecutions = new StageToolExecutionBuffer();
 	const queuedUserMessages = new StageQueuedUserMessageBuffer();
@@ -75,7 +75,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 			await ensureMessagingSession();
 			await runtime.innerCtx.__ensureSession();
 			runtime.throwIfStageMutationBlocked();
-			runtime.captureStageSessionMeta();
+			await runtime.captureStageSessionMeta({ awaitDurable: true });
 		},
 		async sendUserMessage(text, options, beforeDelivery) {
 			runtime.throwIfStageMutationBlocked();
@@ -91,7 +91,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 				}
 				return action;
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 			}
 		},
 		async prompt(text: string) {
@@ -106,7 +106,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 					preparation,
 				);
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 			}
 			if (action !== "handled") runtime.throwIfStageMutationBlocked();
 		},
@@ -124,7 +124,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 				await runtime.innerCtx.steer(text);
 				if (queuedIntoInFlightTurn) runtime.state.resumeContinuationPending = "queued-user-message";
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 			}
 		},
 		async followUp(text: string) {
@@ -137,7 +137,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 				await runtime.innerCtx.followUp(text);
 				if (queuedIntoInFlightTurn) runtime.state.resumeContinuationPending = "queued-user-message";
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 			}
 		},
 		async pause() {
@@ -206,7 +206,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 				}
 				throw err;
 			} finally {
-				runtime.captureStageSessionMeta();
+				void runtime.captureStageSessionMeta();
 			}
 		},
 		subscribe(listener: AgentSessionEventListener) {

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

@@ -40,6 +40,7 @@ import {
 	type InternalStageContext,
 	type StageAdapters,
 } from "./stage-runner.js";
+import { createStageSessionHeartbeat } from "./stage-session-heartbeat.js";
 
 export function createWorkflowStageFactory(input: {
 	readonly runId: string;
@@ -151,6 +152,15 @@ export function createWorkflowStageFactory(input: {
 			if (meta.modelAttempts !== undefined) stageSnapshot.modelAttempts = meta.modelAttempts;
 		};
 
+		let runtime!: LiveStageRuntime;
+		const stageSessionHeartbeat = createStageSessionHeartbeat(async () => {
+			try {
+				await runtime.captureStageSessionMeta({ awaitDurable: true });
+			} catch (error) {
+				await runtime.innerCtx.abort().catch(() => {});
+				throw error;
+			}
+		});
 		const innerCtx = createInnerStageContext({
 			stageId,
 			stageName: name,
@@ -166,6 +176,11 @@ export function createWorkflowStageFactory(input: {
 				applyModelFallbackMeta(meta);
 				if (stageSnapshot.status === "running") input.activeStore.recordStageStart(input.runId, stageSnapshot);
 			},
+			async onSessionReady() {
+				if (stageSnapshot.status !== "running") return;
+				await runtime.captureStageSessionMeta({ awaitDurable: true });
+				runtime.startStageSessionHeartbeat();
+			},
 		});
 
 		const state: LiveStageMutableState = {
@@ -234,21 +249,23 @@ export function createWorkflowStageFactory(input: {
 			await innerCtx.__dispose();
 		};
 
-		let runtime: LiveStageRuntime;
-		const captureStageSessionMeta = (checkpointOptions?: StageSessionCheckpointOptions): unknown => {
+		const captureStageSessionMeta = async (checkpointOptions?: StageSessionCheckpointOptions): Promise<void> => {
 			const meta = innerCtx.__sessionMeta();
 			if (meta.sessionId !== undefined) stageSnapshot.sessionId = meta.sessionId;
 			if (meta.sessionFile !== undefined) stageSnapshot.sessionFile = meta.sessionFile;
 			if (meta.sessionId !== undefined || meta.sessionFile !== undefined)
 				input.activeStore.recordStageSession(input.runId, stageId, meta);
 			const pending = input.opts.onStageSession?.(input.runId, stageSnapshot, checkpointOptions);
-			if (checkpointOptions?.forceDurable === true) return pending;
+			if (checkpointOptions?.forceDurable === true || checkpointOptions?.awaitDurable === true) {
+				await pending;
+				return;
+			}
 			void Promise.resolve(pending).catch(() => {});
-			return undefined;
 		};
 		const releaseLiveHandle = async (): Promise<void> => {
 			if (state.liveHandleReleased) return;
 			state.liveHandleReleased = true;
+			stageSessionHeartbeat.stop();
 			runtime.dropStageControlHandle();
 			runtime.unregisterStageHandle();
 			await disposeInnerContext();
@@ -282,6 +299,7 @@ export function createWorkflowStageFactory(input: {
 		};
 
 		const finalizeStageSnapshot = async (): Promise<boolean> => {
+			stageSessionHeartbeat.stop();
 			if (state.stageFinalized) return false;
 			if (stageSnapshot.endedAt !== undefined && isTerminalStage(stageSnapshot)) {
 				state.stageFinalized = true;
@@ -371,6 +389,9 @@ export function createWorkflowStageFactory(input: {
 			dropStageControlHandle: () => {},
 			unregisterWorkflowExitCleanup: () => {},
 			captureStageSessionMeta,
+			startStageSessionHeartbeat: stageSessionHeartbeat.start,
+			drainStageSessionHeartbeat: stageSessionHeartbeat.drain,
+			raceStageSessionHeartbeat: stageSessionHeartbeat.race,
 			applyModelFallbackMeta,
 			appendStageStartOnce,
 			finalizeStageSnapshot,

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

@@ -51,7 +51,10 @@ export interface LiveStageRuntime {
 	unregisterStageHandle: () => void;
 	dropStageControlHandle: () => void;
 	unregisterWorkflowExitCleanup: () => void;
-	readonly captureStageSessionMeta: (options?: StageSessionCheckpointOptions) => unknown;
+	readonly captureStageSessionMeta: (options?: StageSessionCheckpointOptions) => Promise<void>;
+	readonly startStageSessionHeartbeat: () => void;
+	readonly drainStageSessionHeartbeat: () => Promise<void>;
+	readonly raceStageSessionHeartbeat: <T>(work: Promise<T>) => Promise<T>;
 	readonly applyModelFallbackMeta: (meta: ReturnType<InternalStageContext["__modelFallbackMeta"]>) => void;
 	readonly appendStageStartOnce: () => void;
 	readonly finalizeStageSnapshot: () => Promise<boolean>;

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

@@ -34,6 +34,8 @@ export interface RunContinuationOpts {
 
 export interface StageSessionCheckpointOptions {
 	readonly forceDurable?: boolean;
+	/** Await and surface the persistence result without bypassing duration bucketing. */
+	readonly awaitDurable?: boolean;
 }
 export interface RunOpts
 	extends Omit<

package/dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts

@@ -14,6 +14,7 @@ import type {
 	StageUserMessageContent,
 	WorkflowModelAttempt,
 	WorkflowModelCatalogPort,
+	WorkflowModelUsage,
 } from "../../shared/types.js";
 import {
 	buildModelCandidatesFromCatalog,
@@ -67,6 +68,58 @@ import {
 
 type RetryPauseResume = NonNullable<ReturnType<StageSessionPause["currentResume"]>>;
 
+type StageMessage = StageSessionRuntime["messages"][number];
+type StageAssistantMessage = Extract<StageMessage, { role: "assistant" }>;
+
+type AttemptUsageTotals = {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	turns: number;
+};
+
+/**
+ * A present usage object is meaningful when any token bucket, the total token
+ * count, or the provider-reported total cost is positive. Reject the entire
+ * provider record when any aggregated value is non-finite or negative so
+ * malformed telemetry cannot poison a durable stage checkpoint.
+ */
+function hasMeaningfulUsage(usage: StageAssistantMessage["usage"] | undefined): boolean {
+	if (usage === undefined) return false;
+	const values = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.totalTokens, usage.cost.total];
+	return values.every((value) => Number.isFinite(value) && value >= 0) && values.some((value) => value > 0);
+}
+
+/**
+ * Aggregate the assistant-message usage admitted since the latched attempt
+ * boundary, plus usage accrued from error assistants that a retry restoration
+ * removed from the live transcript. Returns undefined when nothing meaningful
+ * was seen, so no `usage: undefined` enters the serializable attempt record.
+ */
+function usageForAttempt(
+	messages: readonly StageMessage[],
+	start: number,
+	discarded: AttemptUsageTotals,
+): WorkflowModelUsage | undefined {
+	const totals = { ...discarded };
+	let meaningful = totals.turns > 0;
+
+	for (const message of messages.slice(start)) {
+		if (message.role !== "assistant" || !hasMeaningfulUsage(message.usage)) continue;
+		totals.input += message.usage.input;
+		totals.output += message.usage.output;
+		totals.cacheRead += message.usage.cacheRead;
+		totals.cacheWrite += message.usage.cacheWrite;
+		totals.cost += message.usage.cost.total;
+		totals.turns += 1;
+		meaningful = true;
+	}
+
+	return meaningful ? totals : undefined;
+}
+
 interface ThrownErrorRetryState {
 	readonly controller: AbortController;
 	pauseResume?: RetryPauseResume;
@@ -159,6 +212,17 @@ export class StageSessionController {
 	private sessionPromise: Promise<StageSessionRuntime> | undefined;
 	private reattachSessionFile: string | undefined;
 	private lastPromptStartIndex: number | undefined;
+	/** Message index latched once per high-level candidate prompt; never re-read later. */
+	private attemptUsageStartIndex: number | undefined;
+	/** Usage accrued from error assistants removed by retry restoration. */
+	private discardedAttemptUsage: AttemptUsageTotals = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		cost: 0,
+		turns: 0,
+	};
 	private readonly terminatingToolCallIds = new Set<string>();
 	private latestStructuredOutputToolErrorValue: string | undefined;
 	private unsubscribeTerminateWatcher: (() => void) | undefined;
@@ -418,6 +482,7 @@ export class StageSessionController {
 				this.activeCandidateIndex = index;
 				this.selectedModel = candidate.id;
 				this.notifyModelFallbackMetaChange();
+				this.beginAttemptUsage(activeSession);
 				const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(
 					activeSession,
 					promptText,
@@ -563,6 +628,49 @@ export class StageSessionController {
 		}
 		return undefined;
 	}
+	/**
+	 * Latch a fresh high-level usage window against the active session. The
+	 * boundary is the message length before the candidate prompt, so retries,
+	 * pause/re-prompts, and recording never re-read a later index.
+	 */
+	private beginAttemptUsage(session: StageSessionRuntime): void {
+		this.attemptUsageStartIndex = session.messages.length;
+		this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+	}
+
+	/**
+	 * Consume the current window exactly once. A session-creation failure has no
+	 * window: clear the latch instead of reading a previous session's messages.
+	 */
+	private takeAttemptUsage(session: StageSessionRuntime | undefined): WorkflowModelUsage | undefined {
+		const start = this.attemptUsageStartIndex;
+		const usage =
+			session === undefined || start === undefined
+				? undefined
+				: usageForAttempt(session.messages, start, this.discardedAttemptUsage);
+		this.clearAttemptUsage();
+		return usage;
+	}
+
+	private clearAttemptUsage(): void {
+		this.attemptUsageStartIndex = undefined;
+		this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+	}
+
+	/**
+	 * Keep the usage of an error assistant that a retry restoration is about to
+	 * remove from the live transcript, so the final attempt total still counts it.
+	 */
+	private accrueDiscardedAttemptUsage(message: StageAssistantMessage): void {
+		if (!hasMeaningfulUsage(message.usage)) return;
+		this.discardedAttemptUsage.input += message.usage.input;
+		this.discardedAttemptUsage.output += message.usage.output;
+		this.discardedAttemptUsage.cacheRead += message.usage.cacheRead;
+		this.discardedAttemptUsage.cacheWrite += message.usage.cacheWrite;
+		this.discardedAttemptUsage.cost += message.usage.cost.total;
+		this.discardedAttemptUsage.turns += 1;
+	}
+
 	/**
 	 * Drop this attempt's failed input from live state before a same-candidate
 	 * retry, keeping unrelated concurrent messages. The durable transcript keeps
@@ -581,6 +689,12 @@ export class StageSessionController {
 	): StageSessionRuntime["messages"][number] | undefined {
 		const snapshotMessages = new Set(snapshot);
 		const admitted = session.messages.filter((message) => !snapshotMessages.has(message));
+		// Error assistants the filter below removes still carry real provider
+		// usage; accrue it before the splice so the retry total keeps it.
+		for (const message of admitted) {
+			if (message.role !== "assistant" || message.stopReason !== "error") continue;
+			this.accrueDiscardedAttemptUsage(message);
+		}
 		const failedAssistantIndex = admitted.findLastIndex(
 			(message) => message.role === "assistant" && message.stopReason === "error",
 		);
@@ -1054,9 +1168,12 @@ export class StageSessionController {
 				throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
 			throw this.staleCreationReason(startGeneration);
 		}
-		return attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) =>
+		const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) =>
 			this.attachSession(result),
 		);
+		if (session instanceof Promise) return await session;
+		await this.opts.onSessionReady?.();
+		return session;
 	}
 
 	private attachSession(created: StageSessionRuntime | StageSessionCreateResult): StageSessionRuntime {
@@ -1175,11 +1292,17 @@ export class StageSessionController {
 		const resumedSession = this.session;
 		const resumedLabel = this.selectedModel ?? workflowModelId(resumedSession.model) ?? candidates[0]!.id;
 		this.notifyModelFallbackMetaChange();
+		this.beginAttemptUsage(resumedSession);
 		try {
 			const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(resumedSession, text, sdkOptions);
 			const terminalFailure = latestTerminalAssistantFailureSince(resumedSession.messages, terminalScanStartIndex);
 			if (terminalFailure === undefined || this.capturedStructuredOutputForAttempt()) {
-				this.modelAttempts.push({ model: resumedLabel, success: true });
+				const usage = this.takeAttemptUsage(resumedSession);
+				this.modelAttempts.push({
+					model: resumedLabel,
+					success: true,
+					...(usage === undefined ? {} : { usage }),
+				});
 				this.pendingFallbackWarnings.length = 0;
 				this.resumeCurrentSession = true;
 				return true;
@@ -1187,13 +1310,24 @@ export class StageSessionController {
 			throw new WorkflowPromptModelFailure(terminalFailure);
 		} catch (err) {
 			if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
-				this.modelAttempts.push({ model: resumedLabel, success: true });
+				const usage = this.takeAttemptUsage(resumedSession);
+				this.modelAttempts.push({
+					model: resumedLabel,
+					success: true,
+					...(usage === undefined ? {} : { usage }),
+				});
 				this.pendingFallbackWarnings.length = 0;
 				this.resumeCurrentSession = true;
 				return true;
 			}
 			const message = errorMessage(err);
-			this.modelAttempts.push({ model: resumedLabel, success: false, error: message });
+			const usage = this.takeAttemptUsage(resumedSession);
+			this.modelAttempts.push({
+				model: resumedLabel,
+				success: false,
+				...(usage === undefined ? {} : { usage }),
+				error: message,
+			});
 			if (this.opts.signal?.aborted || !isRetryableModelFailure(err)) {
 				this.modelWarnings.push(...this.pendingFallbackWarnings);
 				this.pendingFallbackWarnings.length = 0;
@@ -1233,10 +1367,12 @@ export class StageSessionController {
 			this.recordSuccessfulAttempt(candidate);
 			return "handled";
 		}
+		const usage = this.takeAttemptUsage(this.session);
 		this.modelAttempts.push({
 			model: candidate.id,
 			success: false,
 			...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+			...(usage === undefined ? {} : { usage }),
 			error: message,
 		});
 		if (this.opts.signal?.aborted || !isRetryableModelFailure(err) || index === candidates.length - 1) {
@@ -1258,10 +1394,12 @@ export class StageSessionController {
 	}
 
 	private recordSuccessfulAttempt(candidate: WorkflowResolvedModelCandidate): void {
+		const usage = this.takeAttemptUsage(this.session);
 		this.modelAttempts.push({
 			model: candidate.id,
 			success: true,
 			...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+			...(usage === undefined ? {} : { usage }),
 		});
 		this.pendingFallbackWarnings.length = 0;
 		this.resumeCurrentSession = true;

package/dist/builtin/workflows/src/runs/foreground/stage-runner-types.ts

@@ -147,6 +147,8 @@ export interface StageRunnerOpts {
 	defaultSessionDir?: string;
 	/** Internal: notifies the executor when an in-flight fallback changes model/fast metadata. */
 	onModelFallbackMetaChange?: (meta: StageModelFallbackMeta) => void;
+	/** Internal: persist stage-session identity once the SDK has created its path. */
+	onSessionReady?: () => void | Promise<void>;
 }
 
 export interface InternalStageContext extends StageContext {

package/dist/builtin/workflows/src/runs/foreground/stage-session-heartbeat.ts

@@ -0,0 +1,88 @@
+export const STAGE_SESSION_HEARTBEAT_INTERVAL_MS = 30_000;
+
+export interface StageSessionHeartbeat {
+	start(): void;
+	stop(): void;
+	/**
+	 * Stop scheduling and await the checkpoint that is still in flight, so a late
+	 * durable failure surfaces at shutdown instead of being discarded with the
+	 * cancelled timer. Rejects with a failure recorded earlier via `fail()` too.
+	 */
+	drain(): Promise<void>;
+	fail(error: unknown): void;
+	race<T>(work: Promise<T>): Promise<T>;
+}
+
+/** Run one non-overlapping, unref'd durability checkpoint every 30 seconds. */
+export function createStageSessionHeartbeat(
+	checkpoint: () => Promise<void>,
+	intervalMs: number = STAGE_SESSION_HEARTBEAT_INTERVAL_MS,
+): StageSessionHeartbeat {
+	let active = false;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let generation = 0;
+	let nextDeadline = 0;
+	let failure: unknown;
+	let inFlight: Promise<void> | undefined;
+	let rejectFailure!: (reason: unknown) => void;
+	const failureSignal = new Promise<never>((_resolve, reject) => {
+		rejectFailure = reject;
+	});
+	// A race attaches the normal consumer; this guard prevents a late checkpoint
+	// rejection from becoming an unhandled process error during teardown.
+	void failureSignal.catch(() => undefined);
+	const stopScheduling = (): void => {
+		active = false;
+		generation += 1;
+		if (timer !== undefined) clearTimeout(timer);
+		timer = undefined;
+	};
+	const fail = (error: unknown): void => {
+		if (failure !== undefined) return;
+		failure = error;
+		stopScheduling();
+		rejectFailure(error);
+	};
+
+	const schedule = (scheduledGeneration: number): void => {
+		if (!active || failure !== undefined || scheduledGeneration !== generation) return;
+		const delayMs = Math.max(0, nextDeadline - Date.now());
+		timer = setTimeout(() => {
+			timer = undefined;
+			const startedAt = Date.now();
+			do nextDeadline += intervalMs;
+			while (nextDeadline <= startedAt);
+			const running = checkpoint()
+				.catch(fail)
+				.finally(() => {
+					if (inFlight === running) inFlight = undefined;
+					schedule(scheduledGeneration);
+				});
+			inFlight = running;
+		}, delayMs);
+		(timer as { unref?: () => void }).unref?.();
+	};
+
+	const drain = async (): Promise<void> => {
+		stopScheduling();
+		await inFlight;
+		if (failure !== undefined) throw failure;
+	};
+
+	return {
+		start(): void {
+			if (active || failure !== undefined) return;
+			active = true;
+			generation += 1;
+			nextDeadline = Date.now() + intervalMs;
+			schedule(generation);
+		},
+		stop: stopScheduling,
+		drain,
+		fail,
+		race<T>(work: Promise<T>): Promise<T> {
+			if (failure !== undefined) return Promise.reject(failure);
+			return Promise.race([work, failureSignal]);
+		},
+	};
+}

package/dist/builtin/workflows/src/tui/keybindings-adapter.ts

@@ -44,6 +44,7 @@ export const APP_ACTION = {
 } as const;
 
 export const TUI_ACTION = {
+	altScreenBottom: "tui.altScreen.bottom",
 	editorCursorUp: "tui.editor.cursorUp",
 	editorCursorDown: "tui.editor.cursorDown",
 	editorCursorLeft: "tui.editor.cursorLeft",

package/dist/builtin/workflows/src/tui/overlay-adapter.ts

@@ -412,6 +412,7 @@ export function buildGraphOverlayAdapter(
 			// Ctrl+C (Skip / Close / cancel), so the host must forward it here
 			// instead of closing this overlay on the first press.
 			handlesCtrlC: true,
+			handlesInternalUiAction: true,
 			overlayOptions: FULLSCREEN_OVERLAY_OPTIONS,
 			onHandle: (handle) => {
 				currentHandle = handle;

package/dist/builtin/workflows/src/tui/run-detail.ts

@@ -182,6 +182,7 @@ function summaryRows(detail: RunDetail, now: number): Array<[string, string | un
 	if (detail.error) {
 		rows.push(["error", detail.error.split("\n")[0] ?? ""]);
 	}
+	if (detail.resumeGuidance) rows.push(["guidance", detail.resumeGuidance]);
 	return rows;
 }
 
@@ -319,6 +320,8 @@ function stateBadges(detail: RunDetail, theme: GraphTheme): FlatBandBadge[] {
 	switch (detail.status) {
 		case "running":
 			return [{ text: "● running", fg: theme.warning }];
+		case "crashed":
+			return [{ text: detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed", fg: theme.error }];
 		case "paused":
 			return [{ text: "❚❚ paused", fg: theme.warning }];
 		case "completed":
@@ -342,6 +345,8 @@ function stateLabel(detail: RunDetail): string {
 	switch (detail.status) {
 		case "running":
 			return "● running";
+		case "crashed":
+			return detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed";
 		case "paused":
 			return "❚❚ paused";
 		case "completed":
@@ -387,18 +392,26 @@ function renderIdentifierRows(id: string, width: number, theme?: GraphTheme): st
 }
 
 function renderDetailHintRows(detail: RunDetail, width: number, theme?: GraphTheme): string[] {
-	const prefix =
-		detail.endedAt === undefined
-			? detail.status === "paused"
-				? " ▸ workflow resume id="
-				: " ▸ workflow interrupt   id="
-			: " ▸ workflow resume id=";
-	const suffix =
-		detail.endedAt === undefined
-			? detail.status === "paused"
-				? "    continue workflow "
-				: "    cancel "
-			: "    reopen graph ";
+	const resumable =
+		(detail.status === "paused" && detail.resumable !== false) ||
+		(detail.resumable === true &&
+			(detail.status === "crashed" || detail.status === "failed" || detail.status === "blocked"));
+	const inspectOnly =
+		detail.ownerActiveElsewhere === true ||
+		(detail.status === "crashed" && !resumable) ||
+		(detail.endedAt !== undefined && !resumable);
+	const prefix = inspectOnly
+		? " ▸ workflow status id="
+		: resumable
+			? " ▸ workflow resume id="
+			: " ▸ workflow interrupt   id=";
+	const suffix = inspectOnly
+		? detail.ownerActiveElsewhere === true
+			? "    inspect; owner active elsewhere "
+			: "    inspect retained state "
+		: resumable
+			? "    continue workflow "
+			: "    cancel ";
 	const continuation = "    ";
 	const rows = wrapIdentifierLines(detail.runId, width, prefix, continuation);
 	const last = rows[rows.length - 1]!;

package/dist/builtin/workflows/src/tui/stage-chat-view-archive-history.ts

@@ -38,6 +38,8 @@ export function renderReadOnlyArchiveBody(
 	width: number,
 	budget: number,
 	stage: StageSnapshot | undefined,
+	indicatorLines: readonly string[] = [],
+	renderIndicator: () => readonly string[] = () => indicatorLines,
 ): string[] {
 	if (stage?.promptFootprint) {
 		return renderReadOnlyPromptArchiveBody(ctx, width, budget, stage);
@@ -69,8 +71,14 @@ export function renderReadOnlyArchiveBody(
 		).render(width),
 	);
 	const transcriptBudget = Math.max(0, budget - callout.length);
-	const lines = transcriptBudget > 0 ? ctx.chatHost.renderBody(width, transcriptBudget) : [];
-	lines.push(...callout);
+	const reservedIndicatorRows =
+		indicatorLines.length > 0 && transcriptBudget > indicatorLines.length ? indicatorLines.length : 0;
+	const transcriptRows = transcriptBudget - reservedIndicatorRows;
+	const lines = transcriptRows > 0 ? ctx.chatHost.renderBody(width, transcriptRows) : [];
+	const visibleIndicatorLines =
+		reservedIndicatorRows > 0 ? [...renderIndicator().slice(0, reservedIndicatorRows)] : [];
+	while (visibleIndicatorLines.length < reservedIndicatorRows) visibleIndicatorLines.push(blankLine(width));
+	lines.push(...visibleIndicatorLines, ...callout);
 	while (lines.length < budget) lines.push(blankLine(width));
 	if (lines.length > budget) lines.length = budget;
 	return lines;
@@ -163,7 +171,13 @@ function formatReadOnlyPromptAnswer(value: unknown, kind: PendingPrompt["kind"])
 	}
 }
 
-export function renderPausedBody(ctx: StageChatViewContext, width: number, budget: number): string[] {
+export function renderPausedBody(
+	ctx: StageChatViewContext,
+	width: number,
+	budget: number,
+	indicatorLines: readonly string[] = [],
+	renderIndicator: () => readonly string[] = () => indicatorLines,
+): string[] {
 	const t = ctx.theme;
 	const callout: string[] = [];
 	callout.push(blankLine(width));
@@ -175,11 +189,16 @@ export function renderPausedBody(ctx: StageChatViewContext, width: number, budge
 			0,
 		).render(width),
 	);
-
-	const calloutRows = Math.min(callout.length, Math.max(0, budget - 1));
-	const transcriptBudget = Math.max(1, budget - calloutRows);
-	const lines = ctx.chatHost.renderBody(width, transcriptBudget);
-	lines.push(...callout.slice(0, calloutRows));
+	const calloutRows = Math.min(callout.length, Math.max(0, budget));
+	const transcriptBudget = Math.max(0, budget - calloutRows);
+	const reservedIndicatorRows =
+		indicatorLines.length > 0 && transcriptBudget > indicatorLines.length ? indicatorLines.length : 0;
+	const transcriptRows = transcriptBudget - reservedIndicatorRows;
+	const lines = transcriptRows > 0 ? ctx.chatHost.renderBody(width, transcriptRows) : [];
+	const visibleIndicatorLines =
+		reservedIndicatorRows > 0 ? [...renderIndicator().slice(0, reservedIndicatorRows)] : [];
+	while (visibleIndicatorLines.length < reservedIndicatorRows) visibleIndicatorLines.push(blankLine(width));
+	lines.push(...visibleIndicatorLines, ...callout.slice(0, calloutRows));
 	while (lines.length < budget) lines.push(blankLine(width));
 	if (lines.length > budget) lines.length = budget;
 	return lines;