openspecui 2.1.6 → 2.2.0

package/dist/{src-DglsnBxF.mjs → src-dyNiaV8K.mjs}

@@ -7,17 +7,17 @@ import crypto from "crypto";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { dirname, join } from "path";
 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 { mkdir as mkdir$1, readFile as readFile$1, readdir, realpath, rm, stat, writeFile as writeFile$1 } from "node:fs/promises";
 import { basename as basename$1, 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 { EventEmitter } from "events";
 import { watch } from "fs";
-import { exec, spawn } from "child_process";
+import { exec, execFile, spawn } from "child_process";
 import { promisify } from "util";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { EventEmitter as EventEmitter$1 } from "node:events";
-import { execFile } from "node:child_process";
+import { execFile as execFile$1, spawn as spawn$1 } 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";
@@ -5919,6 +5919,7 @@ var OpenSpecWatcher = class extends EventEmitter {
 //#endregion
 //#region ../core/src/config.ts
 const execAsync = promisify(exec);
+const execFileAsync$2 = promisify(execFile);
 const CLI_PROBE_TIMEOUT_MS = 2e4;
 const THEME_VALUES = [
 	"light",
@@ -6078,6 +6079,53 @@ function commandToString(commandParts) {
 	};
 	return commandParts.map(formatToken).join(" ").trim();
 }
+function isBareExecutableCommand(command) {
+	if (!command) return false;
+	if (command === "." || command === "..") return false;
+	return !/[\\/]/.test(command);
+}
+function quotePosixShellArg(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function resolveShellExecutablePath(command, cwd, env) {
+	if (!isBareExecutableCommand(command)) return null;
+	try {
+		if (process.platform === "win32") {
+			const { stdout: stdout$1 } = await execFileAsync$2("where", [command], {
+				cwd,
+				env,
+				encoding: "utf8",
+				timeout: 5e3
+			});
+			return stdout$1.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) || null;
+		}
+		const { stdout } = await execFileAsync$2(env.SHELL || process.env.SHELL || "/bin/sh", ["-lc", `command -v -- ${quotePosixShellArg(command)}`], {
+			cwd,
+			env,
+			encoding: "utf8",
+			timeout: 5e3
+		});
+		return stdout.split("\n").map((line) => line.trim()).find((line) => line.startsWith("/")) || null;
+	} catch {
+		return null;
+	}
+}
+async function expandCliRunnerCandidates(candidates, cwd, env) {
+	const expanded = [];
+	for (const candidate of candidates) {
+		const [command, ...rest] = candidate.commandParts;
+		if ((candidate.id === "openspec" || candidate.id === "configured" && command.trim().toLowerCase() === "openspec") && command) {
+			const shellResolved = await resolveShellExecutablePath(command, cwd, env);
+			if (shellResolved && shellResolved !== command) expanded.push({
+				...candidate,
+				source: `${candidate.source} (shell)`,
+				commandParts: [shellResolved, ...rest]
+			});
+		}
+		expanded.push(candidate);
+	}
+	return expanded;
+}
 function getRunnerPriorityFromUserAgent(userAgent) {
 	if (!userAgent) return null;
 	if (userAgent.startsWith("bun")) return "bunx";
@@ -6183,8 +6231,9 @@ async function probeCliRunner(candidate, cwd, env) {
 	});
 }
 async function resolveCliRunner(candidates, cwd, env) {
+	const expandedCandidates = await expandCliRunnerCandidates(candidates, cwd, env);
 	const attempts = [];
-	for (const candidate of candidates) {
+	for (const candidate of expandedCandidates) {
 		const attempt = await probeCliRunner(candidate, cwd, env);
 		attempts.push(attempt);
 		if (attempt.success) return {
@@ -6237,7 +6286,13 @@ async function fetchLatestVersion() {
 * 每次调用都会重新检测，不使用缓存。
 */
 async function sniffGlobalCli() {
-	const [localResult, latestVersion] = await Promise.all([execAsync("openspec --version", { timeout: 1e4 }).catch((err) => ({ error: err })), fetchLatestVersion()]);
+	const env = createCleanCliEnv();
+	const resolvedCommand = await resolveShellExecutablePath("openspec", process.cwd(), env) ?? "openspec";
+	const [localResult, latestVersion] = await Promise.all([execFileAsync$2(resolvedCommand, ["--version"], {
+		env,
+		timeout: 1e4,
+		encoding: "utf8"
+	}).catch((err) => ({ error: err })), fetchLatestVersion()]);
 	if ("error" in localResult) {
 		const error = localResult.error instanceof Error ? localResult.error.message : String(localResult.error);
 		if (error.includes("not found") || error.includes("ENOENT") || error.includes("not recognized")) return {
@@ -23207,8 +23262,8 @@ function selectRecentDashboardItems(items, limit = DASHBOARD_RECENT_LIST_LIMIT)
 }
 
 //#endregion
-//#region ../server/src/dashboard-git-snapshot.ts
-const execFileAsync$1 = promisify$1(execFile);
+//#region ../server/src/git-shared.ts
+const execFileAsync$1 = promisify$1(execFile$1);
 const EMPTY_DIFF = {
 	files: 0,
 	insertions: 0,
@@ -23232,6 +23287,22 @@ async function defaultRunGit(cwd, args) {
 		};
 	}
 }
+async function defaultReadPathTimestampMs(absolutePath) {
+	try {
+		const stats = await stat(absolutePath);
+		return Number.isFinite(stats.mtimeMs) && stats.mtimeMs > 0 ? stats.mtimeMs : null;
+	} catch {
+		return null;
+	}
+}
+async function pathExists(absolutePath) {
+	try {
+		await stat(absolutePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
 function parseShortStat(output) {
 	const files = Number(/(\d+)\s+files? changed/.exec(output)?.[1] ?? 0);
 	const insertions = Number(/(\d+)\s+insertions?\(\+\)/.exec(output)?.[1] ?? 0);
@@ -23242,33 +23313,48 @@ function parseShortStat(output) {
 		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 extractGitPathVariants(rawPath) {
+	const trimmed = rawPath.trim();
+	if (!trimmed) return [];
+	const normalizedRaw = normalizeGitPath(trimmed);
+	const braceRenameMatch = /^(.*?)\{(.*?) => (.*?)\}(.*)$/.exec(trimmed);
+	if (braceRenameMatch) {
+		const [, prefix = "", left = "", right = "", suffix = ""] = braceRenameMatch;
+		const variants = /* @__PURE__ */ new Set();
+		variants.add(normalizeGitPath(`${prefix}${left}${suffix}`));
+		variants.add(normalizeGitPath(`${prefix}${right}${suffix}`));
+		return [...variants];
+	}
+	const renameParts = trimmed.split(" => ");
+	if (renameParts.length === 2) {
+		const [left = "", right = ""] = renameParts;
+		const variants = /* @__PURE__ */ new Set();
+		variants.add(normalizeGitPath(left));
+		variants.add(normalizeGitPath(right));
+		return [...variants];
+	}
+	return [normalizedRaw];
+}
 function relativePath(fromDir, target) {
 	const rel = relative$1(fromDir, target);
 	if (!rel || rel.length === 0) return ".";
 	return rel;
 }
+async function canonicalGitPath(path$1) {
+	const resolved = resolve$1(path$1);
+	try {
+		return await realpath(resolved);
+	} catch {
+		return resolved;
+	}
+}
+async function sameGitPath(left, right) {
+	const [canonicalLeft, canonicalRight] = await Promise.all([canonicalGitPath(left), canonicalGitPath(right)]);
+	return canonicalLeft === canonicalRight;
+}
 function parseBranchName(branchRef, detached) {
 	if (detached) return "(detached)";
 	if (!branchRef) return "(unknown)";
@@ -23297,10 +23383,7 @@ function parseWorktreeList(porcelain) {
 			current.branchRef = line.slice(7).trim();
 			continue;
 		}
-		if (line === "detached") {
-			current.detached = true;
-			continue;
-		}
+		if (line === "detached") current.detached = true;
 	}
 	flush();
 	return entries;
@@ -23309,16 +23392,17 @@ function parseRelatedChanges(paths) {
 	const related = /* @__PURE__ */ new Set();
 	for (const path$1 of paths) {
 		const normalized = normalizeGitPath(path$1);
+		if (normalized.includes("{") || normalized.includes("=>")) continue;
+		const archiveMatch = /^openspec\/changes\/archive\/([^/]+)\//.exec(normalized);
+		if (archiveMatch?.[1]) {
+			related.add(archiveMatch[1].replace(/^\d{4}-\d{2}-\d{2}-/, ""));
+			continue;
+		}
 		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));
 }
@@ -23340,39 +23424,112 @@ async function resolveDefaultBranch(projectDir, runGit) {
 	if (localHead.ok && localRef && localRef !== "HEAD") return localRef;
 	return "main";
 }
-async function collectCommitEntries(options) {
-	const { worktreePath, defaultBranch, maxCommitEntries, runGit } = options;
-	const entries = [];
+async function listGitWorktrees(projectDir, runGit) {
+	const resolvedProjectDir = resolve$1(projectDir);
+	const worktreeResult = await runGit(resolvedProjectDir, [
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	const parsed = worktreeResult.ok ? parseWorktreeList(worktreeResult.stdout) : [];
+	if (parsed.length > 0) return parsed;
+	return [{
+		path: resolvedProjectDir,
+		branchRef: null,
+		detached: false
+	}];
+}
+
+//#endregion
+//#region ../server/src/git-entry-summary.ts
+function createEmptyCommitRecord(hash, committedAt, title) {
+	return {
+		hash,
+		committedAt,
+		title,
+		diff: { ...EMPTY_DIFF },
+		changedPaths: []
+	};
+}
+function parseGitLogNumstatRecords(stdout) {
+	const records = [];
+	for (const block of stdout.split("")) {
+		const trimmedBlock = block.trim();
+		if (!trimmedBlock) continue;
+		const lines = trimmedBlock.split("\n");
+		const header = lines.shift()?.trim();
+		if (!header) continue;
+		const [hash, committedAtRaw = "0", title = ""] = header.split("");
+		if (!hash) continue;
+		const committedAtSeconds = Number(committedAtRaw);
+		const record = createEmptyCommitRecord(hash, Number.isFinite(committedAtSeconds) && committedAtSeconds > 0 ? committedAtSeconds * 1e3 : 0, title.trim() || hash.slice(0, 7));
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (!trimmedLine) continue;
+			const parts = trimmedLine.split("	");
+			if (parts.length < 3) continue;
+			const [insertionsRaw = "0", deletionsRaw = "0", ...pathParts] = parts;
+			const rawPath = pathParts.join("	").trim();
+			if (!rawPath) continue;
+			record.diff.files += 1;
+			if (insertionsRaw !== "-") record.diff.insertions += Number(insertionsRaw) || 0;
+			if (deletionsRaw !== "-") record.diff.deletions += Number(deletionsRaw) || 0;
+			record.changedPaths.push(...extractGitPathVariants(rawPath));
+		}
+		records.push(record);
+	}
+	return records;
+}
+async function listGitCommitEntriesPage(options) {
+	const { worktreePath, defaultBranch, offset, limit, runGit } = options;
 	const commits = await runGit(worktreePath, [
 		"log",
-		"--format=%H%x1f%s",
-		`-n${maxCommitEntries}`,
+		"--format=%x1e%H%x1f%ct%x1f%s",
+		"--numstat",
+		`--skip=${offset}`,
+		`-n${limit + 1}`,
 		`${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({
+	if (!commits.ok) return {
+		items: [],
+		nextCursor: null
+	};
+	const records = parseGitLogNumstatRecords(commits.stdout);
+	return {
+		items: records.slice(0, limit).map((record) => ({
 			type: "commit",
-			hash,
-			title: title.trim() || hash.slice(0, 7),
-			relatedChanges: parseRelatedChanges(changedFiles),
-			diff: diffResult.ok ? parseNumStat(diffResult.stdout) : EMPTY_DIFF
-		});
-	}
+			hash: record.hash,
+			title: record.title,
+			committedAt: record.committedAt,
+			relatedChanges: parseRelatedChanges(record.changedPaths),
+			diff: record.diff
+		})),
+		nextCursor: records.length > limit ? String(offset + limit) : null
+	};
+}
+async function readGitCommitEntryByHash(options) {
+	const { worktreePath, hash, runGit } = options;
+	const result = await runGit(worktreePath, [
+		"show",
+		"--numstat",
+		"--format=%x1e%H%x1f%ct%x1f%s",
+		hash
+	]);
+	if (!result.ok) return null;
+	const record = parseGitLogNumstatRecords(result.stdout)[0];
+	if (!record) return null;
+	return {
+		type: "commit",
+		hash: record.hash,
+		title: record.title,
+		committedAt: record.committedAt,
+		relatedChanges: parseRelatedChanges(record.changedPaths),
+		diff: record.diff
+	};
+}
+async function collectUncommittedEntrySummary(options) {
+	const { worktreePath, runGit } = options;
+	const readPathTimestampMs = options.readPathTimestampMs ?? defaultReadPathTimestampMs;
 	const trackedResult = await runGit(worktreePath, [
 		"diff",
 		"--numstat",
@@ -23390,24 +23547,57 @@ async function collectCommitEntries(options) {
 	]);
 	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 trackedDiff = parseGitLogNumstatRecords(`\u001ehead\u001f0\u001fUncommitted\n${trackedResult.stdout}`)[0]?.diff ?? EMPTY_DIFF;
 	const allUncommittedFiles = new Set([...trackedFiles, ...untrackedFiles]);
-	const trackedDiff = trackedResult.ok ? parseNumStat(trackedResult.stdout) : EMPTY_DIFF;
-	entries.push({
+	return {
 		type: "uncommitted",
 		title: "Uncommitted",
+		updatedAt: (await Promise.all([...allUncommittedFiles].map((path$1) => readPathTimestampMs(resolve$1(worktreePath, path$1))))).reduce((latest, current) => {
+			if (!current || !Number.isFinite(current) || current <= 0) return latest;
+			return latest === null || current > latest ? current : latest;
+		}, null) ?? null,
 		relatedChanges: parseRelatedChanges([...allUncommittedFiles]),
 		diff: {
 			files: allUncommittedFiles.size,
 			insertions: trackedDiff.insertions,
 			deletions: trackedDiff.deletions
 		}
+	};
+}
+async function listRecentGitEntries(options) {
+	const { worktreePath, defaultBranch, maxCommitEntries, runGit, readPathTimestampMs } = options;
+	const [uncommitted, commitsPage] = await Promise.all([collectUncommittedEntrySummary({
+		worktreePath,
+		runGit,
+		readPathTimestampMs
+	}), listGitCommitEntriesPage({
+		worktreePath,
+		defaultBranch,
+		offset: 0,
+		limit: maxCommitEntries,
+		runGit
+	})]);
+	return [uncommitted, ...commitsPage.items];
+}
+
+//#endregion
+//#region ../server/src/dashboard-git-snapshot.ts
+async function collectCommitEntries(options) {
+	const { worktreePath, defaultBranch, maxCommitEntries, runGit, readPathTimestampMs } = options;
+	return listRecentGitEntries({
+		worktreePath,
+		defaultBranch,
+		maxCommitEntries,
+		runGit,
+		readPathTimestampMs
 	});
-	return entries;
 }
 async function collectWorktree(options) {
-	const { projectDir, worktree, defaultBranch, runGit, maxCommitEntries } = options;
+	const { projectDir, worktree, defaultBranch, runGit, maxCommitEntries, readPathTimestampMs } = options;
 	const worktreePath = resolve$1(worktree.path);
 	const resolvedProjectDir = resolve$1(projectDir);
+	const isCurrent = await sameGitPath(worktreePath, resolvedProjectDir);
+	const pathAvailable = await pathExists(worktreePath);
 	const aheadBehindResult = await runGit(worktreePath, [
 		"rev-list",
 		"--left-right",
@@ -23431,14 +23621,16 @@ async function collectWorktree(options) {
 		worktreePath,
 		defaultBranch,
 		maxCommitEntries,
-		runGit
+		runGit,
+		readPathTimestampMs
 	});
 	return {
 		path: worktreePath,
 		relativePath: relativePath(resolvedProjectDir, worktreePath),
+		pathAvailable,
 		branchName: parseBranchName(worktree.branchRef, worktree.detached),
 		detached: worktree.detached,
-		isCurrent: resolvedProjectDir === worktreePath,
+		isCurrent,
 		ahead,
 		behind,
 		diff,
@@ -23449,14 +23641,13 @@ 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 (await sameGitPath(resolvedTargetPath, resolvedProjectDir)) throw new Error("Cannot remove the current worktree.");
+	const worktrees = await listGitWorktrees(resolvedProjectDir, runGit);
+	let matched;
+	for (const worktree of worktrees) if (await sameGitPath(worktree.path, resolvedTargetPath)) {
+		matched = worktree;
+		break;
+	}
 	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, [
@@ -23469,25 +23660,17 @@ async function removeDetachedDashboardGitWorktree(options) {
 async function buildDashboardGitSnapshot(options) {
 	const runGit = options.runGit ?? defaultRunGit;
 	const maxCommitEntries = options.maxCommitEntries ?? 8;
+	const readPathTimestampMs = options.readPathTimestampMs ?? defaultReadPathTimestampMs;
 	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 baseWorktrees = await listGitWorktrees(resolvedProjectDir, runGit);
 	const worktrees = await Promise.all(baseWorktrees.map((worktree) => collectWorktree({
 		projectDir: resolvedProjectDir,
 		worktree,
 		defaultBranch,
 		runGit,
-		maxCommitEntries
+		maxCommitEntries,
+		readPathTimestampMs
 	})));
 	worktrees.sort((a, b) => {
 		if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
@@ -23592,7 +23775,7 @@ function buildDashboardTimeTrends(options) {
 
 //#endregion
 //#region ../server/src/dashboard-overview.ts
-const execFileAsync = promisify$1(execFile);
+const execFileAsync = promisify$1(execFile$1);
 const DASHBOARD_GIT_REFRESH_STAMP_NAME = "openspecui-dashboard-git-refresh.stamp";
 const dashboardGitTaskStatusEmitter = new EventEmitter$1();
 dashboardGitTaskStatusEmitter.setMaxListeners(200);
@@ -24510,6 +24693,457 @@ function createCliStreamObservable(startStream) {
 	});
 }
 
+//#endregion
+//#region ../server/src/git-panel-cache.ts
+const gitPanelCaches = {
+	overview: /* @__PURE__ */ new Map(),
+	entries: /* @__PURE__ */ new Map(),
+	shell: /* @__PURE__ */ new Map(),
+	patch: /* @__PURE__ */ new Map()
+};
+function buildCacheKey(projectDir, key) {
+	return `${resolve$1(projectDir)}::${key}`;
+}
+function getCacheVersion() {
+	return getDashboardGitTaskStatus().lastFinishedAt ?? 0;
+}
+async function getCachedGitPanelValue(scope, projectDir, key, load) {
+	const cache = gitPanelCaches[scope];
+	const cacheKey$1 = buildCacheKey(projectDir, key);
+	const version = getCacheVersion();
+	const hit = cache.get(cacheKey$1);
+	if (hit && hit.version === version) return hit.value;
+	const value = await load();
+	cache.set(cacheKey$1, {
+		version,
+		value
+	});
+	return value;
+}
+
+//#endregion
+//#region ../server/src/git-panel-data.ts
+const DEFAULT_ENTRY_PAGE_SIZE = 50;
+const MAX_ENTRY_PAGE_SIZE = 100;
+const MAX_PATCH_BYTES = 2e5;
+const MAX_SYNTHETIC_TEXT_BYTES = 2e5;
+function clampEntryLimit(limit) {
+	if (!Number.isFinite(limit)) return DEFAULT_ENTRY_PAGE_SIZE;
+	return Math.max(1, Math.min(MAX_ENTRY_PAGE_SIZE, Math.trunc(limit ?? DEFAULT_ENTRY_PAGE_SIZE)));
+}
+function parseCursor(cursor) {
+	const value = Number(cursor);
+	if (!Number.isFinite(value) || value < 0) return 0;
+	return Math.trunc(value);
+}
+function createGitFileId(path$1, previousPath) {
+	return JSON.stringify([previousPath ?? null, path$1]);
+}
+function parseGitNameStatus(stdout) {
+	const entries = [];
+	for (const line of stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split("	");
+		const normalized = (parts[0] ?? "")[0] ?? "";
+		if (!normalized) continue;
+		if ((normalized === "R" || normalized === "C") && parts.length >= 3) {
+			entries.push({
+				previousPath: parts[1] ?? null,
+				path: parts[2] ?? "",
+				changeType: normalized === "R" ? "renamed" : "copied"
+			});
+			continue;
+		}
+		if (parts.length < 2) continue;
+		entries.push({
+			previousPath: null,
+			path: parts[1] ?? "",
+			changeType: normalized === "A" ? "added" : normalized === "M" ? "modified" : normalized === "D" ? "deleted" : normalized === "T" ? "typechanged" : normalized === "U" ? "unmerged" : "unknown"
+		});
+	}
+	return entries;
+}
+function parseNumStatMap(stdout) {
+	const diffByPath = /* @__PURE__ */ new Map();
+	for (const line of stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split("	");
+		if (parts.length < 3) continue;
+		const [insertionsRaw = "0", deletionsRaw = "0", ...pathParts] = parts;
+		const rawPath = pathParts.join("	").trim();
+		const diff = {
+			files: 1,
+			insertions: insertionsRaw === "-" ? 0 : Number(insertionsRaw) || 0,
+			deletions: deletionsRaw === "-" ? 0 : Number(deletionsRaw) || 0
+		};
+		for (const path$1 of extractGitPathVariants(rawPath)) diffByPath.set(path$1, diff);
+	}
+	return diffByPath;
+}
+function resolveTrackedDiff(diffByPath, status) {
+	return diffByPath.get(status.path) ?? (status.previousPath ? diffByPath.get(status.previousPath) : void 0) ?? {
+		files: 1,
+		insertions: 0,
+		deletions: 0
+	};
+}
+function readyFileDiff(diff) {
+	return {
+		state: "ready",
+		...diff
+	};
+}
+function loadingFileDiff(files = 1) {
+	return {
+		state: "loading",
+		files
+	};
+}
+function unavailableFileDiff(files = 1) {
+	return {
+		state: "unavailable",
+		files
+	};
+}
+function buildTrackedFileSummaries(statuses, numStatOutput) {
+	const diffByPath = parseNumStatMap(numStatOutput);
+	return statuses.map((status) => ({
+		fileId: createGitFileId(status.path, status.previousPath),
+		source: "tracked",
+		path: status.path,
+		displayPath: status.previousPath ? `${status.previousPath} -> ${status.path}` : status.path,
+		previousPath: status.previousPath,
+		changeType: status.changeType,
+		diff: readyFileDiff(resolveTrackedDiff(diffByPath, status))
+	})).sort((left, right) => left.path.localeCompare(right.path));
+}
+function buildUntrackedFileSummary(path$1) {
+	return {
+		fileId: createGitFileId(path$1, null),
+		source: "untracked",
+		path: path$1,
+		displayPath: path$1,
+		previousPath: null,
+		changeType: "added",
+		diff: loadingFileDiff()
+	};
+}
+async function collectWorktreeSummary(options) {
+	const { projectDir, worktree, defaultBranch, runGit } = options;
+	const worktreePath = resolve$1(worktree.path);
+	const resolvedProjectDir = resolve$1(projectDir);
+	const isCurrent = await sameGitPath(worktreePath, resolvedProjectDir);
+	const pathAvailable = await pathExists(worktreePath);
+	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;
+	return {
+		path: worktreePath,
+		relativePath: relativePath(resolvedProjectDir, worktreePath),
+		pathAvailable,
+		branchName: parseBranchName(worktree.branchRef, worktree.detached),
+		detached: worktree.detached,
+		isCurrent,
+		ahead,
+		behind,
+		diff
+	};
+}
+function normalizePatchState(patch) {
+	const trimmed = patch.trimEnd();
+	if (!trimmed) return {
+		state: "unavailable",
+		patch: null
+	};
+	if (/^GIT binary patch$/m.test(trimmed) || /^Binary files .* differ$/m.test(trimmed)) return {
+		state: "binary",
+		patch: null
+	};
+	if (Buffer.byteLength(trimmed, "utf8") > MAX_PATCH_BYTES) return {
+		state: "too-large",
+		patch: null
+	};
+	return {
+		state: "available",
+		patch: trimmed
+	};
+}
+function splitPatchLines(text) {
+	if (!text) return [];
+	const lines = text.replace(/\r\n/g, "\n").split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines;
+}
+async function buildTrackedPatchFile(options) {
+	const { worktreePath, file, runGit, selector } = options;
+	const patchResult = await runGit(worktreePath, selector.type === "commit" ? [
+		"show",
+		"--patch",
+		"--find-renames",
+		"--format=",
+		selector.hash,
+		"--",
+		file.path
+	] : [
+		"diff",
+		"--patch",
+		"--find-renames",
+		"HEAD",
+		"--",
+		file.path
+	]);
+	const normalized = normalizePatchState(patchResult.stdout);
+	return {
+		...file,
+		patch: normalized.patch,
+		state: patchResult.ok ? normalized.state : "unavailable"
+	};
+}
+async function buildUntrackedPatchFile(worktreePath, file) {
+	try {
+		const buffer = await readFile$1(resolve$1(worktreePath, file.path));
+		if (buffer.byteLength > MAX_SYNTHETIC_TEXT_BYTES) return {
+			...file,
+			diff: unavailableFileDiff(),
+			patch: null,
+			state: "too-large"
+		};
+		if (buffer.includes(0)) return {
+			...file,
+			diff: unavailableFileDiff(),
+			patch: null,
+			state: "binary"
+		};
+		const lines = splitPatchLines(buffer.toString("utf8"));
+		const hunkHeader = lines.length > 0 ? `@@ -0,0 +1,${lines.length} @@` : null;
+		const body = lines.map((line) => `+${line}`);
+		const patch = [
+			`diff --git a/${file.path} b/${file.path}`,
+			"new file mode 100644",
+			"--- /dev/null",
+			`+++ b/${file.path}`,
+			...hunkHeader ? [hunkHeader] : [],
+			...body
+		].join("\n");
+		return {
+			...file,
+			diff: readyFileDiff({
+				files: 1,
+				insertions: lines.length,
+				deletions: 0
+			}),
+			patch: patch.trimEnd(),
+			state: "available"
+		};
+	} catch {
+		return {
+			...file,
+			diff: unavailableFileDiff(),
+			patch: null,
+			state: "unavailable"
+		};
+	}
+}
+async function buildCommitShell(options) {
+	const { worktreePath, hash, runGit } = options;
+	const [entry, nameStatusResult, numStatResult] = await Promise.all([
+		readGitCommitEntryByHash({
+			worktreePath,
+			hash,
+			runGit
+		}),
+		runGit(worktreePath, [
+			"show",
+			"--name-status",
+			"--find-renames",
+			"--format=",
+			hash
+		]),
+		runGit(worktreePath, [
+			"show",
+			"--numstat",
+			"--format=",
+			hash
+		])
+	]);
+	if (!entry) return {
+		entry: null,
+		files: []
+	};
+	return {
+		entry,
+		files: buildTrackedFileSummaries(nameStatusResult.ok ? parseGitNameStatus(nameStatusResult.stdout) : [], numStatResult.stdout)
+	};
+}
+async function buildUncommittedShell(options) {
+	const { worktreePath, runGit, readPathTimestampMs } = options;
+	const [entry, trackedStatusResult, trackedNumStatResult, untrackedResult] = await Promise.all([
+		collectUncommittedEntrySummary({
+			worktreePath,
+			runGit,
+			readPathTimestampMs
+		}),
+		runGit(worktreePath, [
+			"diff",
+			"--name-status",
+			"--find-renames",
+			"HEAD"
+		]),
+		runGit(worktreePath, [
+			"diff",
+			"--numstat",
+			"HEAD"
+		]),
+		runGit(worktreePath, [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		])
+	]);
+	const trackedFiles = buildTrackedFileSummaries(trackedStatusResult.ok ? parseGitNameStatus(trackedStatusResult.stdout) : [], trackedNumStatResult.stdout);
+	const untrackedFiles = untrackedResult.stdout.split("\n").map((item) => item.trim()).filter((item) => item.length > 0).map((path$1) => buildUntrackedFileSummary(path$1));
+	return {
+		entry,
+		files: [...trackedFiles, ...untrackedFiles].sort((left, right) => left.path.localeCompare(right.path))
+	};
+}
+async function loadGitEntryShell(options) {
+	const runGit = options.runGit ?? defaultRunGit;
+	const readPathTimestampMs = options.readPathTimestampMs ?? defaultReadPathTimestampMs;
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	if (options.selector.type === "uncommitted") return buildUncommittedShell({
+		worktreePath: resolvedProjectDir,
+		runGit,
+		readPathTimestampMs
+	});
+	return buildCommitShell({
+		worktreePath: resolvedProjectDir,
+		hash: options.selector.hash,
+		runGit
+	});
+}
+async function buildGitWorktreeOverview(options) {
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	return getCachedGitPanelValue("overview", resolvedProjectDir, "overview", async () => {
+		const runGit = options.runGit ?? defaultRunGit;
+		const defaultBranch = await resolveDefaultBranch(resolvedProjectDir, runGit);
+		const worktrees = await listGitWorktrees(resolvedProjectDir, runGit);
+		const summaries = await Promise.all(worktrees.map((worktree) => collectWorktreeSummary({
+			projectDir: resolvedProjectDir,
+			worktree,
+			defaultBranch,
+			runGit
+		})));
+		summaries.sort((left, right) => {
+			if (left.isCurrent !== right.isCurrent) return left.isCurrent ? -1 : 1;
+			return left.branchName.localeCompare(right.branchName);
+		});
+		return {
+			defaultBranch,
+			currentWorktree: summaries.find((worktree) => worktree.isCurrent) ?? null,
+			otherWorktrees: summaries.filter((worktree) => !worktree.isCurrent)
+		};
+	});
+}
+async function listCurrentWorktreeGitEntries(options) {
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	const limit = clampEntryLimit(options.limit);
+	const offset = parseCursor(options.cursor);
+	return getCachedGitPanelValue("entries", resolvedProjectDir, `entries:${offset}:${limit}`, async () => {
+		const runGit = options.runGit ?? defaultRunGit;
+		const readPathTimestampMs = options.readPathTimestampMs ?? defaultReadPathTimestampMs;
+		const defaultBranch = await resolveDefaultBranch(resolvedProjectDir, runGit);
+		const uncommitted = await collectUncommittedEntrySummary({
+			worktreePath: resolvedProjectDir,
+			runGit,
+			readPathTimestampMs
+		});
+		const includeUncommitted = offset === 0 && uncommitted.diff.files > 0;
+		const commitLimit = includeUncommitted ? Math.max(0, limit - 1) : limit;
+		const commitsPage = commitLimit > 0 ? await listGitCommitEntriesPage({
+			worktreePath: resolvedProjectDir,
+			defaultBranch,
+			offset,
+			limit: commitLimit,
+			runGit
+		}) : {
+			items: [],
+			nextCursor: null
+		};
+		return {
+			items: includeUncommitted ? [uncommitted, ...commitsPage.items] : commitsPage.items,
+			nextCursor: commitsPage.nextCursor
+		};
+	});
+}
+async function getCurrentWorktreeGitEntryShell(options) {
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	return getCachedGitPanelValue("shell", resolvedProjectDir, options.selector.type === "commit" ? `commit:${options.selector.hash}` : "uncommitted", () => loadGitEntryShell({
+		...options,
+		projectDir: resolvedProjectDir
+	}));
+}
+async function getCurrentWorktreeGitEntryPatch(options) {
+	const resolvedProjectDir = resolve$1(options.projectDir);
+	return getCachedGitPanelValue("patch", resolvedProjectDir, `${options.selector.type === "commit" ? `commit:${options.selector.hash}` : "uncommitted"}:${options.fileId}`, async () => {
+		const runGit = options.runGit ?? defaultRunGit;
+		const shell = await getCurrentWorktreeGitEntryShell({
+			...options,
+			projectDir: resolvedProjectDir
+		});
+		const file = shell.files.find((candidate) => candidate.fileId === options.fileId) ?? null;
+		if (!shell.entry || !file) return {
+			entry: shell.entry,
+			file: null
+		};
+		const patch = file.source === "untracked" ? await buildUntrackedPatchFile(resolvedProjectDir, file) : await buildTrackedPatchFile({
+			worktreePath: resolvedProjectDir,
+			file,
+			runGit,
+			selector: options.selector
+		});
+		return {
+			entry: shell.entry,
+			file: patch
+		};
+	});
+}
+async function getCurrentWorktreeGitEntryDetail(options) {
+	const shell = await getCurrentWorktreeGitEntryShell(options);
+	if (!shell.entry) return {
+		entry: null,
+		files: []
+	};
+	const patches = await Promise.all(shell.files.map(async (file) => {
+		return (await getCurrentWorktreeGitEntryPatch({
+			...options,
+			fileId: file.fileId
+		})).file;
+	}));
+	return {
+		entry: shell.entry,
+		files: patches.filter((file) => file !== null)
+	};
+}
+
 //#endregion
 //#region ../server/src/reactive-kv.ts
 /**
@@ -24636,6 +25270,10 @@ const OPSX_CORE_PROFILE_WORKFLOWS = [
 	"apply",
 	"archive"
 ];
+const gitEntrySelectorSchema = discriminatedUnionType("type", [objectType({ type: literalType("uncommitted") }), objectType({
+	type: literalType("commit"),
+	hash: stringType().min(1)
+})]);
 function requireChangeId(changeId) {
 	if (!changeId) throw new Error("change is required");
 	return changeId;
@@ -24882,6 +25520,9 @@ const changeRouter = router({
 		if (!await ctx.adapter.toggleTask(input.changeId, input.taskIndex, input.completed)) throw new Error(`Failed to toggle task ${input.taskIndex} in change ${input.changeId}`);
 		return { success: true };
 	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listChangesWithMeta());
+	}),
 	subscribeFiles: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
 		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChangeFiles(id))(input.id);
 	})
@@ -25546,8 +26187,8 @@ const dashboardRouter = router({
 	}),
 	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);
+		await touchDashboardGitRefreshStamp(ctx.projectDir, reason);
 		return { success: true };
 	}),
 	removeDetachedWorktree: publicProcedure.input(objectType({ path: stringType().min(1) })).mutation(async ({ ctx, input }) => {
@@ -25556,8 +26197,8 @@ const dashboardRouter = router({
 			projectDir: ctx.projectDir,
 			targetPath: input.path
 		});
-		await touchDashboardGitRefreshStamp(ctx.projectDir, "remove-detached-worktree");
 		await ctx.dashboardOverviewService.refresh("remove-detached-worktree");
+		await touchDashboardGitRefreshStamp(ctx.projectDir, "remove-detached-worktree");
 		return { success: true };
 	}),
 	gitTaskStatus: publicProcedure.query(async ({ ctx }) => {
@@ -25577,11 +26218,63 @@ const dashboardRouter = router({
 		});
 	})
 });
+const gitRouter = router({
+	overview: publicProcedure.query(async ({ ctx }) => {
+		return buildGitWorktreeOverview({ projectDir: ctx.projectDir });
+	}),
+	listEntries: publicProcedure.input(objectType({
+		cursor: stringType().optional(),
+		limit: numberType().int().min(1).max(100).optional()
+	}).optional()).query(async ({ ctx, input }) => {
+		return listCurrentWorktreeGitEntries({
+			projectDir: ctx.projectDir,
+			cursor: input?.cursor,
+			limit: input?.limit
+		});
+	}),
+	getEntryDetail: publicProcedure.input(objectType({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
+		return getCurrentWorktreeGitEntryDetail({
+			projectDir: ctx.projectDir,
+			selector: input.selector
+		});
+	}),
+	getEntryShell: publicProcedure.input(objectType({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
+		return getCurrentWorktreeGitEntryShell({
+			projectDir: ctx.projectDir,
+			selector: input.selector
+		});
+	}),
+	getEntryPatch: publicProcedure.input(objectType({
+		selector: gitEntrySelectorSchema,
+		fileId: stringType().min(1)
+	})).query(async ({ ctx, input }) => {
+		return getCurrentWorktreeGitEntryPatch({
+			projectDir: ctx.projectDir,
+			selector: input.selector,
+			fileId: input.fileId
+		});
+	}),
+	switchWorktree: publicProcedure.input(objectType({ path: stringType().min(1) })).mutation(async ({ ctx, input }) => {
+		if (!ctx.gitWorktreeHandoff) throw new Error("Worktree handoff is unavailable in this runtime.");
+		const overview = await buildGitWorktreeOverview({ projectDir: ctx.projectDir });
+		const resolvedInputPath = resolve$1(input.path);
+		let target = null;
+		if (overview.currentWorktree && await sameGitPath(overview.currentWorktree.path, resolvedInputPath)) target = overview.currentWorktree;
+		else for (const worktree of overview.otherWorktrees) if (await sameGitPath(worktree.path, resolvedInputPath)) {
+			target = worktree;
+			break;
+		}
+		if (!target) throw new Error("Worktree not found.");
+		if (!target.pathAvailable) throw new Error("Worktree path is no longer available. Remove the stale worktree entry first.");
+		return ctx.gitWorktreeHandoff.ensureWorktreeServer({ targetPath: target.path });
+	})
+});
 /**
 * Main app router
 */
 const appRouter = router({
 	dashboard: dashboardRouter,
+	git: gitRouter,
 	spec: specRouter,
 	change: changeRouter,
 	archive: archiveRouter,
@@ -25882,6 +26575,7 @@ function createServer$2(config) {
 				kernel,
 				searchService,
 				dashboardOverviewService,
+				gitWorktreeHandoff: config.gitWorktreeHandoff,
 				watcher,
 				projectDir: config.projectDir
 			})
@@ -25894,6 +26588,7 @@ function createServer$2(config) {
 		kernel,
 		searchService,
 		dashboardOverviewService,
+		gitWorktreeHandoff: config.gitWorktreeHandoff,
 		watcher,
 		projectDir: config.projectDir
 	});
@@ -26010,6 +26705,214 @@ function getWebAssetsDirCandidates(runtimeDir) {
 	return [join$1(runtimeDir, "..", "..", "web", "dist"), prodPath];
 }
 
+//#endregion
+//#region src/worktree-instance-manager.ts
+const DEFAULT_CHILD_TIMEOUT_MS = 15e3;
+const DEFAULT_PORT_START = 3100;
+const DEFAULT_PORT_ATTEMPTS = 200;
+function resolveLocalCliWorkspace(runtimeDir) {
+	const repoRoot = resolve$1(runtimeDir, "..", "..", "..");
+	const rootPackageJson = join$1(repoRoot, "package.json");
+	const cliPackageJson = join$1(repoRoot, "packages", "cli", "package.json");
+	const cliSourceEntry = join$1(repoRoot, "packages", "cli", "src", "cli.ts");
+	if (!existsSync(rootPackageJson) || !existsSync(cliPackageJson) || !existsSync(cliSourceEntry)) return null;
+	return {
+		repoRoot,
+		cliPackageDir: join$1(repoRoot, "packages", "cli")
+	};
+}
+function resolvePnpmCommand() {
+	return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+}
+function createWorktreeServerCommand(options) {
+	const workspace = resolveLocalCliWorkspace(options.runtimeDir);
+	if (workspace) return {
+		command: resolvePnpmCommand(),
+		args: [
+			"--filter",
+			"openspecui",
+			"run",
+			"dev",
+			"--dir",
+			options.projectDir,
+			"--port",
+			String(options.port),
+			"--no-open"
+		],
+		cwd: workspace.repoRoot,
+		env: { ...process.env }
+	};
+	return {
+		command: process.execPath,
+		args: [
+			join$1(options.runtimeDir, "cli.mjs"),
+			"start",
+			options.projectDir,
+			"--port",
+			String(options.port),
+			"--no-open"
+		],
+		cwd: options.projectDir,
+		env: { ...process.env }
+	};
+}
+async function waitForServerReady(options) {
+	let exitMessage = null;
+	let startupError = null;
+	options.child.once("error", (error) => {
+		startupError = error;
+	});
+	options.child.once("exit", (code, signal) => {
+		exitMessage = signal ? `signal ${signal}` : `exit ${code ?? "unknown"}`;
+	});
+	const deadline = Date.now() + options.timeoutMs;
+	while (Date.now() < deadline) {
+		if (startupError) throw startupError;
+		if (exitMessage) throw new Error(`Worktree server exited before becoming ready (${exitMessage})`);
+		try {
+			const response = await fetch(`${options.serverUrl}/api/health`, {
+				headers: { accept: "application/json" },
+				cache: "no-store"
+			});
+			if (response.ok) {
+				if ((await response.json()).projectDir === options.projectDir) return;
+			}
+		} catch {}
+		await delay(250);
+	}
+	throw new Error(`Timed out waiting for worktree server at ${options.serverUrl}`);
+}
+async function isHealthyInstance(instance) {
+	try {
+		const response = await fetch(`${instance.serverUrl}/api/health`, {
+			headers: { accept: "application/json" },
+			cache: "no-store"
+		});
+		if (!response.ok) return false;
+		return (await response.json()).projectDir === instance.projectDir;
+	} catch {
+		return false;
+	}
+}
+function killChildProcess(child, signal) {
+	if (process.platform !== "win32" && child.pid) try {
+		process.kill(-child.pid, signal);
+		return;
+	} catch {}
+	child.kill(signal);
+}
+function waitForChildExit(child, timeoutMs) {
+	return new Promise((resolvePromise) => {
+		const timer = setTimeout(() => {
+			cleanup();
+			resolvePromise(false);
+		}, timeoutMs);
+		const onExit = () => {
+			cleanup();
+			resolvePromise(true);
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			child.off("exit", onExit);
+		};
+		child.once("exit", onExit);
+	});
+}
+async function stopChildProcess(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	killChildProcess(child, "SIGTERM");
+	if (await waitForChildExit(child, 5e3)) return;
+	killChildProcess(child, "SIGKILL");
+	await waitForChildExit(child, 1e3);
+}
+function delay(ms) {
+	return new Promise((resolvePromise) => {
+		setTimeout(resolvePromise, ms);
+	});
+}
+function createWorktreeInstanceManager(options) {
+	const currentProjectDir = resolve$1(options.currentProjectDir);
+	const instances = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const ensureWorktreeServer = async (input) => {
+		const targetPath = resolve$1(input.targetPath);
+		if (targetPath === currentProjectDir) return {
+			projectDir: currentProjectDir,
+			serverUrl: options.currentServerUrl
+		};
+		const existing = instances.get(targetPath);
+		if (existing && await isHealthyInstance(existing)) {
+			existing.lastUsedAt = Date.now();
+			return {
+				projectDir: existing.projectDir,
+				serverUrl: existing.serverUrl
+			};
+		}
+		if (existing) {
+			instances.delete(targetPath);
+			await stopChildProcess(existing.child);
+		}
+		const pendingInstance = pending.get(targetPath);
+		if (pendingInstance) return pendingInstance;
+		const promise = (async () => {
+			const port = await findAvailablePort(options.preferredPortStart ?? DEFAULT_PORT_START, DEFAULT_PORT_ATTEMPTS);
+			const command = createWorktreeServerCommand({
+				runtimeDir: options.runtimeDir,
+				projectDir: targetPath,
+				port
+			});
+			const child = spawn$1(command.command, command.args, {
+				cwd: command.cwd,
+				env: command.env,
+				stdio: "inherit",
+				detached: process.platform !== "win32"
+			});
+			const serverUrl = `http://localhost:${port}`;
+			try {
+				await waitForServerReady({
+					serverUrl,
+					projectDir: targetPath,
+					child,
+					timeoutMs: options.readinessTimeoutMs ?? DEFAULT_CHILD_TIMEOUT_MS
+				});
+			} catch (error) {
+				await stopChildProcess(child);
+				throw error;
+			}
+			const instance = {
+				projectDir: targetPath,
+				serverUrl,
+				child,
+				lastUsedAt: Date.now()
+			};
+			instances.set(targetPath, instance);
+			child.once("exit", () => {
+				if (instances.get(targetPath)?.child === child) instances.delete(targetPath);
+			});
+			return {
+				projectDir: targetPath,
+				serverUrl
+			};
+		})();
+		pending.set(targetPath, promise);
+		try {
+			return await promise;
+		} finally {
+			pending.delete(targetPath);
+		}
+	};
+	const close = async () => {
+		await Promise.all([...instances.values()].map(async (instance) => {
+			instances.delete(instance.projectDir);
+			await stopChildProcess(instance.child);
+		}));
+	};
+	return {
+		ensureWorktreeServer,
+		close
+	};
+}
+
 //#endregion
 //#region src/index.ts
 const __dirname = dirname$1(fileURLToPath(import.meta.url));
@@ -26055,12 +26958,29 @@ function setupStaticFiles(app) {
 }
 async function startServer$1(options = {}) {
 	const { projectDir = process.cwd(), port = 3100, enableWatcher = true, corsOrigins } = options;
-	return await startServer({
+	let worktreeManager = null;
+	const server = await startServer({
 		projectDir,
 		port,
 		enableWatcher,
-		corsOrigins
+		corsOrigins,
+		gitWorktreeHandoff: { ensureWorktreeServer: async ({ targetPath }) => {
+			if (!worktreeManager) throw new Error("Worktree handoff is not ready yet.");
+			return worktreeManager.ensureWorktreeServer({ targetPath });
+		} }
 	}, setupStaticFiles);
+	worktreeManager = createWorktreeInstanceManager({
+		currentProjectDir: projectDir,
+		currentServerUrl: server.url,
+		runtimeDir: __dirname
+	});
+	return {
+		...server,
+		close: async () => {
+			await worktreeManager?.close();
+			await server.close();
+		}
+	};
 }
 
 //#endregion