@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

package/dist/builtin/workflows/src/extension/runtime-active-block-claim.ts

@@ -1,78 +0,0 @@
-import type { DurableWorkflowBackend } from "../durable/backend.js";
-import { appendRunEnd } from "../shared/persistence-session-entries.js";
-import type { Store } from "../shared/store.js";
-import type { RunSnapshot } from "../shared/store-types.js";
-import type { WorkflowPersistencePort } from "../shared/types.js";
-
-/**
- * Source ids whose active-block resume is currently in flight in this process.
- * Held across the dispatch+finalize window so a concurrent same-session resume
- * cannot double-dispatch; released once the local source is killed (after
- * which same-session routing refuses it). Cross-process concurrent resume is
- * not guarded here — it is the same recoverable, idempotent-replay edge that
- * exists for any durable failed/blocked run.
- */
-const inFlightActiveBlockResumes = new Set<string>();
-
-/**
- * Claim the right to resume an active recoverable block in this process. The
- * durable source is intentionally NOT mutated: it stays `blocked`/resumable so
- * it remains discoverable and recoverable — including a zero-checkpoint
- * first-stage block — if the process dies before the continuation settles.
- */
-export function claimActiveBlockedResume(_backend: DurableWorkflowBackend, sourceId: string): boolean {
-	if (inFlightActiveBlockResumes.has(sourceId)) return false;
-	inFlightActiveBlockResumes.add(sourceId);
-	return true;
-}
-
-/** Release an in-flight claim (dispatch failed, or the source was finalized). */
-export function releaseActiveBlockedClaim(sourceId: string): void {
-	inFlightActiveBlockResumes.delete(sourceId);
-}
-
-/** Remove a continuation that settled before startup admission completed. */
-export async function discardFailedActiveBlockedContinuation(
-	backend: DurableWorkflowBackend,
-	runId: string,
-	store: Store,
-): Promise<void> {
-	store.removeRun(runId);
-	const handle = backend.getWorkflow(runId);
-	if (handle?.status === "running") {
-		backend.setWorkflowStatus(runId, "failed", handle.pendingPrompts, false);
-		await backend.flush();
-	}
-	const deleted = await backend.deleteWorkflowIfInactive(runId);
-	if (!deleted.ok && deleted.reason !== "not_found") {
-		throw new Error(`continuation ${runId} remained ${deleted.reason}`);
-	}
-}
-/**
- * Mark the resumed source killed locally so the same session will not re-resume
- * it. The durable source is intentionally left `blocked`/resumable for
- * cross-session/crash recoverability; killing only the in-session snapshot is
- * safe because same-session resume resolution consults that snapshot.
- */
-export function finalizeResumedActiveBlockedSourceRun(
-	source: RunSnapshot,
-	continuationRunId: string,
-	store: Store,
-	persistence?: WorkflowPersistencePort,
-): void {
-	const error = source.error ?? source.failureMessage ?? `workflow resumed in new run ${continuationRunId}`;
-	const metadata = {
-		...(source.failureKind !== undefined ? { failureKind: source.failureKind } : {}),
-		...(source.failureCode !== undefined ? { failureCode: source.failureCode } : {}),
-		failureRecoverability: "non_recoverable" as const,
-		failureDisposition: "terminal_killed" as const,
-		...(source.failureMessage !== undefined ? { failureMessage: source.failureMessage } : {}),
-		...(source.failedStageId !== undefined ? { failedStageId: source.failedStageId } : {}),
-		resumable: false,
-		...(source.retryAfterMs !== undefined ? { retryAfterMs: source.retryAfterMs } : {}),
-	};
-	const recorded = store.recordRunEnd(source.id, "killed", undefined, error, metadata);
-	if (recorded && persistence !== undefined) {
-		appendRunEnd(persistence, { runId: source.id, status: "killed", error, ...metadata, ts: Date.now() });
-	}
-}

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

