@bastani/atomic 0.9.14-alpha.1 → 0.9.14-alpha.2

package/dist/builtin/workflows/src/durable/tool-primitive.ts

@@ -19,6 +19,7 @@ import { runCallback } from "@bastani/atomic";
 import { sleepOrAbort } from "../runs/shared/retry.js";
 import { flattenTruncatedString } from "../shared/flat-string.js";
 import type { ToolNodeSnapshot } from "../shared/store-types.js";
+import { boundedToolPayloadRecord, boundedToolText } from "../shared/tool-payload-bounds.js";
 import type {
 	WorkflowSerializableValue,
 	WorkflowToolContext,
@@ -109,12 +110,41 @@ export interface CreateToolPrimitiveInput {
 	readonly onNodeRunning?: (nodeId: string, startedAt: number) => void;
 	readonly onNodeEnd?: (
 		nodeId: string,
-		update: Pick<ToolNodeSnapshot, "status"> & Partial<Pick<ToolNodeSnapshot, "endedAt" | "resultSummary" | "error">>,
+		update: Pick<ToolNodeSnapshot, "status"> &
+			Partial<Pick<ToolNodeSnapshot, "endedAt" | "durationMs" | "result" | "resultSummary" | "error">>,
 	) => void;
 	readonly onNodeSettle?: (nodeId: string) => void;
 	readonly runTopology?: DurableStageRunTopology;
 }
 
+function cloneToolArgs(
+	args: Readonly<Record<string, WorkflowSerializableValue>>,
+): Readonly<Record<string, WorkflowSerializableValue>> {
+	// Bounded, hostile-input safe, and always a plain object: author args may be
+	// cyclic, may throw on property access, may be arbitrarily large, and may
+	// carry a `toJSON` that would otherwise collapse the record to a scalar in a
+	// durable checkpoint. `argsHash` still hashes the raw args, so cache identity
+	// is unaffected by this inspection copy.
+	return boundedToolPayloadRecord(args);
+}
+
+/**
+ * Capture the callback's own source for read-only inspection.
+ *
+ * `Function.prototype.toString` reads text the runtime already holds: it never
+ * invokes the callback, never touches the filesystem, and never reaches any
+ * data beyond the function passed to this call. A host that refuses the read
+ * simply yields no source row.
+ */
+function captureCallbackSource(fn: unknown): string | undefined {
+	if (typeof fn !== "function") return undefined;
+	try {
+		return boundedToolText(Function.prototype.toString.call(fn));
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * Create the `ctx.tool` primitive wired to a durable backend.
  */
@@ -155,7 +185,7 @@ export function createToolPrimitive(input: CreateToolPrimitiveInput): WorkflowTo
 			noteCancelled: () => admission?.noteCancelled?.(),
 			releaseAdmission: () => lease?.release(),
 		};
-		void executeToolInvocation(input, ordinals, name, args, fn, options, control)
+		void executeToolInvocation(input, ordinals, name, args, fn, options, control, captureCallbackSource(fn))
 			// Backstop for a throw before either explicit release point; the lease
 			// release itself is idempotent.
 			.finally(() => lease?.release())
@@ -172,6 +202,7 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 	fn: (toolCtx: WorkflowToolContext) => Promise<T>,
 	options: WorkflowToolOptions | undefined,
 	control: ToolInvocationAdmissionControl,
+	source: string | undefined,
 ): Promise<WorkflowToolInvocationResult<T>> {
 	input.throwIfCancelled();
 	if (
@@ -181,6 +212,9 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 	) {
 		throw new RangeError("atomic-workflows: ctx.tool maxAttempts must be a positive integer");
 	}
+	if (options?.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+		throw new RangeError("atomic-workflows: ctx.tool timeoutMs must be a positive finite number");
+	}
 	const returnFailure = options?.failureMode === "return";
 	const identityMode = returnFailure ? { failureMode: "return" as const } : {};
 	const callKey = durableHash({ name, args, ...identityMode });
@@ -189,10 +223,13 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 	const argsHash = durableHash({ name, args, ordinal, ...identityMode });
 
 	const cached = input.backend.getToolCheckpoint(input.workflowId, argsHash);
+	const capturedSource = cached?.source ?? source;
 	const node: ToolNodeSnapshot = {
 		kind: "tool",
 		id: cached?.topology?.nodeId ?? `tool:${argsHash}`,
 		name,
+		args: cloneToolArgs(cached?.args ?? args),
+		...(capturedSource !== undefined ? { source: capturedSource } : {}),
 		argsHash,
 		ordinal: cached?.topology?.ordinal ?? ordinal,
 		parentIds: Object.freeze(cached?.topology?.parentIds ?? []),
@@ -223,6 +260,8 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 			input.onNodeEnd?.(node.id, {
 				status: failed ? "failed" : "cached",
 				endedAt,
+				...(node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt - node.startedAt) } : {}),
+				result: output,
 				...(failed && returnedOutcome?.ok === false
 					? { error: returnedOutcome.error.message }
 					: { resultSummary: summarizeToolResult(output) }),
@@ -233,9 +272,11 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 			const cancelled = input.signal?.aborted === true;
 			if (cancelled) control.noteCancelled();
 			else input.onFailureObserved?.(error, node.id);
+			const endedAt = Date.now();
 			input.onNodeEnd?.(node.id, {
 				status: cancelled ? "cancelled" : "failed",
-				endedAt: Date.now(),
+				endedAt,
+				...(node.startedAt !== undefined ? { durationMs: Math.max(0, endedAt - node.startedAt) } : {}),
 				error: error instanceof Error ? error.message : String(error),
 			});
 			input.onNodeSettle?.(node.id);
@@ -246,6 +287,8 @@ async function executeToolInvocation<T extends WorkflowSerializableValue>(
 		input,
 		node,
 		name,
+		args: node.args ?? args,
+		...(capturedSource !== undefined ? { source: capturedSource } : {}),
 		argsHash,
 		ordinal,
 		fn,
@@ -259,6 +302,8 @@ interface LiveToolInvocation<T extends WorkflowSerializableValue> {
 	readonly input: CreateToolPrimitiveInput;
 	readonly node: ToolNodeSnapshot;
 	readonly name: string;
+	readonly args: Readonly<Record<string, WorkflowSerializableValue>>;
+	readonly source?: string;
 	readonly argsHash: string;
 	readonly ordinal: number;
 	readonly fn: (toolCtx: WorkflowToolContext) => Promise<T>;
@@ -266,6 +311,86 @@ interface LiveToolInvocation<T extends WorkflowSerializableValue> {
 	readonly control: ToolInvocationAdmissionControl;
 	readonly returnFailure: boolean;
 }
+class WorkflowToolTimeoutError extends Error {
+	constructor(toolName: string, timeoutMs: number) {
+		super(`atomic-workflows: ctx.tool ${toolName} timed out after ${timeoutMs}ms`);
+		this.name = "TimeoutError";
+	}
+}
+
+const MAX_HOST_TIMER_MS = 2_147_483_647;
+
+/** Schedule a finite deadline without triggering host timer overflow clamping. */
+function scheduleDeadline(callback: () => void, timeoutMs: number): () => void {
+	let remainingMs = timeoutMs;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const scheduleNextChunk = () => {
+		const chunkMs = Math.min(remainingMs, MAX_HOST_TIMER_MS);
+		timer = setTimeout(() => {
+			remainingMs -= chunkMs;
+			if (remainingMs > 0) scheduleNextChunk();
+			else callback();
+		}, chunkMs);
+	};
+	scheduleNextChunk();
+	return () => {
+		if (timer !== undefined) clearTimeout(timer);
+	};
+}
+
+type ToolCallbackAttemptResult<T> =
+	| { readonly kind: "value"; readonly value: T }
+	| { readonly kind: "error"; readonly error: unknown };
+
+function abortReason(signal: AbortSignal): Error {
+	return signal.reason instanceof Error ? signal.reason : new Error("atomic-workflows: workflow cancelled");
+}
+
+/** Run one callback attempt with a fresh signal and deadline. */
+async function executeTimedToolAttempt<T extends WorkflowSerializableValue>(
+	toolName: string,
+	runId: string,
+	fn: (toolCtx: WorkflowToolContext) => Promise<T>,
+	baseSignal: AbortSignal,
+	timeoutMs: number,
+): Promise<T> {
+	const timeoutController = new AbortController();
+	const attemptSignal = AbortSignal.any([baseSignal, timeoutController.signal]);
+	return runCallback({ kind: "workflow.ctx_tool", name: toolName, runId }, async () => {
+		const callbackResult: Promise<ToolCallbackAttemptResult<T>> = Promise.resolve()
+			.then(() => fn({ signal: attemptSignal }))
+			.then(
+				(value) => ({ kind: "value" as const, value }),
+				(error: unknown) => ({ kind: "error" as const, error }),
+			);
+		let cancelDeadline: (() => void) | undefined;
+		let onAbort: (() => void) | undefined;
+		let timeoutError: WorkflowToolTimeoutError | undefined;
+		const timeoutResult = new Promise<never>((_, reject) => {
+			cancelDeadline = scheduleDeadline(() => {
+				if (baseSignal.aborted) return;
+				timeoutError = new WorkflowToolTimeoutError(toolName, timeoutMs);
+				timeoutController.abort(timeoutError);
+				reject(timeoutError);
+			}, timeoutMs);
+		});
+		const cancellationResult = new Promise<never>((_, reject) => {
+			onAbort = () => {
+				if (timeoutError === undefined) reject(abortReason(baseSignal));
+			};
+			if (baseSignal.aborted) onAbort();
+			else baseSignal.addEventListener("abort", onAbort, { once: true });
+		});
+		try {
+			const result = await Promise.race([callbackResult, timeoutResult, cancellationResult]);
+			if (result.kind === "value") return result.value;
+			throw result.error;
+		} finally {
+			cancelDeadline?.();
+			if (onAbort !== undefined) baseSignal.removeEventListener("abort", onAbort);
+		}
+	});
+}
 
 /**
  * Execute one uncached tool call under its own abort controller.
@@ -278,7 +403,7 @@ interface LiveToolInvocation<T extends WorkflowSerializableValue> {
 async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 	live: LiveToolInvocation<T>,
 ): Promise<WorkflowToolInvocationResult<T>> {
-	const { input, node, name, argsHash, ordinal, fn, options, control, returnFailure } = live;
+	const { input, node, name, args, source, argsHash, ordinal, fn, options, control, returnFailure } = live;
 	const nodeController = new AbortController();
 	const toolSignal =
 		input.signal === undefined ? nodeController.signal : AbortSignal.any([input.signal, nodeController.signal]);
@@ -302,9 +427,13 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 		const result = await executeWithRetries(
 			() => {
 				attempts += 1;
-				return runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () =>
-					fn({ signal: toolSignal }),
-				).catch((error: unknown) => {
+				const callback =
+					options?.timeoutMs === undefined
+						? runCallback({ kind: "workflow.ctx_tool", name, runId: input.workflowId }, () =>
+								fn({ signal: toolSignal }),
+							)
+						: executeTimedToolAttempt(name, input.workflowId, fn, toolSignal, options.timeoutMs);
+				return callback.catch((error: unknown) => {
 					callbackError = error;
 					throw error;
 				});
@@ -328,6 +457,8 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 			workflowId: input.workflowId,
 			checkpointId: `tool:${argsHash}`,
 			name,
+			args: cloneToolArgs(args),
+			...(source !== undefined ? { source } : {}),
 			argsHash,
 			output,
 			...(returnFailure ? { outcomeKind: "return_success" as const } : {}),
@@ -347,12 +478,15 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 		input.onNodeEnd?.(node.id, {
 			status: "completed",
 			endedAt: completedAt,
+			durationMs: Math.max(0, completedAt - startedAt),
+			result: output,
 			resultSummary: summarizeToolResult(output),
 		});
 		input.onNodeSettle?.(node.id);
 		return output;
 	} catch (error) {
-		const cancellation = invocationCancellation(input, toolSignal);
+		const timeoutFailure = error instanceof WorkflowToolTimeoutError;
+		const cancellation = timeoutFailure ? undefined : invocationCancellation(input, toolSignal);
 		if (cancellation !== undefined) {
 			control.noteCancelled();
 			// A cancelled call never writes a replayable `tool:` checkpoint and never
@@ -366,9 +500,11 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 			if (returnFailure) {
 				await recordCancelledToolInspection(live, startedAt, cancellation, attempts);
 			}
+			const endedAt = Date.now();
 			input.onNodeEnd?.(node.id, {
 				status: "cancelled",
-				endedAt: Date.now(),
+				endedAt,
+				durationMs: Math.max(0, endedAt - startedAt),
 				error: cancellation.message,
 			});
 			input.onNodeSettle?.(node.id);
@@ -380,11 +516,16 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 			const failure = await recordThrowingToolFailure(
 				input,
 				node,
-				{ name, argsHash, ordinal, startedAt },
+				{ name, args, ...(source !== undefined ? { source } : {}), argsHash, ordinal, startedAt },
 				callbackFailure,
 				attempts,
 			);
-			input.onNodeEnd?.(node.id, { status: "failed", endedAt: failure.failedAt, error: failure.message });
+			input.onNodeEnd?.(node.id, {
+				status: "failed",
+				endedAt: failure.failedAt,
+				durationMs: Math.max(0, failure.failedAt - startedAt),
+				error: failure.message,
+			});
 			input.onNodeSettle?.(node.id);
 			throw callbackFailure;
 		}
@@ -396,6 +537,8 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 				workflowId: input.workflowId,
 				checkpointId: `tool:${argsHash}`,
 				name,
+				args: cloneToolArgs(args),
+				...(source !== undefined ? { source } : {}),
 				argsHash,
 				output: outcome,
 				outcomeKind: "return_failure",
@@ -415,30 +558,44 @@ async function executeLiveToolInvocation<T extends WorkflowSerializableValue>(
 				await recordCheckpointDurably(input.backend, checkpoint);
 			} catch (persistenceError) {
 				input.onFailureObserved?.(persistenceError, node.id);
+				const endedAt = Date.now();
 				input.onNodeEnd?.(node.id, {
 					status: "failed",
-					endedAt: Date.now(),
+					endedAt,
+					durationMs: Math.max(0, endedAt - startedAt),
 					error: persistenceError instanceof Error ? persistenceError.message : String(persistenceError),
 				});
 				input.onNodeSettle?.(node.id);
 				throw persistenceError;
 			}
-			input.onNodeEnd?.(node.id, { status: "failed", endedAt: completedAt, error: outcome.error.message });
+			input.onNodeEnd?.(node.id, {
+				status: "failed",
+				endedAt: completedAt,
+				durationMs: Math.max(0, completedAt - startedAt),
+				result: outcome,
+				error: outcome.error.message,
+			});
 			input.onNodeSettle?.(node.id);
-			throwIfInvocationCancelled(input, toolSignal);
+			if (!timeoutFailure) throwIfInvocationCancelled(input, toolSignal);
 			return outcome;
 		}
-		input.onFailureObserved?.(error, node.id);
+		const reportedFailure = timeoutFailure ? callbackError : error;
+		input.onFailureObserved?.(reportedFailure, node.id);
 		const failure = await recordThrowingToolFailure(
 			input,
 			node,
-			{ name, argsHash, ordinal, startedAt },
-			error,
+			{ name, args, ...(source !== undefined ? { source } : {}), argsHash, ordinal, startedAt },
+			reportedFailure,
 			attempts,
 		);
-		input.onNodeEnd?.(node.id, { status: "failed", endedAt: failure.failedAt, error: failure.message });
+		input.onNodeEnd?.(node.id, {
+			status: "failed",
+			endedAt: failure.failedAt,
+			durationMs: Math.max(0, failure.failedAt - startedAt),
+			error: failure.message,
+		});
 		input.onNodeSettle?.(node.id);
-		throw error;
+		throw reportedFailure;
 	} finally {
 		settlement.resolve();
 		unregisterControl?.();
@@ -464,7 +621,14 @@ async function recordCancelledToolInspection<T extends WorkflowSerializableValue
 		await recordThrowingToolFailure(
 			live.input,
 			live.node,
-			{ name: live.name, argsHash: live.argsHash, ordinal: live.ordinal, startedAt },
+			{
+				name: live.name,
+				args: live.args,
+				...(live.source !== undefined ? { source: live.source } : {}),
+				argsHash: live.argsHash,
+				ordinal: live.ordinal,
+				startedAt,
+			},
 			cancellation,
 			attempts,
 		);
@@ -606,6 +770,8 @@ async function recordReplayedToolTopology(
 		workflowId: input.workflowId,
 		checkpointId: `tool-replay-meta:${durableHash({ argsHash, topology })}`,
 		name: node.name,
+		...(cached.args !== undefined ? { args: cached.args } : {}),
+		...(cached.source !== undefined ? { source: cached.source } : {}),
 		argsHash,
 		output: cached.output,
 		...(cached.outcomeKind !== undefined ? { outcomeKind: cached.outcomeKind } : {}),

package/dist/builtin/workflows/src/durable/types.ts

@@ -112,6 +112,10 @@ export interface DurableToolCheckpoint {
 	readonly checkpointId: string;
 	/** Tool name for display/debugging. */
 	readonly name: string;
+	/** Exact invocation arguments retained for read-only inspection. */
+	readonly args?: Readonly<Record<string, WorkflowSerializableValue>>;
+	/** Callback source captured at registration for read-only inspection. */
+	readonly source?: string;
 	/** Deterministic hash of the tool arguments for idempotency. */
 	readonly argsHash: string;
 	/** Cached tool output (JSON-serializable). */

package/dist/builtin/workflows/src/engine/run-tool-control-registry.ts

@@ -13,6 +13,7 @@
  * cross-ref: issue #2078; src/runs/foreground/stage-control-registry.ts
  */
 
+import { createSessionScopedSingleton } from "../shared/session-scoped-singleton.js";
 import type { WorkflowToolNodeIdentity } from "../shared/types.js";
 import type { ToolAdmissionBoundary } from "./run-tool-admission-boundary.js";
 import { WorkflowToolAbortError, type WorkflowToolAbortScope } from "./workflow-tool-abort.js";
@@ -130,7 +131,14 @@ export function createToolControlRegistry(): ToolControlRegistry {
  * through `RunOpts.toolControlRegistry`; the singleton is the default consumer
  * surface used by the extension factory.
  */
-export const toolControlRegistry: ToolControlRegistry = createToolControlRegistry();
+const SESSION_KEY = "workflows:tool-control:v1";
+const singleton = createSessionScopedSingleton(SESSION_KEY, createToolControlRegistry);
+
+export const toolControlRegistry: ToolControlRegistry = singleton.facade;
+
+export function adoptToolControlRegistry(scope: object): ToolControlRegistry {
+	return singleton.adopt(scope);
+}
 
 /**
  * Await settlement of aborted tool handles up to `timeoutMs` and report the

package/dist/builtin/workflows/src/extension/adopt-session-run-state.ts

@@ -0,0 +1,20 @@
+import { adoptToolControlRegistry } from "../engine/run-tool-control-registry.js";
+import { adoptCancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { adoptJobTracker } from "../runs/background/job-tracker.js";
+import { adoptStageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import { adoptStageUiBroker } from "../shared/stage-ui-broker.js";
+import { adoptStore } from "../shared/store-factory.js";
+
+/**
+ * Re-bind every run-scoped singleton to host session state for `scope`.
+ * No-op when the host has not supplied a scope (unit tests, embedded SDK).
+ */
+export function adoptWorkflowSessionRunState(scope: object | undefined): void {
+	if (scope === undefined) return;
+	adoptStore(scope);
+	adoptStageControlRegistry(scope);
+	adoptCancellationRegistry(scope);
+	adoptToolControlRegistry(scope);
+	adoptJobTracker(scope);
+	adoptStageUiBroker(scope);
+}

package/dist/builtin/workflows/src/extension/background-ui-adapter.ts

@@ -29,6 +29,7 @@
  *   src/tui/graph-view.ts pending-prompt rendering + key handling
  */
 
+import { requirePrimitivePromptAnswer } from "../shared/prompt-answer.js";
 import type { Store } from "../shared/store.js";
 import type { PendingPrompt, PromptKind } from "../shared/store-types.js";
 import type { WorkflowUIAdapter } from "../shared/types.js";
@@ -128,48 +129,26 @@ function fallbackForKind(descriptor: PromptDescriptor): unknown {
 export function buildBackgroundUIAdapter(store: Store, runId: string, signal?: AbortSignal): WorkflowUIAdapter {
 	return {
 		async input(prompt: string): Promise<string> {
-			const response = await ask(store, runId, { kind: "input", message: prompt }, signal);
-			return typeof response === "string" ? response : String(response ?? "");
+			const descriptor = { kind: "input" as const, message: prompt };
+			return requirePrimitivePromptAnswer(descriptor, await ask(store, runId, descriptor, signal)) as string;
 		},
 
 		async confirm(message: string): Promise<boolean> {
-			const response = await ask(store, runId, { kind: "confirm", message }, signal);
-			return response === true;
+			const descriptor = { kind: "confirm" as const, message };
+			return requirePrimitivePromptAnswer(descriptor, await ask(store, runId, descriptor, signal)) as boolean;
 		},
 
 		async select<T extends string>(message: string, options: readonly T[]): Promise<T> {
 			if (options.length === 0) {
 				throw new Error("atomic-workflows: ctx.ui.select requires at least one option");
 			}
-			const response = await ask(
-				store,
-				runId,
-				{
-					kind: "select",
-					message,
-					choices: options,
-				},
-				signal,
-			);
-			if (typeof response === "string" && (options as readonly string[]).includes(response)) {
-				return response as T;
-			}
-			return options[0]!;
+			const descriptor = { kind: "select" as const, message, choices: options };
+			return requirePrimitivePromptAnswer(descriptor, await ask(store, runId, descriptor, signal)) as T;
 		},
 
 		async editor(initial?: string): Promise<string> {
-			const response = await ask(
-				store,
-				runId,
-				{
-					kind: "editor",
-					message: "Edit and save to continue.",
-					initial,
-				},
-				signal,
-			);
-			if (typeof response === "string") return response;
-			return initial ?? "";
+			const descriptor = { kind: "editor" as const, message: "Edit and save to continue.", initial };
+			return requirePrimitivePromptAnswer(descriptor, await ask(store, runId, descriptor, signal)) as string;
 		},
 	};
 }

package/dist/builtin/workflows/src/extension/extension-factory.ts

@@ -8,6 +8,7 @@ import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
 import { buildGraphOverlayAdapter } from "../tui/overlay-adapter.js";
 import { installStoreWidget, installToolExecutionHooks } from "../tui/store-widget-installer.js";
 import type { PostMortemHandleResolution } from "../tui/workflow-attach-pane-types.js";
+import { adoptWorkflowSessionRunState } from "./adopt-session-run-state.js";
 import { registerCompletedStageIntercomAskRouter } from "./completed-stage-intercom-ask.js";
 import { registerWorkflowLifecycleHandlers } from "./extension-lifecycle.js";
 import { createWorkflowExtensionRuntimeState } from "./extension-runtime-state.js";
@@ -68,6 +69,8 @@ function registerIntercomControl(pi: ExtensionAPI, intercomControlRef: { current
 }
 
 function factory(pi: ExtensionAPI): void {
+	adoptWorkflowSessionRunState(pi.events);
+
 	const adapters = buildRuntimeAdapters(pi);
 	const runtimeState = createWorkflowExtensionRuntimeState(pi, adapters);
 	const postMortemResolverDeps = {

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

@@ -47,6 +47,17 @@ function installDbosProcessShutdown(): void {
 	process.once("beforeExit", () => void shutdownDbosQuietly());
 }
 
+/**
+ * `/reload`, `/fork`, `/new`, and `/resume` replace the host session inside
+ * one process that keeps running the workflows. Those reasons must not kill
+ * in-flight runs or drop live executor handles. `startup` and any reason
+ * this code does not recognise still clear: neither names a predecessor
+ * that handed anything over. `/reload` reuses the host bus; the others do not.
+ */
+function replacementStopsWorkflows(reason: string | undefined): boolean {
+	return reason !== "reload" && reason !== "fork" && reason !== "new" && reason !== "resume";
+}
+
 export interface WorkflowLifecycleRegistrationDeps {
 	runtimeState: WorkflowExtensionRuntimeState;
 	storeWidgetRef: { current: (() => void) | null };
@@ -72,28 +83,35 @@ export function registerWorkflowLifecycleHandlers(pi: ExtensionAPI, deps: Workfl
 		const messageLabel = reason === "new" ? "Starting a new session" : "Resuming another session";
 		try {
 			const shouldSwitchSession = await confirmSessionSwitch(
-				`${actionLabel} and stop ${inFlightWorkflowCount} in-flight ${workflowNoun}?`,
-				`${messageLabel} will stop/kill ${inFlightWorkflowCount} in-flight ${workflowNoun} and clear workflow history tied to the current session.`,
+				`${actionLabel} with ${inFlightWorkflowCount} in-flight ${workflowNoun} still running?`,
+				`${messageLabel} keeps ${inFlightWorkflowCount} in-flight ${workflowNoun} running in this process. They stay on the session that started them.`,
 			);
 			if (shouldSwitchSession) return undefined;
 		} catch {
 			return undefined;
 		}
 		const cancelledLabel = reason === "new" ? "New session" : "Resume";
-		ctx?.ui?.notify?.(`${cancelledLabel} cancelled; in-flight workflows were left unchanged.`, "info");
+		ctx?.ui?.notify?.(`${cancelledLabel} cancelled; in-flight workflows keep running.`, "info");
 		return { cancel: true };
 	});
 
-	pi.on("session_start", async (_event, ctx) => {
+	pi.on("session_start", async (event, ctx) => {
+		const reason =
+			typeof event === "object" && event !== null && "reason" in event
+				? (event as { readonly reason?: string }).reason
+				: undefined;
 		runtimeState.resetWorkflowDiscoveryForSession();
 		deAdvertiseAskUserQuestionWhenHeadless(pi, ctx?.hasUI);
 		await runtimeState.ensureWorkflowConfigLoaded();
-		killAllRuns({ store, cancellation: cancellationRegistry, persistence: runtimeState.persistenceRef.current });
-		store.clear();
+		if (replacementStopsWorkflows(reason)) {
+			killAllRuns({ store, cancellation: cancellationRegistry, persistence: runtimeState.persistenceRef.current });
+			store.clear();
+		}
 		clearForms();
 		resetWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState);
 		resetWorkflowHilAnswerNotificationState(runtimeState.hilAnswerNotificationState);
-		stageControlRegistry.clear();
+		if (replacementStopsWorkflows(reason)) stageControlRegistry.clear();
+		else stageControlRegistry.clearDetached();
 		// Named workflows publish lifecycle notices through the normal notification path.
 		runtimeState.setNotificationsActive(true);
 		runtimeState.startWorkflowDiscoveryWarmup(() => {
@@ -141,10 +159,10 @@ export function registerWorkflowLifecycleHandlers(pi: ExtensionAPI, deps: Workfl
 			} finally {
 				stageControlRegistry.clear();
 			}
-		} else {
-			// Every non-quit host-session boundary invalidates detached lazy handles
-			// synchronously, before they can attach to the replacement session.
+		} else if (replacementStopsWorkflows(reason)) {
 			stageControlRegistry.clear();
+		} else {
+			stageControlRegistry.clearDetached();
 		}
 		deps.storeWidgetRef.current?.();
 		deps.storeWidgetRef.current = null;