@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/workflows/src/shared/authoring-contract-stage.ts

@@ -31,10 +31,16 @@ export type WorkflowOutputMode = "inline" | "file-only";
 export type WorkflowContextMode = "fresh" | "fork";
 export type WorkflowThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type WorkflowExecutionMode = "interactive" | "non_interactive";
-export type WorkflowExitStatus = "completed" | "skipped" | "cancelled" | "blocked";
-export type RunStatus = "pending" | "running" | "paused" | WorkflowExitStatus | "failed" | "killed";
+export type WorkflowExitStatus = "completed" | "skipped" | "cancelled" | "blocked" | "failed";
+export type RunStatus = "pending" | "running" | "paused" | WorkflowExitStatus | "killed";
+
+/**
+ * Who performed a workflow lifecycle action. Mirrors the store-side union; the
+ * authoring contract keeps its own copy so it stays independent of store types.
+ */
+export type WorkflowActor = "user" | "agent";
 export type WorkflowDetailsMode = "named" | "inspection" | "control";
-export type WorkflowDetailsStatus = "accepted" | "running" | WorkflowExitStatus | "failed" | "killed" | "noop";
+export type WorkflowDetailsStatus = "accepted" | "running" | WorkflowExitStatus | "killed" | "noop";
 export type WorkflowAction = "list" | "get" | "inputs" | "run" | "status" | "interrupt" | "resume";
 
 type WorkflowExitOutputValues<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> = [keyof TOutputs] extends [
@@ -46,6 +52,8 @@ type WorkflowExitOutputValues<TOutputs extends WorkflowOutputValues = WorkflowOu
 export interface WorkflowExitOptions<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> {
 	readonly status?: WorkflowExitStatus;
 	readonly reason?: string;
+	/** Failed exits are non-resumable by default; set this only when retry is intended. */
+	readonly resumable?: boolean;
 	readonly outputs?: WorkflowExitOutputValues<TOutputs>;
 }
 

package/dist/builtin/workflows/src/shared/authoring-contract-ui.d.ts

@@ -2,7 +2,7 @@
 import type { KeybindingsManager, Theme } from "@bastani/atomic";
 import type { Component, OverlayHandle, OverlayOptions, TUI } from "@earendil-works/pi-tui";
 import type { TSchema } from "typebox";
-import type { RunStatus, StageAdapters, StageContext, StageOptions, WorkflowAction, WorkflowArtifact, WorkflowChainOptions, WorkflowChildResult, WorkflowContextMode, WorkflowDetailsMode, WorkflowDetailsStatus, WorkflowExecutionMode, WorkflowExitOptions, WorkflowInputSchemaMap, WorkflowInputValues, WorkflowMcpPort, WorkflowModelCatalogPort, WorkflowOutputSchemaMap, WorkflowOutputValues, WorkflowParallelOptions, WorkflowPersistencePort, WorkflowRunChildArgs, WorkflowSerializableObject, WorkflowSerializableValue, WorkflowTaskOptions, WorkflowTaskResult, WorkflowTaskStep } from "./authoring-contract-stage.js";
+import type { RunStatus, StageAdapters, StageContext, StageOptions, WorkflowAction, WorkflowActor, WorkflowArtifact, WorkflowChainOptions, WorkflowChildResult, WorkflowContextMode, WorkflowDetailsMode, WorkflowDetailsStatus, WorkflowExecutionMode, WorkflowExitOptions, WorkflowInputSchemaMap, WorkflowInputValues, WorkflowMcpPort, WorkflowModelCatalogPort, WorkflowOutputSchemaMap, WorkflowOutputValues, WorkflowParallelOptions, WorkflowPersistencePort, WorkflowRunChildArgs, WorkflowSerializableObject, WorkflowSerializableValue, WorkflowTaskOptions, WorkflowTaskResult, WorkflowTaskStep } from "./authoring-contract-stage.js";
 export type WorkflowCustomUiComponent = Component & {
     dispose?(): void;
 };
@@ -208,6 +208,10 @@ export interface RunOpts {
     readonly toolAdmissionBoundary?: object;
     readonly runId?: string;
     readonly continuation?: RunContinuationOpts;
+    /** Who launched this run. A continuation inherits its source run's origin instead. */
+    readonly origin?: WorkflowActor;
+    /** Who requested the resume that produced this continuation run. */
+    readonly resumeActor?: WorkflowActor;
     readonly parentRun?: WorkflowParentRunLink;
     readonly onRunStart?: (snapshot: RunSnapshot) => void;
     readonly onStageStart?: (runId: string, snapshot: StageSnapshot) => void;

package/dist/builtin/workflows/src/shared/authoring-contract-ui.ts

@@ -9,6 +9,7 @@ import type {
 	StageContext,
 	StageOptions,
 	WorkflowAction,
+	WorkflowActor,
 	WorkflowArtifact,
 	WorkflowChainOptions,
 	WorkflowChildResult,
@@ -298,6 +299,10 @@ export interface RunOpts {
 	readonly toolAdmissionBoundary?: object;
 	readonly runId?: string;
 	readonly continuation?: RunContinuationOpts;
+	/** Who launched this run. A continuation inherits its source run's origin instead. */
+	readonly origin?: WorkflowActor;
+	/** Who requested the resume that produced this continuation run. */
+	readonly resumeActor?: WorkflowActor;
 	readonly parentRun?: WorkflowParentRunLink;
 	readonly onRunStart?: (snapshot: RunSnapshot) => void;
 	readonly onStageStart?: (runId: string, snapshot: StageSnapshot) => void;

package/dist/builtin/workflows/src/shared/graph-store-snapshot.ts

@@ -13,6 +13,7 @@ import type {
 import type { WorkflowOutputValues, WorkflowSerializableValue } from "./types.js";
 
 export const COMPACT_RESULT_FIELD_LIMIT = 1024;
+const COMPACT_EXIT_OUTPUT_LIMIT = COMPACT_RESULT_FIELD_LIMIT * 4;
 
 function compactResultField(value: WorkflowSerializableValue | undefined): string | undefined {
 	if (typeof value !== "string") return undefined;
@@ -22,7 +23,10 @@ function compactResultField(value: WorkflowSerializableValue | undefined): strin
 	return flattenTruncatedString(value.slice(0, COMPACT_RESULT_FIELD_LIMIT));
 }
 
-function compactRunResult(result: WorkflowOutputValues | undefined): WorkflowOutputValues | undefined {
+function compactRunResult(
+	result: WorkflowOutputValues | undefined,
+	preserveExitedOutputs = false,
+): WorkflowOutputValues | undefined {
 	if (result === undefined) return undefined;
 	const status = compactResultField(result.status);
 	const summary = compactResultField(result.summary);
@@ -34,9 +38,37 @@ function compactRunResult(result: WorkflowOutputValues | undefined): WorkflowOut
 		...(remainingWork !== undefined ? { remaining_work: remainingWork } : {}),
 		...(resultText !== undefined ? { result: resultText } : {}),
 	};
+	if (!preserveExitedOutputs) return Object.keys(compact).length === 0 ? undefined : compact;
+	return compactExitedOutputs(result, compact);
+}
+
+function compactExitedOutputs(
+	result: WorkflowOutputValues,
+	compact: WorkflowOutputValues,
+): WorkflowOutputValues | undefined {
+	try {
+		const serialized = JSON.stringify(result);
+		if (serialized !== undefined && serialized.length <= COMPACT_EXIT_OUTPUT_LIMIT) {
+			const parsed: unknown = JSON.parse(serialized);
+			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+				return compactExitedObject(parsed as Record<string, WorkflowSerializableValue>);
+			}
+		}
+	} catch {
+		// Fall through to the bounded legacy fields below.
+	}
 	return Object.keys(compact).length === 0 ? undefined : compact;
 }
 
+function compactExitedObject(result: Record<string, WorkflowSerializableValue>): WorkflowOutputValues | undefined {
+	const compacted = { ...result };
+	for (const key of ["status", "summary", "remaining_work", "result"]) {
+		const value = compacted[key];
+		if (typeof value === "string") compacted[key] = compactResultField(value) ?? "";
+	}
+	return Object.keys(compacted).length === 0 ? undefined : compacted;
+}
+
 // Both cloners are called only from a `!== undefined` guard at their call sites,
 // so they take and return a concrete value; an internal undefined branch here
 // would be unreachable and would only weaken the type for every caller.
@@ -106,7 +138,7 @@ function compactToolNode(node: ToolNodeSnapshot): ToolNodeSnapshot {
 
 function compactRun(run: RunSnapshot): RunSnapshot {
 	const { inputs: _inputs, result: sourceResult, stages, toolNodes, pendingPrompt, ...metadata } = run;
-	const result = compactRunResult(sourceResult);
+	const result = compactRunResult(sourceResult, run.exited === true && run.status === "failed");
 	return {
 		...metadata,
 		inputs: {},

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

@@ -7,6 +7,7 @@ import type {
 	StageSnapshot,
 	StageStatus,
 	ToolNodeSnapshot,
+	WorkflowActor,
 	WorkflowFailureCode,
 	WorkflowFailureDisposition,
 	WorkflowFailureKind,
@@ -189,7 +190,13 @@ export function serializableObjectOrEmpty(value: unknown): WorkflowOutputValues
 }
 
 function isWorkflowChildReplayStatus(status: unknown): status is WorkflowExitStatus {
-	return status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked";
+	return (
+		status === "completed" ||
+		status === "skipped" ||
+		status === "cancelled" ||
+		status === "blocked" ||
+		status === "failed"
+	);
 }
 
 function workflowChildMetadata(payload: Record<string, unknown>): Pick<StageSnapshot, "workflowChild"> {
@@ -234,9 +241,11 @@ function workflowChildMetadata(payload: Record<string, unknown>): Pick<StageSnap
 			status,
 			...(typeof exited === "boolean"
 				? { exited }
-				: status !== "completed" || typeof exitReason === "string"
-					? { exited: true }
-					: {}),
+				: status === "failed"
+					? {}
+					: status !== "completed" || typeof exitReason === "string"
+						? { exited: true }
+						: {}),
 			outputs: clonedOutputs,
 			...(typeof exitReason === "string" ? { exitReason } : {}),
 		},
@@ -387,8 +396,11 @@ export function restoreTerminalRuns(entries: readonly SessionEntry[], store: Sto
 		const resumable = end.resumable;
 		const failedToolNodeId = end.failedToolNodeId;
 		const failedToolNode = restoreFailedToolNode(end.failedToolNode);
+		// Failed is both an author-exit status and the engine's ordinary failure
+		// status, so an exit reason alone cannot establish author intent.
 		const restoredAuthorExit =
-			isWorkflowExitTerminalStatus(status) && (exited === true || typeof exitReason === "string");
+			isWorkflowExitTerminalStatus(status) &&
+			(exited === true || (status !== "failed" && typeof exitReason === "string"));
 		if (status === "completed" && !restoredAuthorExit && stages.some((stage) => stage.status !== "completed"))
 			continue;
 		store.recordRunStart({
@@ -406,6 +418,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 }
 				: {}),
@@ -454,7 +467,13 @@ export function restoreTerminalRuns(entries: readonly SessionEntry[], store: Sto
 }
 
 function isWorkflowExitTerminalStatus(status: RunStatus): status is WorkflowExitStatus {
-	return status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked";
+	return (
+		status === "completed" ||
+		status === "skipped" ||
+		status === "cancelled" ||
+		status === "blocked" ||
+		status === "failed"
+	);
 }
 
 function restoreTerminalRunStatus(status: unknown): RunStatus | undefined {
@@ -481,6 +500,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 +510,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 +522,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/stage-ui-broker.ts

@@ -1,6 +1,12 @@
 import { randomUUID } from "node:crypto";
 import type { Component, Focusable, TUI } from "@earendil-works/pi-tui";
-import type { PiCustomOverlayFactory, PiCustomOverlayOptions, PiKeybindings, PiTheme } from "../extension/wiring.js";
+import type {
+	PiCustomComponent,
+	PiCustomOverlayFactory,
+	PiCustomOverlayOptions,
+	PiKeybindings,
+	PiTheme,
+} from "../extension/wiring.js";
 import type { StageInputAnswer, StagePromptAdapter } from "./stage-prompt.js";
 import type { StagePromptAnswerSource, Store } from "./store.js";
 import { store as defaultStore } from "./store.js";
@@ -280,7 +286,7 @@ export class StageUiBroker {
 
 export interface MountedStageCustomUi {
 	readonly request: StageCustomUiRequest;
-	readonly component: Component & { dispose?(): void };
+	readonly component: PiCustomComponent & { invalidate(): void; dispose?(): void } & Partial<Focusable>;
 }
 
 export async function mountStageCustomUi(
@@ -302,10 +308,10 @@ export async function mountStageCustomUi(
 			onDone?.();
 		},
 	);
-	const component: Component & { dispose?(): void } & Partial<Focusable> = {
+	const component: PiCustomComponent & { invalidate(): void; dispose?(): void } & Partial<Focusable> = {
 		render: (width) => rawComponent.render(width),
 		...(rawComponent.handleInput !== undefined
-			? { handleInput: (data: string) => rawComponent.handleInput?.(data) }
+			? { handleInput: (data: string): boolean => rawComponent.handleInput?.(data) === true }
 			: {}),
 		invalidate: () => rawComponent.invalidate?.(),
 		...(rawComponent.dispose !== undefined ? { dispose: () => rawComponent.dispose?.() } : {}),

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;
@@ -95,7 +117,7 @@ export interface Store {
 	 * Records the end of a run.
 	 * Returns `true` if state changed, `false` if the run was not found or
 	 * already in a terminal state (completed | failed | killed | skipped | cancelled | blocked).
-	 * `result` is applied for intentional success/exit statuses (completed | skipped | cancelled | blocked)
+	 * `result` is applied for intentional success/exit statuses (completed | skipped | cancelled | blocked | failed)
 	 * and for workflows that intentionally return a failed status with structured outputs.
 	 * `error` is applied for status "failed" | "killed" | "blocked".
 	 */
@@ -214,22 +236,38 @@ 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;
 	/**
-	 * Return one immutable payload-free graph projection per store version.
+	 * Return one immutable payload-bounded graph projection per store version.
+	 * Authored failed-exit results may retain bounded JSON output values; all
+	 * other run payloads stay omitted or compacted to bounded diagnostic fields.
 	 * Graph-visible state may change only through a version-bumping store method;
 	 * direct mutation of values returned by `runs()` would leave this cache stale.
 	 */

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;
 		},