@@ -1,174 +0,0 @@
-import type { DurableWorkflowCatalogEntries } from "../durable/backend.js";
-import { listOpenableCompletedWorkflows } from "../durable/completed-catalog.js";
-import {
-	type OpenCompletedDurableResult,
-	openCompletedDurableWorkflow as openCompletedSnapshot,
-} from "../durable/completed-inspection.js";
-import { getDurableBackend } from "../durable/factory.js";
-import {
-	prepareRuntimeDurableResumable,
-	prepareTargetedDurableResumable,
-	purgeSuppressedWorkflowRuns,
-	type ResumeDurableDeps,
-	type ResumeDurableResult,
-	resumeDurableWorkflow as resumeDurableWorkflowAdapter,
-} from "../durable/resume-runtime.js";
-import { inspectTargetedDurableWorkflow, type TargetedDurableInspection } from "../durable/targeted-inspection.js";
-import type { ResumableWorkflowEntry } from "../durable/types.js";
-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 { WorkflowBudget } from "../shared/budget.js";
-import type { Store } from "../shared/store.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";
-
-export interface DurableResumeRuntime {
-	resumeDurableWorkflow(
-		workflowId: string,
-		options?: {
-			readonly policy?: WorkflowExecutionPolicy;
-			readonly actor?: WorkflowActor;
-			readonly budget?: WorkflowBudget;
-		},
-	): Promise<ResumeDurableResult>;
-	inspectDurableWorkflow(workflowId: string): Promise<TargetedDurableInspection>;
-	listDurableResumable(): readonly ResumableWorkflowEntry[];
-	prepareDurableResumable(workflowId?: string): Promise<readonly ResumableWorkflowEntry[]>;
-	prepareDurableCatalog?(): Promise<DurableWorkflowCatalogEntries>;
-	/** Hydrate a bounded set of known DBOS workflow ids. */
-	prepareDurableResumableForIds?(workflowIds: readonly string[]): Promise<readonly ResumableWorkflowEntry[]>;
-	prepareCompletedDurable?(): Promise<readonly ResumableWorkflowEntry[]>;
-	openCompletedDurableWorkflow?(
-		workflowId: string,
-		catalog?: readonly ResumableWorkflowEntry[],
-	): OpenCompletedDurableResult;
-}
-
-export interface DurableResumeRuntimeDeps {
-	readonly registry: WorkflowRegistry;
-	readonly store: Store;
-	readonly adapters?: StageAdapters;
-	readonly runtimeCwd: string;
-	readonly ensureReady: () => Promise<void>;
-	readonly resolveDefaultStageSessionDir?: () => string | undefined;
-	readonly baseRunOpts: (policy?: WorkflowExecutionPolicy) => RunOpts;
-	readonly beforeRestoreCompleted?: (snapshots: readonly RunSnapshot[]) => void;
-	readonly jobs?: JobTracker;
-}
-
-export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): DurableResumeRuntime {
-	const hydrateStoredWorkflowCandidates = async (
-		backend: ReturnType<typeof getDurableBackend>,
-		target?: string,
-	): Promise<void> => {
-		const ids = deps.store
-			.runs()
-			.map((run) => run.id)
-			.filter((id) => target === undefined || id === target);
-		for (const id of ids) await backend.hydrateWorkflow(id);
-	};
-	let preparedCatalog: readonly ResumableWorkflowEntry[] = [];
-	return {
-		async inspectDurableWorkflow(workflowId) {
-			await deps.ensureReady();
-			return await inspectTargetedDurableWorkflow(getDurableBackend(), workflowId);
-		},
-		async resumeDurableWorkflow(workflowId, options): Promise<ResumeDurableResult> {
-			await deps.ensureReady();
-			const backend = getDurableBackend();
-			if (preparedCatalog.length === 0) {
-				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowId);
-			}
-			const resolved = resolveCatalogEntry(workflowId, preparedCatalog);
-			if (resolved !== undefined) await backend.hydrateWorkflow(resolved.workflowId);
-			const adapterDeps: ResumeDurableDeps = {
-				registry: deps.registry,
-				baseRunOpts: {
-					...deps.baseRunOpts(options?.policy),
-					...(options?.budget === undefined ? {} : { budget: options.budget }),
-					...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
-				},
-				durableBackend: backend,
-				resolveDefinition: async (name, cwd) =>
-					(await discoverWorkflows({ cwd: cwd ?? deps.runtimeCwd })).registry.get(name),
-				...(deps.jobs !== undefined ? { jobs: deps.jobs } : {}),
-			};
-			return await resumeDurableWorkflowAdapter(workflowId, adapterDeps, preparedCatalog);
-		},
-		listDurableResumable(): readonly ResumableWorkflowEntry[] {
-			return getDurableBackend().listResumableWorkflows();
-		},
-		async prepareDurableResumable(workflowId) {
-			await deps.ensureReady();
-			const backend = getDurableBackend();
-			try {
-				await hydrateStoredWorkflowCandidates(backend, workflowId);
-				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowId);
-				return preparedCatalog;
-			} finally {
-				purgeSuppressedWorkflowRuns(backend, deps.store);
-			}
-		},
-		async prepareDurableCatalog() {
-			await deps.ensureReady();
-			const backend = getDurableBackend();
-			try {
-				await backend.hydrateResumableWorkflows();
-				await hydrateStoredWorkflowCandidates(backend);
-				const catalog = await backend.prepareWorkflowCatalog();
-				preparedCatalog = catalog.resumable;
-				return catalog;
-			} finally {
-				purgeSuppressedWorkflowRuns(backend, deps.store);
-			}
-		},
-		async prepareDurableResumableForIds(workflowIds) {
-			await deps.ensureReady();
-			const backend = getDurableBackend();
-			try {
-				preparedCatalog = await prepareTargetedDurableResumable(backend, workflowIds);
-				return preparedCatalog;
-			} finally {
-				purgeSuppressedWorkflowRuns(backend, deps.store);
-			}
-		},
-		async prepareCompletedDurable() {
-			await deps.ensureReady();
-			const backend = getDurableBackend();
-			try {
-				await backend.hydrateResumableWorkflows();
-				await hydrateStoredWorkflowCandidates(backend);
-				return listOpenableCompletedWorkflows(backend);
-			} finally {
-				purgeSuppressedWorkflowRuns(backend, deps.store);
-			}
-		},
-		openCompletedDurableWorkflow(workflowId, catalog) {
-			const backend = getDurableBackend();
-			const entry = resolveCatalogEntry(workflowId, catalog ?? []);
-			const handle = backend.getWorkflow(entry?.workflowId ?? workflowId);
-			return openCompletedSnapshot(
-				workflowId,
-				{
-					durableBackend: backend,
-					store: deps.store,
-					adapters: deps.adapters,
-					cwd: handle?.workflowCwd ?? handle?.invocationCwd ?? deps.runtimeCwd,
-					defaultSessionDir: deps.resolveDefaultStageSessionDir?.(),
-					beforeRestore: deps.beforeRestoreCompleted,
-				},
-				catalog,
-			);
-		},
-	};
-}
-
-function resolveCatalogEntry(
-	workflowId: string,
-	catalog: readonly ResumableWorkflowEntry[],
-): ResumableWorkflowEntry | undefined {
-	return catalog.find((entry) => entry.workflowId === workflowId);
-}

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

