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

package/dist/builtin/workflows/src/tui/workflow-notice-card.ts

@@ -1,167 +0,0 @@
-import { renderRoundedBoxLines } from "./chat-surface.js";
-import { BOLD, hexToAnsi, RESET } from "./color-utils.js";
-import type { GraphTheme } from "./graph-theme.js";
-import { truncateToWidth, visibleWidth, wrapPlainText } from "./text-helpers.js";
-
-export type WorkflowNoticeTone = "info" | "success" | "warning" | "error" | "mauve";
-
-export interface WorkflowNoticeCardField {
-	readonly label: string;
-	readonly value: string | undefined;
-	readonly tone?: WorkflowNoticeTone | "text" | "muted";
-}
-
-export interface WorkflowNoticeCardOpts {
-	readonly title: string;
-	readonly glyph: string;
-	readonly headline: string;
-	readonly tone: WorkflowNoticeTone;
-	readonly fields?: readonly WorkflowNoticeCardField[];
-	readonly hints?: readonly string[];
-	readonly footer?: string;
-	readonly fallbackText: string;
-	readonly width: number;
-	readonly theme?: GraphTheme;
-}
-
-const MIN_CARD_WIDTH = 32;
-const FIELD_LABEL_WIDTH = 9;
-
-export function renderWorkflowNoticeCard(opts: WorkflowNoticeCardOpts): string[] {
-	const width = Math.max(1, Math.floor(opts.width));
-	if (width < MIN_CARD_WIDTH) return wrapPlainText(opts.fallbackText, width);
-
-	const theme = opts.theme;
-	const accent = theme ? toneColor(theme, opts.tone) : undefined;
-	const innerWidth = Math.max(2, width - 2);
-	const bodyLines: string[] = [];
-
-	appendHeadline(bodyLines, opts, innerWidth);
-
-	for (const field of opts.fields ?? []) {
-		if (field.value === undefined || field.value.length === 0) continue;
-		appendField(bodyLines, field, innerWidth, theme);
-	}
-
-	for (const hint of opts.hints ?? []) {
-		if (hint.length === 0) continue;
-		appendHint(bodyLines, hint, innerWidth, theme);
-	}
-
-	if (opts.footer && opts.footer.length > 0) {
-		appendFreeText(bodyLines, opts.footer, innerWidth, theme, "muted");
-	}
-
-	return renderRoundedBoxLines({
-		title: opts.title,
-		bodyLines,
-		width,
-		...(theme ? { theme, accent } : {}),
-	});
-}
-
-function appendHeadline(rows: string[], opts: WorkflowNoticeCardOpts, innerWidth: number): void {
-	const prefix = `${opts.glyph} `;
-	const continuationPrefix = `${" ".repeat(visibleWidth(opts.glyph))} `;
-	const budget = Math.max(1, innerWidth - 1 - visibleWidth(prefix));
-	const lines = wrapPlainText(opts.headline, budget);
-	const theme = opts.theme;
-	const tone = theme ? toneColor(theme, opts.tone) : undefined;
-
-	for (let i = 0; i < lines.length; i++) {
-		const rawPrefix = i === 0 ? prefix : continuationPrefix;
-		const styledPrefix = i === 0 ? style(rawPrefix, theme, tone, true) : " ".repeat(visibleWidth(rawPrefix));
-		const line = ` ${styledPrefix}${style(lines[i] ?? "", theme, theme?.text, true)}`;
-		rows.push(fit(line, innerWidth));
-	}
-}
-
-function appendField(
-	rows: string[],
-	field: WorkflowNoticeCardField,
-	innerWidth: number,
-	theme: GraphTheme | undefined,
-): void {
-	const label = truncateToWidth(field.label, FIELD_LABEL_WIDTH, "…").padEnd(FIELD_LABEL_WIDTH, " ");
-	const firstPrefixWidth = 1 + FIELD_LABEL_WIDTH + 1;
-	const firstBudget = Math.max(1, innerWidth - firstPrefixWidth);
-	const value = field.value ?? "";
-	const valueTone = field.tone ?? "text";
-
-	if (visibleWidth(value) <= firstBudget && !value.includes("\n")) {
-		rows.push(
-			fit(
-				` ${style(label, theme, theme?.dim, true)} ${style(value, theme, colorForField(theme, valueTone))}`,
-				innerWidth,
-			),
-		);
-		return;
-	}
-
-	rows.push(fit(` ${style(field.label, theme, theme?.dim, true)}`, innerWidth));
-	if (visibleWidth(value) <= innerWidth - 1 && !value.includes("\n")) {
-		rows.push(fit(` ${style(value, theme, colorForField(theme, valueTone))}`, innerWidth));
-		return;
-	}
-	const continuationPrefix = "   ";
-	const continuationBudget = Math.max(1, innerWidth - visibleWidth(continuationPrefix));
-	for (const line of wrapPlainText(value, continuationBudget)) {
-		rows.push(fit(`${continuationPrefix}${style(line, theme, colorForField(theme, valueTone))}`, innerWidth));
-	}
-}
-
-function appendHint(rows: string[], hint: string, innerWidth: number, theme: GraphTheme | undefined): void {
-	const prefix = "▸ ";
-	const continuationPrefix = "  ";
-	const budget = Math.max(1, innerWidth - 1 - visibleWidth(prefix));
-	const lines = wrapPlainText(hint, budget);
-	for (let i = 0; i < lines.length; i++) {
-		const rawPrefix = i === 0 ? prefix : continuationPrefix;
-		const styledPrefix = i === 0 ? style(rawPrefix, theme, theme?.accent, true) : " ".repeat(visibleWidth(rawPrefix));
-		rows.push(fit(` ${styledPrefix}${style(lines[i] ?? "", theme, theme?.textMuted)}`, innerWidth));
-	}
-}
-
-function appendFreeText(
-	rows: string[],
-	text: string,
-	innerWidth: number,
-	theme: GraphTheme | undefined,
-	tone: WorkflowNoticeCardField["tone"],
-): void {
-	const budget = Math.max(1, innerWidth - 1);
-	for (const line of wrapPlainText(text, budget)) {
-		rows.push(fit(` ${style(line, theme, colorForField(theme, tone ?? "text"))}`, innerWidth));
-	}
-}
-
-function colorForField(theme: GraphTheme | undefined, tone: WorkflowNoticeCardField["tone"]): string | undefined {
-	if (!theme) return undefined;
-	if (tone === "text") return theme.text;
-	if (tone === "muted") return theme.textMuted;
-	return toneColor(theme, tone ?? "info");
-}
-
-function toneColor(theme: GraphTheme, tone: WorkflowNoticeTone): string {
-	switch (tone) {
-		case "success":
-			return theme.success;
-		case "warning":
-			return theme.warning;
-		case "error":
-			return theme.error;
-		case "mauve":
-			return theme.mauve;
-		default:
-			return theme.info;
-	}
-}
-
-function style(text: string, theme: GraphTheme | undefined, color: string | undefined, bold = false): string {
-	if (!theme || !color || text.length === 0) return text;
-	return `${hexToAnsi(color)}${bold ? BOLD : ""}${text}${RESET}`;
-}
-
-function fit(line: string, width: number): string {
-	return truncateToWidth(line, width, "…", true);
-}

