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

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

@@ -1,424 +0,0 @@
-/**
- * Workflow discovery for workflows extension startup.
- *
- * Supports bundled workflows (shipped with this package) as well as
- * project-local, user-global, settings-project, and settings-global sources
- * loaded from the file system via dynamic import.
- *
- * Supported file extensions: .ts, .js, .mjs, .cjs
- *
- * Precedence order (highest wins on duplicate normalizedName):
- *   1. settings-project — paths listed in config.projectWorkflows
- *   2. project-local    — {cwd}/.atomic/workflows/*.{ts,js,mjs,cjs}
- *   3. settings-global  — paths listed in config.globalWorkflows
- *   4. user-global      — {agentDir}/workflows/*.{ts,js,mjs,cjs}
- *   5. package          — workflow files supplied by Atomic/pi packages
- *   6. bundled          — shipped workflows (skipped when includeBundled=false)
- *
- * Usage:
- *   // Full discovery (all sources):
- *   const result = await discoverWorkflows({ cwd: process.cwd() });
- */
-
-import { join } from "node:path";
-import { CONFIG_DIR_NAMES, getAgentDirs, getProjectConfigPaths } from "@bastani/atomic";
-import * as bundledManifest from "../../builtin/index.js";
-import type { WorkflowDefinition } from "../shared/types.js";
-import type { WorkflowRegistry } from "../workflows/registry.js";
-import { createRegistry } from "../workflows/registry.js";
-import { loadFromDir, loadFromPaths, type WorkflowModuleCandidateRecord } from "./discovery-loaders.js";
-import { validateWorkflowDefinitionShape as validateDefinitionShape } from "./workflow-module-loader.js";
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-/**
- * The source kind for a discovered workflow.
- *
- *   bundled          — shipped with the workflows package
- *   project-local    — found in {cwd}/.atomic/workflows/
- *   user-global      — found in {agentDir}/workflows/
- *   settings-project — listed in DiscoveryConfig.projectWorkflows
- *   settings-global  — listed in DiscoveryConfig.globalWorkflows
- *   package          — supplied by Atomic/pi package workflow resources
- */
-export type DiscoveryKind =
-	| "bundled"
-	| "project-local"
-	| "user-global"
-	| "settings-project"
-	| "settings-global"
-	| "package";
-
-/** Identifies the origin of a discovered workflow definition. */
-export interface DiscoverySource {
-	/** The workflow's normalizedName (registry key). */
-	readonly id: string;
-	/** Where this workflow was discovered from. */
-	readonly kind: DiscoveryKind;
-	/** Human-readable display name as authored. */
-	readonly name: string;
-	/** Absolute file path (undefined for bundled). */
-	readonly filePath?: string;
-	/**
-	 * The configured name (key) under which this workflow was registered in
-	 * settings (e.g. the key in `config.projectWorkflows`).
-	 * Only present for settings-project and settings-global sources loaded
-	 * via a named-entry config map.
-	 */
-	readonly configuredName?: string;
-}
-
-/** Severity of a discovery diagnostic. */
-export type DiagnosticLevel = "error" | "warn";
-
-/**
- * A diagnostic emitted during discovery.
- * Errors indicate a definition was rejected; warnings indicate a recoverable
- * condition (e.g. a duplicate that was skipped).
- *
- * Codes:
- *   INVALID_DEFINITION — failed structural validation
- *   DUPLICATE_NAME     — normalizedName already registered; skipped (warn)
- *   IMPORT_FAILED      — dynamic import of a workflow file threw
- *   PATH_NOT_FOUND     — a config-specified path does not exist
- *   CONFIG_INVALID     — DiscoveryConfig has an invalid structure
- */
-export interface DiscoveryDiagnostic {
-	readonly level: DiagnosticLevel;
-	readonly code: "INVALID_DEFINITION" | "DUPLICATE_NAME" | "IMPORT_FAILED" | "PATH_NOT_FOUND" | "CONFIG_INVALID";
-	readonly message: string;
-	/** Export key, workflow name, or file path associated with this diagnostic. */
-	readonly source?: string;
-}
-
-/**
- * Optional config for settings-based workflow paths.
- * Entries are absolute paths (or resolvable relative paths) to .ts/.js/.mjs/.cjs
- * files that export a default WorkflowDefinition.
- *
- * Both plain string arrays and named entry maps are supported:
- *   - `string[]`          — paths without configured names
- *   - `Record<string, string>` — maps configuredName → path (preserves name in DiscoverySource)
- */
-export interface DiscoveryConfig {
-	/** Paths to project-scoped workflow files (settings-project). */
-	projectWorkflows?: string[] | Record<string, string>;
-	/** Paths to globally-scoped workflow files (settings-global). */
-	globalWorkflows?: string[] | Record<string, string>;
-}
-
-/**
- * Options for discoverWorkflows().
- * All fields have sensible defaults so callers can pass Partial<DiscoveryOptions>.
- */
-export interface DiscoveryOptions {
-	/** Working directory; used as root for project-local discovery. Default: process.cwd() */
-	cwd: string;
-	/** User's home directory; when set, preserves legacy test/compat user-global discovery roots. */
-	homeDir: string;
-	/** User agent config directories in precedence order. Defaults to Atomic's configured agent directories. */
-	agentDirs?: readonly string[];
-	/** Optional extra paths from project/global config. */
-	config?: DiscoveryConfig;
-	/** Workflow files supplied by installed Atomic/pi packages. */
-	packageWorkflowPaths?: string[] | Record<string, string>;
-	/** When false, bundled workflows are excluded. Default: true */
-	includeBundled?: boolean;
-}
-
-/** Result returned by discoverWorkflows(). */
-export interface DiscoveryResult {
-	/** Registry populated with all valid, non-duplicate definitions (precedence-ordered). */
-	readonly registry: WorkflowRegistry;
-	/** One record per successfully registered workflow. */
-	readonly sources: readonly DiscoverySource[];
-	/** All diagnostics (errors + warnings). Empty when all is well. */
-	readonly errors: readonly DiscoveryDiagnostic[];
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function workflowAgentDirs(options: Partial<DiscoveryOptions> | undefined): readonly string[] {
-	if (options?.agentDirs !== undefined) return options.agentDirs;
-	if (options?.homeDir !== undefined) {
-		const homeDir = options.homeDir;
-		return CONFIG_DIR_NAMES.map((name) => join(homeDir, name, "agent"));
-	}
-	return getAgentDirs();
-}
-
-/**
- * Validate DiscoveryConfig shape.
- * Returns null when valid, or a description of the problem.
- */
-function validateConfig(config: unknown): string | null {
-	if (config === null || typeof config !== "object") {
-		return "config must be an object";
-	}
-	const c = config as Record<string, unknown>;
-	for (const field of ["projectWorkflows", "globalWorkflows"] as const) {
-		const val = c[field];
-		if (val !== undefined) {
-			if (Array.isArray(val)) {
-				for (const entry of val) {
-					if (typeof entry !== "string") return `config.${field} entries must be strings`;
-				}
-			} else if (typeof val === "object" && val !== null) {
-				// Named map: Record<string, string>
-				for (const [key, entry] of Object.entries(val as Record<string, unknown>)) {
-					if (typeof entry !== "string") return `config.${field}["${key}"] must be a string path`;
-				}
-			} else {
-				return `config.${field} must be a string array or a Record<string, string> map`;
-			}
-		}
-	}
-	return null;
-}
-
-/** Merge a batch of candidates into registry state, first-seen wins. */
-async function applyBatch(
-	candidates: WorkflowModuleCandidateRecord[],
-	registry: WorkflowRegistry,
-	sources: DiscoverySource[],
-	diagnostics: DiscoveryDiagnostic[],
-): Promise<WorkflowRegistry> {
-	for (const { value, exportKey, kind, filePath, configuredName } of candidates) {
-		const reason = validateDefinitionShape(value);
-		if (reason !== null) {
-			diagnostics.push({
-				level: "error",
-				code: "INVALID_DEFINITION",
-				message: `${kind} export "${exportKey}" rejected: ${reason}`,
-				source: filePath ?? exportKey,
-			});
-			continue;
-		}
-
-		const def = value as WorkflowDefinition;
-		const key = def.normalizedName;
-
-		if (registry.has(key)) {
-			diagnostics.push({
-				level: "warn",
-				code: "DUPLICATE_NAME",
-				message: `${kind} export "${exportKey}" skipped: normalizedName "${key}" already registered`,
-				source: filePath ?? exportKey,
-			});
-			continue;
-		}
-
-		registry = registry.register(def);
-		sources.push({
-			id: key,
-			kind,
-			name: def.name,
-			...(filePath !== undefined ? { filePath } : {}),
-			...(configuredName !== undefined ? { configuredName } : {}),
-		});
-	}
-	return registry;
-}
-
-/** Merge bundled startup candidates with shape-only validation to keep startup seeding synchronous. */
-function applyBatchShapeOnly(
-	candidates: WorkflowModuleCandidateRecord[],
-	registry: WorkflowRegistry,
-	sources: DiscoverySource[],
-	diagnostics: DiscoveryDiagnostic[],
-): WorkflowRegistry {
-	for (const { value, exportKey, kind, filePath, configuredName } of candidates) {
-		const reason = validateDefinitionShape(value);
-		if (reason !== null) {
-			diagnostics.push({
-				level: "error",
-				code: "INVALID_DEFINITION",
-				message: `${kind} export "${exportKey}" rejected: ${reason}`,
-				source: filePath ?? exportKey,
-			});
-			continue;
-		}
-
-		const def = value as WorkflowDefinition;
-		const key = def.normalizedName;
-
-		if (registry.has(key)) {
-			diagnostics.push({
-				level: "warn",
-				code: "DUPLICATE_NAME",
-				message: `${kind} export "${exportKey}" skipped: normalizedName "${key}" already registered`,
-				source: filePath ?? exportKey,
-			});
-			continue;
-		}
-
-		registry = registry.register(def);
-		sources.push({
-			id: key,
-			kind,
-			name: def.name,
-			...(filePath !== undefined ? { filePath } : {}),
-			...(configuredName !== undefined ? { configuredName } : {}),
-		});
-	}
-	return registry;
-}
-
-// ---------------------------------------------------------------------------
-// Main API
-// ---------------------------------------------------------------------------
-
-/**
- * Discover workflows from all configured sources, applying precedence order.
- *
- * Precedence (highest first; first-registered wins on duplicate normalizedName):
- *   1. settings-project — config.projectWorkflows paths
- *   2. project-local    — {cwd}/.atomic/workflows/*.{ts,js,mjs,cjs}
- *   3. settings-global  — config.globalWorkflows paths
- *   4. user-global      — {agentDir}/workflows/*.{ts,js,mjs,cjs}
- *   5. package          — package-supplied workflow files
- *   6. bundled          — shipped workflows (omitted when includeBundled=false)
- */
-export async function discoverWorkflows(options?: Partial<DiscoveryOptions>): Promise<DiscoveryResult> {
-	const cwd = options?.cwd ?? process.cwd();
-	const homeDir = options?.homeDir ?? (await defaultHomeDir());
-	const agentDirs = workflowAgentDirs(options);
-	const config = options?.config;
-	const packageWorkflowPaths = options?.packageWorkflowPaths;
-	const includeBundled = options?.includeBundled !== false;
-
-	const diagnostics: DiscoveryDiagnostic[] = [];
-	const sources: DiscoverySource[] = [];
-	let registry = createRegistry();
-
-	// Validate config if provided
-	let configIsValid = true;
-	if (config !== undefined) {
-		const configErr = validateConfig(config);
-		if (configErr !== null) {
-			diagnostics.push({
-				level: "error",
-				code: "CONFIG_INVALID",
-				message: `DiscoveryConfig is invalid: ${configErr}`,
-				source: "config",
-			});
-			configIsValid = false;
-			// Skip settings-project and settings-global loading for invalid config
-		}
-	}
-
-	// 1. settings-project (highest precedence)
-	if (configIsValid && config !== undefined && config.projectWorkflows !== undefined) {
-		const pw = config.projectWorkflows;
-		const hasEntries = Array.isArray(pw) ? pw.length > 0 : Object.keys(pw).length > 0;
-		if (hasEntries) {
-			const candidates = await loadFromPaths(pw, "settings-project", cwd, diagnostics);
-			registry = await applyBatch(candidates, registry, sources, diagnostics);
-		}
-	}
-
-	// 2. project-local
-	for (const dir of getProjectConfigPaths(cwd, "workflows").reverse()) {
-		const candidates = await loadFromDir(dir, "project-local", diagnostics);
-		registry = await applyBatch(candidates, registry, sources, diagnostics);
-	}
-
-	// 3. settings-global
-	if (configIsValid && config !== undefined && config.globalWorkflows !== undefined) {
-		const gw = config.globalWorkflows;
-		const hasEntries = Array.isArray(gw) ? gw.length > 0 : Object.keys(gw).length > 0;
-		if (hasEntries) {
-			const candidates = await loadFromPaths(gw, "settings-global", homeDir, diagnostics);
-			registry = await applyBatch(candidates, registry, sources, diagnostics);
-		}
-	}
-
-	// 4. user-global — configured Atomic agent dir plus legacy/defaults when applicable.
-	for (const dir of agentDirs.map((agentDir) => join(agentDir, "workflows")).reverse()) {
-		const candidates = await loadFromDir(dir, "user-global", diagnostics);
-		registry = await applyBatch(candidates, registry, sources, diagnostics);
-	}
-
-	// 5. package workflows
-	if (packageWorkflowPaths !== undefined) {
-		const hasEntries = Array.isArray(packageWorkflowPaths)
-			? packageWorkflowPaths.length > 0
-			: Object.keys(packageWorkflowPaths).length > 0;
-		if (hasEntries) {
-			const candidates = await loadFromPaths(packageWorkflowPaths, "package", cwd, diagnostics);
-			registry = await applyBatch(candidates, registry, sources, diagnostics);
-		}
-	}
-
-	// 6. bundled
-	if (includeBundled) {
-		const bundledResult = discoverBundledManifest();
-		// Merge bundled: only register names not already present (lower precedence)
-		for (const def of bundledResult.registry.all()) {
-			const key = def.normalizedName;
-			if (registry.has(key)) {
-				diagnostics.push({
-					level: "warn",
-					code: "DUPLICATE_NAME",
-					message: `Bundled workflow "${key}" skipped: already registered by higher-precedence source`,
-					source: key,
-				});
-				continue;
-			}
-			registry = registry.register(def);
-			sources.push({ id: key, kind: "bundled", name: def.name });
-		}
-		// Propagate bundled diagnostics (e.g. INVALID_DEFINITION within bundled)
-		for (const d of bundledResult.errors) {
-			diagnostics.push(d);
-		}
-	}
-
-	return { registry, sources, errors: diagnostics };
-}
-
-/** Resolve default homeDir using os.homedir(). */
-async function defaultHomeDir(): Promise<string> {
-	const { homedir } = await import("node:os");
-	return homedir();
-}
-
-// ---------------------------------------------------------------------------
-// Startup seed discovery
-// ---------------------------------------------------------------------------
-
-/**
- * Discover all bundled workflow definitions, validate them, and register valid
- * ones into a new WorkflowRegistry.
- *
- * Duplicate policy: first-seen wins (insertion order of the manifest export).
- */
-export function discoverStartupWorkflowsSync(): DiscoveryResult {
-	return discoverBundledManifest();
-}
-
-function discoverBundledManifest(): DiscoveryResult {
-	const manifest = bundledManifest as Record<string, unknown>;
-	const diagnostics: DiscoveryDiagnostic[] = [];
-	const sources: DiscoverySource[] = [];
-	let registry = createRegistry();
-
-	const candidates = Object.entries(manifest).map(([exportKey, value]) => ({
-		value,
-		exportKey,
-		kind: "bundled" as DiscoveryKind,
-	}));
-
-	registry = applyBatchShapeOnly(candidates, registry, sources, diagnostics);
-
-	return { registry, sources, errors: diagnostics };
-}
-
-// ---------------------------------------------------------------------------
-// Re-export types needed by callers (avoids them importing from registry.ts)
-// ---------------------------------------------------------------------------
-export type { WorkflowRegistry };

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

@@ -1,273 +0,0 @@
-/**
- * WorkflowDispatcher — routes tool actions (list, inputs, run) through the
- * WorkflowRegistry + executor.  status/interrupt/resume are handled upstream in
- * index.ts since they operate on in-flight run tracking, not the registry.
- *
- * Design: pure function `dispatch(args, opts)`.  No broad catch — caller sees
- * real errors so bugs surface instead of being swallowed as success-shaped results.
- */
-
-import { getDurableBackend } from "../durable/factory.js";
-import type { CancellationRegistry } from "../runs/background/cancellation-registry.js";
-import { jobTracker as defaultJobTracker, type JobTracker } from "../runs/background/job-tracker.js";
-import { launchDetachedUntilStartup, workflowStartupFailureMessage } from "../runs/background/startup-admission.js";
-import { resolveAndValidateInputs } from "../runs/foreground/executor.js";
-import type { StageAdapters } from "../runs/foreground/stage-runner.js";
-import { resolve_budget } from "../shared/budget.js";
-import { effectiveRunStatus } from "../shared/returned-run-status.js";
-import { deriveInputFields, schemaIsRequired } from "../shared/schema-introspection.js";
-import { store as defaultStore, type Store } from "../shared/store.js";
-import type { WorkflowActor } from "../shared/store-types.js";
-import {
-	INTERACTIVE_WORKFLOW_POLICY,
-	type WorkflowExecutionPolicy,
-	type WorkflowMcpPort,
-	type WorkflowModelCatalogPort,
-	type WorkflowPersistencePort,
-	type WorkflowRuntimeConfig,
-} from "../shared/types.js";
-import type { WorkflowRegistry } from "../workflows/registry.js";
-import type { WorkflowToolArgs } from "./index.js";
-import type { WorkflowInputEntry, WorkflowToolResult } from "./render-result.js";
-import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
-
-type WorkflowRunResult = Extract<WorkflowToolResult, { action: "run" }>;
-
-function failedRunResult(name: string | undefined, runId: string, error: string): WorkflowRunResult {
-	return {
-		action: "run",
-		name,
-		runId,
-		status: "failed",
-		error,
-		stages: [],
-	};
-}
-async function discardUnadmittedRun(runId: string, activeStore: Store): Promise<void> {
-	activeStore.removeRun(runId);
-	const backend = getDurableBackend();
-	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(`workflow ${runId} remained ${deleted.reason}`);
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface DispatcherOpts {
-	/** Registry of compiled workflow definitions. */
-	registry: WorkflowRegistry;
-	/** Stage adapters forwarded to the executor (prompt/complete). */
-	adapters?: StageAdapters;
-	/** Store override (defaults to executor's singleton). */
-	store?: Store;
-	/** Cancellation registry forwarded to the detached runner. */
-	cancellation?: CancellationRegistry;
-	/** Job tracker forwarded to runDetached() for background run management. */
-	jobs?: JobTracker;
-	/** Persistence port forwarded to the executor. */
-	persistence?: WorkflowPersistencePort;
-	/** MCP scope-gating port forwarded to the executor. */
-	mcp?: WorkflowMcpPort;
-	/**
-	 * Resolved runtime configuration. Forwarded to runDetached() so downstream
-	 * tasks (maxDepth, concurrency, statusFile) can consume it.
-	 */
-	config?: WorkflowRuntimeConfig;
-	/** Optional model catalog forwarded to workflow runs for fallback resolution. */
-	models?: WorkflowModelCatalogPort;
-	/** Runtime-derived interaction policy for this dispatch. */
-	policy?: WorkflowExecutionPolicy;
-	/** Who launched this run. Omitted when the launcher is not attributable. */
-	origin?: WorkflowActor;
-	/** Invocation cwd used for workflow execution. */
-	cwd?: string;
-	/** Host-resolved non-default session directory inherited by stages without explicit sessionDir. */
-	defaultSessionDir?: string;
-	/** Cancels only startup admission waiting; the detached run keeps its own lifecycle. */
-	signal?: AbortSignal;
-	/** Reports the exact detached identity before startup admission is awaited. */
-	onRunAccepted?: (runId: string) => void;
-}
-
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-
-/**
- * Dispatch a `list`, `inputs`, or `run` action.
- *
- * Throws for unknown actions or not-found workflows on `run`.
- * Returns a typed `WorkflowToolResult` — no broad catch, no success-shaped errors.
- */
-export async function dispatch(args: WorkflowToolArgs, opts: DispatcherOpts): Promise<WorkflowToolResult> {
-	const action = args.action ?? "run";
-	const name = args.workflow ?? "";
-	const inputs = args.inputs ?? {};
-
-	switch (action) {
-		// -----------------------------------------------------------------------
-		// list — enumerate registered workflow metadata: name, description,
-		// inputs. Single source of truth for the catalogue renderer.
-		// -----------------------------------------------------------------------
-		case "list": {
-			const items = opts.registry.all().map((def) => ({
-				name: def.normalizedName,
-				description: def.description,
-				inputs: Object.entries(def.inputs).map(([iname, schema]) => ({
-					name: iname,
-					required: schemaIsRequired(schema),
-				})),
-			}));
-			return { action: "list", items };
-		}
-
-		// -----------------------------------------------------------------------
-		// inputs — return a workflow's input schema, or a clear not-found result
-		// -----------------------------------------------------------------------
-		case "inputs": {
-			const def = opts.registry.get(name);
-			if (!def) {
-				return {
-					action: "inputs",
-					name,
-					inputs: [],
-					error: `Workflow not found: "${name}"`,
-				};
-			}
-			const inputSchema: WorkflowInputEntry[] = deriveInputFields(def.inputs);
-			return { action: "inputs", name, inputs: inputSchema };
-		}
-
-		// -----------------------------------------------------------------------
-		// run — always dispatched as a background run. The chat editor stays
-		// free; the workflow surfaces progress through the store, the widget,
-		// and the graph viewer overlay. Foreground execution is no longer a
-		// user-facing option — call `run()` directly from src/runs/foreground
-		// /executor.js if you need synchronous semantics in code or tests.
-		// -----------------------------------------------------------------------
-		case "run": {
-			const def = opts.registry.get(name);
-			if (!def) {
-				// Return structured failed result — not-found is a user error, not a bug.
-				// Status "failed" is honest; action is "run" for tool consumers to dispatch on.
-				return {
-					action: "run",
-					name,
-					runId: "",
-					status: "failed",
-					error: `Workflow not found: "${name}"`,
-					stages: [],
-				};
-			}
-
-			const policy = opts.policy ?? INTERACTIVE_WORKFLOW_POLICY;
-			// Pre-validate inputs and budget declarations. The executor would otherwise
-			// reject them deep in the background promise, silently from the caller's
-			// perspective. Catch errors here so the dispatch result names the problem.
-			try {
-				resolveAndValidateInputs(def.inputs, inputs, `workflow "${def.name}"`);
-				resolve_budget({ config: opts.config?.budget, definition: def.budget, run: args.budget });
-			} catch (err) {
-				return failedRunResult(def.name, "", err instanceof Error ? err.message : String(err));
-			}
-
-			const runId = crypto.randomUUID();
-			let launch: ReturnType<typeof launchDetachedUntilStartup>;
-			try {
-				launch = launchDetachedUntilStartup(def, inputs, {
-					registry: opts.registry,
-					adapters: opts.adapters,
-					store: opts.store,
-					cancellation: opts.cancellation,
-					jobs: opts.jobs,
-					persistence: opts.persistence,
-					mcp: opts.mcp,
-					config: opts.config,
-					budget: args.budget,
-					models: opts.models,
-					executionMode: policy.mode,
-					cwd: opts.cwd,
-					defaultSessionDir: opts.defaultSessionDir,
-					...(opts.origin === undefined ? {} : { origin: opts.origin }),
-					runId,
-				});
-			} catch (error) {
-				return failedRunResult(def.name, runId, error instanceof Error ? error.message : String(error));
-			}
-			const { accepted } = launch;
-			opts.onRunAccepted?.(accepted.runId);
-			const admission = await raceWorkflowRequestAbort(launch.wait, opts.signal);
-			if (!admission.started) {
-				const activeStore = opts.store ?? defaultStore;
-				const snapshot = activeStore.runs().find((run) => run.id === accepted.runId);
-				const error = workflowStartupFailureMessage(
-					admission,
-					snapshot?.error,
-					`Workflow run ${accepted.runId} ended before startup admission`,
-				);
-				try {
-					await discardUnadmittedRun(accepted.runId, activeStore);
-				} catch (cleanupError) {
-					return failedRunResult(
-						accepted.name,
-						accepted.runId,
-						`${error}; startup cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
-					);
-				}
-				return failedRunResult(accepted.name, accepted.runId, error);
-			}
-			if (policy.awaitTerminalRun === true) {
-				const tracker = opts.jobs ?? defaultJobTracker;
-				const job = tracker.get(accepted.runId);
-				if (!job) {
-					return failedRunResult(
-						accepted.name,
-						accepted.runId,
-						`Workflow run ${accepted.runId} was accepted but no live job was registered to await`,
-					);
-				}
-				await job.promise;
-				const activeStore = opts.store ?? defaultStore;
-				const snapshot = activeStore.runs().find((run) => run.id === accepted.runId);
-				if (!snapshot) {
-					return failedRunResult(
-						accepted.name,
-						accepted.runId,
-						`Workflow run ${accepted.runId} ended without a retained snapshot`,
-					);
-				}
-				return {
-					action: "run",
-					name: snapshot.name,
-					runId: snapshot.id,
-					status: effectiveRunStatus(snapshot),
-					result: snapshot.result,
-					error: snapshot.error,
-					exited: snapshot.exited,
-					exitReason: snapshot.exitReason,
-					stages: snapshot.stages.map((stage) => structuredClone(stage)),
-				};
-			}
-			return {
-				action: "run",
-				name: accepted.name,
-				runId: accepted.runId,
-				status: accepted.status,
-				message: accepted.message,
-				stages: [],
-			};
-		}
-
-		default:
-			// Status and run-control actions are not routed here; unknown actions are bugs.
-			throw new Error(`WorkflowDispatcher: unknown action "${action}"`);
-	}
-}