@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/workflows/src/intercom/intercom-routing.ts

@@ -7,6 +7,7 @@
  * cross-ref: spec §5.10, RFC §8.1 Phase G
  */
 
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
 import type { NoticeLevel } from "../shared/store-types.js";
 import type { IntercomControlCallbacks, IntercomControlPayload } from "./result-intercom.js";
@@ -90,12 +91,17 @@ export function buildIntercomCallbacks(deps: IntercomRoutingDeps): IntercomContr
 					? await confirm("Subagent needs decision", payload.message).catch(() => false)
 					: false;
 
-			emit?.("subagent:control-intercom:response", {
-				requestId: payload.requestId ?? "",
-				runId: payload.runId ?? "",
-				stageId: payload.stageId ?? "",
-				accepted,
-			});
+			try {
+				emit?.("subagent:control-intercom:response", {
+					requestId: payload.requestId ?? "",
+					runId: payload.runId ?? "",
+					stageId: payload.stageId ?? "",
+					accepted,
+				});
+			} catch (error) {
+				if (!isStaleExtensionContextError(error)) throw error;
+				// The decision can finish after the workflow extension reloads.
+			}
 
 			store.ackNotice(noticeId);
 		},

package/dist/builtin/workflows/src/intercom/result-intercom.ts

@@ -15,6 +15,7 @@
  * cross-ref: spec §5.10 Integration with pi-intercom, §8.1 Phase G
  */
 
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import type { WorkflowDetails } from "../shared/types.js";
 
 // ---------------------------------------------------------------------------
@@ -103,6 +104,10 @@ export interface WorkflowControlIntercomPayload {
 	readonly mode: WorkflowDetails["mode"];
 	readonly status: WorkflowDetails["status"];
 	readonly message: string;
+	/** Terminal ctx.exit() discriminator and payload for parent sessions. */
+	readonly exited?: boolean;
+	readonly exitReason?: string;
+	readonly outputs?: WorkflowDetails["output"];
 	readonly parentSession?: string;
 	readonly createdAt: number;
 }
@@ -150,10 +155,19 @@ export function emitWorkflowControlIntercom(
 		mode: details.mode,
 		status: details.status,
 		message,
+		...(details.exited !== undefined ? { exited: details.exited } : {}),
+		...(details.exitReason !== undefined ? { exitReason: details.exitReason } : {}),
+		...(details.output !== undefined ? { outputs: details.output } : {}),
 		...(parentSession !== undefined ? { parentSession } : {}),
 		createdAt: Date.now(),
 	};
-	port!.emit!("workflow:control-intercom", payload as unknown as Record<string, unknown>);
+	try {
+		port!.emit!("workflow:control-intercom", payload as unknown as Record<string, unknown>);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// A workflow can outlive the extension runtime that supplied the port.
+		return false;
+	}
 	return true;
 }
 
@@ -174,7 +188,13 @@ export function emitWorkflowResultIntercom(
 		...(parentSession !== undefined ? { parentSession } : {}),
 		createdAt: Date.now(),
 	};
-	port!.emit!("workflow:result-intercom", payload as unknown as Record<string, unknown>);
+	try {
+		port!.emit!("workflow:result-intercom", payload as unknown as Record<string, unknown>);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// A workflow can outlive the extension runtime that supplied the port.
+		return false;
+	}
 	return true;
 }
 
@@ -231,10 +251,21 @@ export function subscribeIntercomControl(
 		});
 	};
 
-	const unsubscribe = pi.events!.on!("subagent:control-intercom", handler);
+	let unsubscribe: unknown;
+	try {
+		unsubscribe = pi.events!.on!("subagent:control-intercom", handler);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		return null;
+	}
 
 	return () => {
 		active = false;
-		if (typeof unsubscribe === "function") unsubscribe();
+		try {
+			if (typeof unsubscribe === "function") unsubscribe();
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Stale event-bus cleanup is best effort.
+		}
 	};
 }