@@ -1,439 +0,0 @@
-/**
- * ExtensionRuntime — facade that owns the WorkflowRegistry and delegates
- * tool/slash dispatch through the WorkflowDispatcher.
- *
- * Startup seam: callers supply a registry directly (from a discovery worker
- * or createBundledWorkflowRegistry if available) or a list of compiled
- * definitions.  The runtime itself is registry-agnostic.
- *
- * cross-ref: src/extension/dispatcher.ts
- *            src/workflows/registry.ts
- */
-
-import { getDurableBackend, initializeDurableBackend } from "../durable/factory.js";
-import type { CancellationRegistry } from "../runs/background/cancellation-registry.js";
-import type { JobTracker } from "../runs/background/job-tracker.js";
-import { launchDetachedUntilStartup, workflowStartupFailureMessage } from "../runs/background/startup-admission.js";
-import { type RunOpts, resolveAndValidateInputs } from "../runs/foreground/executor.js";
-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, WorkflowActor } from "../shared/store-types.js";
-import type {
-	WorkflowBudget,
-	WorkflowDefinition,
-	WorkflowExecutionPolicy,
-	WorkflowMcpPort,
-	WorkflowModelCatalogPort,
-	WorkflowPersistencePort,
-	WorkflowRuntimeConfig,
-} from "../shared/types.js";
-import type { WorkflowRegistry } from "../workflows/registry.js";
-import { createRegistry } from "../workflows/registry.js";
-import { dispatch } from "./dispatcher.js";
-import type { WorkflowToolArgs } from "./index.js";
-import type { WorkflowToolResult } from "./render-result.js";
-import {
-	claimActiveBlockedResume,
-	discardFailedActiveBlockedContinuation,
-	finalizeResumedActiveBlockedSourceRun,
-	releaseActiveBlockedClaim,
-} from "./runtime-active-block-claim.js";
-import { createDurableResumeRuntime, type DurableResumeRuntime } from "./runtime-durable-resume.js";
-import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface ExtensionRuntimeOpts {
-	/**
-	 * Pre-populated registry — takes precedence over `definitions`.
-	 * Pass the output of a discovery worker / createBundledWorkflowRegistry here.
-	 */
-	registry?: WorkflowRegistry;
-	/**
-	 * Seed definitions used when no registry is provided.
-	 * Typically populated by the discovery worker at startup.
-	 */
-	definitions?: WorkflowDefinition[];
-	/** Stage adapters forwarded to the executor (prompt/complete). */
-	adapters?: StageAdapters;
-
-	/** Store override (defaults to the singleton store). */
-	store?: Store;
-	/** Cancellation registry forwarded to the executor. */
-	cancellation?: CancellationRegistry;
-	/** Persistence port forwarded to the executor. */
-	persistence?: WorkflowPersistencePort;
-	/** MCP scope-gating port forwarded to the executor. */
-	mcp?: WorkflowMcpPort;
-	/**
-	 * Resolved runtime configuration. Injected by the composition root after
-	 * merging file config with defaults. Forwarded to dispatch → run/runDetached.
-	 */
-	config?: WorkflowRuntimeConfig;
-	/** Optional model catalog forwarded to workflow runs for fallback resolution. */
-	models?: WorkflowModelCatalogPort;
-	/** Job tracker forwarded to named detached runs. */
-	jobs?: JobTracker;
-	/** Invocation cwd used for workflow execution. Defaults to process.cwd(). */
-	cwd?: string;
-	/** Resolve the host's non-default session directory for workflow stage transcripts. */
-	resolveDefaultStageSessionDir?: () => string | undefined;
-	/** Seed lifecycle state before historical completed snapshots are restored. */
-	beforeRestoreCompleted?: (snapshots: readonly RunSnapshot[]) => void;
-}
-// ---------------------------------------------------------------------------
-// Public interface
-// ---------------------------------------------------------------------------
-export type ResumeFailedRunResult =
-	| { ok: true; runId: string; sourceRunId: string; resumeFromStageId?: string; message: string }
-	| {
-			ok: false;
-			reason: "run_not_found" | "not_resumable" | "workflow_not_found" | "insufficient_state";
-			message: string;
-	  };
-
-export interface ExtensionRuntime extends DurableResumeRuntime {
-	/**
-	 * Live registry — read-only reference.
-	 * Reflects all definitions registered at startup.
-	 */
-	readonly registry: WorkflowRegistry;
-
-	/**
-	 * Dispatch a `list`, `inputs`, or `run` action.
-	 * Status and run-control actions use the dedicated control modules directly.
-	 */
-	dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult>;
-
-	/** Start a linked continuation for a failed resumable named workflow run. */
-	resumeFailedRun(
-		sourceRunId: string,
-		stageId?: string,
-		options?: RuntimeDispatchOptions,
-	): Promise<ResumeFailedRunResult>;
-}
-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;
-	/** Run-level budget override used when a continuation is launched. */
-	readonly budget?: WorkflowBudget;
-	/** Cancels only the public request/admission wait, never detached execution after acknowledgement. */
-	readonly signal?: AbortSignal;
-	/** Reports the exact detached identity before startup admission is awaited. */
-	readonly onRunAccepted?: (runId: string) => void;
-}
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create an ExtensionRuntime.
- *
- * @example — discovery worker registry
- * ```ts
- * const runtime = createExtensionRuntime({ registry: createBundledWorkflowRegistry() });
- * ```
- *
- * @example — explicit definitions
- * ```ts
- * const runtime = createExtensionRuntime({ definitions: [myWorkflow] });
- * ```
- */
-export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): ExtensionRuntime {
-	const registry = opts.registry ?? createRegistry(opts.definitions ?? []);
-	const adapters = opts.adapters;
-	const activeStore = opts.store ?? defaultStore;
-	const cancellation = opts.cancellation;
-	const persistence = opts.persistence;
-	const mcp = opts.mcp;
-	const config = opts.config;
-	const models = opts.models;
-	const jobs = opts.jobs;
-	const runtimeCwd = opts.cwd ?? process.cwd();
-	const resolveDefaultStageSessionDir = opts.resolveDefaultStageSessionDir;
-	const beforeRestoreCompleted = opts.beforeRestoreCompleted;
-	const ensureDbosReady = async (): Promise<void> => {
-		// Deliberately not memoized: the factory revalidates its memoized backend
-		// against the current DBOS lifecycle generation, so caching a permanently
-		// resolved promise here could mask a backend stopped after a
-		// host-session replacement (issue #1957).
-		await initializeDurableBackend();
-	};
-
-	function runOptions(policy?: WorkflowExecutionPolicy): RunOpts {
-		const defaultSessionDir = resolveDefaultStageSessionDir?.();
-		return {
-			adapters,
-			store: activeStore,
-			cancellation,
-			persistence,
-			mcp,
-			config,
-			models,
-			...(defaultSessionDir !== undefined ? { defaultSessionDir } : {}),
-			...(policy !== undefined ? { executionMode: policy.mode } : {}),
-			registry,
-			cwd: runtimeCwd,
-		};
-	}
-
-	function matchesResumeStageIdentifier(stage: RunSnapshot["stages"][number], identifier: string): boolean {
-		return stage.id === identifier || stage.name === identifier;
-	}
-
-	function stageLabel(stage: RunSnapshot["stages"][number]): string {
-		return `${stage.name} (${stage.id})`;
-	}
-
-	function resolveUniqueResumeStage(
-		source: RunSnapshot,
-		identifier: string,
-	): { ok: true; stage: RunSnapshot["stages"][number] } | { ok: false; message: string } {
-		const exactId = source.stages.find((stage) => stage.id === identifier);
-		if (exactId !== undefined) return { ok: true, stage: exactId };
-
-		const exactNames = source.stages.filter((stage) => stage.name === identifier);
-		if (exactNames.length === 1) return { ok: true, stage: exactNames[0]! };
-		if (exactNames.length > 1) {
-			return {
-				ok: false,
-				message: `insufficient_state: ambiguous stage identifier "${identifier}" matches: ${exactNames.map(stageLabel).join(", ")}`,
-			};
-		}
-
-		const matches = source.stages.filter((stage) => matchesResumeStageIdentifier(stage, identifier));
-		if (matches.length === 0)
-			return { ok: false, message: `insufficient_state: stage not found in source run ${source.id}: ${identifier}` };
-		if (matches.length > 1) {
-			return {
-				ok: false,
-				message: `insufficient_state: ambiguous stage identifier "${identifier}" matches: ${matches.map(stageLabel).join(", ")}`,
-			};
-		}
-		return { ok: true, stage: matches[0]! };
-	}
-
-	function resolveResumeStage(
-		source: RunSnapshot,
-		stageId?: string,
-	): { ok: true; stageId?: string } | { ok: false; message: string } {
-		const budgetExceededSource =
-			source.result?.status === "budget_exceeded" && source.budgetState?.systemOwnedStop === true;
-		if (stageId !== undefined) {
-			const resolved = resolveUniqueResumeStage(source, stageId);
-			if (!resolved.ok) return { ok: false, message: resolved.message };
-			const stage = resolved.stage;
-			if (stage.status !== "failed" && !(budgetExceededSource && stage.id === source.failedStageId))
-				return { ok: false, message: `insufficient_state: stage ${stage.name} is ${stage.status}, not failed` };
-			return { ok: true, stageId: stage.id };
-		}
-		const failedStageId = source.failedStageId ?? source.stages.find((stage) => stage.status === "failed")?.id;
-		if (failedStageId !== undefined) return { ok: true, stageId: failedStageId };
-		if (budgetExceededSource && source.stages.length === 0) return { ok: true };
-		return { ok: false, message: `insufficient_state: failed run ${source.id} does not identify a failed stage` };
-	}
-
-	async function resumeFailedRun(
-		sourceRunId: string,
-		stageId?: string,
-		options?: RuntimeDispatchOptions,
-	): Promise<ResumeFailedRunResult> {
-		const source = activeStore.runs().find((run) => run.id === sourceRunId);
-		if (source === undefined) {
-			return { ok: false, reason: "run_not_found", message: `run not found: ${sourceRunId}` };
-		}
-		const isTerminalFailedResumable =
-			source.status === "failed" && source.endedAt !== undefined && source.resumable !== false;
-		const isBudgetResumable =
-			source.result?.status === "budget_exceeded" && source.budgetState?.systemOwnedStop === true;
-		const isActiveBlockedResumable =
-			(source.endedAt === undefined || isBudgetResumable) &&
-			source.resumable === true &&
-			source.failureRecoverability === "recoverable";
-		if (!isTerminalFailedResumable && !isActiveBlockedResumable) {
-			return { ok: false, reason: "not_resumable", message: `run ${sourceRunId} is not a resumable workflow run` };
-		}
-		const def = registry.get(source.name);
-		if (def === undefined) {
-			return { ok: false, reason: "workflow_not_found", message: `workflow_not_found: ${source.name}` };
-		}
-		const resolvedStage = resolveResumeStage(source, stageId);
-		if (!resolvedStage.ok) {
-			return { ok: false, reason: "insufficient_state", message: resolvedStage.message };
-		}
-		const sourceInputs = { ...source.inputs };
-		try {
-			resolveAndValidateInputs(def.inputs, sourceInputs, `workflow "${def.name}"`);
-		} catch (err) {
-			return {
-				ok: false,
-				reason: "insufficient_state",
-				message: `insufficient_state: ${err instanceof Error ? err.message : String(err)}`,
-			};
-		}
-		const stageMessage = (verb: string, runId: string): string =>
-			`${verb} workflow "${def.name}" from run ${source.id}${resolvedStage.stageId === undefined ? " at workflow start" : ` at stage ${resolvedStage.stageId}`} (run ${runId}).`;
-		const launchContinuation = () =>
-			launchDetachedUntilStartup(def, sourceInputs, {
-				...runOptions(options?.policy),
-				continuation: {
-					source,
-					...(resolvedStage.stageId !== undefined ? { resumeFromStageId: resolvedStage.stageId } : {}),
-				},
-				...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
-				...(jobs !== undefined ? { jobs } : {}),
-				...(options?.budget === undefined ? {} : { budget: options.budget }),
-			});
-		if (isActiveBlockedResumable) {
-			// Keep the durable blocked source recoverable until fresh-ID startup admission succeeds.
-			if (!claimActiveBlockedResume(getDurableBackend(), source.id)) {
-				return {
-					ok: false,
-					reason: "not_resumable",
-					message: `run ${source.id} is already being resumed in this session`,
-				};
-			}
-			let launch: ReturnType<typeof launchContinuation>;
-			try {
-				launch = launchContinuation();
-			} catch (error) {
-				releaseActiveBlockedClaim(source.id);
-				return {
-					ok: false,
-					reason: "insufficient_state",
-					message: `failed to resume run ${source.id}: ${error instanceof Error ? error.message : String(error)}`,
-				};
-			}
-			const { accepted } = launch;
-			const admission = await launch.wait;
-			if (!admission.started) {
-				const startupError = workflowStartupFailureMessage(
-					admission,
-					activeStore.runs().find((run) => run.id === accepted.runId)?.error,
-					`workflow run ${accepted.runId} ended before startup admission`,
-				);
-				try {
-					await discardFailedActiveBlockedContinuation(getDurableBackend(), accepted.runId, activeStore);
-				} catch (error) {
-					releaseActiveBlockedClaim(source.id);
-					return {
-						ok: false,
-						reason: "insufficient_state",
-						message: `continuation for run ${source.id} failed to start (${startupError}) and cleanup failed: ${error instanceof Error ? error.message : String(error)}; source left resumable`,
-					};
-				}
-				releaseActiveBlockedClaim(source.id);
-				return {
-					ok: false,
-					reason: "insufficient_state",
-					message: `continuation for run ${source.id} failed to start: ${startupError}; source left resumable`,
-				};
-			}
-			try {
-				finalizeResumedActiveBlockedSourceRun(source, accepted.runId, activeStore, persistence);
-			} catch (error) {
-				releaseActiveBlockedClaim(source.id);
-				return {
-					ok: false,
-					reason: "insufficient_state",
-					message: `failed to finalize resumed source ${source.id}: ${error instanceof Error ? error.message : String(error)}`,
-				};
-			}
-			releaseActiveBlockedClaim(source.id);
-			return {
-				ok: true,
-				runId: accepted.runId,
-				sourceRunId: source.id,
-				resumeFromStageId: resolvedStage.stageId,
-				message: stageMessage("Resuming blocked", accepted.runId),
-			};
-		}
-		let launch: ReturnType<typeof launchContinuation>;
-		try {
-			launch = launchContinuation();
-		} catch (error) {
-			return {
-				ok: false,
-				reason: "insufficient_state",
-				message: `failed to resume run ${source.id}: ${error instanceof Error ? error.message : String(error)}`,
-			};
-		}
-		const { accepted } = launch;
-		const admission = await launch.wait;
-		if (!admission.started) {
-			const startupError = workflowStartupFailureMessage(
-				admission,
-				activeStore.runs().find((run) => run.id === accepted.runId)?.error,
-				`workflow run ${accepted.runId} ended before startup admission`,
-			);
-			try {
-				await discardFailedActiveBlockedContinuation(getDurableBackend(), accepted.runId, activeStore);
-			} catch (error) {
-				return {
-					ok: false,
-					reason: "insufficient_state",
-					message: `continuation for run ${source.id} failed to start (${startupError}) and cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
-				};
-			}
-			return {
-				ok: false,
-				reason: "insufficient_state",
-				message: `continuation for run ${source.id} failed to start: ${startupError}`,
-			};
-		}
-		return {
-			ok: true,
-			runId: accepted.runId,
-			sourceRunId: source.id,
-			resumeFromStageId: resolvedStage.stageId,
-			message: stageMessage("Resuming failed", accepted.runId),
-		};
-	}
-
-	return {
-		get registry(): WorkflowRegistry {
-			return registry;
-		},
-
-		async dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult> {
-			await raceWorkflowRequestAbort(ensureDbosReady(), options?.signal);
-			const defaultSessionDir = resolveDefaultStageSessionDir?.();
-			return dispatch(args, {
-				registry,
-				adapters,
-				store: activeStore,
-				cancellation,
-				jobs,
-				persistence,
-				mcp,
-				config,
-				models,
-				policy: options?.policy,
-				...(options?.origin === undefined ? {} : { origin: options.origin }),
-				...(options?.signal === undefined ? {} : { signal: options.signal }),
-				...(options?.onRunAccepted === undefined ? {} : { onRunAccepted: options.onRunAccepted }),
-				cwd: runtimeCwd,
-				...(defaultSessionDir !== undefined ? { defaultSessionDir } : {}),
-			});
-		},
-
-		resumeFailedRun,
-		...createDurableResumeRuntime({
-			registry,
-			store: activeStore,
-			adapters,
-			runtimeCwd,
-			ensureReady: ensureDbosReady,
-			resolveDefaultStageSessionDir,
-			baseRunOpts: (policy) => runOptions(policy),
-			beforeRestoreCompleted,
-			...(jobs !== undefined ? { jobs } : {}),
-		}),
-	};
-}