@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/workflows/src/shared/persistence-restore-helpers.ts

@@ -7,6 +7,7 @@ import type {
 	StageSnapshot,
 	StageStatus,
 	ToolNodeSnapshot,
+	WorkflowActor,
 	WorkflowFailureCode,
 	WorkflowFailureDisposition,
 	WorkflowFailureKind,
@@ -406,6 +407,7 @@ export function restoreTerminalRuns(entries: readonly SessionEntry[], store: Sto
 			...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
 			...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
 			...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
+			...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
 			...(runMeta.accumulatedDurationMs !== undefined
 				? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
 				: {}),
@@ -481,6 +483,7 @@ export function findRunStartMetadata(
 	readonly resumedFromRunId?: string;
 	readonly resumeFromStageId?: string;
 	readonly accumulatedDurationMs?: number;
+	readonly origin?: WorkflowActor;
 } {
 	for (const entry of entries) {
 		if (entry.type !== "workflow.run.start" || entry.payload.runId !== runId) continue;
@@ -490,6 +493,7 @@ export function findRunStartMetadata(
 		const resumedFromRunId = entry.payload.resumedFromRunId;
 		const resumeFromStageId = entry.payload.resumeFromStageId;
 		const accumulatedDurationMs = entry.payload.accumulatedDurationMs;
+		const origin = entry.payload.origin;
 		return {
 			...(typeof parentRunId === "string" ? { parentRunId } : {}),
 			...(typeof parentStageId === "string" ? { parentStageId } : {}),
@@ -501,6 +505,7 @@ export function findRunStartMetadata(
 			accumulatedDurationMs > 0
 				? { accumulatedDurationMs }
 				: {}),
+			...(origin === "user" || origin === "agent" ? { origin } : {}),
 		};
 	}
 	return {};

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -209,6 +209,7 @@ export function restoreOnSessionStart(
 				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
 				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
 				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
 				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
 				...(runMeta.accumulatedDurationMs !== undefined
 					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
@@ -244,6 +245,7 @@ export function restoreOnSessionStart(
 				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
 				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
 				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
 				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
 				...(runMeta.accumulatedDurationMs !== undefined
 					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
@@ -268,6 +270,7 @@ export function restoreOnSessionStart(
 				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
 				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
 				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
 				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
 				...(runMeta.accumulatedDurationMs !== undefined
 					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }

package/dist/builtin/workflows/src/shared/persistence-session-entries.ts

@@ -8,6 +8,7 @@
 
 import type {
 	ToolNodeSnapshot,
+	WorkflowActor,
 	WorkflowFailureCode,
 	WorkflowFailureDisposition,
 	WorkflowFailureKind,
@@ -40,6 +41,8 @@ export interface RunStartPayload {
 	readonly parentStageId?: string;
 	readonly rootRunId?: string;
 	readonly resumedFromRunId?: string;
+	/** Who launched this run, when the launcher was attributable. */
+	readonly origin?: WorkflowActor;
 	readonly resumeFromStageId?: string;
 	/** Elapsed ms inherited from prior sessions of a resumed run. */
 	readonly accumulatedDurationMs?: number;
@@ -151,6 +154,7 @@ export function appendRunStart(api: PersistenceAPI, payload: RunStartPayload): v
 		...(payload.parentStageId !== undefined ? { parentStageId: payload.parentStageId } : {}),
 		...(payload.rootRunId !== undefined ? { rootRunId: payload.rootRunId } : {}),
 		...(payload.resumedFromRunId !== undefined ? { resumedFromRunId: payload.resumedFromRunId } : {}),
+		...(payload.origin !== undefined ? { origin: payload.origin } : {}),
 		...(payload.resumeFromStageId !== undefined ? { resumeFromStageId: payload.resumeFromStageId } : {}),
 		...(payload.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: payload.accumulatedDurationMs } : {}),
 		ts: payload.ts,

package/dist/builtin/workflows/src/shared/run-indicator-status.ts

@@ -0,0 +1,75 @@
+import { effectiveRunStatus } from "./returned-run-status.js";
+import type { RunSnapshot, RunStatus } from "./store-types.js";
+
+/** The status represented by a run's primary indicator. */
+export type RunIndicatorStatus = RunStatus | "awaiting_input";
+
+const TERMINAL_OR_BLOCKED = new Set<RunStatus>(["completed", "failed", "killed", "cancelled", "skipped", "blocked"]);
+
+/**
+ * Resolve the status represented by a run's primary indicator.
+ *
+ * A live run with a pending run/stage prompt is awaiting input. When the
+ * caller supplies the complete run collection, pending prompts in hidden
+ * nested descendants are attributed to the visible ancestor by following
+ * `rootRunId` and `parentRunId`. Effective terminal and blocked statuses are
+ * authoritative, even when a stale prompt marker remains in a snapshot.
+ */
+export function runIndicatorStatus(run: RunSnapshot, allRuns: readonly RunSnapshot[] = [run]): RunIndicatorStatus {
+	const status = effectiveRunStatus(run);
+	if (TERMINAL_OR_BLOCKED.has(status)) return status;
+	if (runHasPendingInput(run)) return "awaiting_input";
+
+	const runsById = new Map(allRuns.map((candidate) => [candidate.id, candidate]));
+	for (const candidate of allRuns) {
+		if (candidate.id === run.id || !runBelongsTo(candidate, run, runsById)) continue;
+		const candidateStatus = effectiveRunStatus(candidate);
+		if (!TERMINAL_OR_BLOCKED.has(candidateStatus) && runHasPendingInput(candidate)) return "awaiting_input";
+	}
+	return status;
+}
+
+/**
+ * Precompute the indicator status of each listed run against the complete
+ * run collection. The result is plain serializable data, so a surface whose
+ * payload is persisted and re-rendered after a session restore (e.g. the
+ * `/workflow status` chat entry) keeps hidden-descendant prompt attribution
+ * without serializing the hidden run snapshots themselves.
+ */
+export function resolveRunIndicatorStatuses(
+	runs: readonly RunSnapshot[],
+	allRuns: readonly RunSnapshot[],
+): Readonly<Record<string, RunIndicatorStatus>> {
+	const statuses: Record<string, RunIndicatorStatus> = {};
+	for (const run of runs) statuses[run.id] = runIndicatorStatus(run, allRuns);
+	return statuses;
+}
+
+function runHasPendingInput(run: RunSnapshot): boolean {
+	if (run.pendingPrompt !== undefined) return true;
+	return run.stages.some(
+		(stage) =>
+			stage.status === "awaiting_input" ||
+			stage.awaitingInputSince !== undefined ||
+			stage.pendingPrompt !== undefined ||
+			stage.inputRequest !== undefined,
+	);
+}
+
+function runBelongsTo(
+	candidate: RunSnapshot,
+	ancestor: RunSnapshot,
+	runsById: ReadonlyMap<string, RunSnapshot>,
+): boolean {
+	if (candidate.rootRunId === ancestor.id) return true;
+
+	const visited = new Set<string>();
+	let current: RunSnapshot | undefined = candidate;
+	while (current !== undefined && current.parentRunId !== undefined) {
+		if (current.parentRunId === ancestor.id) return true;
+		if (visited.has(current.id)) return false;
+		visited.add(current.id);
+		current = runsById.get(current.parentRunId);
+	}
+	return false;
+}

package/dist/builtin/workflows/src/shared/store-public-types.ts

@@ -1,6 +1,7 @@
 import type {
 	PendingPrompt,
 	PromptKind,
+	RunResumeSource,
 	RunSnapshot,
 	RunStatus,
 	StageInputRequest,
@@ -9,6 +10,7 @@ import type {
 	StoreSnapshot,
 	ToolEvent,
 	ToolNodeSnapshot,
+	WorkflowActor,
 	WorkflowChildRunRef,
 	WorkflowFailureCode,
 	WorkflowFailureDisposition,
@@ -33,10 +35,30 @@ export interface RunEndMetadata {
 	readonly exitReason?: string;
 }
 
+export type { RunResumeSource, WorkflowActor } from "./store-types.js";
+
 export interface RunPauseMetadata {
 	readonly resumable?: boolean;
 	readonly exitReason?: string;
+	/** Who paused or quit this run. Omitted for internal engine pauses. */
+	readonly actor?: WorkflowActor;
+}
+
+export interface RunResumeMetadata {
+	/** Who resumed this run. Omitted for internal engine resumes. */
+	readonly actor?: WorkflowActor;
+	/**
+	 * Required so a new call site cannot silently start notifying: every caller
+	 * states its own path, and only `run_control` is user-visible.
+	 */
+	readonly source: RunResumeSource;
+}
+
+/** Attribution for a stage-scoped pause or resume. */
+export interface StageControlMetadata {
+	readonly actor?: WorkflowActor;
 }
+
 export interface RunBlockedMetadata extends RunEndMetadata {
 	readonly failureRecoverability: "recoverable";
 	readonly failedStageId: string;
@@ -214,17 +236,31 @@ export interface Store {
 	recordStageInputRequest(runId: string, stageId: string, request: StageInputRequest): boolean;
 	/** Clear a stage's brokered structured-prompt descriptor. */
 	clearStageInputRequest(runId: string, stageId: string): boolean;
-	/** Mark a stage as `paused` and record `pausedAt`. */
-	recordStagePaused(runId: string, stageId: string, pausedAt?: number): boolean;
-	/** Clear `paused`/`blocked` state on a stage and record `resumedAt`. */
-	recordStageResumed(runId: string, stageId: string, resumedAt?: number): boolean;
+	/**
+	 * Mark a stage as `paused` and record `pausedAt`. Metadata on an already-paused
+	 * stage records attribution alone, so a control path can claim a pause the
+	 * engine already published.
+	 */
+	recordStagePaused(runId: string, stageId: string, pausedAt?: number, metadata?: StageControlMetadata): boolean;
+	/**
+	 * Clear `paused`/`blocked` state on a stage and record `resumedAt`. Metadata on
+	 * an already-running stage records attribution alone.
+	 */
+	recordStageResumed(runId: string, stageId: string, resumedAt?: number, metadata?: StageControlMetadata): boolean;
 	recordStageBlocked(runId: string, stageId: string, blockedBy: string): boolean;
 	recordStageUnblocked(runId: string, stageId: string): boolean;
 	recordStageNotice(runId: string, stageId: string, notice: StageNotice): boolean;
-	/** Mark a run as `paused`. Optional metadata can annotate resumable quit/detach state. */
+	/** Mark a run as `paused`. Optional metadata can annotate resumable quit/detach state and attribution. */
 	recordRunPaused(runId: string, pausedAt?: number, metadata?: RunPauseMetadata): boolean;
-	/** Restore a run from `paused` back to `running`. */
-	recordRunResumed(runId: string, resumedAt?: number): boolean;
+	/**
+	 * Restore a run from `paused` back to `running`.
+	 *
+	 * Metadata states which path resumed the run. A run-control resume records its
+	 * attribution even when an inner engine path already flipped the status, which
+	 * is the normal order: stage control and the acknowledgement pass both resume
+	 * the run before public run control returns.
+	 */
+	recordRunResumed(runId: string, resumedAt?: number, metadata?: RunResumeMetadata): boolean;
 	/** Drop every run and notice. */
 	clear(): void;
 	snapshot(): StoreSnapshot;

package/dist/builtin/workflows/src/shared/store-run-methods.ts

@@ -6,9 +6,15 @@ import {
 	type StoreContext,
 	TERMINAL_STATUSES,
 } from "./store-internal.js";
-import type { RunBlockedMetadata, RunEndMetadata, RunPauseMetadata, Store } from "./store-public-types.js";
+import type {
+	RunBlockedMetadata,
+	RunEndMetadata,
+	RunPauseMetadata,
+	RunResumeMetadata,
+	Store,
+} from "./store-public-types.js";
 import type { RunSnapshot, RunStatus, StoreSnapshot, WorkflowNotice } from "./store-types.js";
-import { accumulatePausedDurationMs, elapsedRunMs } from "./timing.js";
+import { accumulatePausedDurationMs, elapsedRunMs, nextControlTimestamp } from "./timing.js";
 import type { WorkflowOutputValues } from "./types.js";
 
 type RunStoreMethods = Pick<
@@ -181,32 +187,60 @@ export function createRunStoreMethods(context: StoreContext): RunStoreMethods {
 			if (!run) return false;
 			if (TERMINAL_STATUSES.has(run.status)) return false;
 			const wasPaused = run.status === "paused";
-			const enteringQuit = metadata?.exitReason === "quit" && run.exitReason !== "quit";
 			if (!wasPaused) {
 				run.status = "paused";
-				run.pausedAt = pausedAt ?? Date.now();
+				run.pausedAt = nextControlTimestamp(pausedAt, run.resumedAt);
 				run.resumedAt = undefined;
+				delete run.pauseActor;
+				delete run.resumeActor;
+				delete run.resumeSource;
 			}
 			if (metadata?.resumable !== undefined) run.resumable = metadata.resumable;
 			if (metadata?.exitReason !== undefined) run.exitReason = metadata.exitReason;
-			if (enteringQuit) run.quitAt = Date.now();
+			if (metadata?.exitReason === "quit" && run.quitAt === undefined)
+				run.quitAt = nextControlTimestamp(undefined, run.pausedAt);
+			// A control path claims the stop it just performed, even when the engine
+			// already published the paused state on its way there.
+			if (metadata?.actor !== undefined) run.pauseActor = metadata.actor;
 			if (wasPaused && metadata === undefined) return false;
 			context.bumpAndNotify();
 			return true;
 		},
 
-		recordRunResumed(runId: string, resumedAt?: number): boolean {
+		recordRunResumed(runId: string, resumedAt?: number, metadata?: RunResumeMetadata): boolean {
 			const run = context.findRun(runId);
 			if (!run) return false;
 			if (TERMINAL_STATUSES.has(run.status)) return false;
-			if (run.status !== "paused") return false;
-			const resumedTs = resumedAt ?? Date.now();
+			// Run control is the last step of a resume, by which point stage control
+			// or the acknowledgement pass has usually flipped the status already.
+			// Recording its attribution anyway is what distinguishes a deliberate
+			// resume from the engine continuing work on its own.
+			const claimsRunControl = metadata?.source === "run_control";
+			if (run.status !== "paused") {
+				if (!claimsRunControl || run.status !== "running" || run.resumedAt === undefined) return false;
+				if (run.resumeSource === "run_control" && run.resumeActor === metadata?.actor) return false;
+				run.resumeSource = "run_control";
+				if (metadata?.actor === undefined) delete run.resumeActor;
+				else run.resumeActor = metadata.actor;
+				context.bumpAndNotify();
+				return false;
+			}
+			const resumedTs = nextControlTimestamp(resumedAt, run.pausedAt);
 			run.status = "running";
 			run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, resumedTs);
 			run.resumedAt = resumedTs;
 			run.pausedAt = undefined;
 			delete run.quitAt;
 			delete run.exitReason;
+			delete run.pauseActor;
+			if (metadata === undefined) {
+				delete run.resumeActor;
+				delete run.resumeSource;
+			} else {
+				run.resumeSource = metadata.source;
+				if (metadata.actor === undefined) delete run.resumeActor;
+				else run.resumeActor = metadata.actor;
+			}
 			context.bumpAndNotify();
 			return true;
 		},

package/dist/builtin/workflows/src/shared/store-stage-methods.ts

@@ -6,10 +6,10 @@ import {
 	type StoreContext,
 	TERMINAL_STATUSES,
 } from "./store-internal.js";
-import type { Store } from "./store-public-types.js";
+import type { StageControlMetadata, Store } from "./store-public-types.js";
 import { nextExecutionOrder } from "./store-tool-node-methods.js";
 import type { StageInputRequest, StageNotice, StageSnapshot, ToolEvent, WorkflowChildRunRef } from "./store-types.js";
-import { accumulatePausedDurationMs } from "./timing.js";
+import { accumulatePausedDurationMs, nextControlTimestamp } from "./timing.js";
 
 type StageStoreMethods = Pick<
 	Store,
@@ -269,29 +269,49 @@ export function createStageStoreMethods(context: StoreContext): StageStoreMethod
 			return true;
 		},
 
-		recordStagePaused(runId: string, stageId: string, pausedAt?: number): boolean {
+		recordStagePaused(runId: string, stageId: string, pausedAt?: number, metadata?: StageControlMetadata): boolean {
 			const run = context.findRun(runId);
 			if (!run) return false;
 			if (TERMINAL_STATUSES.has(run.status)) return false;
 			const stage = context.findStage(run, stageId);
 			if (!stage) return false;
-			if (cannotPause(stage.status)) return false;
+			if (cannotPause(stage.status)) {
+				// Attribution-only claim: the control path paused this stage through
+				// the engine and is naming itself afterwards.
+				if (stage.status !== "paused" || metadata?.actor === undefined) return false;
+				if (stage.pauseActor === metadata.actor) return false;
+				stage.pauseActor = metadata.actor;
+				context.bumpAndNotify();
+				return false;
+			}
 			stage.status = "paused";
-			stage.pausedAt = pausedAt ?? Date.now();
+			stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
 			stage.resumedAt = undefined;
 			delete stage.awaitingInputSince;
+			delete stage.resumeActor;
+			if (metadata?.actor === undefined) delete stage.pauseActor;
+			else stage.pauseActor = metadata.actor;
 			context.bumpAndNotify();
 			return true;
 		},
 
-		recordStageResumed(runId: string, stageId: string, resumedAt?: number): boolean {
+		recordStageResumed(runId: string, stageId: string, resumedAt?: number, metadata?: StageControlMetadata): boolean {
 			const run = context.findRun(runId);
 			if (!run) return false;
 			if (TERMINAL_STATUSES.has(run.status)) return false;
 			const stage = context.findStage(run, stageId);
 			if (!stage) return false;
-			if (stage.status !== "paused" && stage.status !== "blocked") return false;
-			const resumedTs = resumedAt ?? Date.now();
+			if (stage.status !== "paused" && stage.status !== "blocked") {
+				// Attribution-only claim, mirroring the paused path above.
+				if (stage.status !== "running" || stage.resumedAt === undefined || metadata?.actor === undefined) {
+					return false;
+				}
+				if (stage.resumeActor === metadata.actor) return false;
+				stage.resumeActor = metadata.actor;
+				context.bumpAndNotify();
+				return false;
+			}
+			const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
 			stage.status = "running";
 			if (stage.startedAt !== undefined) {
 				stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
@@ -300,6 +320,9 @@ export function createStageStoreMethods(context: StoreContext): StageStoreMethod
 			stage.pausedAt = undefined;
 			delete stage.blockedByStageId;
 			delete stage.awaitingInputSince;
+			delete stage.pauseActor;
+			if (metadata?.actor === undefined) delete stage.resumeActor;
+			else stage.resumeActor = metadata.actor;
 			context.bumpAndNotify();
 			return true;
 		},

package/dist/builtin/workflows/src/shared/store-types.ts

@@ -261,8 +261,27 @@ export interface StageSnapshot {
 	pausedAt?: number;
 	/** Timestamp recorded on the most recent resume from a paused state. */
 	resumedAt?: number;
+	/** Who paused this stage. Set only by a deliberate control action. */
+	pauseActor?: WorkflowActor;
+	/** Who resumed this stage. Set only by a deliberate control action. */
+	resumeActor?: WorkflowActor;
 }
 
+/**
+ * Who performed a workflow lifecycle action. A run's `origin` answers "who
+ * launched it"; an actor on a pause, quit, or resume answers "who did this one
+ * thing". They differ routinely — the agent starts a run and the user quits it.
+ */
+export type WorkflowActor = "user" | "agent";
+
+/**
+ * Which code path resumed a run. Only `run_control` is a deliberate control
+ * action; the rest continue work already in progress — answering a
+ * human-in-the-loop prompt, per-stage control, and the acknowledgement pass —
+ * and must never be reported as a lifecycle event of their own.
+ */
+export type RunResumeSource = "run_control" | "prompt_answer" | "stage_control" | "acknowledgement";
+
 export interface RunSnapshot {
 	readonly id: string;
 	readonly name: string;
@@ -286,6 +305,21 @@ export interface RunSnapshot {
 	pausedAt?: number;
 	/** Timestamp when the run entered resumable quit state; display-only expiry marker. */
 	quitAt?: number;
+	/**
+	 * Who paused or quit this run, and who resumed it. A control path records
+	 * these; the engine's own pauses and resumes leave them unset, which is what
+	 * keeps an internal continuation from being reported as a user action.
+	 */
+	pauseActor?: WorkflowActor;
+	resumeActor?: WorkflowActor;
+	/** Which path performed the most recent resume. */
+	resumeSource?: RunResumeSource;
+	/**
+	 * Who launched this run. Set once at dispatch and inherited by a continuation
+	 * from the run it continues. Absent on legacy and restored runs that never
+	 * recorded it, in which case attribution is omitted rather than guessed.
+	 */
+	origin?: WorkflowActor;
 	/** Timestamp recorded on the most recent resume from a paused state. */
 	resumedAt?: number;
 	result?: WorkflowOutputValues;

package/dist/builtin/workflows/src/shared/timing.ts

@@ -19,6 +19,16 @@ interface RunTimerSnapshot {
 function nonNegative(ms: number): number {
 	return Math.max(0, ms);
 }
+/**
+ * Return an occurrence timestamp that remains ordered when a clock tick is
+ * shared by two deliberate control transitions. Lifecycle notice keys use
+ * these timestamps as occurrence identities, so a later transition must not
+ * reuse the prior transition's key.
+ */
+export function nextControlTimestamp(requestedAt: number | undefined, previousAt: number | undefined): number {
+	const candidate = requestedAt ?? Date.now();
+	return previousAt === undefined || candidate > previousAt ? candidate : previousAt + 1;
+}
 
 export function rebasedStageStartedAt(accumulatedDurationMs: number | undefined, resumedAt: number): number {
 	return resumedAt - nonNegative(accumulatedDurationMs ?? 0);

package/dist/builtin/workflows/src/tui/chat-surface-message.ts

@@ -27,6 +27,7 @@
 
 import type { ExtensionAPI } from "../extension/index.js";
 import type { RunDetail } from "../runs/background/status.js";
+import type { RunIndicatorStatus } from "../shared/run-indicator-status.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 import type { WorkflowInputValues } from "../shared/types.js";
 import { renderDispatchConfirm } from "./dispatch-confirm.js";
@@ -67,6 +68,15 @@ export interface DispatchPayload {
 export interface StatusPayload {
 	kind: "status";
 	runs: readonly RunSnapshot[];
+	/**
+	 * Emit-time indicator status per visible run id, resolved against the
+	 * complete point-in-time run collection (including hidden nested
+	 * descendants). Persisted with the payload because chat entries are
+	 * re-rendered from `details` after a session restore, where the full
+	 * collection is gone; storing only the derived statuses keeps hidden
+	 * run snapshots out of the serialized message.
+	 */
+	indicatorStatuses?: Readonly<Record<string, RunIndicatorStatus>>;
 }
 
 /** Workflow catalogue after `/workflow list`. */
@@ -164,7 +174,12 @@ export function renderChatSurfacePlainText(
 			return [rendered, `run id: ${payload.runId}`, `inputs: ${formatPlainRecord(payload.inputs)}`].join("\n");
 		}
 		case "status": {
-			const rendered = renderStatusList(payload.runs, { width, now, ...themed });
+			const rendered = renderStatusList(payload.runs, {
+				width,
+				now,
+				...themed,
+				indicatorStatuses: payload.indicatorStatuses,
+			});
 			if (payload.runs.length === 0) return rendered;
 			return [
 				rendered,
@@ -288,7 +303,12 @@ function renderPayload(payload: ChatSurfacePayload, theme: GraphTheme, width: nu
 				width,
 			});
 		case "status":
-			return renderStatusList(payload.runs, { theme, width, now });
+			return renderStatusList(payload.runs, {
+				theme,
+				width,
+				now,
+				indicatorStatuses: payload.indicatorStatuses,
+			});
 		case "list":
 			return renderWorkflowList(payload.entries, { theme, width });
 		case "detail":

package/dist/builtin/workflows/src/tui/session-list.ts

@@ -34,5 +34,5 @@ export function renderSessionList(runs: readonly RunSnapshot[], opts: SessionLis
 			toolNodes: graph.tools.map((tool) => structuredClone(tool)),
 		};
 	});
-	return renderStatusList(filtered, { theme: opts.theme, now });
+	return renderStatusList(filtered, { theme: opts.theme, now, allRuns: runs });
 }

package/dist/builtin/workflows/src/tui/session-overlays.ts

@@ -25,7 +25,7 @@
 
 import type { PiCustomComponent, PiCustomOverlayFactoryTui, PiCustomOverlayFunction } from "../extension/wiring.js";
 import type { Store } from "../shared/store.js";
-import { readGraphStoreSnapshot, subscribeStoreInvalidation } from "../shared/store-observation.js";
+import { subscribeStoreInvalidation } from "../shared/store-observation.js";
 import type { GraphTheme } from "./graph-theme.js";
 import {
 	createSessionPickerResumeCandidateCache,
@@ -81,6 +81,7 @@ export function openSessionPicker(
 		const state = createSessionPickerState();
 		let settled = false;
 		let unsubscribe: (() => void) | null = null;
+		let pickerRevision = 0;
 
 		const resumeCandidateCache = createSessionPickerResumeCandidateCache();
 
@@ -100,16 +101,16 @@ export function openSessionPicker(
 			};
 			// Re-render on store changes so newly-started runs appear and
 			// status icons refresh without the user having to press a key.
-			// Read one memoized payload-free projection per render rather than
-			// caching a snapshot from the subscription callback: the
-			// invalidation channel carries no snapshot, so a cached one would
-			// go stale and newly-started runs would never appear.
+			// The picker only needs live run references for rendering; a small local
+			// revision keeps resume-probe caching coherent without cloning the store.
 			const selectRows = (): ReturnType<typeof selectRunsForPicker> => {
-				const snapshot = readGraphStoreSnapshot(store);
+				const liveRuns = store.runs();
 				const resumeCandidateLookup =
-					intent === "resume" ? resumeCandidateCache({ ...snapshot, runs: store.runs() }) : undefined;
+					intent === "resume"
+						? resumeCandidateCache({ runs: liveRuns, notices: store.notices(), version: pickerRevision })
+						: undefined;
 				return selectRunsForPicker(
-					snapshot.runs,
+					liveRuns,
 					state.query,
 					state.includeAll,
 					Date.now(),
@@ -117,11 +118,14 @@ export function openSessionPicker(
 					resumeCandidateLookup,
 				);
 			};
-			unsubscribe = subscribeStoreInvalidation(store, () => tui.requestRender?.());
+			unsubscribe = subscribeStoreInvalidation(store, () => {
+				pickerRevision++;
+				tui.requestRender?.();
+			});
 			return {
 				render: (width: number) => {
 					const rows = selectRows();
-					return renderSessionPicker({ width, theme, rows, state });
+					return renderSessionPicker({ width, theme, rows, state, allRuns: store.runs() });
 				},
 				handleInput: (data: string) => {
 					const rows = selectRows();