openspecui 2.1.0 → 2.1.2

package/dist/{src-B5XQ-ERE.mjs → src-Nn_MJz41.mjs}

@@ -15,10 +15,10 @@ import { watch } from "fs";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
 import { fileURLToPath } from "node:url";
-import * as pty from "@lydell/node-pty";
-import { execFile } from "node:child_process";
 import { EventEmitter as EventEmitter$1 } from "node:events";
+import { execFile } from "node:child_process";
 import { promisify as promisify$1 } from "node:util";
+import * as pty from "@lydell/node-pty";
 import { Worker as Worker$1 } from "node:worker_threads";
 
 //#region rolldown:runtime
@@ -22886,1022 +22886,1390 @@ var import_websocket = /* @__PURE__ */ __toESM$1(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM$1(require_websocket_server(), 1);
 
 //#endregion
-//#region ../server/src/pty-manager.ts
-const DEFAULT_SCROLLBACK = 1e3;
-const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
-function detectPtyPlatform() {
-	if (process.platform === "win32") return "windows";
-	if (process.platform === "darwin") return "macos";
-	return "common";
-}
-function resolveDefaultShell(platform, env) {
-	if (platform === "windows") return env.ComSpec?.trim() || "cmd.exe";
-	return env.SHELL?.trim() || "/bin/sh";
-}
-function resolvePtyCommand(opts) {
-	const command = opts.command?.trim();
-	if (command) return {
-		command,
-		args: opts.args ?? []
-	};
-	return {
-		command: resolveDefaultShell(opts.platform, opts.env),
-		args: []
-	};
-}
-var PtySession = class extends EventEmitter {
-	id;
-	command;
-	args;
-	platform;
-	closeTip;
-	closeCallbackUrl;
-	createdAt;
-	process;
-	titleInterval = null;
-	lastTitle = "";
-	buffer = [];
-	bufferByteLength = 0;
-	maxBufferLines;
-	maxBufferBytes;
-	isExited = false;
-	exitCode = null;
-	constructor(id, opts) {
-		super();
-		this.id = id;
-		this.createdAt = Date.now();
-		const resolvedCommand = resolvePtyCommand({
-			platform: opts.platform,
-			command: opts.command,
-			args: opts.args,
-			env: process.env
-		});
-		this.command = resolvedCommand.command;
-		this.args = resolvedCommand.args;
-		this.platform = opts.platform;
-		this.closeTip = opts.closeTip;
-		this.closeCallbackUrl = opts.closeCallbackUrl;
-		this.maxBufferLines = opts.scrollback ?? DEFAULT_SCROLLBACK;
-		this.maxBufferBytes = opts.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
-		this.process = pty.spawn(this.command, this.args, {
-			name: "xterm-256color",
-			cols: opts.cols ?? 80,
-			rows: opts.rows ?? 24,
-			cwd: opts.cwd,
-			env: {
-				...process.env,
-				TERM: "xterm-256color"
-			}
-		});
-		this.process.onData((data) => {
-			this.appendBuffer(data);
-			this.emit("data", data);
-		});
-		this.process.onExit(({ exitCode }) => {
-			if (this.titleInterval) {
-				clearInterval(this.titleInterval);
-				this.titleInterval = null;
-			}
-			this.isExited = true;
-			this.exitCode = exitCode;
-			this.emit("exit", exitCode);
+//#region ../server/src/dashboard-overview-service.ts
+const REBUILD_DEBOUNCE_MS$1 = 250;
+var DashboardOverviewService = class {
+	current = null;
+	initialized = false;
+	initPromise = null;
+	refreshPromise = null;
+	refreshTimer = null;
+	pendingRefreshReason = null;
+	emitter = new EventEmitter$1();
+	constructor(loadOverview, watcher) {
+		this.loadOverview = loadOverview;
+		this.emitter.setMaxListeners(200);
+		watcher?.on("change", () => {
+			this.scheduleRefresh("watcher-change");
 		});
-		this.titleInterval = setInterval(() => {
-			try {
-				const title = this.process.process;
-				if (title && title !== this.lastTitle) {
-					this.lastTitle = title;
-					this.emit("title", title);
-				}
-			} catch {}
-		}, 1e3);
-	}
-	get title() {
-		return this.lastTitle;
-	}
-	appendBuffer(data) {
-		let chunk = data;
-		if (chunk.length > this.maxBufferBytes) chunk = chunk.slice(-this.maxBufferBytes);
-		this.buffer.push(chunk);
-		this.bufferByteLength += chunk.length;
-		while (this.bufferByteLength > this.maxBufferBytes && this.buffer.length > 0) {
-			const removed = this.buffer.shift();
-			this.bufferByteLength -= removed.length;
-		}
-		while (this.buffer.length > this.maxBufferLines) {
-			const removed = this.buffer.shift();
-			this.bufferByteLength -= removed.length;
-		}
-	}
-	getBuffer() {
-		return this.buffer.join("");
-	}
-	write(data) {
-		if (!this.isExited) this.process.write(data);
 	}
-	resize(cols, rows) {
-		if (!this.isExited) this.process.resize(cols, rows);
-	}
-	close() {
-		if (this.titleInterval) {
-			clearInterval(this.titleInterval);
-			this.titleInterval = null;
-		}
+	async init() {
+		if (this.initialized && this.current) return this.current;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.refresh("init");
 		try {
-			this.process.kill();
-		} catch {}
-		this.removeAllListeners();
-	}
-	toInfo() {
-		return {
-			id: this.id,
-			title: this.lastTitle,
-			command: this.command,
-			args: this.args,
-			platform: this.platform,
-			isExited: this.isExited,
-			exitCode: this.exitCode,
-			closeTip: this.closeTip,
-			closeCallbackUrl: this.closeCallbackUrl,
-			createdAt: this.createdAt
-		};
+			return await this.initPromise;
+		} finally {
+			this.initPromise = null;
+		}
 	}
-};
-var PtyManager = class {
-	sessions = /* @__PURE__ */ new Map();
-	idCounter = 0;
-	platform;
-	constructor(defaultCwd) {
-		this.defaultCwd = defaultCwd;
-		this.platform = detectPtyPlatform();
+	async getCurrent() {
+		if (this.current) return this.current;
+		return this.init();
 	}
-	create(opts) {
-		const id = `pty-${++this.idCounter}`;
-		const session = new PtySession(id, {
-			cols: opts.cols,
-			rows: opts.rows,
-			command: opts.command,
-			args: opts.args,
-			closeTip: opts.closeTip,
-			closeCallbackUrl: opts.closeCallbackUrl,
-			cwd: this.defaultCwd,
-			scrollback: opts.scrollback,
-			maxBufferBytes: opts.maxBufferBytes,
-			platform: this.platform
+	subscribe(listener, options) {
+		this.emitter.on("change", listener);
+		if (options?.emitCurrent) if (this.current) listener(this.current);
+		else this.init().catch((error) => {
+			options?.onError?.(error instanceof Error ? error : new Error(String(error)));
 		});
-		this.sessions.set(id, session);
-		return session;
-	}
-	get(id) {
-		return this.sessions.get(id);
-	}
-	list() {
-		const result = [];
-		for (const session of this.sessions.values()) result.push(session.toInfo());
-		return result;
-	}
-	write(id, data) {
-		this.sessions.get(id)?.write(data);
-	}
-	resize(id, cols, rows) {
-		this.sessions.get(id)?.resize(cols, rows);
+		return () => {
+			this.emitter.off("change", listener);
+		};
 	}
-	close(id) {
-		const session = this.sessions.get(id);
-		if (session) {
-			session.close();
-			this.sessions.delete(id);
+	scheduleRefresh(reason = "scheduled-refresh") {
+		this.cancelScheduledRefresh();
+		this.refreshTimer = setTimeout(() => {
+			this.refreshTimer = null;
+			this.refresh(reason).catch(() => {});
+		}, REBUILD_DEBOUNCE_MS$1);
+	}
+	async refresh(reason = "manual-refresh") {
+		this.cancelScheduledRefresh();
+		if (this.refreshPromise) {
+			this.pendingRefreshReason = reason;
+			return this.refreshPromise;
+		}
+		this.refreshPromise = (async () => {
+			const next = await this.loadOverview(reason);
+			this.current = next;
+			this.initialized = true;
+			this.emitter.emit("change", next);
+			return next;
+		})();
+		try {
+			return await this.refreshPromise;
+		} finally {
+			this.refreshPromise = null;
+			if (this.pendingRefreshReason) {
+				const pendingReason = this.pendingRefreshReason;
+				this.pendingRefreshReason = null;
+				this.refresh(pendingReason).catch(() => {});
+			}
 		}
 	}
-	closeAll() {
-		for (const session of this.sessions.values()) session.close();
-		this.sessions.clear();
+	dispose() {
+		this.cancelScheduledRefresh();
+		this.emitter.removeAllListeners();
+	}
+	cancelScheduledRefresh() {
+		if (!this.refreshTimer) return;
+		clearTimeout(this.refreshTimer);
+		this.refreshTimer = null;
 	}
 };
 
 //#endregion
-//#region ../server/src/pty-websocket.ts
-function createPtyWebSocketHandler(ptyManager) {
-	return (ws) => {
-		const cleanups = /* @__PURE__ */ new Map();
-		const send = (msg) => {
-			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+//#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
 		};
-		const sendError = (code, message, opts) => {
-			send({
-				type: "error",
-				code,
-				message,
-				sessionId: opts?.sessionId
-			});
+	} catch {
+		return {
+			ok: false,
+			stdout: ""
 		};
-		const attachToSession = (session, opts) => {
-			const sessionId = session.id;
-			cleanups.get(sessionId)?.();
-			if (opts?.cols && opts?.rows && !session.isExited) session.resize(opts.cols, opts.rows);
-			const onData = (data) => {
-				send({
-					type: "output",
-					sessionId,
-					data
-				});
-			};
-			const onExit = (exitCode) => {
-				send({
-					type: "exit",
-					sessionId,
-					exitCode
-				});
-			};
-			const onTitle = (title) => {
-				send({
-					type: "title",
-					sessionId,
-					title
-				});
-			};
-			session.on("data", onData);
-			session.on("exit", onExit);
-			session.on("title", onTitle);
-			cleanups.set(sessionId, () => {
-				session.removeListener("data", onData);
-				session.removeListener("exit", onExit);
-				session.removeListener("title", onTitle);
-				cleanups.delete(sessionId);
-			});
-		};
-		ws.on("message", (raw$1) => {
-			let parsed;
-			try {
-				parsed = JSON.parse(String(raw$1));
-			} catch {
-				sendError("INVALID_JSON", "Invalid JSON payload");
-				return;
-			}
-			const parsedMessage = PtyClientMessageSchema.safeParse(parsed);
-			if (!parsedMessage.success) {
-				const firstIssue = parsedMessage.error.issues[0]?.message;
-				sendError("INVALID_MESSAGE", firstIssue ?? "Invalid PTY message");
-				return;
-			}
-			const msg = parsedMessage.data;
-			switch (msg.type) {
-				case "create":
-					try {
-						const createMessage = msg;
-						const session = ptyManager.create({
-							cols: msg.cols,
-							rows: msg.rows,
-							command: msg.command,
-							args: msg.args,
-							closeTip: createMessage.closeTip,
-							closeCallbackUrl: createMessage.closeCallbackUrl
-						});
-						send({
-							type: "created",
-							requestId: msg.requestId,
-							sessionId: session.id,
-							platform: session.platform
-						});
-						attachToSession(session);
-					} catch (err) {
-						sendError("PTY_CREATE_FAILED", err instanceof Error ? err.message : String(err), { sessionId: msg.requestId });
-					}
-					break;
-				case "attach": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						send({
-							type: "exit",
-							sessionId: msg.sessionId,
-							exitCode: -1
-						});
-						break;
-					}
-					attachToSession(session, {
-						cols: msg.cols,
-						rows: msg.rows
-					});
-					const buffer = session.getBuffer();
-					if (buffer) send({
-						type: "buffer",
-						sessionId: session.id,
-						data: buffer
-					});
-					if (session.title) send({
-						type: "title",
-						sessionId: session.id,
-						title: session.title
-					});
-					if (session.isExited) send({
-						type: "exit",
-						sessionId: session.id,
-						exitCode: session.exitCode ?? -1
-					});
-					break;
-				}
-				case "list":
-					send({
-						type: "list",
-						sessions: ptyManager.list().map((s) => ({
-							id: s.id,
-							title: s.title,
-							command: s.command,
-							args: s.args,
-							platform: s.platform,
-							isExited: s.isExited,
-							exitCode: s.exitCode,
-							closeTip: s.closeTip,
-							closeCallbackUrl: s.closeCallbackUrl
-						}))
-					});
-					break;
-				case "input": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					session.write(msg.data);
-					break;
-				}
-				case "resize": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					session.resize(msg.cols, msg.rows);
-					break;
-				}
-				case "close": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					cleanups.get(msg.sessionId)?.();
-					ptyManager.close(session.id);
-					break;
-				}
-			}
-		});
-		ws.on("close", () => {
-			for (const cleanup of cleanups.values()) cleanup();
-			cleanups.clear();
-		});
+	}
+}
+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
 	};
 }
-
-//#endregion
-//#region ../search/src/protocol.ts
-const SearchDocumentKindSchema = enumType([
-	"spec",
-	"change",
-	"archive"
-]);
-const SearchDocumentSchema = objectType({
-	id: stringType(),
-	kind: SearchDocumentKindSchema,
-	title: stringType(),
-	href: stringType(),
-	path: stringType(),
-	content: stringType(),
-	updatedAt: numberType()
-});
-const SearchQuerySchema = objectType({
-	query: stringType(),
-	limit: numberType().int().positive().optional()
-});
-const SearchHitSchema = objectType({
-	documentId: stringType(),
-	kind: SearchDocumentKindSchema,
-	title: stringType(),
-	href: stringType(),
-	path: stringType(),
-	score: numberType(),
-	snippet: stringType(),
-	updatedAt: numberType()
-});
-const SearchWorkerRequestSchema = discriminatedUnionType("type", [
-	objectType({
-		id: stringType(),
-		type: literalType("init"),
-		docs: arrayType(SearchDocumentSchema)
-	}),
-	objectType({
-		id: stringType(),
-		type: literalType("replaceAll"),
-		docs: arrayType(SearchDocumentSchema)
-	}),
-	objectType({
-		id: stringType(),
-		type: literalType("search"),
-		query: SearchQuerySchema
-	}),
-	objectType({
-		id: stringType(),
-		type: literalType("dispose")
-	})
-]);
-const SearchWorkerResponseSchema = discriminatedUnionType("type", [
-	objectType({
-		id: stringType(),
-		type: literalType("ok")
-	}),
-	objectType({
-		id: stringType(),
-		type: literalType("results"),
-		hits: arrayType(SearchHitSchema)
-	}),
-	objectType({
-		id: stringType(),
-		type: literalType("error"),
-		message: stringType()
-	})
-]);
-
-//#endregion
-//#region ../search/src/worker-source.ts
-const sharedRuntimeSource = String.raw`
-const DEFAULT_LIMIT = 50;
-const MAX_LIMIT = 200;
-const SNIPPET_SIZE = 180;
-
-function normalizeText(input) {
-  return String(input || '')
-    .toLowerCase()
-    .replace(/\s+/g, ' ')
-    .trim();
+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 splitTerms(query) {
-  return normalizeText(query)
-    .split(' ')
-    .map((term) => term.trim())
-    .filter((term) => term.length > 0);
+function normalizeGitPath(path$1) {
+	return path$1.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-
-function toSearchIndexDocument(doc) {
-  return {
-    id: doc.id,
-    kind: doc.kind,
-    title: doc.title,
-    href: doc.href,
-    path: doc.path,
-    content: doc.content,
-    updatedAt: doc.updatedAt,
-    normalizedTitle: normalizeText(doc.title),
-    normalizedPath: normalizeText(doc.path),
-    normalizedContent: normalizeText(doc.content),
-  };
-}
-
-function buildSearchIndex(docs) {
-  return {
-    documents: Array.isArray(docs) ? docs.map(toSearchIndexDocument) : [],
-  };
+function relativePath(fromDir, target) {
+	const rel = relative$1(fromDir, target);
+	if (!rel || rel.length === 0) return ".";
+	return rel;
 }
-
-function resolveLimit(limit) {
-  if (typeof limit !== 'number' || Number.isNaN(limit)) return DEFAULT_LIMIT;
-  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
+function parseBranchName(branchRef, detached) {
+	if (detached) return "(detached)";
+	if (!branchRef) return "(unknown)";
+	return branchRef.replace(/^refs\/heads\//, "");
 }
-
-function isDocumentMatch(doc, terms) {
-  return terms.every(
-    (term) =>
-      doc.normalizedTitle.includes(term) ||
-      doc.normalizedPath.includes(term) ||
-      doc.normalizedContent.includes(term)
-  );
+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 scoreDocument(doc, terms) {
-  let score = 0;
-
-  for (const term of terms) {
-    if (doc.normalizedTitle.includes(term)) score += 30;
-    if (doc.normalizedPath.includes(term)) score += 20;
-
-    const contentIdx = doc.normalizedContent.indexOf(term);
-    if (contentIdx >= 0) {
-      score += 8;
-      if (contentIdx < 160) score += 4;
-    }
-  }
-
-  return score;
+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));
 }
-
-function createSnippet(content, terms) {
-  const source = String(content || '').trim();
-  if (!source) return '';
-
-  const normalizedSource = normalizeText(source);
-  let matchIndex = -1;
-
-  for (const term of terms) {
-    const idx = normalizedSource.indexOf(term);
-    if (idx >= 0 && (matchIndex < 0 || idx < matchIndex)) {
-      matchIndex = idx;
-    }
-  }
-
-  if (matchIndex < 0) {
-    return source.slice(0, SNIPPET_SIZE);
-  }
-
-  const start = Math.max(0, matchIndex - Math.floor(SNIPPET_SIZE / 3));
-  const end = Math.min(source.length, start + SNIPPET_SIZE);
-
-  const prefix = start > 0 ? '...' : '';
-  const suffix = end < source.length ? '...' : '';
-  return prefix + source.slice(start, end) + suffix;
+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";
 }
-
-function searchIndex(index, query) {
-  const terms = splitTerms(query && query.query ? query.query : '');
-  if (terms.length === 0) return [];
-
-  const hits = [];
-
-  for (const doc of index.documents) {
-    if (!isDocumentMatch(doc, terms)) continue;
-
-    hits.push({
-      documentId: doc.id,
-      kind: doc.kind,
-      title: doc.title,
-      href: doc.href,
-      path: doc.path,
-      score: scoreDocument(doc, terms),
-      snippet: createSnippet(doc.content, terms),
-      updatedAt: doc.updatedAt,
-    });
-  }
-
-  hits.sort((a, b) => {
-    if (b.score !== a.score) return b.score - a.score;
-    return b.updatedAt - a.updatedAt;
-  });
-
-  return hits.slice(0, resolveLimit(query ? query.limit : undefined));
+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),
+		detached: worktree.detached,
+		isCurrent: resolvedProjectDir === worktreePath,
+		ahead,
+		behind,
+		diff,
+		entries
+	};
+}
+async function removeDetachedDashboardGitWorktree(options) {
+	const runGit = options.runGit ?? defaultRunGit;
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	const resolvedTargetPath = resolve$1(options.targetPath);
+	if (resolvedTargetPath === resolvedProjectDir) throw new Error("Cannot remove the current worktree.");
+	const worktreeResult = await runGit(resolvedProjectDir, [
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	if (!worktreeResult.ok) throw new Error("Failed to inspect git worktrees.");
+	const matched = parseWorktreeList(worktreeResult.stdout).find((worktree) => resolve$1(worktree.path) === resolvedTargetPath);
+	if (!matched) throw new Error("Worktree not found.");
+	if (!matched.detached) throw new Error("Only detached worktrees can be removed from Dashboard.");
+	if (!(await runGit(resolvedProjectDir, [
+		"worktree",
+		"remove",
+		"--force",
+		resolvedTargetPath
+	])).ok) throw new Error("Failed to remove detached worktree.");
+}
+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
+	};
 }
 
-let index = buildSearchIndex([]);
-
-function handleMessage(payload) {
-  try {
-    if (!payload || typeof payload !== 'object') {
-      throw new Error('Invalid worker request payload');
-    }
-
-    if (payload.type === 'init' || payload.type === 'replaceAll') {
-      index = buildSearchIndex(Array.isArray(payload.docs) ? payload.docs : []);
-      return { id: payload.id, type: 'ok' };
-    }
-
-    if (payload.type === 'search') {
-      const hits = searchIndex(index, payload.query || { query: '' });
-      return { id: payload.id, type: 'results', hits };
-    }
-
-    if (payload.type === 'dispose') {
-      index = buildSearchIndex([]);
-      return { id: payload.id, type: 'ok' };
-    }
-
-    throw new Error('Unsupported worker request type');
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { id: payload?.id ?? 'unknown', type: 'error', message };
-  }
+//#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 buildNodeWorkerSource() {
-	return `${sharedRuntimeSource}\nconst { parentPort } = require('node:worker_threads');\nif (!parentPort) { throw new Error('Missing parentPort'); }\nparentPort.on('message', (payload) => { parentPort.postMessage(handleMessage(payload)); });`;
+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/cli-stream-observable.ts
-/**
-* 创建安全的 CLI 流式 observable
-*
-* 解决的问题：
-* 1. 防止在 emit.complete() 之后调用 emit.next()（会导致 "Controller is already closed" 错误）
-* 2. 统一的错误处理，防止未捕获的异常导致服务器崩溃
-* 3. 确保取消时正确清理资源
-*
-* @param startStream 启动流的函数，接收 onEvent 回调，返回取消函数的 Promise
-*/
-function createCliStreamObservable(startStream) {
-	return observable((emit) => {
-		let cancel;
-		let completed = false;
-		/**
-		* 安全的事件处理器
-		* - 检查是否已完成，防止重复调用
-		* - 使用 try-catch 防止异常导致服务器崩溃
-		*/
-		const safeEventHandler = (event) => {
-			if (completed) return;
-			try {
-				emit.next(event);
-				if (event.type === "exit") {
-					completed = true;
-					emit.complete();
+//#region ../server/src/dashboard-overview.ts
+const execFileAsync = promisify$1(execFile);
+const DASHBOARD_GIT_REFRESH_STAMP_NAME = "openspecui-dashboard-git-refresh.stamp";
+const dashboardGitTaskStatusEmitter = new EventEmitter$1();
+dashboardGitTaskStatusEmitter.setMaxListeners(200);
+const dashboardGitTaskStatus = {
+	running: false,
+	inFlight: 0,
+	lastStartedAt: null,
+	lastFinishedAt: null,
+	lastReason: null,
+	lastError: null
+};
+function createEmptyTriColorTrends() {
+	return Object.fromEntries(DASHBOARD_METRIC_KEYS.map((metric) => [metric, []]));
+}
+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;
+}
+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;
+	}
+}
+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 getDashboardGitTaskStatus() {
+	return { ...dashboardGitTaskStatus };
+}
+function subscribeDashboardGitTaskStatus(listener) {
+	dashboardGitTaskStatusEmitter.on("change", listener);
+	return () => {
+		dashboardGitTaskStatusEmitter.off("change", listener);
+	};
+}
+async function resolveGitMetadataDir(projectDir) {
+	try {
+		const { stdout } = await execFileAsync("git", ["rev-parse", "--git-dir"], {
+			cwd: projectDir,
+			maxBuffer: 1024 * 1024,
+			encoding: "utf8"
+		});
+		const gitDirRaw = stdout.trim();
+		if (!gitDirRaw) return null;
+		const gitDirPath = resolve$1(projectDir, gitDirRaw);
+		if (!(await stat(gitDirPath)).isDirectory()) return null;
+		return gitDirPath;
+	} catch {
+		return null;
+	}
+}
+function getDashboardGitRefreshStampPath(gitMetadataDir) {
+	return join$1(gitMetadataDir, DASHBOARD_GIT_REFRESH_STAMP_NAME);
+}
+async function touchDashboardGitRefreshStamp(projectDir, reason) {
+	const gitMetadataDir = await resolveGitMetadataDir(projectDir);
+	if (!gitMetadataDir) return { skipped: true };
+	const stampPath = getDashboardGitRefreshStampPath(gitMetadataDir);
+	await mkdir$1(dirname$1(stampPath), { recursive: true });
+	await writeFile$1(stampPath, `${Date.now()} ${reason}\n`, "utf8");
+	return { skipped: false };
+}
+async function loadDashboardOverview(ctx, reason = "dashboard-refresh") {
+	const now = Date.now();
+	const [specMetas, changeMetas, archiveMetas] = await Promise.all([
+		ctx.adapter.listSpecsWithMeta(),
+		ctx.adapter.listChangesWithMeta(),
+		ctx.adapter.listArchivedChangesWithMeta()
+	]);
+	const activeChanges = changeMetas.map((changeMeta) => ({
+		id: changeMeta.id,
+		name: changeMeta.name ?? changeMeta.id,
+		progress: changeMeta.progress,
+		updatedAt: changeMeta.updatedAt
+	})).sort((a, b) => b.updatedAt - a.updatedAt);
+	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 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
+	};
+}
+
+//#endregion
+//#region ../server/src/pty-manager.ts
+const DEFAULT_SCROLLBACK = 1e3;
+const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
+function detectPtyPlatform() {
+	if (process.platform === "win32") return "windows";
+	if (process.platform === "darwin") return "macos";
+	return "common";
+}
+function resolveDefaultShell(platform, env) {
+	if (platform === "windows") return env.ComSpec?.trim() || "cmd.exe";
+	return env.SHELL?.trim() || "/bin/sh";
+}
+function resolvePtyCommand(opts) {
+	const command = opts.command?.trim();
+	if (command) return {
+		command,
+		args: opts.args ?? []
+	};
+	return {
+		command: resolveDefaultShell(opts.platform, opts.env),
+		args: []
+	};
+}
+var PtySession = class extends EventEmitter {
+	id;
+	command;
+	args;
+	platform;
+	closeTip;
+	closeCallbackUrl;
+	createdAt;
+	process;
+	titleInterval = null;
+	lastTitle = "";
+	buffer = [];
+	bufferByteLength = 0;
+	maxBufferLines;
+	maxBufferBytes;
+	isExited = false;
+	exitCode = null;
+	constructor(id, opts) {
+		super();
+		this.id = id;
+		this.createdAt = Date.now();
+		const resolvedCommand = resolvePtyCommand({
+			platform: opts.platform,
+			command: opts.command,
+			args: opts.args,
+			env: process.env
+		});
+		this.command = resolvedCommand.command;
+		this.args = resolvedCommand.args;
+		this.platform = opts.platform;
+		this.closeTip = opts.closeTip;
+		this.closeCallbackUrl = opts.closeCallbackUrl;
+		this.maxBufferLines = opts.scrollback ?? DEFAULT_SCROLLBACK;
+		this.maxBufferBytes = opts.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
+		this.process = pty.spawn(this.command, this.args, {
+			name: "xterm-256color",
+			cols: opts.cols ?? 80,
+			rows: opts.rows ?? 24,
+			cwd: opts.cwd,
+			env: {
+				...process.env,
+				TERM: "xterm-256color"
+			}
+		});
+		this.process.onData((data) => {
+			this.appendBuffer(data);
+			this.emit("data", data);
+		});
+		this.process.onExit(({ exitCode }) => {
+			if (this.titleInterval) {
+				clearInterval(this.titleInterval);
+				this.titleInterval = null;
+			}
+			this.isExited = true;
+			this.exitCode = exitCode;
+			this.emit("exit", exitCode);
+		});
+		this.titleInterval = setInterval(() => {
+			try {
+				const title = this.process.process;
+				if (title && title !== this.lastTitle) {
+					this.lastTitle = title;
+					this.emit("title", title);
+				}
+			} catch {}
+		}, 1e3);
+	}
+	get title() {
+		return this.lastTitle;
+	}
+	appendBuffer(data) {
+		let chunk = data;
+		if (chunk.length > this.maxBufferBytes) chunk = chunk.slice(-this.maxBufferBytes);
+		this.buffer.push(chunk);
+		this.bufferByteLength += chunk.length;
+		while (this.bufferByteLength > this.maxBufferBytes && this.buffer.length > 0) {
+			const removed = this.buffer.shift();
+			this.bufferByteLength -= removed.length;
+		}
+		while (this.buffer.length > this.maxBufferLines) {
+			const removed = this.buffer.shift();
+			this.bufferByteLength -= removed.length;
+		}
+	}
+	getBuffer() {
+		return this.buffer.join("");
+	}
+	write(data) {
+		if (!this.isExited) this.process.write(data);
+	}
+	resize(cols, rows) {
+		if (!this.isExited) this.process.resize(cols, rows);
+	}
+	close() {
+		if (this.titleInterval) {
+			clearInterval(this.titleInterval);
+			this.titleInterval = null;
+		}
+		try {
+			this.process.kill();
+		} catch {}
+		this.removeAllListeners();
+	}
+	toInfo() {
+		return {
+			id: this.id,
+			title: this.lastTitle,
+			command: this.command,
+			args: this.args,
+			platform: this.platform,
+			isExited: this.isExited,
+			exitCode: this.exitCode,
+			closeTip: this.closeTip,
+			closeCallbackUrl: this.closeCallbackUrl,
+			createdAt: this.createdAt
+		};
+	}
+};
+var PtyManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	idCounter = 0;
+	platform;
+	constructor(defaultCwd) {
+		this.defaultCwd = defaultCwd;
+		this.platform = detectPtyPlatform();
+	}
+	create(opts) {
+		const id = `pty-${++this.idCounter}`;
+		const session = new PtySession(id, {
+			cols: opts.cols,
+			rows: opts.rows,
+			command: opts.command,
+			args: opts.args,
+			closeTip: opts.closeTip,
+			closeCallbackUrl: opts.closeCallbackUrl,
+			cwd: this.defaultCwd,
+			scrollback: opts.scrollback,
+			maxBufferBytes: opts.maxBufferBytes,
+			platform: this.platform
+		});
+		this.sessions.set(id, session);
+		return session;
+	}
+	get(id) {
+		return this.sessions.get(id);
+	}
+	list() {
+		const result = [];
+		for (const session of this.sessions.values()) result.push(session.toInfo());
+		return result;
+	}
+	write(id, data) {
+		this.sessions.get(id)?.write(data);
+	}
+	resize(id, cols, rows) {
+		this.sessions.get(id)?.resize(cols, rows);
+	}
+	close(id) {
+		const session = this.sessions.get(id);
+		if (session) {
+			session.close();
+			this.sessions.delete(id);
+		}
+	}
+	closeAll() {
+		for (const session of this.sessions.values()) session.close();
+		this.sessions.clear();
+	}
+};
+
+//#endregion
+//#region ../server/src/pty-websocket.ts
+function createPtyWebSocketHandler(ptyManager) {
+	return (ws) => {
+		const cleanups = /* @__PURE__ */ new Map();
+		const send = (msg) => {
+			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+		};
+		const sendError = (code, message, opts) => {
+			send({
+				type: "error",
+				code,
+				message,
+				sessionId: opts?.sessionId
+			});
+		};
+		const attachToSession = (session, opts) => {
+			const sessionId = session.id;
+			cleanups.get(sessionId)?.();
+			if (opts?.cols && opts?.rows && !session.isExited) session.resize(opts.cols, opts.rows);
+			const onData = (data) => {
+				send({
+					type: "output",
+					sessionId,
+					data
+				});
+			};
+			const onExit = (exitCode) => {
+				send({
+					type: "exit",
+					sessionId,
+					exitCode
+				});
+			};
+			const onTitle = (title) => {
+				send({
+					type: "title",
+					sessionId,
+					title
+				});
+			};
+			session.on("data", onData);
+			session.on("exit", onExit);
+			session.on("title", onTitle);
+			cleanups.set(sessionId, () => {
+				session.removeListener("data", onData);
+				session.removeListener("exit", onExit);
+				session.removeListener("title", onTitle);
+				cleanups.delete(sessionId);
+			});
+		};
+		ws.on("message", (raw$1) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(String(raw$1));
+			} catch {
+				sendError("INVALID_JSON", "Invalid JSON payload");
+				return;
+			}
+			const parsedMessage = PtyClientMessageSchema.safeParse(parsed);
+			if (!parsedMessage.success) {
+				const firstIssue = parsedMessage.error.issues[0]?.message;
+				sendError("INVALID_MESSAGE", firstIssue ?? "Invalid PTY message");
+				return;
+			}
+			const msg = parsedMessage.data;
+			switch (msg.type) {
+				case "create":
+					try {
+						const createMessage = msg;
+						const session = ptyManager.create({
+							cols: msg.cols,
+							rows: msg.rows,
+							command: msg.command,
+							args: msg.args,
+							closeTip: createMessage.closeTip,
+							closeCallbackUrl: createMessage.closeCallbackUrl
+						});
+						send({
+							type: "created",
+							requestId: msg.requestId,
+							sessionId: session.id,
+							platform: session.platform
+						});
+						attachToSession(session);
+					} catch (err) {
+						sendError("PTY_CREATE_FAILED", err instanceof Error ? err.message : String(err), { sessionId: msg.requestId });
+					}
+					break;
+				case "attach": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						send({
+							type: "exit",
+							sessionId: msg.sessionId,
+							exitCode: -1
+						});
+						break;
+					}
+					attachToSession(session, {
+						cols: msg.cols,
+						rows: msg.rows
+					});
+					const buffer = session.getBuffer();
+					if (buffer) send({
+						type: "buffer",
+						sessionId: session.id,
+						data: buffer
+					});
+					if (session.title) send({
+						type: "title",
+						sessionId: session.id,
+						title: session.title
+					});
+					if (session.isExited) send({
+						type: "exit",
+						sessionId: session.id,
+						exitCode: session.exitCode ?? -1
+					});
+					break;
+				}
+				case "list":
+					send({
+						type: "list",
+						sessions: ptyManager.list().map((s) => ({
+							id: s.id,
+							title: s.title,
+							command: s.command,
+							args: s.args,
+							platform: s.platform,
+							isExited: s.isExited,
+							exitCode: s.exitCode,
+							closeTip: s.closeTip,
+							closeCallbackUrl: s.closeCallbackUrl
+						}))
+					});
+					break;
+				case "input": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					session.write(msg.data);
+					break;
+				}
+				case "resize": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					session.resize(msg.cols, msg.rows);
+					break;
 				}
-			} catch (err) {
-				console.error("[CLI Stream] Error emitting event:", err);
-				if (!completed) {
-					completed = true;
-					try {
-						emit.error(err instanceof Error ? err : new Error(String(err)));
-					} catch {}
+				case "close": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					cleanups.get(msg.sessionId)?.();
+					ptyManager.close(session.id);
+					break;
 				}
 			}
-		};
-		startStream(safeEventHandler).then((cancelFn) => {
-			cancel = cancelFn;
-		}).catch((err) => {
-			console.error("[CLI Stream] Error starting stream:", err);
-			if (!completed) {
-				completed = true;
-				try {
-					emit.error(err instanceof Error ? err : new Error(String(err)));
-				} catch {}
-			}
 		});
-		return () => {
-			completed = true;
-			cancel?.();
-		};
-	});
-}
-
-//#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
+		ws.on("close", () => {
+			for (const cleanup of cleanups.values()) cleanup();
+			cleanups.clear();
 		});
-		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(/^\.\//, "");
+
+//#endregion
+//#region ../search/src/protocol.ts
+const SearchDocumentKindSchema = enumType([
+	"spec",
+	"change",
+	"archive"
+]);
+const SearchDocumentSchema = objectType({
+	id: stringType(),
+	kind: SearchDocumentKindSchema,
+	title: stringType(),
+	href: stringType(),
+	path: stringType(),
+	content: stringType(),
+	updatedAt: numberType()
+});
+const SearchQuerySchema = objectType({
+	query: stringType(),
+	limit: numberType().int().positive().optional()
+});
+const SearchHitSchema = objectType({
+	documentId: stringType(),
+	kind: SearchDocumentKindSchema,
+	title: stringType(),
+	href: stringType(),
+	path: stringType(),
+	score: numberType(),
+	snippet: stringType(),
+	updatedAt: numberType()
+});
+const SearchWorkerRequestSchema = discriminatedUnionType("type", [
+	objectType({
+		id: stringType(),
+		type: literalType("init"),
+		docs: arrayType(SearchDocumentSchema)
+	}),
+	objectType({
+		id: stringType(),
+		type: literalType("replaceAll"),
+		docs: arrayType(SearchDocumentSchema)
+	}),
+	objectType({
+		id: stringType(),
+		type: literalType("search"),
+		query: SearchQuerySchema
+	}),
+	objectType({
+		id: stringType(),
+		type: literalType("dispose")
+	})
+]);
+const SearchWorkerResponseSchema = discriminatedUnionType("type", [
+	objectType({
+		id: stringType(),
+		type: literalType("ok")
+	}),
+	objectType({
+		id: stringType(),
+		type: literalType("results"),
+		hits: arrayType(SearchHitSchema)
+	}),
+	objectType({
+		id: stringType(),
+		type: literalType("error"),
+		message: stringType()
+	})
+]);
+
+//#endregion
+//#region ../search/src/worker-source.ts
+const sharedRuntimeSource = String.raw`
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+const SNIPPET_SIZE = 180;
+
+function normalizeText(input) {
+  return String(input || '')
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .trim();
 }
-function relativePath(fromDir, target) {
-	const rel = relative$1(fromDir, target);
-	if (!rel || rel.length === 0) return ".";
-	return rel;
+
+function splitTerms(query) {
+  return normalizeText(query)
+    .split(' ')
+    .map((term) => term.trim())
+    .filter((term) => term.length > 0);
 }
-function parseBranchName(branchRef, detached) {
-	if (detached) return "(detached)";
-	if (!branchRef) return "(unknown)";
-	return branchRef.replace(/^refs\/heads\//, "");
+
+function toSearchIndexDocument(doc) {
+  return {
+    id: doc.id,
+    kind: doc.kind,
+    title: doc.title,
+    href: doc.href,
+    path: doc.path,
+    content: doc.content,
+    updatedAt: doc.updatedAt,
+    normalizedTitle: normalizeText(doc.title),
+    normalizedPath: normalizeText(doc.path),
+    normalizedContent: normalizeText(doc.content),
+  };
 }
-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 buildSearchIndex(docs) {
+  return {
+    documents: Array.isArray(docs) ? docs.map(toSearchIndexDocument) : [],
+  };
 }
-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));
+
+function resolveLimit(limit) {
+  if (typeof limit !== 'number' || Number.isNaN(limit)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
 }
-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";
+
+function isDocumentMatch(doc, terms) {
+  return terms.every(
+    (term) =>
+      doc.normalizedTitle.includes(term) ||
+      doc.normalizedPath.includes(term) ||
+      doc.normalizedContent.includes(term)
+  );
 }
-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;
+
+function scoreDocument(doc, terms) {
+  let score = 0;
+
+  for (const term of terms) {
+    if (doc.normalizedTitle.includes(term)) score += 30;
+    if (doc.normalizedPath.includes(term)) score += 20;
+
+    const contentIdx = doc.normalizedContent.indexOf(term);
+    if (contentIdx >= 0) {
+      score += 8;
+      if (contentIdx < 160) score += 4;
+    }
+  }
+
+  return score;
 }
-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
-	};
+
+function createSnippet(content, terms) {
+  const source = String(content || '').trim();
+  if (!source) return '';
+
+  const normalizedSource = normalizeText(source);
+  let matchIndex = -1;
+
+  for (const term of terms) {
+    const idx = normalizedSource.indexOf(term);
+    if (idx >= 0 && (matchIndex < 0 || idx < matchIndex)) {
+      matchIndex = idx;
+    }
+  }
+
+  if (matchIndex < 0) {
+    return source.slice(0, SNIPPET_SIZE);
+  }
+
+  const start = Math.max(0, matchIndex - Math.floor(SNIPPET_SIZE / 3));
+  const end = Math.min(source.length, start + SNIPPET_SIZE);
+
+  const prefix = start > 0 ? '...' : '';
+  const suffix = end < source.length ? '...' : '';
+  return prefix + source.slice(start, end) + suffix;
 }
-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
-	};
+
+function searchIndex(index, query) {
+  const terms = splitTerms(query && query.query ? query.query : '');
+  if (terms.length === 0) return [];
+
+  const hits = [];
+
+  for (const doc of index.documents) {
+    if (!isDocumentMatch(doc, terms)) continue;
+
+    hits.push({
+      documentId: doc.id,
+      kind: doc.kind,
+      title: doc.title,
+      href: doc.href,
+      path: doc.path,
+      score: scoreDocument(doc, terms),
+      snippet: createSnippet(doc.content, terms),
+      updatedAt: doc.updatedAt,
+    });
+  }
+
+  hits.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.updatedAt - a.updatedAt;
+  });
+
+  return hits.slice(0, resolveLimit(query ? query.limit : undefined));
+}
+
+let index = buildSearchIndex([]);
+
+function handleMessage(payload) {
+  try {
+    if (!payload || typeof payload !== 'object') {
+      throw new Error('Invalid worker request payload');
+    }
+
+    if (payload.type === 'init' || payload.type === 'replaceAll') {
+      index = buildSearchIndex(Array.isArray(payload.docs) ? payload.docs : []);
+      return { id: payload.id, type: 'ok' };
+    }
+
+    if (payload.type === 'search') {
+      const hits = searchIndex(index, payload.query || { query: '' });
+      return { id: payload.id, type: 'results', hits };
+    }
+
+    if (payload.type === 'dispose') {
+      index = buildSearchIndex([]);
+      return { id: payload.id, type: 'ok' };
+    }
+
+    throw new Error('Unsupported worker request type');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { id: payload?.id ?? 'unknown', type: 'error', message };
+  }
+}
+`;
+function buildNodeWorkerSource() {
+	return `${sharedRuntimeSource}\nconst { parentPort } = require('node:worker_threads');\nif (!parentPort) { throw new Error('Missing parentPort'); }\nparentPort.on('message', (payload) => { parentPort.postMessage(handleMessage(payload)); });`;
 }
 
 //#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]
+//#region ../server/src/cli-stream-observable.ts
+/**
+* 创建安全的 CLI 流式 observable
+*
+* 解决的问题：
+* 1. 防止在 emit.complete() 之后调用 emit.next()（会导致 "Controller is already closed" 错误）
+* 2. 统一的错误处理，防止未捕获的异常导致服务器崩溃
+* 3. 确保取消时正确清理资源
+*
+* @param startStream 启动流的函数，接收 onEvent 回调，返回取消函数的 Promise
+*/
+function createCliStreamObservable(startStream) {
+	return observable((emit) => {
+		let cancel;
+		let completed = false;
+		/**
+		* 安全的事件处理器
+		* - 检查是否已完成，防止重复调用
+		* - 使用 try-catch 防止异常导致服务器崩溃
+		*/
+		const safeEventHandler = (event) => {
+			if (completed) return;
+			try {
+				emit.next(event);
+				if (event.type === "exit") {
+					completed = true;
+					emit.complete();
+				}
+			} catch (err) {
+				console.error("[CLI Stream] Error emitting event:", err);
+				if (!completed) {
+					completed = true;
+					try {
+						emit.error(err instanceof Error ? err : new Error(String(err)));
+					} catch {}
+				}
+			}
 		};
-		if (reducer === "sum-cumulative") {
-			cumulative += sums[index];
-			return {
-				ts,
-				value: cumulative
-			};
-		}
-		if (counts[index] > 0) carry = sums[index] / counts[index];
-		return {
-			ts,
-			value: carry
+		startStream(safeEventHandler).then((cancelFn) => {
+			cancel = cancelFn;
+		}).catch((err) => {
+			console.error("[CLI Stream] Error starting stream:", err);
+			if (!completed) {
+				completed = true;
+				try {
+					emit.error(err instanceof Error ? err : new Error(String(err)));
+				} catch {}
+			}
+		});
+		return () => {
+			completed = true;
+			cancel?.();
 		};
 	});
 }
-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
@@ -23980,133 +24348,55 @@ const reactiveKV = new ReactiveKV();
 */
 function createReactiveSubscription(task) {
 	return observable((emit) => {
-		const context = new ReactiveContext();
-		const controller = new AbortController();
-		(async () => {
-			try {
-				for await (const data of context.stream(task, controller.signal)) emit.next(data);
-			} catch (err) {
-				if (!controller.signal.aborted) emit.error(err);
-			}
-		})();
-		return () => {
-			controller.abort();
-		};
-	});
-}
-/**
-* 创建带输入参数的响应式订阅
-*
-* @param task 接收输入参数的异步任务
-* @returns 返回一个函数，接收输入参数并返回 tRPC observable
-*
-* @example
-* ```typescript
-* // 在 router 中使用
-* subscribeOne: publicProcedure
-*   .input(z.object({ id: z.string() }))
-*   .subscription(({ ctx, input }) => {
-*     return createReactiveSubscriptionWithInput(
-*       (id: string) => ctx.adapter.readSpec(id)
-*     )(input.id)
-*   })
-* ```
-*/
-function createReactiveSubscriptionWithInput(task) {
-	return (input) => {
-		return createReactiveSubscription(() => task(input));
-	};
-}
-
-//#endregion
-//#region ../server/src/router.ts
-const t = initTRPC.context().create();
-const router = t.router;
-const publicProcedure = t.procedure;
-const execFileAsync = promisify$1(execFile);
-const OPSX_CORE_PROFILE_WORKFLOWS = [
-	"propose",
-	"explore",
-	"apply",
-	"archive"
-];
-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();
-}
-const DASHBOARD_GIT_REFRESH_STAMP_NAME = "openspecui-dashboard-git-refresh.stamp";
-async function resolveGitMetadataDir(projectDir) {
-	try {
-		const { stdout } = await execFileAsync("git", ["rev-parse", "--git-dir"], {
-			cwd: projectDir,
-			maxBuffer: 1024 * 1024,
-			encoding: "utf8"
-		});
-		const gitDirRaw = stdout.trim();
-		if (!gitDirRaw) return null;
-		const gitDirPath = resolve$1(projectDir, gitDirRaw);
-		if (!(await stat(gitDirPath)).isDirectory()) return null;
-		return gitDirPath;
-	} catch {
-		return null;
-	}
-}
-async function resolveGitMetadataDirReactive(projectDir) {
-	const gitMetadataDir = await resolveGitMetadataDir(projectDir);
-	if (!gitMetadataDir) return null;
-	await reactiveReadDir(gitMetadataDir, { includeHidden: true });
-	return gitMetadataDir;
-}
-function getDashboardGitRefreshStampPath(gitMetadataDir) {
-	return join$1(gitMetadataDir, DASHBOARD_GIT_REFRESH_STAMP_NAME);
-}
-async function touchDashboardGitRefreshStamp(projectDir, reason) {
-	const gitMetadataDir = await resolveGitMetadataDir(projectDir);
-	if (!gitMetadataDir) return { skipped: true };
-	const stampPath = getDashboardGitRefreshStampPath(gitMetadataDir);
-	await mkdir$1(dirname$1(stampPath), { recursive: true });
-	await writeFile$1(stampPath, `${Date.now()} ${reason}\n`, "utf8");
-	return { skipped: false };
-}
-async function registerDashboardGitReactiveDeps(projectDir) {
-	await reactiveReadDir(projectDir, {
-		includeHidden: true,
-		exclude: ["node_modules"]
+		const context = new ReactiveContext();
+		const controller = new AbortController();
+		(async () => {
+			try {
+				for await (const data of context.stream(task, controller.signal)) emit.next(data);
+			} catch (err) {
+				if (!controller.signal.aborted) emit.error(err);
+			}
+		})();
+		return () => {
+			controller.abort();
+		};
 	});
-	const gitMetadataDir = await resolveGitMetadataDirReactive(projectDir);
-	if (!gitMetadataDir) return;
-	await reactiveReadFile(getDashboardGitRefreshStampPath(gitMetadataDir));
-	await reactiveReadFile(join$1(gitMetadataDir, "HEAD"));
-	await reactiveReadFile(join$1(gitMetadataDir, "index"));
-	await reactiveReadFile(join$1(gitMetadataDir, "packed-refs"));
 }
+/**
+* 创建带输入参数的响应式订阅
+*
+* @param task 接收输入参数的异步任务
+* @returns 返回一个函数，接收输入参数并返回 tRPC observable
+*
+* @example
+* ```typescript
+* // 在 router 中使用
+* subscribeOne: publicProcedure
+*   .input(z.object({ id: z.string() }))
+*   .subscription(({ ctx, input }) => {
+*     return createReactiveSubscriptionWithInput(
+*       (id: string) => ctx.adapter.readSpec(id)
+*     )(input.id)
+*   })
+* ```
+*/
+function createReactiveSubscriptionWithInput(task) {
+	return (input) => {
+		return createReactiveSubscription(() => task(input));
+	};
+}
+
+//#endregion
+//#region ../server/src/router.ts
+const t = initTRPC.context().create();
+const router = t.router;
+const publicProcedure = t.procedure;
+const OPSX_CORE_PROFILE_WORKFLOWS = [
+	"propose",
+	"explore",
+	"apply",
+	"archive"
+];
 function requireChangeId(changeId) {
 	if (!changeId) throw new Error("change is required");
 	return changeId;
@@ -24276,200 +24566,6 @@ 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 activeChanges = changeMetas.map((changeMeta) => ({
-		id: changeMeta.id,
-		name: changeMeta.name ?? changeMeta.id,
-		progress: changeMeta.progress,
-		updatedAt: changeMeta.updatedAt
-	})).sort((a, b) => b.updatedAt - a.updatedAt);
-	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 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
 */
@@ -25171,30 +25267,52 @@ const systemRouter = router({
 */
 const dashboardRouter = router({
 	get: publicProcedure.query(async ({ ctx }) => {
-		return fetchDashboardOverview(ctx, "dashboard.get");
+		return ctx.dashboardOverviewService.getCurrent();
 	}),
 	subscribe: publicProcedure.subscription(({ ctx }) => {
-		return createReactiveSubscription(async () => {
-			return fetchDashboardOverview(ctx, "dashboard.subscribe");
+		return observable((emit) => {
+			const unsubscribe = ctx.dashboardOverviewService.subscribe((overview) => {
+				emit.next(overview);
+			}, {
+				emitCurrent: true,
+				onError: (error) => {
+					emit.error(error);
+				}
+			});
+			return () => {
+				unsubscribe();
+			};
 		});
 	}),
 	refreshGitSnapshot: publicProcedure.input(objectType({ reason: stringType().optional() }).optional()).mutation(async ({ ctx, input }) => {
 		const reason = input?.reason?.trim() || "manual-refresh";
 		await touchDashboardGitRefreshStamp(ctx.projectDir, reason);
+		await ctx.dashboardOverviewService.refresh(reason);
+		return { success: true };
+	}),
+	removeDetachedWorktree: publicProcedure.input(objectType({ path: stringType().min(1) })).mutation(async ({ ctx, input }) => {
+		await ctx.dashboardOverviewService.getCurrent();
+		await removeDetachedDashboardGitWorktree({
+			projectDir: ctx.projectDir,
+			targetPath: input.path
+		});
+		await touchDashboardGitRefreshStamp(ctx.projectDir, "remove-detached-worktree");
+		await ctx.dashboardOverviewService.refresh("remove-detached-worktree");
 		return { success: true };
 	}),
-	gitTaskStatus: publicProcedure.query(() => {
+	gitTaskStatus: publicProcedure.query(async ({ ctx }) => {
+		await ctx.dashboardOverviewService.getCurrent();
 		return getDashboardGitTaskStatus();
 	}),
-	subscribeGitTaskStatus: publicProcedure.subscription(() => {
+	subscribeGitTaskStatus: publicProcedure.subscription(({ ctx }) => {
 		return observable((emit) => {
+			ctx.dashboardOverviewService.getCurrent().catch(() => {});
 			emit.next(getDashboardGitTaskStatus());
-			const handler = (status) => {
+			const unsubscribe = subscribeDashboardGitTaskStatus((status) => {
 				emit.next(status);
-			};
-			dashboardGitTaskStatusEmitter.on("change", handler);
+			});
 			return () => {
-				dashboardGitTaskStatusEmitter.off("change", handler);
+				unsubscribe();
 			};
 		});
 	})
@@ -25472,6 +25590,11 @@ function createServer$2(config) {
 	const kernel = config.kernel;
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
 	const searchService = new SearchService(adapter, watcher);
+	const dashboardOverviewService = new DashboardOverviewService((reason) => loadDashboardOverview({
+		adapter,
+		configManager,
+		projectDir: config.projectDir
+	}, reason), watcher);
 	const app = new Hono();
 	const corsOrigins = config.corsOrigins ?? ["http://localhost:5173", "http://localhost:3000"];
 	app.use("*", cors({
@@ -25498,6 +25621,7 @@ function createServer$2(config) {
 				cliExecutor,
 				kernel,
 				searchService,
+				dashboardOverviewService,
 				watcher,
 				projectDir: config.projectDir
 			})
@@ -25509,6 +25633,7 @@ function createServer$2(config) {
 		cliExecutor,
 		kernel,
 		searchService,
+		dashboardOverviewService,
 		watcher,
 		projectDir: config.projectDir
 	});
@@ -25519,6 +25644,7 @@ function createServer$2(config) {
 		cliExecutor,
 		kernel,
 		searchService,
+		dashboardOverviewService,
 		watcher,
 		createContext,
 		port: config.port ?? 3100
@@ -25566,6 +25692,7 @@ async function createWebSocketServer(server, httpServer, config) {
 			wss.close();
 			server.watcher?.stop();
 			server.searchService.dispose().catch(() => {});
+			server.dashboardOverviewService.dispose();
 		}
 	};
 }
@@ -25601,6 +25728,9 @@ async function startServer(config, setupApp) {
 	server.searchService.init().catch((err) => {
 		console.error("Search service warmup failed:", err);
 	});
+	server.dashboardOverviewService.init().catch((err) => {
+		console.error("Dashboard overview warmup failed:", err);
+	});
 	return {
 		url,
 		port,