@bastani/atomic 0.9.12 → 0.9.13-alpha.1

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

@@ -129,7 +129,7 @@ export async function handleRunControlCommand(
 					return true;
 				}
 			}
-			const results = action === "quit" ? await quitAllRuns() : await interruptAllRuns();
+			const results = action === "quit" ? await quitAllRuns({ actor: "user" }) : await interruptAllRuns();
 			const successes = results.filter((result) => result.ok);
 			const changed = successes.length;
 			const failures = results.filter((result) => !result.ok);
@@ -171,7 +171,7 @@ export async function handleRunControlCommand(
 				return true;
 			}
 			try {
-				const result = await quitRun(resolved.runId);
+				const result = await quitRun(resolved.runId, { actor: "user" });
 				if (result.ok) print(`Run ${result.runId} quit and can be resumed with /workflow resume.`);
 				else if (result.reason === "already_ended") print(`Run ${result.runId} already ended.`);
 				else if (result.reason === "no_active_stages") {
@@ -284,11 +284,11 @@ export async function handleRunControlCommand(
 						await ensureWorkflowResourcesVisible();
 						const continuation = await deps
 							.runtimeForContext(ctx)
-							.resumeFailedRun(resolved.runId, undefined, { policy });
+							.resumeFailedRun(resolved.runId, undefined, { policy, actor: "user" });
 						continuation.ok ? print(continuation.message) : fail(continuation.message);
 					} else {
 						try {
-							const result = await resumeRun(resolved.runId, {});
+							const result = await resumeRun(resolved.runId, { actor: "user" });
 							if (result.ok && !isPaused && result.mode === "snapshot" && run?.exitReason === "quit") {
 								return await handleDurableResume(resolved.runId, ctx, reporter, deps);
 							}
@@ -443,7 +443,7 @@ export async function handleRunControlCommand(
 		const stageRunId = resolvedStage.runId ?? runId;
 		if (action === "pause") {
 			try {
-				const result = await pauseRun(stageRunId, { stageId });
+				const result = await pauseRun(stageRunId, { stageId, actor: "user" });
 				if (!result.ok) {
 					fail(
 						result.reason === "not_found"
@@ -495,7 +495,9 @@ export async function handleRunControlCommand(
 		}
 		if (isResumableContinuation) {
 			await ensureWorkflowResourcesVisible();
-			const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(stageRunId, stageId, { policy });
+			const continuation = await deps
+				.runtimeForContext(ctx)
+				.resumeFailedRun(stageRunId, stageId, { policy, actor: "user" });
 			continuation.ok ? print(continuation.message) : fail(continuation.message);
 			return true;
 		}
@@ -507,7 +509,7 @@ export async function handleRunControlCommand(
 		}
 		let result: Awaited<ReturnType<typeof resumeRun>>;
 		try {
-			result = await resumeRun(stageRunId, { stageId, message });
+			result = await resumeRun(stageRunId, { stageId, message, actor: "user" });
 		} catch (error) {
 			fail(`Failed to resume run ${stageRunId}: ${error instanceof Error ? error.message : String(error)}`);
 			return true;

package/dist/builtin/workflows/src/extension/workflow-status-summary.ts

@@ -102,6 +102,17 @@ export interface WorkflowStatusListing {
 	readonly snapshots: RunSnapshot[];
 }
 
+const workflowStatusRenderRuns = new WeakMap<object, readonly RunSnapshot[]>();
+
+/** Keep the full point-in-time run collection out of agent-facing result JSON. */
+export function setWorkflowStatusRenderRuns(result: object, runs: readonly RunSnapshot[]): void {
+	workflowStatusRenderRuns.set(result, runs);
+}
+
+export function getWorkflowStatusRenderRuns(result: object): readonly RunSnapshot[] | undefined {
+	return workflowStatusRenderRuns.get(result);
+}
+
 function stageIsActive(stage: StageSnapshot): boolean {
 	return stage.status === "running" || stage.status === "awaiting_input";
 }

package/dist/builtin/workflows/src/extension/workflow-tool-content.ts

@@ -1,10 +1,13 @@
+import { runIndicatorStatus } from "../shared/run-indicator-status.js";
 import { deriveInputFields } from "../shared/schema-introspection.js";
+import type { RunSnapshot } from "../shared/store-types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
-import { fmtDuration } from "../tui/status-helpers.js";
+import { fmtDuration, statusIcon } from "../tui/status-helpers.js";
 import type { WorkflowToolArgs } from "./public-types.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowRunStatusSummary, WorkflowStatusAwaitingInput } from "./workflow-status-summary.js";
+import { getWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
 
 function stringifyWorkflowToolResult(result: WorkflowToolResult): string {
 	return JSON.stringify(result, null, 2);
@@ -69,7 +72,20 @@ function statusAwaitingInputLine(entry: WorkflowStatusAwaitingInput): string {
 	return `    awaiting input: ${target}${prompt}${message}`;
 }
 
+function statusRunIcon(
+	run: WorkflowRunStatusSummary,
+	snapshot: RunSnapshot | undefined,
+	allRuns: readonly RunSnapshot[],
+): string {
+	if (snapshot === undefined) return statusIcon(run.status);
+	const indicatorStatus = runIndicatorStatus(snapshot, allRuns);
+	if (snapshot.endedAt === undefined && snapshot.status === "paused" && snapshot.exitReason === "quit") {
+		return statusIcon("pending");
+	}
+	return statusIcon(indicatorStatus);
+}
 function renderStatusToolContent(result: Extract<WorkflowToolResult, { action: "status" }>): string {
+	const allRuns = getWorkflowStatusRenderRuns(result) ?? result.snapshots;
 	const lines = ["action: status", `filter: ${result.filter}`];
 	if (result.runs.length === 0) {
 		lines.push(result.filter === "all" ? "runs: none" : `runs: none (statusFilter: ${result.filter})`);
@@ -81,6 +97,7 @@ function renderStatusToolContent(result: Extract<WorkflowToolResult, { action: "
 		const hint = statusRunHint(run);
 		const summaryLine = [
 			`[${index + 1}]`,
+			statusRunIcon(run, result.snapshots[index], allRuns),
 			run.runId,
 			run.name,
 			run.status,

package/dist/builtin/workflows/src/extension/workflow-tool-control.ts

@@ -70,7 +70,7 @@ export async function workflowPauseAction(args: WorkflowToolArgs): Promise<Workf
 			return { action, runId: "--all", status: "noop", message: allStageConflictMessage("pause") };
 		}
 		try {
-			const results = await pauseAllRuns();
+			const results = await pauseAllRuns({ actor: "agent" });
 			const paused = results.filter((result) => result.ok).length;
 			return {
 				action,
@@ -100,7 +100,7 @@ export async function workflowPauseAction(args: WorkflowToolArgs): Promise<Workf
 	if (!stage.ok) return { action, runId: target.runId, status: "noop", message: stage.message };
 	const stageRunId = stage.runId ?? target.runId;
 	try {
-		const result = await pauseRun(stageRunId, { stageId: stage.stageId });
+		const result = await pauseRun(stageRunId, { stageId: stage.stageId, actor: "agent" });
 		return result.ok
 			? {
 					action,
@@ -241,7 +241,7 @@ export async function workflowQuitAction(args: WorkflowToolArgs): Promise<Workfl
 		if (args.stageId !== undefined && args.stageId.length > 0) {
 			return { action, runId: "--all", status: "noop", message: allStageConflictMessage("quit") };
 		}
-		const results = await quitAllRuns();
+		const results = await quitAllRuns({ actor: "agent" });
 		const successes = results.filter((result) => result.ok);
 		const quitCount = successes.length;
 		const failures = results.filter((result) => !result.ok);
@@ -264,7 +264,7 @@ export async function workflowQuitAction(args: WorkflowToolArgs): Promise<Workfl
 	if (!controlNode.ok) return { action, runId: target.runId, status: "noop", message: controlNode.message };
 	if (controlNode.kind === "tool") return quitToolNodeAction(controlNode.runId, controlNode.nodeId, action);
 	try {
-		const result = await quitRun(target.runId);
+		const result = await quitRun(target.runId, { actor: "agent" });
 		if (result.ok) {
 			return {
 				action,
@@ -354,7 +354,7 @@ async function resumeDurableShadow(
 	} catch (error) {
 		warning = formatWorkflowResourceLoadWarning(error);
 	}
-	const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy });
+	const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
 	const message = warning === undefined ? resumed.message : `${warning}\n\n${resumed.message}`;
 	return {
 		action: "resume",
@@ -369,7 +369,7 @@ async function resumePreparedDurableTarget(
 	deps: Pick<WorkflowControlActionDeps, "getRuntime" | "policy">,
 ): Promise<WorkflowToolResult> {
 	try {
-		const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, { policy: deps.policy });
+		const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
 		return {
 			action: "resume",
 			runId: resumed.ok ? resumed.runId : runId,
@@ -493,7 +493,9 @@ export async function workflowResumeAction(
 		} catch (error) {
 			warning = formatWorkflowResourceLoadWarning(error);
 		}
-		const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy });
+		const continuation = await deps
+			.getRuntime()
+			.resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy, actor: "agent" });
 		const message = warning === undefined ? continuation.message : `${warning}\n\n${continuation.message}`;
 		return {
 			action: "resume",
@@ -503,7 +505,7 @@ export async function workflowResumeAction(
 		};
 	}
 	try {
-		const result = await resumeRun(stageRunId, { stageId: stage.stageId, message: args.message });
+		const result = await resumeRun(stageRunId, { stageId: stage.stageId, message: args.message, actor: "agent" });
 		if (result.ok) {
 			const runLevelResumed =
 				hadPausedRunState &&

package/dist/builtin/workflows/src/extension/workflow-tool.ts

@@ -1,5 +1,6 @@
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
 import { inspectRun } from "../runs/background/status.js";
+import { store } from "../shared/store.js";
 import type { WorkflowExecutionPolicy } from "../shared/types.js";
 import type { PiExecuteContext, WorkflowToolArgs } from "./public-types.js";
 import type { WorkflowToolResult } from "./render-result.js";
@@ -7,7 +8,7 @@ import type { ExtensionRuntime } from "./runtime.js";
 import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import type { WorkflowReloadReport } from "./workflow-reload-report.js";
-import { buildWorkflowStatusListing } from "./workflow-status-summary.js";
+import { buildWorkflowStatusListing, setWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
 import { isWorkflowStageToolContext, resolveRunId, topLevelExpandedSnapshots } from "./workflow-targets.js";
 import { workflowGetResult } from "./workflow-tool-content.js";
 import {
@@ -74,7 +75,9 @@ export function makeExecuteWorkflowTool(
 			}
 			case "run": {
 				await ensureWorkflowResourcesVisible();
-				return getRuntime().dispatch(args, { policy });
+				// A tool launch is the agent's own action: it is attributed as such and
+				// the tool result already reports the run, so it raises no chat notice.
+				return getRuntime().dispatch(args, { policy, origin: "agent" });
 			}
 			case "status": {
 				const target = args.runId;
@@ -92,12 +95,14 @@ export function makeExecuteWorkflowTool(
 						: { action: "statusDetail", runId: target, error: `run not found: ${target}` };
 				}
 				const listing = buildWorkflowStatusListing(topLevelExpandedSnapshots(), args.statusFilter ?? "all");
-				return {
-					action: "status",
+				const result = {
+					action: "status" as const,
 					filter: listing.filter,
 					runs: listing.runs,
 					snapshots: listing.snapshots,
 				};
+				setWorkflowStatusRenderRuns(result, store.graphSnapshot().runs);
+				return result;
 			}
 			case "stages":
 				return workflowStagesResult(args);

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) {
@@ -346,7 +369,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 +385,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 +413,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 +439,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-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-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-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() {