openspecui 2.1.2 → 2.1.3

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as SchemaInfoSchema, c as toOpsxDisplayPath, d as CliExecutor, f as ConfigManager, g as __toESM, h as __commonJS, i as SchemaDetailSchema, l as buildHostedLaunchUrl, m as OpenSpecAdapter, o as SchemaResolutionSchema, p as DEFAULT_CONFIG, r as require_dist, s as TemplatesSchema, t as startServer, u as resolveHostedAppBaseUrl } from "./src-Nn_MJz41.mjs";
+import { a as SchemaInfoSchema, c as toOpsxDisplayPath, d as CliExecutor, f as ConfigManager, g as __toESM, h as __commonJS, i as SchemaDetailSchema, l as buildHostedLaunchUrl, m as OpenSpecAdapter, o as SchemaResolutionSchema, p as DEFAULT_CONFIG, r as require_dist, s as TemplatesSchema, t as startServer, u as resolveHostedAppBaseUrl } from "./src-DFu4IXMV.mjs";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
@@ -4508,7 +4508,7 @@ var yargs_default = Yargs;
 //#endregion
 //#region package.json
 var import_dist = require_dist();
-var version = "2.1.2";
+var version = "2.1.3";
 
 //#endregion
 //#region src/export.ts
@@ -4811,13 +4811,9 @@ async function generateSnapshot(projectDir) {
 		};
 	}));
 	let projectMd;
-	let agentsMd;
 	try {
 		projectMd = await adapter.readProjectMd() ?? void 0;
 	} catch {}
-	try {
-		agentsMd = await adapter.readAgentsMd() ?? void 0;
-	} catch {}
 	let configYaml;
 	let schemas = [];
 	const schemaDetails = {};
