openspecui 1.4.0 → 1.5.0

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

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
-import { createServer } from "http";
+import { createServer } from "node:net";
+import { createServer as createServer$1 } from "http";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import crypto from "crypto";
@@ -9,13 +10,14 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { mkdir as mkdir$1, readFile as readFile$1, readdir, rm, stat, writeFile as writeFile$1 } from "node:fs/promises";
 import { dirname as dirname$1, join as join$1, matchesGlob, relative as relative$1, resolve as resolve$1, sep } from "node:path";
 import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { watch } from "fs";
 import { EventEmitter } from "events";
+import { watch } from "fs";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
-import { createServer as createServer$1 } from "node:net";
 import * as pty from "@lydell/node-pty";
+import { execFile } from "node:child_process";
 import { EventEmitter as EventEmitter$1 } from "node:events";
+import { promisify as promisify$1 } from "node:util";
 import { Worker as Worker$1 } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
 
@@ -49,6 +51,41 @@ var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region ../server/src/port-utils.ts
+/**
+* Check if a port is available by trying to listen on it.
+* Uses default binding (both IPv4 and IPv6) to detect conflicts.
+*/
+function isPortAvailable(port) {
+	return new Promise((resolve$2) => {
+		const server = createServer();
+		server.once("error", () => {
+			resolve$2(false);
+		});
+		server.once("listening", () => {
+			server.close(() => resolve$2(true));
+		});
+		server.listen(port);
+	});
+}
+/**
+* Find an available port starting from the given port.
+* Will try up to maxAttempts ports sequentially.
+*
+* @param startPort - The preferred port to start checking from
+* @param maxAttempts - Maximum number of ports to try (default: 10)
+* @returns The first available port found
+* @throws Error if no available port is found in the range
+*/
+async function findAvailablePort(startPort, maxAttempts = 10) {
+	for (let i = 0; i < maxAttempts; i++) {
+		const port = startPort + i;
+		if (await isPortAvailable(port)) return port;
+	}
+	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/@hono+node-server@1.19.6_hono@4.10.6/node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
@@ -476,7 +513,7 @@ var createAdaptorServer = (options) => {
 		overrideGlobalObjects: options.overrideGlobalObjects,
 		autoCleanupIncoming: options.autoCleanupIncoming
 	});
