@openspecui/core 0.9.0 → 1.0.2

package/dist/index.mjs

@@ -2,14 +2,14 @@ import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { join } from "path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { readFile as readFile$1, readdir, stat } from "node:fs/promises";
-import { dirname, join as join$1, resolve } from "node:path";
+import { dirname, join as join$1, matchesGlob, relative, resolve, sep } from "node:path";
 import { existsSync, realpathSync, utimesSync } from "node:fs";
 import { z } from "zod";
 import { watch } from "fs";
 import { EventEmitter } from "events";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
-import { homedir } from "node:os";
+import { parse } from "yaml";
 
 //#region src/parser.ts
 /**
@@ -1077,6 +1077,15 @@ async function reactiveReadFile(filepath) {
 	return state.get();
 }
 /**
+* 主动更新响应式文件缓存（用于写入后立即推送订阅）
+*
+* 仅当该文件已有缓存状态时生效；不会创建新的监听器。
+*/
+function updateReactiveFileCache(filepath, content) {
+	const key = `file:${resolve(filepath)}`;
+	stateCache$1.get(key)?.set(content);
+}
+/**
 * 响应式读取目录内容
 *
 * 特性：
@@ -1870,20 +1879,124 @@ function createFileChangeObservable(watcher) {
 //#endregion
 //#region src/config.ts
 const execAsync = promisify(exec);
-/** 默认的 fallback CLI 命令（数组形式） */
-const FALLBACK_CLI_COMMAND = ["npx", "@fission-ai/openspec"];
-/** 全局 openspec 命令（数组形式） */
-const GLOBAL_CLI_COMMAND = ["openspec"];
-/** 缓存检测到的 CLI 命令 */
-let detectedCliCommand = null;
+const CLI_PROBE_TIMEOUT_MS = 2e4;
+const THEME_VALUES = [
+	"light",
+	"dark",
+	"system"
+];
+const CURSOR_STYLE_VALUES = [
+	"block",
+	"underline",
+	"bar"
+];
+const BASE_PACKAGE_MANAGER_RUNNERS = [
+	{
+		id: "npx",
+		source: "npx",
+		commandParts: [
+			"npx",
+			"-y",
+			"@fission-ai/openspec"
+		]
+	},
+	{
+		id: "bunx",
+		source: "bunx",
+		commandParts: ["bunx", "@fission-ai/openspec"]
+	},
+	{
+		id: "deno",
+		source: "deno",
+		commandParts: [
+			"deno",
+			"run",
+			"-A",
+			"npm:@fission-ai/openspec"
+		]
+	},
+	{
+		id: "pnpm",
+		source: "pnpm",
+		commandParts: [
+			"pnpm",
+			"dlx",
+			"@fission-ai/openspec"
+		]
+	},
+	{
+		id: "yarn",
+		source: "yarn",
+		commandParts: [
+			"yarn",
+			"dlx",
+			"@fission-ai/openspec"
+		]
+	}
+];
+function tokenizeCliCommand(input) {
+	const tokens = [];
+	let current = "";
+	let quote = null;
+	let tokenStarted = false;
+	for (let index = 0; index < input.length; index += 1) {
+		const char = input[index];
+		if (quote) {
+			if (char === quote) {
+				quote = null;
+				tokenStarted = true;
+				continue;
+			}
+			if (char === "\\") {
+				const next = input[index + 1];
+				if (next && (next === quote || next === "\\")) {
+					current += next;
+					tokenStarted = true;
+					index += 1;
+					continue;
+				}
+			}
+			current += char;
+			tokenStarted = true;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			tokenStarted = true;
+			continue;
+		}
+		if (char === "\\") {
+			const next = input[index + 1];
+			if (next && /[\s"'\\]/.test(next)) {
+				current += next;
+				tokenStarted = true;
+				index += 1;
+				continue;
+			}
+			current += char;
+			tokenStarted = true;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (tokenStarted) {
+				tokens.push(current);
+				current = "";
+				tokenStarted = false;
+			}
+			continue;
+		}
+		current += char;
+		tokenStarted = true;
+	}
+	if (tokenStarted) tokens.push(current);
+	return tokens;
+}
 /**
 * 解析 CLI 命令字符串为数组
 *
 * 支持两种格式：
 * 1. JSON 数组：以 `[` 开头，如 `["npx", "@fission-ai/openspec"]`
-* 2. 简单字符串：用空格分割，如 `npx @fission-ai/openspec`
-*
-* 注意：简单字符串解析不支持带引号的参数，如需复杂命令请使用 JSON 数组格式
+* 2. shell-like 字符串：支持引号与基础转义
 */
 function parseCliCommand(command) {
 	const trimmed = command.trim();
@@ -1894,7 +2007,144 @@ function parseCliCommand(command) {
 	} catch (err) {
 		throw new Error(`Failed to parse CLI command as JSON array: ${err instanceof Error ? err.message : err}`);
 	}
-	return trimmed.split(/\s+/).filter(Boolean);
+	const tokens = tokenizeCliCommand(trimmed);
+	if (tokens.length !== 1) return tokens;
+	const firstChar = trimmed[0];
+	const lastChar = trimmed[trimmed.length - 1];
+	if (firstChar !== "\"" && firstChar !== "'" || firstChar !== lastChar) return tokens;
+	const inner = trimmed.slice(1, -1).trim();
+	if (!inner) return tokens;
+	const innerTokens = tokenizeCliCommand(inner.replace(/\\(["'])/g, "$1"));
+	if (innerTokens.length > 1 && innerTokens.slice(1).some((token) => token.startsWith("-"))) return innerTokens;
+	return tokens;
+}
+function commandToString(commandParts) {
+	const formatToken = (token) => {
+		if (!token) return "\"\"";
+		if (!/[\s"'\\]/.test(token)) return token;
+		return JSON.stringify(token);
+	};
+	return commandParts.map(formatToken).join(" ").trim();
+}
+function getRunnerPriorityFromUserAgent(userAgent) {
+	if (!userAgent) return null;
+	if (userAgent.startsWith("bun")) return "bunx";
+	if (userAgent.startsWith("npm")) return "npx";
+	if (userAgent.startsWith("deno")) return "deno";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	return null;
+}
+function buildCliRunnerCandidates(options) {
+	const candidates = [];
+	const configuredCommandParts = options.configuredCommandParts?.filter(Boolean) ?? [];
+	if (configuredCommandParts.length > 0) candidates.push({
+		id: "configured",
+		source: "config.cli.command",
+		commandParts: configuredCommandParts
+	});
+	candidates.push({
+		id: "openspec",
+		source: "openspec",
+		commandParts: ["openspec"]
+	});
+	const packageRunners = [...BASE_PACKAGE_MANAGER_RUNNERS];
+	const preferred = getRunnerPriorityFromUserAgent(options.userAgent);
+	if (preferred) {
+		const index = packageRunners.findIndex((item) => item.id === preferred);
+		if (index > 0) {
+			const [runner] = packageRunners.splice(index, 1);
+			packageRunners.unshift(runner);
+		}
+	}
+	return [...candidates, ...packageRunners];
+}
+function createCleanCliEnv(baseEnv = process.env) {
+	const env = { ...baseEnv };
+	for (const key of Object.keys(env)) if (key.startsWith("npm_config_") || key.startsWith("npm_package_") || key === "npm_execpath" || key === "npm_lifecycle_event" || key === "npm_lifecycle_script") delete env[key];
+	return env;
+}
+async function probeCliRunner(candidate, cwd, env) {
+	const [cmd, ...cmdArgs] = candidate.commandParts;
+	return new Promise((resolve$1) => {
+		let stdout = "";
+		let stderr = "";
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill();
+		}, CLI_PROBE_TIMEOUT_MS);
+		const child = spawn(cmd, [...cmdArgs, "--version"], {
+			cwd,
+			shell: false,
+			env
+		});
+		child.stdout?.on("data", (data) => {
+			stdout += data.toString();
+		});
+		child.stderr?.on("data", (data) => {
+			stderr += data.toString();
+		});
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			const code = err.code;
+			const suffix = code ? ` (${code})` : "";
+			resolve$1({
+				source: candidate.source,
+				command: commandToString(candidate.commandParts),
+				success: false,
+				error: `${err.message}${suffix}`,
+				exitCode: null
+			});
+		});
+		child.on("close", (exitCode) => {
+			clearTimeout(timer);
+			if (timedOut) {
+				resolve$1({
+					source: candidate.source,
+					command: commandToString(candidate.commandParts),
+					success: false,
+					error: "CLI probe timed out",
+					exitCode
+				});
+				return;
+			}
+			if (exitCode === 0) {
+				const version = stdout.trim().split("\n")[0] || void 0;
+				resolve$1({
+					source: candidate.source,
+					command: commandToString(candidate.commandParts),
+					success: true,
+					version,
+					exitCode
+				});
+				return;
+			}
+			resolve$1({
+				source: candidate.source,
+				command: commandToString(candidate.commandParts),
+				success: false,
+				error: stderr.trim() || `Exit code ${exitCode ?? "null"}`,
+				exitCode
+			});
+		});
+	});
+}
+async function resolveCliRunner(candidates, cwd, env) {
+	const attempts = [];
+	for (const candidate of candidates) {
+		const attempt = await probeCliRunner(candidate, cwd, env);
+		attempts.push(attempt);
+		if (attempt.success) return {
+			source: attempt.source,
+			command: attempt.command,
+			commandParts: candidate.commandParts,
+			version: attempt.version,
+			attempts
+		};
+	}
+	const details = attempts.map((attempt) => `- ${attempt.command}: ${attempt.error ?? "failed"}`).join("\n");
+	throw new Error(`No available OpenSpec CLI runner.\n${details}`);
 }
 /**
 * 比较两个语义化版本号
@@ -1921,7 +2171,7 @@ function compareVersions(a, b) {
 */
 async function fetchLatestVersion() {
 	try {
-		const { stdout } = await execAsync("npx @fission-ai/openspec --version", { timeout: 6e4 });
+		const { stdout } = await execAsync("npx -y @fission-ai/openspec --version", { timeout: 6e4 });
 		return stdout.trim();
 	} catch {
 		return;
@@ -1951,7 +2201,6 @@ async function sniffGlobalCli() {
 		};
 	}
 	const version = localResult.stdout.trim();
-	detectedCliCommand = GLOBAL_CLI_COMMAND;
 	return {
 		hasGlobal: true,
 		version,
@@ -1960,53 +2209,44 @@ async function sniffGlobalCli() {
 	};
 }
 /**
-* 检测全局安装的 openspec 命令
-* 优先使用全局命令，fallback 到 npx
-*
-* @returns CLI 命令数组
-*/
-async function detectCliCommand() {
-	if (detectedCliCommand !== null) return detectedCliCommand;
-	try {
-		await execAsync(`${process.platform === "win32" ? "where" : "which"} openspec`);
-		detectedCliCommand = GLOBAL_CLI_COMMAND;
-		return detectedCliCommand;
-	} catch {
-		detectedCliCommand = FALLBACK_CLI_COMMAND;
-		return detectedCliCommand;
-	}
-}
-/**
 * 获取默认 CLI 命令（异步，带检测）
 *
 * @returns CLI 命令数组，如 `['openspec']` 或 `['npx', '@fission-ai/openspec']`
 */
 async function getDefaultCliCommand() {
-	return detectCliCommand();
+	return (await resolveCliRunner(buildCliRunnerCandidates({ userAgent: process.env.npm_config_user_agent }).filter((candidate) => candidate.id !== "configured"), process.cwd(), createCleanCliEnv())).commandParts;
 }
 /**
 * 获取默认 CLI 命令的字符串形式（用于 UI 显示）
 */
 async function getDefaultCliCommandString() {
-	return (await detectCliCommand()).join(" ");
+	return commandToString(await getDefaultCliCommand());
 }
+const TerminalConfigSchema = z.object({
+	fontSize: z.number().min(8).max(32).default(13),
+	fontFamily: z.string().default(""),
+	cursorBlink: z.boolean().default(true),
+	cursorStyle: z.enum(CURSOR_STYLE_VALUES).default("block"),
+	scrollback: z.number().min(0).max(1e5).default(1e3)
+});
 /**
 * OpenSpecUI 配置 Schema
 *
 * 存储在 openspec/.openspecui.json 中，利用文件监听实现响应式更新
 */
 const OpenSpecUIConfigSchema = z.object({
-	cli: z.object({ command: z.string().optional() }).default({}),
-	ui: z.object({ theme: z.enum([
-		"light",
-		"dark",
-		"system"
-	]).default("system") }).default({})
+	cli: z.object({
+		command: z.string().optional(),
+		args: z.array(z.string()).optional()
+	}).default({}),
+	theme: z.enum(THEME_VALUES).default("system"),
+	terminal: TerminalConfigSchema.default(TerminalConfigSchema.parse({}))
 });
 /** 默认配置（静态，用于测试和类型） */
 const DEFAULT_CONFIG = {
 	cli: {},
-	ui: { theme: "system" }
+	theme: "system",
+	terminal: TerminalConfigSchema.parse({})
 };
 /**
 * 配置管理器
@@ -2016,7 +2256,11 @@ const DEFAULT_CONFIG = {
 */
 var ConfigManager = class {
 	configPath;
+	projectDir;
+	resolvedRunner = null;
+	resolvingRunnerPromise = null;
 	constructor(projectDir) {
+		this.projectDir = projectDir;
 		this.configPath = join(projectDir, "openspec", ".openspecui.json");
 	}
 	/**
@@ -2046,43 +2290,140 @@ var ConfigManager = class {
 	*/
 	async writeConfig(config) {
 		const current = await this.readConfig();
+		const nextCli = { ...current.cli };
+		if (config.cli && Object.prototype.hasOwnProperty.call(config.cli, "command")) {
+			const trimmed = config.cli.command?.trim();
+			if (trimmed) nextCli.command = trimmed;
+			else {
+				delete nextCli.command;
+				delete nextCli.args;
+			}
+		}
+		if (config.cli && Object.prototype.hasOwnProperty.call(config.cli, "args")) {
+			const args = (config.cli.args ?? []).map((arg) => arg.trim()).filter(Boolean);
+			if (args.length > 0) nextCli.args = args;
+			else delete nextCli.args;
+		}
+		if (!nextCli.command) delete nextCli.args;
 		const merged = {
 			...current,
-			...config,
-			cli: {
-				...current.cli,
-				...config.cli
-			},
-			ui: {
-				...current.ui,
-				...config.ui
+			cli: nextCli,
+			theme: config.theme ?? current.theme,
+			terminal: {
+				...current.terminal,
+				...config.terminal
 			}
 		};
-		await writeFile(this.configPath, JSON.stringify(merged, null, 2), "utf-8");
+		const serialized = JSON.stringify(merged, null, 2);
+		await writeFile(this.configPath, serialized, "utf-8");
+		updateReactiveFileCache(this.configPath, serialized);
+		this.invalidateResolvedCliRunner();
+	}
+	/**
+	* 解析并缓存可用 CLI runner。
+	*/
+	async resolveCliRunner() {
+		if (this.resolvedRunner) return this.resolvedRunner;
+		if (this.resolvingRunnerPromise) return this.resolvingRunnerPromise;
+		this.resolvingRunnerPromise = this.resolveCliRunnerUncached().then((runner) => {
+			this.resolvedRunner = runner;
+			return runner;
+		}).finally(() => {
+			this.resolvingRunnerPromise = null;
+		});
+		return this.resolvingRunnerPromise;
+	}
+	async resolveCliRunnerUncached() {
+		const config = await this.readConfig();
+		const configuredCommandParts = this.getConfiguredCommandParts(config.cli);
+		const hasConfiguredCommand = configuredCommandParts.length > 0;
+		const resolved = await resolveCliRunner(hasConfiguredCommand ? [{
+			id: "configured",
+			source: "config.cli.command",
+			commandParts: configuredCommandParts
+		}] : buildCliRunnerCandidates({
+			configuredCommandParts,
+			userAgent: process.env.npm_config_user_agent
+		}), this.projectDir, createCleanCliEnv());
+		if (!hasConfiguredCommand) {
+			const [resolvedCommand, ...resolvedArgs] = resolved.commandParts;
+			const currentCommand = config.cli.command?.trim();
+			const currentArgs = config.cli.args ?? [];
+			if (currentCommand !== resolvedCommand || currentArgs.length !== resolvedArgs.length || currentArgs.some((arg, index) => arg !== resolvedArgs[index])) await this.writeConfig({ cli: {
+				command: resolvedCommand,
+				args: resolvedArgs
+			} });
+		}
+		return resolved;
 	}
 	/**
 	* 获取 CLI 命令（数组形式）
-	*
-	* 优先级：配置文件 > 全局 openspec 命令 > npx fallback
-	*
-	* @returns CLI 命令数组，如 `['openspec']` 或 `['npx', '@fission-ai/openspec']`
 	*/
 	async getCliCommand() {
-		const config = await this.readConfig();
-		if (config.cli.command) return parseCliCommand(config.cli.command);
-		return getDefaultCliCommand();
+		return (await this.resolveCliRunner()).commandParts;
 	}
 	/**
 	* 获取 CLI 命令的字符串形式（用于 UI 显示）
 	*/
 	async getCliCommandString() {
-		return (await this.getCliCommand()).join(" ");
+		return (await this.resolveCliRunner()).command;
+	}
+	/**
+	* 获取 CLI 解析结果（用于诊断）
+	*/
+	async getResolvedCliRunner() {
+		return this.resolveCliRunner();
+	}
+	/**
+	* 清理 CLI 解析缓存（用于 ENOENT 自愈）
+	*/
+	invalidateResolvedCliRunner() {
+		this.resolvedRunner = null;
+		this.resolvingRunnerPromise = null;
 	}
 	/**
 	* 设置 CLI 命令
 	*/
 	async setCliCommand(command) {
-		await this.writeConfig({ cli: { command } });
+		const trimmed = command.trim();
+		if (!trimmed) {
+			await this.writeConfig({ cli: {
+				command: null,
+				args: null
+			} });
+			return;
+		}
+		const commandParts = parseCliCommand(trimmed);
+		if (commandParts.length === 0) {
+			await this.writeConfig({ cli: {
+				command: null,
+				args: null
+			} });
+			return;
+		}
+		const [resolvedCommand, ...resolvedArgs] = commandParts;
+		await this.writeConfig({ cli: {
+			command: resolvedCommand,
+			args: resolvedArgs
+		} });
+	}
+	getConfiguredCommandParts(cli) {
+		const command = cli.command?.trim();
+		if (!command) return [];
+		if (Array.isArray(cli.args) && cli.args.length > 0) return [command, ...cli.args];
+		return parseCliCommand(command);
+	}
+	/**
+	* 设置主题
+	*/
+	async setTheme(theme) {
+		await this.writeConfig({ theme });
+	}
+	/**
+	* 设置终端配置（部分更新）
+	*/
+	async setTerminalConfig(terminal) {
+		await this.writeConfig({ terminal });
 	}
 };
 
@@ -2091,50 +2432,24 @@ var ConfigManager = class {
 /**
 * CLI 执行器
 *
-* 负责调用外部 openspec CLI 命令。
-* 命令前缀从 ConfigManager 获取，支持：
-* - ['npx', '@fission-ai/openspec'] (默认)
-* - ['openspec'] (全局安装)
-* - 自定义数组或字符串
-*
-* 注意：所有命令都使用 shell: false 执行，避免 shell 注入风险
+* 负责调用外部 openspec CLI 命令，统一通过 ConfigManager 的 runner 解析结果执行。
+* 所有命令都使用 shell: false，避免 shell 注入风险。
 */
 var CliExecutor = class {
 	constructor(configManager, projectDir) {
 		this.configManager = configManager;
 		this.projectDir = projectDir;
 	}
-	/**
-	* 创建干净的环境变量，移除 pnpm 特有的配置
-	* 避免 pnpm 环境变量污染 npx/npm 执行
-	*/
-	getCleanEnv() {
-		const env = { ...process.env };
-		for (const key of Object.keys(env)) if (key.startsWith("npm_config_") || key.startsWith("npm_package_") || key === "npm_execpath" || key === "npm_lifecycle_event" || key === "npm_lifecycle_script") delete env[key];
-		return env;
-	}
-	/**
-	* 构建完整命令数组
-	*
-	* @param args CLI 参数，如 ['init'] 或 ['archive', 'change-id']
-	* @returns [command, ...commandArgs, ...args]
-	*/
 	async buildCommandArray(args) {
 		return [...await this.configManager.getCliCommand(), ...args];
 	}
-	/**
-	* 执行 CLI 命令
-	*
-	* @param args CLI 参数，如 ['init'] 或 ['archive', 'change-id']
-	* @returns 执行结果
-	*/
-	async execute(args) {
-		const [cmd, ...cmdArgs] = await this.buildCommandArray(args);
+	runCommandOnce(fullCommand) {
+		const [cmd, ...cmdArgs] = fullCommand;
 		return new Promise((resolve$1) => {
 			const child = spawn(cmd, cmdArgs, {
 				cwd: this.projectDir,
 				shell: false,
-				env: this.getCleanEnv()
+				env: createCleanCliEnv()
 			});
 			let stdout = "";
 			let stderr = "";
@@ -2153,19 +2468,50 @@ var CliExecutor = class {
 				});
 			});
 			child.on("error", (err) => {
+				const errorCode = err.code;
+				const errorMessage = err.message + (errorCode ? ` (${errorCode})` : "");
 				resolve$1({
 					success: false,
 					stdout,
-					stderr: stderr + "\n" + err.message,
-					exitCode: null
+					stderr: stderr ? `${stderr}\n${errorMessage}` : errorMessage,
+					exitCode: null,
+					errorCode
 				});
 			});
 		});
 	}
+	async executeInternal(args, allowRetry) {
+		let fullCommand;
+		try {
+			fullCommand = await this.buildCommandArray(args);
+		} catch (err) {
+			return {
+				success: false,
+				stdout: "",
+				stderr: err instanceof Error ? err.message : String(err),
+				exitCode: null
+			};
+		}
+		const result = await this.runCommandOnce(fullCommand);
+		if (allowRetry && result.errorCode === "ENOENT") {
+			this.configManager.invalidateResolvedCliRunner();
+			return this.executeInternal(args, false);
+		}
+		return {
+			success: result.success,
+			stdout: result.stdout,
+			stderr: result.stderr,
+			exitCode: result.exitCode
+		};
+	}
+	/**
+	* 执行 CLI 命令
+	*/
+	async execute(args) {
+		return this.executeInternal(args, true);
+	}
 	/**
 	* 执行 openspec init（非交互式）
-	*
-	* @param tools 工具列表，如 ['claude', 'cursor'] 或 'all' 或 'none'
 	*/
 	async init(tools = "all") {
 		const toolsArg = Array.isArray(tools) ? tools.join(",") : tools;
@@ -2177,9 +2523,6 @@ var CliExecutor = class {
 	}
 	/**
 	* 执行 openspec archive <changeId>（非交互式）
-	*
-	* @param changeId 要归档的 change ID
-	* @param options 选项
 	*/
 	async archive(changeId, options = {}) {
 		const args = [
@@ -2201,6 +2544,31 @@ var CliExecutor = class {
 		return this.execute(args);
 	}
 	/**
+	* 执行 openspec schemas --json
+	*/
+	async schemas() {
+		return this.execute(["schemas", "--json"]);
+	}
+	/**
+	* 执行 openspec schema which <name> --json
+	*/
+	async schemaWhich(name) {
+		return this.execute([
+			"schema",
+			"which",
+			name,
+			"--json"
+		]);
+	}
+	/**
+	* 执行 openspec templates --json [--schema <name>]
+	*/
+	async templates(schema) {
+		const args = ["templates", "--json"];
+		if (schema) args.push("--schema", schema);
+		return this.execute(args);
+	}
+	/**
 	* 流式执行 openspec validate
 	*/
 	validateStream(type, id, onEvent) {
@@ -2211,75 +2579,108 @@ var CliExecutor = class {
 	}
 	/**
 	* 检查 CLI 是否可用
-	* @param timeout 超时时间（毫秒），默认 10 秒
 	*/
 	async checkAvailability(timeout = 1e4) {
 		try {
-			const result = await Promise.race([this.execute(["--version"]), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("CLI check timed out")), timeout))]);
-			if (result.success) return {
+			const resolved = await Promise.race([this.configManager.getResolvedCliRunner(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("CLI runner resolve timed out")), timeout))]);
+			const versionResult = await Promise.race([this.runCommandOnce([...resolved.commandParts, "--version"]), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("CLI check timed out")), timeout))]);
+			if (versionResult.success) return {
 				available: true,
-				version: result.stdout.trim()
+				version: versionResult.stdout.trim() || resolved.version,
+				effectiveCommand: resolved.command,
+				tried: resolved.attempts.map((attempt) => attempt.command)
 			};
 			return {
 				available: false,
-				error: result.stderr || "Unknown error"
+				error: versionResult.stderr || "Unknown error",
+				effectiveCommand: resolved.command,
+				tried: resolved.attempts.map((attempt) => attempt.command)
 			};
 		} catch (err) {
 			return {
 				available: false,
-				error: err instanceof Error ? err.message : "Unknown error"
+				error: err instanceof Error ? err.message : String(err)
 			};
 		}
 	}
 	/**
 	* 流式执行 CLI 命令
-	*
-	* @param args CLI 参数
-	* @param onEvent 事件回调
-	* @returns 取消函数
 	*/
 	async executeStream(args, onEvent) {
-		const fullCommand = await this.buildCommandArray(args);
-		const [cmd, ...cmdArgs] = fullCommand;
-		onEvent({
-			type: "command",
-			data: fullCommand.join(" ")
-		});
-		const child = spawn(cmd, cmdArgs, {
-			cwd: this.projectDir,
-			shell: false,
-			env: this.getCleanEnv()
-		});
-		child.stdout?.on("data", (data) => {
+		let cancelled = false;
+		let activeChild = null;
+		const start = async (allowRetry) => {
+			if (cancelled) return;
+			let fullCommand;
+			try {
+				fullCommand = await this.buildCommandArray(args);
+			} catch (err) {
+				onEvent({
+					type: "stderr",
+					data: err instanceof Error ? err.message : String(err)
+				});
+				onEvent({
+					type: "exit",
+					exitCode: null
+				});
+				return;
+			}
 			onEvent({
-				type: "stdout",
-				data: data.toString()
+				type: "command",
+				data: fullCommand.join(" ")
 			});
-		});
-		child.stderr?.on("data", (data) => {
-			onEvent({
-				type: "stderr",
-				data: data.toString()
+			const [cmd, ...cmdArgs] = fullCommand;
+			const child = spawn(cmd, cmdArgs, {
+				cwd: this.projectDir,
+				shell: false,
+				env: createCleanCliEnv()
 			});
-		});
-		child.on("close", (exitCode) => {
-			onEvent({
-				type: "exit",
-				exitCode
+			activeChild = child;
+			child.stdout?.on("data", (data) => {
+				onEvent({
+					type: "stdout",
+					data: data.toString()
+				});
 			});
-		});
-		child.on("error", (err) => {
-			onEvent({
-				type: "stderr",
-				data: err.message
+			child.stderr?.on("data", (data) => {
+				onEvent({
+					type: "stderr",
+					data: data.toString()
+				});
 			});
-			onEvent({
-				type: "exit",
-				exitCode: null
+			child.on("close", (exitCode) => {
+				if (activeChild !== child) return;
+				activeChild = null;
+				onEvent({
+					type: "exit",
+					exitCode
+				});
 			});
-		});
+			child.on("error", (err) => {
+				if (activeChild !== child) return;
+				activeChild = null;
+				const code = err.code;
+				const message = err.message + (code ? ` (${code})` : "");
+				if (allowRetry && code === "ENOENT" && !cancelled) {
+					this.configManager.invalidateResolvedCliRunner();
+					start(false);
+					return;
+				}
+				onEvent({
+					type: "stderr",
+					data: message
+				});
+				onEvent({
+					type: "exit",
+					exitCode: null
+				});
+			});
+		};
+		await start(true);
 		return () => {
-			child.kill();
+			cancelled = true;
+			activeChild?.kill();
+			activeChild = null;
 		};
 	}
 	/**
@@ -2308,13 +2709,6 @@ var CliExecutor = class {
 	}
 	/**
 	* 流式执行任意命令（数组形式）
-	*
-	* 用于执行不需要 openspec CLI 前缀的命令，如 npm install。
-	* 使用 shell: false 避免 shell 注入风险。
-	*
-	* @param command 命令数组，如 ['npm', 'install', '-g', '@fission-ai/openspec']
-	* @param onEvent 事件回调
-	* @returns 取消函数
 	*/
 	executeCommandStream(command, onEvent) {
 		const [cmd, ...cmdArgs] = command;
@@ -2325,7 +2719,7 @@ var CliExecutor = class {
 		const child = spawn(cmd, cmdArgs, {
 			cwd: this.projectDir,
 			shell: false,
-			env: this.getCleanEnv()
+			env: createCleanCliEnv()
 		});
 		child.stdout?.on("data", (data) => {
 			onEvent({
@@ -2346,9 +2740,10 @@ var CliExecutor = class {
 			});
 		});
 		child.on("error", (err) => {
+			const code = err.code;
 			onEvent({
 				type: "stderr",
-				data: err.message
+				data: err.message + (code ? ` (${code})` : "")
 			});
 			onEvent({
 				type: "exit",
@@ -2366,32 +2761,27 @@ var CliExecutor = class {
 /**
 * 工具配置检测模块
 *
-* 完全对齐 @fission-ai/openspec 的官方实现
-* 用于检测项目中已配置的 AI 工具
-*
-* 重要：使用响应式文件系统实现，监听配置目录，
-* 当配置文件变化时会自动触发更新。
-*
-* @see references/openspec/src/core/config.ts (AI_TOOLS)
-* @see references/openspec/src/core/configurators/slash/
-* @see references/openspec/src/core/init.ts (isToolConfigured)
+* 对齐 @fission-ai/openspec 的 skills 体系，
+* 通过 `skills/<skill>/SKILL.md` 判断工具是否已配置。
 */
 /**
-* 获取 Codex 全局 prompts 目录
-* 优先使用 $CODEX_HOME 环境变量，否则使用 ~/.codex
-* @see references/openspec/src/core/configurators/slash/codex.ts
+* OpenSpec 初始化生成的技能目录名称
+* @see references/openspec/src/core/shared/tool-detection.ts
 */
-function getCodexGlobalPromptsDir() {
-	return join$1(process.env.CODEX_HOME?.trim() || join$1(homedir(), ".codex"), "prompts");
-}
+const SKILL_NAMES = [
+	"openspec-explore",
+	"openspec-new-change",
+	"openspec-continue-change",
+	"openspec-apply-change",
+	"openspec-ff-change",
+	"openspec-sync-specs",
+	"openspec-archive-change",
+	"openspec-bulk-archive-change",
+	"openspec-verify-change"
+];
 /**
 * 所有支持的 AI 工具配置
-*
 * 完全对齐官方 OpenSpec CLI 的 AI_TOOLS
-* 按字母顺序排序（与官方一致）
-*
-* @see references/openspec/src/core/config.ts
-* @see references/openspec/src/core/configurators/slash/registry.ts
 */
 const AI_TOOLS = [
 	{
@@ -2399,168 +2789,160 @@ const AI_TOOLS = [
 		value: "amazon-q",
 		available: true,
 		successLabel: "Amazon Q Developer",
-		scope: "project",
-		detectionPath: ".amazonq/prompts/openspec-proposal.md"
+		skillsDir: ".amazonq"
 	},
 	{
 		name: "Antigravity",
 		value: "antigravity",
 		available: true,
 		successLabel: "Antigravity",
-		scope: "project",
-		detectionPath: ".agent/workflows/openspec-proposal.md"
+		skillsDir: ".agent"
 	},
 	{
 		name: "Auggie (Augment CLI)",
 		value: "auggie",
 		available: true,
 		successLabel: "Auggie",
-		scope: "project",
-		detectionPath: ".augment/commands/openspec-proposal.md"
+		skillsDir: ".augment"
 	},
 	{
 		name: "Claude Code",
 		value: "claude",
 		available: true,
 		successLabel: "Claude Code",
-		scope: "project",
-		detectionPath: ".claude/commands/openspec/proposal.md"
+		skillsDir: ".claude"
 	},
 	{
 		name: "Cline",
 		value: "cline",
 		available: true,
 		successLabel: "Cline",
-		scope: "project",
-		detectionPath: ".clinerules/workflows/openspec-proposal.md"
+		skillsDir: ".cline"
 	},
 	{
 		name: "Codex",
 		value: "codex",
 		available: true,
 		successLabel: "Codex",
-		scope: "global",
-		detectionPath: () => join$1(getCodexGlobalPromptsDir(), "openspec-proposal.md")
+		skillsDir: ".codex"
 	},
 	{
 		name: "CodeBuddy Code (CLI)",
 		value: "codebuddy",
 		available: true,
 		successLabel: "CodeBuddy Code",
-		scope: "project",
-		detectionPath: ".codebuddy/commands/openspec/proposal.md"
+		skillsDir: ".codebuddy"
+	},
+	{
+		name: "Continue",
+		value: "continue",
+		available: true,
+		successLabel: "Continue (VS Code / JetBrains / Cli)",
+		skillsDir: ".continue"
 	},
 	{
 		name: "CoStrict",
 		value: "costrict",
 		available: true,
 		successLabel: "CoStrict",
-		scope: "project",
-		detectionPath: ".cospec/openspec/commands/openspec-proposal.md"
+		skillsDir: ".cospec"
 	},
 	{
 		name: "Crush",
 		value: "crush",
 		available: true,
 		successLabel: "Crush",
-		scope: "project",
-		detectionPath: ".crush/commands/openspec/proposal.md"
+		skillsDir: ".crush"
 	},
 	{
 		name: "Cursor",
 		value: "cursor",
 		available: true,
 		successLabel: "Cursor",
-		scope: "project",
-		detectionPath: ".cursor/commands/openspec-proposal.md"
+		skillsDir: ".cursor"
 	},
 	{
 		name: "Factory Droid",
 		value: "factory",
 		available: true,
 		successLabel: "Factory Droid",
-		scope: "project",
-		detectionPath: ".factory/commands/openspec-proposal.md"
+		skillsDir: ".factory"
 	},
 	{
 		name: "Gemini CLI",
 		value: "gemini",
 		available: true,
 		successLabel: "Gemini CLI",
-		scope: "project",
-		detectionPath: ".gemini/commands/openspec/proposal.toml"
+		skillsDir: ".gemini"
 	},
 	{
 		name: "GitHub Copilot",
 		value: "github-copilot",
 		available: true,
 		successLabel: "GitHub Copilot",
-		scope: "project",
-		detectionPath: ".github/prompts/openspec-proposal.prompt.md"
+		skillsDir: ".github"
 	},
 	{
 		name: "iFlow",
 		value: "iflow",
 		available: true,
 		successLabel: "iFlow",
-		scope: "project",
-		detectionPath: ".iflow/commands/openspec-proposal.md"
+		skillsDir: ".iflow"
 	},
 	{
 		name: "Kilo Code",
 		value: "kilocode",
 		available: true,
 		successLabel: "Kilo Code",
-		scope: "project",
-		detectionPath: ".kilocode/workflows/openspec-proposal.md"
+		skillsDir: ".kilocode"
 	},
 	{
 		name: "OpenCode",
 		value: "opencode",
 		available: true,
 		successLabel: "OpenCode",
-		scope: "project",
-		detectionPath: ".opencode/command/openspec-proposal.md"
+		skillsDir: ".opencode"
 	},
 	{
-		name: "Qoder (CLI)",
+		name: "Qoder",
 		value: "qoder",
 		available: true,
 		successLabel: "Qoder",
-		scope: "project",
-		detectionPath: ".qoder/commands/openspec/proposal.md"
+		skillsDir: ".qoder"
 	},
 	{
 		name: "Qwen Code",
 		value: "qwen",
 		available: true,
 		successLabel: "Qwen Code",
-		scope: "project",
-		detectionPath: ".qwen/commands/openspec-proposal.toml"
+		skillsDir: ".qwen"
 	},
 	{
 		name: "RooCode",
 		value: "roocode",
 		available: true,
 		successLabel: "RooCode",
-		scope: "project",
-		detectionPath: ".roo/commands/openspec-proposal.md"
+		skillsDir: ".roo"
+	},
+	{
+		name: "Trae",
+		value: "trae",
+		available: true,
+		successLabel: "Trae",
+		skillsDir: ".trae"
 	},
 	{
 		name: "Windsurf",
 		value: "windsurf",
 		available: true,
 		successLabel: "Windsurf",
-		scope: "project",
-		detectionPath: ".windsurf/workflows/openspec-proposal.md"
+		skillsDir: ".windsurf"
 	},
 	{
 		name: "AGENTS.md (works with Amp, VS Code, …)",
 		value: "agents",
 		available: false,
-		successLabel: "your AGENTS.md-compatible assistant",
-		scope: "project",
-		detectionPath: "AGENTS.md"
+		successLabel: "your AGENTS.md-compatible assistant"
 	}
 ];
 /**
@@ -2597,71 +2979,39 @@ function getToolById(toolId) {
 const stateCache = /* @__PURE__ */ new Map();
 /** 监听器释放函数缓存 */
 const releaseCache = /* @__PURE__ */ new Map();
-/**
-* 检查文件是否存在
-*/
-async function fileExists(filePath) {
-	try {
-		await stat(filePath);
-		return true;
-	} catch {
-		return false;
-	}
+function getSkillsDir(projectDir, tool) {
+	if (!tool.skillsDir) return null;
+	return join$1(projectDir, tool.skillsDir, "skills");
 }
-/**
-* 解析工具的检测路径
-* @param config 工具配置
-* @param projectDir 项目根目录
-* @returns 绝对路径，如果无检测路径则返回 undefined
-*/
-function resolveDetectionPath(config, projectDir) {
-	if (config.scope === "none" || !config.detectionPath) return;
-	if (config.scope === "global") return config.detectionPath();
-	return join$1(projectDir, config.detectionPath);
+async function getSkillCount(projectDir, tool) {
+	const skillsDir = getSkillsDir(projectDir, tool);
+	if (!skillsDir) return 0;
+	let count = 0;
+	for (const skillName of SKILL_NAMES) if (await reactiveExists(join$1(skillsDir, skillName, "SKILL.md"))) count++;
+	return count;
 }
 /**
 * 扫描已配置的工具（并行检查）
 */
 async function scanConfiguredTools(projectDir) {
 	return (await Promise.all(AI_TOOLS.map(async (config) => {
-		const filePath = resolveDetectionPath(config, projectDir);
-		if (!filePath) return null;
-		return await fileExists(filePath) ? config.value : null;
+		if (!config.skillsDir) return null;
+		return await getSkillCount(projectDir, config) > 0 ? config.value : null;
 	}))).filter((id) => id !== null);
 }
 /**
 * 获取需要监听的项目级目录列表
-* 只监听包含工具配置的一级隐藏目录
 */
 function getProjectWatchDirs(projectDir) {
 	const dirs = /* @__PURE__ */ new Set();
-	for (const config of AI_TOOLS) if (config.scope === "project" && config.detectionPath) {
-		const firstDir = config.detectionPath.split("/")[0];
-		if (firstDir) dirs.add(join$1(projectDir, firstDir));
-	}
-	return Array.from(dirs);
-}
-/**
-* 获取需要监听的全局目录列表
-* 如 Codex 的 ~/.codex/prompts/
-*/
-function getGlobalWatchDirs() {
-	const dirs = /* @__PURE__ */ new Set();
-	for (const config of AI_TOOLS) if (config.scope === "global" && config.detectionPath) {
-		const filePath = config.detectionPath();
-		dirs.add(dirname(filePath));
+	for (const config of AI_TOOLS) {
+		if (!config.skillsDir) continue;
+		dirs.add(join$1(projectDir, config.skillsDir));
 	}
 	return Array.from(dirs);
 }
 /**
 * 检测项目中已配置的工具（响应式）
-*
-* 监听两类目录：
-* 1. 项目级配置目录（如 .claude, .cursor 等）
-* 2. 全局配置目录（如 ~/.codex/prompts/）
-*
-* @param projectDir 项目根目录
-* @returns 已配置的工具 ID 列表
 */
 async function getConfiguredTools(projectDir) {
 	const normalizedPath = resolve(projectDir);
@@ -2680,11 +3030,6 @@ async function getConfiguredTools(projectDir) {
 			const release = acquireWatcher(dir, onUpdate, { recursive: true });
 			releases.push(release);
 		}
-		const globalWatchDirs = getGlobalWatchDirs();
-		for (const dir of globalWatchDirs) {
-			const release = acquireWatcher(dir, onUpdate, { recursive: false });
-			releases.push(release);
-		}
 		const rootRelease = acquireWatcher(normalizedPath, onUpdate, { recursive: false });
 		releases.push(rootRelease);
 		releaseCache.set(key, () => releases.forEach((r) => r()));
@@ -2693,14 +3038,814 @@ async function getConfiguredTools(projectDir) {
 }
 /**
 * 检查特定工具是否已配置
-*
-* @param projectDir 项目根目录
-* @param toolId 工具 ID
-* @returns 是否已配置
 */
 async function isToolConfigured(projectDir, toolId) {
 	return (await getConfiguredTools(projectDir)).includes(toolId);
 }
 
 //#endregion
-export { AI_TOOLS, ChangeFileSchema, ChangeSchema, CliExecutor, ConfigManager, DEFAULT_CONFIG, DeltaOperationType, DeltaSchema, DeltaSpecSchema, MarkdownParser, OpenSpecAdapter, OpenSpecUIConfigSchema, OpenSpecWatcher, ProjectWatcher, ReactiveContext, ReactiveState, RequirementSchema, SpecSchema, TaskSchema, Validator, acquireWatcher, clearCache, closeAllProjectWatchers, closeAllWatchers, contextStorage, createFileChangeObservable, getActiveWatcherCount, getAllToolIds, getAllTools, getAvailableToolIds, getAvailableTools, getCacheSize, getConfiguredTools, getDefaultCliCommand, getDefaultCliCommandString, getProjectWatcher, getToolById, getWatchedProjectDir, initWatcherPool, isToolConfigured, isWatcherPoolInitialized, parseCliCommand, reactiveExists, reactiveReadDir, reactiveReadFile, reactiveStat, sniffGlobalCli };
+//#region src/opsx-types.ts
+/** Check if an outputPath contains glob pattern characters */
+function isGlobPattern(pattern) {
+	return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+const ArtifactStatusSchema = z.object({
+	id: z.string(),
+	outputPath: z.string(),
+	status: z.enum([
+		"done",
+		"ready",
+		"blocked"
+	]),
+	missingDeps: z.array(z.string()).optional(),
+	relativePath: z.string().optional()
+});
+const ChangeStatusSchema = z.object({
+	changeName: z.string(),
+	schemaName: z.string(),
+	isComplete: z.boolean(),
+	applyRequires: z.array(z.string()),
+	artifacts: z.array(ArtifactStatusSchema)
+});
+const DependencyInfoSchema = z.object({
+	id: z.string(),
+	done: z.boolean(),
+	path: z.string(),
+	description: z.string()
+});
+const ApplyTaskSchema = z.object({
+	id: z.string(),
+	description: z.string(),
+	done: z.boolean()
+});
+const ApplyInstructionsSchema = z.object({
+	changeName: z.string(),
+	changeDir: z.string(),
+	schemaName: z.string(),
+	contextFiles: z.record(z.string()),
+	progress: z.object({
+		total: z.number(),
+		complete: z.number(),
+		remaining: z.number()
+	}),
+	tasks: z.array(ApplyTaskSchema),
+	state: z.enum([
+		"blocked",
+		"all_done",
+		"ready"
+	]),
+	missingArtifacts: z.array(z.string()).optional(),
+	instruction: z.string()
+});
+const NullableString = z.string().nullable().optional();
+const ArtifactInstructionsSchema = z.object({
+	changeName: z.string(),
+	artifactId: z.string(),
+	schemaName: z.string(),
+	changeDir: z.string(),
+	outputPath: z.string(),
+	description: z.string(),
+	instruction: NullableString,
+	context: NullableString,
+	rules: z.array(z.string()).optional().nullable(),
+	template: z.string(),
+	dependencies: z.array(DependencyInfoSchema),
+	unlocks: z.array(z.string())
+});
+const SchemaInfoSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	artifacts: z.array(z.string()),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	])
+});
+const SchemaResolutionSchema = z.object({
+	name: z.string(),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	]),
+	path: z.string(),
+	shadows: z.array(z.object({
+		source: z.enum([
+			"project",
+			"user",
+			"package"
+		]),
+		path: z.string()
+	}))
+});
+const TemplatesSchema = z.record(z.object({
+	path: z.string(),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	])
+}));
+const SchemaArtifactSchema = z.object({
+	id: z.string(),
+	outputPath: z.string(),
+	description: z.string().optional(),
+	template: z.string().optional(),
+	instruction: z.string().optional(),
+	requires: z.array(z.string())
+});
+const SchemaDetailSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	version: z.union([z.string(), z.number()]).optional(),
+	artifacts: z.array(SchemaArtifactSchema),
+	applyRequires: z.array(z.string()),
+	applyTracks: z.string().optional(),
+	applyInstruction: z.string().optional()
+});
+
+//#endregion
+//#region src/opsx-kernel.ts
+function parseCliJson(raw, schema, label) {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error(`${label} returned empty output`);
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`${label} returned invalid JSON: ${message}`);
+	}
+	const result = schema.safeParse(parsed);
+	if (!result.success) throw new Error(`${label} returned unexpected JSON: ${result.error.message}`);
+	return result.data;
+}
+function toRelativePath(root, absolutePath) {
+	return relative(root, absolutePath).split(sep).join("/");
+}
+async function readEntriesUnderRoot(root) {
+	if (!(await reactiveStat(root))?.isDirectory) return [];
+	const collectEntries = async (dir) => {
+		const names = await reactiveReadDir(dir, { includeHidden: false });
+		const entries = [];
+		for (const name of names) {
+			const fullPath = join$1(dir, name);
+			const statInfo = await reactiveStat(fullPath);
+			if (!statInfo) continue;
+			const relativePath = toRelativePath(root, fullPath);
+			if (statInfo.isDirectory) {
+				entries.push({
+					path: relativePath,
+					type: "directory"
+				});
+				entries.push(...await collectEntries(fullPath));
+			} else {
+				const content = await reactiveReadFile(fullPath);
+				const size = content ? Buffer.byteLength(content, "utf-8") : void 0;
+				entries.push({
+					path: relativePath,
+					type: "file",
+					content: content ?? void 0,
+					size
+				});
+			}
+		}
+		return entries;
+	};
+	return collectEntries(root);
+}
+async function readGlobArtifactFiles(projectDir, changeId, outputPath) {
+	return (await readEntriesUnderRoot(join$1(projectDir, "openspec", "changes", changeId))).filter((entry) => entry.type === "file" && matchesGlob(entry.path, outputPath)).map((entry) => ({
+		path: entry.path,
+		type: "file",
+		content: entry.content ?? ""
+	}));
+}
+async function touchOpsxProjectDeps(projectDir) {
+	const openspecDir = join$1(projectDir, "openspec");
+	await reactiveReadFile(join$1(openspecDir, "config.yaml"));
+	const schemaRoot = join$1(openspecDir, "schemas");
+	const schemaDirs = await reactiveReadDir(schemaRoot, {
+		directoriesOnly: true,
+		includeHidden: true
+	});
+	await Promise.all(schemaDirs.map((name) => reactiveReadFile(join$1(schemaRoot, name, "schema.yaml"))));
+	await reactiveReadDir(join$1(openspecDir, "changes"), {
+		directoriesOnly: true,
+		includeHidden: true,
+		exclude: ["archive"]
+	});
+}
+async function touchOpsxChangeDeps(projectDir, changeId) {
+	const changeDir = join$1(projectDir, "openspec", "changes", changeId);
+	await reactiveReadDir(changeDir, { includeHidden: true });
+	await reactiveReadFile(join$1(changeDir, ".openspec.yaml"));
+}
+var OpsxKernel = class {
+	projectDir;
+	cliExecutor;
+	controller = new AbortController();
+	_statusList = new ReactiveState([]);
+	_schemas = new ReactiveState([]);
+	_changeIds = new ReactiveState([]);
+	_projectConfig = new ReactiveState(null);
+	_schemaResolutions = /* @__PURE__ */ new Map();
+	_schemaDetails = /* @__PURE__ */ new Map();
+	_schemaFiles = /* @__PURE__ */ new Map();
+	_schemaYamls = /* @__PURE__ */ new Map();
+	_templates = /* @__PURE__ */ new Map();
+	_templateContents = /* @__PURE__ */ new Map();
+	_statuses = /* @__PURE__ */ new Map();
+	_instructions = /* @__PURE__ */ new Map();
+	_applyInstructions = /* @__PURE__ */ new Map();
+	_changeMetadata = /* @__PURE__ */ new Map();
+	_artifactOutputs = /* @__PURE__ */ new Map();
+	_globArtifactFiles = /* @__PURE__ */ new Map();
+	_entityControllers = /* @__PURE__ */ new Map();
+	constructor(projectDir, cliExecutor) {
+		this.projectDir = projectDir;
+		this.cliExecutor = cliExecutor;
+	}
+	async warmup() {
+		const signal = this.controller.signal;
+		await Promise.all([
+			this.startStream(this._schemas, () => this.fetchSchemas(), signal),
+			this.startStream(this._changeIds, () => this.fetchChangeIds(), signal),
+			this.startStream(this._projectConfig, () => this.fetchProjectConfig(), signal)
+		]);
+		const schemas = this._schemas.get();
+		await Promise.all(schemas.map((s) => this.warmupSchema(s.name, signal)));
+		const changeIds = this._changeIds.get();
+		await Promise.all(changeIds.map((id) => this.warmupChange(id, signal)));
+		await this.startStream(this._statusList, () => this.fetchStatusList(), signal);
+		this.watchSchemaChanges(signal);
+		this.watchChangeIdChanges(signal);
+	}
+	dispose() {
+		this.controller.abort();
+		for (const ctrl of this._entityControllers.values()) ctrl.abort();
+		this._entityControllers.clear();
+	}
+	getStatusList() {
+		return this._statusList.get();
+	}
+	getSchemas() {
+		return this._schemas.get();
+	}
+	getChangeIds() {
+		return this._changeIds.get();
+	}
+	getProjectConfig() {
+		return this._projectConfig.get();
+	}
+	getTemplates(schema) {
+		const key = schema ?? "";
+		const state = this._templates.get(key);
+		return state ? state.get() : {};
+	}
+	getTemplateContents(schema) {
+		const key = schema ?? "";
+		const state = this._templateContents.get(key);
+		return state ? state.get() : {};
+	}
+	getStatus(changeId, schema) {
+		const key = `${changeId}:${schema ?? ""}`;
+		const state = this._statuses.get(key);
+		if (!state) throw new Error(`Status not found for change "${changeId}"`);
+		return state.get();
+	}
+	getInstructions(changeId, artifact, schema) {
+		const key = `${changeId}:${artifact}:${schema ?? ""}`;
+		const state = this._instructions.get(key);
+		if (!state) throw new Error(`Instructions not found for change "${changeId}" artifact "${artifact}"`);
+		return state.get();
+	}
+	getApplyInstructions(changeId, schema) {
+		const key = `${changeId}:${schema ?? ""}`;
+		const state = this._applyInstructions.get(key);
+		if (!state) throw new Error(`Apply instructions not found for change "${changeId}"`);
+		return state.get();
+	}
+	getSchemaResolution(name) {
+		const state = this._schemaResolutions.get(name);
+		if (!state) throw new Error(`Schema resolution not found for "${name}"`);
+		return state.get();
+	}
+	getSchemaDetail(name) {
+		const state = this._schemaDetails.get(name);
+		if (!state) throw new Error(`Schema detail not found for "${name}"`);
+		return state.get();
+	}
+	getSchemaFiles(name) {
+		const state = this._schemaFiles.get(name);
+		if (!state) throw new Error(`Schema files not found for "${name}"`);
+		return state.get();
+	}
+	getSchemaYaml(name) {
+		const state = this._schemaYamls.get(name);
+		if (!state) throw new Error(`Schema yaml not found for "${name}"`);
+		return state.get();
+	}
+	getChangeMetadata(changeId) {
+		const state = this._changeMetadata.get(changeId);
+		if (!state) return null;
+		return state.get();
+	}
+	getArtifactOutput(changeId, outputPath) {
+		const key = `${changeId}:${outputPath}`;
+		const state = this._artifactOutputs.get(key);
+		if (!state) return null;
+		return state.get();
+	}
+	getGlobArtifactFiles(changeId, outputPath) {
+		const key = `${changeId}:${outputPath}`;
+		const state = this._globArtifactFiles.get(key);
+		if (!state) return [];
+		return state.get();
+	}
+	startStream(state, task, signal) {
+		return new Promise((resolve$1) => {
+			const context = new ReactiveContext();
+			let first = true;
+			(async () => {
+				try {
+					for await (const data of context.stream(task, signal)) {
+						state.set(data);
+						if (first) {
+							first = false;
+							resolve$1();
+						}
+					}
+				} catch {}
+				if (first) resolve$1();
+			})();
+		});
+	}
+	async warmupSchema(name, parentSignal) {
+		const entityCtrl = new AbortController();
+		this._entityControllers.set(`schema:${name}`, entityCtrl);
+		const signal = this.combineSignals(parentSignal, entityCtrl.signal);
+		if (!this._schemaResolutions.has(name)) this._schemaResolutions.set(name, new ReactiveState(null));
+		if (!this._schemaDetails.has(name)) this._schemaDetails.set(name, new ReactiveState(null));
+		if (!this._schemaFiles.has(name)) this._schemaFiles.set(name, new ReactiveState([]));
+		if (!this._schemaYamls.has(name)) this._schemaYamls.set(name, new ReactiveState(null));
+		if (!this._templates.has(name)) this._templates.set(name, new ReactiveState({}));
+		if (!this._templateContents.has(name)) this._templateContents.set(name, new ReactiveState({}));
+		if (!this._templates.has("")) this._templates.set("", new ReactiveState({}));
+		if (!this._templateContents.has("")) this._templateContents.set("", new ReactiveState({}));
+		await Promise.all([
+			this.startStream(this._schemaResolutions.get(name), () => this.fetchSchemaResolution(name), signal),
+			this.startStream(this._schemaDetails.get(name), () => this.fetchSchemaDetail(name), signal),
+			this.startStream(this._schemaFiles.get(name), () => this.fetchSchemaFiles(name), signal),
+			this.startStream(this._schemaYamls.get(name), () => this.fetchSchemaYaml(name), signal),
+			this.startStream(this._templates.get(name), () => this.fetchTemplates(name), signal),
+			this.startStream(this._templateContents.get(name), () => this.fetchTemplateContents(name), signal),
+			this.startStream(this._templates.get(""), () => this.fetchTemplates(void 0), signal),
+			this.startStream(this._templateContents.get(""), () => this.fetchTemplateContents(void 0), signal)
+		]);
+	}
+	async warmupChange(changeId, parentSignal) {
+		const entityCtrl = new AbortController();
+		this._entityControllers.set(`change:${changeId}`, entityCtrl);
+		const signal = this.combineSignals(parentSignal, entityCtrl.signal);
+		const statusKey = `${changeId}:`;
+		if (!this._statuses.has(statusKey)) this._statuses.set(statusKey, new ReactiveState(null));
+		if (!this._changeMetadata.has(changeId)) this._changeMetadata.set(changeId, new ReactiveState(null));
+		const applyKey = `${changeId}:`;
+		if (!this._applyInstructions.has(applyKey)) this._applyInstructions.set(applyKey, new ReactiveState(null));
+		await Promise.all([
+			this.startStream(this._statuses.get(statusKey), () => this.fetchStatus(changeId, void 0), signal),
+			this.startStream(this._changeMetadata.get(changeId), () => this.fetchChangeMetadata(changeId), signal),
+			this.startStream(this._applyInstructions.get(applyKey), () => this.fetchApplyInstructions(changeId, void 0), signal)
+		]);
+		const status = this._statuses.get(statusKey)?.get();
+		if (status?.artifacts) await Promise.all(status.artifacts.map(async (artifact) => {
+			const instrKey = `${changeId}:${artifact.id}:`;
+			if (!this._instructions.has(instrKey)) this._instructions.set(instrKey, new ReactiveState(null));
+			await this.startStream(this._instructions.get(instrKey), () => this.fetchInstructions(changeId, artifact.id, void 0), signal);
+			const outputKey = `${changeId}:${artifact.outputPath}`;
+			if (!this._artifactOutputs.has(outputKey)) this._artifactOutputs.set(outputKey, new ReactiveState(null));
+			await this.startStream(this._artifactOutputs.get(outputKey), () => this.fetchArtifactOutput(changeId, artifact.outputPath), signal);
+			if (artifact.outputPath.includes("*") || artifact.outputPath.includes("?") || artifact.outputPath.includes("[")) {
+				const globKey = `${changeId}:${artifact.outputPath}`;
+				if (!this._globArtifactFiles.has(globKey)) this._globArtifactFiles.set(globKey, new ReactiveState([]));
+				await this.startStream(this._globArtifactFiles.get(globKey), () => readGlobArtifactFiles(this.projectDir, changeId, artifact.outputPath), signal);
+			}
+		}));
+	}
+	watchSchemaChanges(signal) {
+		const context = new ReactiveContext();
+		(async () => {
+			let prevNames = new Set(this._schemas.get().map((s) => s.name));
+			try {
+				for await (const schemas of context.stream(() => Promise.resolve(this._schemas.get()), signal)) {
+					const newNames = new Set(schemas.map((s) => s.name));
+					for (const name of newNames) if (!prevNames.has(name)) this.warmupSchema(name, signal);
+					for (const name of prevNames) if (!newNames.has(name)) {
+						this.teardownEntity(`schema:${name}`);
+						this._schemaResolutions.delete(name);
+						this._schemaDetails.delete(name);
+						this._schemaFiles.delete(name);
+						this._schemaYamls.delete(name);
+						this._templates.delete(name);
+						this._templateContents.delete(name);
+					}
+					prevNames = newNames;
+				}
+			} catch {}
+		})();
+	}
+	watchChangeIdChanges(signal) {
+		const context = new ReactiveContext();
+		(async () => {
+			let prevIds = new Set(this._changeIds.get());
+			try {
+				for await (const ids of context.stream(() => Promise.resolve(this._changeIds.get()), signal)) {
+					const newIds = new Set(ids);
+					for (const id of newIds) if (!prevIds.has(id)) this.warmupChange(id, signal);
+					for (const id of prevIds) if (!newIds.has(id)) {
+						this.teardownEntity(`change:${id}`);
+						for (const key of this._statuses.keys()) if (key.startsWith(`${id}:`)) this._statuses.delete(key);
+						for (const key of this._instructions.keys()) if (key.startsWith(`${id}:`)) this._instructions.delete(key);
+						for (const key of this._applyInstructions.keys()) if (key.startsWith(`${id}:`)) this._applyInstructions.delete(key);
+						this._changeMetadata.delete(id);
+						for (const key of this._artifactOutputs.keys()) if (key.startsWith(`${id}:`)) this._artifactOutputs.delete(key);
+						for (const key of this._globArtifactFiles.keys()) if (key.startsWith(`${id}:`)) this._globArtifactFiles.delete(key);
+					}
+					prevIds = newIds;
+				}
+			} catch {}
+		})();
+	}
+	teardownEntity(key) {
+		const ctrl = this._entityControllers.get(key);
+		if (ctrl) {
+			ctrl.abort();
+			this._entityControllers.delete(key);
+		}
+	}
+	async fetchSchemas() {
+		await touchOpsxProjectDeps(this.projectDir);
+		const result = await this.cliExecutor.schemas();
+		if (!result.success) throw new Error(result.stderr || `openspec schemas failed (exit ${result.exitCode ?? "null"})`);
+		return parseCliJson(result.stdout, z.array(SchemaInfoSchema), "openspec schemas");
+	}
+	async fetchChangeIds() {
+		return reactiveReadDir(join$1(this.projectDir, "openspec", "changes"), {
+			directoriesOnly: true,
+			includeHidden: false,
+			exclude: ["archive"]
+		});
+	}
+	async fetchProjectConfig() {
+		return reactiveReadFile(join$1(this.projectDir, "openspec", "config.yaml"));
+	}
+	async fetchStatus(changeId, schema) {
+		await touchOpsxProjectDeps(this.projectDir);
+		await touchOpsxChangeDeps(this.projectDir, changeId);
+		const args = [
+			"status",
+			"--json",
+			"--change",
+			changeId
+		];
+		if (schema) args.push("--schema", schema);
+		const result = await this.cliExecutor.execute(args);
+		if (!result.success) throw new Error(result.stderr || `openspec status failed (exit ${result.exitCode ?? "null"})`);
+		const status = parseCliJson(result.stdout, ChangeStatusSchema, "openspec status");
+		const changeRelDir = `openspec/changes/${changeId}`;
+		for (const artifact of status.artifacts) artifact.relativePath = `${changeRelDir}/${artifact.outputPath}`;
+		return status;
+	}
+	async fetchStatusList() {
+		const changeIds = this._changeIds.get();
+		return Promise.all(changeIds.map((id) => {
+			const key = `${id}:`;
+			const state = this._statuses.get(key);
+			if (state) return Promise.resolve(state.get());
+			return this.fetchStatus(id);
+		}));
+	}
+	async fetchInstructions(changeId, artifact, schema) {
+		await touchOpsxProjectDeps(this.projectDir);
+		await touchOpsxChangeDeps(this.projectDir, changeId);
+		const args = [
+			"instructions",
+			artifact,
+			"--json",
+			"--change",
+			changeId
+		];
+		if (schema) args.push("--schema", schema);
+		const result = await this.cliExecutor.execute(args);
+		if (!result.success) throw new Error(result.stderr || `openspec instructions failed (exit ${result.exitCode ?? "null"})`);
+		return parseCliJson(result.stdout, ArtifactInstructionsSchema, "openspec instructions");
+	}
+	async fetchApplyInstructions(changeId, schema) {
+		await touchOpsxProjectDeps(this.projectDir);
+		await touchOpsxChangeDeps(this.projectDir, changeId);
+		const args = [
+			"instructions",
+			"apply",
+			"--json",
+			"--change",
+			changeId
+		];
+		if (schema) args.push("--schema", schema);
+		const result = await this.cliExecutor.execute(args);
+		if (!result.success) throw new Error(result.stderr || `openspec instructions apply failed (exit ${result.exitCode ?? "null"})`);
+		return parseCliJson(result.stdout, ApplyInstructionsSchema, "openspec instructions apply");
+	}
+	async fetchSchemaResolution(name) {
+		await touchOpsxProjectDeps(this.projectDir);
+		const result = await this.cliExecutor.schemaWhich(name);
+		if (!result.success) throw new Error(result.stderr || `openspec schema which failed (exit ${result.exitCode ?? "null"})`);
+		return parseCliJson(result.stdout, SchemaResolutionSchema, "openspec schema which");
+	}
+	async fetchSchemaDetail(name) {
+		await touchOpsxProjectDeps(this.projectDir);
+		const schemaPath = join$1((await this.fetchSchemaResolution(name)).path, "schema.yaml");
+		const content = await reactiveReadFile(schemaPath);
+		if (!content) throw new Error(`schema.yaml not found at ${schemaPath}`);
+		return parseSchemaYamlInline(content);
+	}
+	async fetchSchemaFiles(name) {
+		await touchOpsxProjectDeps(this.projectDir);
+		return readEntriesUnderRoot((await this.fetchSchemaResolution(name)).path);
+	}
+	async fetchSchemaYaml(name) {
+		await touchOpsxProjectDeps(this.projectDir);
+		return reactiveReadFile(join$1((await this.fetchSchemaResolution(name)).path, "schema.yaml"));
+	}
+	async fetchTemplates(schema) {
+		await touchOpsxProjectDeps(this.projectDir);
+		const result = await this.cliExecutor.templates(schema);
+		if (!result.success) throw new Error(result.stderr || `openspec templates failed (exit ${result.exitCode ?? "null"})`);
+		return parseCliJson(result.stdout, TemplatesSchema, "openspec templates");
+	}
+	async fetchTemplateContents(schema) {
+		const templates = await this.fetchTemplates(schema);
+		const entries = await Promise.all(Object.entries(templates).map(async ([artifactId, info]) => {
+			return [artifactId, {
+				content: await reactiveReadFile(info.path),
+				path: info.path,
+				source: info.source
+			}];
+		}));
+		return Object.fromEntries(entries);
+	}
+	async fetchChangeMetadata(changeId) {
+		return reactiveReadFile(join$1(this.projectDir, "openspec", "changes", changeId, ".openspec.yaml"));
+	}
+	async fetchArtifactOutput(changeId, outputPath) {
+		return reactiveReadFile(join$1(this.projectDir, "openspec", "changes", changeId, outputPath));
+	}
+	/**
+	* Ensure a per-change status stream exists. If not yet warmed up,
+	* creates the state and starts a stream lazily.
+	*/
+	ensureStatus(changeId, schema) {
+		const key = `${changeId}:${schema ?? ""}`;
+		if (!this._statuses.has(key)) {
+			this._statuses.set(key, new ReactiveState(null));
+			this.startStream(this._statuses.get(key), () => this.fetchStatus(changeId, schema), this.controller.signal);
+		}
+	}
+	ensureInstructions(changeId, artifact, schema) {
+		const key = `${changeId}:${artifact}:${schema ?? ""}`;
+		if (!this._instructions.has(key)) {
+			this._instructions.set(key, new ReactiveState(null));
+			this.startStream(this._instructions.get(key), () => this.fetchInstructions(changeId, artifact, schema), this.controller.signal);
+		}
+	}
+	ensureApplyInstructions(changeId, schema) {
+		const key = `${changeId}:${schema ?? ""}`;
+		if (!this._applyInstructions.has(key)) {
+			this._applyInstructions.set(key, new ReactiveState(null));
+			this.startStream(this._applyInstructions.get(key), () => this.fetchApplyInstructions(changeId, schema), this.controller.signal);
+		}
+	}
+	ensureArtifactOutput(changeId, outputPath) {
+		const key = `${changeId}:${outputPath}`;
+		if (!this._artifactOutputs.has(key)) {
+			this._artifactOutputs.set(key, new ReactiveState(null));
+			this.startStream(this._artifactOutputs.get(key), () => this.fetchArtifactOutput(changeId, outputPath), this.controller.signal);
+		}
+	}
+	ensureGlobArtifactFiles(changeId, outputPath) {
+		const key = `${changeId}:${outputPath}`;
+		if (!this._globArtifactFiles.has(key)) {
+			this._globArtifactFiles.set(key, new ReactiveState([]));
+			this.startStream(this._globArtifactFiles.get(key), () => readGlobArtifactFiles(this.projectDir, changeId, outputPath), this.controller.signal);
+		}
+	}
+	ensureSchemaResolution(name) {
+		if (!this._schemaResolutions.has(name)) {
+			this._schemaResolutions.set(name, new ReactiveState(null));
+			this.startStream(this._schemaResolutions.get(name), () => this.fetchSchemaResolution(name), this.controller.signal);
+		}
+	}
+	ensureSchemaDetail(name) {
+		if (!this._schemaDetails.has(name)) {
+			this._schemaDetails.set(name, new ReactiveState(null));
+			this.startStream(this._schemaDetails.get(name), () => this.fetchSchemaDetail(name), this.controller.signal);
+		}
+	}
+	ensureSchemaFiles(name) {
+		if (!this._schemaFiles.has(name)) {
+			this._schemaFiles.set(name, new ReactiveState([]));
+			this.startStream(this._schemaFiles.get(name), () => this.fetchSchemaFiles(name), this.controller.signal);
+		}
+	}
+	ensureSchemaYaml(name) {
+		if (!this._schemaYamls.has(name)) {
+			this._schemaYamls.set(name, new ReactiveState(null));
+			this.startStream(this._schemaYamls.get(name), () => this.fetchSchemaYaml(name), this.controller.signal);
+		}
+	}
+	ensureTemplates(schema) {
+		const key = schema ?? "";
+		if (!this._templates.has(key)) {
+			this._templates.set(key, new ReactiveState({}));
+			this.startStream(this._templates.get(key), () => this.fetchTemplates(schema), this.controller.signal);
+		}
+	}
+	ensureTemplateContents(schema) {
+		const key = schema ?? "";
+		if (!this._templateContents.has(key)) {
+			this._templateContents.set(key, new ReactiveState({}));
+			this.startStream(this._templateContents.get(key), () => this.fetchTemplateContents(schema), this.controller.signal);
+		}
+	}
+	ensureChangeMetadata(changeId) {
+		if (!this._changeMetadata.has(changeId)) {
+			this._changeMetadata.set(changeId, new ReactiveState(null));
+			this.startStream(this._changeMetadata.get(changeId), () => this.fetchChangeMetadata(changeId), this.controller.signal);
+		}
+	}
+	combineSignals(a, b) {
+		const ctrl = new AbortController();
+		const abort = () => ctrl.abort();
+		if (a.aborted || b.aborted) {
+			ctrl.abort();
+			return ctrl.signal;
+		}
+		a.addEventListener("abort", abort, { once: true });
+		b.addEventListener("abort", abort, { once: true });
+		return ctrl.signal;
+	}
+};
+const SchemaYamlArtifactSchema = z.object({
+	id: z.string(),
+	generates: z.string(),
+	description: z.string().optional(),
+	template: z.string().optional(),
+	instruction: z.string().optional(),
+	requires: z.array(z.string()).optional()
+});
+const SchemaYamlSchema = z.object({
+	name: z.string(),
+	version: z.union([z.string(), z.number()]).optional(),
+	description: z.string().optional(),
+	artifacts: z.array(SchemaYamlArtifactSchema),
+	apply: z.object({
+		requires: z.array(z.string()).optional(),
+		tracks: z.string().optional(),
+		instruction: z.string().optional()
+	}).optional()
+});
+function parseSchemaYamlInline(content) {
+	const raw = parse(content);
+	const parsed = SchemaYamlSchema.safeParse(raw);
+	if (!parsed.success) throw new Error(`Invalid schema.yaml: ${parsed.error.message}`);
+	const { artifacts, apply, name, description, version } = parsed.data;
+	const detail = {
+		name,
+		description,
+		version,
+		artifacts: artifacts.map((artifact) => ({
+			id: artifact.id,
+			outputPath: artifact.generates,
+			description: artifact.description,
+			template: artifact.template,
+			instruction: artifact.instruction,
+			requires: artifact.requires ?? []
+		})),
+		applyRequires: apply?.requires ?? [],
+		applyTracks: apply?.tracks,
+		applyInstruction: apply?.instruction
+	};
+	const validated = SchemaDetailSchema.safeParse(detail);
+	if (!validated.success) throw new Error(`Invalid schema detail: ${validated.error.message}`);
+	return validated.data;
+}
+
+//#endregion
+//#region src/pty-protocol.ts
+const PositiveInt = z.number().int().positive();
+const PtyPlatformSchema = z.enum([
+	"windows",
+	"macos",
+	"common"
+]);
+const PtySessionInfoSchema = z.object({
+	id: z.string().min(1),
+	title: z.string(),
+	command: z.string(),
+	args: z.array(z.string()),
+	platform: PtyPlatformSchema,
+	isExited: z.boolean(),
+	exitCode: z.number().int().nullable()
+});
+const PtyCreateMessageSchema = z.object({
+	type: z.literal("create"),
+	requestId: z.string().min(1),
+	cols: PositiveInt.optional(),
+	rows: PositiveInt.optional(),
+	command: z.string().min(1).optional(),
+	args: z.array(z.string()).optional()
+});
+const PtyInputMessageSchema = z.object({
+	type: z.literal("input"),
+	sessionId: z.string().min(1),
+	data: z.string()
+});
+const PtyResizeMessageSchema = z.object({
+	type: z.literal("resize"),
+	sessionId: z.string().min(1),
+	cols: PositiveInt,
+	rows: PositiveInt
+});
+const PtyCloseMessageSchema = z.object({
+	type: z.literal("close"),
+	sessionId: z.string().min(1)
+});
+const PtyAttachMessageSchema = z.object({
+	type: z.literal("attach"),
+	sessionId: z.string().min(1),
+	cols: PositiveInt.optional(),
+	rows: PositiveInt.optional()
+});
+const PtyListMessageSchema = z.object({ type: z.literal("list") });
+const PtyClientMessageSchema = z.discriminatedUnion("type", [
+	PtyCreateMessageSchema,
+	PtyInputMessageSchema,
+	PtyResizeMessageSchema,
+	PtyCloseMessageSchema,
+	PtyAttachMessageSchema,
+	PtyListMessageSchema
+]);
+const PtyCreatedResponseSchema = z.object({
+	type: z.literal("created"),
+	requestId: z.string().min(1),
+	sessionId: z.string().min(1),
+	platform: PtyPlatformSchema
+});
+const PtyOutputResponseSchema = z.object({
+	type: z.literal("output"),
+	sessionId: z.string().min(1),
+	data: z.string()
+});
+const PtyExitResponseSchema = z.object({
+	type: z.literal("exit"),
+	sessionId: z.string().min(1),
+	exitCode: z.number().int()
+});
+const PtyTitleResponseSchema = z.object({
+	type: z.literal("title"),
+	sessionId: z.string().min(1),
+	title: z.string()
+});
+const PtyBufferResponseSchema = z.object({
+	type: z.literal("buffer"),
+	sessionId: z.string().min(1),
+	data: z.string()
+});
+const PtyListResponseSchema = z.object({
+	type: z.literal("list"),
+	sessions: z.array(PtySessionInfoSchema)
+});
+const PtyErrorCodeSchema = z.enum([
+	"INVALID_JSON",
+	"INVALID_MESSAGE",
+	"SESSION_NOT_FOUND"
+]);
+const PtyErrorResponseSchema = z.object({
+	type: z.literal("error"),
+	code: PtyErrorCodeSchema,
+	message: z.string().min(1),
+	sessionId: z.string().min(1).optional()
+});
+const PtyServerMessageSchema = z.discriminatedUnion("type", [
+	PtyCreatedResponseSchema,
+	PtyOutputResponseSchema,
+	PtyExitResponseSchema,
+	PtyTitleResponseSchema,
+	PtyBufferResponseSchema,
+	PtyListResponseSchema,
+	PtyErrorResponseSchema
+]);
+
+//#endregion
+export { AI_TOOLS, ApplyInstructionsSchema, ApplyTaskSchema, ArtifactInstructionsSchema, ArtifactStatusSchema, ChangeFileSchema, ChangeSchema, ChangeStatusSchema, CliExecutor, ConfigManager, DEFAULT_CONFIG, DeltaOperationType, DeltaSchema, DeltaSpecSchema, DependencyInfoSchema, MarkdownParser, OpenSpecAdapter, OpenSpecUIConfigSchema, OpenSpecWatcher, OpsxKernel, ProjectWatcher, PtyAttachMessageSchema, PtyBufferResponseSchema, PtyClientMessageSchema, PtyCloseMessageSchema, PtyCreateMessageSchema, PtyCreatedResponseSchema, PtyErrorCodeSchema, PtyErrorResponseSchema, PtyExitResponseSchema, PtyInputMessageSchema, PtyListMessageSchema, PtyListResponseSchema, PtyOutputResponseSchema, PtyPlatformSchema, PtyResizeMessageSchema, PtyServerMessageSchema, PtyTitleResponseSchema, ReactiveContext, ReactiveState, RequirementSchema, SchemaArtifactSchema, SchemaDetailSchema, SchemaInfoSchema, SchemaResolutionSchema, SpecSchema, TaskSchema, TemplatesSchema, TerminalConfigSchema, Validator, acquireWatcher, buildCliRunnerCandidates, clearCache, closeAllProjectWatchers, closeAllWatchers, contextStorage, createCleanCliEnv, createFileChangeObservable, getActiveWatcherCount, getAllToolIds, getAllTools, getAvailableToolIds, getAvailableTools, getCacheSize, getConfiguredTools, getDefaultCliCommand, getDefaultCliCommandString, getProjectWatcher, getToolById, getWatchedProjectDir, initWatcherPool, isGlobPattern, isToolConfigured, isWatcherPoolInitialized, parseCliCommand, reactiveExists, reactiveReadDir, reactiveReadFile, reactiveStat, sniffGlobalCli };