@openspecui/core 0.9.0

package/dist/index.mjs

@@ -0,0 +1,2706 @@
+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 { 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";
+
+//#region src/parser.ts
+/**
+* Markdown parser for OpenSpec documents
+*/
+var MarkdownParser = class {
+	/**
+	* Parse a spec markdown content into a Spec object
+	*/
+	parseSpec(specId, content) {
+		const lines = content.split("\n");
+		let name = specId;
+		let overview = "";
+		const requirements = [];
+		let currentSection = "";
+		let currentRequirement = null;
+		let currentScenarioText = "";
+		let reqIndex = 0;
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (line.startsWith("# ") && name === specId) {
+				name = line.slice(2).trim();
+				continue;
+			}
+			if (line.startsWith("## ")) {
+				const sectionTitle = line.slice(3).trim().toLowerCase();
+				if (sectionTitle.includes("purpose") || sectionTitle.includes("overview")) currentSection = "overview";
+				else if (sectionTitle.includes("requirement")) currentSection = "requirements";
+				else currentSection = sectionTitle;
+				continue;
+			}
+			if (line.startsWith("### Requirement:") || line.startsWith("### ") && currentSection === "requirements") {
+				if (currentRequirement) {
+					if (currentScenarioText.trim()) {
+						currentRequirement.scenarios = currentRequirement.scenarios || [];
+						currentRequirement.scenarios.push({ rawText: currentScenarioText.trim() });
+					}
+					requirements.push({
+						id: currentRequirement.id || `req-${reqIndex}`,
+						text: currentRequirement.text || "",
+						scenarios: currentRequirement.scenarios || []
+					});
+				}
+				reqIndex++;
+				const reqTitle = line.replace(/^###\s*(Requirement:\s*)?/, "").trim();
+				currentRequirement = {
+					id: `req-${reqIndex}`,
+					text: reqTitle,
+					scenarios: []
+				};
+				currentScenarioText = "";
+				continue;
+			}
+			if (line.startsWith("#### Scenario:") || line.startsWith("#### ")) {
+				if (currentScenarioText.trim() && currentRequirement) {
+					currentRequirement.scenarios = currentRequirement.scenarios || [];
+					currentRequirement.scenarios.push({ rawText: currentScenarioText.trim() });
+				}
+				currentScenarioText = line.replace(/^####\s*(Scenario:\s*)?/, "").trim() + "\n";
+				continue;
+			}
+			if (currentSection === "overview" && !currentRequirement) overview += line + "\n";
+			else if (currentRequirement && line.trim()) {
+				if (line.startsWith("- ") || line.startsWith("* ")) currentScenarioText += line + "\n";
+				else if (!line.startsWith("#")) if (currentRequirement.text && !currentScenarioText) currentRequirement.text += " " + line.trim();
+				else currentScenarioText += line + "\n";
+			}
+		}
+		if (currentRequirement) {
+			if (currentScenarioText.trim()) {
+				currentRequirement.scenarios = currentRequirement.scenarios || [];
+				currentRequirement.scenarios.push({ rawText: currentScenarioText.trim() });
+			}
+			requirements.push({
+				id: currentRequirement.id || `req-${reqIndex}`,
+				text: currentRequirement.text || "",
+				scenarios: currentRequirement.scenarios || []
+			});
+		}
+		return {
+			id: specId,
+			name: name || specId,
+			overview: overview.trim(),
+			requirements,
+			metadata: {
+				version: "1.0.0",
+				format: "openspec"
+			}
+		};
+	}
+	/**
+	* Parse a change proposal markdown content into a Change object
+	*/
+	parseChange(changeId, proposalContent, tasksContent = "", options) {
+		const lines = proposalContent.split("\n");
+		let name = changeId;
+		let why = "";
+		let whatChanges = "";
+		const deltas = [];
+		let currentSection = "";
+		for (const line of lines) {
+			if (line.startsWith("# ")) {
+				name = line.slice(2).trim();
+				continue;
+			}
+			if (line.startsWith("## ")) {
+				const sectionTitle = line.slice(3).trim().toLowerCase();
+				if (sectionTitle.includes("why")) currentSection = "why";
+				else if (sectionTitle.includes("what") || sectionTitle.includes("change")) currentSection = "whatChanges";
+				else if (sectionTitle.includes("impact") || sectionTitle.includes("delta")) currentSection = "impact";
+				else currentSection = sectionTitle;
+				continue;
+			}
+			if (currentSection === "why") why += line + "\n";
+			else if (currentSection === "whatChanges") whatChanges += line + "\n";
+			else if (currentSection === "impact") {
+				const specMatch = line.match(/specs\/([a-zA-Z0-9-_]+)/);
+				if (specMatch) deltas.push({
+					spec: specMatch[1],
+					operation: "MODIFIED",
+					description: line.trim()
+				});
+			}
+		}
+		const tasks = this.parseTasks(tasksContent);
+		const deltasFromDeltaSpecs = this.parseDeltasFromDeltaSpecs(options?.deltaSpecs);
+		const deltasFromWhatChanges = this.parseDeltasFromWhatChanges(whatChanges);
+		const combinedDeltas = deltasFromDeltaSpecs.length > 0 ? deltasFromDeltaSpecs : deltas;
+		const finalDeltas = combinedDeltas.length > 0 ? combinedDeltas : deltasFromWhatChanges;
+		return {
+			id: changeId,
+			name: name || changeId,
+			why: why.trim(),
+			whatChanges: whatChanges.trim(),
+			deltas: finalDeltas,
+			tasks,
+			progress: {
+				total: tasks.length,
+				completed: tasks.filter((t) => t.completed).length
+			},
+			design: options?.design,
+			deltaSpecs: options?.deltaSpecs
+		};
+	}
+	parseDeltasFromWhatChanges(whatChanges) {
+		if (!whatChanges.trim()) return [];
+		const deltas = [];
+		const lines = whatChanges.split("\n");
+		for (const line of lines) {
+			const match = line.match(/^\s*-\s*\*\*([^*:]+)(?::\*\*|\*\*:):?\s*(.+)$/);
+			if (!match) continue;
+			const spec = match[1].trim();
+			const description = match[2].trim();
+			const lower = description.toLowerCase();
+			let operation = "MODIFIED";
+			if (/\brename(s|d|ing)?\b/.test(lower) || /\brenamed\b/.test(lower)) operation = "RENAMED";
+			else if (/\bremove(s|d|ing)?\b/.test(lower) || /\bdelete(s|d|ing)?\b/.test(lower)) operation = "REMOVED";
+			else if (/\badd(s|ed|ing)?\b/.test(lower) || /\bcreate(s|d|ing)?\b/.test(lower) || /\bnew\b/.test(lower)) operation = "ADDED";
+			deltas.push({
+				spec,
+				operation,
+				description
+			});
+		}
+		return deltas;
+	}
+	parseDeltasFromDeltaSpecs(deltaSpecs) {
+		if (!deltaSpecs || deltaSpecs.length === 0) return [];
+		return deltaSpecs.flatMap((deltaSpec) => this.parseDeltaSpecContent(deltaSpec));
+	}
+	parseDeltaSpecContent(deltaSpec) {
+		const deltas = [];
+		const lines = deltaSpec.content.split("\n");
+		let currentOperation = null;
+		let currentRequirement = null;
+		let renameBuffer = null;
+		let reqIndex = 0;
+		const finalizeRequirement = () => {
+			if (!currentOperation || !currentRequirement) return;
+			const scenarios = currentRequirement.scenarios.map((scenario) => {
+				const rawText = [scenario.title, ...scenario.lines].join("\n").trim();
+				return rawText ? { rawText } : null;
+			}).filter((s) => Boolean(s));
+			const descriptionText = currentRequirement.descriptionLines.map((l) => l.trim()).filter(Boolean).join(" ");
+			const requirement = {
+				id: `${deltaSpec.specId}-${currentOperation.toLowerCase()}-${++reqIndex}`,
+				text: descriptionText || currentRequirement.title,
+				scenarios
+			};
+			deltas.push({
+				spec: deltaSpec.specId,
+				operation: currentOperation,
+				description: `${currentOperation} requirement: ${requirement.text}`,
+				requirement,
+				requirements: [requirement]
+			});
+		};
+		for (const rawLine of lines) {
+			const line = rawLine.trimEnd();
+			const opMatch = line.match(/^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements/i);
+			if (opMatch) {
+				finalizeRequirement();
+				currentRequirement = null;
+				currentOperation = opMatch[1].toUpperCase();
+				renameBuffer = null;
+				continue;
+			}
+			if (currentOperation === "RENAMED") {
+				const fromMatch = line.match(/FROM:\s*`?###\s*Requirement:\s*(.+?)`?$/i);
+				const toMatch = line.match(/TO:\s*`?###\s*Requirement:\s*(.+?)`?$/i);
+				if (fromMatch) renameBuffer = {
+					...renameBuffer ?? {},
+					from: fromMatch[1].trim()
+				};
+				if (toMatch) renameBuffer = {
+					...renameBuffer ?? {},
+					to: toMatch[1].trim()
+				};
+				if (renameBuffer?.from && renameBuffer?.to) {
+					deltas.push({
+						spec: deltaSpec.specId,
+						operation: "RENAMED",
+						description: `Rename requirement from "${renameBuffer.from}" to "${renameBuffer.to}"`,
+						rename: {
+							from: renameBuffer.from,
+							to: renameBuffer.to
+						}
+					});
+					renameBuffer = null;
+				}
+				continue;
+			}
+			const requirementMatch = line.match(/^###\s+Requirement:\s*(.+)$/);
+			if (requirementMatch) {
+				finalizeRequirement();
+				currentRequirement = {
+					title: requirementMatch[1].trim(),
+					descriptionLines: [],
+					scenarios: []
+				};
+				continue;
+			}
+			const scenarioMatch = line.match(/^####\s*Scenario:?\s*(.*)$/);
+			if (scenarioMatch && currentRequirement) {
+				const title = scenarioMatch[1].trim() || "Scenario";
+				currentRequirement.scenarios.push({
+					title,
+					lines: []
+				});
+				continue;
+			}
+			if (currentRequirement) {
+				const activeScenario = currentRequirement.scenarios[currentRequirement.scenarios.length - 1];
+				if (activeScenario) activeScenario.lines.push(line);
+				else currentRequirement.descriptionLines.push(line);
+			}
+		}
+		finalizeRequirement();
+		return deltas;
+	}
+	/**
+	* Parse tasks from a tasks.md content
+	*/
+	parseTasks(content) {
+		if (!content) return [];
+		const tasks = [];
+		const lines = content.split("\n");
+		let currentSection = "";
+		let taskIndex = 0;
+		for (const line of lines) {
+			if (line.startsWith("## ")) {
+				currentSection = line.slice(3).trim();
+				continue;
+			}
+			const taskMatch = line.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
+			if (taskMatch) {
+				taskIndex++;
+				tasks.push({
+					id: `task-${taskIndex}`,
+					text: taskMatch[2].trim(),
+					completed: taskMatch[1].toLowerCase() === "x",
+					section: currentSection || void 0
+				});
+			}
+		}
+		return tasks;
+	}
+	/**
+	* Serialize a spec back to markdown
+	*/
+	serializeSpec(spec) {
+		let content = `# ${spec.name}\n\n`;
+		content += `## Purpose\n${spec.overview}\n\n`;
+		content += `## Requirements\n`;
+		for (const req of spec.requirements) {
+			content += `\n### Requirement: ${req.text}\n`;
+			for (const scenario of req.scenarios) content += `\n#### Scenario\n${scenario.rawText}\n`;
+		}
+		return content;
+	}
+};
+
+//#endregion
+//#region src/validator.ts
+/**
+* Validator for OpenSpec documents
+*/
+var Validator = class {
+	/**
+	* Validate a spec document
+	*/
+	validateSpec(spec) {
+		const issues = [];
+		if (!spec.overview || spec.overview.trim().length === 0) issues.push({
+			severity: "ERROR",
+			message: "Spec must have a Purpose/Overview section",
+			path: "overview"
+		});
+		if (spec.requirements.length === 0) issues.push({
+			severity: "ERROR",
+			message: "Spec must have at least one requirement",
+			path: "requirements"
+		});
+		for (const req of spec.requirements) {
+			if (!req.text.includes("SHALL") && !req.text.includes("MUST")) issues.push({
+				severity: "WARNING",
+				message: `Requirement should contain "SHALL" or "MUST": ${req.id}`,
+				path: `requirements.${req.id}`
+			});
+			if (req.scenarios.length === 0) issues.push({
+				severity: "WARNING",
+				message: `Requirement should have at least one scenario: ${req.id}`,
+				path: `requirements.${req.id}.scenarios`
+			});
+			if (req.text.length > 1e3) issues.push({
+				severity: "WARNING",
+				message: `Requirement text is too long (max 1000 chars): ${req.id}`,
+				path: `requirements.${req.id}.text`
+			});
+		}
+		return {
+			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
+			issues
+		};
+	}
+	/**
+	* Validate a change proposal
+	*/
+	validateChange(change) {
+		const issues = [];
+		if (!change.why || change.why.length < 50) issues.push({
+			severity: "ERROR",
+			message: "Change \"Why\" section must be at least 50 characters",
+			path: "why"
+		});
+		if (change.why && change.why.length > 500) issues.push({
+			severity: "WARNING",
+			message: "Change \"Why\" section should be under 500 characters",
+			path: "why"
+		});
+		if (!change.whatChanges || change.whatChanges.trim().length === 0) issues.push({
+			severity: "ERROR",
+			message: "Change must have a \"What Changes\" section",
+			path: "whatChanges"
+		});
+		if (change.deltas.length === 0) issues.push({
+			severity: "WARNING",
+			message: "Change should have at least one delta",
+			path: "deltas"
+		});
+		if (change.deltas.length > 50) issues.push({
+			severity: "WARNING",
+			message: "Change has too many deltas (max 50)",
+			path: "deltas"
+		});
+		return {
+			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
+			issues
+		};
+	}
+};
+
+//#endregion
+//#region src/reactive-fs/reactive-state.ts
+/**
+* 全局的 AsyncLocalStorage，用于在异步调用链中传递 ReactiveContext
+* 这是实现依赖收集的核心机制
+*/
+const contextStorage = new AsyncLocalStorage();
+/**
+* 响应式状态类，类似 Signal.State
+*
+* 核心机制：
+* - get() 时自动注册到当前 ReactiveContext 的依赖列表
+* - set() 时如果值变化，通知所有依赖的 Context
+*/
+var ReactiveState = class {
+	currentValue;
+	equals;
+	/** 所有依赖此状态的 Context */
+	subscribers = /* @__PURE__ */ new Set();
+	constructor(initialValue, options) {
+		this.currentValue = initialValue;
+		this.equals = options?.equals ?? ((a, b) => a === b);
+	}
+	/**
+	* 获取当前值
+	* 如果在 ReactiveContext 中调用，会自动注册依赖
+	*/
+	get() {
+		const context = contextStorage.getStore();
+		if (context) {
+			context.track(this);
+			this.subscribers.add(context);
+		}
+		return this.currentValue;
+	}
+	/**
+	* 设置新值
+	* 如果值变化，通知所有订阅者
+	* @returns 是否发生了变化
+	*/
+	set(newValue) {
+		if (this.equals(this.currentValue, newValue)) return false;
+		this.currentValue = newValue;
+		for (const context of this.subscribers) context.notifyChange();
+		return true;
+	}
+	/**
+	* 取消订阅
+	* 当 Context 销毁时调用
+	*/
+	unsubscribe(context) {
+		this.subscribers.delete(context);
+	}
+	/**
+	* 获取当前订阅者数量（用于调试）
+	*/
+	get subscriberCount() {
+		return this.subscribers.size;
+	}
+};
+
+//#endregion
+//#region src/reactive-fs/reactive-context.ts
+function createPromiseWithResolvers() {
+	let resolve$1;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve$1 = res;
+			reject = rej;
+		}),
+		resolve: resolve$1,
+		reject
+	};
+}
+/**
+* 响应式上下文，管理依赖收集和变更通知
+*
+* 核心机制：
+* - 在 stream() 中执行任务时，通过 AsyncLocalStorage 传递 this
+* - 任务中的所有 ReactiveState.get() 调用都会自动注册依赖
+* - 当任何依赖变更时，重新执行任务并 yield 新结果
+*/
+var ReactiveContext = class {
+	/** 当前追踪的依赖 */
+	dependencies = /* @__PURE__ */ new Set();
+	/** 等待变更的 Promise */
+	changePromise;
+	/** 是否已销毁 */
+	destroyed = false;
+	/**
+	* 追踪依赖
+	* 由 ReactiveState.get() 调用
+	*/
+	track(state) {
+		if (!this.destroyed) this.dependencies.add(state);
+	}
+	/**
+	* 通知变更
+	* 由 ReactiveState.set() 调用
+	*/
+	notifyChange() {
+		if (!this.destroyed && this.changePromise) this.changePromise.resolve();
+	}
+	/**
+	* 运行响应式任务流
+	* 每次依赖变更时重新执行任务并 yield 结果
+	*
+	* @param task 要执行的异步任务
+	* @param signal 用于取消的 AbortSignal
+	*/
+	async *stream(task, signal) {
+		try {
+			while (!signal?.aborted && !this.destroyed) {
+				this.clearDependencies();
+				this.changePromise = createPromiseWithResolvers();
+				yield await contextStorage.run(this, task);
+				if (this.dependencies.size === 0) break;
+				await Promise.race([this.changePromise.promise, signal ? this.waitForAbort(signal) : new Promise(() => {})]);
+				if (signal?.aborted) break;
+			}
+		} finally {
+			this.destroy();
+		}
+	}
+	/**
+	* 执行一次任务（非响应式）
+	* 用于初始数据获取
+	*/
+	async runOnce(task) {
+		return contextStorage.run(this, task);
+	}
+	/**
+	* 清理依赖
+	*/
+	clearDependencies() {
+		for (const state of this.dependencies) state.unsubscribe(this);
+		this.dependencies.clear();
+	}
+	/**
+	* 销毁上下文
+	* @param reason 可选的销毁原因，如果提供则 reject changePromise
+	*/
+	destroy(reason) {
+		this.destroyed = true;
+		this.clearDependencies();
+		if (reason && this.changePromise) this.changePromise.reject(reason);
+		this.changePromise = void 0;
+	}
+	/**
+	* 等待 AbortSignal
+	*/
+	waitForAbort(signal) {
+		return new Promise((_, reject) => {
+			if (signal.aborted) {
+				reject(new DOMException("Aborted", "AbortError"));
+				return;
+			}
+			signal.addEventListener("abort", () => {
+				reject(new DOMException("Aborted", "AbortError"));
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/reactive-fs/project-watcher.ts
+/**
+* 获取路径的真实路径（解析符号链接）
+* 在 macOS 上，/var 是 /private/var 的符号链接
+*/
+function getRealPath$1(path) {
+	try {
+		return realpathSync(resolve(path));
+	} catch {
+		return resolve(path);
+	}
+}
+/** 默认防抖时间 (ms) */
+const DEBOUNCE_MS$1 = 50;
+/** 默认忽略模式 */
+const DEFAULT_IGNORE = [
+	"node_modules",
+	".git",
+	"**/.DS_Store"
+];
+/** 健康检查间隔 (ms) - 3秒 */
+const HEALTH_CHECK_INTERVAL_MS = 3e3;
+/**
+* 项目监听器
+*
+* 使用 @parcel/watcher 监听项目根目录，
+* 然后通过路径前缀匹配分发事件给订阅者。
+*
+* 特性：
+* - 单个 watcher 监听整个项目
+* - 自动处理新创建的目录
+* - 内置防抖机制
+* - 高性能原生实现
+*/
+var ProjectWatcher = class {
+	projectDir;
+	subscription = null;
+	pathSubscriptions = /* @__PURE__ */ new Map();
+	pendingEvents = [];
+	debounceTimer = null;
+	debounceMs;
+	ignore;
+	initialized = false;
+	initPromise = null;
+	healthCheckTimer = null;
+	lastEventTime = 0;
+	healthCheckPending = false;
+	enableHealthCheck;
+	reinitializeTimer = null;
+	reinitializePending = false;
+	constructor(projectDir, options = {}) {
+		this.projectDir = getRealPath$1(projectDir);
+		this.debounceMs = options.debounceMs ?? DEBOUNCE_MS$1;
+		this.ignore = options.ignore ?? DEFAULT_IGNORE;
+		this.enableHealthCheck = options.enableHealthCheck ?? true;
+	}
+	/**
+	* 初始化 watcher
+	* 懒加载，首次订阅时自动调用
+	*/
+	async init() {
+		if (this.initialized) return;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.doInit();
+		await this.initPromise;
+	}
+	async doInit() {
+		this.subscription = await (await import("@parcel/watcher")).subscribe(this.projectDir, (err, events) => {
+			if (err) {
+				this.handleWatcherError(err);
+				return;
+			}
+			this.handleEvents(events);
+		}, { ignore: this.ignore });
+		this.initialized = true;
+		this.lastEventTime = Date.now();
+		if (this.enableHealthCheck) this.startHealthCheck();
+	}
+	/**
+	* 处理 watcher 错误
+	* 对于 FSEvents dropped 错误，触发延迟重建
+	*/
+	handleWatcherError(err) {
+		if ((err.message || String(err)).includes("Events were dropped")) {
+			if (!this.reinitializePending) {
+				console.warn("[ProjectWatcher] FSEvents dropped events, scheduling reinitialize...");
+				this.scheduleReinitialize();
+			}
+			return;
+		}
+		console.error("[ProjectWatcher] Error:", err);
+	}
+	/**
+	* 延迟重建 watcher（防抖，避免频繁重建）
+	*/
+	scheduleReinitialize() {
+		if (this.reinitializePending) return;
+		this.reinitializePending = true;
+		if (this.reinitializeTimer) clearTimeout(this.reinitializeTimer);
+		this.reinitializeTimer = setTimeout(() => {
+			this.reinitializeTimer = null;
+			this.reinitializePending = false;
+			console.log("[ProjectWatcher] Reinitializing due to FSEvents error...");
+			this.reinitialize();
+		}, 1e3);
+	}
+	/**
+	* 处理原始事件
+	*/
+	handleEvents(events) {
+		this.lastEventTime = Date.now();
+		this.healthCheckPending = false;
+		const watchEvents = events.map((e) => ({
+			type: e.type,
+			path: e.path
+		}));
+		this.pendingEvents.push(...watchEvents);
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(() => {
+			this.flushEvents();
+		}, this.debounceMs);
+	}
+	/**
+	* 分发事件给订阅者
+	*/
+	flushEvents() {
+		const events = this.pendingEvents;
+		this.pendingEvents = [];
+		this.debounceTimer = null;
+		if (events.length === 0) return;
+		for (const sub of this.pathSubscriptions.values()) {
+			const matchedEvents = events.filter((e) => this.matchPath(e, sub));
+			if (matchedEvents.length > 0) try {
+				sub.callback(matchedEvents);
+			} catch (err) {
+				console.error(`[ProjectWatcher] Callback error for ${sub.path}:`, err);
+			}
+		}
+	}
+	/**
+	* 检查事件是否匹配订阅
+	*/
+	matchPath(event, sub) {
+		const eventPath = event.path;
+		if (sub.watchChildren) return eventPath.startsWith(sub.path + "/") || eventPath === sub.path;
+		else {
+			const eventDir = dirname(eventPath);
+			return eventPath === sub.path || eventDir === sub.path;
+		}
+	}
+	/**
+	* 同步订阅路径变更（watcher 必须已初始化）
+	*
+	* 这是同步版本，用于在 watcher 已初始化后快速注册订阅。
+	* 如果 watcher 未初始化，抛出错误。
+	*
+	* @param path 要监听的路径
+	* @param callback 变更回调
+	* @param options 订阅选项
+	* @returns 取消订阅函数
+	*/
+	subscribeSync(path, callback, options = {}) {
+		if (!this.initialized) throw new Error("ProjectWatcher not initialized. Call init() first.");
+		const normalizedPath = getRealPath$1(path);
+		const id = Symbol();
+		this.pathSubscriptions.set(id, {
+			path: normalizedPath,
+			watchChildren: options.watchChildren ?? false,
+			callback
+		});
+		return () => {
+			this.pathSubscriptions.delete(id);
+		};
+	}
+	/**
+	* 订阅路径变更（异步版本，自动初始化）
+	*
+	* @param path 要监听的路径
+	* @param callback 变更回调
+	* @param options 订阅选项
+	* @returns 取消订阅函数
+	*/
+	async subscribe(path, callback, options = {}) {
+		await this.init();
+		return this.subscribeSync(path, callback, options);
+	}
+	/**
+	* 获取当前订阅数量（用于调试）
+	*/
+	get subscriptionCount() {
+		return this.pathSubscriptions.size;
+	}
+	/**
+	* 检查是否已初始化
+	*/
+	get isInitialized() {
+		return this.initialized;
+	}
+	/**
+	* 启动健康检查定时器
+	*/
+	startHealthCheck() {
+		this.stopHealthCheck();
+		this.healthCheckTimer = setInterval(() => {
+			this.performHealthCheck();
+		}, HEALTH_CHECK_INTERVAL_MS);
+		this.healthCheckTimer.unref();
+	}
+	/**
+	* 停止健康检查定时器
+	*/
+	stopHealthCheck() {
+		if (this.healthCheckTimer) {
+			clearInterval(this.healthCheckTimer);
+			this.healthCheckTimer = null;
+		}
+		this.healthCheckPending = false;
+	}
+	/**
+	* 执行健康检查
+	*
+	* 工作流程：
+	* 1. 如果最近有事件，无需检查
+	* 2. 如果上次探测还在等待中，说明 watcher 可能失效，尝试重建
+	* 3. 否则，创建临时文件触发事件，等待下次检查验证
+	*/
+	async performHealthCheck() {
+		if (Date.now() - this.lastEventTime < HEALTH_CHECK_INTERVAL_MS) {
+			this.healthCheckPending = false;
+			return;
+		}
+		if (this.healthCheckPending) {
+			console.warn("[ProjectWatcher] Health check failed, watcher appears stale. Reinitializing...");
+			await this.reinitialize();
+			return;
+		}
+		this.healthCheckPending = true;
+		this.sendProbe();
+	}
+	/**
+	* 发送探测：通过 utimesSync 修改项目目录的时间戳来触发 watcher 事件
+	*/
+	sendProbe() {
+		try {
+			const now = /* @__PURE__ */ new Date();
+			utimesSync(this.projectDir, now, now);
+		} catch {}
+	}
+	/**
+	* 重新初始化 watcher
+	*/
+	async reinitialize() {
+		this.stopHealthCheck();
+		if (this.subscription) {
+			try {
+				await this.subscription.unsubscribe();
+			} catch {}
+			this.subscription = null;
+		}
+		this.initialized = false;
+		this.initPromise = null;
+		this.healthCheckPending = false;
+		if (!existsSync(this.projectDir)) {
+			console.warn("[ProjectWatcher] Project directory does not exist, waiting for it to be created...");
+			this.waitForProjectDir();
+			return;
+		}
+		try {
+			await this.init();
+			console.log("[ProjectWatcher] Reinitialized successfully");
+		} catch (err) {
+			console.error("[ProjectWatcher] Failed to reinitialize:", err);
+			setTimeout(() => this.reinitialize(), HEALTH_CHECK_INTERVAL_MS);
+		}
+	}
+	/**
+	* 等待项目目录被创建
+	*/
+	waitForProjectDir() {
+		const checkInterval = setInterval(() => {
+			if (existsSync(this.projectDir)) {
+				clearInterval(checkInterval);
+				console.log("[ProjectWatcher] Project directory created, reinitializing...");
+				this.reinitialize();
+			}
+		}, HEALTH_CHECK_INTERVAL_MS);
+		checkInterval.unref();
+	}
+	/**
+	* 关闭 watcher
+	*/
+	async close() {
+		this.stopHealthCheck();
+		if (this.debounceTimer) {
+			clearTimeout(this.debounceTimer);
+			this.debounceTimer = null;
+		}
+		if (this.reinitializeTimer) {
+			clearTimeout(this.reinitializeTimer);
+			this.reinitializeTimer = null;
+		}
+		this.reinitializePending = false;
+		if (this.subscription) {
+			await this.subscription.unsubscribe();
+			this.subscription = null;
+		}
+		this.pathSubscriptions.clear();
+		this.pendingEvents = [];
+		this.initialized = false;
+		this.initPromise = null;
+	}
+};
+/**
+* 全局 ProjectWatcher 实例缓存
+* key: 项目目录路径
+*/
+const watcherCache = /* @__PURE__ */ new Map();
+/**
+* 获取或创建项目监听器
+*/
+function getProjectWatcher(projectDir, options) {
+	const normalizedDir = getRealPath$1(projectDir);
+	let watcher = watcherCache.get(normalizedDir);
+	if (!watcher) {
+		watcher = new ProjectWatcher(normalizedDir, options);
+		watcherCache.set(normalizedDir, watcher);
+	}
+	return watcher;
+}
+/**
+* 关闭所有 ProjectWatcher（用于测试清理）
+*/
+async function closeAllProjectWatchers() {
+	const closePromises = Array.from(watcherCache.values()).map((w) => w.close());
+	await Promise.all(closePromises);
+	watcherCache.clear();
+}
+
+//#endregion
+//#region src/reactive-fs/watcher-pool.ts
+/**
+* 获取路径的真实路径（解析符号链接）
+*/
+function getRealPath(path) {
+	try {
+		return realpathSync(resolve(path));
+	} catch {
+		return resolve(path);
+	}
+}
+/**
+* 全局 ProjectWatcher 实例
+* 通过 initWatcherPool 初始化
+*/
+let globalProjectWatcher = null;
+let globalProjectDir = null;
+/** 默认防抖时间 (ms) */
+const DEBOUNCE_MS = 100;
+/** 路径订阅缓存 */
+const subscriptionCache = /* @__PURE__ */ new Map();
+/** 防抖定时器 */
+const debounceTimers = /* @__PURE__ */ new Map();
+/**
+* 初始化 watcher pool
+*
+* 必须在使用 acquireWatcher 之前调用。
+* 通常由 server 在启动时调用。
+*
+* @param projectDir 项目根目录
+*/
+async function initWatcherPool(projectDir) {
+	const normalizedDir = getRealPath(projectDir);
+	if (globalProjectWatcher && globalProjectDir === normalizedDir) return;
+	if (globalProjectWatcher) await globalProjectWatcher.close();
+	globalProjectDir = normalizedDir;
+	globalProjectWatcher = getProjectWatcher(normalizedDir);
+	await globalProjectWatcher.init();
+}
+/**
+* 获取或创建文件/目录监听器
+*
+* 特性：
+* - 使用 @parcel/watcher 监听项目根目录
+* - 自动处理新创建的目录（解决 init 后无法监听的问题）
+* - 同一路径共享订阅
+* - 引用计数管理生命周期
+* - 内置防抖机制
+*
+* @param path 要监听的路径
+* @param onChange 变更回调
+* @param options 监听选项
+* @returns 释放函数，调用后取消订阅
+*/
+function acquireWatcher(path, onChange, options = {}) {
+	if (!globalProjectWatcher || !globalProjectWatcher.isInitialized) return () => {};
+	const normalizedPath = getRealPath(path);
+	const debounceMs = options.debounceMs ?? DEBOUNCE_MS;
+	const isRecursive = options.recursive ?? false;
+	const cacheKey = `${normalizedPath}:${isRecursive}`;
+	let subscription = subscriptionCache.get(cacheKey);
+	if (!subscription) {
+		const unsubscribe = globalProjectWatcher.subscribeSync(normalizedPath, () => {
+			const existingTimer = debounceTimers.get(cacheKey);
+			if (existingTimer) clearTimeout(existingTimer);
+			const timer = setTimeout(() => {
+				debounceTimers.delete(cacheKey);
+				const currentSub = subscriptionCache.get(cacheKey);
+				if (currentSub) for (const cb of currentSub.callbacks) try {
+					cb();
+				} catch (err) {
+					console.error(`[watcher-pool] Callback error for ${normalizedPath}:`, err);
+				}
+			}, debounceMs);
+			debounceTimers.set(cacheKey, timer);
+		}, { watchChildren: isRecursive });
+		subscription = {
+			path: normalizedPath,
+			callbacks: /* @__PURE__ */ new Set(),
+			unsubscribe,
+			onError: options.onError
+		};
+		subscriptionCache.set(cacheKey, subscription);
+	}
+	subscription.callbacks.add(onChange);
+	return () => {
+		const currentSub = subscriptionCache.get(cacheKey);
+		if (!currentSub) return;
+		currentSub.callbacks.delete(onChange);
+		if (currentSub.callbacks.size === 0) {
+			currentSub.unsubscribe();
+			subscriptionCache.delete(cacheKey);
+			const timer = debounceTimers.get(cacheKey);
+			if (timer) {
+				clearTimeout(timer);
+				debounceTimers.delete(cacheKey);
+			}
+		}
+	};
+}
+/**
+* 获取当前活跃的监听器数量（用于调试）
+*/
+function getActiveWatcherCount() {
+	return subscriptionCache.size;
+}
+/**
+* 关闭所有监听器（用于测试清理）
+*/
+async function closeAllWatchers() {
+	for (const [key, sub] of subscriptionCache) {
+		sub.unsubscribe();
+		const timer = debounceTimers.get(key);
+		if (timer) clearTimeout(timer);
+	}
+	subscriptionCache.clear();
+	debounceTimers.clear();
+	if (globalProjectWatcher) {
+		await globalProjectWatcher.close();
+		globalProjectWatcher = null;
+		globalProjectDir = null;
+	}
+}
+/**
+* 检查 watcher pool 是否已初始化
+*/
+function isWatcherPoolInitialized() {
+	return globalProjectWatcher !== null && globalProjectWatcher.isInitialized;
+}
+/**
+* 获取当前监听的项目目录
+*/
+function getWatchedProjectDir() {
+	return globalProjectDir;
+}
+
+//#endregion
+//#region src/reactive-fs/reactive-fs.ts
+/** 状态缓存：路径 -> ReactiveState */
+const stateCache$1 = /* @__PURE__ */ new Map();
+/** 监听器释放函数缓存 */
+const releaseCache$1 = /* @__PURE__ */ new Map();
+/**
+* 响应式读取文件内容
+*
+* 特性：
+* - 自动注册文件监听
+* - 文件变更时自动更新状态
+* - 在 ReactiveContext 中调用时自动追踪依赖
+* - 支持监听尚未创建的文件（通过 @parcel/watcher）
+*
+* @param filepath 文件路径
+* @returns 文件内容，文件不存在时返回 null
+*/
+async function reactiveReadFile(filepath) {
+	const normalizedPath = resolve(filepath);
+	const key = `file:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			return await readFile$1(normalizedPath, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+	let state = stateCache$1.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue());
+		stateCache$1.set(key, state);
+		const release = acquireWatcher(dirname(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		}, { onError: () => {
+			stateCache$1.delete(key);
+			releaseCache$1.delete(key);
+		} });
+		releaseCache$1.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式读取目录内容
+*
+* 特性：
+* - 自动注册目录监听
+* - 目录变更时自动更新状态
+* - 在 ReactiveContext 中调用时自动追踪依赖
+* - 支持监听尚未创建的目录（通过 @parcel/watcher）
+*
+* @param dirpath 目录路径
+* @param options 选项
+* @returns 目录项名称数组
+*/
+async function reactiveReadDir(dirpath, options = {}) {
+	const normalizedPath = resolve(dirpath);
+	const key = `dir:${normalizedPath}:${JSON.stringify(options)}`;
+	const getValue = async () => {
+		try {
+			return (await readdir(normalizedPath, { withFileTypes: true })).filter((entry) => {
+				if (!options.includeHidden && entry.name.startsWith(".")) return false;
+				if (options.exclude?.includes(entry.name)) return false;
+				if (options.directoriesOnly && !entry.isDirectory()) return false;
+				if (options.filesOnly && !entry.isFile()) return false;
+				return true;
+			}).map((entry) => entry.name);
+		} catch {
+			return [];
+		}
+	};
+	let state = stateCache$1.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue(), { equals: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) });
+		stateCache$1.set(key, state);
+		const release = acquireWatcher(normalizedPath, async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		}, {
+			recursive: true,
+			onError: () => {
+				stateCache$1.delete(key);
+				releaseCache$1.delete(key);
+			}
+		});
+		releaseCache$1.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式检查路径是否存在
+*
+* @param path 路径
+* @returns 是否存在
+*/
+async function reactiveExists(path) {
+	const normalizedPath = resolve(path);
+	const key = `exists:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			await stat(normalizedPath);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	let state = stateCache$1.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue());
+		stateCache$1.set(key, state);
+		const release = acquireWatcher(dirname(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		}, { onError: () => {
+			stateCache$1.delete(key);
+			releaseCache$1.delete(key);
+		} });
+		releaseCache$1.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式获取文件/目录的 stat 信息
+*
+* @param path 路径
+* @returns stat 信息，不存在时返回 null
+*/
+async function reactiveStat(path) {
+	const normalizedPath = resolve(path);
+	const key = `stat:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			const s = await stat(normalizedPath);
+			return {
+				isDirectory: s.isDirectory(),
+				isFile: s.isFile(),
+				mtime: s.mtime.getTime(),
+				birthtime: s.birthtime.getTime()
+			};
+		} catch {
+			return null;
+		}
+	};
+	let state = stateCache$1.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue(), { equals: (a, b) => {
+			if (a === null && b === null) return true;
+			if (a === null || b === null) return false;
+			return a.isDirectory === b.isDirectory && a.isFile === b.isFile && a.mtime === b.mtime && a.birthtime === b.birthtime;
+		} });
+		stateCache$1.set(key, state);
+		const release = acquireWatcher(dirname(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		}, { onError: () => {
+			stateCache$1.delete(key);
+			releaseCache$1.delete(key);
+		} });
+		releaseCache$1.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 清除指定路径的缓存（用于测试）
+*/
+function clearCache(path) {
+	if (path) {
+		const normalizedPath = resolve(path);
+		for (const [key, release] of releaseCache$1) if (key.includes(normalizedPath)) {
+			release();
+			releaseCache$1.delete(key);
+			stateCache$1.delete(key);
+		}
+	} else {
+		for (const release of releaseCache$1.values()) release();
+		releaseCache$1.clear();
+		stateCache$1.clear();
+	}
+}
+/**
+* 获取缓存大小（用于调试）
+*/
+function getCacheSize() {
+	return stateCache$1.size;
+}
+
+//#endregion
+//#region src/adapter.ts
+/**
+* OpenSpec filesystem adapter
+* Handles reading, writing, and managing OpenSpec files
+*/
+var OpenSpecAdapter = class {
+	parser = new MarkdownParser();
+	validator = new Validator();
+	constructor(projectDir) {
+		this.projectDir = projectDir;
+	}
+	get openspecDir() {
+		return join(this.projectDir, "openspec");
+	}
+	get specsDir() {
+		return join(this.openspecDir, "specs");
+	}
+	get changesDir() {
+		return join(this.openspecDir, "changes");
+	}
+	get archiveDir() {
+		return join(this.changesDir, "archive");
+	}
+	async isInitialized() {
+		return (await reactiveStat(this.openspecDir))?.isDirectory ?? false;
+	}
+	/** File time info derived from filesystem (reactive) */
+	async getFileTimeInfo(filePath) {
+		const statInfo = await reactiveStat(filePath);
+		if (!statInfo) return null;
+		return {
+			createdAt: statInfo.birthtime,
+			updatedAt: statInfo.mtime
+		};
+	}
+	async listSpecs() {
+		return reactiveReadDir(this.specsDir, { directoriesOnly: true });
+	}
+	/**
+	* List specs with metadata (id, name, and time info)
+	* Only returns specs that have valid spec.md
+	* Sorted by updatedAt descending (most recent first)
+	*/
+	async listSpecsWithMeta() {
+		const ids = await this.listSpecs();
+		return (await Promise.all(ids.map(async (id) => {
+			const spec = await this.readSpec(id);
+			if (!spec) return null;
+			const specPath = join(this.specsDir, id, "spec.md");
+			const timeInfo = await this.getFileTimeInfo(specPath);
+			return {
+				id,
+				name: spec.name,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
+			};
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+	}
+	async listChanges() {
+		return reactiveReadDir(this.changesDir, {
+			directoriesOnly: true,
+			exclude: ["archive"]
+		});
+	}
+	/**
+	* List changes with metadata (id, name, progress, and time info)
+	* Only returns changes that have valid proposal.md
+	* Sorted by updatedAt descending (most recent first)
+	*/
+	async listChangesWithMeta() {
+		const ids = await this.listChanges();
+		return (await Promise.all(ids.map(async (id) => {
+			const change = await this.readChange(id);
+			if (!change) return null;
+			const proposalPath = join(this.changesDir, id, "proposal.md");
+			const timeInfo = await this.getFileTimeInfo(proposalPath);
+			return {
+				id,
+				name: change.name,
+				progress: change.progress,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
+			};
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+	}
+	async listArchivedChanges() {
+		return reactiveReadDir(this.archiveDir, { directoriesOnly: true });
+	}
+	/**
+	* List archived changes with metadata and time info
+	* Only returns archives that have valid proposal.md
+	* Sorted by updatedAt descending (most recent first)
+	*/
+	async listArchivedChangesWithMeta() {
+		const ids = await this.listArchivedChanges();
+		return (await Promise.all(ids.map(async (id) => {
+			const change = await this.readArchivedChange(id);
+			if (!change) return null;
+			const proposalPath = join(this.archiveDir, id, "proposal.md");
+			const timeInfo = await this.getFileTimeInfo(proposalPath);
+			return {
+				id,
+				name: change.name,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
+			};
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+	}
+	/**
+	* Read project.md content (reactive)
+	*/
+	async readProjectMd() {
+		return reactiveReadFile(join(this.openspecDir, "project.md"));
+	}
+	/**
+	* Read AGENTS.md content (reactive)
+	*/
+	async readAgentsMd() {
+		return reactiveReadFile(join(this.openspecDir, "AGENTS.md"));
+	}
+	/**
+	* Write project.md content
+	*/
+	async writeProjectMd(content) {
+		await writeFile(join(this.openspecDir, "project.md"), content, "utf-8");
+	}
+	/**
+	* Write AGENTS.md content
+	*/
+	async writeAgentsMd(content) {
+		await writeFile(join(this.openspecDir, "AGENTS.md"), content, "utf-8");
+	}
+	async readSpec(specId) {
+		try {
+			const content = await this.readSpecRaw(specId);
+			if (!content) return null;
+			return this.parser.parseSpec(specId, content);
+		} catch {
+			return null;
+		}
+	}
+	async readSpecRaw(specId) {
+		return reactiveReadFile(join(this.specsDir, specId, "spec.md"));
+	}
+	async readChange(changeId) {
+		try {
+			const raw = await this.readChangeRaw(changeId);
+			if (!raw) return null;
+			return this.parser.parseChange(changeId, raw.proposal, raw.tasks, {
+				design: raw.design,
+				deltaSpecs: raw.deltaSpecs
+			});
+		} catch {
+			return null;
+		}
+	}
+	async readChangeFiles(changeId) {
+		const changeRoot = join(this.changesDir, changeId);
+		return this.readFilesUnderRoot(changeRoot);
+	}
+	async readArchivedChangeFiles(changeId) {
+		const archiveRoot = join(this.archiveDir, changeId);
+		return this.readFilesUnderRoot(archiveRoot);
+	}
+	async readFilesUnderRoot(root) {
+		if (!(await reactiveStat(root))?.isDirectory) return [];
+		return (await this.collectChangeFiles(root, root)).sort((a, b) => {
+			if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+			return a.path.localeCompare(b.path);
+		});
+	}
+	async collectChangeFiles(root, dir) {
+		const names = await reactiveReadDir(dir, { includeHidden: false });
+		const files = [];
+		for (const name of names) {
+			const fullPath = join(dir, name);
+			const statInfo = await reactiveStat(fullPath);
+			if (!statInfo) continue;
+			const relativePath = fullPath.slice(root.length + 1);
+			if (statInfo.isDirectory) {
+				files.push({
+					path: relativePath,
+					type: "directory"
+				});
+				files.push(...await this.collectChangeFiles(root, fullPath));
+			} else {
+				const content = await reactiveReadFile(fullPath);
+				files.push({
+					path: relativePath,
+					type: "file",
+					content: content ?? void 0
+				});
+			}
+		}
+		return files;
+	}
+	async readChangeRaw(changeId) {
+		const changeDir = join(this.changesDir, changeId);
+		const proposalPath = join(changeDir, "proposal.md");
+		const tasksPath = join(changeDir, "tasks.md");
+		const designPath = join(changeDir, "design.md");
+		const specsDir = join(changeDir, "specs");
+		const [proposal, tasks, design] = await Promise.all([
+			reactiveReadFile(proposalPath),
+			reactiveReadFile(tasksPath),
+			reactiveReadFile(designPath)
+		]);
+		if (!proposal) return null;
+		const deltaSpecs = await this.readDeltaSpecs(specsDir);
+		return {
+			proposal,
+			tasks: tasks ?? "",
+			design: design ?? void 0,
+			deltaSpecs
+		};
+	}
+	/** Read delta specs from a specs directory */
+	async readDeltaSpecs(specsDir) {
+		const specIds = await reactiveReadDir(specsDir, { directoriesOnly: true });
+		const deltaSpecs = [];
+		for (const specId of specIds) {
+			const content = await reactiveReadFile(join(specsDir, specId, "spec.md"));
+			if (content) deltaSpecs.push({
+				specId,
+				content
+			});
+		}
+		return deltaSpecs;
+	}
+	/**
+	* Read an archived change
+	*/
+	async readArchivedChange(changeId) {
+		try {
+			const raw = await this.readArchivedChangeRaw(changeId);
+			if (!raw) return null;
+			return this.parser.parseChange(changeId, raw.proposal, raw.tasks, {
+				design: raw.design,
+				deltaSpecs: raw.deltaSpecs
+			});
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Read raw archived change files (reactive)
+	*/
+	async readArchivedChangeRaw(changeId) {
+		const archiveChangeDir = join(this.archiveDir, changeId);
+		const proposalPath = join(archiveChangeDir, "proposal.md");
+		const tasksPath = join(archiveChangeDir, "tasks.md");
+		const designPath = join(archiveChangeDir, "design.md");
+		const specsDir = join(archiveChangeDir, "specs");
+		const [proposal, tasks, design] = await Promise.all([
+			reactiveReadFile(proposalPath),
+			reactiveReadFile(tasksPath),
+			reactiveReadFile(designPath)
+		]);
+		if (!proposal) return null;
+		const deltaSpecs = await this.readDeltaSpecs(specsDir);
+		return {
+			proposal,
+			tasks: tasks ?? "",
+			design: design ?? void 0,
+			deltaSpecs
+		};
+	}
+	async writeSpec(specId, content) {
+		const specDir = join(this.specsDir, specId);
+		await mkdir(specDir, { recursive: true });
+		await writeFile(join(specDir, "spec.md"), content, "utf-8");
+	}
+	async writeChange(changeId, proposal, tasks) {
+		const changeDir = join(this.changesDir, changeId);
+		await mkdir(changeDir, { recursive: true });
+		await writeFile(join(changeDir, "proposal.md"), proposal, "utf-8");
+		if (tasks !== void 0) await writeFile(join(changeDir, "tasks.md"), tasks, "utf-8");
+	}
+	async archiveChange(changeId) {
+		try {
+			const changeDir = join(this.changesDir, changeId);
+			const archivePath = join(this.archiveDir, changeId);
+			await mkdir(this.archiveDir, { recursive: true });
+			await rename(changeDir, archivePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async init() {
+		await mkdir(this.specsDir, { recursive: true });
+		await mkdir(this.changesDir, { recursive: true });
+		await mkdir(this.archiveDir, { recursive: true });
+		await writeFile(join(this.openspecDir, "project.md"), `# Project Specification
+
+## Overview
+This project uses OpenSpec for spec-driven development.
+
+## Structure
+- \`specs/\` - Source of truth specifications
+- \`changes/\` - Active change proposals
+- \`changes/archive/\` - Completed changes
+`, "utf-8");
+		await writeFile(join(this.openspecDir, "AGENTS.md"), `# AI Agent Instructions
+
+This project uses OpenSpec for spec-driven development.
+
+## Available Commands
+- \`openspec list\` - List changes or specs
+- \`openspec view\` - Dashboard view
+- \`openspec show <name>\` - Show change or spec details
+- \`openspec validate <name>\` - Validate change or spec
+- \`openspec archive <change>\` - Archive completed change
+
+## Workflow
+1. Create a change proposal in \`changes/<change-id>/proposal.md\`
+2. Define delta specs in \`changes/<change-id>/specs/\`
+3. Track tasks in \`changes/<change-id>/tasks.md\`
+4. Implement and mark tasks complete
+5. Archive when done: \`openspec archive <change-id>\`
+`, "utf-8");
+	}
+	/**
+	* Toggle a task's completion status in tasks.md
+	* @param changeId - The change ID
+	* @param taskIndex - 1-based task index
+	* @param completed - New completion status
+	*/
+	async toggleTask(changeId, taskIndex, completed) {
+		try {
+			const tasksPath = join(this.changesDir, changeId, "tasks.md");
+			const lines = (await readFile(tasksPath, "utf-8")).split("\n");
+			let currentTaskIndex = 0;
+			for (let i = 0; i < lines.length; i++) {
+				const taskMatch = lines[i].match(/^([-*]\s+)\[([ xX])\](\s+.*)$/);
+				if (taskMatch) {
+					currentTaskIndex++;
+					if (currentTaskIndex === taskIndex) {
+						const prefix = taskMatch[1];
+						const suffix = taskMatch[3];
+						lines[i] = `${prefix}${completed ? "[x]" : "[ ]"}${suffix}`;
+						break;
+					}
+				}
+			}
+			if (currentTaskIndex < taskIndex) return false;
+			await writeFile(tasksPath, lines.join("\n"), "utf-8");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async validateSpec(specId) {
+		const spec = await this.readSpec(specId);
+		if (!spec) return {
+			valid: false,
+			issues: [{
+				severity: "ERROR",
+				message: `Spec '${specId}' not found`
+			}]
+		};
+		return this.validator.validateSpec(spec);
+	}
+	async validateChange(changeId) {
+		const change = await this.readChange(changeId);
+		if (!change) return {
+			valid: false,
+			issues: [{
+				severity: "ERROR",
+				message: `Change '${changeId}' not found`
+			}]
+		};
+		return this.validator.validateChange(change);
+	}
+	async getDashboardData() {
+		const [specIds, changeIds, archivedIds] = await Promise.all([
+			this.listSpecs(),
+			this.listChanges(),
+			this.listArchivedChanges()
+		]);
+		const specs = await Promise.all(specIds.map((id) => this.readSpec(id)));
+		const changes = await Promise.all(changeIds.map((id) => this.readChange(id)));
+		const validSpecs = specs.filter((s) => s !== null);
+		const validChanges = changes.filter((c) => c !== null);
+		const totalRequirements = validSpecs.reduce((sum, s) => sum + s.requirements.length, 0);
+		const totalTasks = validChanges.reduce((sum, c) => sum + c.progress.total, 0);
+		const completedTasks = validChanges.reduce((sum, c) => sum + c.progress.completed, 0);
+		return {
+			specs: validSpecs,
+			changes: validChanges,
+			archivedCount: archivedIds.length,
+			summary: {
+				specCount: validSpecs.length,
+				requirementCount: totalRequirements,
+				activeChangeCount: validChanges.length,
+				archivedChangeCount: archivedIds.length,
+				totalTasks,
+				completedTasks,
+				progressPercent: totalTasks > 0 ? Math.round(completedTasks / totalTasks * 100) : 0
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/schemas.ts
+/**
+* Zod schemas and TypeScript types for OpenSpec documents.
+*
+* OpenSpec uses a structured format for specifications and change proposals:
+* - Spec: A specification document with requirements and scenarios
+* - Change: A change proposal with deltas and tasks
+* - Task: A trackable work item within a change
+*
+* @module schemas
+*/
+/**
+* File metadata for a change directory entry.
+*/
+const ChangeFileSchema = z.object({
+	path: z.string(),
+	type: z.enum(["file", "directory"]),
+	content: z.string().optional(),
+	size: z.number().optional()
+});
+/**
+* A requirement within a specification.
+* Requirements should use RFC 2119 keywords (SHALL, MUST, etc.)
+*/
+const RequirementSchema = z.object({
+	id: z.string(),
+	text: z.string(),
+	scenarios: z.array(z.object({ rawText: z.string() }))
+});
+/**
+* A specification document.
+* Located at: openspec/specs/{id}/spec.md
+*/
+const SpecSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	overview: z.string(),
+	requirements: z.array(RequirementSchema),
+	metadata: z.object({
+		version: z.string().default("1.0.0"),
+		format: z.literal("openspec").default("openspec"),
+		sourcePath: z.string().optional()
+	}).optional()
+});
+/**
+* A delta describes changes to a spec within a change proposal.
+* Deltas track which specs are affected and how.
+*/
+const DeltaOperationType = z.enum([
+	"ADDED",
+	"MODIFIED",
+	"REMOVED",
+	"RENAMED"
+]);
+const DeltaSchema = z.object({
+	spec: z.string(),
+	operation: DeltaOperationType,
+	description: z.string(),
+	requirement: RequirementSchema.optional(),
+	requirements: z.array(RequirementSchema).optional(),
+	rename: z.object({
+		from: z.string(),
+		to: z.string()
+	}).optional()
+});
+/**
+* A task within a change proposal.
+* Tasks are parsed from tasks.md using checkbox syntax: - [ ] or - [x]
+*/
+const TaskSchema = z.object({
+	id: z.string(),
+	text: z.string(),
+	completed: z.boolean(),
+	section: z.string().optional()
+});
+/**
+* A delta spec file from changes/{id}/specs/{specId}/spec.md
+* Contains the proposed changes to a spec
+*/
+const DeltaSpecSchema = z.object({
+	specId: z.string(),
+	content: z.string()
+});
+/**
+* A change proposal document.
+* Located at: openspec/changes/{id}/proposal.md + tasks.md
+*
+* Change proposals describe why a change is needed, what will change,
+* which specs are affected (deltas), and trackable tasks.
+*/
+const ChangeSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	why: z.string(),
+	whatChanges: z.string(),
+	deltas: z.array(DeltaSchema),
+	tasks: z.array(TaskSchema),
+	progress: z.object({
+		total: z.number(),
+		completed: z.number()
+	}),
+	design: z.string().optional(),
+	deltaSpecs: z.array(DeltaSpecSchema).optional(),
+	metadata: z.object({
+		version: z.string().default("1.0.0"),
+		format: z.literal("openspec-change").default("openspec-change")
+	}).optional()
+});
+
+//#endregion
+//#region src/watcher.ts
+/**
+* OpenSpec file watcher
+* Watches the openspec/ directory for changes and emits events
+*/
+var OpenSpecWatcher = class extends EventEmitter {
+	watchers = [];
+	debounceTimers = /* @__PURE__ */ new Map();
+	debounceMs;
+	constructor(projectDir, options = {}) {
+		super();
+		this.projectDir = projectDir;
+		this.debounceMs = options.debounceMs ?? 100;
+	}
+	get openspecDir() {
+		return join(this.projectDir, "openspec");
+	}
+	get specsDir() {
+		return join(this.openspecDir, "specs");
+	}
+	get changesDir() {
+		return join(this.openspecDir, "changes");
+	}
+	get archiveDir() {
+		return join(this.changesDir, "archive");
+	}
+	/**
+	* Start watching for file changes
+	*/
+	start() {
+		this.stop();
+		this.watchDir(this.specsDir, (filename, eventType) => {
+			const match = filename.match(/^([^/]+)\//);
+			if (match) this.emitDebounced(`spec:${match[1]}`, {
+				type: "spec",
+				action: eventType === "rename" ? "create" : "update",
+				id: match[1],
+				path: join(this.specsDir, filename),
+				timestamp: Date.now()
+			});
+		});
+		this.watchDir(this.changesDir, (filename, eventType) => {
+			if (filename.startsWith("archive/")) return;
+			const match = filename.match(/^([^/]+)\//);
+			if (match) this.emitDebounced(`change:${match[1]}`, {
+				type: "change",
+				action: eventType === "rename" ? "create" : "update",
+				id: match[1],
+				path: join(this.changesDir, filename),
+				timestamp: Date.now()
+			});
+		});
+		this.watchDir(this.archiveDir, (filename, eventType) => {
+			const match = filename.match(/^([^/]+)\//);
+			if (match) this.emitDebounced(`archive:${match[1]}`, {
+				type: "archive",
+				action: eventType === "rename" ? "create" : "update",
+				id: match[1],
+				path: join(this.archiveDir, filename),
+				timestamp: Date.now()
+			});
+		});
+		this.watchDir(this.openspecDir, (filename, eventType) => {
+			if (filename === "project.md" || filename === "AGENTS.md") this.emitDebounced(`project:${filename}`, {
+				type: "project",
+				action: eventType === "rename" ? "create" : "update",
+				path: join(this.openspecDir, filename),
+				timestamp: Date.now()
+			});
+		});
+		this.emit("started");
+	}
+	/**
+	* Stop watching for file changes
+	*/
+	stop() {
+		for (const watcher of this.watchers) watcher.close();
+		this.watchers = [];
+		for (const timer of this.debounceTimers.values()) clearTimeout(timer);
+		this.debounceTimers.clear();
+		this.emit("stopped");
+	}
+	/**
+	* Watch a directory recursively
+	*/
+	watchDir(dir, callback) {
+		try {
+			const watcher = watch(dir, { recursive: true }, (eventType, filename) => {
+				if (filename) callback(filename, eventType);
+			});
+			watcher.on("error", (error) => {
+				this.emit("error", error);
+			});
+			this.watchers.push(watcher);
+		} catch (error) {
+			this.emit("warning", `Could not watch ${dir}: ${error}`);
+		}
+	}
+	/**
+	* Emit event with debouncing to avoid duplicate events
+	*/
+	emitDebounced(key, event) {
+		const existing = this.debounceTimers.get(key);
+		if (existing) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.debounceTimers.delete(key);
+			this.emit("change", event);
+		}, this.debounceMs);
+		this.debounceTimers.set(key, timer);
+	}
+};
+/**
+* Create a file change observable for use with tRPC subscriptions
+*/
+function createFileChangeObservable(watcher) {
+	return { subscribe: (observer) => {
+		const changeHandler = (event) => {
+			observer.next(event);
+		};
+		const errorHandler = (error) => {
+			observer.error?.(error);
+		};
+		watcher.on("change", changeHandler);
+		watcher.on("error", errorHandler);
+		return { unsubscribe: () => {
+			watcher.off("change", changeHandler);
+			watcher.off("error", errorHandler);
+		} };
+	} };
+}
+
+//#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;
+/**
+* 解析 CLI 命令字符串为数组
+*
+* 支持两种格式：
+* 1. JSON 数组：以 `[` 开头，如 `["npx", "@fission-ai/openspec"]`
+* 2. 简单字符串：用空格分割，如 `npx @fission-ai/openspec`
+*
+* 注意：简单字符串解析不支持带引号的参数，如需复杂命令请使用 JSON 数组格式
+*/
+function parseCliCommand(command) {
+	const trimmed = command.trim();
+	if (trimmed.startsWith("[")) try {
+		const parsed = JSON.parse(trimmed);
+		if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) return parsed;
+		throw new Error("Invalid JSON array: expected array of strings");
+	} 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);
+}
+/**
+* 比较两个语义化版本号
+* @returns 正数表示 a > b，负数表示 a < b，0 表示相等
+*/
+function compareVersions(a, b) {
+	const parseVersion = (v) => {
+		return v.replace(/^v/, "").split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+	};
+	const aParts = parseVersion(a);
+	const bParts = parseVersion(b);
+	for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+		const aVal = aParts[i] ?? 0;
+		const bVal = bParts[i] ?? 0;
+		if (aVal !== bVal) return aVal - bVal;
+	}
+	return 0;
+}
+/**
+* 获取 npx 可用的最新版本
+*
+* 使用 `npx @fission-ai/openspec --version` 获取最新版本
+* 这会下载并执行最新版本，所以超时时间较长
+*/
+async function fetchLatestVersion() {
+	try {
+		const { stdout } = await execAsync("npx @fission-ai/openspec --version", { timeout: 6e4 });
+		return stdout.trim();
+	} catch {
+		return;
+	}
+}
+/**
+* 嗅探全局 openspec 命令（无缓存）
+*
+* 使用 `openspec --version` 检测是否有全局命令可用。
+* 同时检查 npm registry 上的最新版本。
+* 每次调用都会重新检测，不使用缓存。
+*/
+async function sniffGlobalCli() {
+	const [localResult, latestVersion] = await Promise.all([execAsync("openspec --version", { timeout: 1e4 }).catch((err) => ({ error: err })), fetchLatestVersion()]);
+	if ("error" in localResult) {
+		const error = localResult.error instanceof Error ? localResult.error.message : String(localResult.error);
+		if (error.includes("not found") || error.includes("ENOENT") || error.includes("not recognized")) return {
+			hasGlobal: false,
+			latestVersion,
+			hasUpdate: !!latestVersion
+		};
+		return {
+			hasGlobal: false,
+			latestVersion,
+			hasUpdate: !!latestVersion,
+			error
+		};
+	}
+	const version = localResult.stdout.trim();
+	detectedCliCommand = GLOBAL_CLI_COMMAND;
+	return {
+		hasGlobal: true,
+		version,
+		latestVersion,
+		hasUpdate: latestVersion ? compareVersions(latestVersion, version) > 0 : false
+	};
+}
+/**
+* 检测全局安装的 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();
+}
+/**
+* 获取默认 CLI 命令的字符串形式（用于 UI 显示）
+*/
+async function getDefaultCliCommandString() {
+	return (await detectCliCommand()).join(" ");
+}
+/**
+* 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({})
+});
+/** 默认配置（静态，用于测试和类型） */
+const DEFAULT_CONFIG = {
+	cli: {},
+	ui: { theme: "system" }
+};
+/**
+* 配置管理器
+*
+* 负责读写 openspec/.openspecui.json 配置文件。
+* 读取操作使用 reactiveReadFile，支持响应式更新。
+*/
+var ConfigManager = class {
+	configPath;
+	constructor(projectDir) {
+		this.configPath = join(projectDir, "openspec", ".openspecui.json");
+	}
+	/**
+	* 读取配置（响应式）
+	*
+	* 如果配置文件不存在，返回默认配置。
+	* 如果配置文件格式错误，返回默认配置并打印警告。
+	*/
+	async readConfig() {
+		const content = await reactiveReadFile(this.configPath);
+		if (!content) return DEFAULT_CONFIG;
+		try {
+			const parsed = JSON.parse(content);
+			const result = OpenSpecUIConfigSchema.safeParse(parsed);
+			if (result.success) return result.data;
+			console.warn("Invalid config format, using defaults:", result.error.message);
+			return DEFAULT_CONFIG;
+		} catch (err) {
+			console.warn("Failed to parse config, using defaults:", err);
+			return DEFAULT_CONFIG;
+		}
+	}
+	/**
+	* 写入配置
+	*
+	* 会触发文件监听，自动更新订阅者。
+	*/
+	async writeConfig(config) {
+		const current = await this.readConfig();
+		const merged = {
+			...current,
+			...config,
+			cli: {
+				...current.cli,
+				...config.cli
+			},
+			ui: {
+				...current.ui,
+				...config.ui
+			}
+		};
+		await writeFile(this.configPath, JSON.stringify(merged, null, 2), "utf-8");
+	}
+	/**
+	* 获取 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();
+	}
+	/**
+	* 获取 CLI 命令的字符串形式（用于 UI 显示）
+	*/
+	async getCliCommandString() {
+		return (await this.getCliCommand()).join(" ");
+	}
+	/**
+	* 设置 CLI 命令
+	*/
+	async setCliCommand(command) {
+		await this.writeConfig({ cli: { command } });
+	}
+};
+
+//#endregion
+//#region src/cli-executor.ts
+/**
+* CLI 执行器
+*
+* 负责调用外部 openspec CLI 命令。
+* 命令前缀从 ConfigManager 获取，支持：
+* - ['npx', '@fission-ai/openspec'] (默认)
+* - ['openspec'] (全局安装)
+* - 自定义数组或字符串
+*
+* 注意：所有命令都使用 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);
+		return new Promise((resolve$1) => {
+			const child = spawn(cmd, cmdArgs, {
+				cwd: this.projectDir,
+				shell: false,
+				env: this.getCleanEnv()
+			});
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.on("data", (data) => {
+				stdout += data.toString();
+			});
+			child.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			child.on("close", (exitCode) => {
+				resolve$1({
+					success: exitCode === 0,
+					stdout,
+					stderr,
+					exitCode
+				});
+			});
+			child.on("error", (err) => {
+				resolve$1({
+					success: false,
+					stdout,
+					stderr: stderr + "\n" + err.message,
+					exitCode: null
+				});
+			});
+		});
+	}
+	/**
+	* 执行 openspec init（非交互式）
+	*
+	* @param tools 工具列表，如 ['claude', 'cursor'] 或 'all' 或 'none'
+	*/
+	async init(tools = "all") {
+		const toolsArg = Array.isArray(tools) ? tools.join(",") : tools;
+		return this.execute([
+			"init",
+			"--tools",
+			toolsArg
+		]);
+	}
+	/**
+	* 执行 openspec archive <changeId>（非交互式）
+	*
+	* @param changeId 要归档的 change ID
+	* @param options 选项
+	*/
+	async archive(changeId, options = {}) {
+		const args = [
+			"archive",
+			"-y",
+			changeId
+		];
+		if (options.skipSpecs) args.push("--skip-specs");
+		if (options.noValidate) args.push("--no-validate");
+		return this.execute(args);
+	}
+	/**
+	* 执行 openspec validate [type] [id]
+	*/
+	async validate(type, id) {
+		const args = ["validate"];
+		if (type) args.push(type);
+		if (id) args.push(id);
+		return this.execute(args);
+	}
+	/**
+	* 流式执行 openspec validate
+	*/
+	validateStream(type, id, onEvent) {
+		const args = ["validate"];
+		if (type) args.push(type);
+		if (id) args.push(id);
+		return this.executeStream(args, onEvent);
+	}
+	/**
+	* 检查 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 {
+				available: true,
+				version: result.stdout.trim()
+			};
+			return {
+				available: false,
+				error: result.stderr || "Unknown error"
+			};
+		} catch (err) {
+			return {
+				available: false,
+				error: err instanceof Error ? err.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 流式执行 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) => {
+			onEvent({
+				type: "stdout",
+				data: data.toString()
+			});
+		});
+		child.stderr?.on("data", (data) => {
+			onEvent({
+				type: "stderr",
+				data: data.toString()
+			});
+		});
+		child.on("close", (exitCode) => {
+			onEvent({
+				type: "exit",
+				exitCode
+			});
+		});
+		child.on("error", (err) => {
+			onEvent({
+				type: "stderr",
+				data: err.message
+			});
+			onEvent({
+				type: "exit",
+				exitCode: null
+			});
+		});
+		return () => {
+			child.kill();
+		};
+	}
+	/**
+	* 流式执行 openspec init
+	*/
+	initStream(tools, onEvent) {
+		const toolsArg = Array.isArray(tools) ? tools.join(",") : tools;
+		return this.executeStream([
+			"init",
+			"--tools",
+			toolsArg
+		], onEvent);
+	}
+	/**
+	* 流式执行 openspec archive
+	*/
+	archiveStream(changeId, options, onEvent) {
+		const args = [
+			"archive",
+			"-y",
+			changeId
+		];
+		if (options.skipSpecs) args.push("--skip-specs");
+		if (options.noValidate) args.push("--no-validate");
+		return this.executeStream(args, onEvent);
+	}
+	/**
+	* 流式执行任意命令（数组形式）
+	*
+	* 用于执行不需要 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;
+		onEvent({
+			type: "command",
+			data: command.join(" ")
+		});
+		const child = spawn(cmd, cmdArgs, {
+			cwd: this.projectDir,
+			shell: false,
+			env: this.getCleanEnv()
+		});
+		child.stdout?.on("data", (data) => {
+			onEvent({
+				type: "stdout",
+				data: data.toString()
+			});
+		});
+		child.stderr?.on("data", (data) => {
+			onEvent({
+				type: "stderr",
+				data: data.toString()
+			});
+		});
+		child.on("close", (exitCode) => {
+			onEvent({
+				type: "exit",
+				exitCode
+			});
+		});
+		child.on("error", (err) => {
+			onEvent({
+				type: "stderr",
+				data: err.message
+			});
+			onEvent({
+				type: "exit",
+				exitCode: null
+			});
+		});
+		return () => {
+			child.kill();
+		};
+	}
+};
+
+//#endregion
+//#region src/tool-config.ts
+/**
+* 工具配置检测模块
+*
+* 完全对齐 @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)
+*/
+/**
+* 获取 Codex 全局 prompts 目录
+* 优先使用 $CODEX_HOME 环境变量，否则使用 ~/.codex
+* @see references/openspec/src/core/configurators/slash/codex.ts
+*/
+function getCodexGlobalPromptsDir() {
+	return join$1(process.env.CODEX_HOME?.trim() || join$1(homedir(), ".codex"), "prompts");
+}
+/**
+* 所有支持的 AI 工具配置
+*
+* 完全对齐官方 OpenSpec CLI 的 AI_TOOLS
+* 按字母顺序排序（与官方一致）
+*
+* @see references/openspec/src/core/config.ts
+* @see references/openspec/src/core/configurators/slash/registry.ts
+*/
+const AI_TOOLS = [
+	{
+		name: "Amazon Q Developer",
+		value: "amazon-q",
+		available: true,
+		successLabel: "Amazon Q Developer",
+		scope: "project",
+		detectionPath: ".amazonq/prompts/openspec-proposal.md"
+	},
+	{
+		name: "Antigravity",
+		value: "antigravity",
+		available: true,
+		successLabel: "Antigravity",
+		scope: "project",
+		detectionPath: ".agent/workflows/openspec-proposal.md"
+	},
+	{
+		name: "Auggie (Augment CLI)",
+		value: "auggie",
+		available: true,
+		successLabel: "Auggie",
+		scope: "project",
+		detectionPath: ".augment/commands/openspec-proposal.md"
+	},
+	{
+		name: "Claude Code",
+		value: "claude",
+		available: true,
+		successLabel: "Claude Code",
+		scope: "project",
+		detectionPath: ".claude/commands/openspec/proposal.md"
+	},
+	{
+		name: "Cline",
+		value: "cline",
+		available: true,
+		successLabel: "Cline",
+		scope: "project",
+		detectionPath: ".clinerules/workflows/openspec-proposal.md"
+	},
+	{
+		name: "Codex",
+		value: "codex",
+		available: true,
+		successLabel: "Codex",
+		scope: "global",
+		detectionPath: () => join$1(getCodexGlobalPromptsDir(), "openspec-proposal.md")
+	},
+	{
+		name: "CodeBuddy Code (CLI)",
+		value: "codebuddy",
+		available: true,
+		successLabel: "CodeBuddy Code",
+		scope: "project",
+		detectionPath: ".codebuddy/commands/openspec/proposal.md"
+	},
+	{
+		name: "CoStrict",
+		value: "costrict",
+		available: true,
+		successLabel: "CoStrict",
+		scope: "project",
+		detectionPath: ".cospec/openspec/commands/openspec-proposal.md"
+	},
+	{
+		name: "Crush",
+		value: "crush",
+		available: true,
+		successLabel: "Crush",
+		scope: "project",
+		detectionPath: ".crush/commands/openspec/proposal.md"
+	},
+	{
+		name: "Cursor",
+		value: "cursor",
+		available: true,
+		successLabel: "Cursor",
+		scope: "project",
+		detectionPath: ".cursor/commands/openspec-proposal.md"
+	},
+	{
+		name: "Factory Droid",
+		value: "factory",
+		available: true,
+		successLabel: "Factory Droid",
+		scope: "project",
+		detectionPath: ".factory/commands/openspec-proposal.md"
+	},
+	{
+		name: "Gemini CLI",
+		value: "gemini",
+		available: true,
+		successLabel: "Gemini CLI",
+		scope: "project",
+		detectionPath: ".gemini/commands/openspec/proposal.toml"
+	},
+	{
+		name: "GitHub Copilot",
+		value: "github-copilot",
+		available: true,
+		successLabel: "GitHub Copilot",
+		scope: "project",
+		detectionPath: ".github/prompts/openspec-proposal.prompt.md"
+	},
+	{
+		name: "iFlow",
+		value: "iflow",
+		available: true,
+		successLabel: "iFlow",
+		scope: "project",
+		detectionPath: ".iflow/commands/openspec-proposal.md"
+	},
+	{
+		name: "Kilo Code",
+		value: "kilocode",
+		available: true,
+		successLabel: "Kilo Code",
+		scope: "project",
+		detectionPath: ".kilocode/workflows/openspec-proposal.md"
+	},
+	{
+		name: "OpenCode",
+		value: "opencode",
+		available: true,
+		successLabel: "OpenCode",
+		scope: "project",
+		detectionPath: ".opencode/command/openspec-proposal.md"
+	},
+	{
+		name: "Qoder (CLI)",
+		value: "qoder",
+		available: true,
+		successLabel: "Qoder",
+		scope: "project",
+		detectionPath: ".qoder/commands/openspec/proposal.md"
+	},
+	{
+		name: "Qwen Code",
+		value: "qwen",
+		available: true,
+		successLabel: "Qwen Code",
+		scope: "project",
+		detectionPath: ".qwen/commands/openspec-proposal.toml"
+	},
+	{
+		name: "RooCode",
+		value: "roocode",
+		available: true,
+		successLabel: "RooCode",
+		scope: "project",
+		detectionPath: ".roo/commands/openspec-proposal.md"
+	},
+	{
+		name: "Windsurf",
+		value: "windsurf",
+		available: true,
+		successLabel: "Windsurf",
+		scope: "project",
+		detectionPath: ".windsurf/workflows/openspec-proposal.md"
+	},
+	{
+		name: "AGENTS.md (works with Amp, VS Code, …)",
+		value: "agents",
+		available: false,
+		successLabel: "your AGENTS.md-compatible assistant",
+		scope: "project",
+		detectionPath: "AGENTS.md"
+	}
+];
+/**
+* 获取所有可用的工具（available: true）
+*/
+function getAvailableTools() {
+	return AI_TOOLS.filter((tool) => tool.available);
+}
+/**
+* 获取所有可用的工具 ID 列表（available: true）
+*/
+function getAvailableToolIds() {
+	return getAvailableTools().map((tool) => tool.value);
+}
+/**
+* 获取所有工具（包括 available: false 的）
+*/
+function getAllTools() {
+	return AI_TOOLS;
+}
+/**
+* 获取所有工具 ID 列表（包括 available: false 的）
+*/
+function getAllToolIds() {
+	return AI_TOOLS.map((tool) => tool.value);
+}
+/**
+* 根据工具 ID 获取工具配置
+*/
+function getToolById(toolId) {
+	return AI_TOOLS.find((tool) => tool.value === toolId);
+}
+/** 状态缓存：projectDir -> ReactiveState */
+const stateCache = /* @__PURE__ */ new Map();
+/** 监听器释放函数缓存 */
+const releaseCache = /* @__PURE__ */ new Map();
+/**
+* 检查文件是否存在
+*/
+async function fileExists(filePath) {
+	try {
+		await stat(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 解析工具的检测路径
+* @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 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;
+	}))).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));
+	}
+	return Array.from(dirs);
+}
+/**
+* 检测项目中已配置的工具（响应式）
+*
+* 监听两类目录：
+* 1. 项目级配置目录（如 .claude, .cursor 等）
+* 2. 全局配置目录（如 ~/.codex/prompts/）
+*
+* @param projectDir 项目根目录
+* @returns 已配置的工具 ID 列表
+*/
+async function getConfiguredTools(projectDir) {
+	const normalizedPath = resolve(projectDir);
+	const key = `tools:${normalizedPath}`;
+	let state = stateCache.get(key);
+	if (!state) {
+		state = new ReactiveState(await scanConfiguredTools(normalizedPath), { equals: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) });
+		stateCache.set(key, state);
+		const releases = [];
+		const onUpdate = async () => {
+			const newValue = await scanConfiguredTools(normalizedPath);
+			state.set(newValue);
+		};
+		const projectWatchDirs = getProjectWatchDirs(normalizedPath);
+		for (const dir of projectWatchDirs) {
+			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()));
+	}
+	return state.get();
+}
+/**
+* 检查特定工具是否已配置
+*
+* @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 };