package/dist/builtin/workflows/src/tui/workflow-resume-selector.ts

@@ -1,334 +0,0 @@
-import type { SessionInfo } from "@bastani/atomic";
-import { isWorkflowRunResumable } from "../durable/resume-eligibility.js";
-import type { DurableWorkflowDeleteOutcome } from "../durable/retention-policy.js";
-import type { ResumableWorkflowEntry } from "../durable/types.js";
-import type { PiHostSessionPickerFunction, PiHostSessionPickerRow } from "../extension/wiring.js";
-import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
-import { workflowRunResumeCandidate } from "../shared/workflow-artifacts.js";
-
-export type WorkflowResumeSelectorResult =
-	| { kind: "live"; runId: string }
-	| { kind: "durable"; workflowId: string }
-	| { kind: "completed"; workflowId: string }
-	| { kind: "close" };
-
-/**
- * UI surface required by the resume picker. The host session-picker
- * capability is REQUIRED: both isolated (engine-child) and non-isolated
- * interactive hosts expose the identical `hostSessionPicker` API, so the
- * picker always mounts natively in the terminal process. There is no
- * remote-rendered fallback; `openWorkflowResumeSelector` rejects with an
- * actionable error when the capability is absent (e.g. a mismatched host).
- */
-export interface WorkflowResumeSelectorUiSurface {
-	hostSessionPicker?: PiHostSessionPickerFunction;
-}
-
-export interface WorkflowResumeSelectorOptions {
-	readonly deleteWorkflow?: (workflowId: string) => Promise<DurableWorkflowDeleteOutcome>;
-	/** Subscribe to local run-store changes; returns an unsubscribe function. */
-	readonly watch?: (onChange: () => void) => () => void;
-	/** Recompute every row: fresh live runs plus a re-hydrated catalog. */
-	readonly refresh?: WorkflowResumeRefresh;
-	/** Cross-session polling cadence while the picker is open. 0 disables. */
-	readonly refreshIntervalMs?: number;
-}
-
-export type WorkflowResumeRefresh = () => Promise<{
-	readonly liveRuns: readonly RunSnapshot[];
-	readonly catalog: WorkflowResumeCatalogRows;
-}>;
-
-interface WorkflowResumeSelectorItem {
-	readonly result: Exclude<WorkflowResumeSelectorResult, { kind: "close" }>;
-	readonly session: SessionInfo;
-}
-
-function latestStageTimestamp(stage: StageSnapshot): number {
-	return stage.endedAt ?? stage.startedAt ?? 0;
-}
-
-function latestRunTimestamp(run: RunSnapshot): number {
-	const stageTimes = run.stages.map(latestStageTimestamp);
-	return Math.max(run.endedAt ?? 0, run.resumedAt ?? 0, run.pausedAt ?? 0, run.startedAt, ...stageTimes);
-}
-
-function completedStageCount(run: RunSnapshot): number {
-	return run.stages.filter((stage) => stage.status === "completed" || stage.status === "failed").length;
-}
-
-function isResumePickerLiveRun(run: RunSnapshot): boolean {
-	return isWorkflowRunResumable(workflowRunResumeCandidate(run));
-}
-interface WorkflowStatusPresentation {
-	readonly label: string;
-	readonly color?: "success" | "warning" | "error";
-}
-
-/**
- * Semantic row presentation: green completed, yellow paused, red failed and
- * blocked. Durable `running` rows only reach the picker once their heartbeat
- * is stale (nothing is executing them), so they present as crashed.
- */
-function workflowStatusPresentation(
-	status: string,
-	kind: "live" | "durable" | "completed",
-): WorkflowStatusPresentation {
-	if (kind === "completed") return { label: "✓ completed", color: "success" };
-	if (status === "paused") return { label: "paused", color: "warning" };
-	if (status === "failed" || status === "blocked") return { label: status, color: "error" };
-	if (kind === "durable" && status === "running") return { label: "crashed", color: "error" };
-	return { label: status };
-}
-
-function liveRunSession(run: RunSnapshot): WorkflowResumeSelectorItem {
-	const completed = completedStageCount(run);
-	const total = run.stages.length;
-	const modified = new Date(latestRunTimestamp(run));
-	const presentation = workflowStatusPresentation(run.status, "live");
-	const firstMessage = `${run.name}  ${presentation.label}  ${completed}/${total} stages`;
-	return {
-		result: { kind: "live", runId: run.id },
-		session: {
-			path: `workflow-live:${run.id}`,
-			id: run.id,
-			cwd: "Live workflow runs",
-			created: new Date(run.startedAt),
-			modified,
-			messageCount: total,
-			firstMessage,
-			allMessagesText: `${run.id} ${run.name} ${presentation.label} ${completed}/${total} stages`,
-			...(presentation.color !== undefined ? { messageColor: presentation.color } : {}),
-		},
-	};
-}
-
-function durableWorkflowSession(
-	entry: ResumableWorkflowEntry,
-	kind: "durable" | "completed",
-): WorkflowResumeSelectorItem {
-	const checkpointText = `${entry.completedCheckpoints} checkpoints`;
-	const presentation = workflowStatusPresentation(entry.status, kind);
-	return {
-		result: { kind, workflowId: entry.workflowId },
-		session: {
-			path: `workflow-${kind}:${entry.workflowId}`,
-			id: entry.workflowId,
-			cwd: kind === "completed" ? "Completed workflow runs" : "Durable workflow runs",
-			created: new Date(entry.createdAt),
-			modified: new Date(entry.updatedAt),
-			messageCount: entry.completedCheckpoints,
-			firstMessage: `${entry.name}  ${presentation.label}  ${checkpointText}`,
-			allMessagesText: `${entry.workflowId} ${entry.name} ${presentation.label} ${checkpointText}`,
-			...(presentation.color !== undefined ? { messageColor: presentation.color } : {}),
-		},
-	};
-}
-
-function compareResumeItemsByRecency(left: WorkflowResumeSelectorItem, right: WorkflowResumeSelectorItem): number {
-	const recencyDifference = right.session.modified.getTime() - left.session.modified.getTime();
-	if (recencyDifference !== 0) return recencyDifference;
-	const idDifference = left.session.id.localeCompare(right.session.id);
-	return idDifference !== 0 ? idDifference : left.session.path.localeCompare(right.session.path);
-}
-
-export function workflowResumeSelectorItems(
-	liveRuns: readonly RunSnapshot[],
-	durableEntries: readonly ResumableWorkflowEntry[],
-	completedEntries: readonly ResumableWorkflowEntry[] = [],
-): WorkflowResumeSelectorItem[] {
-	const classifiedLiveRuns = liveRuns.map((run) => ({ run, resumable: isResumePickerLiveRun(run) }));
-	const eligibleLiveRuns = classifiedLiveRuns.filter(({ resumable }) => resumable).map(({ run }) => run);
-	const visibleLiveIds = new Set(eligibleLiveRuns.map((run) => run.id));
-	// An actively executing live snapshot is intentionally not resumable here, but its durable
-	// row remains the existing fallback. Other predicate-rejected snapshots must disappear from
-	// the resumable row kinds, or a missing-artifact live run would reappear as a durable duplicate.
-	const suppressedLiveIds = new Set(
-		classifiedLiveRuns
-			.filter(({ run, resumable }) => resumable || !(run.status === "running" && run.endedAt === undefined))
-			.map(({ run }) => run.id),
-	);
-	const visibleDurableEntries = durableEntries.filter((entry) => !suppressedLiveIds.has(entry.workflowId));
-	const durableIds = new Set(visibleDurableEntries.map((entry) => entry.workflowId));
-	return [
-		...eligibleLiveRuns.map(liveRunSession),
-		...visibleDurableEntries.map((entry) => durableWorkflowSession(entry, "durable")),
-		...completedEntries
-			.filter((entry) => !visibleLiveIds.has(entry.workflowId) && !durableIds.has(entry.workflowId))
-			.map((entry) => durableWorkflowSession(entry, "completed")),
-	].sort(compareResumeItemsByRecency);
-}
-export interface WorkflowResumeCatalogRows {
-	readonly durable: readonly ResumableWorkflowEntry[];
-	readonly completed: readonly ResumableWorkflowEntry[];
-}
-
-/**
- * Lazily produces the durable/completed catalog. Invoked at most once, after the
- * selector has already mounted with live rows, so resource/catalog loading stays
- * off the command's synchronous mount path.
- */
-export type WorkflowResumeHydrate = () => Promise<WorkflowResumeCatalogRows>;
-
-export interface OpenWorkflowResumeSelectorResult {
-	readonly result: WorkflowResumeSelectorResult;
-	/** The catalog resolved by hydrate(), for follow-on resume without a rescan. */
-	readonly catalog: WorkflowResumeCatalogRows;
-}
-
-const EMPTY_CATALOG: WorkflowResumeCatalogRows = { durable: [], completed: [] };
-
-export const WORKFLOW_RESUME_PICKER_UNAVAILABLE =
-	"The workflow resume picker requires the host session-picker capability (ctx.ui.hostSessionPicker), " +
-	"which this host does not expose. Update @bastani/atomic, or resume directly with: /workflow resume <id>";
-
-function toPickerRow(session: SessionInfo): PiHostSessionPickerRow {
-	return {
-		path: session.path,
-		id: session.id,
-		cwd: session.cwd,
-		createdAt: session.created.getTime(),
-		modifiedAt: session.modified.getTime(),
-		messageCount: session.messageCount,
-		firstMessage: session.firstMessage,
-		...(session.summary !== undefined ? { summary: session.summary } : {}),
-		allMessagesText: session.allMessagesText,
-		...(session.name !== undefined ? { name: session.name } : {}),
-		...(session.messageColor !== undefined ? { messageColor: session.messageColor } : {}),
-	};
-}
-
-/**
- * Open the `/workflow resume` picker through the host session-picker
- * capability: the terminal host mounts the real `SessionSelectorComponent`,
- * so arrow-key navigation and search never cross the host⇄extension boundary
- * and stay instant even while this process hydrates the catalog or refreshes
- * the run store.
- *
- * Semantics: live rows seed the first frame, `hydrate()` runs once and merges
- * via a row update (errors keep the seeded rows and surface in-picker), watch
- * refreshes are debounced (250 ms) and polling defaults to 5 s, a failed
- * refresh keeps the previous rows, live rows cannot be deleted, and the
- * resolved catalog is returned with the result for follow-on resume.
- *
- * Rejects with `WORKFLOW_RESUME_PICKER_UNAVAILABLE` when the host does not
- * expose the capability — there is no remote-rendered fallback.
- */
-export function openWorkflowResumeSelector(
-	ui: WorkflowResumeSelectorUiSurface,
-	liveRuns: readonly RunSnapshot[],
-	hydrate: WorkflowResumeHydrate,
-	options: WorkflowResumeSelectorOptions = {},
-): Promise<OpenWorkflowResumeSelectorResult> {
-	const hostSessionPicker = ui.hostSessionPicker;
-	if (typeof hostSessionPicker !== "function") {
-		return Promise.reject(new Error(WORKFLOW_RESUME_PICKER_UNAVAILABLE));
-	}
-
-	let currentLiveRuns = liveRuns;
-	let resolvedCatalog: WorkflowResumeCatalogRows = EMPTY_CATALOG;
-	const liveItems = workflowResumeSelectorItems(currentLiveRuns, [], []);
-	let sessions = liveItems.map((item) => item.session);
-	let resultByPath = new Map(liveItems.map((item) => [item.session.path, item.result]));
-	let settled = false;
-	let stopWatching: (() => void) | undefined;
-	let refreshTimer: ReturnType<typeof setInterval> | undefined;
-	let debounceTimer: ReturnType<typeof setTimeout> | undefined;
-
-	const applyRows = (catalog: WorkflowResumeCatalogRows): void => {
-		resolvedCatalog = catalog;
-		const items = workflowResumeSelectorItems(currentLiveRuns, catalog.durable, catalog.completed);
-		sessions = items.map((item) => item.session);
-		resultByPath = new Map(items.map((item) => [item.session.path, item.result]));
-	};
-
-	// Deletion is extension-owned: the host keeps the row until update()/error().
-	const handle = hostSessionPicker({
-		sessions: sessions.map(toPickerRow),
-		showRenameHint: false,
-		onDelete: async (path) => {
-			if (settled) return;
-			const target = resultByPath.get(path);
-			if (target === undefined || target.kind === "live") {
-				handle.error("Cannot delete an in-flight workflow run");
-				return;
-			}
-			if (options.deleteWorkflow === undefined) {
-				handle.error("Workflow history deletion is unavailable");
-				return;
-			}
-			const outcome = await options.deleteWorkflow(target.workflowId);
-			if (settled) return;
-			if (!outcome.ok) {
-				handle.error(outcome.message);
-				return;
-			}
-			resultByPath.delete(path);
-			sessions = sessions.filter((session) => session.path !== path);
-			handle.update(sessions.map(toPickerRow));
-		},
-	});
-
-	// Frame-1 seed is the cheap in-memory live rows; the durable/completed
-	// catalog hydrates once, asynchronously, and merges via a row update.
-	// Hydrate errors keep the live rows on screen (error surfaces in-header).
-	void hydrate()
-		.then((catalog) => {
-			if (settled) return;
-			applyRows(catalog);
-			handle.update(sessions.map(toPickerRow));
-		})
-		.catch((error: unknown) => {
-			if (settled) return;
-			const message = error instanceof Error ? error.message : String(error);
-			handle.error(`Failed to load sessions: ${message}`);
-		});
-
-	// Live updates: re-list rows on local run-store changes and on a bounded
-	// cross-session poll; a failed refresh keeps the previous rows.
-	let refreshing = false;
-	const runRefresh = async (): Promise<void> => {
-		const refresh = options.refresh;
-		if (refresh === undefined || settled || refreshing) return;
-		refreshing = true;
-		try {
-			const next = await refresh();
-			if (settled) return;
-			currentLiveRuns = next.liveRuns;
-			applyRows(next.catalog);
-			handle.update(sessions.map(toPickerRow));
-		} catch {
-			// Keep the previous rows on a failed refresh; the next tick retries.
-		} finally {
-			refreshing = false;
-		}
-	};
-	const scheduleRefresh = (): void => {
-		if (settled || debounceTimer !== undefined) return;
-		debounceTimer = setTimeout(() => {
-			debounceTimer = undefined;
-			void runRefresh();
-		}, 250);
-		debounceTimer.unref?.();
-	};
-	if (options.watch !== undefined && options.refresh !== undefined) {
-		stopWatching = options.watch(scheduleRefresh);
-	}
-	const intervalMs = options.refreshIntervalMs ?? 5_000;
-	if (options.refresh !== undefined && intervalMs > 0) {
-		refreshTimer = setInterval(() => {
-			void runRefresh();
-		}, intervalMs);
-		refreshTimer.unref?.();
-	}
-
-	return handle.result.then((path): OpenWorkflowResumeSelectorResult => {
-		settled = true;
-		stopWatching?.();
-		if (refreshTimer !== undefined) clearInterval(refreshTimer);
-		if (debounceTimer !== undefined) clearTimeout(debounceTimer);
-		const result: WorkflowResumeSelectorResult =
-			path === undefined ? { kind: "close" } : (resultByPath.get(path) ?? { kind: "close" });
-		return { result, catalog: resolvedCatalog };
-	});
-}

