openspecui 1.5.0 → 1.6.0

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as SchemaInfoSchema, c as CliExecutor, d as OpenSpecAdapter, f as __commonJS, i as SchemaDetailSchema, l as ConfigManager, o as SchemaResolutionSchema, p as __toESM, r as require_dist, s as TemplatesSchema, t as startServer, u as DEFAULT_CONFIG } from "./src-16GA3our.mjs";
+import { a as SchemaInfoSchema, c as toOpsxDisplayPath, d as DEFAULT_CONFIG, f as OpenSpecAdapter, i as SchemaDetailSchema, l as CliExecutor, m as __toESM, o as SchemaResolutionSchema, p as __commonJS, r as require_dist, s as TemplatesSchema, t as startServer, u as ConfigManager } from "./src-Brh3druE.mjs";
 import { createRequire } from "node:module";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
 import { readFile } from "node:fs/promises";
@@ -8,7 +8,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync
 import { readFileSync as readFileSync$1, readdirSync as readdirSync$1, statSync as statSync$1, writeFile as writeFile$1 } from "fs";
 import { format, inspect } from "util";
 import { fileURLToPath } from "url";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { promisify as promisify$1 } from "node:util";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
 import { notStrictEqual, strictEqual } from "assert";
 
@@ -4506,26 +4507,12 @@ var yargs_default = Yargs;
 //#endregion
 //#region package.json
 var import_dist = require_dist();
-var version = "1.5.0";
-var devDependencies = {
-	"@hono/node-server": "^1.14.1",
-	"@openspecui/server": "workspace:*",
-	"@openspecui/web": "workspace:*",
-	"@types/node": "^22.10.2",
-	"@types/ws": "^8.5.13",
-	"@types/yargs": "^17.0.35",
-	"hono": "^4.7.3",
-	"open": "^10.1.0",
-	"tsdown": "^0.16.6",
-	"tsx": "^4.19.2",
-	"typescript": "^5.7.2",
-	"vitest": "^2.1.8",
-	"yargs": "^18.0.0"
-};
+var version = "1.6.0";
 
 //#endregion
 //#region src/export.ts
 const __dirname$1 = dirname$1(fileURLToPath$1(import.meta.url));
