@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,220 +0,0 @@
-import type { DurableBoundaryRuntimeIdentity } from "../durable/boundary-topology.js";
-import {
-	createWorkflowBoundaryFactory,
-	type WorkflowBoundaryStage,
-} from "../runs/foreground/executor-child-boundary.js";
-import type { ContinuationReplayIndex } from "../runs/foreground/executor-continuation.js";
-import type { GitWorktreeSetupCache } from "../runs/foreground/executor-direct-helpers.js";
-import type { WorkflowExitManager } from "../runs/foreground/executor-exit-manager.js";
-import type { StageScheduler } from "../runs/foreground/executor-scheduler.js";
-import { createWorkflowStageFactory } from "../runs/foreground/executor-stage-factory.js";
-import type { LiveStageRuntime, StageContextWithMeta, StageMcpScope } from "../runs/foreground/executor-stage-types.js";
-import type { ParallelFailFastScope } from "../runs/foreground/executor-types.js";
-import type { StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
-import type { StageAdapters } from "../runs/foreground/stage-runner.js";
-import type { ConcurrencyLimiter } from "../runs/shared/concurrency.js";
-import { workflowInvocationIntercomGroup } from "../shared/intercom-group.js";
-import type { Store } from "../shared/store.js";
-import type { RunSnapshot } from "../shared/store-types.js";
-import type { StageOptions } from "../shared/types.js";
-import type { GraphFrontierTracker } from "./graph-inference.js";
-import type { EngineChildRunOptions, EngineStageRuntimeOptions, EngineWorkflowBoundaryOptions } from "./options.js";
-import type { RunBudgetController } from "./run-budget.js";
-
-export interface EngineRuntimeInput {
-	readonly runId: string;
-	readonly depth: number;
-	readonly runSnapshot: RunSnapshot;
-	readonly activeStore: Store;
-	readonly stageOptions: EngineStageRuntimeOptions;
-	readonly workflowBoundaryOptions: EngineWorkflowBoundaryOptions;
-	readonly childRunOptions: EngineChildRunOptions;
-	readonly parentRootRunId?: string;
-	readonly adapters: StageAdapters;
-	readonly signal: AbortSignal;
-	readonly tracker: GraphFrontierTracker;
-	readonly scheduler: StageScheduler;
-	readonly replayIndex: ContinuationReplayIndex;
-	readonly limiter: ConcurrencyLimiter;
-	readonly inputRuntimeDefaults: Partial<StageOptions>;
-	readonly workflowInvocationCwd: string;
-	readonly gitWorktreeSetupCache: GitWorktreeSetupCache;
-	readonly worktreeSymlinkDirectories?: readonly string[];
-	readonly stageRegistry: StageControlRegistry;
-	readonly exit: WorkflowExitManager;
-	readonly budget: RunBudgetController;
-	readonly rootBudget: RunBudgetController;
-	readonly classifyExecutorFailure: LiveStageRuntime["classifyExecutorFailure"];
-}
-
-export interface EngineSpawnAgentStageOptions {
-	readonly kind?: "agent";
-	readonly options?: StageOptions;
-	readonly failFastScope?: ParallelFailFastScope;
-}
-
-export interface EngineSpawnWorkflowBoundaryOptions {
-	readonly kind: "workflow-boundary";
-	readonly replayKey: string;
-	readonly identity?: DurableBoundaryRuntimeIdentity;
-}
-
-export type EngineSpawnStageOptions = EngineSpawnAgentStageOptions | EngineSpawnWorkflowBoundaryOptions;
-
-export interface EngineAgentStageHandle {
-	readonly kind: "agent";
-	readonly context: StageContextWithMeta;
-}
-
-export interface EngineWorkflowBoundaryHandle {
-	readonly kind: "workflow-boundary";
-	readonly boundary: WorkflowBoundaryStage;
-}
-
-export type StageHandle = EngineAgentStageHandle | EngineWorkflowBoundaryHandle;
-
-export class EngineRuntime {
-	readonly runId: string;
-	readonly workflowIntercomGroup: string;
-	readonly depth: number;
-	readonly activeStore: Store;
-	readonly childRunOptions: EngineChildRunOptions;
-	readonly parentRootRunId?: string;
-	readonly adapters: StageAdapters;
-	readonly signal: AbortSignal;
-	readonly tracker: GraphFrontierTracker;
-	readonly exit: WorkflowExitManager;
-	readonly inputRuntimeDefaults: Partial<StageOptions>;
-	readonly workflowInvocationCwd: string;
-	readonly budget: RunBudgetController;
-	readonly rootBudget: RunBudgetController;
-	readonly gitWorktreeSetupCache: GitWorktreeSetupCache;
-	readonly worktreeSymlinkDirectories?: readonly string[];
-
-	private readonly spawnAgentStage: (
-		name: string,
-		options?: StageOptions,
-		stageFailFastScope?: ParallelFailFastScope,
-	) => StageContextWithMeta;
-	private readonly spawnWorkflowBoundary: (
-		name: string,
-		replayKey: string,
-		identity?: DurableBoundaryRuntimeIdentity,
-	) => WorkflowBoundaryStage;
-
-	constructor(input: EngineRuntimeInput) {
-		this.runId = input.runId;
-		this.workflowIntercomGroup = workflowInvocationIntercomGroup(input.parentRootRunId ?? input.runId);
-		this.depth = input.depth;
-		this.activeStore = input.activeStore;
-		this.childRunOptions = input.childRunOptions;
-		this.parentRootRunId = input.parentRootRunId;
-		this.adapters = input.adapters;
-		this.signal = input.signal;
-		this.tracker = input.tracker;
-		this.exit = input.exit;
-		this.inputRuntimeDefaults = input.inputRuntimeDefaults;
-		this.workflowInvocationCwd = input.workflowInvocationCwd;
-		this.budget = input.budget;
-		this.rootBudget = input.rootBudget;
-		this.gitWorktreeSetupCache = input.gitWorktreeSetupCache;
-		this.worktreeSymlinkDirectories = input.worktreeSymlinkDirectories;
-
-		// The runtime only wires host-injected ports; stage sessions are still
-		// created lazily by the stage runner through input.adapters.agentSession.
-		this.spawnAgentStage = createWorkflowStageFactory({
-			runId: input.runId,
-			workflowIntercomGroup: this.workflowIntercomGroup,
-			activeStore: input.activeStore,
-			opts: input.stageOptions,
-			adapters: input.adapters,
-			signal: input.signal,
-			tracker: input.tracker,
-			scheduler: input.scheduler,
-			replayIndex: input.replayIndex,
-			limiter: input.limiter,
-			inputRuntimeDefaults: input.inputRuntimeDefaults,
-			workflowInvocationCwd: input.workflowInvocationCwd,
-			gitWorktreeSetupCache: input.gitWorktreeSetupCache,
-			stageRegistry: input.stageRegistry,
-			budget: input.budget,
-			exit: input.exit,
-			classifyExecutorFailure: input.classifyExecutorFailure,
-			createMcpScope: (stageId, options) => this.createMcpScope(stageId, options),
-		});
-		this.spawnWorkflowBoundary = createWorkflowBoundaryFactory({
-			runId: input.runId,
-			runSnapshot: input.runSnapshot,
-			activeStore: input.activeStore,
-			opts: input.workflowBoundaryOptions,
-			tracker: input.tracker,
-			replayIndex: input.replayIndex,
-			registerWorkflowExitCleanup: input.exit.registerWorkflowExitCleanup,
-			workflowExitSkippedReason: input.exit.workflowExitSkippedReason,
-			classifyExecutorFailure: input.classifyExecutorFailure,
-		});
-	}
-
-	spawnStage(name: string, opts: EngineSpawnWorkflowBoundaryOptions): EngineWorkflowBoundaryHandle;
-	spawnStage(name: string, opts?: EngineSpawnAgentStageOptions): EngineAgentStageHandle;
-	spawnStage(name: string, opts: EngineSpawnStageOptions = {}): StageHandle {
-		if (opts.kind === "workflow-boundary") {
-			return {
-				kind: "workflow-boundary",
-				boundary: this.spawnWorkflowBoundary(name, opts.replayKey, opts.identity),
-			};
-		}
-		return { kind: "agent", context: this.spawnAgentStage(name, opts.options, opts.failFastScope) };
-	}
-
-	readonly stage = (
-		name: string,
-		options?: StageOptions,
-		failFastScope?: ParallelFailFastScope,
-	): StageContextWithMeta => {
-		if (this.budget.enabled) this.budget.stopAtBoundary();
-		const handle = this.spawnStage(name, {
-			kind: "agent",
-			...(options !== undefined ? { options } : {}),
-			...(failFastScope !== undefined ? { failFastScope } : {}),
-		});
-		return handle.context;
-	};
-
-	private createMcpScope(stageId: string, options: StageOptions | undefined): StageMcpScope {
-		const allow = options?.mcp?.allow ?? null;
-		const deny = options?.mcp?.deny ?? null;
-		const hasScope = allow !== null || deny !== null;
-		let depth = 0;
-		return {
-			apply: () => {
-				if (!this.childRunOptions.mcp || !hasScope) return;
-				if (depth > 0) {
-					depth += 1;
-					return;
-				}
-				depth = 1;
-				try {
-					this.childRunOptions.mcp.setScope(stageId, allow, deny);
-				} catch (error) {
-					depth = 0;
-					try {
-						this.childRunOptions.mcp.clearScope(stageId);
-					} catch (cleanupError) {
-						throw new AggregateError(
-							[error, cleanupError],
-							"MCP scope setup failed and compensating cleanup failed",
-						);
-					}
-					throw error;
-				}
-			},
-			clear: () => {
-				if (!this.childRunOptions.mcp || !hasScope) return;
-				if (depth === 0) return;
-				depth -= 1;
-				if (depth === 0) this.childRunOptions.mcp.clearScope(stageId);
-			},
-		};
-	}
-}

package/dist/builtin/workflows/src/engine/workflow-activity.ts

@@ -1,13 +0,0 @@
-import { runCallback } from "@bastani/atomic";
-
-export function nextEventLoopTurn(): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-export function runWorkflowDefinitionCallback<T>(
-	name: string,
-	runId: string,
-	callback: () => T | Promise<T>,
-): Promise<T> {
-	return runCallback({ kind: "workflow.run", name, runId }, callback);
-}

package/dist/builtin/workflows/src/engine/workflow-tool-abort.ts

@@ -1,92 +0,0 @@
-/**
- * Cancellation reasons for in-flight `ctx.tool` graph nodes.
- *
- * A tool node can be aborted on its own (`/workflow interrupt|quit` naming the
- * node) or as part of a graceful run-level quit. Both use `AbortError` as the
- * error name so the existing callback-cancellation classification and any
- * author code that checks `err.name === "AbortError"` keep working; the `scope`
- * field is what separates a single-node abort from a graceful run quit.
- *
- * cross-ref: issue #2078 — in-flight ctx.tool calls cannot be quit.
- */
-
-export type WorkflowToolAbortScope = "node" | "quit";
-
-export interface WorkflowToolAbortInput {
-	readonly runId: string;
-	readonly nodeId: string;
-	readonly toolName: string;
-	readonly scope: WorkflowToolAbortScope;
-}
-
-/** Abort reason handed to a tool node's `AbortController`. */
-export class WorkflowToolAbortError extends Error {
-	readonly runId: string;
-	readonly nodeId: string;
-	readonly toolName: string;
-	readonly scope: WorkflowToolAbortScope;
-
-	constructor(input: WorkflowToolAbortInput) {
-		super(
-			`atomic-workflows: ctx.tool ${input.toolName} aborted by ${
-				input.scope === "quit" ? "workflow quit" : "node abort"
-			}`,
-		);
-		this.name = "AbortError";
-		this.runId = input.runId;
-		this.nodeId = input.nodeId;
-		this.toolName = input.toolName;
-		this.scope = input.scope;
-	}
-}
-
-export function isWorkflowToolAbortError(value: unknown): value is WorkflowToolAbortError {
-	return value instanceof WorkflowToolAbortError;
-}
-
-/** Exit reason a gracefully quit run reports instead of a terminal status. */
-export const WORKFLOW_GRACEFUL_QUIT_EXIT_REASON = "quit";
-
-/**
- * Suspension raised at a nested `ctx.workflow(...)` boundary whose child run was
- * gracefully quit. It carries the quit through the parent so the parent also
- * suspends instead of recording a terminal child failure.
- */
-export class WorkflowGracefulQuitError extends Error {
-	readonly runId: string;
-
-	constructor(runId: string, detail: string) {
-		super(`atomic-workflows: ${detail} suspended by workflow quit`);
-		this.name = "AbortError";
-		this.runId = runId;
-	}
-}
-
-export type WorkflowGracefulQuitSignal = WorkflowToolAbortError | WorkflowGracefulQuitError;
-
-function isGracefulQuitSignal(value: unknown): value is WorkflowGracefulQuitSignal {
-	if (value instanceof WorkflowGracefulQuitError) return true;
-	return isWorkflowToolAbortError(value) && value.scope === "quit";
-}
-
-/**
- * Find a graceful run-quit suspension in an error or its cause chain.
- *
- * Depth-bounded so a self-referential cause cannot spin, and every property
- * read is guarded: control-signal probing must never let a throwing accessor
- * on a foreign error escape into run finalization.
- */
-export function findWorkflowGracefulQuit(value: unknown): WorkflowGracefulQuitSignal | undefined {
-	let current: unknown = value;
-	for (let depth = 0; depth < 8; depth++) {
-		if (isGracefulQuitSignal(current)) return current;
-		if (typeof current !== "object" || current === null) return undefined;
-		try {
-			if (!("cause" in current)) return undefined;
-			current = (current as { readonly cause?: unknown }).cause;
-		} catch {
-			return undefined;
-		}
-	}
-	return undefined;
-}

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

@@ -1,20 +0,0 @@
-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/atomic-stage-session.ts

@@ -1,168 +0,0 @@
-import { basename } from "node:path";
-import type {
-	CreateAgentSessionOptions,
-	DefaultResourceLoaderInheritanceSnapshot,
-	PackageSource,
-	SubagentChildPolicy,
-} from "@bastani/atomic";
-import type { StageSessionRuntime } from "../runs/foreground/stage-runner.js";
-
-export interface PiSdkSettingsManager {
-	getCodexFastModeSettings(): { readonly chat: boolean; readonly workflow: boolean };
-	getRetrySettings?(): { readonly enabled: boolean; readonly maxRetries: number; readonly baseDelayMs: number };
-}
-
-export interface PiSdkResourceLoader {
-	reload(): Promise<void>;
-}
-
-interface PiSdkSessionManager {
-	getCwd(): string;
-}
-
-export interface PiCodingAgentSdk {
-	getAgentDir(): string;
-	getBuiltinPackagePaths?: () => string[];
-	SettingsManager: {
-		create(cwd?: string, agentDir?: string, options?: { projectTrusted?: boolean }): PiSdkSettingsManager;
-	};
-	DefaultResourceLoader: new (options: {
-		cwd: string;
-		agentDir: string;
-		settingsManager?: PiSdkSettingsManager;
-		builtinPackagePaths?: PackageSource[];
-		resourceLoaderInheritanceSnapshot?: DefaultResourceLoaderInheritanceSnapshot;
-	}) => PiSdkResourceLoader;
-	createAgentSession(options?: AtomicCreateAgentSessionOptions): Promise<{ session: StageSessionRuntime }>;
-}
-
-export type AtomicCreateAgentSessionOptions = Omit<
-	CreateAgentSessionOptions,
-	"settingsManager" | "resourceLoader" | "sessionManager"
-> & {
-	settingsManager?: PiSdkSettingsManager;
-	resourceLoader?: PiSdkResourceLoader;
-	sessionManager?: PiSdkSessionManager;
-};
-
-export interface PrepareAtomicStageSessionOptions {
-	resourceLoaderInheritanceSnapshot?: DefaultResourceLoaderInheritanceSnapshot;
-	onSettingsManager?: (settingsManager: PiSdkSettingsManager) => void;
-}
-/**
- * Workflow stages are top-level sessions that carry a policy object; they are
- * not subagent children. They keep full management and are authorized to
- * delegate, as `packages/coding-agent/docs/workflows.md` documents. Nesting
- * stays bounded by the depth guard in the subagent executor.
- */
-const WORKFLOW_STAGE_SUBAGENT_POLICY: SubagentChildPolicy = {
-	managementActions: "full",
-	fanoutAuthorized: true,
-	inheritProjectContext: true,
-	inheritSkills: true,
-};
-function resolveSessionCwd(options: AtomicCreateAgentSessionOptions | undefined): string {
-	return options?.cwd ?? options?.sessionManager?.getCwd() ?? process.cwd();
-}
-
-/**
- * Prepare Atomic SDK stage-session options with Atomic-first resource loading.
- *
- * The Atomic SDK's documented defaults are intentionally significant:
- * omitted `agentDir` means credentials/models/settings can be read from the
- * primary `~/.atomic/agent` paths first while still considering legacy
- * `~/.pi/agent` compatibility paths when the SDK supports multiple config
- * directories. Passing the computed default back as an explicit `agentDir`
- * would accidentally turn that multi-dir behavior into a single-dir override.
- *
- * A user-supplied `agentDir` is still preserved exactly and remains an
- * explicit override. A user-supplied `resourceLoader` is also preserved; in
- * that case cwd/agentDir no longer control resource discovery and only affect
- * session naming/tool path resolution, matching the pi SDK docs.
- */
-export async function prepareAtomicStageSessionOptions(
-	options: CreateAgentSessionOptions | undefined,
-	sdk: PiCodingAgentSdk,
-	prepareOptions: PrepareAtomicStageSessionOptions = {},
-): Promise<AtomicCreateAgentSessionOptions | undefined> {
-	const atomicOptions = options as AtomicCreateAgentSessionOptions | undefined;
-	if (atomicOptions?.resourceLoader !== undefined) return atomicOptions;
-
-	const inheritanceSnapshot = prepareOptions.resourceLoaderInheritanceSnapshot;
-	const cwd = resolveSessionCwd(atomicOptions);
-	const hasAgentDirOverride = atomicOptions?.agentDir !== undefined;
-	const agentDir = atomicOptions?.agentDir ?? sdk.getAgentDir();
-	const settingsManager =
-		atomicOptions?.settingsManager ??
-		sdk.SettingsManager.create(
-			cwd,
-			agentDir,
-			inheritanceSnapshot?.projectTrusted === undefined
-				? undefined
-				: { projectTrusted: inheritanceSnapshot.projectTrusted },
-		);
-	prepareOptions.onSettingsManager?.(settingsManager);
-	const inheritedBuiltinPackagePaths = inheritanceSnapshot?.builtinPackagePaths;
-	const builtinPackagePaths =
-		inheritedBuiltinPackagePaths === undefined
-			? (sdk.getBuiltinPackagePaths?.() ?? [])
-			: [...inheritedBuiltinPackagePaths];
-	const resourceLoader = new sdk.DefaultResourceLoader({
-		cwd,
-		agentDir,
-		settingsManager,
-		resourceLoaderInheritanceSnapshot: inheritanceSnapshot,
-		builtinPackagePaths: stageBuiltinPackagePaths(builtinPackagePaths),
-	});
-	await reloadWorkflowStageResources(resourceLoader);
-
-	return {
-		...atomicOptions,
-		cwd,
-		...(hasAgentDirOverride ? { agentDir } : {}),
-		settingsManager,
-		resourceLoader,
-		subagentPolicy: WORKFLOW_STAGE_SUBAGENT_POLICY,
-	};
-}
-
-function clonePackageSource(source: PackageSource): PackageSource {
-	if (typeof source === "string") return source;
-	return {
-		source: source.source,
-		...(source.extensions === undefined ? {} : { extensions: [...source.extensions] }),
-		...(source.skills === undefined ? {} : { skills: [...source.skills] }),
-		...(source.prompts === undefined ? {} : { prompts: [...source.prompts] }),
-		...(source.themes === undefined ? {} : { themes: [...source.themes] }),
-		...(source.workflows === undefined ? {} : { workflows: [...source.workflows] }),
-	};
-}
-
-function packageSourcePath(source: PackageSource): string {
-	return typeof source === "string" ? source : source.source;
-}
-
-function disablePackageExtensions(source: PackageSource): PackageSource {
-	if (typeof source === "string") return { source, extensions: [] };
-	return { ...source, extensions: [] };
-}
-
-function stageBuiltinPackagePaths(paths: readonly PackageSource[]): PackageSource[] {
-	// Workflow stages are child AgentSessions owned by the workflow extension.
-	// Loading the workflows extension again inside that child session replays its
-	// `session_start` lifecycle and clears/kills the parent workflow store. Keep
-	// the workflows package itself so its bundled skills/prompts/resources remain
-	// available, but disable only its extension entry for stage sessions.
-	return paths.map((path) => {
-		const cloned = clonePackageSource(path);
-		return basename(packageSourcePath(cloned)) === "workflows" ? disablePackageExtensions(cloned) : cloned;
-	});
-}
-
-let workflowStageResourceReloadQueue: Promise<void> = Promise.resolve();
-
-async function reloadWorkflowStageResources(resourceLoader: PiSdkResourceLoader): Promise<void> {
-	const queuedReload = workflowStageResourceReloadQueue.then(() => resourceLoader.reload());
-	workflowStageResourceReloadQueue = queuedReload.catch(() => undefined);
-	return queuedReload;
-}

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

@@ -1,154 +0,0 @@
-/**
- * Legacy background workflow HIL adapter — bridges
- * `ctx.ui.input/confirm/select/editor` to run-level store-backed pending
- * prompts instead of pi.ui modal dialogs.
- *
- * Normal detached workflow runs now use executor-owned synthetic prompt nodes
- * backed by `StageSnapshot.pendingPrompt`; this adapter remains for tests and
- * non-executor fallback callers that still need the run-level graph overlay:
- *
- *   1. Stage calls `ctx.ui.editor(prefill)`
- *   2. Adapter records a `PendingPrompt` on the run via the store
- *   3. Adapter awaits resolution (Promise stays pending; chat editor is free)
- *   4. User presses F2 / `/workflow connect <id>` — graph viewer mounts
- *   5. Graph viewer shows the prompt card; user types + submits
- *   6. Graph viewer calls `store.resolvePendingPrompt(runId, promptId, value)`
- *   7. Adapter promise resolves; workflow body continues
- *
- * If the run terminates (kill / abort) before the user responds, the awaiter
- * rejects via `recordRunEnd` so the executor can finalise cleanly — no leaked
- * pending promises.
- *
- * @internal Legacy fallback retained for tests and non-executor callers.
- * TODO(workflows): delete after all tests and fallback entrypoints migrate to
- * executor-owned synthetic prompt nodes.
- *
- * cross-ref:
- *   src/shared/store-types.ts PendingPrompt
- *   src/shared/store.ts recordPendingPrompt / resolvePendingPrompt / awaitPendingPrompt
- *   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";
-
-type BackgroundPromptKind = Exclude<PromptKind, "custom">;
-
-interface PromptDescriptor {
-	readonly kind: BackgroundPromptKind;
-	readonly message: string;
-	readonly choices?: readonly string[];
-	readonly initial?: string;
-}
-
-function nextPromptId(): string {
-	// Crypto-strong is overkill here; runId already provides isolation. A short
-	// random suffix keeps the id readable in debug logs.
-	return `hil-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function ask(
-	store: Store,
-	runId: string,
-	descriptor: PromptDescriptor,
-	signal: AbortSignal | undefined,
-): Promise<unknown> {
-	if (signal?.aborted) {
-		// Pre-aborted: don't record a prompt that won't be answered. Resolve to
-		// a kind-appropriate default so the workflow body unwinds without
-		// throwing — the executor's post-body abort check finalises as "killed".
-		return Promise.resolve(fallbackForKind(descriptor));
-	}
-	const prompt: PendingPrompt = {
-		id: nextPromptId(),
-		kind: descriptor.kind,
-		message: descriptor.message,
-		...(descriptor.choices !== undefined ? { choices: descriptor.choices } : {}),
-		...(descriptor.initial !== undefined ? { initial: descriptor.initial } : {}),
-		createdAt: Date.now(),
-	};
-	const accepted = store.recordPendingPrompt(runId, prompt);
-	if (!accepted) {
-		// Run missing, terminal, or already has a pending prompt. Resolve with a
-		// safe default rather than throwing — workflow authors don't need to
-		// defensively try/catch every HIL call.
-		return Promise.resolve(fallbackForKind(descriptor));
-	}
-	const waiter = store.awaitPendingPrompt(runId, prompt.id);
-	if (!signal) return waiter;
-	// Race against abort so kill() doesn't leave the workflow body wedged on
-	// a HIL await nobody will answer. We also forward a default response into
-	// the store so any concurrent observer sees the prompt cleared.
-	return new Promise<unknown>((resolve, reject) => {
-		const onAbort = (): void => {
-			store.resolvePendingPrompt(runId, prompt.id, fallbackForKind(descriptor));
-			reject(signal.reason instanceof Error ? signal.reason : new Error("atomic-workflows: HIL aborted"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		waiter.then(
-			(value) => {
-				signal.removeEventListener("abort", onAbort);
-				resolve(value);
-			},
-			(err: unknown) => {
-				signal.removeEventListener("abort", onAbort);
-				reject(err);
-			},
-		);
-	});
-}
-
-function fallbackForKind(descriptor: PromptDescriptor): unknown {
-	switch (descriptor.kind) {
-		case "input":
-		case "editor":
-			return descriptor.initial ?? "";
-		case "confirm":
-			return false;
-		case "select":
-			return descriptor.choices?.[0] ?? "";
-	}
-}
-
-/**
- * Build a legacy `WorkflowUIAdapter` whose methods record prompts on `runId`
- * via the store and await user response through the graph viewer overlay.
- *
- * Detached workflow execution normally uses node-local prompt stages instead.
- * `pi.ui.editor`, `pi.ui.confirm`, etc. are still intentionally never invoked
- * from inside a background run. The chat editor stays free; fallback callers
- * attend to run-level prompts via F2 / the `/workflow connect` overlay.
- *
- * `signal` is the run's `AbortController.signal`; when fired (e.g. via
- * `/workflow interrupt <id>`), any HIL waiter rejects so the workflow body
- * unwinds instead of hanging. Pass `undefined` only in tests where you
- * drive resolution directly via `store.resolvePendingPrompt`.
- */
-export function buildBackgroundUIAdapter(store: Store, runId: string, signal?: AbortSignal): WorkflowUIAdapter {
-	return {
-		async input(prompt: string): Promise<string> {
-			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 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 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 descriptor = { kind: "editor" as const, message: "Edit and save to continue.", initial };
-			return requirePrimitivePromptAnswer(descriptor, await ask(store, runId, descriptor, signal)) as string;
-		},
-	};
-}