@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/workflows/src/extension/lifecycle-notifications.ts

@@ -17,6 +17,7 @@ import type {
 	StageSnapshot,
 	StageStatus,
 	StoreSnapshot,
+	WorkflowActor,
 } from "../shared/store-types.js";
 import { deriveGraphThemeFromPiTheme, type GraphTheme } from "../tui/graph-theme.js";
 import { renderWorkflowNoticeCard, type WorkflowNoticeTone } from "../tui/workflow-notice-card.js";
@@ -26,13 +27,33 @@ import { createLifecycleNoticeDelivery } from "./lifecycle-notification-delivery
 export const LIFECYCLE_NOTICE_CUSTOM_TYPE = "workflows:lifecycle-notice";
 export const LIFECYCLE_NOTICE_SNIPPET_LIMIT = 240;
 
-export type WorkflowLifecycleNoticeKind = "completed" | "failed" | "blocked" | "awaiting_input";
+export type WorkflowLifecycleNoticeKind =
+	| "started"
+	| "completed"
+	| "failed"
+	| "blocked"
+	| "awaiting_input"
+	| "paused"
+	| "quit"
+	| "resumed";
+
+/**
+ * Control-action kinds. Unlike terminal outcomes these are reversible and can
+ * repeat, so their dedupe keys carry the occurrence timestamp rather than the
+ * run id alone, and they are reported only when a control path attributed the
+ * action to a user.
+ */
+type WorkflowControlNoticeKind = "started" | "paused" | "quit" | "resumed";
 
 export const WORKFLOW_LIFECYCLE_NOTICE_KINDS = [
+	"started",
 	"completed",
 	"failed",
 	"blocked",
 	"awaiting_input",
+	"paused",
+	"quit",
+	"resumed",
 ] as const satisfies readonly WorkflowLifecycleNoticeKind[];
 
 export interface WorkflowLifecycleNotificationConfig {
@@ -57,6 +78,14 @@ export interface WorkflowLifecycleNoticeDetails {
 	readonly toolName?: string;
 	readonly durationMs?: number;
 	readonly active?: boolean;
+	/** Whether a quit run advertises itself as resumable. */
+	readonly resumable?: boolean;
+	/** Who performed this lifecycle action, when a control path attributed it. */
+	readonly actor?: WorkflowActor;
+	/** Who launched the run, when the launch was attributed. */
+	readonly origin?: WorkflowActor;
+	/** Source run this run continues, for a resumed continuation with a fresh id. */
+	readonly continuedFromRunId?: string;
 	readonly createdAt: number;
 }
 
@@ -118,6 +147,12 @@ export function seedWorkflowLifecycleNotificationState(
 				state.deliveredTerminalRuns.add(key);
 			}
 		}
+		for (const occurrence of controlOccurrences(run)) {
+			const controlKey = controlOccurrenceKey(run, occurrence);
+			if (!state.pendingTerminalRuns.has(controlKey) && !state.retryableTerminalRuns.has(controlKey)) {
+				state.deliveredTerminalRuns.add(controlKey);
+			}
+		}
 		if (run.pendingPrompt !== undefined) {
 			state.deliveredInputPrompts.add(runAwaitingInputKey(run.id, run.pendingPrompt));
 		}
@@ -227,6 +262,26 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 		delivery.deliver(key, makeTerminalNotice(run, kind));
 	};
 