@@ -4920,7 +4916,6 @@ async function generateSnapshot(projectDir) {
 		changes,
 		archives,
 		projectMd,
-		agentsMd,
 		opsx: {
 			configYaml,
 			schemas,
@@ -5462,7 +5457,7 @@ async function main() {
 			}
 			console.log("");
 			if (argv.open) {
-				await (await import("./open-DfwCb8mL.mjs")).default(browserUrl);
+				await (await import("./open-CLEEmeZr.mjs")).default(browserUrl);
 				console.log(useHostedApp ? "🌐 Hosted app opened" : "🌐 Browser opened");
 			}
 			console.log("");

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { n as createServer, t as startServer } from "./src-Nn_MJz41.mjs";
+import { n as createServer, t as startServer } from "./src-DFu4IXMV.mjs";
 
 export { createServer, startServer };

package/dist/{open-DfwCb8mL.mjs → open-CLEEmeZr.mjs}

@@ -1,12 +1,12 @@
 import fs, { constants } from "node:fs/promises";
 import path from "node:path";
 import fs$1 from "node:fs";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 import childProcess, { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import process from "node:process";
 import { Buffer } from "node:buffer";
-import os from "node:os";
 
 //#region ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
 let isDockerCached;

package/dist/{src-Nn_MJz41.mjs → src-DFu4IXMV.mjs}

@@ -14,6 +14,7 @@ import { EventEmitter } from "events";
 import { watch } from "fs";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { execFile } from "node:child_process";
@@ -1669,6 +1670,23 @@ async function reactiveStat(path$1) {
 	}
 	return state.get();
 }
+/**
+* 清除指定路径的缓存（用于测试）
+*/
+function clearCache(path$1) {
+	if (path$1) {
+		const normalizedPath = resolve$1(path$1);
+		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();
+	}
+}
 
 //#endregion
 //#region ../core/src/validator.ts
@@ -1869,23 +1887,11 @@ var OpenSpecAdapter = class {
 		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);
@@ -2056,24 +2062,6 @@ This project uses OpenSpec for spec-driven development.
 - \`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");
 	}
 	/**
@@ -5879,7 +5867,7 @@ var OpenSpecWatcher = class extends EventEmitter {
 			});
 		});
 		this.watchDir(this.openspecDir, (filename, eventType) => {
-			if (filename === "project.md" || filename === "AGENTS.md") this.emitDebounced(`project:${filename}`, {
+			if (filename === "project.md") this.emitDebounced(`project:${filename}`, {
 				type: "project",
 				action: eventType === "rename" ? "create" : "update",
 				path: join(this.openspecDir, filename),
@@ -6321,11 +6309,68 @@ const DEFAULT_CONFIG = {
 	terminal: TerminalConfigSchema.parse({}),
 	dashboard: DashboardConfigSchema.parse({})
 };
+function areStringArraysEqual(left, right) {
+	if (left === right) return true;
+	if (!left || !right) return !left && !right;
+	if (left.length !== right.length) return false;
+	return left.every((value, index) => value === right[index]);
+}
+function pruneNullish(value) {
+	if (value === null || value === void 0) return;
+	if (Array.isArray(value)) return value.map((entry) => pruneNullish(entry)).filter((entry) => entry !== void 0);
+	if (typeof value === "object") {
+		const normalizedEntries = Object.entries(value).flatMap(([key, entryValue]) => {
+			const nextValue = pruneNullish(entryValue);
+			return nextValue === void 0 ? [] : [[key, nextValue]];
+		});
+		return Object.fromEntries(normalizedEntries);
+	}
+	return value;
+}
+function hasOwnEntries(value) {
+	return Object.keys(value).length > 0;
+}
+function toPersistedConfig(config, options = {}) {
+	const persisted = {};
+	const command = config.cli.command?.trim();
+	const args = (config.cli.args ?? []).map((arg) => arg.trim()).filter(Boolean);
+	const cliCommandParts = command ? [command, ...args] : void 0;
+	if (cliCommandParts && !areStringArraysEqual(cliCommandParts, options.defaultCliCommandParts)) {
+		const persistedCommand = cliCommandParts[0];
+		persisted.cli = args.length > 0 ? {
+			command: persistedCommand,
+			args
+		} : { command: persistedCommand };
+	}
+	if (config.theme !== DEFAULT_CONFIG.theme) persisted.theme = config.theme;
+	const codeEditor = {};
+	if (config.codeEditor.theme !== DEFAULT_CONFIG.codeEditor.theme) codeEditor.theme = config.codeEditor.theme;
+	if (hasOwnEntries(codeEditor)) persisted.codeEditor = codeEditor;
+	if (config.appBaseUrl !== DEFAULT_CONFIG.appBaseUrl) persisted.appBaseUrl = config.appBaseUrl;
+	const terminal = {};
+	if (config.terminal.fontSize !== DEFAULT_CONFIG.terminal.fontSize) terminal.fontSize = config.terminal.fontSize;
+	if (config.terminal.fontFamily !== DEFAULT_CONFIG.terminal.fontFamily) terminal.fontFamily = config.terminal.fontFamily;
+	if (config.terminal.cursorBlink !== DEFAULT_CONFIG.terminal.cursorBlink) terminal.cursorBlink = config.terminal.cursorBlink;
+	if (config.terminal.cursorStyle !== DEFAULT_CONFIG.terminal.cursorStyle) terminal.cursorStyle = config.terminal.cursorStyle;
+	if (config.terminal.scrollback !== DEFAULT_CONFIG.terminal.scrollback) terminal.scrollback = config.terminal.scrollback;
+	if (config.terminal.rendererEngine !== DEFAULT_CONFIG.terminal.rendererEngine) terminal.rendererEngine = config.terminal.rendererEngine;
+	if (hasOwnEntries(terminal)) persisted.terminal = terminal;
+	const dashboard = {};
+	if (config.dashboard.trendPointLimit !== DEFAULT_CONFIG.dashboard.trendPointLimit) dashboard.trendPointLimit = config.dashboard.trendPointLimit;
+	if (hasOwnEntries(dashboard)) persisted.dashboard = dashboard;
+	return persisted;
+}
+function isPersistedConfigEmpty(config) {
+	return !hasOwnEntries(config);
+}
 /**
 * 配置管理器
 *
 * 负责读写 openspec/.openspecui.json 配置文件。
 * 读取操作使用 reactiveReadFile，支持响应式更新。
+*
+* `.openspecui.json` 是预期中的项目级 UI 配置文件，但只有显式偏离默认值的
+* override 才会落盘。仅启动 openspecui 或仅依赖默认配置时，不应触发文件写入。
 */
 var ConfigManager = class {
 	configPath;
@@ -6336,18 +6381,11 @@ var ConfigManager = class {
 		this.projectDir = projectDir;
 		this.configPath = join(projectDir, "openspec", ".openspecui.json");
 	}
-	/**
-	* 读取配置（响应式）
-	*
-	* 如果配置文件不存在，返回默认配置。
-	* 如果配置文件格式错误，返回默认配置并打印警告。
-	*/
-	async readConfig() {
-		const content = await reactiveReadFile(this.configPath);
+	parseConfigContent(content) {
 		if (!content) return DEFAULT_CONFIG;
 		try {
-			const parsed = JSON.parse(content);
-			const result = OpenSpecUIConfigSchema.safeParse(parsed);
+			const normalized = pruneNullish(JSON.parse(content)) ?? {};
+			const result = OpenSpecUIConfigSchema.safeParse(normalized);
 			if (result.success) return result.data;
 			console.warn("Invalid config format, using defaults:", result.error.message);
 			return DEFAULT_CONFIG;
@@ -6357,12 +6395,24 @@ var ConfigManager = class {
 		}
 	}
 	/**
+	* 读取配置（响应式）
+	*
+	* 如果配置文件不存在，返回默认配置。
+	* 如果配置文件格式错误，返回默认配置并打印警告。
+	*/
+	async readConfig() {
+		const content = await reactiveReadFile(this.configPath);
+		return this.parseConfigContent(content);
+	}
+	/**
 	* 写入配置
 	*
 	* 会触发文件监听，自动更新订阅者。
 	*/
 	async writeConfig(config) {
-		const current = await this.readConfig();
+		const currentContent = await reactiveReadFile(this.configPath);
+		const fileExists = currentContent !== null;
+		const current = this.parseConfigContent(currentContent);
 		const nextCli = { ...current.cli };
 		if (config.cli && Object.prototype.hasOwnProperty.call(config.cli, "command")) {
 			const trimmed = config.cli.command?.trim();
@@ -6378,7 +6428,7 @@ var ConfigManager = class {
 			else delete nextCli.args;
 		}
 		if (!nextCli.command) delete nextCli.args;
-		const merged = {
+		const persisted = toPersistedConfig({
 			...current,
 			cli: nextCli,
 			theme: config.theme ?? current.theme,
@@ -6395,13 +6445,25 @@ var ConfigManager = class {
 				...current.dashboard,
 				...config.dashboard
 			}
-		};
-		const serialized = JSON.stringify(merged, null, 2);
+		});
+		if (isPersistedConfigEmpty(persisted) && !fileExists) return;
+		const serialized = isPersistedConfigEmpty(persisted) ? "{}" : JSON.stringify(persisted, null, 2);
+		if (currentContent === serialized) return;
 		await mkdir(dirname(this.configPath), { recursive: true });
 		await writeFile(this.configPath, serialized, "utf-8");
 		updateReactiveFileCache(this.configPath, serialized);
 		this.invalidateResolvedCliRunner();
 	}
+	async resolveDefaultCliCommandParts() {
+		return (await resolveCliRunner(buildCliRunnerCandidates({ userAgent: process.env.npm_config_user_agent }).filter((candidate) => candidate.id !== "configured"), this.projectDir, createCleanCliEnv())).commandParts;
+	}
+	async isDefaultCliCommand(commandParts) {
+		try {
+			return areStringArraysEqual(commandParts, await this.resolveDefaultCliCommandParts());
+		} catch {
+			return false;
+		}
+	}
 	/**
 	* 解析并缓存可用 CLI runner。
 	*/
@@ -6419,8 +6481,7 @@ var ConfigManager = class {
 	async resolveCliRunnerUncached() {
 		const config = await this.readConfig();
 		const configuredCommandParts = this.getConfiguredCommandParts(config.cli);
-		const hasConfiguredCommand = configuredCommandParts.length > 0;
-		const resolved = await resolveCliRunner(hasConfiguredCommand ? [{
+		return await resolveCliRunner(configuredCommandParts.length > 0 ? [{
 			id: "configured",
 			source: "config.cli.command",
 			commandParts: configuredCommandParts
@@ -6428,20 +6489,6 @@ var ConfigManager = class {
 			configuredCommandParts,
 			userAgent: process.env.npm_config_user_agent
 		}), this.projectDir, createCleanCliEnv());
-		if (!hasConfiguredCommand) {
-			const [resolvedCommand, ...resolvedArgs] = resolved.commandParts;
-			const currentCommand = config.cli.command?.trim();
-			const currentArgs = config.cli.args ?? [];
-			if (currentCommand !== resolvedCommand || currentArgs.length !== resolvedArgs.length || currentArgs.some((arg, index) => arg !== resolvedArgs[index])) try {
-				await this.writeConfig({ cli: {
-					command: resolvedCommand,
-					args: resolvedArgs
-				} });
-			} catch (err) {
-				console.warn("Failed to persist auto-detected CLI command:", err);
-			}
-		}
-		return resolved;
 	}
 	/**
 	* 获取 CLI 命令（数组形式）
@@ -6488,6 +6535,13 @@ var ConfigManager = class {
 			} });
 			return;
 		}
+		if (await this.isDefaultCliCommand(commandParts)) {
+			await this.writeConfig({ cli: {
+				command: null,
+				args: null
+			} });
+			return;
+		}
 		const [resolvedCommand, ...resolvedArgs] = commandParts;
 		await this.writeConfig({ cli: {
 			command: resolvedCommand,
@@ -6800,9 +6854,36 @@ var CliExecutor = class {
 	}
 	/**
 	* 流式执行任意命令（数组形式）
+	*
+	* 字面量 `openspec` 会自动通过已解析的 CLI runner 执行，
+	* 其它命令保持原始 spawn 行为。
 	*/
 	executeCommandStream(command, onEvent) {
 		const [cmd, ...cmdArgs] = command;
+		if (cmd === "openspec") {
+			let cancelResolved = null;
+			let cancelled = false;
+			this.executeStream([...cmdArgs], onEvent).then((cancel) => {
+				if (cancelled) {
+					cancel();
+					return;
+				}
+				cancelResolved = cancel;
+			}).catch((err) => {
+				onEvent({
+					type: "stderr",
+					data: err instanceof Error ? err.message : String(err)
+				});
+				onEvent({
+					type: "exit",
+					exitCode: null
+				});
+			});
+			return () => {
+				cancelled = true;
+				cancelResolved?.();
+			};
+		}
 		onEvent({
 			type: "command",
 			data: command.join(" ")
@@ -7044,12 +7125,6 @@ const AI_TOOLS = [
 		available: true,
 		successLabel: "Windsurf",
 		skillsDir: ".windsurf"
-	},
-	{
-		name: "AGENTS.md (works with Amp, VS Code, …)",
-		value: "agents",
-		available: false,
-		successLabel: "your AGENTS.md-compatible assistant"
 	}
 ];
 /**
@@ -7059,11 +7134,23 @@ function getAvailableTools() {
 	return AI_TOOLS.filter((tool) => tool.available);
 }
 /**
-* 获取所有工具（包括 available: false 的）
+* 获取所有工具
 */
 function getAllTools() {
 	return AI_TOOLS;
 }
+/**
+* 检测当前项目中已经存在的工具目录。
+*
+* 这里对齐 OpenSpec 官方 `getAvailableTools(projectPath)` 的语义：
+* 仅根据项目根目录下的工具目录是否存在来判断，不读取全局命令安装状态。
+*/
+async function getDetectedProjectTools(projectDir) {
+	return (await Promise.all(AI_TOOLS.map(async (tool) => {
+		if (!tool.skillsDir) return null;
+		return await reactiveExists(join$1(projectDir, tool.skillsDir)) ? tool : null;
+	}))).filter((tool) => tool !== null);
+}
 /** 状态缓存：projectDir -> ReactiveState */
 const stateCache = /* @__PURE__ */ new Map();
 /** 监听器释放函数缓存 */
@@ -7126,6 +7213,143 @@ async function getConfiguredTools(projectDir) {
 	return state.get();
 }
 
+//#endregion
+//#region ../core/src/tool-init-state.ts
+const TOOL_WORKFLOW_TO_SKILL_DIR = {
+	propose: "openspec-propose",
+	explore: "openspec-explore",
+	new: "openspec-new-change",
+	continue: "openspec-continue-change",
+	apply: "openspec-apply-change",
+	ff: "openspec-ff-change",
+	sync: "openspec-sync-specs",
+	archive: "openspec-archive-change",
+	"bulk-archive": "openspec-bulk-archive-change",
+	verify: "openspec-verify-change",
+	onboard: "openspec-onboard"
+};
+const ALL_TOOL_WORKFLOWS = Object.keys(TOOL_WORKFLOW_TO_SKILL_DIR);
+function toKnownWorkflows(workflows) {
+	return workflows.filter((workflow) => workflow in TOOL_WORKFLOW_TO_SKILL_DIR);
+}
+function resolveCodexHome() {
+	const configuredHome = process.env.CODEX_HOME?.trim();
+	return resolve$1(configuredHome ? configuredHome : join$1(homedir(), ".codex"));
+}
+function resolveToolCommandPath(projectDir, toolId, workflow) {
+	switch (toolId) {
+		case "amazon-q": return resolve$1(projectDir, ".amazonq", "prompts", `opsx-${workflow}.md`);
+		case "antigravity": return resolve$1(projectDir, ".agent", "workflows", `opsx-${workflow}.md`);
+		case "auggie": return resolve$1(projectDir, ".augment", "commands", `opsx-${workflow}.md`);
+		case "claude": return resolve$1(projectDir, ".claude", "commands", "opsx", `${workflow}.md`);
+		case "cline": return resolve$1(projectDir, ".clinerules", "workflows", `opsx-${workflow}.md`);
+		case "codebuddy": return resolve$1(projectDir, ".codebuddy", "commands", "opsx", `${workflow}.md`);
+		case "codex": return resolve$1(resolveCodexHome(), "prompts", `opsx-${workflow}.md`);
+		case "continue": return resolve$1(projectDir, ".continue", "prompts", `opsx-${workflow}.prompt`);
+		case "costrict": return resolve$1(projectDir, ".cospec", "openspec", "commands", `opsx-${workflow}.md`);
+		case "crush": return resolve$1(projectDir, ".crush", "commands", "opsx", `${workflow}.md`);
+		case "cursor": return resolve$1(projectDir, ".cursor", "commands", `opsx-${workflow}.md`);
+		case "factory": return resolve$1(projectDir, ".factory", "commands", `opsx-${workflow}.md`);
+		case "gemini": return resolve$1(projectDir, ".gemini", "commands", "opsx", `${workflow}.toml`);
+		case "github-copilot": return resolve$1(projectDir, ".github", "prompts", `opsx-${workflow}.prompt.md`);
+		case "iflow": return resolve$1(projectDir, ".iflow", "commands", `opsx-${workflow}.md`);
+		case "kilocode": return resolve$1(projectDir, ".kilocode", "workflows", `opsx-${workflow}.md`);
+		case "kiro": return resolve$1(projectDir, ".kiro", "prompts", `opsx-${workflow}.prompt.md`);
+		case "opencode": return resolve$1(projectDir, ".opencode", "command", `opsx-${workflow}.md`);
+		case "pi": return resolve$1(projectDir, ".pi", "prompts", `opsx-${workflow}.md`);
+		case "qoder": return resolve$1(projectDir, ".qoder", "commands", "opsx", `${workflow}.md`);
+		case "qwen": return resolve$1(projectDir, ".qwen", "commands", `opsx-${workflow}.toml`);
+		case "roocode": return resolve$1(projectDir, ".roo", "commands", `opsx-${workflow}.md`);
+		case "windsurf": return resolve$1(projectDir, ".windsurf", "workflows", `opsx-${workflow}.md`);
+		default: return null;
+	}
+}
+function getSkillArtifacts(projectDir, skillsDir) {
+	return ALL_TOOL_WORKFLOWS.map((workflow) => ({
+		workflow,
+		path: resolve$1(projectDir, skillsDir, "skills", TOOL_WORKFLOW_TO_SKILL_DIR[workflow], "SKILL.md")
+	}));
+}
+function getCommandArtifacts(projectDir, toolId) {
+	return ALL_TOOL_WORKFLOWS.flatMap((workflow) => {
+		const path$1 = resolveToolCommandPath(projectDir, toolId, workflow);
+		return path$1 ? [{
+			workflow,
+			path: path$1
+		}] : [];
+	});
+}
+function invalidateToolInitCaches(projectDir) {
+	const cacheRoots = /* @__PURE__ */ new Set();
+	for (const tool of AI_TOOLS) {
+		if (tool.skillsDir) cacheRoots.add(resolve$1(projectDir, tool.skillsDir));
+		for (const workflow of ALL_TOOL_WORKFLOWS) {
+			const commandPath = resolveToolCommandPath(projectDir, tool.value, workflow);
+			if (commandPath) cacheRoots.add(dirname$1(commandPath));
+		}
+	}
+	for (const root of cacheRoots) clearCache(root);
+}
+async function getExistingArtifactPaths(entries) {
+	const presence = await Promise.all(entries.map(async (entry) => ({
+		path: entry.path,
+		exists: await reactiveExists(entry.path)
+	})));
+	return new Set(presence.filter((entry) => entry.exists).map((entry) => entry.path));
+}
+function countExisting(entries, existingPaths) {
+	return entries.reduce((count, entry) => count + (existingPaths.has(entry.path) ? 1 : 0), 0);
+}
+function collectMissingWorkflows(entries, existingPaths) {
+	return entries.filter((entry) => !existingPaths.has(entry.path)).map((entry) => entry.workflow);
+}
+function collectUnexpectedWorkflows(entries, desiredWorkflowSet, existingPaths) {
+	return entries.filter((entry) => !desiredWorkflowSet.has(entry.workflow) && existingPaths.has(entry.path)).map((entry) => entry.workflow);
+}
+async function getToolInitStates(projectDir, options) {
+	invalidateToolInitCaches(projectDir);
+	const desiredWorkflows = toKnownWorkflows(options.workflows);
+	const desiredWorkflowSet = new Set(desiredWorkflows);
+	const shouldGenerateSkills = options.delivery !== "commands";
+	const shouldGenerateCommands = options.delivery !== "skills";
+	return Promise.all(AI_TOOLS.filter((tool) => tool.skillsDir).map(async (tool) => {
+		const skillArtifacts = getSkillArtifacts(projectDir, tool.skillsDir);
+		const commandArtifacts = getCommandArtifacts(projectDir, tool.value);
+		const existingSkillPaths = await getExistingArtifactPaths(skillArtifacts);
+		const existingCommandPaths = await getExistingArtifactPaths(commandArtifacts);
+		const expectedSkillArtifacts = shouldGenerateSkills ? skillArtifacts.filter((entry) => desiredWorkflowSet.has(entry.workflow)) : [];
+		const expectedCommandArtifacts = shouldGenerateCommands ? commandArtifacts.filter((entry) => desiredWorkflowSet.has(entry.workflow)) : [];
+		const missingSkillWorkflows = collectMissingWorkflows(expectedSkillArtifacts, existingSkillPaths);
+		const missingCommandWorkflows = collectMissingWorkflows(expectedCommandArtifacts, existingCommandPaths);
+		const unexpectedSkillWorkflows = collectUnexpectedWorkflows(shouldGenerateSkills ? skillArtifacts : skillArtifacts, shouldGenerateSkills ? desiredWorkflowSet : /* @__PURE__ */ new Set(), existingSkillPaths);
+		const unexpectedCommandWorkflows = collectUnexpectedWorkflows(shouldGenerateCommands ? commandArtifacts : commandArtifacts, shouldGenerateCommands ? desiredWorkflowSet : /* @__PURE__ */ new Set(), existingCommandPaths);
+		const expectedSkillCount = expectedSkillArtifacts.length;
+		const presentExpectedSkillCount = expectedSkillCount - missingSkillWorkflows.length;
+		const detectedSkillCount = countExisting(skillArtifacts, existingSkillPaths);
+		const expectedCommandCount = expectedCommandArtifacts.length;
+		const presentExpectedCommandCount = expectedCommandCount - missingCommandWorkflows.length;
+		const detectedCommandCount = countExisting(commandArtifacts, existingCommandPaths);
+		const hasAnyArtifacts = detectedSkillCount + detectedCommandCount > 0;
+		const isInitialized = missingSkillWorkflows.length === 0 && missingCommandWorkflows.length === 0 && unexpectedSkillWorkflows.length === 0 && unexpectedCommandWorkflows.length === 0;
+		return {
+			toolId: tool.value,
+			toolName: tool.name,
+			status: !hasAnyArtifacts ? "uninitialized" : isInitialized ? "initialized" : "partial",
+			hasAnyArtifacts,
+			expectedSkillCount,
+			presentExpectedSkillCount,
+			detectedSkillCount,
+			expectedCommandCount,
+			presentExpectedCommandCount,
+			detectedCommandCount,
+			missingSkillWorkflows,
+			missingCommandWorkflows,
+			unexpectedSkillWorkflows,
+			unexpectedCommandWorkflows
+		};
+	}));
+}
+
 //#endregion
 //#region ../core/src/dashboard-types.ts
 const DASHBOARD_METRIC_KEYS = [
@@ -24846,9 +25070,30 @@ const cliRouter = router({
 			successLabel: tool.successLabel
 		}));
 	}),
+	getDetectedProjectTools: publicProcedure.query(async ({ ctx }) => {
+		return (await getDetectedProjectTools(ctx.projectDir)).map((tool) => ({
+			name: tool.name,
+			value: tool.value,
+			available: tool.available,
+			successLabel: tool.successLabel
+		}));
+	}),
 	getProfileState: publicProcedure.query(async ({ ctx }) => {
 		return fetchOpsxProfileState(ctx);
 	}),
+	getToolInitStates: publicProcedure.input(objectType({
+		delivery: enumType([
+			"both",
+			"skills",
+			"commands"
+		]),
+		workflows: arrayType(stringType()).default([])
+	})).query(async ({ ctx, input }) => {
+		return getToolInitStates(ctx.projectDir, {
+			delivery: input.delivery,
+			workflows: input.workflows
+		});
+	}),
 	getGlobalConfigPath: publicProcedure.query(async ({ ctx }) => {
 		return { path: await resolveGlobalConfigPath(ctx) };
 	}),
@@ -25743,14 +25988,17 @@ async function startServer(config, setupApp) {
 	};
 }
 
+//#endregion
+//#region src/web-assets.ts
+function getWebAssetsDirCandidates(runtimeDir) {
+	return [join$1(runtimeDir, "..", "web"), join$1(runtimeDir, "..", "..", "web", "dist")];
+}
+
 //#endregion
 //#region src/index.ts
 const __dirname = dirname$1(fileURLToPath(import.meta.url));
 function getWebAssetsDir() {
-	const devPath = join$1(__dirname, "..", "..", "web", "dist");
-	const prodPath = join$1(__dirname, "..", "web");
-	if (existsSync(prodPath)) return prodPath;
-	if (existsSync(devPath)) return devPath;
+	for (const candidate of getWebAssetsDirCandidates(__dirname)) if (existsSync(candidate)) return candidate;
 	throw new Error("Web assets not found. Make sure to build the web package first.");
 }
 function setupStaticFiles(app) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openspecui",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "OpenSpec UI - Visual interface for spec-driven development",
   "type": "module",
   "main": "dist/index.mjs",

package/web/assets/{BufferResource-CSbEbiLP.js → BufferResource-CYUkNl6e.js}

@@ -1,4 +1,4 @@
-import{y as U,z as g,A as c,B as S,D as _,F as m,H as I,J as p}from"./index-Cq4njHD4.js";const x={name:"local-uniform-bit",vertex:{header:`
+import{y as U,z as g,A as c,B as S,D as _,F as m,H as I,J as p}from"./index-Cy7P7qsp.js";const x={name:"local-uniform-bit",vertex:{header:`
 
             struct LocalUniforms {
                 uTransformMatrix:mat3x3<f32>,