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

package/dist/builtin/workflows/src/shared/stage-prompt.ts

@@ -1,338 +0,0 @@
-/**
- * stage-prompt — headless answering for brokered in-stage prompts.
- *
- * A workflow stage's agent can call the `ask_user_question` tool, and the
- * executor raises a deterministic readiness gate after such a turn. Both
- * render their UI through {@link StageUiBroker.requestCustomUi} and resolve the
- * tool's `ctx.ui.custom<QuestionnaireResult>()` promise with a
- * `QuestionnaireResult`-shaped value. That value is normally produced by the
- * interactive TUI component.
- *
- * For programmatic / non-interactive control (e.g. an orchestrating agent
- * answering via `workflow send`), we need to synthesize the same value WITHOUT
- * the TUI. This module:
- *   1. Parses the `ask_user_question` tool args into a serializable
- *      {@link StageInputRequest} descriptor (surfaced on the stage snapshot so
- *      `workflow send` / status can show the questions + options).
- *   2. Produces a {@link StagePromptAdapter} whose `buildResult` maps a simple
- *      answer (free text, an option label, an option index, or a pre-built raw
- *      result) into the `QuestionnaireResult` the tool expects.
- *
- * cross-ref:
- *   - packages/coding-agent/src/core/tools/ask-user-question/tool/types.ts
- *       QuestionnaireResult / QuestionAnswer (the result shape mirrored here)
- *   - src/shared/stage-ui-broker.ts  provideStagePrompt / answerStagePrompt
- *   - src/runs/foreground/executor.ts  ask_user_question watcher + readiness gate
- */
-
-import type { StageInputKind, StageInputQuestion, StageInputRequest } from "./store-types.js";
-
-/**
- * A simple, transport-friendly answer to a brokered stage prompt. Exactly one
- * of the fields is typically populated:
- *   - `raw`: a pre-built `QuestionnaireResult`-shaped value, forwarded verbatim.
- *   - `optionLabels`: explicit option label(s) (one for single-select, many for
- *     multi-select).
- *   - `text`: free text — matched against option labels / 1-based indices, and
- *     otherwise treated as a typed ("custom") answer.
- */
-export interface StageInputAnswer {
-	readonly text?: string;
-	readonly optionLabels?: readonly string[];
-	readonly raw?: unknown;
-}
-
-/** Result shape mirrored from the coding-agent ask_user_question tool. */
-interface BuiltAnswer {
-	questionIndex: number;
-	question: string;
-	kind: "option" | "custom" | "chat" | "multi";
-	answer: string | null;
-	selected?: string[];
-}
-interface BuiltResult {
-	answers: BuiltAnswer[];
-	cancelled: boolean;
-}
-
-/**
- * Couples the serializable {@link StageInputRequest} descriptor with a
- * `buildResult` that turns a {@link StageInputAnswer} into the value used to
- * resolve the brokered `ctx.ui.custom` promise.
- */
-export interface StagePromptAdapter {
-	readonly prompt: StageInputRequest;
-	buildResult(answer: StageInputAnswer): unknown;
-}
-
-function normalizeLabel(value: string): string {
-	return value.trim().toLowerCase();
-}
-
-function asString(value: unknown): string | undefined {
-	return typeof value === "string" ? value : undefined;
-}
-
-function readStringArray(value: unknown): readonly string[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const out = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
-	return out.length > 0 ? out : undefined;
-}
-
-function readFirstString(...values: readonly unknown[]): string | undefined {
-	for (const value of values) {
-		if (typeof value === "string" && value.length > 0) return value;
-	}
-	return undefined;
-}
-
-/** True when the answer carries a value the adapter can resolve. */
-export function hasStageInputAnswerContent(answer: StageInputAnswer): boolean {
-	return answer.text !== undefined || answer.optionLabels !== undefined || answer.raw !== undefined;
-}
-
-/**
- * Coerce a loosely-typed answer payload — as delivered by `workflow send`
- * (`text` / `response` / `message`) — into a normalized {@link StageInputAnswer}
- * the {@link StagePromptAdapter} can resolve against a question's options.
- *
- * Recognized inputs:
- *   - a plain string (option label, 1-based index, or free text);
- *   - a JSON-encoded string of any structured shape below;
- *   - a fully-formed `QuestionnaireResult` (every answer carries a numeric
- *     `questionIndex`), forwarded raw;
- *   - the orchestrator-friendly `{ answers: [{ answer | label | selected }] }`
- *     or `{ questions: [{ answer | label | selected }] }`;
- *   - a flat `{ answer | response | label | selected | optionLabels }`;
- *   - a string array (multi-select labels).
- *
- * Without this, a structured `response` was forwarded verbatim as the brokered
- * result, violating the `QuestionnaireResult` contract and leaving the readiness
- * gate (and any brokered prompt) unable to resolve to a matching option.
- */
-export function coerceStageInputAnswer(value: unknown): StageInputAnswer {
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-			try {
-				const parsed: unknown = JSON.parse(trimmed);
-				if (parsed !== null && typeof parsed === "object") {
-					const coerced = coerceStageInputAnswer(parsed);
-					if (hasStageInputAnswerContent(coerced)) return coerced;
-				}
-			} catch {
-				// Not JSON — fall through and treat the string as a literal answer.
-			}
-		}
-		return { text: value };
-	}
-	if (Array.isArray(value)) {
-		const labels = readStringArray(value);
-		return labels !== undefined ? { optionLabels: labels } : {};
-	}
-	if (value === null || typeof value !== "object") return {};
-
-	const record = value as Record<string, unknown>;
-
-	// Forward verbatim ONLY a fully-formed QuestionnaireResult — every answer
-	// entry must carry a numeric `questionIndex`. A loosely-shaped `answers[]`
-	// (e.g. `{ answers: [{ question, answer }] }`) is NOT genuine: forwarding it
-	// raw makes the tool envelope match no question index and reply
-	// "User declined to answer questions", stranding the prompt.
-	const answersArray = Array.isArray(record.answers) ? (record.answers as readonly unknown[]) : undefined;
-	if (
-		answersArray !== undefined &&
-		answersArray.length > 0 &&
-		answersArray.every(
-			(entry) =>
-				entry !== null &&
-				typeof entry === "object" &&
-				typeof (entry as Record<string, unknown>).questionIndex === "number",
-		)
-	) {
-		return { raw: value };
-	}
-
-	// Otherwise locate the answer-bearing record — the first `answers[]` or
-	// `questions[]` entry when present, else the object itself — and extract a
-	// value the adapter can resolve against the question's options (so it assigns
-	// the correct questionIndex), rather than forwarding an unusable result.
-	const source = answerBearingRecord(record);
-	const labels = readStringArray(source.optionLabels) ?? readStringArray(source.selected);
-	if (labels !== undefined) return { optionLabels: labels };
-
-	const text = readFirstString(source.answer, source.response, source.label, source.text);
-	if (text !== undefined) return { text };
-
-	// Nothing resolvable — decline rather than forward an unusable result.
-	return {};
-}
-
-function firstObjectOf(value: unknown): Record<string, unknown> | undefined {
-	const first = Array.isArray(value) ? value[0] : undefined;
-	return first !== null && typeof first === "object" ? (first as Record<string, unknown>) : undefined;
-}
-
-function answerBearingRecord(record: Record<string, unknown>): Record<string, unknown> {
-	return firstObjectOf(record.answers) ?? firstObjectOf(record.questions) ?? record;
-}
-
-function parseOption(value: unknown): StageInputQuestion["options"][number] | undefined {
-	if (value === null || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	const label = asString(record.label);
-	if (label === undefined) return undefined;
-	const description = asString(record.description);
-	return description !== undefined ? { label, description } : { label };
-}
-
-function parseQuestion(value: unknown): StageInputQuestion | undefined {
-	if (value === null || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	const question = asString(record.question);
-	if (question === undefined) return undefined;
-	const rawOptions = Array.isArray(record.options) ? record.options : [];
-	const options = rawOptions
-		.map(parseOption)
-		.filter((option): option is StageInputQuestion["options"][number] => option !== undefined);
-	const header = asString(record.header);
-	const multiSelect = record.multiSelect === true;
-	return {
-		question,
-		...(header !== undefined ? { header } : {}),
-		...(multiSelect ? { multiSelect: true } : {}),
-		options,
-	};
-}
-
-/**
- * Parse `ask_user_question` tool args (`{ questions: [...] }`) into the
- * serializable question descriptors. Returns `undefined` when no well-formed
- * question is present.
- */
-export function parseAskUserQuestionArgs(args: unknown): readonly StageInputQuestion[] | undefined {
-	if (args === null || typeof args !== "object") return undefined;
-	const rawQuestions = (args as Record<string, unknown>).questions;
-	if (!Array.isArray(rawQuestions)) return undefined;
-	const questions = rawQuestions
-		.map(parseQuestion)
-		.filter((question): question is StageInputQuestion => question !== undefined);
-	return questions.length > 0 ? questions : undefined;
-}
-
-/**
- * Sentinel label for the chat escape hatch. Matches the `ROW_INTENT_META.chat.label`
- * in the coding-agent package. Duplicated here as a literal to avoid a cross-package
- * import; the reserved-label guard in validate-questionnaire already prevents an
- * authored option from using this label.
- */
-const CHAT_ABOUT_THIS_LABEL = "Chat about this";
-const CHAT_ABOUT_THIS_NORMALIZED = normalizeLabel(CHAT_ABOUT_THIS_LABEL);
-
-function isChatSentinel(value: string): boolean {
-	return normalizeLabel(value) === CHAT_ABOUT_THIS_NORMALIZED;
-}
-
-function answerChat(question: StageInputQuestion): BuiltAnswer {
-	return {
-		questionIndex: 0,
-		question: question.question,
-		kind: "chat",
-		answer: CHAT_ABOUT_THIS_LABEL,
-	};
-}
-
-/**
- * Resolve a desired answer string against a single-select question's options.
- * Checks the chat sentinel first (case/whitespace insensitive), then matches a
- * case-insensitive option label, then a 1-based option index, then falls back to
- * a typed ("custom") answer.
- */
-function answerSingle(question: StageInputQuestion, desired: string): BuiltAnswer {
-	const normalized = normalizeLabel(desired);
-	// Chat sentinel takes priority over authored options — the label is reserved so
-	// no option can legitimately match it.
-	if (isChatSentinel(desired)) {
-		return answerChat(question);
-	}
-	const byLabel = question.options.find((option) => normalizeLabel(option.label) === normalized);
-	if (byLabel) {
-		return { questionIndex: 0, question: question.question, kind: "option", answer: byLabel.label };
-	}
-	const asIndex = Number.parseInt(desired.trim(), 10);
-	if (
-		Number.isInteger(asIndex) &&
-		asIndex >= 1 &&
-		asIndex <= question.options.length &&
-		String(asIndex) === desired.trim()
-	) {
-		const option = question.options[asIndex - 1]!;
-		return { questionIndex: 0, question: question.question, kind: "option", answer: option.label };
-	}
-	return { questionIndex: 0, question: question.question, kind: "custom", answer: desired };
-}
-
-function answerMulti(question: StageInputQuestion, candidates: readonly string[]): BuiltAnswer {
-	const selected: string[] = [];
-	for (const candidate of candidates) {
-		const normalized = normalizeLabel(candidate);
-		const byLabel = question.options.find((option) => normalizeLabel(option.label) === normalized);
-		if (byLabel) {
-			if (!selected.includes(byLabel.label)) selected.push(byLabel.label);
-			continue;
-		}
-		const asIndex = Number.parseInt(candidate.trim(), 10);
-		if (Number.isInteger(asIndex) && asIndex >= 1 && asIndex <= question.options.length) {
-			const option = question.options[asIndex - 1]!;
-			if (!selected.includes(option.label)) selected.push(option.label);
-		}
-	}
-	return { questionIndex: 0, question: question.question, kind: "multi", answer: null, selected };
-}
-
-function buildResult(questions: readonly StageInputQuestion[], answer: StageInputAnswer): unknown {
-	if (answer.raw !== undefined) return answer.raw;
-	const question = questions[0];
-	if (question === undefined) return { answers: [], cancelled: true } satisfies BuiltResult;
-
-	const multi = question.multiSelect === true;
-	if (multi) {
-		const candidates =
-			answer.optionLabels !== undefined
-				? answer.optionLabels
-				: (answer.text ?? "")
-						.split(",")
-						.map((part) => part.trim())
-						.filter((part) => part.length > 0);
-		if (candidates.some(isChatSentinel)) {
-			return { answers: [answerChat(question)], cancelled: false } satisfies BuiltResult;
-		}
-		return { answers: [answerMulti(question, candidates)], cancelled: false } satisfies BuiltResult;
-	}
-
-	const desired = answer.optionLabels?.[0] ?? answer.text;
-	if (desired === undefined || desired.length === 0) {
-		return { answers: [], cancelled: true } satisfies BuiltResult;
-	}
-	return { answers: [answerSingle(question, desired)], cancelled: false } satisfies BuiltResult;
-}
-
-/**
- * Build a {@link StagePromptAdapter} from `ask_user_question` tool args. Returns
- * `undefined` when the args contain no parseable question (the prompt then
- * stays TUI-only).
- */
-export function buildStagePromptAdapter(
-	id: string,
-	kind: StageInputKind,
-	args: unknown,
-	createdAt: number,
-): StagePromptAdapter | undefined {
-	const questions = parseAskUserQuestionArgs(args);
-	if (questions === undefined) return undefined;
-	const prompt: StageInputRequest = { id, kind, questions, createdAt };
-	return {
-		prompt,
-		buildResult: (answer) => buildResult(questions, answer),
-	};
-}

package/dist/builtin/workflows/src/shared/stage-ui-broker.ts

@@ -1,340 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { Component, Focusable, TUI } from "@earendil-works/pi-tui";
-import type {
-	PiCustomComponent,
-	PiCustomOverlayFactory,
-	PiCustomOverlayOptions,
-	PiKeybindings,
-	PiTheme,
-} from "../extension/wiring.js";
-import { createSessionScopedSingleton } from "./session-scoped-singleton.js";
-import type { StageInputAnswer, StagePromptAdapter } from "./stage-prompt.js";
-import type { StagePromptAnswerSource, Store } from "./store.js";
-import { store as defaultStore } from "./store.js";
-import type { StageInputRequest } from "./store-types.js";
-
-export interface StageCustomUiRequest<T = unknown> {
-	readonly id: string;
-	readonly runId: string;
-	readonly stageId: string;
-	readonly factory: PiCustomOverlayFactory<T>;
-	readonly options?: PiCustomOverlayOptions;
-	readonly createdAt: number;
-	resolve(value: T): void;
-	reject(reason: unknown): void;
-}
-
-export interface StageCustomUiHost {
-	showCustomUi(request: StageCustomUiRequest): void;
-	hideCustomUi?(request: StageCustomUiRequest, reason: unknown): void;
-}
-
-export interface StagePromptResolvedEvent {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly prompt: StageInputRequest;
-	readonly answer: unknown;
-	readonly answeredAt: number;
-	readonly answerSource?: StagePromptAnswerSource;
-}
-
-export interface AnswerStagePromptOptions {
-	/** Identifies who answered the prompt so notification code can avoid echoing workflow-tool answers. */
-	readonly answerSource?: StagePromptAnswerSource;
-}
-
-export type StagePromptResolvedListener = (event: StagePromptResolvedEvent) => void;
-
-function key(runId: string, stageId: string): string {
-	return `${runId}\0${stageId}`;
-}
-
-function nextRequestId(): string {
-	return `stage-ui-${randomUUID()}`;
-}
-
-export class StageUiBroker {
-	private readonly store: Store;
-	private readonly pending = new Map<string, StageCustomUiRequest>();
-	private readonly hosts = new Map<string, StageCustomUiHost>();
-	// Headless-answer adapters keyed by (runId, stageId). Populated by the
-	// executor's ask_user_question watcher and the readiness gate so a brokered
-	// custom-UI prompt can be answered programmatically (e.g. via `workflow
-	// send`) without a TUI host rendering the interactive component.
-	private readonly adapters = new Map<string, StagePromptAdapter>();
-	private readonly resolvedPromptIds = new Map<string, string>();
-	private readonly resolvedListeners = new Set<StagePromptResolvedListener>();
-
-	constructor(store: Store = defaultStore) {
-		this.store = store;
-	}
-
-	/**
-	 * Register the structured descriptor + headless result builder for the
-	 * prompt a stage is about to raise (or has just raised) via
-	 * `requestCustomUi`. Surfaces the descriptor on the stage snapshot so
-	 * `workflow send` / status can see and answer it. Safe to call before or
-	 * after the matching `requestCustomUi`; the (runId, stageId) key joins them.
-	 */
-	provideStagePrompt(runId: string, stageId: string, adapter: StagePromptAdapter): void {
-		const hostKey = key(runId, stageId);
-		this.adapters.set(hostKey, adapter);
-		// A newly provided adapter represents a fresh prompt instance, even when
-		// the caller reuses the same prompt id (readiness gates historically did).
-		// Clear the resolved marker unconditionally so a raced answer for this new
-		// request cannot be mistaken for a duplicate answer to the prior instance.
-		this.resolvedPromptIds.delete(hostKey);
-		this.store.recordStageInputRequest(runId, stageId, adapter.prompt);
-	}
-
-	/** Drop a stage's headless-answer adapter and clear its snapshot descriptor. */
-	clearStagePrompt(runId: string, stageId: string): void {
-		if (this.adapters.delete(key(runId, stageId))) {
-			this.store.clearStageInputRequest(runId, stageId);
-		}
-	}
-
-	/**
-	 * Settle and hide any brokered prompt that belongs to a stage whose workflow
-	 * lifecycle has ended. Detaching a host intentionally does not cancel human
-	 * input, but terminal stage/run cleanup must not leave stale HIL UI mounted.
-	 */
-	cancelStagePrompt(runId: string, stageId: string, reason: unknown): void {
-		const hostKey = key(runId, stageId);
-		const request = this.pending.get(hostKey);
-		if (request) {
-			this.reject(request, reason);
-			return;
-		}
-		if (this.adapters.delete(hostKey)) {
-			this.store.clearStageInputRequest(runId, stageId);
-		}
-	}
-
-	/**
-	 * Return the structured descriptor for a stage's brokered prompt when BOTH a
-	 * headless-answer adapter and a live pending request exist for it — i.e. when
-	 * `answerStagePrompt` can actually resolve something right now.
-	 */
-	peekStagePrompt(runId: string, stageId: string): StageInputRequest | undefined {
-		const hostKey = key(runId, stageId);
-		const adapter = this.adapters.get(hostKey);
-		if (adapter && this.pending.has(hostKey)) return adapter.prompt;
-		return undefined;
-	}
-
-	/**
-	 * Headlessly answer a stage's pending brokered prompt. Resolves the awaiting
-	 * `ctx.ui.custom` promise with the adapter-built result. Returns `false` when
-	 * there is no adapter+request pair for the stage.
-	 */
-	answerStagePrompt(
-		runId: string,
-		stageId: string,
-		answer: StageInputAnswer,
-		options: AnswerStagePromptOptions = {},
-	): boolean {
-		const hostKey = key(runId, stageId);
-		const adapter = this.adapters.get(hostKey);
-		const request = this.pending.get(hostKey);
-		if (!adapter || !request) return false;
-		this.resolve(request, adapter.buildResult(answer), options);
-		return true;
-	}
-
-	wasStagePromptResolved(runId: string, stageId: string, promptId: string): boolean {
-		return this.resolvedPromptIds.get(key(runId, stageId)) === promptId;
-	}
-
-	onStagePromptResolved(listener: StagePromptResolvedListener): () => void {
-		this.resolvedListeners.add(listener);
-		return () => {
-			this.resolvedListeners.delete(listener);
-		};
-	}
-
-	private notifyStagePromptAnswered(event: StagePromptResolvedEvent): void {
-		for (const listener of this.resolvedListeners) {
-			try {
-				listener(event);
-			} catch {
-				// Listener failures must not prevent the prompt from resolving.
-			}
-		}
-	}
-
-	private hideHost(host: StageCustomUiHost | undefined, request: StageCustomUiRequest, reason: unknown): void {
-		try {
-			host?.hideCustomUi?.(request, reason);
-		} catch {
-			// Host teardown is best-effort; request settlement must still continue.
-		}
-	}
-
-	private showHostOrReject(host: StageCustomUiHost, request: StageCustomUiRequest): void {
-		try {
-			host.showCustomUi(request);
-		} catch (error) {
-			this.reject(request, error);
-		}
-	}
-
-	registerHost(runId: string, stageId: string, host: StageCustomUiHost): () => void {
-		const hostKey = key(runId, stageId);
-		const previousHost = this.hosts.get(hostKey);
-		const request = this.pending.get(hostKey);
-		if (previousHost && previousHost !== host && request) {
-			this.hideHost(previousHost, request, new Error(`atomic-workflows: stage ${stageId} custom UI host replaced`));
-		}
-		this.hosts.set(hostKey, host);
-		const activeRequest = this.pending.get(hostKey);
-		if (activeRequest) this.showHostOrReject(host, activeRequest);
-		return () => {
-			if (this.hosts.get(hostKey) !== host) return;
-			this.hosts.delete(hostKey);
-			// Unregistering a host means it stops *displaying* the request — not that
-			// the request is cancelled. A stage-scoped human-input request (e.g.
-			// ask_user_question / readiness gate) outlives any one attached chat:
-			// detaching leaves it pending (the stage stays awaiting_input) and a
-			// future host re-displays it. The request is settled only by the user
-			// answering (resolve) or the run aborting (its AbortSignal -> reject).
-		};
-	}
-
-	requestCustomUi<T>(
-		runId: string,
-		stageId: string,
-		factory: PiCustomOverlayFactory<T>,
-		options?: PiCustomOverlayOptions,
-		signal?: AbortSignal,
-	): Promise<T> {
-		if (signal?.aborted) {
-			return Promise.reject(signal.reason ?? new Error("atomic-workflows: stage UI request aborted"));
-		}
-		const hostKey = key(runId, stageId);
-		const existing = this.pending.get(hostKey);
-		if (existing) {
-			return Promise.reject(new Error(`atomic-workflows: stage ${stageId} already has a pending custom UI request`));
-		}
-
-		let request!: StageCustomUiRequest<T>;
-		const promise = new Promise<T>((resolve, reject) => {
-			request = {
-				id: nextRequestId(),
-				runId,
-				stageId,
-				factory,
-				...(options !== undefined ? { options } : {}),
-				createdAt: Date.now(),
-				resolve,
-				reject,
-			};
-		});
-
-		const onAbort = (): void => {
-			this.reject(request, signal?.reason ?? new Error("atomic-workflows: stage UI request aborted"));
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-
-		this.pending.set(hostKey, request);
-		this.store.recordStageAwaitingInput(runId, stageId, true, request.createdAt);
-		const host = this.hosts.get(hostKey);
-		if (host) this.showHostOrReject(host, request);
-		// Re-check after listener registration and host display; AbortSignal does
-		// not replay an already-fired abort event for listeners added later.
-		if (signal?.aborted) onAbort();
-
-		return promise.finally(() => {
-			signal?.removeEventListener("abort", onAbort);
-		});
-	}
-
-	resolve<T>(request: StageCustomUiRequest<T>, value: T, options: AnswerStagePromptOptions = {}): void {
-		const hostKey = key(request.runId, request.stageId);
-		if (this.pending.get(hostKey)?.id !== request.id) return;
-		const prompt = this.adapters.get(hostKey)?.prompt;
-		this.pending.delete(hostKey);
-		this.adapters.delete(hostKey);
-		if (prompt !== undefined) this.resolvedPromptIds.set(hostKey, prompt.id);
-		this.store.clearStageInputRequest(request.runId, request.stageId);
-		this.store.recordStageAwaitingInput(request.runId, request.stageId, false);
-		this.hideHost(this.hosts.get(hostKey), request, undefined);
-		if (prompt !== undefined) {
-			this.notifyStagePromptAnswered({
-				runId: request.runId,
-				stageId: request.stageId,
-				prompt,
-				answer: value,
-				answeredAt: Date.now(),
-				...(options.answerSource !== undefined ? { answerSource: options.answerSource } : {}),
-			});
-		}
-		request.resolve(value);
-	}
-
-	reject(request: StageCustomUiRequest, reason: unknown): void {
-		const hostKey = key(request.runId, request.stageId);
-		if (this.pending.get(hostKey)?.id !== request.id) return;
-		this.pending.delete(hostKey);
-		this.adapters.delete(hostKey);
-		this.resolvedPromptIds.delete(hostKey);
-		this.store.clearStageInputRequest(request.runId, request.stageId);
-		this.store.recordStageAwaitingInput(request.runId, request.stageId, false);
-		this.hideHost(this.hosts.get(hostKey), request, reason);
-		request.reject(reason);
-	}
-}
-
-export interface MountedStageCustomUi {
-	readonly request: StageCustomUiRequest;
-	readonly component: PiCustomComponent & { invalidate(): void; dispose?(): void } & Partial<Focusable>;
-}
-
-export async function mountStageCustomUi(
-	request: StageCustomUiRequest,
-	tui: TUI,
-	theme: PiTheme,
-	keybindings: PiKeybindings,
-	broker: StageUiBroker,
-	onDone?: () => void,
-	canResolve?: () => boolean,
-): Promise<MountedStageCustomUi> {
-	const rawComponent = await request.factory(
-		tui as unknown as Parameters<StageCustomUiRequest["factory"]>[0],
-		theme,
-		keybindings,
-		(result: unknown) => {
-			if (canResolve?.() === false) return;
-			broker.resolve(request, result);
-			onDone?.();
-		},
-	);
-	const component: PiCustomComponent & { invalidate(): void; dispose?(): void } & Partial<Focusable> = {
-		render: (width) => rawComponent.render(width),
-		...(rawComponent.handleInput !== undefined
-			? { handleInput: (data: string): boolean => rawComponent.handleInput?.(data) === true }
-			: {}),
-		invalidate: () => rawComponent.invalidate?.(),
-		...(rawComponent.dispose !== undefined ? { dispose: () => rawComponent.dispose?.() } : {}),
-	};
-	if ("focused" in rawComponent) {
-		Object.defineProperty(component, "focused", {
-			get: () => (rawComponent as Component & Partial<Focusable>).focused,
-			set: (value: boolean) => {
-				(rawComponent as Component & Partial<Focusable>).focused = value;
-			},
-			enumerable: true,
-			configurable: true,
-		});
-	}
-	return { request, component };
-}
-
-const SESSION_KEY = "workflows:stage-ui:v1";
-const singleton = createSessionScopedSingleton(SESSION_KEY, () => new StageUiBroker());
-
-export const stageUiBroker = singleton.facade;
-
-export function adoptStageUiBroker(scope: object): StageUiBroker {
-	return singleton.adopt(scope);
-}