-	return (options.createServer || createServer)(options.serverOptions || {}, requestListener);
+	return (options.createServer || createServer$1)(options.serverOptions || {}, requestListener);
 };
 var serve = (options, listeningListener) => {
 	const server = createAdaptorServer(options);
@@ -697,14 +734,14 @@ var MarkdownParser = class {
 			if (currentOperation === "RENAMED") {
 				const fromMatch = line.match(/FROM:\s*`?###\s*Requirement:\s*(.+?)`?$/i);
 				const toMatch = line.match(/TO:\s*`?###\s*Requirement:\s*(.+?)`?$/i);
-				if (fromMatch) renameBuffer = {
-					...renameBuffer ?? {},
-					from: fromMatch[1].trim()
-				};
-				if (toMatch) renameBuffer = {
-					...renameBuffer ?? {},
-					to: toMatch[1].trim()
-				};
+				if (fromMatch) {
+					if (!renameBuffer) renameBuffer = {};
+					renameBuffer.from = fromMatch[1].trim();
+				}
+				if (toMatch) {
+					if (!renameBuffer) renameBuffer = {};
+					renameBuffer.to = toMatch[1].trim();
+				}
 				if (renameBuffer?.from && renameBuffer?.to) {
 					deltas.push({
 						spec: deltaSpec.specId,
@@ -789,86 +826,6 @@ var MarkdownParser = class {
 	}
 };
 
-//#endregion
-//#region ../core/src/validator.ts
-/**
-* Validator for OpenSpec documents
-*/
-var Validator = class {
-	/**
-	* Validate a spec document
-	*/
-	validateSpec(spec) {
-		const issues = [];
-		if (!spec.overview || spec.overview.trim().length === 0) issues.push({
-			severity: "ERROR",
-			message: "Spec must have a Purpose/Overview section",
-			path: "overview"
-		});
-		if (spec.requirements.length === 0) issues.push({
-			severity: "ERROR",
-			message: "Spec must have at least one requirement",
-			path: "requirements"
-		});
-		for (const req of spec.requirements) {
-			if (!req.text.includes("SHALL") && !req.text.includes("MUST")) issues.push({
-				severity: "WARNING",
-				message: `Requirement should contain "SHALL" or "MUST": ${req.id}`,
-				path: `requirements.${req.id}`
-			});
-			if (req.scenarios.length === 0) issues.push({
-				severity: "WARNING",
-				message: `Requirement should have at least one scenario: ${req.id}`,
-				path: `requirements.${req.id}.scenarios`
-			});
-			if (req.text.length > 1e3) issues.push({
-				severity: "WARNING",
-				message: `Requirement text is too long (max 1000 chars): ${req.id}`,
-				path: `requirements.${req.id}.text`
-			});
-		}
-		return {
-			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
-			issues
-		};
-	}
-	/**
-	* Validate a change proposal
-	*/
-	validateChange(change) {
-		const issues = [];
-		if (!change.why || change.why.length < 50) issues.push({
-			severity: "ERROR",
-			message: "Change \"Why\" section must be at least 50 characters",
-			path: "why"
-		});
-		if (change.why && change.why.length > 500) issues.push({
-			severity: "WARNING",
-			message: "Change \"Why\" section should be under 500 characters",
-			path: "why"
-		});
-		if (!change.whatChanges || change.whatChanges.trim().length === 0) issues.push({
-			severity: "ERROR",
-			message: "Change must have a \"What Changes\" section",
-			path: "whatChanges"
-		});
-		if (change.deltas.length === 0) issues.push({
-			severity: "WARNING",
-			message: "Change should have at least one delta",
-			path: "deltas"
-		});
-		if (change.deltas.length > 50) issues.push({
-			severity: "WARNING",
-			message: "Change has too many deltas (max 50)",
-			path: "deltas"
-		});
-		return {
-			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
-			issues
-		};
-	}
-};
-
 //#endregion
 //#region ../core/src/reactive-fs/reactive-state.ts
 /**
@@ -1713,6 +1670,86 @@ async function reactiveStat(path$1) {
 	return state.get();
 }
 
+//#endregion
+//#region ../core/src/validator.ts
+/**
+* Validator for OpenSpec documents
+*/
+var Validator = class {
+	/**
+	* Validate a spec document
+	*/
+	validateSpec(spec) {
+		const issues = [];
+		if (!spec.overview || spec.overview.trim().length === 0) issues.push({
+			severity: "ERROR",
+			message: "Spec must have a Purpose/Overview section",
+			path: "overview"
+		});
+		if (spec.requirements.length === 0) issues.push({
+			severity: "ERROR",
+			message: "Spec must have at least one requirement",
+			path: "requirements"
+		});
+		for (const req of spec.requirements) {
+			if (!req.text.includes("SHALL") && !req.text.includes("MUST")) issues.push({
+				severity: "WARNING",
+				message: `Requirement should contain "SHALL" or "MUST": ${req.id}`,
+				path: `requirements.${req.id}`
+			});
+			if (req.scenarios.length === 0) issues.push({
+				severity: "WARNING",
+				message: `Requirement should have at least one scenario: ${req.id}`,
+				path: `requirements.${req.id}.scenarios`
+			});
+			if (req.text.length > 1e3) issues.push({
+				severity: "WARNING",
+				message: `Requirement text is too long (max 1000 chars): ${req.id}`,
+				path: `requirements.${req.id}.text`
+			});
+		}
+		return {
+			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
+			issues
+		};
+	}
+	/**
+	* Validate a change proposal
+	*/
+	validateChange(change) {
+		const issues = [];
+		if (!change.why || change.why.length < 50) issues.push({
+			severity: "ERROR",
+			message: "Change \"Why\" section must be at least 50 characters",
+			path: "why"
+		});
+		if (change.why && change.why.length > 500) issues.push({
+			severity: "WARNING",
+			message: "Change \"Why\" section should be under 500 characters",
+			path: "why"
+		});
+		if (!change.whatChanges || change.whatChanges.trim().length === 0) issues.push({
+			severity: "ERROR",
+			message: "Change must have a \"What Changes\" section",
+			path: "whatChanges"
+		});
+		if (change.deltas.length === 0) issues.push({
+			severity: "WARNING",
+			message: "Change should have at least one delta",
+			path: "deltas"
+		});
+		if (change.deltas.length > 50) issues.push({
+			severity: "WARNING",
+			message: "Change has too many deltas (max 50)",
+			path: "deltas"
+		});
+		return {
+			valid: issues.filter((i) => i.severity === "ERROR").length === 0,
+			issues
+		};
+	}
+};
+
 //#endregion
 //#region ../core/src/adapter.ts
 /**
@@ -1892,17 +1929,17 @@ var OpenSpecAdapter = class {
 			const fullPath = join(dir, name);
 			const statInfo = await reactiveStat(fullPath);
 			if (!statInfo) continue;
-			const relativePath = fullPath.slice(root.length + 1);
+			const relativePath$1 = fullPath.slice(root.length + 1);
 			if (statInfo.isDirectory) {
 				files.push({
-					path: relativePath,
+					path: relativePath$1,
 					type: "directory"
 				});
 				files.push(...await this.collectChangeFiles(root, fullPath));
 			} else {
 				const content = await reactiveReadFile(fullPath);
 				files.push({
-					path: relativePath,
+					path: relativePath$1,
 					type: "file",
 					content: content ?? void 0
 				});
@@ -6244,6 +6281,7 @@ const TerminalConfigSchema = objectType({
 	scrollback: numberType().min(0).max(1e5).default(1e3),
 	rendererEngine: stringType().default("xterm")
 });
+const DashboardConfigSchema = objectType({ trendPointLimit: numberType().int().min(20).max(500).default(100) });
 /**
 * OpenSpecUI 配置 Schema
 *
@@ -6255,13 +6293,15 @@ const OpenSpecUIConfigSchema = objectType({
 		args: arrayType(stringType()).optional()
 	}).default({}),
 	theme: enumType(THEME_VALUES).default("system"),
-	terminal: TerminalConfigSchema.default(TerminalConfigSchema.parse({}))
+	terminal: TerminalConfigSchema.default(TerminalConfigSchema.parse({})),
+	dashboard: DashboardConfigSchema.default(DashboardConfigSchema.parse({}))
 });
 /** 默认配置（静态，用于测试和类型） */
 const DEFAULT_CONFIG = {
 	cli: {},
 	theme: "system",
-	terminal: TerminalConfigSchema.parse({})
+	terminal: TerminalConfigSchema.parse({}),
+	dashboard: DashboardConfigSchema.parse({})
 };
 /**
 * 配置管理器
@@ -6327,6 +6367,10 @@ var ConfigManager = class {
 			terminal: {
 				...current.terminal,
 				...config.terminal
+			},
+			dashboard: {
+				...current.dashboard,
+				...config.dashboard
 			}
 		};
 		const serialized = JSON.stringify(merged, null, 2);
@@ -7039,6 +7083,17 @@ async function getConfiguredTools(projectDir) {
 	return state.get();
 }
 
+//#endregion
+//#region ../core/src/dashboard-types.ts
+const DASHBOARD_METRIC_KEYS = [
+	"specifications",
+	"requirements",
+	"activeChanges",
+	"inProgressChanges",
+	"completedChanges",
+	"taskCompletionPercent"
+];
+
 //#endregion
 //#region ../core/src/opsx-types.ts
 const ArtifactStatusSchema = objectType({
@@ -13838,10 +13893,10 @@ async function readEntriesUnderRoot(root) {
 			const fullPath = join$1(dir, name);
 			const statInfo = await reactiveStat(fullPath);
 			if (!statInfo) continue;
-			const relativePath = toRelativePath(root, fullPath);
+			const relativePath$1 = toRelativePath(root, fullPath);
 			if (statInfo.isDirectory) {
 				entries.push({
-					path: relativePath,
+					path: relativePath$1,
 					type: "directory"
 				});
 				entries.push(...await collectEntries(fullPath));
@@ -13849,7 +13904,7 @@ async function readEntriesUnderRoot(root) {
 				const content = await reactiveReadFile(fullPath);
 				const size = content ? Buffer.byteLength(content, "utf-8") : void 0;
 				entries.push({
-					path: relativePath,
+					path: relativePath$1,
 					type: "file",
 					content: content ?? void 0,
 					size
@@ -22659,41 +22714,6 @@ var import_sender = /* @__PURE__ */ __toESM$1(require_sender(), 1);
 var import_websocket = /* @__PURE__ */ __toESM$1(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM$1(require_websocket_server(), 1);
 
-//#endregion
-//#region ../server/src/port-utils.ts
-/**
-* Check if a port is available by trying to listen on it.
-* Uses default binding (both IPv4 and IPv6) to detect conflicts.
-*/
-function isPortAvailable(port) {
-	return new Promise((resolve$2) => {
-		const server = createServer$1();
-		server.once("error", () => {
-			resolve$2(false);
-		});
-		server.once("listening", () => {
-			server.close(() => resolve$2(true));
-		});
-		server.listen(port);
-	});
-}
-/**
-* Find an available port starting from the given port.
-* Will try up to maxAttempts ports sequentially.
-*
-* @param startPort - The preferred port to start checking from
-* @param maxAttempts - Maximum number of ports to try (default: 10)
-* @returns The first available port found
-* @throws Error if no available port is found in the range
-*/
-async function findAvailablePort(startPort, maxAttempts = 10) {
-	for (let i = 0; i < maxAttempts; i++) {
-		const port = startPort + i;
-		if (await isPortAvailable(port)) return port;
-	}
-	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
-}
-
 //#endregion
 //#region ../server/src/pty-manager.ts
 const DEFAULT_SCROLLBACK = 1e3;
@@ -23064,7 +23084,7 @@ function createPtyWebSocketHandler(ptyManager) {
 }
 
 //#endregion
-//#region ../search/dist/worker-source-CMPZlh9-.mjs
+//#region ../search/src/protocol.ts
 const SearchDocumentKindSchema = enumType([
 	"spec",
 	"change",
@@ -23130,6 +23150,9 @@ const SearchWorkerResponseSchema = discriminatedUnionType("type", [
 		message: stringType()
 	})
 ]);
+
+//#endregion
+//#region ../search/src/worker-source.ts
 const sharedRuntimeSource = String.raw`
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
@@ -23347,6 +23370,368 @@ function createCliStreamObservable(startStream) {
 	});
 }
 
+//#endregion
+//#region ../server/src/dashboard-git-snapshot.ts
+const execFileAsync$1 = promisify$1(execFile);
+const EMPTY_DIFF = {
+	files: 0,
+	insertions: 0,
+	deletions: 0
+};
+async function defaultRunGit(cwd, args) {
+	try {
+		const { stdout } = await execFileAsync$1("git", args, {
+			cwd,
+			encoding: "utf8",
+			maxBuffer: 8 * 1024 * 1024
+		});
+		return {
+			ok: true,
+			stdout
+		};
+	} catch {
+		return {
+			ok: false,
+			stdout: ""
+		};
+	}
+}
+function parseShortStat(output) {
+	const files = Number(/(\d+)\s+files? changed/.exec(output)?.[1] ?? 0);
+	const insertions = Number(/(\d+)\s+insertions?\(\+\)/.exec(output)?.[1] ?? 0);
+	const deletions = Number(/(\d+)\s+deletions?\(-\)/.exec(output)?.[1] ?? 0);
+	return {
+		files: Number.isFinite(files) ? files : 0,
+		insertions: Number.isFinite(insertions) ? insertions : 0,
+		deletions: Number.isFinite(deletions) ? deletions : 0
+	};
+}
+function parseNumStat(output) {
+	let files = 0;
+	let insertions = 0;
+	let deletions = 0;
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const [addRaw, deleteRaw] = trimmed.split("	");
+		if (!addRaw || !deleteRaw) continue;
+		files += 1;
+		if (addRaw !== "-") insertions += Number(addRaw) || 0;
+		if (deleteRaw !== "-") deletions += Number(deleteRaw) || 0;
+	}
+	return {
+		files,
+		insertions,
+		deletions
+	};
+}
+function normalizeGitPath(path$1) {
+	return path$1.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function relativePath(fromDir, target) {
+	const rel = relative$1(fromDir, target);
+	if (!rel || rel.length === 0) return ".";
+	return rel;
+}
+function parseBranchName(branchRef, detached) {
+	if (detached) return "(detached)";
+	if (!branchRef) return "(unknown)";
+	return branchRef.replace(/^refs\/heads\//, "");
+}
+function parseWorktreeList(porcelain) {
+	const entries = [];
+	let current = null;
+	const flush = () => {
+		if (!current) return;
+		entries.push(current);
+		current = null;
+	};
+	for (const line of porcelain.split("\n")) {
+		if (line.startsWith("worktree ")) {
+			flush();
+			current = {
+				path: line.slice(9).trim(),
+				branchRef: null,
+				detached: false
+			};
+			continue;
+		}
+		if (!current) continue;
+		if (line.startsWith("branch ")) {
+			current.branchRef = line.slice(7).trim();
+			continue;
+		}
+		if (line === "detached") {
+			current.detached = true;
+			continue;
+		}
+	}
+	flush();
+	return entries;
+}
+function parseRelatedChanges(paths) {
+	const related = /* @__PURE__ */ new Set();
+	for (const path$1 of paths) {
+		const normalized = normalizeGitPath(path$1);
+		const activeMatch = /^openspec\/changes\/([^/]+)\//.exec(normalized);
+		if (activeMatch?.[1]) {
+			related.add(activeMatch[1]);
+			continue;
+		}
+		const archiveMatch = /^openspec\/changes\/archive\/([^/]+)\//.exec(normalized);
+		if (archiveMatch?.[1]) {
+			const fullName = archiveMatch[1];
+			related.add(fullName.replace(/^\d{4}-\d{2}-\d{2}-/, ""));
+		}
+	}
+	return [...related].sort((a, b) => a.localeCompare(b));
+}
+async function resolveDefaultBranch(projectDir, runGit) {
+	const remoteHead = await runGit(projectDir, [
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"refs/remotes/origin/HEAD"
+	]);
+	const remoteRef = remoteHead.stdout.trim();
+	if (remoteHead.ok && remoteRef) return remoteRef;
+	const localHead = await runGit(projectDir, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]);
+	const localRef = localHead.stdout.trim();
+	if (localHead.ok && localRef && localRef !== "HEAD") return localRef;
+	return "main";
+}
+async function collectCommitEntries(options) {
+	const { worktreePath, defaultBranch, maxCommitEntries, runGit } = options;
+	const entries = [];
+	const commits = await runGit(worktreePath, [
+		"log",
+		"--format=%H%x1f%s",
+		`-n${maxCommitEntries}`,
+		`${defaultBranch}..HEAD`
+	]);
+	if (commits.ok) for (const line of commits.stdout.split("\n")) {
+		if (!line.trim()) continue;
+		const [hash, title = ""] = line.split("");
+		if (!hash) continue;
+		const diffResult = await runGit(worktreePath, [
+			"show",
+			"--numstat",
+			"--format=",
+			hash
+		]);
+		const changedFiles = (await runGit(worktreePath, [
+			"show",
+			"--name-only",
+			"--format=",
+			hash
+		])).stdout.split("\n").map((item) => item.trim()).filter((item) => item.length > 0);
+		entries.push({
+			type: "commit",
+			hash,
+			title: title.trim() || hash.slice(0, 7),
+			relatedChanges: parseRelatedChanges(changedFiles),
+			diff: diffResult.ok ? parseNumStat(diffResult.stdout) : EMPTY_DIFF
+		});
+	}
+	const trackedResult = await runGit(worktreePath, [
+		"diff",
+		"--numstat",
+		"HEAD"
+	]);
+	const trackedFilesResult = await runGit(worktreePath, [
+		"diff",
+		"--name-only",
+		"HEAD"
+	]);
+	const untrackedResult = await runGit(worktreePath, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]);
+	const trackedFiles = trackedFilesResult.stdout.split("\n").map((item) => item.trim()).filter((item) => item.length > 0);
+	const untrackedFiles = untrackedResult.stdout.split("\n").map((item) => item.trim()).filter((item) => item.length > 0);
+	const allUncommittedFiles = new Set([...trackedFiles, ...untrackedFiles]);
+	const trackedDiff = trackedResult.ok ? parseNumStat(trackedResult.stdout) : EMPTY_DIFF;
+	entries.push({
+		type: "uncommitted",
+		title: "Uncommitted",
+		relatedChanges: parseRelatedChanges([...allUncommittedFiles]),
+		diff: {
+			files: allUncommittedFiles.size,
+			insertions: trackedDiff.insertions,
+			deletions: trackedDiff.deletions
+		}
+	});
+	return entries;
+}
+async function collectWorktree(options) {
+	const { projectDir, worktree, defaultBranch, runGit, maxCommitEntries } = options;
+	const worktreePath = resolve$1(worktree.path);
+	const resolvedProjectDir = resolve$1(projectDir);
+	const aheadBehindResult = await runGit(worktreePath, [
+		"rev-list",
+		"--left-right",
+		"--count",
+		`${defaultBranch}...HEAD`
+	]);
+	let ahead = 0;
+	let behind = 0;
+	if (aheadBehindResult.ok) {
+		const [behindRaw, aheadRaw] = aheadBehindResult.stdout.trim().split(/\s+/);
+		ahead = Number(aheadRaw) || 0;
+		behind = Number(behindRaw) || 0;
+	}
+	const diffResult = await runGit(worktreePath, [
+		"diff",
+		"--shortstat",
+		`${defaultBranch}...HEAD`
+	]);
+	const diff = diffResult.ok ? parseShortStat(diffResult.stdout) : EMPTY_DIFF;
+	const entries = await collectCommitEntries({
+		worktreePath,
+		defaultBranch,
+		maxCommitEntries,
+		runGit
+	});
+	return {
+		path: worktreePath,
+		relativePath: relativePath(resolvedProjectDir, worktreePath),
+		branchName: parseBranchName(worktree.branchRef, worktree.detached),
+		isCurrent: resolvedProjectDir === worktreePath,
+		ahead,
+		behind,
+		diff,
+		entries
+	};
+}
+async function buildDashboardGitSnapshot(options) {
+	const runGit = options.runGit ?? defaultRunGit;
+	const maxCommitEntries = options.maxCommitEntries ?? 8;
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	const defaultBranch = await resolveDefaultBranch(resolvedProjectDir, runGit);
+	const worktreeResult = await runGit(resolvedProjectDir, [
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	const parsed = worktreeResult.ok ? parseWorktreeList(worktreeResult.stdout) : [];
+	const baseWorktrees = parsed.length > 0 ? parsed : [{
+		path: resolvedProjectDir,
+		branchRef: null,
+		detached: false
+	}];
+	const worktrees = await Promise.all(baseWorktrees.map((worktree) => collectWorktree({
+		projectDir: resolvedProjectDir,
+		worktree,
+		defaultBranch,
+		runGit,
+		maxCommitEntries
+	})));
+	worktrees.sort((a, b) => {
+		if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
+		return a.branchName.localeCompare(b.branchName);
+	});
+	return {
+		defaultBranch,
+		worktrees
+	};
+}
+
+//#endregion
+//#region ../server/src/dashboard-time-trends.ts
+const MIN_TREND_POINT_LIMIT = 20;
+const MAX_TREND_POINT_LIMIT = 500;
+const DEFAULT_TREND_POINT_LIMIT = 100;
+const TARGET_TREND_BARS = 20;
+const DAY_MS = 1440 * 60 * 1e3;
+function clampPointLimit(pointLimit) {
+	if (!Number.isFinite(pointLimit)) return DEFAULT_TREND_POINT_LIMIT;
+	return Math.max(MIN_TREND_POINT_LIMIT, Math.min(MAX_TREND_POINT_LIMIT, Math.trunc(pointLimit)));
+}
+function createEmptyTrendSeries() {
+	return Object.fromEntries(DASHBOARD_METRIC_KEYS.map((metric) => [metric, []]));
+}
+function normalizeEvents(events, pointLimit) {
+	return events.filter((event) => Number.isFinite(event.ts) && event.ts > 0 && Number.isFinite(event.value)).sort((a, b) => a.ts - b.ts).slice(-pointLimit);
+}
+function buildTimeWindow(options) {
+	const { probeEvents, targetBars, rightEdgeTs } = options;
+	if (probeEvents.length === 0) return null;
+	const probeEnd = probeEvents[probeEvents.length - 1].ts;
+	const end = typeof rightEdgeTs === "number" && Number.isFinite(rightEdgeTs) && rightEdgeTs > 0 ? Math.max(probeEnd, rightEdgeTs) : probeEnd;
+	const probeStart = probeEvents[0].ts;
+	const rangeMs = Math.max(1, end - probeStart);
+	const bucketMs = rangeMs >= DAY_MS ? Math.max(DAY_MS, Math.ceil(rangeMs / targetBars / DAY_MS) * DAY_MS) : Math.max(1, Math.ceil(rangeMs / targetBars));
+	const windowStart = end - bucketMs * targetBars;
+	return {
+		windowStart,
+		bucketMs,
+		bucketEnds: Array.from({ length: targetBars }, (_, index) => windowStart + bucketMs * (index + 1))
+	};
+}
+function bucketizeTrend(events, reducer, rightEdgeTs) {
+	if (events.length === 0) return [];
+	const timeWindow = buildTimeWindow({
+		probeEvents: events,
+		targetBars: TARGET_TREND_BARS,
+		rightEdgeTs
+	});
+	if (!timeWindow) return [];
+	const { windowStart, bucketMs, bucketEnds } = timeWindow;
+	const sums = Array.from({ length: bucketEnds.length }, () => 0);
+	const counts = Array.from({ length: bucketEnds.length }, () => 0);
+	let baseline = 0;
+	for (const event of events) {
+		if (event.ts <= windowStart) {
+			if (reducer === "sum-cumulative") baseline += event.value;
+			continue;
+		}
+		const offset = event.ts - windowStart;
+		const index = Math.max(0, Math.min(bucketEnds.length - 1, Math.ceil(offset / bucketMs) - 1));
+		sums[index] += event.value;
+		counts[index] += 1;
+	}
+	let cumulative = baseline;
+	let carry = baseline !== 0 ? baseline : events[0].value;
+	return bucketEnds.map((ts, index) => {
+		if (reducer === "sum") return {
+			ts,
+			value: sums[index]
+		};
+		if (reducer === "sum-cumulative") {
+			cumulative += sums[index];
+			return {
+				ts,
+				value: cumulative
+			};
+		}
+		if (counts[index] > 0) carry = sums[index] / counts[index];
+		return {
+			ts,
+			value: carry
+		};
+	});
+}
+function buildDashboardTimeTrends(options) {
+	const pointLimit = clampPointLimit(options.pointLimit);
+	const trends = createEmptyTrendSeries();
+	for (const metric of DASHBOARD_METRIC_KEYS) {
+		if (options.availability[metric].state !== "ok") continue;
+		trends[metric] = bucketizeTrend(normalizeEvents(options.events[metric], pointLimit), options.reducers?.[metric] ?? "sum", options.rightEdgeTs);
+	}
+	return {
+		trends,
+		trendMeta: {
+			pointLimit,
+			lastUpdatedAt: options.timestamp
+		}
+	};
+}
+
 //#endregion
 //#region ../server/src/reactive-kv.ts
 /**
@@ -23467,6 +23852,76 @@ function createReactiveSubscriptionWithInput(task) {
 const t = initTRPC.context().create();
 const router = t.router;
 const publicProcedure = t.procedure;
+const execFileAsync = promisify$1(execFile);
+const dashboardGitTaskStatusEmitter = new EventEmitter$1();
+dashboardGitTaskStatusEmitter.setMaxListeners(200);
+const dashboardGitTaskStatus = {
+	running: false,
+	inFlight: 0,
+	lastStartedAt: null,
+	lastFinishedAt: null,
+	lastReason: null,
+	lastError: null
+};
+function getDashboardGitTaskStatus() {
+	return { ...dashboardGitTaskStatus };
+}
+function emitDashboardGitTaskStatus() {
+	dashboardGitTaskStatusEmitter.emit("change", getDashboardGitTaskStatus());
+}
+function beginDashboardGitTask(reason) {
+	dashboardGitTaskStatus.inFlight += 1;
+	dashboardGitTaskStatus.running = true;
+	dashboardGitTaskStatus.lastStartedAt = Date.now();
+	dashboardGitTaskStatus.lastReason = reason;
+	dashboardGitTaskStatus.lastError = null;
+	emitDashboardGitTaskStatus();
+}
+function endDashboardGitTask(error) {
+	dashboardGitTaskStatus.inFlight = Math.max(0, dashboardGitTaskStatus.inFlight - 1);
+	dashboardGitTaskStatus.running = dashboardGitTaskStatus.inFlight > 0;
+	dashboardGitTaskStatus.lastFinishedAt = Date.now();
+	if (error) dashboardGitTaskStatus.lastError = error instanceof Error ? error.message : String(error);
+	emitDashboardGitTaskStatus();
+}
+function parseGitDirFromDotGitFile(content) {
+	const line = content.split(/\r?\n/).map((item) => item.trim()).find((item) => item.startsWith("gitdir:"));
+	if (!line) return null;
+	const rawPath = line.slice(7).trim();
+	return rawPath.length > 0 ? rawPath : null;
+}
+function getDashboardGitRefreshStampPath(projectDir) {
+	return join$1(projectDir, "openspec", ".openspecui-dashboard-git-refresh.stamp");
+}
+async function touchDashboardGitRefreshStamp(projectDir, reason) {
+	const stampPath = getDashboardGitRefreshStampPath(projectDir);
+	await mkdir$1(dirname$1(stampPath), { recursive: true });
+	await writeFile$1(stampPath, `${Date.now()} ${reason}\n`, "utf8");
+}
+async function registerDashboardGitReactiveDeps(projectDir) {
+	await reactiveReadDir(projectDir, {
+		includeHidden: true,
+		exclude: ["node_modules"]
+	});
+	await reactiveReadFile(getDashboardGitRefreshStampPath(projectDir));
+	const dotGitPath = join$1(projectDir, ".git");
+	if (!await reactiveExists(dotGitPath)) return;
+	const dotGitFileContent = await reactiveReadFile(dotGitPath);
+	if (dotGitFileContent !== null) {
+		const gitDirRaw = parseGitDirFromDotGitFile(dotGitFileContent);
+		if (!gitDirRaw) return;
+		const gitDirPath = resolve$1(projectDir, gitDirRaw);
+		await reactiveReadDir(gitDirPath, { includeHidden: true });
+		await reactiveReadFile(join$1(gitDirPath, "HEAD"));
+		await reactiveReadFile(join$1(gitDirPath, "index"));
+		await reactiveReadFile(join$1(gitDirPath, "packed-refs"));
+		return;
+	}
+	await reactiveReadDir(dotGitPath, { includeHidden: true });
+	await reactiveReadFile(join$1(dotGitPath, "HEAD"));
+	await reactiveReadFile(join$1(dotGitPath, "index"));
+	await reactiveReadFile(join$1(dotGitPath, "packed-refs"));
+}
 function requireChangeId(changeId) {
 	if (!changeId) throw new Error("change is required");
 	return changeId;
@@ -23548,6 +24003,200 @@ function buildSystemStatus(ctx) {
 		watcherLastReinitializeReason: runtime?.lastReinitializeReason ?? null
 	};
 }
+function resolveTrendTimestamp(primary, secondary) {
+	if (typeof primary === "number" && Number.isFinite(primary) && primary > 0) return primary;
+	if (typeof secondary === "number" && Number.isFinite(secondary) && secondary > 0) return secondary;
+	return null;
+}
+function parseDatedIdTimestamp(id) {
+	const match$1 = /^(\d{4})-(\d{2})-(\d{2})(?:-|$)/.exec(id);
+	if (!match$1) return null;
+	const year = Number(match$1[1]);
+	const month = Number(match$1[2]);
+	const day = Number(match$1[3]);
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return null;
+	if (month < 1 || month > 12) return null;
+	if (day < 1 || day > 31) return null;
+	const ts = Date.UTC(year, month - 1, day);
+	return Number.isFinite(ts) ? ts : null;
+}
+function createEmptyTriColorTrends() {
+	return Object.fromEntries(DASHBOARD_METRIC_KEYS.map((metric) => [metric, []]));
+}
+async function readLatestCommitTimestamp(projectDir) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"-1",
+			"--format=%ct"
+		], {
+			cwd: projectDir,
+			maxBuffer: 1024 * 1024,
+			encoding: "utf8"
+		});
+		const seconds = Number(stdout.trim());
+		return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : null;
+	} catch {
+		return null;
+	}
+}
+async function fetchDashboardOverview(ctx, reason = "dashboard-refresh") {
+	if (contextStorage.getStore()) await registerDashboardGitReactiveDeps(ctx.projectDir);
+	const now = Date.now();
+	const [specMetas, changeMetas, archiveMetas] = await Promise.all([
+		ctx.adapter.listSpecsWithMeta(),
+		ctx.adapter.listChangesWithMeta(),
+		ctx.adapter.listArchivedChangesWithMeta()
+	]);
+	const archivedChanges = (await Promise.all(archiveMetas.map(async (meta) => {
+		const change = await ctx.adapter.readArchivedChange(meta.id);
+		if (!change) return null;
+		return {
+			id: meta.id,
+			createdAt: meta.createdAt,
+			updatedAt: meta.updatedAt,
+			tasksCompleted: change.tasks.filter((task) => task.completed).length
+		};
+	}))).filter((item) => item !== null);
+	const specifications = (await Promise.all(specMetas.map(async (meta) => {
+		const spec = await ctx.adapter.readSpec(meta.id);
+		if (!spec) return null;
+		return {
+			id: meta.id,
+			name: meta.name,
+			requirements: spec.requirements.length,
+			updatedAt: meta.updatedAt
+		};
+	}))).filter((item) => item !== null).sort((a, b) => b.requirements - a.requirements || b.updatedAt - a.updatedAt);
+	const activeChanges = changeMetas.map((change) => ({
+		id: change.id,
+		name: change.name,
+		progress: change.progress,
+		updatedAt: change.updatedAt
+	}));
+	const requirements = specifications.reduce((sum, spec) => sum + spec.requirements, 0);
+	const tasksTotal = activeChanges.reduce((sum, change) => sum + change.progress.total, 0);
+	const tasksCompleted = activeChanges.reduce((sum, change) => sum + change.progress.completed, 0);
+	const archivedTasksCompleted = archivedChanges.reduce((sum, change) => sum + change.tasksCompleted, 0);
+	const taskCompletionPercent = tasksTotal > 0 ? Math.round(tasksCompleted / tasksTotal * 100) : null;
+	const inProgressChanges = activeChanges.filter((change) => change.progress.total > 0 && change.progress.completed < change.progress.total).length;
+	const specificationTrendEvents = specMetas.flatMap((spec) => {
+		const ts = resolveTrendTimestamp(spec.createdAt, spec.updatedAt);
+		return ts === null ? [] : [{
+			ts,
+			value: 1
+		}];
+	});
+	const completedTrendEvents = archivedChanges.flatMap((archive) => {
+		const ts = parseDatedIdTimestamp(archive.id) ?? resolveTrendTimestamp(archive.updatedAt, archive.createdAt);
+		return ts === null ? [] : [{
+			ts,
+			value: archive.tasksCompleted
+		}];
+	});
+	const specMetaById = new Map(specMetas.map((meta) => [meta.id, meta]));
+	const requirementTrendEvents = specifications.flatMap((spec) => {
+		const meta = specMetaById.get(spec.id);
+		const ts = resolveTrendTimestamp(meta?.updatedAt, meta?.createdAt);
+		return ts === null ? [] : [{
+			ts,
+			value: spec.requirements
+		}];
+	});
+	const hasObjectiveSpecificationTrend = specificationTrendEvents.length > 0 || specifications.length === 0;
+	const hasObjectiveRequirementTrend = requirementTrendEvents.length > 0 || requirements === 0;
+	const hasObjectiveCompletedTrend = completedTrendEvents.length > 0 || archiveMetas.length === 0;
+	const config = await ctx.configManager.readConfig();
+	beginDashboardGitTask(reason);
+	let latestCommitTs = null;
+	let git;
+	try {
+		const gitSnapshotPromise = buildDashboardGitSnapshot({ projectDir: ctx.projectDir }).catch(() => ({
+			defaultBranch: "main",
+			worktrees: []
+		}));
+		latestCommitTs = await readLatestCommitTimestamp(ctx.projectDir);
+		git = await gitSnapshotPromise;
+	} catch (error) {
+		endDashboardGitTask(error);
+		throw error;
+	}
+	endDashboardGitTask(null);
+	const cardAvailability = {
+		specifications: hasObjectiveSpecificationTrend ? { state: "ok" } : {
+			state: "invalid",
+			reason: "objective-history-unavailable"
+		},
+		requirements: hasObjectiveRequirementTrend ? { state: "ok" } : {
+			state: "invalid",
+			reason: "objective-history-unavailable"
+		},
+		activeChanges: {
+			state: "invalid",
+			reason: "objective-history-unavailable"
+		},
+		inProgressChanges: {
+			state: "invalid",
+			reason: "objective-history-unavailable"
+		},
+		completedChanges: hasObjectiveCompletedTrend ? { state: "ok" } : {
+			state: "invalid",
+			reason: "objective-history-unavailable"
+		},
+		taskCompletionPercent: {
+			state: "invalid",
+			reason: taskCompletionPercent === null ? "semantic-uncomputable" : "objective-history-unavailable"
+		}
+	};
+	const trendKinds = {
+		specifications: "monotonic",
+		requirements: "monotonic",
+		activeChanges: "bidirectional",
+		inProgressChanges: "bidirectional",
+		completedChanges: "monotonic",
+		taskCompletionPercent: "bidirectional"
+	};
+	const { trends: baselineTrends, trendMeta } = buildDashboardTimeTrends({
+		pointLimit: config.dashboard.trendPointLimit,
+		timestamp: now,
+		rightEdgeTs: latestCommitTs,
+		availability: cardAvailability,
+		events: {
+			specifications: specificationTrendEvents,
+			requirements: requirementTrendEvents,
+			activeChanges: [],
+			inProgressChanges: [],
+			completedChanges: completedTrendEvents,
+			taskCompletionPercent: []
+		},
+		reducers: {
+			specifications: "sum",
+			requirements: "sum",
+			completedChanges: "sum"
+		}
+	});
+	return {
+		summary: {
+			specifications: specifications.length,
+			requirements,
+			activeChanges: activeChanges.length,
+			inProgressChanges,
+			completedChanges: archiveMetas.length,
+			archivedTasksCompleted,
+			tasksTotal,
+			tasksCompleted,
+			taskCompletionPercent
+		},
+		trends: baselineTrends,
+		triColorTrends: createEmptyTriColorTrends(),
+		trendKinds,
+		cardAvailability,
+		trendMeta,
+		specifications,
+		activeChanges,
+		git
+	};
+}
 /**
 * Spec router - spec CRUD operations
 */
@@ -23755,15 +24404,17 @@ const configRouter = router({
 			"dark",
 			"system"
 		]).optional(),
-		terminal: TerminalConfigSchema.omit({ rendererEngine: true }).partial().extend({ rendererEngine: TerminalRendererEngineSchema.optional() }).optional()
+		terminal: TerminalConfigSchema.omit({ rendererEngine: true }).partial().extend({ rendererEngine: TerminalRendererEngineSchema.optional() }).optional(),
+		dashboard: DashboardConfigSchema.partial().optional()
 	})).mutation(async ({ ctx, input }) => {
 		const hasCliCommand = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "command");
 		const hasCliArgs = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "args");
 		if (hasCliCommand && !hasCliArgs) {
 			await ctx.configManager.setCliCommand(input.cli?.command ?? "");
-			if (input.theme !== void 0 || input.terminal !== void 0) await ctx.configManager.writeConfig({
+			if (input.theme !== void 0 || input.terminal !== void 0 || input.dashboard !== void 0) await ctx.configManager.writeConfig({
 				theme: input.theme,
-				terminal: input.terminal
+				terminal: input.terminal,
+				dashboard: input.dashboard
 			});
 			return { success: true };
 		}
@@ -24220,9 +24871,43 @@ const systemRouter = router({
 	})
 });
 /**
+* Dashboard router - objective project overview for UI
+*/
+const dashboardRouter = router({
+	get: publicProcedure.query(async ({ ctx }) => {
+		return fetchDashboardOverview(ctx, "dashboard.get");
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(async () => {
+			return fetchDashboardOverview(ctx, "dashboard.subscribe");
+		});
+	}),
+	refreshGitSnapshot: publicProcedure.input(objectType({ reason: stringType().optional() }).optional()).mutation(async ({ ctx, input }) => {
+		const reason = input?.reason?.trim() || "manual-refresh";
+		await touchDashboardGitRefreshStamp(ctx.projectDir, reason);
+		return { success: true };
+	}),
+	gitTaskStatus: publicProcedure.query(() => {
+		return getDashboardGitTaskStatus();
+	}),
+	subscribeGitTaskStatus: publicProcedure.subscription(() => {
+		return observable((emit) => {
+			emit.next(getDashboardGitTaskStatus());
+			const handler = (status) => {
+				emit.next(status);
+			};
+			dashboardGitTaskStatusEmitter.on("change", handler);
+			return () => {
+				dashboardGitTaskStatusEmitter.off("change", handler);
+			};
+		});
+	})
+});
+/**
 * Main app router
 */
 const appRouter = router({
+	dashboard: dashboardRouter,
 	spec: specRouter,
 	change: changeRouter,
 	archive: archiveRouter,
@@ -24237,7 +24922,7 @@ const appRouter = router({
 });
 
 //#endregion
-//#region ../search/dist/node.mjs
+//#region ../search/src/node-worker-provider.ts
 function requestId() {
 	return Math.random().toString(36).slice(2);
 }
@@ -24685,4 +25370,4 @@ async function startServer$1(options = {}) {
 }
 
 //#endregion
-export { SchemaInfoSchema as a, CliExecutor as c, __commonJS$1 as d, __toESM$1 as f, SchemaDetailSchema as i, ConfigManager as l, createServer$2 as n, SchemaResolutionSchema as o, require_dist as r, TemplatesSchema as s, startServer$1 as t, OpenSpecAdapter as u };
+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 };