package/dist/builtin/workflows/src/tui/workflow-status.ts

@@ -1,12 +0,0 @@
-/** Shared status slot used by workflow graph/attach UI surfaces. */
-export const WORKFLOW_STATUS_KEY = "pi-workflows";
-
-/**
- * Host status keys hidden from the workflow orchestrator statusline. The MCP
- * server count and the ADHD Mode badge of a separately installed i-have-adhd
- * extension are main-chat chrome and carry no workflow signal, so the overlay
- * keeps its statusline for run-scoped hints instead. The key stays listed
- * even though the package is no longer bundled, so an externally installed
- * copy remains hidden too.
- */
-export const OVERLAY_HIDDEN_STATUS_KEYS: ReadonlySet<string> = new Set(["mcp", "i-have-adhd"]);

package/dist/builtin/workflows/src/workflows/identity.ts

@@ -1,39 +0,0 @@
-/**
- * Workflow name identity helpers.
- * Provides a canonical normalized form used as the registry key.
- *
- * cross-ref: pi-subagents src/agents/identity.ts
- */
-
-/**
- * Normalize a workflow name to a canonical key:
- * - Trim surrounding whitespace
- * - Lowercase
- * - Replace one or more whitespace / underscore characters with a single hyphen
- * - Strip any characters that are not alphanumeric or hyphens
- *
- * @example
- * normalizeWorkflowName("Repository Audit") // "repository-audit"
- * normalizeWorkflowName("my_workflow")             // "my-workflow"
- * normalizeWorkflowName("  My Workflow  ")         // "my-workflow"
- */
-export function normalizeWorkflowName(name: string): string {
-	if (!name || typeof name !== "string") {
-		throw new TypeError("normalizeWorkflowName: name must be a non-empty string");
-	}
-	return name
-		.trim()
-		.toLowerCase()
-		.replace(/[\s_]+/g, "-")
-		.replace(/[^a-z0-9-]/g, "")
-		.replace(/-{2,}/g, "-")
-		.replace(/^-|-$/g, "");
-}
-
-/**
- * Returns true when two workflow names refer to the same workflow
- * (i.e. their normalized forms are identical).
- */
-export function workflowNamesEqual(a: string, b: string): boolean {
-	return normalizeWorkflowName(a) === normalizeWorkflowName(b);
-}