+	const emitControlNoticesOnce = (run: RunSnapshot): void => {
+		for (const occurrence of controlOccurrences(run)) {
+			if (!notifyOn.has(occurrence.kind)) continue;
+			const key = controlOccurrenceKey(run, occurrence);
+			if (
+				state.deliveredTerminalRuns.has(key) ||
+				state.pendingTerminalRuns.has(key) ||
+				state.retryableTerminalRuns.has(key)
+			)
+				continue;
+			if (state.suppressionDepth > 0) {
+				state.deliveredTerminalRuns.add(key);
+				state.retryableTerminalRuns.delete(key);
+				state.retryableTerminalNotices.delete(key);
+				continue;
+			}
+			delivery.deliver(key, makeControlNotice(run, occurrence));
+		}
+	};
+
 	const emitStageAwaitingInputNoticeOnce = (run: RunSnapshot, stage: StageSnapshot): void => {
 		if (stage.status !== "awaiting_input") return;
 
@@ -256,6 +311,7 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 			emitTerminalNoticeOnce(run, "completed");
 			emitTerminalNoticeOnce(run, "failed");
 			emitTerminalNoticeOnce(run, "blocked");
+			emitControlNoticesOnce(run);
 
 			if (!notifyOn.has("awaiting_input")) continue;
 			emitRunAwaitingInputNoticeOnce(run);
@@ -298,20 +354,51 @@ export function registerLifecycleNoticeRenderer(
 
 export function formatWorkflowLifecycleNoticeText(details: WorkflowLifecycleNoticeDetails): string {
 	const workflowName = escapeQuotedText(details.workflowName);
+	// "which you started" / "which the user started". Omitted entirely when the
+	// run carries no recorded origin, rather than guessing one.
+	const origin =
+		details.origin === undefined
+			? ""
+			: details.origin === "agent"
+				? ", which you started"
+				: ", which the user started";
+	const actor = details.actor === "agent" ? "You" : "The user";
+	if (details.kind === "started") {
+		return `▶ ${actor} started workflow "${workflowName}" (run ${details.runId}). It is running in the background; you will be notified when it completes.`;
+	}
 	if (details.kind === "completed") {
-		return `✓ Workflow "${workflowName}" completed (run ${details.runId}). Inspect: /workflow status ${details.runId}`;
+		return `✓ Workflow "${workflowName}" completed (run ${details.runId})${origin}. Inspect: /workflow status ${details.runId}`;
 	}
 	if (details.kind === "failed") {
 		const stage = details.stageName ?? details.failedStageId ?? details.stageId;
 		const tool = lifecycleToolOrigin(details);
-		const originText = stage ? `, stage ${stage}` : tool !== undefined ? `, tool ${tool}` : "";
+		const failureSite = stage ? `, stage ${stage}` : tool !== undefined ? `, tool ${tool}` : "";
 		const errorText = details.error ? `: ${details.error}` : "";
-		return `✗ Workflow "${workflowName}" failed (run ${details.runId}${originText})${errorText}. Inspect: /workflow status ${details.runId}`;
+		return `✗ Workflow "${workflowName}" failed (run ${details.runId}${failureSite})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
 	}
 	if (details.kind === "blocked") {
 		const errorText = details.error ? `: ${details.error}` : "";
 		const stateText = details.active === true ? "is blocked" : "ended blocked";
-		return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${errorText}. Inspect: /workflow status ${details.runId}`;
+		return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
+	}
+	if (details.kind === "paused" || details.kind === "quit") {
+		const stopStage = details.stageName ?? details.stageId;
+		// "(run 8c31), which you started, at stage review" — the stage clause takes a
+		// separating comma only when an origin clause precedes it.
+		const stageText = stopStage ? `${origin === "" ? "" : ","} at stage ${stopStage}` : "";
+		const scopeText = details.scope === "stage" ? "stage of workflow" : "workflow";
+		const verb = details.kind === "paused" ? "paused" : "quit";
+		const noun = details.kind === "paused" ? "pause" : "stop";
+		const glyph = details.kind === "paused" ? "⏸" : "⏹";
+		return `${glyph} ${actor} ${verb} the ${scopeText} "${workflowName}" (run ${details.runId})${origin}${stageText}. This ${noun} was deliberate and user-requested; do not resume it or take over the work unless asked. Resume: /workflow resume ${details.runId}`;
+	}
+	if (details.kind === "resumed") {
+		const resumedStage = details.stageName ?? details.stageId;
+		const stageText = resumedStage ? `${origin === "" ? "" : ","} at stage ${resumedStage}` : "";
+		const scopeText = details.scope === "stage" ? "stage of workflow" : "workflow";
+		const continues =
+			details.continuedFromRunId === undefined ? "" : `, continuing run ${details.continuedFromRunId}`;
+		return `▶ ${actor} resumed the ${scopeText} "${workflowName}" (run ${details.runId}${continues})${origin}${stageText}. It is running again in the background.`;
 	}
 	const prompt = details.promptMessage ? ` Prompt: ${details.promptMessage}` : "";
 	if (details.scope === "run") {
@@ -349,10 +436,42 @@ function makeTerminalNotice(
 		...(failedToolNodeId !== undefined ? { toolNodeId: failedToolNodeId } : {}),
 		...(failedTool !== undefined ? { toolName: failedTool.name } : {}),
 		...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}),
+		// Attribution renders on every kind, and is omitted for a run that never
+		// recorded an origin rather than guessed at.
+		...(run.origin !== undefined ? { origin: run.origin } : {}),
 		createdAt: lifecycleOccurrenceAt(run, kind) ?? Date.now(),
 	};
 }
 
+function makeControlNotice(run: RunSnapshot, occurrence: ControlOccurrence): WorkflowLifecycleNoticeDetails {
+	const stage = occurrence.stage ?? restingStage(run);
+	const elapsedMs = run.durationMs ?? (occurrence.at >= run.startedAt ? occurrence.at - run.startedAt : undefined);
+	return {
+		kind: occurrence.kind,
+		scope: occurrence.scope,
+		runId: run.id,
+		workflowName: run.name,
+		status: occurrence.stage !== undefined ? occurrence.stage.status : run.status,
+		...(stage !== undefined ? { stageId: stage.id, stageName: stage.name } : {}),
+		...(elapsedMs !== undefined ? { durationMs: elapsedMs } : {}),
+		...(occurrence.kind === "quit" && run.resumable !== undefined ? { resumable: run.resumable } : {}),
+		...(occurrence.actor !== undefined ? { actor: occurrence.actor } : {}),
+		// The origin clause is omitted entirely for a run that never recorded one.
+		...(occurrence.kind !== "started" && run.origin !== undefined ? { origin: run.origin } : {}),
+		...(occurrence.kind === "resumed" && run.resumedFromRunId !== undefined
+			? { continuedFromRunId: run.resumedFromRunId }
+			: {}),
+		createdAt: occurrence.at,
+	};
+}
+
+/** The stage a run currently rests on, preferring an explicitly paused one. */
+function restingStage(run: RunSnapshot): StageSnapshot | undefined {
+	return (
+		run.stages.find((stage) => stage.status === "paused") ?? run.stages.find((stage) => stage.status === "running")
+	);
+}
+
 function warnLifecycleSendFailure(error: unknown): void {
 	if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1") return;
 	const message = error instanceof Error ? error.message : String(error);
@@ -400,6 +519,87 @@ function terminalRunKey(kind: "completed" | "failed" | "blocked", run: RunSnapsh
 	return occurrence === undefined ? `${kind}:${run.id}` : `${kind}:${run.id}:${occurrence}`;
 }
 
+/** One deliberate control action a run currently carries. */
+interface ControlOccurrence {
+	readonly kind: WorkflowControlNoticeKind;
+	readonly scope: "run" | "stage";
+	readonly at: number;
+	readonly actor: WorkflowActor;
+	readonly stage?: StageSnapshot;
+}
+
+/**
+ * Every control action this run currently carries that a user actually asked
+ * for.
+ *
+ * Attribution, not the status transition, is the trigger. A run passes through
+ * paused on its way to a quit, and the engine resumes a run whenever a
+ * human-in-the-loop prompt is answered or a stage control acknowledges; none of
+ * those record an actor, so none of them reach the chat. Only a control path
+ * that names its caller does, and it names exactly one scope per request, which
+ * is what keeps a stage card and a run card from reporting the same event.
+ */
+function controlOccurrences(run: RunSnapshot): ControlOccurrence[] {
+	const occurrences: ControlOccurrence[] = [];
+	// Whether this run exists because someone resumed work, whoever asked for it.
+	// A durable resume reuses the original run id (issue #1498) and a failed-run
+	// continuation takes a fresh one; both re-enter `recordRunStart`, and neither
+	// is a new run to the user. Keying the start suppression on the resume itself
+	// rather than on who requested it is what keeps an agent-requested resume of a
+	// user-started run from being announced as a fresh launch.
+	const resumedRun = run.resumeSource === "run_control" || run.resumedFromRunId !== undefined;
+	const userResumed = run.resumeSource === "run_control" && run.resumeActor === "user";
+	// A resumed run that never paused in this session reports its start timestamp:
+	// the re-dispatch is the occurrence.
+	const continuation = userResumed && run.resumedAt === undefined;
+	if (run.origin === "user" && !resumedRun) {
+		occurrences.push({ kind: "started", scope: "run", at: run.startedAt, actor: "user" });
+	}
+	if (userResumed && run.status === "running") {
+		occurrences.push({
+			kind: "resumed",
+			scope: "run",
+			at: continuation ? run.startedAt : (run.resumedAt ?? run.startedAt),
+			actor: "user",
+		});
+	}
+	if (run.endedAt === undefined && run.status === "paused" && run.pauseActor === "user") {
+		if (run.exitReason === "quit") {
+			const quitAt = run.quitAt ?? run.pausedAt;
+			if (quitAt !== undefined) occurrences.push({ kind: "quit", scope: "run", at: quitAt, actor: "user" });
+		} else if (run.pausedAt !== undefined) {
+			occurrences.push({ kind: "paused", scope: "run", at: run.pausedAt, actor: "user" });
+		}
+	}
+	const runScoped = new Set(occurrences.map((occurrence) => occurrence.kind));
+	if (run.endedAt !== undefined) return occurrences;
+	for (const stage of run.stages) {
+		if (stage.status === "paused" && stage.pauseActor === "user" && stage.pausedAt !== undefined) {
+			if (!runScoped.has("paused") && !runScoped.has("quit")) {
+				occurrences.push({ kind: "paused", scope: "stage", at: stage.pausedAt, actor: "user", stage });
+			}
+		}
+		if (stage.status === "running" && stage.resumeActor === "user" && stage.resumedAt !== undefined) {
+			if (!runScoped.has("resumed")) {
+				occurrences.push({ kind: "resumed", scope: "stage", at: stage.resumedAt, actor: "user", stage });
+			}
+		}
+	}
+	return occurrences;
+}
+
+/**
+ * Control actions are repeatable, so the occurrence timestamp is part of the
+ * key: resuming clears `pausedAt`/`quitAt`, and the next pause mints a new key
+ * while repeated invalidations at one unchanged state reuse the delivered one.
+ */
+function controlOccurrenceKey(run: RunSnapshot, occurrence: ControlOccurrence): string {
+	if (occurrence.scope === "stage" && occurrence.stage !== undefined) {
+		return `${occurrence.kind}:${run.id}:stage:${occurrence.stage.id}:${occurrence.at}`;
+	}
+	return `${occurrence.kind}:${run.id}:${occurrence.at}`;
+}
+
 function awaitingInputKey(runId: string, stage: StageSnapshot): string {
 	const promptId = stage.pendingPrompt?.id ?? stage.inputRequest?.id;
 	if (promptId) return `awaiting_input:${runId}:stage:${stage.id}:${promptId}`;
@@ -439,38 +639,12 @@ function renderLifecycleNoticeCard(
 	details: WorkflowLifecycleNoticeDetails,
 	opts: { width: number; theme?: GraphTheme; fallbackText: string },
 ): string[] {
-	const tone: WorkflowNoticeTone =
-		details.kind === "failed"
-			? "error"
-			: details.kind === "awaiting_input" || details.kind === "blocked"
-				? "warning"
-				: "success";
-	const title =
-		details.kind === "failed"
-			? "WORKFLOW FAILED"
-			: details.kind === "awaiting_input"
-				? "WORKFLOW INPUT"
-				: details.kind === "blocked"
-					? "WORKFLOW BLOCKED"
-					: "WORKFLOW COMPLETE";
-	const glyph =
-		details.kind === "failed"
-			? "✗"
-			: details.kind === "awaiting_input"
-				? "？"
-				: details.kind === "blocked"
-					? "!"
-					: "✓";
+	const tone: WorkflowNoticeTone = lifecycleNoticeTone(details.kind);
+	const title = lifecycleNoticeTitle(details.kind);
+	const glyph = lifecycleNoticeGlyph(details.kind);
 	const stage = details.stageName ?? details.failedStageId ?? details.stageId;
 	const tool = stage === undefined ? lifecycleToolOrigin(details) : undefined;
-	const headline =
-		details.kind === "failed"
-			? `Workflow "${details.workflowName}" failed`
-			: details.kind === "awaiting_input"
-				? `Workflow "${details.workflowName}" needs input`
-				: details.kind === "blocked"
-					? `Workflow "${details.workflowName}" ${details.active === true ? "is blocked" : "ended blocked"}`
-					: `Workflow "${details.workflowName}" completed`;
+	const headline = lifecycleNoticeHeadline(details);
 	return renderWorkflowNoticeCard({
 		title,
 		glyph,
@@ -479,21 +653,112 @@ function renderLifecycleNoticeCard(
 		fields: [
 			{ label: "workflow", value: details.workflowName },
 			{ label: "run", value: details.runId },
+			{ label: "continues", value: details.continuedFromRunId },
 			{ label: "stage", value: stage },
 			{ label: "tool", value: tool },
+			{ label: "actor", value: details.actor, tone: "muted" },
+			{ label: "launched", value: details.origin, tone: "muted" },
 			{ label: "prompt", value: details.promptMessage, tone: "muted" },
 			{ label: "error", value: details.error, tone: "error" },
+			{ label: "resumable", value: resumableFieldValue(details), tone: "muted" },
 			{ label: "duration", value: formatDurationMs(details.durationMs), tone: "muted" },
 		],
-		hints: [
-			details.kind === "awaiting_input" ? `/workflow connect ${details.runId}` : `/workflow status ${details.runId}`,
-		],
+		hints: [lifecycleNoticeHint(details)],
 		fallbackText: opts.fallbackText,
 		width: opts.width,
 		...(opts.theme ? { theme: opts.theme } : {}),
 	});
 }
 
+function lifecycleNoticeTone(kind: WorkflowLifecycleNoticeKind): WorkflowNoticeTone {
+	switch (kind) {
+		case "failed":
+			return "error";
+		case "blocked":
+		case "awaiting_input":
+		case "paused":
+		case "quit":
+			return "warning";
+		default:
+			return "success";
+	}
+}
+
+function lifecycleNoticeTitle(kind: WorkflowLifecycleNoticeKind): string {
+	switch (kind) {
+		case "started":
+			return "WORKFLOW STARTED";
+		case "failed":
+			return "WORKFLOW FAILED";
+		case "awaiting_input":
+			return "WORKFLOW INPUT";
+		case "blocked":
+			return "WORKFLOW BLOCKED";
+		case "paused":
+			return "WORKFLOW PAUSED";
+		case "quit":
+			return "WORKFLOW QUIT";
+		case "resumed":
+			return "WORKFLOW RESUMED";
+		default:
+			return "WORKFLOW COMPLETE";
+	}
+}
+
+function lifecycleNoticeGlyph(kind: WorkflowLifecycleNoticeKind): string {
+	switch (kind) {
+		case "failed":
+			return "✗";
+		case "awaiting_input":
+			return "？";
+		case "blocked":
+			return "!";
+		case "paused":
+			return "⏸";
+		case "quit":
+			return "⏹";
+		case "started":
+		case "resumed":
+			return "▶";
+		default:
+			return "✓";
+	}
+}
+
+function lifecycleNoticeHeadline(details: WorkflowLifecycleNoticeDetails): string {
+	const name = details.workflowName;
+	const scope = details.scope === "stage" ? "Stage of workflow" : "Workflow";
+	switch (details.kind) {
+		case "started":
+			return `Workflow "${name}" started`;
+		case "failed":
+			return `Workflow "${name}" failed`;
+		case "awaiting_input":
+			return `Workflow "${name}" needs input`;
+		case "blocked":
+			return `Workflow "${name}" ${details.active === true ? "is blocked" : "ended blocked"}`;
+		case "paused":
+			return `${scope} "${name}" paused`;
+		case "quit":
+			return `Workflow "${name}" quit`;
+		case "resumed":
+			return `${scope} "${name}" resumed`;
+		default:
+			return `Workflow "${name}" completed`;
+	}
+}
+
+function lifecycleNoticeHint(details: WorkflowLifecycleNoticeDetails): string {
+	if (details.kind === "awaiting_input") return `/workflow connect ${details.runId}`;
+	if (details.kind === "paused" || details.kind === "quit") return `/workflow resume ${details.runId}`;
+	return `/workflow status ${details.runId}`;
+}
+
+function resumableFieldValue(details: WorkflowLifecycleNoticeDetails): string | undefined {
+	if (details.resumable === undefined) return undefined;
+	return details.resumable ? "yes" : "no";
+}
+
 function formatDurationMs(durationMs: number | undefined): string | undefined {
 	if (durationMs === undefined) return undefined;
 	if (durationMs < 1000) return `${durationMs}ms`;

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -32,6 +32,7 @@ import { truncateToWidth } from "../tui/text-helpers.js";
 import { renderWorkflowList } from "../tui/workflow-list.js";
 import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 import type { WorkflowRunStatusFilter, WorkflowRunStatusSummary } from "./workflow-status-summary.js";
+import { getWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
 
 // ---------------------------------------------------------------------------
 // Result variants
@@ -240,6 +241,8 @@ export interface RenderResultOpts {
 	 * not implement synchronized output (e.g. mosh).
 	 */
 	now?: number;
+	/** Point-in-time full run collection used only to resolve hidden nested indicators. */
+	allRuns?: readonly RunSnapshot[];
 }
 
 /**
@@ -335,6 +338,7 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 				theme: themed ? deriveGraphTheme({}) : undefined,
 				width: opts?.width,
 				now: opts?.now,
+				allRuns: opts?.allRuns ?? getWorkflowStatusRenderRuns(r) ?? r.snapshots,
 			});
 		}
 

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

@@ -18,7 +18,7 @@ import type { JobTracker } from "../runs/background/job-tracker.js";
 import type { RunOpts } from "../runs/foreground/executor.js";
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
 import type { Store } from "../shared/store.js";
-import type { RunSnapshot } from "../shared/store-types.js";
+import type { RunSnapshot, WorkflowActor } from "../shared/store-types.js";
 import type { WorkflowExecutionPolicy } from "../shared/types.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import { discoverWorkflows } from "./discovery.js";
@@ -26,7 +26,7 @@ import { discoverWorkflows } from "./discovery.js";
 export interface DurableResumeRuntime {
 	resumeDurableWorkflow(
 		workflowId: string,
-		options?: { readonly policy?: WorkflowExecutionPolicy },
+		options?: { readonly policy?: WorkflowExecutionPolicy; readonly actor?: WorkflowActor },
 	): Promise<ResumeDurableResult>;
 	listDurableResumable(): readonly ResumableWorkflowEntry[];
 	prepareDurableResumable(workflowId?: string): Promise<readonly ResumableWorkflowEntry[]>;
@@ -75,7 +75,10 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 			if (resolved !== undefined) await backend.hydrateWorkflow(resolved.workflowId);
 			const adapterDeps: ResumeDurableDeps = {
 				registry: deps.registry,
-				baseRunOpts: deps.baseRunOpts(options?.policy),
+				baseRunOpts: {
+					...deps.baseRunOpts(options?.policy),
+					...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
+				},
 				durableBackend: backend,
 				resolveDefinition: async (name, cwd) =>
 					(await discoverWorkflows({ cwd: cwd ?? deps.runtimeCwd })).registry.get(name),

package/dist/builtin/workflows/src/extension/runtime.ts

@@ -18,7 +18,7 @@ import { type RunOpts, resolveAndValidateInputs } from "../runs/foreground/execu
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
 import type { Store } from "../shared/store.js";
 import { store as defaultStore } from "../shared/store.js";
-import type { RunSnapshot } from "../shared/store-types.js";
+import type { RunSnapshot, WorkflowActor } from "../shared/store-types.js";
 import type {
 	WorkflowDefinition,
 	WorkflowExecutionPolicy,
@@ -115,6 +115,10 @@ export interface ExtensionRuntime extends DurableResumeRuntime {
 }
 export interface RuntimeDispatchOptions {
 	readonly policy?: WorkflowExecutionPolicy;
+	/** Who launched this run. Only an attributable launcher supplies it. */
+	readonly origin?: WorkflowActor;
+	/** Who requested this resume. Only an attributable requester supplies it. */
+	readonly actor?: WorkflowActor;
 }
 // ---------------------------------------------------------------------------
 // Factory
@@ -266,6 +270,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 			launchDetachedUntilStartup(def, sourceInputs, {
 				...runOptions(options?.policy),
 				continuation: { source, resumeFromStageId: resolvedStage.stageId },
+				...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
 				...(jobs !== undefined ? { jobs } : {}),
 			});
 		if (isActiveBlockedResumable) {
@@ -393,6 +398,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 				config,
 				models,
 				policy: options?.policy,
+				...(options?.origin === undefined ? {} : { origin: options.origin }),
 				cwd: runtimeCwd,
 				...(defaultSessionDir !== undefined ? { defaultSessionDir } : {}),
 			});

package/dist/builtin/workflows/src/extension/wiring.ts

@@ -134,22 +134,64 @@ function isTestContext(): boolean {
 	return process.env.NODE_TEST_CONTEXT !== undefined || process.env.NODE_ENV === "test";
 }
 
+type StageSettingsManager = ReturnType<PiCodingAgentSdk["SettingsManager"]["create"]>;
+
+function attachSettingsManager(error: unknown, settingsManager: StageSettingsManager): unknown {
+	if (error !== null && (typeof error === "object" || typeof error === "function")) {
+		try {
+			if (Object.isExtensible(error)) {
+				Object.defineProperty(error, "settingsManager", {
+					configurable: true,
+					enumerable: false,
+					value: settingsManager,
+					writable: false,
+				});
+				return error;
+			}
+		} catch {
+			// Frozen or proxy errors cannot carry the private retry hint. Wrap them
+			// without replacing the original failure as the cause.
+		}
+	}
+	const wrapped = new Error(error instanceof Error ? error.message : String(error), { cause: error });
+	Object.defineProperty(wrapped, "settingsManager", {
+		configurable: true,
+		enumerable: false,
+		value: settingsManager,
+		writable: false,
+	});
+	return wrapped;
+}
+
 async function createPiSdkAgentSession(
 	options?: CreateAgentSessionOptions,
 	prepareOptions?: PrepareAtomicStageSessionOptions,
 ): Promise<StageSessionCreateResult> {
 	const sdk = (await import("@bastani/atomic")) as PiCodingAgentSdk;
-	const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk, prepareOptions);
-	const result = await sdk.createAgentSession(sessionOptions);
-	// `CreateAgentSessionResult` is `{ session, extensionsResult, modelFallbackMessage? }`;
-	// workflow stages only consume `.session` (structurally an `AgentSession`,
-	// which is a superset of our `StageSessionRuntime` projection).
-	const resultSettingsManager = result.session.settingsManager;
-	const settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager;
-	return {
-		session: result.session,
-		...(settingsManager?.getCodexFastModeSettings !== undefined ? { settingsManager } : {}),
-	};
+	let settingsManager: ReturnType<PiCodingAgentSdk["SettingsManager"]["create"]> | undefined;
+	try {
+		const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk, {
+			...prepareOptions,
+			onSettingsManager: (manager) => {
+				settingsManager = manager;
+				prepareOptions?.onSettingsManager?.(manager);
+			},
+		});
+		settingsManager = sessionOptions?.settingsManager ?? settingsManager;
+		const result = await sdk.createAgentSession(sessionOptions);
+		// `CreateAgentSessionResult` is `{ session, extensionsResult, modelFallbackMessage? }`;
+		// workflow stages only consume `.session` (structurally an `AgentSession`,
+		// which is a superset of our `StageSessionRuntime` projection).
+		const resultSettingsManager = result.session.settingsManager;
+		settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager ?? settingsManager;
+		return {
+			session: result.session,
+			...(settingsManager?.getCodexFastModeSettings !== undefined ? { settingsManager } : {}),
+		};
+	} catch (error) {
+		if (settingsManager !== undefined) throw attachSettingsManager(error, settingsManager);
+		throw error;
+	}
 }
 
 async function createTestAgentSession(_options?: CreateAgentSessionOptions): Promise<StageSessionCreateResult> {

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

@@ -1,5 +1,6 @@
 import { inspectRun } from "../runs/background/status.js";
 import { renderInputsSchema } from "../shared/render-inputs-schema.js";
+import { resolveRunIndicatorStatuses } from "../shared/run-indicator-status.js";
 import { schemaIsRequired } from "../shared/schema-introspection.js";
 import { store } from "../shared/store.js";
 import type { WorkflowExecutionPolicy } from "../shared/types.js";
@@ -158,8 +159,14 @@ async function workflowSlashHandler(
 			emitChatSurface(pi, { kind: "detail", detail: inspected.detail });
 			return;
 		}
-		const rows = selectRunsForPicker(store.runs(), "", true, Date.now());
-		emitChatSurface(pi, { kind: "status", runs: rows.map((r) => r.run) });
+		const capturedRuns = store.graphSnapshot().runs;
+		const rows = selectRunsForPicker(capturedRuns, "", true, Date.now());
+		const visibleRuns = rows.map((r) => r.run);
+		emitChatSurface(pi, {
+			kind: "status",
+			runs: visibleRuns,
+			indicatorStatuses: resolveRunIndicatorStatuses(visibleRuns, capturedRuns),
+		});
 		return;
 	}
 	if (subcommand === "reload") {
@@ -250,7 +257,9 @@ async function workflowSlashHandler(
 
 	await ensureWorkflowResourcesVisible();
 	const result = await deps.runWithLifecycleSuppressedForPolicy(policy, () =>
-		deps.runtimeForContext(ctx).dispatch({ workflow: workflowName, inputs: mergedInputs, action: "run" }, { policy }),
+		deps
+			.runtimeForContext(ctx)
+			.dispatch({ workflow: workflowName, inputs: mergedInputs, action: "run" }, { policy, origin: "user" }),
 	);
 	if (result.action !== "run" || !("runId" in result)) return;
 	const runResult = result as Extract<WorkflowToolResult, { action: "run"; runId: string }>;

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

@@ -121,7 +121,7 @@ export async function handleDurableResume(
 			fail(completedAttempt.message);
 			return true;
 		}
-		const result = await runtime.resumeDurableWorkflow(target, { policy });
+		const result = await runtime.resumeDurableWorkflow(target, { policy, actor: "user" });
 		fail(
 			allOpenable.length === 0 ? result.message : `${result.message}\n\n${formatResumableWorkflowList(allOpenable)}`,
 		);
@@ -216,7 +216,10 @@ async function resumeDurableTarget(
 	deps: WorkflowRunControlDeps,
 	runtime: ExtensionRuntime,
 ): Promise<boolean> {
-	const result = await runtime.resumeDurableWorkflow(workflowId, { policy: workflowPolicyFromContext(ctx) });
+	const result = await runtime.resumeDurableWorkflow(workflowId, {
+		policy: workflowPolicyFromContext(ctx),
+		actor: "user",
+	});
 	if (!result.ok) reporter.error(result.message);
 	else {
 		reporter.info(result.message);