package/dist/builtin/workflows/src/runs/background/quit.ts

@@ -20,7 +20,7 @@ import { topLevelWorkflowRuns } from "../../shared/run-visibility.js";
 import { store as defaultStore } from "../../shared/store.js";
 import { readGraphStoreSnapshot } from "../../shared/store-observation.js";
 import type { Store } from "../../shared/store-public-types.js";
-import type { RunSnapshot, StageSnapshot } from "../../shared/store-types.js";
+import type { RunSnapshot, StageSnapshot, WorkflowActor } from "../../shared/store-types.js";
 import type { WorkflowCancelledToolNode, WorkflowToolNodeIdentity } from "../../shared/types.js";
 import {
 	stageControlRegistry as defaultStageControlRegistry,
@@ -83,6 +83,12 @@ type QuitAllRunResult =
  * It deliberately does NOT abort through the cancellation registry or append a
  * terminal `workflow.run.end` entry. Destructive cancellation remains an
  * internal lifecycle mechanism.
+ *
+ * A quit publishes its stage pauses in step 1, long before step 5 can record the
+ * quit itself, so the run passes through an ordinary paused state on the way.
+ * Only step 5 carries the caller's `actor`, so an observer that reports deliberate
+ * control actions sees one quit rather than a pause followed by a quit — and
+ * still sees nothing at all when a quit never publishes.
  */
 export async function quitRun(
 	runId: string,
@@ -91,6 +97,8 @@ export async function quitRun(
 		stageControlRegistry?: StageControlRegistry;
 		toolControlRegistry?: ToolControlRegistry;
 		jobs?: JobTracker;
+		/** Who requested this quit. Omitted for internal callers. */
+		actor?: WorkflowActor;
 	},
 ): Promise<QuitRunResult> {
 	const activeStore = opts?.store ?? defaultStore;
@@ -170,7 +178,7 @@ export async function quitRun(
 	// record, and only the publication below can report that the run stopped.
 	const suspendedByAbort = toolHandles.length > 0;
 	const publish = (resumable: boolean): void => {
-		publishLocalQuit(activeStore, runId, pausedRunIds, resumable);
+		publishLocalQuit(activeStore, runId, pausedRunIds, resumable, opts?.actor);
 		// An abandoned callback keeps its executor alive, but that executor is no
 		// longer authoritative for this run id: detach it so `/workflow resume`
 		// relaunches a fresh executor instead of adopting the stale job and
@@ -202,15 +210,28 @@ export async function quitRun(
  * process could resume from it, so it is not advertised as resumable. Recording
  * it keeps the run controllable, so a later `/workflow quit` re-attempts the
  * transition and upgrades the record.
+ *
+ * The boundary run is deliberately excluded from the descendant loop: a bare
+ * `recordRunPaused(runId)` first would publish a plain paused state, and a
+ * lifecycle observer would report this quit as a pause followed by a quit. The
+ * single metadata-carrying call below records the same end state in one step.
  */
 function publishLocalQuit(
 	activeStore: Store,
 	runId: string,
 	pausedRunIds: ReadonlySet<string>,
 	resumable: boolean,
+	actor?: WorkflowActor,
 ): void {
-	for (const pausedRunId of pausedRunIds) activeStore.recordRunPaused(pausedRunId);
-	activeStore.recordRunPaused(runId, undefined, { exitReason: "quit", resumable });
+	for (const pausedRunId of pausedRunIds) {
+		if (pausedRunId === runId) continue;
+		activeStore.recordRunPaused(pausedRunId);
+	}
+	activeStore.recordRunPaused(runId, undefined, {
+		exitReason: "quit",
+		resumable,
+		...(actor === undefined ? {} : { actor }),
+	});
 }
 
 /**
@@ -368,6 +389,8 @@ export async function quitAllRuns(opts?: {
 	stageControlRegistry?: StageControlRegistry;
 	toolControlRegistry?: ToolControlRegistry;
 	jobs?: JobTracker;
+	/** Who requested these quits. Omitted for internal callers. */
+	actor?: WorkflowActor;
 }): Promise<QuitAllRunResult[]> {
 	const activeStore = opts?.store ?? defaultStore;
 	const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
@@ -377,6 +400,7 @@ export async function quitAllRuns(opts?: {
 			stageControlRegistry: opts?.stageControlRegistry,
 			toolControlRegistry: opts?.toolControlRegistry,
 			jobs: opts?.jobs,
+			...(opts?.actor === undefined ? {} : { actor: opts.actor }),
 		}),
 	);
 	const settled = await Promise.allSettled(attempts);

package/dist/builtin/workflows/src/runs/background/resume-acknowledgements.ts

@@ -75,7 +75,8 @@ export async function settleResumeAcknowledgements(
 		if (visiblyRunning) lateFailures.push(qualified);
 		else if (controlRun?.endedAt === undefined && targetIsActuallyPaused(store, target)) failures.push(qualified);
 	});
-	for (const controlRunId of resumedRunIds) store.recordRunResumed(controlRunId);
+	for (const controlRunId of resumedRunIds)
+		store.recordRunResumed(controlRunId, undefined, { source: "acknowledgement" });
 	return { resumed, acknowledged, failures, lateFailures };
 }
 

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -16,7 +16,7 @@ import { topLevelWorkflowRuns } from "../../shared/run-visibility.js";
 import type { Store } from "../../shared/store.js";
 import { store as defaultStore } from "../../shared/store.js";
 import { readGraphStoreSnapshot } from "../../shared/store-observation.js";
-import type { RunSnapshot, RunStatus, StageSnapshot } from "../../shared/store-types.js";
+import type { RunSnapshot, RunStatus, StageSnapshot, WorkflowActor } from "../../shared/store-types.js";
 import type { WorkflowPersistencePort } from "../../shared/types.js";
 import type { StageControlRegistry } from "../foreground/stage-control-registry.js";
 import { stageControlRegistry as defaultStageControlRegistry } from "../foreground/stage-control-registry.js";
@@ -204,6 +204,8 @@ export async function resumeRun(
 		stageId?: string;
 		/** Optional resume message forwarded to each resumed stage. */
 		message?: string;
+		/** Who requested this resume. Omitted for internal callers. */
+		actor?: WorkflowActor;
 	},
 ): Promise<ResumeResult> {
 	const activeStore = opts?.store ?? defaultStore;
@@ -250,8 +252,29 @@ export async function resumeRun(
 				!hasPausedDescendant &&
 				currentRun?.status === "paused")
 		) {
-			activeStore.recordRunResumed(runId);
-			if (aggregateRootRunId !== runId) activeStore.recordRunResumed(aggregateRootRunId);
+			// One scope carries the actor, mirroring pauseRun: the stage when a
+			// stage-scoped resume leaves siblings paused, the run otherwise. The
+			// aggregate root is reconciled without attribution so one request never
+			// reports twice.
+			//
+			// A run only carries the actor when it has a resume transition to attach
+			// it to. A stage-scoped resume of a run that never paused — because a
+			// sibling stage kept it running — leaves `resumedAt` unset, and
+			// `recordRunResumed` refuses an attribution-only claim against a run that
+			// never resumed. Attributing the run there would report nothing at all,
+			// so the stage carries it instead.
+			const attributeStage =
+				opts?.stageId !== undefined && (hasPausedDescendant || currentRun?.resumedAt === undefined);
+			activeStore.recordRunResumed(runId, undefined, {
+				source: "run_control",
+				...(opts?.actor === undefined || attributeStage ? {} : { actor: opts.actor }),
+			});
+			if (aggregateRootRunId !== runId) {
+				activeStore.recordRunResumed(aggregateRootRunId, undefined, { source: "run_control" });
+			}
+			if (attributeStage && opts?.actor !== undefined && opts.stageId !== undefined) {
+				activeStore.recordStageResumed(runId, opts.stageId, undefined, { actor: opts.actor });
+			}
 		}
 		const reconciledRoot = activeStore.runs().find((candidate) => candidate.id === runId);
 		if (acknowledgements.failures.length > 0) {
@@ -319,6 +342,21 @@ export async function resumeRun(
 			message: "This workflow is not resumable; inspect the snapshot and start a new workflow run when ready.",
 		};
 	}