+const execFileAsync = promisify$1(execFile);
 function parseCliJson(raw, schema, label) {
 	const trimmed = raw.trim();
 	if (!trimmed) throw new Error(`${label} returned empty output`);
@@ -4574,6 +4561,184 @@ function parseSchemaYaml(content) {
 	if (!validated.success) throw new Error(`Invalid schema.yaml detail: ${validated.error.message}`);
 	return validated.data;
 }
+function isAbsoluteFsPath(path$1) {
+	const normalized = path$1.replace(/\\/g, "/");
+	return normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+}
+function toAbsoluteProjectPath(projectDir, path$1) {
+	return isAbsoluteFsPath(path$1) ? path$1 : resolve$1(projectDir, path$1);
+}
+function normalizeGitPath(path$1) {
+	return path$1.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function parseRelatedChanges(paths) {
+	const related = /* @__PURE__ */ new Set();
+	for (const rawPath of paths) {
+		const path$1 = normalizeGitPath(rawPath);
+		const activeMatch = /^openspec\/changes\/([^/]+)\//.exec(path$1);
+		if (activeMatch?.[1]) {
+			related.add(activeMatch[1]);
+			continue;
+		}
+		const archiveMatch = /^openspec\/changes\/archive\/([^/]+)\//.exec(path$1);
+		if (archiveMatch?.[1]) related.add(archiveMatch[1].replace(/^\d{4}-\d{2}-\d{2}-/, ""));
+	}
+	return [...related].sort((a, b) => a.localeCompare(b));
+}
+function parseNumstat(numstatOutput) {
+	let files = 0;
+	let insertions = 0;
+	let deletions = 0;
+	for (const line of numstatOutput.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const [addRaw, delRaw] = trimmed.split("	");
+		if (!addRaw || !delRaw) continue;
+		files += 1;
+		if (addRaw !== "-") insertions += Number(addRaw) || 0;
+		if (delRaw !== "-") deletions += Number(delRaw) || 0;
+	}
+	return {
+		files,
+		insertions,
+		deletions
+	};
+}
+async function readDefaultBranch(projectDir) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"refs/remotes/origin/HEAD"
+		], {
+			cwd: projectDir,
+			encoding: "utf8",
+			maxBuffer: 1024 * 1024
+		});
+		const branch = stdout.trim();
+		if (branch.length > 0) return branch;
+	} catch {}
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			cwd: projectDir,
+			encoding: "utf8",
+			maxBuffer: 1024 * 1024
+		});
+		const branch = stdout.trim();
+		if (branch.length > 0 && branch !== "HEAD") return branch;
+	} catch {}
+	return "main";
+}
+function parseRecentCommitLog(output) {
+	const commits = [];
+	let current = null;
+	const pushCurrent = () => {
+		if (!current) return;
+		commits.push({
+			hash: current.hash,
+			title: current.title,
+			committedAt: current.committedAt,
+			relatedChanges: parseRelatedChanges(current.changedPaths),
+			diff: parseNumstat(current.numstatLines.join("\n"))
+		});
+		current = null;
+	};
+	for (const line of output.split("\n")) {
+		if (line.startsWith("__COMMIT__	")) {
+			pushCurrent();
+			const [_, hash, tsRaw, ...titleParts] = line.split("	");
+			const committedAt = Number(tsRaw) * 1e3;
+			current = {
+				hash: hash ?? "",
+				title: titleParts.join("	").trim() || (hash ? hash.slice(0, 8) : "commit"),
+				committedAt: Number.isFinite(committedAt) && committedAt > 0 ? committedAt : 0,
+				numstatLines: [],
+				changedPaths: []
+			};
+			continue;
+		}
+		if (!current) continue;
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const [addRaw, delRaw, ...pathParts] = trimmed.split("	");
+		if (!addRaw || !delRaw || pathParts.length === 0) continue;
+		const path$1 = pathParts.join("	");
+		current.numstatLines.push(`${addRaw}\t${delRaw}\t${path$1}`);
+		current.changedPaths.push(path$1);
+	}
+	pushCurrent();
+	return commits.filter((commit) => commit.hash.length > 0);
+}
+function normalizeRepositoryUrl(raw) {
+	const value = raw.trim();
+	if (!value) return null;
+	if (value.startsWith("http://") || value.startsWith("https://")) return value.replace(/\.git$/i, "");
+	const gitAtMatch = /^git@([^:]+):(.+)$/.exec(value);
+	if (gitAtMatch?.[1] && gitAtMatch[2]) return `https://${gitAtMatch[1]}/${gitAtMatch[2].replace(/\.git$/i, "")}`;
+	if (value.startsWith("ssh://")) try {
+		const parsed = new URL(value);
+		const pathname = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/i, "");
+		if (!pathname) return null;
+		return `https://${parsed.hostname}/${pathname}`;
+	} catch {}
+	return value.replace(/\.git$/i, "");
+}
+async function readSnapshotGit(projectDir) {
+	try {
+		const defaultBranch = await readDefaultBranch(projectDir);
+		const { stdout: latestTsRaw } = await execFileAsync("git", [
+			"log",
+			"-1",
+			"--format=%ct"
+		], {
+			cwd: projectDir,
+			encoding: "utf8",
+			maxBuffer: 1024 * 1024
+		});
+		const latestSeconds = Number(latestTsRaw.trim());
+		const latestCommitTs = Number.isFinite(latestSeconds) && latestSeconds > 0 ? latestSeconds * 1e3 : null;
+		let repositoryUrl = null;
+		try {
+			const { stdout: remoteRaw } = await execFileAsync("git", [
+				"config",
+				"--get",
+				"remote.origin.url"
+			], {
+				cwd: projectDir,
+				encoding: "utf8",
+				maxBuffer: 1024 * 1024
+			});
+			repositoryUrl = normalizeRepositoryUrl(remoteRaw);
+		} catch {
+			repositoryUrl = null;
+		}
+		const { stdout: logOutput } = await execFileAsync("git", [
+			"log",
+			"-n",
+			"5",
+			"--format=__COMMIT__%x09%H%x09%ct%x09%s",
+			"--numstat",
+			"--"
+		], {
+			cwd: projectDir,
+			encoding: "utf8",
+			maxBuffer: 8 * 1024 * 1024
+		});
+		return {
+			defaultBranch,
+			repositoryUrl,
+			latestCommitTs,
+			recentCommits: parseRecentCommitLog(logOutput)
+		};
+	} catch {
+		return;
+	}
+}
 /**
 * Generate a complete data snapshot of the OpenSpec project
 * (Kept for backwards compatibility and testing)
@@ -4656,8 +4821,10 @@ async function generateSnapshot(projectDir) {
 	let configYaml;
 	let schemas = [];
 	const schemaDetails = {};
+	const schemaYamls = {};
 	const schemaResolutions = {};
 	const templates = {};
+	const templateContents = {};
 	const changeMetadata = {};
 	try {
 		configYaml = await readFile(join$1(projectDir, "openspec", "config.yaml"), "utf-8");
@@ -4675,16 +4842,56 @@ async function generateSnapshot(projectDir) {
 			const resolutionResult = await cliExecutor.schemaWhich(schema.name);
 			if (resolutionResult.success) {
 				const resolution = parseCliJson(resolutionResult.stdout, SchemaResolutionSchema, "openspec schema which");
-				schemaResolutions[schema.name] = resolution;
+				schemaResolutions[schema.name] = {
+					...resolution,
+					displayPath: toOpsxDisplayPath(resolution.path, {
+						source: resolution.source,
+						projectDir
+					}),
+					shadows: resolution.shadows.map((shadow) => ({
+						...shadow,
+						displayPath: toOpsxDisplayPath(shadow.path, {
+							source: shadow.source,
+							projectDir
+						})
+					}))
+				};
 				try {
 					const schemaContent = await readFile(join$1(resolution.path, "schema.yaml"), "utf-8");
 					schemaDetails[schema.name] = parseSchemaYaml(schemaContent);
+					schemaYamls[schema.name] = schemaContent;
 				} catch {}
 			}
 		} catch {}
 		try {
 			const templatesResult = await cliExecutor.templates(schema.name);
-			if (templatesResult.success) templates[schema.name] = parseCliJson(templatesResult.stdout, TemplatesSchema, "openspec templates");
+			if (templatesResult.success) {
+				const parsedTemplates = parseCliJson(templatesResult.stdout, TemplatesSchema, "openspec templates");
+				const normalizedTemplates = Object.fromEntries(Object.entries(parsedTemplates).map(([artifactId, info]) => [artifactId, {
+					...info,
+					path: toAbsoluteProjectPath(projectDir, info.path),
+					displayPath: toOpsxDisplayPath(info.path, {
+						source: info.source,
+						projectDir
+					})
+				}]));
+				templates[schema.name] = normalizedTemplates;
+				const contents = await Promise.all(Object.entries(normalizedTemplates).map(async ([artifactId, info]) => {
+					let content = null;
+					try {
+						content = await readFile(info.path, "utf-8");
+					} catch {
+						content = null;
+					}
+					return [artifactId, {
+						content,
+						path: info.path,
+						displayPath: info.displayPath,
+						source: info.source
+					}];
+				}));
+				templateContents[schema.name] = Object.fromEntries(contents);
+			}
 		} catch {}
 	}
 	try {
@@ -4695,6 +4902,7 @@ async function generateSnapshot(projectDir) {
 			changeMetadata[changeId] = null;
 		}
 	} catch {}
+	const git = await readSnapshotGit(projectDir);
 	return {
 		meta: {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4706,6 +4914,7 @@ async function generateSnapshot(projectDir) {
 			changesCount: changes.filter((c) => c !== null).length,
 			archivesCount: archives.length
 		},
+		git,
 		config: uiConfig,
 		specs,
 		changes: changes.filter((c) => c !== null),
@@ -4716,8 +4925,10 @@ async function generateSnapshot(projectDir) {
 			configYaml,
 			schemas,
 			schemaDetails,
+			schemaYamls,
 			schemaResolutions,
 			templates,
+			templateContents,
 			changeMetadata
 		}
 	};
@@ -4738,7 +4949,7 @@ function runCommand(cmd, args, cwd) {
 		const child = spawn(cmd, args, {
 			stdio: "inherit",
 			cwd,
-			shell: true
+			shell: false
 		});
 		child.on("close", (code) => {
 			if (code === 0) resolvePromise();
@@ -4747,6 +4958,11 @@ function runCommand(cmd, args, cwd) {
 		child.on("error", (err) => reject(err));
 	});
 }
+const LOCAL_PACKAGE_PROTOCOLS = [
+	"workspace:",
+	"file:",
+	"link:"
+];
 /**
 * Detect the package manager used in the current project
 */
