@openspecui/core 0.9.0 → 1.0.0

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
 /**
@@ -2201,6 +2201,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) {
@@ -2366,32 +2391,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 +2419,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 +2609,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 +2660,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 +2668,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, Validator, acquireWatcher, clearCache, closeAllProjectWatchers, closeAllWatchers, contextStorage, createFileChangeObservable, getActiveWatcherCount, getAllToolIds, getAllTools, getAvailableToolIds, getAvailableTools, getCacheSize, getConfiguredTools, getDefaultCliCommand, getDefaultCliCommandString, getProjectWatcher, getToolById, getWatchedProjectDir, initWatcherPool, isGlobPattern, isToolConfigured, isWatcherPoolInitialized, parseCliCommand, reactiveExists, reactiveReadDir, reactiveReadFile, reactiveStat, sniffGlobalCli };