+	if (
+		current.status === "failed" &&
+		current.endedAt !== undefined &&
+		current.exited === true &&
+		current.resumable === true
+	) {
+		return {
+			ok: true,
+			runId,
+			snapshot,
+			resumed: resumedCopy,
+			mode: "snapshot",
+			message: `This failed run is marked resumable; use /workflow resume ${runId} to ask the durable backend to retry it or start a new workflow run.`,
+		};
+	}
 	if (
 		current.endedAt === undefined &&
 		current.resumable === true &&
@@ -346,7 +384,15 @@ export async function resumeRun(
 }
 
 // pauseRun
-/** Pause a run only after its live stage controls acknowledge the request. */
+/**
+ * Pause a run only after its live stage controls acknowledge the request.
+ *
+ * `actor` attributes the pause to whoever asked for it. Exactly one scope carries
+ * it: a whole-run pause attributes the run, and a stage-scoped pause attributes
+ * the run when it stops the last active stage and the stage otherwise. An
+ * observer therefore reports one event per request, never a stage and a run
+ * event for the same one.
+ */
 export async function pauseRun(
 	runId: string,
 	opts?: {
@@ -354,11 +400,14 @@ export async function pauseRun(
 		stageControlRegistry?: StageControlRegistry;
 		/** Pause only this stage. */
 		stageId?: string;
+		/** Who requested this pause. Omitted for internal callers. */
+		actor?: WorkflowActor;
 	},
 ): Promise<PauseResult> {
 	const activeStore = opts?.store ?? defaultStore;
 	const registry = opts?.stageControlRegistry ?? defaultStageControlRegistry;
 	const run = activeStore.runs().find((candidate) => candidate.id === runId);
+	const actorMetadata = opts?.actor === undefined ? undefined : { actor: opts.actor };
 
 	if (!run) return { ok: false, runId, reason: "not_found" };
 	if (run.endedAt !== undefined) return { ok: false, runId, reason: "already_ended" };
@@ -379,7 +428,9 @@ export async function pauseRun(
 				(candidate) =>
 					candidate.id !== opts.stageId && (candidate.status === "running" || candidate.status === "pending"),
 			) ?? false;
-		if (!stillActive) activeStore.recordRunPaused(runId);
+		if (!stillActive) activeStore.recordRunPaused(runId, undefined, actorMetadata);
+		else if (actorMetadata !== undefined)
+			activeStore.recordStagePaused(runId, opts.stageId, undefined, actorMetadata);
 		return { ok: true, runId, paused };
 	}
 
@@ -403,19 +454,30 @@ export async function pauseRun(
 		const stage = controlRun?.stages.find((candidate) => candidate.id === handle.stageId);
 		if (stage !== undefined) paused.push(structuredClone(stage));
 	}
-	for (const pausedRunId of pausedRunIds) activeStore.recordRunPaused(pausedRunId);
-	activeStore.recordRunPaused(runId);
+	for (const pausedRunId of pausedRunIds) {
+		if (pausedRunId === runId) continue;
+		activeStore.recordRunPaused(pausedRunId);
+	}
+	activeStore.recordRunPaused(runId, undefined, actorMetadata);
 	return { ok: true, runId, paused };
 }
 
 export async function pauseAllRuns(opts?: {
 	store?: Store;
 	stageControlRegistry?: StageControlRegistry;
+	/** Who requested these pauses. Omitted for internal callers. */
+	actor?: WorkflowActor;
 }): Promise<PauseResult[]> {
 	const activeStore = opts?.store ?? defaultStore;
 	const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
 	return Promise.all(
-		inFlight.map((run) => pauseRun(run.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry })),
+		inFlight.map((run) =>
+			pauseRun(run.id, {
+				store: activeStore,
+				stageControlRegistry: opts?.stageControlRegistry,
+				...(opts?.actor === undefined ? {} : { actor: opts.actor }),
+			}),
+		),
 	);
 }
 // ---------------------------------------------------------------------------

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

