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

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/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/workflow-resume-selector.ts

@@ -191,6 +191,7 @@ function toPickerRow(session: SessionInfo): PiHostSessionPickerRow {
 		modifiedAt: session.modified.getTime(),
 		messageCount: session.messageCount,
 		firstMessage: session.firstMessage,
+		...(session.summary !== undefined ? { summary: session.summary } : {}),
 		allMessagesText: session.allMessagesText,
 		...(session.name !== undefined ? { name: session.name } : {}),
 		...(session.messageColor !== undefined ? { messageColor: session.messageColor } : {}),

package/dist/core/agent-session-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-session-events.d.ts","sourceRoot":"","sources":["../../src/core/agent-session-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAe,MAAM,8BAA8B,CAAC;AAE3F,OAAO,KAAK,EAAE,2BAA2B,IAAI,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAS9F,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAI9B,MAAM,0BAA0B,CAAC;AAiBlC,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAIxE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAMzD;AAED,4EAA4E;AAE5E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CA2B7F;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CA6B1F;AAED,wBAAgB,4BAA4B,CAC3C,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,YAAY,EAAE,GACtB,gBAAgB,GAAG,SAAS,CAQ9B;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyL7F;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CA0BvF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAQvF;AAED,wCAAwC;AAExC,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAMtD;AAED,0CAA0C;AAE1C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAMhF;AAED,8EAA8E;AAE9E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,SAAS,CAS1F;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,IAAI,CAchH;AAED,kDAAkD;AAElD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAsE9F;AAED;;;;GAIG;AAEH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,yBAAyB,GAAG,MAAM,IAAI,CAU7F;AAED,oDAAoD;AACpD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAK7D;AAED;;;GAGG;AAEH,wBAAgB,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAchD;AAMD,uBAAuB;AAEvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;CAiBrC,CAAC"}
+{"version":3,"file":"agent-session-events.d.ts","sourceRoot":"","sources":["../../src/core/agent-session-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAe,MAAM,8BAA8B,CAAC;AAE3F,OAAO,KAAK,EAAE,2BAA2B,IAAI,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAS9F,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAI9B,MAAM,0BAA0B,CAAC;AAgBlC,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAIxE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAMzD;AAED,4EAA4E;AAE5E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CA2B7F;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CA6B1F;AAED,wBAAgB,4BAA4B,CAC3C,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,YAAY,EAAE,GACtB,gBAAgB,GAAG,SAAS,CAQ9B;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAgM7F;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CA0BvF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAQvF;AAED,wCAAwC;AAExC,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAMtD;AAED,0CAA0C;AAE1C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAMhF;AAED,8EAA8E;AAE9E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,SAAS,CAS1F;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,IAAI,CAchH;AAED,kDAAkD;AAElD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAsE9F;AAED;;;;GAIG;AAEH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,yBAAyB,GAAG,MAAM,IAAI,CAU7F;AAED,oDAAoD;AACpD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAK7D;AAED;;;GAGG;AAEH,wBAAgB,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAmBhD;AAMD,uBAAuB;AAEvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;CAiBrC,CAAC"}

package/dist/core/agent-session-events.js

@@ -1,7 +1,6 @@
 import { cleanupSessionResources } from "@earendil-works/pi-ai/compat";
 import { isProtectedStreamingCustomMessage, markProtectedStreamingCustomMessageConsumed, markProtectedStreamingCustomMessagePersistenceFailed, persistProtectedStreamingCustomMessage, prepareProtectedStreamingCustomMessagesForDisposal, retryConsumedProtectedStreamingCustomMessages, } from "./agent-session-persistent-custom-messages.js";
 import { customMessageExcludesContext, isSingleGenericAbortTextContent, replacementAbortContent, } from "./agent-session-types.js";
-import { disposeSessionAsyncJobManager } from "./async/session-manager.js";
 import { formatCodexProviderError } from "./codex-errors.js";
 import { STALE_EXTENSION_CONTEXT_MESSAGE } from "./extensions/stale-context.js";
 import { normalizeMessageContent } from "./messages.js";
@@ -235,6 +234,12 @@ export async function _processAgentEvent(event) {
             if (typeof this._restoreFallbackModel === "function")
                 await this._restoreFallbackModel();
         }
+        // Launched last so the fallback lifecycle wins: a switch above returns before this line, and
+        // the restore has already put `this.model` back to the user's selection, which the launch
+        // reads synchronously before it parks on waitForIdle(). Guarded like the fallback methods
+        // above because the fallback suites drive this function on a synthetic session.
+        if (event.type === "agent_end" && typeof this._maybeGenerateSessionSummary === "function")
+            void this._maybeGenerateSessionSummary();
     }
 }
 export function _applyInterruptAbortMessage(event) {
@@ -421,17 +426,23 @@ export function _disconnectFromAgent() {
  * Call this when completely done with the session.
  */
 export function dispose() {
+    // Terminal and idempotent: callers legitimately dispose more than once (an explicit dispose
+    // followed by a harness teardown), and the steps below are not all safe to repeat.
+    if (this._disposed)
+        return;
+    // Summary work queued before its AbortController exists cannot be reached by
+    // abortSessionSummary(), so disposal is recorded as state that every checkpoint consults.
+    this._disposed = true;
+    // A background summary must never keep the process alive past shutdown.
+    this.abortSessionSummary();
     // Fail closed while protected input remains queued, or flush a consumed
     // reconciliation before invalidation can discard its recovery state.
     prepareProtectedStreamingCustomMessagesForDisposal(this);
     this._extensionRunner.invalidate(STALE_EXTENSION_CONTEXT_MESSAGE);
-    disposeSessionAsyncJobManager(this._asyncJobManager, this._asyncJobManagerSessionId);
     this._disconnectFromAgent();
     this._eventListeners = [];
     cleanupSessionResources(this.sessionId);
-    // Last: an async spill writer started by this session holds its own lease, so
-    // releasing here stops protecting a tree nothing is using without cutting a
-    // writer that outlived the session object.
+    // Releasing the session lease stops protecting a tree that is no longer in use.
     this._tempStorageLease?.release();
     this._tempStorageLease = undefined;
 }