@@ -4767,7 +4983,7 @@ function detectPackageManager() {
 	return "npm";
 }
 /**
-* Get the command to run a local binary (like vite)
+* Get the command to run a binary in a package-manager agnostic way.
 */
 function getRunCommand(pm, bin) {
 	switch (pm) {
@@ -4777,11 +4993,11 @@ function getRunCommand(pm, bin) {
 		};
 		case "pnpm": return {
 			cmd: "pnpm",
-			args: ["exec", bin]
+			args: ["dlx", bin]
 		};
 		case "yarn": return {
 			cmd: "yarn",
-			args: [bin]
+			args: ["dlx", bin]
 		};
 		case "deno": return {
 			cmd: "deno",
@@ -4797,12 +5013,36 @@ function getRunCommand(pm, bin) {
 		};
 	}
 }
+function findNearestPackageJson(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		const packageJsonPath = join$1(currentDir, "package.json");
+		if (existsSync(packageJsonPath)) return packageJsonPath;
+		const parentDir = dirname$1(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function readWebPackageRangeFromPackageJson(startDir) {
+	const packageJsonPath = findNearestPackageJson(startDir);
+	if (!packageJsonPath) return null;
+	try {
+		const packageJsonRaw = readFileSync(packageJsonPath, "utf-8");
+		const parsed = JSON.parse(packageJsonRaw);
+		return parsed.dependencies?.["@openspecui/web"] ?? parsed.devDependencies?.["@openspecui/web"] ?? parsed.peerDependencies?.["@openspecui/web"] ?? parsed.optionalDependencies?.["@openspecui/web"] ?? null;
+	} catch {
+		return null;
+	}
+}
+function isLocalPackageRange(range) {
+	if (!range) return false;
+	return LOCAL_PACKAGE_PROTOCOLS.some((protocol) => range.startsWith(protocol));
+}
 /**
 * Get the exec command for running a package binary
 * Uses appropriate flags to ensure the correct version of @openspecui/web is installed
 */
-function getExecCommand(pm) {
-	const webPkgSpec = `@openspecui/web@${devDependencies["@openspecui/web"]}`;
+function getExecCommand(pm, webPkgSpec) {
 	switch (pm) {
 		case "bun": return {
 			cmd: "bunx",
@@ -4867,7 +5107,9 @@ async function exportHtml(options) {
 	writeFileSync(dataJsonPath, JSON.stringify(snapshot, null, 2));
 	console.log(`Data snapshot written to ${dataJsonPath}`);
 	const localWebPkg = findLocalWebPackage();
-	if (localWebPkg) {
+	const webPackageRange = readWebPackageRangeFromPackageJson(__dirname$1);
+	if (isLocalPackageRange(webPackageRange)) {
+		if (!localWebPkg) throw new Error(`Detected local/dev @openspecui/web range "${webPackageRange}" but local web package was not found`);
 		console.log("\n[Local dev mode] Running SSG from local web package...");
 		await runCommand("pnpm", [
 			"tsx",
@@ -4882,7 +5124,7 @@ async function exportHtml(options) {
 	} else {
 		console.log("\n[Production mode] Running SSG via @openspecui/web...");
 		const pm = detectPackageManager();
-		const execCmd = getExecCommand(pm);
+		const execCmd = getExecCommand(pm, `@openspecui/web@${webPackageRange || version}`);
 		try {
 			await runCommand(execCmd.cmd, [
 				...execCmd.args,
@@ -5027,6 +5269,10 @@ async function main() {
 		}).option("preview-port", {
 			describe: "Port for the preview server (used with --open)",
 			type: "number"
+		}).option("port", {
+			alias: "p",
+			describe: "Alias of --open --preview-port <port>",
+			type: "number"
 		}).option("preview-host", {
 			describe: "Host for the preview server (used with --open)",
 			type: "string"
@@ -5034,6 +5280,8 @@ async function main() {
 	}, async (argv) => {
 		const projectDir = resolve$1(originalCwd, argv.dir || ".");
 		const outputDir = resolve$1(originalCwd, argv.output);
+		const previewPort = argv.port ?? argv["preview-port"];
+		const shouldOpen = argv.open || argv.port !== void 0;
 		try {
 			await exportStaticSite({
 				projectDir,
@@ -5041,16 +5289,16 @@ async function main() {
 				format: argv.format,
 				basePath: argv["base-path"],
 				clean: argv.clean,
-				open: argv.open,
-				previewPort: argv["preview-port"],
+				open: shouldOpen,
+				previewPort,
 				previewHost: argv["preview-host"]
 			});
-			if (!argv.open) process.exit(0);
+			if (!shouldOpen) process.exit(0);
 		} catch (error) {
 			console.error("❌ Export failed:", error);
 			process.exit(1);
 		}
-	}).example("$0", "Start server in current directory").example("$0 ./my-project", "Start server with specific project").example("$0 -p 8080", "Start server on custom port").example("$0 export -o ./dist", "Export HTML to ./dist directory").example("$0 export -o ./dist -f json", "Export JSON data only").example("$0 export -o ./dist --base-path=/docs/", "Export for subdirectory deployment").example("$0 export -o ./dist --clean", "Clean output directory before export").version(getVersion()).alias("v", "version").help().alias("h", "help").parse();
+	}).example("$0", "Start server in current directory").example("$0 ./my-project", "Start server with specific project").example("$0 -p 8080", "Start server on custom port").example("$0 export -o ./dist", "Export HTML to ./dist directory").example("$0 export -o ./dist -f json", "Export JSON data only").example("$0 export -o ./dist -p 8092", "Export and open preview on port 8092").example("$0 export -o ./dist --base-path=/docs/", "Export for subdirectory deployment").example("$0 export -o ./dist --clean", "Clean output directory before export").version(getVersion()).alias("v", "version").help().alias("h", "help").parse();
 }
 main();
 

package/dist/index.mjs

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

package/dist/{src-16GA3our.mjs → src-Brh3druE.mjs}

@@ -7094,6 +7094,68 @@ const DASHBOARD_METRIC_KEYS = [
 	"taskCompletionPercent"
 ];
 
+//#endregion
+//#region ../core/src/opsx-display-path.ts
+const VIRTUAL_PROJECT_DIRNAME = "project";
+const WINDOWS_DRIVE_PREFIX = /^[A-Za-z]:\//;
+function normalizeFsPath(path$1) {
+	return path$1.replace(/\\/g, "/").replace(/\/+$/g, "");
+}
+function isAbsolutePath(path$1) {
+	return path$1.startsWith("/") || WINDOWS_DRIVE_PREFIX.test(path$1);
+}
+function stripRelativePrefix(path$1) {
+	return path$1.replace(/^\.?\//, "");
+}
+function splitSegments(path$1) {
+	return normalizeFsPath(path$1).split("/").filter(Boolean);
+}
+function toNpmSpecifier(path$1) {
+	const normalized = normalizeFsPath(path$1);
+	const match$1 = /(?:^|\/)node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?(@[^/]+\/[^/]+|[^/]+)(\/.*)?/.exec(normalized);
+	const pkgName = match$1?.[1];
+	if (!pkgName) return null;
+	return `npm:${pkgName}${match$1[2] ?? ""}`;
+}
+function toVirtualProjectPath(path$1) {
+	return `${VIRTUAL_PROJECT_DIRNAME}:${stripRelativePrefix(path$1)}`;
+}
+function isPathInside(root, target) {
+	const normalizedRoot = normalizeFsPath(root);
+	const normalizedTarget = normalizeFsPath(target);
+	const rootLower = normalizedRoot.toLowerCase();
+	const targetLower = normalizedTarget.toLowerCase();
+	return targetLower === rootLower || targetLower.startsWith(`${rootLower}/`);
+}
+function toRelativeFromRoot(root, target) {
+	const rootSegments = splitSegments(root);
+	const targetSegments = splitSegments(target);
+	let index = 0;
+	while (index < rootSegments.length && index < targetSegments.length) {
+		if (rootSegments[index]?.toLowerCase() !== targetSegments[index]?.toLowerCase()) break;
+		index += 1;
+	}
+	return targetSegments.slice(index).join("/");
+}
+function findOpspecSlice(path$1) {
+	const segments = splitSegments(path$1);
+	const idx = segments.lastIndexOf("openspec");
+	if (idx < 0) return null;
+	return segments.slice(idx).join("/");
+}
+function toOpsxDisplayPath(absoluteOrRelativePath, options) {
+	const normalized = normalizeFsPath(absoluteOrRelativePath);
+	const npmSpecifier = toNpmSpecifier(normalized);
+	if (options?.source === "package" || npmSpecifier) {
+		if (npmSpecifier) return npmSpecifier;
+	}
+	if (!isAbsolutePath(normalized)) return toVirtualProjectPath(normalized);
+	if (options?.projectDir && isPathInside(options.projectDir, normalized)) return toVirtualProjectPath(toRelativeFromRoot(options.projectDir, normalized));
+	const openspecSlice = findOpspecSlice(normalized);
+	if (openspecSlice) return toVirtualProjectPath(openspecSlice);
+	return toVirtualProjectPath(splitSegments(normalized).slice(-4).join("/"));
+}
+
 //#endregion
 //#region ../core/src/opsx-types.ts
 const ArtifactStatusSchema = objectType({
@@ -7177,17 +7239,20 @@ const SchemaResolutionSchema = objectType({
 		"package"
 	]),
 	path: stringType(),
+	displayPath: stringType().optional(),
 	shadows: arrayType(objectType({
 		source: enumType([
 			"project",
 			"user",
 			"package"
 		]),
-		path: stringType()
+		path: stringType(),
+		displayPath: stringType().optional()
 	}))
 });
 const TemplatesSchema = recordType(objectType({
 	path: stringType(),
+	displayPath: stringType().optional(),
 	source: enumType([
 		"project",
 		"user",
@@ -13884,6 +13949,12 @@ function parseCliJson(raw$1, schema$6, label) {
 function toRelativePath(root, absolutePath) {
 	return relative$1(root, absolutePath).split(sep).join("/");
 }
+function isAbsoluteFsPath(path$1) {
+	return path$1.startsWith("/") || /^[A-Za-z]:\//.test(path$1);
+}
+function toAbsoluteProjectPath(projectDir, path$1) {
+	return isAbsoluteFsPath(path$1.replace(/\\/g, "/")) ? path$1 : resolve$1(projectDir, path$1);
+}
 async function readEntriesUnderRoot(root) {
 	if (!(await reactiveStat(root))?.isDirectory) return [];
 	const collectEntries = async (dir) => {
@@ -14322,7 +14393,21 @@ var OpsxKernel = class {
 		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");
+		const parsed = parseCliJson(result.stdout, SchemaResolutionSchema, "openspec schema which");
+		return {
+			...parsed,
+			displayPath: toOpsxDisplayPath(parsed.path, {
+				source: parsed.source,
+				projectDir: this.projectDir
+			}),
+			shadows: parsed.shadows.map((shadow) => ({
+				...shadow,
+				displayPath: toOpsxDisplayPath(shadow.path, {
+					source: shadow.source,
+					projectDir: this.projectDir
+				})
+			}))
+		};
 	}
 	async fetchSchemaDetail(name) {
 		await touchOpsxProjectDeps(this.projectDir);
@@ -14346,7 +14431,15 @@ var OpsxKernel = class {
 		await touchOpsxProjectDeps(this.projectDir);
 		const result = await this.cliExecutor.templates(schema$6);
 		if (!result.success) throw new Error(result.stderr || `openspec templates failed (exit ${result.exitCode ?? "null"})`);
-		return parseCliJson(result.stdout, TemplatesSchema, "openspec templates");
+		const templates = parseCliJson(result.stdout, TemplatesSchema, "openspec templates");
+		return Object.fromEntries(Object.entries(templates).map(([artifactId, info]) => [artifactId, {
+			...info,
+			path: toAbsoluteProjectPath(this.projectDir, info.path),
+			displayPath: toOpsxDisplayPath(info.path, {
+				source: info.source,
+				projectDir: this.projectDir
+			})
+		}]));
 	}
 	async fetchTemplateContents(schema$6) {
 		await this.ensureTemplates(schema$6);
@@ -14355,6 +14448,10 @@ var OpsxKernel = class {
 			return [artifactId, {
 				content: await reactiveReadFile(info.path),
 				path: info.path,
+				displayPath: info.displayPath ?? toOpsxDisplayPath(info.path, {
+					source: info.source,
+					projectDir: this.projectDir
+				}),
 				source: info.source
 			}];
 		}));
@@ -25370,4 +25467,4 @@ async function startServer$1(options = {}) {
 }
 
 //#endregion
-export { SchemaInfoSchema as a, CliExecutor as c, OpenSpecAdapter as d, __commonJS$1 as f, SchemaDetailSchema as i, ConfigManager as l, createServer$2 as n, SchemaResolutionSchema as o, __toESM$1 as p, require_dist as r, TemplatesSchema as s, startServer$1 as t, DEFAULT_CONFIG as u };
+export { SchemaInfoSchema as a, toOpsxDisplayPath as c, DEFAULT_CONFIG as d, OpenSpecAdapter as f, SchemaDetailSchema as i, CliExecutor as l, __toESM$1 as m, createServer$2 as n, SchemaResolutionSchema as o, __commonJS$1 as p, require_dist as r, TemplatesSchema as s, startServer$1 as t, ConfigManager as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openspecui",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "OpenSpec UI - Visual interface for spec-driven development",
   "type": "module",
   "main": "dist/index.mjs",
@@ -33,8 +33,8 @@
     "typescript": "^5.7.2",
     "vitest": "^2.1.8",
     "yargs": "^18.0.0",
-    "@openspecui/server": "1.5.0",
-    "@openspecui/web": "1.5.0"
+    "@openspecui/server": "1.6.0",
+    "@openspecui/web": "1.6.0"
   },
   "scripts": {
     "build": "pnpm run build:web && pnpm run build:copy-web && tsdown",

package/web/assets/{BufferResource-Bn1UWy0D.js → BufferResource-LpIscPOh.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-T8xoxmUb.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-CKfGQiMr.js";const x={name:"local-uniform-bit",vertex:{header:`
 
             struct LocalUniforms {
                 uTransformMatrix:mat3x3<f32>,