substrate-ai 0.1.32 → 0.2.0

package/dist/event-bus-J-bw-pkp.js

@@ -0,0 +1,1549 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as readline from "node:readline";
+import { EventEmitter } from "node:events";
+
+//#region src/adapters/claude-adapter.ts
+const execAsync$2 = promisify(exec);
+/** Default model used when none is specified */
+const DEFAULT_MODEL$1 = "claude-sonnet-4-6";
+/** Approximate characters per token for estimation */
+const CHARS_PER_TOKEN$2 = 3;
+/** Estimated output token multiplier relative to input */
+const OUTPUT_RATIO$2 = .5;
+/** Strip markdown code fences from LLM output (e.g. ```json ... ```) */
+function stripCodeFences$2(raw) {
+	return raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+}
+/**
+* Adapter for the Claude Code CLI agent.
+*
+* Capabilities: JSON output, streaming, both billing modes, plan generation.
+* Health check: runs `claude --version` to verify install.
+* Billing detection: detects subscription vs API via version output or env.
+*/
+var ClaudeCodeAdapter = class {
+	id = "claude-code";
+	displayName = "Claude Code";
+	adapterVersion = "1.0.0";
+	/**
+	* Verify the `claude` binary is installed and responsive.
+	* Detects subscription vs API billing mode.
+	*/
+	async healthCheck() {
+		try {
+			const { stdout } = await execAsync$2("claude --version", { timeout: 1e4 });
+			const output = stdout.trim();
+			const detectedBillingModes = this._detectBillingModes(output);
+			let cliPath;
+			try {
+				const whichResult = await execAsync$2("which claude", { timeout: 5e3 });
+				cliPath = whichResult.stdout.trim();
+			} catch {}
+			return {
+				healthy: true,
+				version: output,
+				...cliPath !== void 0 ? { cliPath } : {},
+				detectedBillingModes,
+				supportsHeadless: true
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				healthy: false,
+				error: `Claude CLI not available: ${message}`,
+				supportsHeadless: false
+			};
+		}
+	}
+	/**
+	* Build spawn command for a coding task.
+	* Uses: `claude -p <prompt> --model <model> --dangerously-skip-permissions --system-prompt <minimal>`
+	*/
+	buildCommand(prompt, options) {
+		const model = options.model ?? DEFAULT_MODEL$1;
+		const systemPrompt = "You are an autonomous coding agent executing a single pipeline task. Ignore all session startup context, memory notes, and \"Next Up\" indicators. Follow the instructions in the user message exactly. Emit ONLY the YAML output specified in the Output Contract — no other text.";
+		const args = [
+			"-p",
+			prompt,
+			"--model",
+			model,
+			"--dangerously-skip-permissions",
+			"--system-prompt",
+			systemPrompt
+		];
+		if (options.maxTurns !== void 0) args.push("--max-turns", String(options.maxTurns));
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		const unsetKeys = ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"];
+		if (options.billingMode === "api" && options.apiKey) envEntries.ANTHROPIC_API_KEY = options.apiKey;
+		else unsetKeys.push("ANTHROPIC_API_KEY");
+		return {
+			binary: "claude",
+			args,
+			env: envEntries,
+			unsetEnvKeys: unsetKeys,
+			cwd: options.worktreePath
+		};
+	}
+	/**
+	* Build spawn command for plan generation.
+	* Appends a structured planning directive to the prompt.
+	*/
+	buildPlanningCommand(request, options) {
+		const model = options.model ?? DEFAULT_MODEL$1;
+		const planningPrompt = this._buildPlanningPrompt(request);
+		const args = [
+			"-p",
+			planningPrompt,
+			"--model",
+			model
+		];
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		const planUnsetKeys = ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"];
+		if (options.billingMode === "api" && options.apiKey) envEntries.ANTHROPIC_API_KEY = options.apiKey;
+		else planUnsetKeys.push("ANTHROPIC_API_KEY");
+		return {
+			binary: "claude",
+			args,
+			env: envEntries,
+			unsetEnvKeys: planUnsetKeys,
+			cwd: options.worktreePath
+		};
+	}
+	/**
+	* Parse Claude CLI JSON stdout output into TaskResult.
+	*/
+	parseOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			output: stdout,
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			exitCode
+		};
+		if (stdout.trim() === "") return {
+			success: true,
+			output: "",
+			exitCode
+		};
+		try {
+			const parsed = JSON.parse(stdout.trim());
+			const success = parsed.status === "completed" || parsed.status === void 0;
+			const rawTokens = parsed.metadata?.tokensUsed;
+			const tokensUsed = rawTokens !== void 0 ? {
+				input: rawTokens.input ?? 0,
+				output: rawTokens.output ?? 0,
+				total: (rawTokens.input ?? 0) + (rawTokens.output ?? 0)
+			} : void 0;
+			const executionTime = parsed.metadata?.executionTime;
+			return {
+				success: success && !parsed.error,
+				output: parsed.output ?? stdout,
+				...parsed.error ? { error: parsed.error } : {},
+				exitCode,
+				metadata: {
+					...executionTime !== void 0 ? { executionTime } : {},
+					...tokensUsed !== void 0 ? { tokensUsed } : {}
+				}
+			};
+		} catch {
+			return {
+				success: true,
+				output: stdout,
+				exitCode
+			};
+		}
+	}
+	/**
+	* Parse plan generation output from Claude.
+	*/
+	parsePlanOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			tasks: [],
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			rawOutput: stdout
+		};
+		if (stdout.trim() === "") return {
+			success: false,
+			tasks: [],
+			error: "Empty output from plan generation",
+			rawOutput: stdout
+		};
+		try {
+			const parsed = JSON.parse(stripCodeFences$2(stdout));
+			if (!Array.isArray(parsed.tasks)) return {
+				success: false,
+				tasks: [],
+				error: "Plan output missing tasks array",
+				rawOutput: stdout
+			};
+			const tasks = parsed.tasks.map((t) => ({
+				title: t.title ?? "Untitled task",
+				description: t.description ?? "",
+				...t.complexity !== void 0 ? { complexity: t.complexity } : {},
+				...t.dependencies !== void 0 ? { dependencies: t.dependencies } : {}
+			}));
+			return {
+				success: true,
+				tasks,
+				rawOutput: stdout
+			};
+		} catch {
+			return {
+				success: false,
+				tasks: [],
+				error: "Failed to parse plan output as JSON",
+				rawOutput: stdout
+			};
+		}
+	}
+	/**
+	* Estimate token count using character-based heuristic.
+	* Approximation: 1 token ≈ 3 characters for English text.
+	*/
+	estimateTokens(prompt) {
+		const input = Math.ceil(prompt.length / CHARS_PER_TOKEN$2);
+		const output = Math.ceil(input * OUTPUT_RATIO$2);
+		return {
+			input,
+			output,
+			total: input + output
+		};
+	}
+	/**
+	* Return Claude Code's capabilities.
+	*/
+	getCapabilities() {
+		return {
+			supportsJsonOutput: true,
+			supportsStreaming: true,
+			supportsSubscriptionBilling: true,
+			supportsApiBilling: true,
+			supportsPlanGeneration: true,
+			maxContextTokens: 2e5,
+			supportedTaskTypes: [
+				"code",
+				"refactor",
+				"test",
+				"review",
+				"debug",
+				"document",
+				"analyze"
+			],
+			supportedLanguages: ["*"]
+		};
+	}
+	_detectBillingModes(_versionOutput) {
+		const explicit = process.env.ADT_BILLING_MODE;
+		if (explicit === "subscription" || explicit === "api" || explicit === "free") return [explicit];
+		const modes = ["subscription"];
+		if (process.env.ANTHROPIC_API_KEY) modes.push("api");
+		return modes;
+	}
+	_buildPlanningPrompt(request) {
+		const maxTasks = request.maxTasks ?? 10;
+		const contextSection = request.context ? `\n\nAdditional context:\n${request.context}` : "";
+		return `Generate a detailed task plan for the following goal:\n${request.goal}${contextSection}\n\nOutput a JSON object with a "tasks" array. Each task should have: "title" (string), "description" (string), "complexity" (1-10 integer), "dependencies" (array of task titles this depends on). Produce at most ${String(maxTasks)} tasks. Output ONLY raw valid JSON — no markdown, no code fences, no explanation. Start your response with { and end with }.`;
+	}
+};
+
+//#endregion
+//#region src/adapters/codex-adapter.ts
+const execAsync$1 = promisify(exec);
+/** Approximate characters per token for estimation */
+const CHARS_PER_TOKEN$1 = 3;
+/** Estimated output token multiplier relative to input */
+const OUTPUT_RATIO$1 = .5;
+/** Strip markdown code fences from LLM output (e.g. ```json ... ```) */
+function stripCodeFences$1(raw) {
+	return raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+}
+/** Codex default billing modes — subscription via `codex login`, or API key */
+const CODEX_BILLING_MODES = ["subscription", "api"];
+/**
+* Adapter for the OpenAI Codex CLI agent.
+*
+* Codex CLI uses stdin for the prompt and outputs JSON when --json flag is used.
+* Codex supports subscription billing (via `codex login`) and API key billing.
+*/
+var CodexCLIAdapter = class {
+	id = "codex";
+	displayName = "Codex CLI";
+	adapterVersion = "1.0.0";
+	/**
+	* Verify the `codex` binary is installed and responsive.
+	*/
+	async healthCheck() {
+		try {
+			const { stdout } = await execAsync$1("codex --version", { timeout: 1e4 });
+			const output = stdout.trim();
+			let cliPath;
+			try {
+				const whichResult = await execAsync$1("which codex", { timeout: 5e3 });
+				cliPath = whichResult.stdout.trim();
+			} catch {}
+			return {
+				healthy: true,
+				version: output,
+				...cliPath !== void 0 ? { cliPath } : {},
+				detectedBillingModes: CODEX_BILLING_MODES,
+				supportsHeadless: true
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				healthy: false,
+				error: `Codex CLI not available: ${message}`,
+				supportsHeadless: false
+			};
+		}
+	}
+	/**
+	* Build spawn command for a coding task.
+	* Uses: `codex exec --json` with prompt delivered via stdin.
+	*/
+	buildCommand(prompt, options) {
+		const args = ["exec", "--json"];
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		if (options.apiKey) envEntries.OPENAI_API_KEY = options.apiKey;
+		const hasEnv = Object.keys(envEntries).length > 0;
+		return {
+			binary: "codex",
+			args,
+			...hasEnv ? { env: envEntries } : {},
+			cwd: options.worktreePath,
+			stdin: prompt
+		};
+	}
+	/**
+	* Build spawn command for plan generation.
+	* Uses codex exec with a JSON plan generation prompt via stdin.
+	*/
+	buildPlanningCommand(request, options) {
+		const planningPrompt = this._buildPlanningPrompt(request);
+		const args = [
+			"exec",
+			planningPrompt,
+			"--sandbox",
+			"read-only"
+		];
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		if (options.apiKey) envEntries.OPENAI_API_KEY = options.apiKey;
+		const hasEnv = Object.keys(envEntries).length > 0;
+		return {
+			binary: "codex",
+			args,
+			...hasEnv ? { env: envEntries } : {},
+			cwd: options.worktreePath
+		};
+	}
+	/**
+	* Parse Codex CLI JSON output into a TaskResult.
+	*/
+	parseOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			output: stdout,
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			exitCode
+		};
+		if (stdout.trim() === "") return {
+			success: true,
+			output: "",
+			exitCode
+		};
+		try {
+			const parsed = JSON.parse(stdout.trim());
+			const success = parsed.status === "success" || parsed.status === "completed" || parsed.status === void 0 && !parsed.error;
+			const inputTokens = parsed.tokens?.input ?? 0;
+			const outputTokens = parsed.tokens?.output ?? 0;
+			const totalTokens = parsed.tokens?.total ?? inputTokens + outputTokens;
+			const hasTokens = inputTokens > 0 || outputTokens > 0;
+			const tokensUsed = hasTokens ? {
+				input: inputTokens,
+				output: outputTokens,
+				total: totalTokens
+			} : void 0;
+			const executionTime = parsed.executionTime;
+			return {
+				success: success && !parsed.error,
+				output: parsed.output ?? parsed.result ?? stdout,
+				...parsed.error ? { error: parsed.error } : {},
+				exitCode,
+				metadata: {
+					...executionTime !== void 0 ? { executionTime } : {},
+					...tokensUsed !== void 0 ? { tokensUsed } : {}
+				}
+			};
+		} catch {
+			return {
+				success: true,
+				output: stdout,
+				exitCode
+			};
+		}
+	}
+	/**
+	* Parse Codex plan generation output.
+	*/
+	parsePlanOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			tasks: [],
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			rawOutput: stdout
+		};
+		if (stdout.trim() === "") return {
+			success: false,
+			tasks: [],
+			error: "Empty output from plan generation",
+			rawOutput: stdout
+		};
+		try {
+			const parsed = JSON.parse(stripCodeFences$1(stdout));
+			if (parsed.tasks === void 0 && parsed.plan === void 0) return {
+				success: false,
+				tasks: [],
+				error: "Plan output missing tasks array",
+				rawOutput: stdout
+			};
+			const rawTasks = parsed.tasks ?? parsed.plan ?? [];
+			if (!Array.isArray(rawTasks)) return {
+				success: false,
+				tasks: [],
+				error: "Plan output missing tasks array",
+				rawOutput: stdout
+			};
+			const tasks = rawTasks.map((t) => {
+				const deps = "dependencies" in t ? t.dependencies : t.deps;
+				return {
+					title: t.title ?? "Untitled task",
+					description: t.description ?? "",
+					...t.complexity !== void 0 ? { complexity: t.complexity } : {},
+					...deps !== void 0 ? { dependencies: deps } : {}
+				};
+			});
+			return {
+				success: true,
+				tasks,
+				rawOutput: stdout
+			};
+		} catch {
+			return {
+				success: false,
+				tasks: [],
+				error: "Failed to parse Codex plan output as JSON",
+				rawOutput: stdout
+			};
+		}
+	}
+	/**
+	* Estimate token count using character-based heuristic.
+	*/
+	estimateTokens(prompt) {
+		const input = Math.ceil(prompt.length / CHARS_PER_TOKEN$1);
+		const output = Math.ceil(input * OUTPUT_RATIO$1);
+		return {
+			input,
+			output,
+			total: input + output
+		};
+	}
+	/**
+	* Return Codex CLI capabilities.
+	*/
+	getCapabilities() {
+		return {
+			supportsJsonOutput: true,
+			supportsStreaming: false,
+			supportsSubscriptionBilling: true,
+			supportsApiBilling: true,
+			supportsPlanGeneration: true,
+			maxContextTokens: 128e3,
+			supportedTaskTypes: [
+				"code",
+				"refactor",
+				"test",
+				"debug",
+				"analyze"
+			],
+			supportedLanguages: ["*"]
+		};
+	}
+	_buildPlanningPrompt(request) {
+		const maxTasks = request.maxTasks ?? 10;
+		const contextSection = request.context ? `\n\nAdditional context:\n${request.context}` : "";
+		return `Generate a detailed task plan for the following goal:\n${request.goal}${contextSection}\n\nOutput a JSON object with a "tasks" array. Each task should have: "title" (string), "description" (string), "complexity" (1-10 integer), "dependencies" (array of task titles this depends on). Produce at most ${String(maxTasks)} tasks. Output ONLY raw valid JSON — no markdown, no code fences, no explanation. Start your response with { and end with }.`;
+	}
+};
+
+//#endregion
+//#region src/adapters/gemini-adapter.ts
+const execAsync = promisify(exec);
+/** Default model used when none is specified */
+const DEFAULT_MODEL = "gemini-2.0-flash";
+/** Approximate characters per token for estimation */
+const CHARS_PER_TOKEN = 3;
+/** Estimated output token multiplier relative to input */
+const OUTPUT_RATIO = .5;
+/**
+* Strip markdown code fences from LLM output.
+* LLMs often wrap JSON in ```json ... ``` despite being told not to.
+*/
+function stripCodeFences(raw) {
+	const stripped = raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "");
+	return stripped.trim();
+}
+/**
+* Adapter for the Google Gemini CLI agent.
+*
+* Gemini CLI follows similar patterns to Claude Code: prompt via `-p` flag,
+* JSON output via `--output-format json`, and model via `--model`.
+*/
+var GeminiCLIAdapter = class {
+	id = "gemini";
+	displayName = "Gemini CLI";
+	adapterVersion = "1.0.0";
+	/**
+	* Verify the `gemini` binary is installed and responsive.
+	* Detects subscription vs API billing mode.
+	*/
+	async healthCheck() {
+		try {
+			const { stdout } = await execAsync("gemini --version", { timeout: 1e4 });
+			const output = stdout.trim();
+			const detectedBillingModes = this._detectBillingModes(output);
+			let cliPath;
+			try {
+				const whichResult = await execAsync("which gemini", { timeout: 5e3 });
+				cliPath = whichResult.stdout.trim();
+			} catch {}
+			return {
+				healthy: true,
+				version: output,
+				...cliPath !== void 0 ? { cliPath } : {},
+				detectedBillingModes,
+				supportsHeadless: true
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				healthy: false,
+				error: `Gemini CLI not available: ${message}`,
+				supportsHeadless: false
+			};
+		}
+	}
+	/**
+	* Build spawn command for a coding task.
+	* Uses: `gemini -p <prompt> --output-format json --model <model>`
+	*/
+	buildCommand(prompt, options) {
+		const model = options.model ?? DEFAULT_MODEL;
+		const args = [
+			"-p",
+			prompt,
+			"--output-format",
+			"json",
+			"--model",
+			model
+		];
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		if (options.billingMode === "api" && options.apiKey) envEntries.GEMINI_API_KEY = options.apiKey;
+		const hasEnv = Object.keys(envEntries).length > 0;
+		return {
+			binary: "gemini",
+			args,
+			...hasEnv ? { env: envEntries } : {},
+			cwd: options.worktreePath
+		};
+	}
+	/**
+	* Build spawn command for plan generation.
+	*/
+	buildPlanningCommand(request, options) {
+		const model = options.model ?? DEFAULT_MODEL;
+		const planningPrompt = this._buildPlanningPrompt(request);
+		const args = [
+			planningPrompt,
+			"--model",
+			model
+		];
+		if (options.additionalFlags && options.additionalFlags.length > 0) args.push(...options.additionalFlags);
+		const envEntries = {};
+		if (options.billingMode === "api" && options.apiKey) envEntries.GEMINI_API_KEY = options.apiKey;
+		const hasEnv = Object.keys(envEntries).length > 0;
+		return {
+			binary: "gemini",
+			args,
+			...hasEnv ? { env: envEntries } : {},
+			cwd: options.worktreePath
+		};
+	}
+	/**
+	* Parse Gemini CLI JSON output into a TaskResult.
+	*/
+	parseOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			output: stdout,
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			exitCode
+		};
+		if (stdout.trim() === "") return {
+			success: true,
+			output: "",
+			exitCode
+		};
+		try {
+			const parsed = JSON.parse(stdout.trim());
+			const success = parsed.status === "completed" || parsed.status === void 0;
+			const usageMeta = parsed.metadata?.usageMetadata;
+			const inputTokens = parsed.metadata?.tokensUsed?.input ?? usageMeta?.promptTokenCount ?? 0;
+			const outputTokens = parsed.metadata?.tokensUsed?.output ?? usageMeta?.candidatesTokenCount ?? 0;
+			const hasTokens = inputTokens > 0 || outputTokens > 0;
+			const tokensUsed = hasTokens ? {
+				input: inputTokens,
+				output: outputTokens,
+				total: inputTokens + outputTokens
+			} : void 0;
+			const executionTime = parsed.metadata?.executionTime;
+			return {
+				success: success && !parsed.error,
+				output: parsed.output ?? parsed.response ?? stdout,
+				...parsed.error ? { error: parsed.error } : {},
+				exitCode,
+				metadata: {
+					...executionTime !== void 0 ? { executionTime } : {},
+					...tokensUsed !== void 0 ? { tokensUsed } : {}
+				}
+			};
+		} catch {
+			return {
+				success: true,
+				output: stdout,
+				exitCode
+			};
+		}
+	}
+	/**
+	* Parse Gemini plan generation output.
+	*/
+	parsePlanOutput(stdout, stderr, exitCode) {
+		if (exitCode !== 0) return {
+			success: false,
+			tasks: [],
+			error: stderr || `Process exited with code ${String(exitCode)}`,
+			rawOutput: stdout
+		};
+		if (stdout.trim() === "") return {
+			success: false,
+			tasks: [],
+			error: "Empty output from plan generation",
+			rawOutput: stdout
+		};
+		try {
+			const parsed = JSON.parse(stripCodeFences(stdout));
+			if (!Array.isArray(parsed.tasks)) return {
+				success: false,
+				tasks: [],
+				error: "Plan output missing tasks array",
+				rawOutput: stdout
+			};
+			const tasks = parsed.tasks.map((t) => ({
+				title: t.title ?? "Untitled task",
+				description: t.description ?? "",
+				...t.complexity !== void 0 ? { complexity: t.complexity } : {},
+				...t.dependencies !== void 0 ? { dependencies: t.dependencies } : {}
+			}));
+			return {
+				success: true,
+				tasks,
+				rawOutput: stdout
+			};
+		} catch {
+			return {
+				success: false,
+				tasks: [],
+				error: "Failed to parse Gemini plan output as JSON",
+				rawOutput: stdout
+			};
+		}
+	}
+	/**
+	* Estimate token count using character-based heuristic.
+	*/
+	estimateTokens(prompt) {
+		const input = Math.ceil(prompt.length / CHARS_PER_TOKEN);
+		const output = Math.ceil(input * OUTPUT_RATIO);
+		return {
+			input,
+			output,
+			total: input + output
+		};
+	}
+	/**
+	* Return Gemini CLI capabilities.
+	*/
+	getCapabilities() {
+		return {
+			supportsJsonOutput: true,
+			supportsStreaming: true,
+			supportsSubscriptionBilling: true,
+			supportsApiBilling: true,
+			supportsPlanGeneration: true,
+			maxContextTokens: 1e6,
+			supportedTaskTypes: [
+				"code",
+				"refactor",
+				"test",
+				"review",
+				"debug",
+				"document",
+				"analyze"
+			],
+			supportedLanguages: ["*"]
+		};
+	}
+	_detectBillingModes(versionOutput) {
+		const explicit = process.env.ADT_BILLING_MODE;
+		if (explicit === "subscription" || explicit === "api" || explicit === "free") return [explicit];
+		const modes = [];
+		if (process.env.GEMINI_API_KEY) modes.push("api");
+		if (versionOutput.toLowerCase().includes("subscription")) modes.push("subscription");
+		if (modes.length === 0) return ["subscription", "api"];
+		return modes;
+	}
+	_buildPlanningPrompt(request) {
+		const maxTasks = request.maxTasks ?? 10;
+		const contextSection = request.context ? `\n\nAdditional context:\n${request.context}` : "";
+		return `Generate a detailed task plan for the following goal:\n${request.goal}${contextSection}\n\nOutput a JSON object with a "tasks" array. Each task should have: "title" (string), "description" (string), "complexity" (1-10 integer), "dependencies" (array of task titles this depends on). Produce at most ${String(maxTasks)} tasks. Output ONLY raw valid JSON — no markdown, no code fences, no explanation. Start your response with { and end with }.`;
+	}
+};
+
+//#endregion
+//#region src/adapters/adapter-registry.ts
+/**
+* AdapterRegistry manages the lifecycle of WorkerAdapter instances.
+*
+* Usage:
+* ```typescript
+* const registry = new AdapterRegistry()
+* const report = await registry.discoverAndRegister()
+* const claude = registry.get('claude-code')
+* ```
+*/
+var AdapterRegistry = class {
+	_adapters = new Map();
+	/**
+	* Register an adapter by its id.
+	* Overwrites any existing adapter with the same id.
+	*/
+	register(adapter) {
+		this._adapters.set(adapter.id, adapter);
+	}
+	/**
+	* Retrieve a registered adapter by id.
+	* @returns The adapter, or undefined if not registered
+	*/
+	get(id) {
+		return this._adapters.get(id);
+	}
+	/**
+	* Return all registered adapters as an array.
+	*/
+	getAll() {
+		return Array.from(this._adapters.values());
+	}
+	/**
+	* Return all registered adapters that support plan generation.
+	*/
+	getPlanningCapable() {
+		return this.getAll().filter((adapter) => adapter.getCapabilities().supportsPlanGeneration);
+	}
+	/**
+	* Instantiate all built-in adapters, run health checks sequentially,
+	* and register those that pass.
+	*
+	* Failed adapters are included in the report but do NOT prevent startup.
+	*
+	* @returns Discovery report with per-adapter results
+	*/
+	async discoverAndRegister() {
+		const builtInAdapters = [
+			new ClaudeCodeAdapter(),
+			new CodexCLIAdapter(),
+			new GeminiCLIAdapter()
+		];
+		const results = [];
+		let registeredCount = 0;
+		let failedCount = 0;
+		for (const adapter of builtInAdapters) {
+			let healthResult;
+			try {
+				healthResult = await adapter.healthCheck();
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				healthResult = {
+					healthy: false,
+					error: `Unexpected error during health check: ${message}`,
+					supportsHeadless: false
+				};
+			}
+			const registered = healthResult.healthy;
+			if (registered) {
+				this.register(adapter);
+				registeredCount++;
+			} else failedCount++;
+			results.push({
+				adapterId: adapter.id,
+				displayName: adapter.displayName,
+				healthResult,
+				registered
+			});
+		}
+		return {
+			registeredCount,
+			failedCount,
+			results
+		};
+	}
+};
+
+//#endregion
+//#region src/tui/ansi.ts
+/**
+* ANSI escape code helpers for TUI rendering.
+*
+* Provides cursor control, color, and screen manipulation utilities.
+*/
+const ANSI = {
+	RESET: "\x1B[0m",
+	BOLD: "\x1B[1m",
+	DIM: "\x1B[2m",
+	BLACK: "\x1B[30m",
+	RED: "\x1B[31m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m",
+	BLUE: "\x1B[34m",
+	MAGENTA: "\x1B[35m",
+	CYAN: "\x1B[36m",
+	WHITE: "\x1B[37m",
+	BRIGHT_BLACK: "\x1B[90m",
+	BRIGHT_RED: "\x1B[91m",
+	BRIGHT_GREEN: "\x1B[92m",
+	BRIGHT_YELLOW: "\x1B[93m",
+	BRIGHT_BLUE: "\x1B[94m",
+	BRIGHT_MAGENTA: "\x1B[95m",
+	BRIGHT_CYAN: "\x1B[96m",
+	BRIGHT_WHITE: "\x1B[97m",
+	BG_BLACK: "\x1B[40m",
+	BG_WHITE: "\x1B[47m",
+	BG_BLUE: "\x1B[44m",
+	BG_BRIGHT_BLACK: "\x1B[100m",
+	HIDE_CURSOR: "\x1B[?25l",
+	SHOW_CURSOR: "\x1B[?25h",
+	CLEAR_SCREEN: "\x1B[2J",
+	HOME: "\x1B[H",
+	CLEAR_LINE: "\x1B[2K",
+	ERASE_DOWN: "\x1B[J",
+	ALT_SCREEN_ENTER: "\x1B[?1049h",
+	ALT_SCREEN_EXIT: "\x1B[?1049l"
+};
+/** Check if color output is supported. */
+function supportsColor(isTTY) {
+	if (process.env.NO_COLOR !== void 0) return false;
+	return isTTY;
+}
+/** Wrap text with an ANSI color code (only if color is enabled). */
+function colorize(text, code, useColor) {
+	if (!useColor) return text;
+	return `${code}${text}${ANSI.RESET}`;
+}
+/** Bold text. */
+function bold(text, useColor) {
+	if (!useColor) return text;
+	return `${ANSI.BOLD}${text}${ANSI.RESET}`;
+}
+/**
+* Get current terminal dimensions.
+* Returns { cols, rows } with fallback defaults if unavailable.
+*/
+function getTerminalSize() {
+	const cols = process.stdout.columns ?? 80;
+	const rows = process.stdout.rows ?? 24;
+	return {
+		cols,
+		rows
+	};
+}
+/**
+* Truncate a string to fit within maxWidth characters.
+* Adds ellipsis if truncated.
+*/
+function truncate(text, maxWidth) {
+	if (maxWidth <= 0) return "";
+	if (text.length <= maxWidth) return text;
+	if (maxWidth <= 3) return text.slice(0, maxWidth);
+	return text.slice(0, maxWidth - 3) + "...";
+}
+/**
+* Pad or truncate a string to exactly `width` characters.
+*/
+function padOrTruncate(text, width, padChar = " ") {
+	if (text.length > width) return truncate(text, width);
+	return text.padEnd(width, padChar);
+}
+
+//#endregion
+//#region src/tui/story-panel.ts
+const COL_KEY_WIDTH = 12;
+const COL_PHASE_WIDTH = 8;
+const COL_STATUS_WIDTH = 30;
+/**
+* Get ANSI color code for a story status.
+*/
+function statusColor(status) {
+	switch (status) {
+		case "pending": return ANSI.BRIGHT_BLACK;
+		case "in_progress": return ANSI.YELLOW;
+		case "succeeded": return ANSI.GREEN;
+		case "failed":
+		case "escalated": return ANSI.RED;
+		default: return ANSI.RESET;
+	}
+}
+/**
+* Get status indicator symbol for a story status.
+*/
+function statusSymbol(status) {
+	switch (status) {
+		case "pending": return "○";
+		case "in_progress": return "◉";
+		case "succeeded": return "✓";
+		case "failed":
+		case "escalated": return "✗";
+		default: return "·";
+	}
+}
+/**
+* Render the story panel header row.
+*/
+function renderStoryPanelHeader(useColor) {
+	const key = padOrTruncate("STORY", COL_KEY_WIDTH);
+	const phase = padOrTruncate("PHASE", COL_PHASE_WIDTH);
+	const status = "STATUS";
+	const header = `  ${key}  ${phase}  ${status}`;
+	return bold(colorize(header, ANSI.BRIGHT_WHITE, useColor), useColor);
+}
+/**
+* Render a single story row.
+*/
+function renderStoryRow(story, isSelected, useColor, width) {
+	const symbol = statusSymbol(story.status);
+	const color = statusColor(story.status);
+	const keyCol = padOrTruncate(story.key, COL_KEY_WIDTH);
+	const phaseCol = padOrTruncate(story.phase, COL_PHASE_WIDTH);
+	const statusCol = padOrTruncate(story.statusLabel, COL_STATUS_WIDTH);
+	const maxWidth = Math.max(width - 2, 10);
+	let row = `${symbol} ${keyCol}  ${phaseCol}  ${statusCol}`;
+	row = row.slice(0, maxWidth);
+	if (useColor) row = `${color}${row}${ANSI.RESET}`;
+	if (isSelected && useColor) row = `${ANSI.BG_BRIGHT_BLACK}${row}${ANSI.RESET}`;
+	else if (isSelected) row = `> ${row.slice(2)}`;
+	return row;
+}
+/**
+* Render the complete story panel.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderStoryPanel(options) {
+	const { stories, selectedIndex, useColor, width } = options;
+	const lines = [];
+	lines.push(bold(colorize("  Story Status", ANSI.CYAN, useColor), useColor));
+	lines.push(renderStoryPanelHeader(useColor));
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	if (stories.length === 0) lines.push(colorize("  (no stories)", ANSI.BRIGHT_BLACK, useColor));
+	else for (let i = 0; i < stories.length; i++) {
+		const story = stories[i];
+		if (story !== void 0) lines.push(renderStoryRow(story, i === selectedIndex, useColor, width));
+	}
+	return lines;
+}
+
+//#endregion
+//#region src/tui/log-panel.ts
+/**
+* Format a log entry timestamp to a short HH:MM:SS format.
+*/
+function formatTimestamp(ts) {
+	try {
+		const date = new Date(ts);
+		const hh = date.getHours().toString().padStart(2, "0");
+		const mm = date.getMinutes().toString().padStart(2, "0");
+		const ss = date.getSeconds().toString().padStart(2, "0");
+		return `${hh}:${mm}:${ss}`;
+	} catch {
+		return ts.slice(11, 19);
+	}
+}
+/**
+* Render a single log entry line.
+*/
+function renderLogEntry(entry, useColor, width) {
+	const ts = formatTimestamp(entry.ts);
+	const prefix = `[${ts}] [${entry.key}] `;
+	const maxMsgWidth = Math.max(width - prefix.length - 2, 10);
+	const msg = truncate(entry.msg, maxMsgWidth);
+	const line = `${prefix}${msg}`;
+	if (useColor) {
+		if (entry.level === "warn") return colorize(line, ANSI.YELLOW, useColor);
+		const coloredPrefix = colorize(`[${ts}] `, ANSI.BRIGHT_BLACK, useColor) + colorize(`[${entry.key}] `, ANSI.CYAN, useColor);
+		return `${coloredPrefix}${msg}`;
+	}
+	return line;
+}
+/**
+* Render the complete log panel.
+*
+* Auto-scrolls to show the most recent entries (last `maxLines` entries).
+* Returns an array of lines to be written to the terminal.
+*/
+function renderLogPanel(options) {
+	const { entries, maxLines, useColor, width, filterKey } = options;
+	const lines = [];
+	const title = filterKey !== void 0 ? `  Logs for ${filterKey}` : "  Live Logs";
+	lines.push(bold(colorize(title, ANSI.CYAN, useColor), useColor));
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	const filtered = filterKey !== void 0 ? entries.filter((e) => e.key === filterKey) : entries;
+	if (filtered.length === 0) {
+		lines.push(colorize("  (no log entries)", ANSI.BRIGHT_BLACK, useColor));
+		return lines;
+	}
+	const visibleEntries = filtered.slice(-maxLines);
+	for (const entry of visibleEntries) lines.push("  " + renderLogEntry(entry, useColor, width - 2));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/detail-view.ts
+/**
+* Render the full detail view for a story.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderDetailView(options) {
+	const { story, allLogs, maxLogLines, useColor, width, height } = options;
+	const lines = [];
+	const titleBar = `  Story Detail: ${story.key}`;
+	lines.push(bold(colorize(titleBar, ANSI.BRIGHT_WHITE, useColor), useColor));
+	lines.push("  " + "═".repeat(Math.max(width - 4, 20)));
+	lines.push("");
+	const phaseLabel = padOrTruncate("Phase:", 12);
+	const statusLabel = padOrTruncate("Status:", 12);
+	const cyclesLabel = padOrTruncate("Review Cycles:", 12);
+	lines.push(`  ${bold(phaseLabel, useColor)} ${colorize(story.phase, ANSI.CYAN, useColor)}`);
+	lines.push(`  ${bold(statusLabel, useColor)} ${colorize(story.statusLabel, ANSI.WHITE, useColor)}`);
+	lines.push(`  ${bold(cyclesLabel, useColor)} ${story.reviewCycles}`);
+	if (story.escalationReason !== void 0) lines.push(`  ${bold(padOrTruncate("Escalated:", 12), useColor)} ${colorize(story.escalationReason, ANSI.RED, useColor)}`);
+	lines.push("");
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	const availableLogLines = Math.max(height - lines.length - 4, 3);
+	const logLines = renderLogPanel({
+		entries: allLogs,
+		maxLines: Math.min(maxLogLines, availableLogLines),
+		useColor,
+		width,
+		filterKey: story.key
+	});
+	lines.push(...logLines);
+	lines.push("");
+	lines.push(colorize("  [Esc] Back to overview", ANSI.BRIGHT_BLACK, useColor));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/help-overlay.ts
+/** All keyboard bindings shown in the help overlay. */
+const KEY_BINDINGS = [
+	{
+		key: "↑ / ↓",
+		description: "Navigate between stories"
+	},
+	{
+		key: "Enter",
+		description: "Drill into selected story detail view"
+	},
+	{
+		key: "Esc",
+		description: "Return to overview from detail view"
+	},
+	{
+		key: "q",
+		description: "Quit TUI (pipeline completes in background)"
+	},
+	{
+		key: "?",
+		description: "Show/hide this help overlay"
+	}
+];
+/**
+* Render the help overlay.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderHelpOverlay(options) {
+	const { useColor, width } = options;
+	const lines = [];
+	const boxWidth = Math.min(56, Math.max(width - 4, 30));
+	const horizontalBorder = "─".repeat(boxWidth - 2);
+	lines.push(colorize(`  ┌${horizontalBorder}┐`, ANSI.CYAN, useColor));
+	lines.push(colorize(`  │${padOrTruncate(" Keyboard Shortcuts", boxWidth - 2)}│`, ANSI.CYAN, useColor));
+	lines.push(colorize(`  ├${horizontalBorder}┤`, ANSI.CYAN, useColor));
+	for (const binding of KEY_BINDINGS) {
+		const keyPart = bold(padOrTruncate(binding.key, 12), useColor);
+		const descPart = padOrTruncate(binding.description, boxWidth - 16);
+		lines.push(useColor ? `${ANSI.CYAN}  │${ANSI.RESET}  ${keyPart}  ${descPart}${ANSI.CYAN}│${ANSI.RESET}` : `  │  ${keyPart}  ${descPart}│`);
+	}
+	lines.push(colorize(`  └${horizontalBorder}┘`, ANSI.CYAN, useColor));
+	lines.push(colorize("  Press ? to close", ANSI.BRIGHT_BLACK, useColor));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/app.ts
+/** Minimum terminal width for TUI to render properly. */
+const MIN_COLS = 80;
+/** Minimum terminal height for TUI to render properly. */
+const MIN_ROWS = 24;
+/** Maximum log entries to keep in memory. */
+const MAX_LOG_ENTRIES = 500;
+function mapPhaseToLabel(phase) {
+	switch (phase) {
+		case "create-story": return "create";
+		case "dev-story": return "dev";
+		case "code-review": return "review";
+		case "fix": return "fix";
+		default: return "wait";
+	}
+}
+function mapPhaseToStatus(phase, eventStatus) {
+	if (eventStatus === "failed") return "failed";
+	if (eventStatus === "in_progress") return "in_progress";
+	if (eventStatus === "complete") {
+		if (phase === "done") return "succeeded";
+		return "in_progress";
+	}
+	return "pending";
+}
+function makeStatusLabel(phase, eventStatus, verdict) {
+	if (eventStatus === "failed") return "failed";
+	if (eventStatus === "in_progress") switch (phase) {
+		case "create": return "creating story...";
+		case "dev": return "implementing...";
+		case "review": return "reviewing...";
+		case "fix": return "fixing issues...";
+		default: return "in progress...";
+	}
+	if (eventStatus === "complete") switch (phase) {
+		case "create": return "story created";
+		case "dev": return "implemented";
+		case "review": return verdict !== void 0 ? `reviewed (${verdict})` : "reviewed";
+		case "fix": return "fixes applied";
+		default: return "complete";
+	}
+	return "queued";
+}
+/**
+* Factory that creates a TUI application instance.
+*
+* @param output - Writable stream for rendering (typically process.stdout)
+* @param input  - Readable stream for keyboard input (typically process.stdin)
+*/
+function createTuiApp(output, input) {
+	const isTTY = output.isTTY === true;
+	const useColor = supportsColor(isTTY);
+	const state = {
+		headerLine: "",
+		storyOrder: [],
+		stories: new Map(),
+		logs: [],
+		selectedIndex: 0,
+		view: "overview",
+		pipelineComplete: false
+	};
+	let exitResolve;
+	const exitPromise = new Promise((resolve) => {
+		exitResolve = resolve;
+	});
+	let rl;
+	function write(text) {
+		try {
+			output.write(text);
+		} catch {}
+	}
+	function checkTerminalSize() {
+		const { cols, rows } = getTerminalSize();
+		if (cols < MIN_COLS || rows < MIN_ROWS) {
+			write(ANSI.CLEAR_SCREEN + ANSI.HOME);
+			write(colorize(`Terminal too small: ${cols}x${rows} (minimum ${MIN_COLS}x${MIN_ROWS})\n`, ANSI.YELLOW, useColor));
+			write("Please resize your terminal.\n");
+			return false;
+		}
+		return true;
+	}
+	function render() {
+		const { cols, rows } = getTerminalSize();
+		if (cols < MIN_COLS || rows < MIN_ROWS) {
+			checkTerminalSize();
+			return;
+		}
+		write(ANSI.CLEAR_SCREEN + ANSI.HOME);
+		const lines = [];
+		if (state.view === "help") renderHelpView(lines, cols, rows);
+		else if (state.view === "detail") renderDetailViewLayout(lines, cols, rows);
+		else renderOverviewLayout(lines, cols, rows);
+		for (const line of lines) write(line + "\n");
+	}
+	function renderOverviewLayout(lines, cols, rows) {
+		lines.push(bold(colorize("  substrate run --tui", ANSI.BRIGHT_WHITE, useColor), useColor));
+		if (state.headerLine) lines.push(colorize(`  ${state.headerLine}`, ANSI.BRIGHT_BLACK, useColor));
+		lines.push("");
+		const storyPanelHeight = Math.max(Math.floor(rows * .4), 6);
+		const storyPanelLines = renderStoryPanel({
+			stories: Array.from(state.storyOrder).map((k) => state.stories.get(k)).filter((s) => s !== void 0),
+			selectedIndex: state.selectedIndex,
+			useColor,
+			width: cols
+		});
+		lines.push(...storyPanelLines.slice(0, storyPanelHeight));
+		lines.push("");
+		lines.push("  " + "─".repeat(Math.max(cols - 4, 20)));
+		lines.push("");
+		const usedLines = lines.length + 3;
+		const logPanelHeight = Math.max(rows - usedLines, 3);
+		const logLines = renderLogPanel({
+			entries: state.logs,
+			maxLines: logPanelHeight,
+			useColor,
+			width: cols
+		});
+		lines.push(...logLines);
+		lines.push("");
+		const footerParts = [
+			colorize("[↑↓] Navigate", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[Enter] Details", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[q] Quit", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[?] Help", ANSI.BRIGHT_BLACK, useColor)
+		];
+		if (state.pipelineComplete) lines.push(colorize("  Pipeline complete. Press q to exit.", ANSI.GREEN, useColor));
+		lines.push("  " + footerParts.join("  "));
+	}
+	function renderDetailViewLayout(lines, cols, rows) {
+		const selectedKey = state.storyOrder[state.selectedIndex];
+		const story = selectedKey !== void 0 ? state.stories.get(selectedKey) : void 0;
+		if (story === void 0) {
+			lines.push("  No story selected. Press Esc to go back.");
+			return;
+		}
+		const detailLines = renderDetailView({
+			story,
+			allLogs: state.logs,
+			maxLogLines: Math.max(rows - 10, 5),
+			useColor,
+			width: cols,
+			height: rows
+		});
+		lines.push(...detailLines);
+	}
+	function renderHelpView(lines, cols, _rows) {
+		lines.push(bold(colorize("  substrate run --tui", ANSI.BRIGHT_WHITE, useColor), useColor));
+		lines.push("");
+		const helpLines = renderHelpOverlay({
+			useColor,
+			width: cols
+		});
+		lines.push(...helpLines);
+	}
+	function setupKeyboard() {
+		if (input.isTTY === true) try {
+			input.setRawMode(true);
+		} catch {}
+		rl = readline.createInterface({
+			input,
+			terminal: false
+		});
+		readline.emitKeypressEvents(input);
+		const stdin = input;
+		const onKeypress = (chunk, key) => {
+			if (key === void 0) return;
+			handleKeypress(key);
+		};
+		stdin.on("keypress", onKeypress);
+		rl.on("close", () => {
+			exit();
+		});
+	}
+	function handleKeypress(key) {
+		if (key.ctrl === true && key.name === "c") {
+			exit();
+			return;
+		}
+		switch (key.name) {
+			case "q":
+				exit();
+				return;
+			case "up":
+				if (state.view === "overview") {
+					state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+					render();
+				}
+				break;
+			case "down":
+				if (state.view === "overview") {
+					state.selectedIndex = Math.min(Math.max(0, state.storyOrder.length - 1), state.selectedIndex + 1);
+					render();
+				}
+				break;
+			case "return":
+			case "enter":
+				if (state.view === "overview" && state.storyOrder.length > 0) {
+					state.view = "detail";
+					render();
+				}
+				break;
+			case "escape":
+				if (state.view === "detail" || state.view === "help") {
+					state.view = "overview";
+					render();
+				}
+				break;
+			case "?":
+				state.view = state.view === "help" ? "overview" : "help";
+				render();
+				break;
+			default:
+				if (key.sequence === "?") {
+					state.view = state.view === "help" ? "overview" : "help";
+					render();
+				}
+				break;
+		}
+	}
+	function onResize() {
+		render();
+	}
+	function init() {
+		write(ANSI.ALT_SCREEN_ENTER);
+		write(ANSI.HIDE_CURSOR);
+		setupKeyboard();
+		const resizeEmitter = typeof output.on === "function" ? output : process.stdout;
+		resizeEmitter.on("resize", onResize);
+		render();
+	}
+	function exit() {
+		cleanup();
+		if (exitResolve !== void 0) {
+			exitResolve();
+			exitResolve = void 0;
+		}
+	}
+	function cleanup() {
+		write(ANSI.SHOW_CURSOR);
+		write(ANSI.ALT_SCREEN_EXIT);
+		const resizeEmitter = typeof output.on === "function" ? output : process.stdout;
+		resizeEmitter.off("resize", onResize);
+		if (rl !== void 0) {
+			try {
+				rl.close();
+			} catch {}
+			rl = void 0;
+		}
+		if (input.isTTY === true) try {
+			input.setRawMode(false);
+		} catch {}
+	}
+	function handleEvent(event) {
+		switch (event.type) {
+			case "pipeline:start":
+				state.headerLine = `${event.stories.length} stories, concurrency ${event.concurrency}, run ${event.run_id.slice(0, 8)}...`;
+				for (const key of event.stories) {
+					state.storyOrder.push(key);
+					state.stories.set(key, {
+						key,
+						phase: "wait",
+						status: "pending",
+						statusLabel: "queued",
+						reviewCycles: 0
+					});
+				}
+				break;
+			case "story:phase": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "wait",
+						status: "pending",
+						statusLabel: "queued",
+						reviewCycles: 0
+					};
+					state.stories.set(event.key, story);
+				}
+				const phaseLabel = mapPhaseToLabel(event.phase);
+				story.phase = phaseLabel;
+				story.status = mapPhaseToStatus(phaseLabel, event.status);
+				story.statusLabel = makeStatusLabel(phaseLabel, event.status, event.verdict);
+				break;
+			}
+			case "story:done": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "done",
+						status: event.result === "success" ? "succeeded" : "failed",
+						statusLabel: event.result === "success" ? "SHIP_IT" : "FAILED",
+						reviewCycles: event.review_cycles
+					};
+					state.stories.set(event.key, story);
+				} else {
+					story.phase = event.result === "success" ? "done" : "failed";
+					story.status = event.result === "success" ? "succeeded" : "failed";
+					const cycleWord = event.review_cycles === 1 ? "cycle" : "cycles";
+					story.statusLabel = event.result === "success" ? `SHIP_IT (${event.review_cycles} ${cycleWord})` : "FAILED";
+					story.reviewCycles = event.review_cycles;
+				}
+				break;
+			}
+			case "story:escalation": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "escalated",
+						status: "escalated",
+						statusLabel: `ESCALATED — ${event.reason}`,
+						reviewCycles: event.cycles,
+						escalationReason: event.reason
+					};
+					state.stories.set(event.key, story);
+				} else {
+					story.phase = "escalated";
+					story.status = "escalated";
+					story.statusLabel = `ESCALATED — ${event.reason}`;
+					story.reviewCycles = event.cycles;
+					story.escalationReason = event.reason;
+				}
+				break;
+			}
+			case "story:warn": {
+				const logEntry = {
+					ts: event.ts,
+					key: event.key,
+					msg: `[WARN] ${event.msg}`,
+					level: "warn"
+				};
+				state.logs.push(logEntry);
+				if (state.logs.length > MAX_LOG_ENTRIES) state.logs.splice(0, state.logs.length - MAX_LOG_ENTRIES);
+				break;
+			}
+			case "story:log": {
+				const logEntry = {
+					ts: event.ts,
+					key: event.key,
+					msg: event.msg,
+					level: "log"
+				};
+				state.logs.push(logEntry);
+				if (state.logs.length > MAX_LOG_ENTRIES) state.logs.splice(0, state.logs.length - MAX_LOG_ENTRIES);
+				break;
+			}
+			case "pipeline:complete":
+				state.pipelineComplete = true;
+				state.completionStats = {
+					succeeded: event.succeeded,
+					failed: event.failed,
+					escalated: event.escalated
+				};
+				setTimeout(() => {
+					if (exitResolve !== void 0) render();
+				}, 500);
+				break;
+			default: break;
+		}
+		render();
+	}
+	init();
+	return {
+		handleEvent,
+		cleanup,
+		waitForExit: () => exitPromise
+	};
+}
+/**
+* Check whether the TUI can run in the current environment.
+*
+* Returns true if stdout is a TTY, false otherwise.
+* If false, the caller should print a warning and use default output.
+*/
+function isTuiCapable() {
+	return process.stdout.isTTY === true;
+}
+/**
+* Print the non-TTY fallback warning message.
+*/
+function printNonTtyWarning() {
+	process.stderr.write("TUI requires an interactive terminal. Falling back to default output.\n");
+}
+
+//#endregion
+//#region src/core/event-bus.ts
+/**
+* Concrete implementation of TypedEventBus backed by Node.js EventEmitter.
+*
+* @example
+* const bus = new TypedEventBusImpl()
+* bus.on('task:complete', ({ taskId, result }) => {
+*   console.log(`Task ${taskId} finished`)
+* })
+* bus.emit('task:complete', { taskId: 'abc', result: { exitCode: 0 } })
+*/
+var TypedEventBusImpl = class {
+	_emitter;
+	constructor() {
+		this._emitter = new EventEmitter();
+		this._emitter.setMaxListeners(100);
+	}
+	emit(event, payload) {
+		this._emitter.emit(event, payload);
+	}
+	on(event, handler) {
+		this._emitter.on(event, handler);
+	}
+	off(event, handler) {
+		this._emitter.off(event, handler);
+	}
+};
+/**
+* Create a new TypedEventBus instance.
+*
+* @example
+* const bus = createEventBus()
+*/
+function createEventBus() {
+	return new TypedEventBusImpl();
+}
+
+//#endregion
+export { AdapterRegistry, ClaudeCodeAdapter, CodexCLIAdapter, GeminiCLIAdapter, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning };
+//# sourceMappingURL=event-bus-J-bw-pkp.js.map