package/dist/builtin/workflows/src/workflows/registry.ts

@@ -1,115 +0,0 @@
-/**
- * Workflow registry — createRegistry().
- * Immutable, chainable, keyed by normalized workflow name.
- *
- * Supported operations: register, get, has, remove, merge, names, all.
- *
- * cross-ref: v0.x packages/atomic-sdk/src/registry.ts
- *            pi-subagents src/agents/agents.ts (discover/parse)
- */
-
-import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../shared/types.js";
-import { normalizeWorkflowName } from "./identity.js";
-
-export interface WorkflowRegistry {
-	/**
-	 * Register a compiled workflow definition.
-	 * Keyed by the definition's normalizedName; replaces any prior entry with
-	 * the same key.  Returns a NEW registry — this one is unchanged.
-	 */
-	register<
-		TInputs extends WorkflowInputValues,
-		TOutputs extends WorkflowOutputValues,
-		TRunInputs extends WorkflowInputValues = TInputs,
-	>(definition: WorkflowDefinition<TInputs, TOutputs, TRunInputs>): WorkflowRegistry;
-	/**
-	 * Return a new registry with all definitions from another registry merged
-	 * in (other's entries win on collision).
-	 */
-	merge(other: WorkflowRegistry): WorkflowRegistry;
-	/**
-	 * Retrieve a workflow by (raw or normalized) name.
-	 * Returns undefined when not found.
-	 */
-	get(name: string): WorkflowDefinition | undefined;
-	/** Return true when a workflow with the given (raw or normalized) name exists. */
-	has(name: string): boolean;
-	/**
-	 * Return a new registry with the named workflow removed.
-	 * No-op (returns equivalent registry) if the name is not found.
-	 */
-	remove(name: string): WorkflowRegistry;
-	/** Return all registered normalized names (insertion-order preserved). */
-	names(): string[];
-	/** Return all registered workflow definitions (insertion-order preserved). */
-	all(): WorkflowDefinition[];
-}
-
-// ---------------------------------------------------------------------------
-// Internal factory
-// ---------------------------------------------------------------------------
-
-/**
- * Construct a registry backed by an ordered Map keyed by normalizedName.
- */
-function makeRegistry(store: Map<string, WorkflowDefinition>): WorkflowRegistry {
-	return {
-		register(definition) {
-			const next = new Map(store);
-			next.set(definition.normalizedName, definition as never as WorkflowDefinition);
-			return makeRegistry(next);
-		},
-
-		merge(other) {
-			const next = new Map(store);
-			for (const def of other.all()) {
-				next.set(def.normalizedName, def);
-			}
-			return makeRegistry(next);
-		},
-
-		get(name) {
-			return store.get(normalizeWorkflowName(name));
-		},
-
-		has(name) {
-			return store.has(normalizeWorkflowName(name));
-		},
-
-		remove(name) {
-			const key = normalizeWorkflowName(name);
-			if (!store.has(key)) return this;
-			const next = new Map(store);
-			next.delete(key);
-			return makeRegistry(next);
-		},
-
-		names() {
-			return [...store.keys()];
-		},
-
-		all() {
-			return [...store.values()];
-		},
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Public factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a new empty (or pre-populated) immutable-style workflow registry.
- *
- * @example
- * const registry = createRegistry()
- *   .register(myWorkflow)
- *   .register(otherWorkflow);
- *
- * registry.get("my-workflow"); // WorkflowDefinition | undefined
- * registry.has("other-workflow"); // true
- */
-export function createRegistry(initial: WorkflowDefinition[] = []): WorkflowRegistry {
-	const store = new Map<string, WorkflowDefinition>(initial.map((d) => [d.normalizedName, d]));
-	return makeRegistry(store);
-}