@@ -7,6 +7,7 @@ const WORKFLOW_EXIT_STATUSES: ReadonlySet<WorkflowExitStatus> = new Set([
 	"skipped",
 	"cancelled",
 	"blocked",
+	"failed",
 ]);
 
 export type WorkflowExitOutputSnapshot =
@@ -24,6 +25,7 @@ export interface WorkflowExitSignal {
 	readonly scope: symbol;
 	readonly status: WorkflowExitStatus;
 	readonly reason?: string;
+	readonly resumable?: boolean;
 	readonly outputSnapshot?: WorkflowExitOutputSnapshot;
 	readonly validationError?: Error;
 }
@@ -32,6 +34,7 @@ export function makeWorkflowExitSignal(input: {
 	readonly scope: symbol;
 	readonly status: WorkflowExitStatus;
 	readonly reason?: string;
+	readonly resumable?: boolean;
 	readonly outputSnapshot?: WorkflowExitOutputSnapshot;
 	readonly validationError?: Error;
 }): WorkflowExitSignal {
@@ -40,6 +43,7 @@ export function makeWorkflowExitSignal(input: {
 		scope: input.scope,
 		status: input.status,
 		...(input.reason !== undefined ? { reason: input.reason } : {}),
+		...(input.resumable !== undefined ? { resumable: input.resumable } : {}),
 		...(input.outputSnapshot !== undefined ? { outputSnapshot: input.outputSnapshot } : {}),
 		...(input.validationError !== undefined ? { validationError: input.validationError } : {}),
 	};
@@ -81,13 +85,13 @@ function workflowExitSnapshotError(message: string, cause: unknown): Error {
 	return new Error(`${message}: ${unknownErrorMessage(cause)}`, { cause });
 }
 
-function workflowExitOptionReadError(key: "status" | "reason" | "outputs", cause: unknown): Error {
+function workflowExitOptionReadError(key: "status" | "reason" | "resumable" | "outputs", cause: unknown): Error {
 	return workflowExitSnapshotError(`atomic-workflows: ctx.exit() ${key} option could not be read`, cause);
 }
 
 export function readWorkflowExitOption(
-	options: Pick<WorkflowExitOptions, "status" | "reason" | "outputs"> | null | undefined,
-	key: "status" | "reason" | "outputs",
+	options: Pick<WorkflowExitOptions, "status" | "reason" | "resumable" | "outputs"> | null | undefined,
+	key: "status" | "reason" | "resumable" | "outputs",
 ): { readonly ok: true; readonly value: unknown } | { readonly ok: false; readonly error: Error } {
 	try {
 		return { ok: true, value: options?.[key] };
@@ -339,6 +343,9 @@ function readWorkflowExitSignalCandidate(value: object, scope: symbol): Workflow
 	const reason = safeGetProperty(value, "reason");
 	if (!reason.ok || (reason.value !== undefined && typeof reason.value !== "string")) return undefined;
 
+	const resumable = safeGetProperty(value, "resumable");
+	if (!resumable.ok || (resumable.value !== undefined && typeof resumable.value !== "boolean")) return undefined;
+
 	const outputSnapshotValue = safeGetProperty(value, "outputSnapshot");
 	if (!outputSnapshotValue.ok) return undefined;
 	const outputSnapshot = readWorkflowExitOutputSnapshot(outputSnapshotValue.value);
@@ -352,6 +359,7 @@ function readWorkflowExitSignalCandidate(value: object, scope: symbol): Workflow
 		scope,
 		status: status.value,
 		...(reason.value !== undefined ? { reason: reason.value } : {}),
+		...(resumable.value !== undefined ? { resumable: resumable.value } : {}),
 		...(outputSnapshot !== undefined ? { outputSnapshot } : {}),
 		...(validationError.value !== undefined ? { validationError: safeErrorValue(validationError.value) } : {}),
 	};

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

@@ -41,11 +41,12 @@ export interface WorkflowBoundaryStage {
 }
 
 function workflowChildResultFromReplay(snapshot: WorkflowChildReplaySnapshot): WorkflowChildResult {
+	const exited = snapshot.exited ?? (snapshot.status === "completed" ? false : undefined);
 	const candidate = {
 		workflow: snapshot.workflow,
 		runId: snapshot.runId,
 		status: snapshot.status,
-		exited: snapshot.exited,
+		exited,
 		outputs: cloneWorkflowChildValue(snapshot.outputs),
 		...(snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}),
 	} as WorkflowSerializableValue;

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

@@ -1,5 +1,6 @@
 import { isAbsolute, join, resolve } from "node:path";
 import { CONFIG_DIR_NAME, isCodexFastModeCandidateModelId } from "@bastani/atomic";
+import type { WorkflowActor } from "../../shared/store-types.js";
 import type { StageOptions, WorkflowArtifact, WorkflowTaskOptions, WorkflowTaskStep } from "../../shared/types.js";
 import { workflowArtifactRunPath } from "../../shared/workflow-artifacts.js";
 import { buildModelCandidatesFromCatalog, workflowModelId } from "../shared/model-fallback.js";
@@ -178,11 +179,13 @@ export function workflowInvocationMetadata(
 	inputDefaults: Partial<StageOptions>,
 	workflowInvocationCwd: string,
 	cache?: GitWorktreeSetupCache,
+	origin?: WorkflowActor,
 ): {
 	readonly invocationCwd: string;
 	readonly workflowCwd?: string;
 	readonly repositoryRoot?: string;
 	readonly gitWorktreeRoot?: string;
+	readonly origin?: WorkflowActor;
 } {
 	const setup = setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cache);
 	return {
@@ -190,6 +193,7 @@ export function workflowInvocationMetadata(
 		...(setup !== undefined
 			? { workflowCwd: setup.cwd, repositoryRoot: setup.repositoryRoot, gitWorktreeRoot: setup.worktreeRoot }
 			: {}),
+		...(origin !== undefined ? { origin } : {}),
 	};
 }
 

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

@@ -127,7 +127,10 @@ export function createWorkflowExitManager(input: {
 			runWorkflowExitCleanups(selectedExit.reason);
 			throw selectedExit;
 		};
-		const rawOptions = options as Pick<WorkflowExitOptions, "status" | "reason" | "outputs"> | null | undefined;
+		const rawOptions = options as
+			| Pick<WorkflowExitOptions, "status" | "reason" | "resumable" | "outputs">
+			| null
+			| undefined;
 		let validationError: Error | undefined;
 		const captureValidationError = (error: Error): void => {
 			validationError ??= error;
@@ -141,7 +144,7 @@ export function createWorkflowExitManager(input: {
 		} else if (!isWorkflowExitStatus(rawStatus)) {
 			captureValidationError(
 				new TypeError(
-					`atomic-workflows: ctx.exit() status must be one of completed, skipped, cancelled, blocked; got ${describeWorkflowExitOptionValue(rawStatus)}`,
+					`atomic-workflows: ctx.exit() status must be one of completed, skipped, cancelled, blocked, failed; got ${describeWorkflowExitOptionValue(rawStatus)}`,
 				),
 			);
 		}
@@ -161,6 +164,26 @@ export function createWorkflowExitManager(input: {
 		}
 		const reason = typeof rawReason === "string" ? rawReason : undefined;
 
+		const resumableRead = readWorkflowExitOption(rawOptions, "resumable");
+		throwNestedSelectedExit();
+		const rawResumable = resumableRead.ok ? resumableRead.value : undefined;
+		if (!resumableRead.ok) {
+			captureValidationError(resumableRead.error);
+		} else if (rawResumable !== undefined && typeof rawResumable !== "boolean") {
+			captureValidationError(
+				new TypeError(
+					`atomic-workflows: ctx.exit() resumable must be a boolean when provided; got ${workflowSerializableTypeName(rawResumable)}`,
+				),
+			);
+		} else if (rawResumable !== undefined && rawStatus !== "failed") {
+			captureValidationError(
+				new TypeError(
+					`atomic-workflows: ctx.exit() resumable is only valid with status failed; got ${describeWorkflowExitOptionValue(rawStatus)}`,
+				),
+			);
+		}
+		const resumable = status === "failed" && rawResumable === true;
+
 		const outputsRead = readWorkflowExitOption(rawOptions, "outputs");
 		throwNestedSelectedExit();
 		const outputSnapshot = !outputsRead.ok
@@ -175,6 +198,7 @@ export function createWorkflowExitManager(input: {
 				scope: input.exitScope,
 				status,
 				...(reason !== undefined ? { reason } : {}),
+				...(status === "failed" ? { resumable } : {}),
 				...(outputSnapshot !== undefined ? { outputSnapshot } : {}),
 				...(validationError !== undefined ? { validationError } : {}),
 			}),

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

@@ -182,7 +182,9 @@ export function buildPromptNodeUiAdapter(input: {
 			},
 			async resume() {
 				input.activeStore.recordStageResumed(input.runId, stageId);
-				input.activeStore.recordRunResumed(input.runId);
+				// Answering a human-in-the-loop prompt continues work already in flight.
+				// It is not a control action and must never reach the main chat.
+				input.activeStore.recordRunResumed(input.runId, undefined, { source: "prompt_answer" });
 				const currentPauseGate = pauseGate;
 				pauseGate = undefined;
 				currentPauseGate?.resolve();

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

@@ -81,8 +81,9 @@ export function createRunFinalizers(input: {
 			return finalizeWorkflowExitValidationFailure(err, signal.reason);
 		}
 
+		const resumable = signal.status === "failed" && signal.resumable === true;
 		const metadata = {
-			resumable: false,
+			resumable,
 			exited: true,
 			...(signal.reason !== undefined ? { exitReason: signal.reason } : {}),
 		} as const;
@@ -93,7 +94,7 @@ export function createRunFinalizers(input: {
 			result: outputs,
 			exited: true,
 			...(signal.reason !== undefined ? { exitReason: signal.reason } : {}),
-			resumable: false,
+			resumable,
 			ts: Date.now(),
 		});
 		return reconcileTerminalRunResult(

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

@@ -193,7 +193,7 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
 					await runtime.scheduler.cascadeResumeFrom(runtime.stageId);
 					// Preserve manual per-stage semantics: once this acknowledged
 					// resume succeeds, the run is active even if sibling stages remain paused.
-					runtime.activeStore.recordRunResumed(runtime.runId);
+					runtime.activeStore.recordRunResumed(runtime.runId, undefined, { source: "stage_control" });
 				}
 				if (wakeReleasedIdleStageChat) runtime.state.wakeWaitingForStageChatTurn?.();
 				if (resumesIdleStageChat && hasMessage) {

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

@@ -233,7 +233,7 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 		},
 
 		async abort() {
-			await controller.currentSession?.abort();
+			await controller.abort();
 		},
 
 		async __dispose() {