@youtyan/code-viewer 0.12.0 → 0.13.1

package/dist/code-viewer.js

@@ -213,6 +213,14 @@ function buildRoute(route) {
       return "/file?path=" + encodeURIComponent(route.path) + "&ref=" + encodeURIComponent(route.ref || "worktree") + "&from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
     case "diff":
       return "/todif?from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree") + (route.path ? `&path=${encodeURIComponent(route.path)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+    case "worktree": {
+      const params = new URLSearchParams();
+      if (route.wt) params.set("wt", route.wt);
+      if (route.file) params.set("file", route.file);
+      if (route.file && route.origin) params.set("origin", route.origin);
+      const qs = params.toString();
+      return `/worktree${qs ? `?${qs}` : ""}`;
+    }
     case "help": {
       const params = new URLSearchParams();
       if (route.lang && route.lang !== "en") params.set("lang", route.lang);
@@ -267,6 +275,7 @@ var init_routes = __esm({
       "/history",
       "/journal",
       "/database",
+      "/worktree",
       "/doctor"
     ];
     APP_ENTRY_PATHS = ["/", "/index.html"];
@@ -1197,6 +1206,127 @@ var init_command_resolver = __esm({
   }
 });
 
+// web-src/core/worktree.ts
+function worktreeNameError(name) {
+  if (!name) return "empty";
+  if (name.length > WORKTREE_NAME_MAX_LENGTH) return "too-long";
+  for (const ch of name) {
+    const code = ch.charCodeAt(0);
+    if (code < 32 || code === 127) return "control";
+  }
+  if (name.includes("/") || name.includes("\\")) return "separator";
+  if (name === "." || name === "..") return "relative";
+  if (name.startsWith(".")) return "leading-dot";
+  return null;
+}
+function worktreeBranchError(branch) {
+  if (!branch) return "empty";
+  if (branch.length > WORKTREE_NAME_MAX_LENGTH) return "too-long";
+  for (const ch of branch) {
+    const code = ch.charCodeAt(0);
+    if (code < 32 || code === 127) return "control";
+  }
+  if (branch.startsWith("-") || branch.includes("..")) return "relative";
+  return null;
+}
+function emptyRef(path) {
+  return {
+    path,
+    head: "",
+    branch: "",
+    detached: false,
+    bare: false,
+    locked: false,
+    lockedReason: "",
+    prunable: false,
+    prunableReason: ""
+  };
+}
+function parseWorktreeList(stdout) {
+  const refs = [];
+  let current = null;
+  const nulDelimited = stdout.includes("\0");
+  const records = nulDelimited ? stdout.split("\0") : stdout.split("\n");
+  for (const rawRecord of records) {
+    const line = nulDelimited ? rawRecord : rawRecord.replace(/\r$/, "");
+    if (!line) continue;
+    if (line.startsWith("worktree ")) {
+      current = emptyRef(line.slice("worktree ".length));
+      refs.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
+    } else if (line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length);
+      current.branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+    } else if (line === "detached") {
+      current.detached = true;
+    } else if (line === "bare") {
+      current.bare = true;
+    } else if (line === "locked" || line.startsWith("locked ")) {
+      current.locked = true;
+      current.lockedReason = line.slice("locked".length).trim();
+    } else if (line === "prunable" || line.startsWith("prunable ")) {
+      current.prunable = true;
+      current.prunableReason = line.slice("prunable".length).trim();
+    }
+  }
+  return refs;
+}
+function findWorktree(worktrees, path) {
+  return worktrees.find((entry) => entry.path === path) || null;
+}
+function parseAheadBehind(stdout) {
+  const parts = stdout.trim().split(/\s+/);
+  if (parts.length < 2) return null;
+  const behind = Number(parts[0]);
+  const ahead = Number(parts[1]);
+  if (!Number.isInteger(behind) || !Number.isInteger(ahead)) return null;
+  if (behind < 0 || ahead < 0) return null;
+  return { behind, ahead };
+}
+function parseMergeTreeConflicts(stdout) {
+  const lines = stdout.split("\n");
+  const conflicts = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].replace(/\r$/, "");
+    if (!line) break;
+    conflicts.push(line);
+  }
+  return conflicts;
+}
+function findWorktreeOverlaps(items) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const counted = /* @__PURE__ */ new Set();
+    for (const file of item.files) {
+      for (const path of [file.path, file.oldPath]) {
+        if (!path || counted.has(path)) continue;
+        counted.add(path);
+        const owners = byPath.get(path);
+        if (owners) owners.push(item.id);
+        else byPath.set(path, [item.id]);
+      }
+    }
+  }
+  const overlaps = [];
+  for (const [path, worktreeIds] of byPath) {
+    if (worktreeIds.length >= 2) overlaps.push({ path, worktreeIds });
+  }
+  overlaps.sort(
+    (a, b) => b.worktreeIds.length - a.worktreeIds.length || (a.path < b.path ? -1 : 1)
+  );
+  return overlaps;
+}
+var WORKTREE_NAME_MAX_LENGTH;
+var init_worktree = __esm({
+  "web-src/core/worktree.ts"() {
+    WORKTREE_NAME_MAX_LENGTH = 100;
+  }
+});
+
 // web-src/server/cache.ts
 import { lstatSync } from "node:fs";
 import { join as join3 } from "node:path";
@@ -1389,7 +1519,8 @@ function runBytesAsync(args, cwd2, options = {}) {
   return new Promise((resolve4) => {
     const proc = spawn(args[0], args.slice(1), {
       cwd: cwd2,
-      stdio: [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+      stdio: [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+      signal: options.signal
     });
     if (options.stdin !== void 0) {
       proc.stdin?.on("error", () => {
@@ -1686,8 +1817,8 @@ function run(args, cwd2) {
 }
 function runGitAsync(args, cwd2, options = {}) {
   return runAsync(resolveGitArgs(args), cwd2, {
-    timeout: GIT_COMMAND_TIMEOUT_MS,
-    ...options
+    ...options,
+    timeout: options.timeout ?? GIT_COMMAND_TIMEOUT_MS
   });
 }
 function resolveGitArgs(args) {
@@ -1714,17 +1845,140 @@ async function runGitRefLookupAsync(args, cwd2) {
 function repoRoot(cwd2) {
   return runGitRefLookup(["git", "rev-parse", "--show-toplevel"], cwd2);
 }
+async function worktreeListResultAsync(cwd2, options = {}) {
+  const res = await runGitAsync(
+    ["git", "worktree", "list", "--porcelain", "-z"],
+    cwd2,
+    options
+  );
+  if (res.code !== 0) {
+    return {
+      worktrees: [],
+      ...gitFailureResult(res, "git worktree list failed")
+    };
+  }
+  return { worktrees: parseWorktreeList(res.stdout) };
+}
 async function worktreePathsAsync(cwd2) {
+  const res = await worktreeListResultAsync(cwd2);
+  return res.worktrees.map((entry) => entry.path);
+}
+async function localBranchExistsResultAsync(cwd2, branch) {
+  const result = await runGitAsync(
+    ["git", "rev-parse", "--verify", "--quiet", `refs/heads/${branch}`],
+    cwd2
+  );
+  if (result.code === 0) return { exists: true };
+  if (result.code === 1) return { exists: false };
+  return {
+    exists: false,
+    ...gitFailureResult(result, "git branch lookup failed")
+  };
+}
+async function defaultBranchResultAsync(cwd2) {
+  const headResult = await runGitAsync(
+    ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+    cwd2
+  );
+  if (headResult.code !== 0 && headResult.code !== 1) {
+    return {
+      branch: "",
+      ...gitFailureResult(headResult, "git default branch lookup failed")
+    };
+  }
+  const head = headResult.code === 0 ? headResult.stdout.trimEnd() : "";
+  const fromRemote = head?.startsWith("origin/") ? head.slice("origin/".length) : head;
+  if (fromRemote) {
+    const exists = await localBranchExistsResultAsync(cwd2, fromRemote);
+    if (exists.error) {
+      return { branch: "", error: exists.error, status: exists.status };
+    }
+    if (exists.exists) return { branch: fromRemote };
+  }
+  for (const name of ["main", "master"]) {
+    const exists = await localBranchExistsResultAsync(cwd2, name);
+    if (exists.error) {
+      return { branch: "", error: exists.error, status: exists.status };
+    }
+    if (exists.exists) return { branch: name };
+  }
+  return { branch: "" };
+}
+async function worktreeDivergenceResultAsync(cwd2, base, ref) {
   const res = await runGitAsync(
-    ["git", "worktree", "list", "--porcelain"],
+    [
+      "git",
+      "rev-list",
+      "--left-right",
+      "--count",
+      `refs/heads/${base}...refs/heads/${ref}`
+    ],
     cwd2
   );
-  if (res.code !== 0) return [];
-  const paths = [];
-  for (const line of res.stdout.split("\n")) {
-    if (line.startsWith("worktree ")) paths.push(line.slice(9).trimEnd());
+  if (res.code !== 0) {
+    return {
+      behind: 0,
+      ahead: 0,
+      ...gitFailureResult(res, "git rev-list failed")
+    };
+  }
+  const parsed = parseAheadBehind(res.stdout);
+  if (!parsed) {
+    return {
+      behind: 0,
+      ahead: 0,
+      error: `unexpected rev-list output: ${res.stdout.trim()}`
+    };
+  }
+  return parsed;
+}
+async function mergePreviewResultAsync(cwd2, base, ref) {
+  const res = await runGitAsync(
+    [
+      "git",
+      "merge-tree",
+      "--write-tree",
+      "--name-only",
+      `refs/heads/${base}`,
+      `refs/heads/${ref}`
+    ],
+    cwd2
+  );
+  if (res.code === 0) return { state: "clean", conflicts: [] };
+  if (res.code === 1) {
+    return {
+      state: "conflict",
+      conflicts: parseMergeTreeConflicts(res.stdout)
+    };
   }
-  return paths;
+  return {
+    state: "unknown",
+    conflicts: [],
+    error: gitFailureMessage(res, "git merge-tree failed")
+  };
+}
+async function worktreeAddResultAsync(cwd2, options) {
+  const args = options.createBranch ? ["git", "worktree", "add", "-b", options.branch, options.path] : ["git", "worktree", "add", options.path, options.branch];
+  const res = await runGitAsync(args, cwd2);
+  if (res.code !== 0) return gitFailureResult(res, "git worktree add failed");
+  return {};
+}
+async function worktreeRemoveResultAsync(cwd2, options) {
+  const args = ["git", "worktree", "remove"];
+  if (options.force) args.push("--force");
+  args.push("--", options.path);
+  const res = await runGitAsync(args, cwd2);
+  if (res.code !== 0) {
+    return gitFailureResult(res, "git worktree remove failed");
+  }
+  return {};
+}
+async function worktreePruneResultAsync(cwd2) {
+  const res = await runGitAsync(["git", "worktree", "prune"], cwd2);
+  if (res.code !== 0) {
+    return gitFailureResult(res, "git worktree prune failed");
+  }
+  return {};
 }
 function repoRootResult(cwd2) {
   const res = run(["git", "rev-parse", "--show-toplevel"], cwd2);
@@ -1771,28 +2025,9 @@ async function statusPorcelainForPathAsync(path, cwd2) {
     error: gitFailureMessage(res, "git status failed")
   };
 }
-async function repoStatusMapAsync(cwd2, now = Date.now()) {
-  const cached = repoStatusMapCache.get(cwd2);
-  if (cacheFresh(cached, now)) return cached.map;
+function parseStatusPorcelainZ(stdout) {
   const map = /* @__PURE__ */ new Map();
-  const res = await runGitAsync(
-    [
-      "git",
-      "-c",
-      "core.quotepath=false",
-      "status",
-      "--porcelain=v1",
-      "-z",
-      // "normal" (not "all") keeps a brand-new untracked directory collapsed
-      // to a single `?? dir/` record instead of walking into it: the tree
-      // explorer badges its descendants by ancestor lookup anyway, and "all"
-      // would make git enumerate every file under it on each poll.
-      "--untracked-files=normal"
-    ],
-    cwd2
-  );
-  if (res.code !== 0) return map;
-  const records = res.stdout.split("\0").filter(Boolean);
+  const records = stdout.split("\0").filter(Boolean);
   for (let i = 0; i < records.length; i++) {
     const record = records[i];
     const xy = record.slice(0, 2);
@@ -1810,6 +2045,14 @@ async function repoStatusMapAsync(cwd2, now = Date.now()) {
     const code = xy[0] !== " " ? xy[0] : xy[1];
     if (code && code !== " ") map.set(path, code);
   }
+  return map;
+}
+async function repoStatusMapAsync(cwd2, now = Date.now()) {
+  const cached = repoStatusMapCache.get(cwd2);
+  if (cacheFresh(cached, now)) return cached.map;
+  const res = await runGitAsync(STATUS_PORCELAIN_ARGS, cwd2);
+  if (res.code !== 0) return /* @__PURE__ */ new Map();
+  const map = parseStatusPorcelainZ(res.stdout);
   setTimedCacheEntry(repoStatusMapCache, cwd2, { map }, now);
   return map;
 }
@@ -2372,8 +2615,8 @@ function isGitInternalPath(path) {
 function syntheticUncommittedBlameFromWorktree(cwd2, path) {
   const filePath = join4(cwd2, path);
   try {
-    const stat3 = statSync3(filePath);
-    if (!stat3.isFile()) return { lines: [], commits: {}, error: "not a file" };
+    const stat4 = statSync3(filePath);
+    if (!stat4.isFile()) return { lines: [], commits: {}, error: "not a file" };
     const text2 = readFileSync(filePath, "utf8");
     const normalized = text2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     const lineCount = normalized.length ? normalized.endsWith("\n") ? normalized.length - 1 === 0 ? 1 : normalized.split("\n").length - 1 : normalized.split("\n").length : 1;
@@ -2493,11 +2736,18 @@ async function blameAsync(cwd2, options) {
   return { lines, commits };
 }
 async function untrackedAsync(cwd2, path = "") {
-  const args = ["git", "ls-files", "--others", "--exclude-standard"];
+  const args = ["git", "ls-files", "-z", "--others", "--exclude-standard"];
   if (path) args.push("--", `${path}/`);
   const res = await runGitAsync(args, cwd2);
-  if (res.code !== 0) return [];
-  return res.stdout.split("\n").filter(Boolean).filter((entry) => !isToolInternalPath(entry));
+  if (res.code !== 0) {
+    return {
+      paths: [],
+      ...gitFailureResult(res, "git untracked file lookup failed")
+    };
+  }
+  return {
+    paths: res.stdout.split("\0").filter(Boolean).filter((entry) => !isToolInternalPath(entry))
+  };
 }
 function normalizeTreePath(path) {
   return path.replace(/^\/+|\/+$/g, "");
@@ -2549,8 +2799,8 @@ function resolveWorktreeSymlinkTarget(cwd2, full) {
   let symlink_target_type = "missing";
   if (realpathWithinRepo(cwd2, full, false) !== null) {
     try {
-      const stat3 = statSync3(full);
-      symlink_target_type = stat3.isDirectory() ? "tree" : stat3.isFile() ? "blob" : "missing";
+      const stat4 = statSync3(full);
+      symlink_target_type = stat4.isDirectory() ? "tree" : stat4.isFile() ? "blob" : "missing";
     } catch {
       symlink_target_type = "missing";
     }
@@ -2809,10 +3059,15 @@ async function scanFileBinaryAndNewlinesAsync(full) {
   return { binary: false, newlines };
 }
 async function untrackedMetaAsync(cwd2) {
-  const paths = await untrackedAsync(cwd2);
+  const listed = await untrackedAsync(cwd2);
+  if (listed.error) {
+    return { files: [], error: listed.error, status: listed.status };
+  }
+  const paths = listed.paths;
   const previous = untrackedScanCache.get(cwd2);
   const next = /* @__PURE__ */ new Map();
   const results = new Array(paths.length).fill(null);
+  const errors = new Array(paths.length).fill(null);
   let cursor = 0;
   const worker = async () => {
     while (cursor < paths.length) {
@@ -2822,7 +3077,8 @@ async function untrackedMetaAsync(cwd2) {
       let stats;
       try {
         stats = await stat(full);
-      } catch {
+      } catch (error) {
+        errors[index] = `failed to stat untracked file ${path}: ${formatErrorDetail(error)}`;
         continue;
       }
       if (!stats.isFile()) continue;
@@ -2834,7 +3090,8 @@ async function untrackedMetaAsync(cwd2) {
       } else {
         try {
           scan = await scanFileBinaryAndNewlinesAsync(full);
-        } catch {
+        } catch (error) {
+          errors[index] = `failed to read untracked file ${path}: ${formatErrorDetail(error)}`;
           continue;
         }
       }
@@ -2851,7 +3108,10 @@ async function untrackedMetaAsync(cwd2) {
     )
   );
   untrackedScanCache.set(cwd2, next);
-  return results.filter((meta) => meta !== null);
+  return {
+    files: results.filter((meta) => meta !== null),
+    ...errors.some(Boolean) ? { error: errors.filter((error) => !!error).join("\n") } : {}
+  };
 }
 async function fileMetaResultAsync(args, cwd2, includeUntracked2 = false) {
   let ns;
@@ -2877,8 +3137,11 @@ async function fileMetaResultAsync(args, cwd2, includeUntracked2 = false) {
       binary: stats?.binary || false
     };
   });
+  if (!includeUntracked2) return { files };
+  const untracked = await untrackedMetaAsync(cwd2);
   return {
-    files: includeUntracked2 ? files.concat(await untrackedMetaAsync(cwd2)) : files
+    files: files.concat(untracked.files),
+    ...untracked.error ? { error: untracked.error, status: untracked.status } : {}
   };
 }
 async function fileDiffTextAsync(args, path, cwd2) {
@@ -2915,7 +3178,12 @@ async function untrackedFileDiffAsync(extras, path, cwd2) {
       "--no-index",
       ...extras,
       "/dev/null",
-      path
+      // `--no-index` は `--` によるオプション終端を受け付けない (usage エラー
+      // になる) ので、`./` を前置してオプションに見えなくする。これが無いと
+      // path が `--output=/tmp/x` のときに git がオプションとして解釈し、
+      // **任意の場所へファイルを書けてしまう** (再現確認済み)。
+      // 呼び出し側でのパス検証と合わせた二重の防御。
+      path.startsWith("./") ? path : `./${path}`
     ],
     cwd2
   );
@@ -2990,9 +3258,11 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA, WORKTREE_RECURSIVE_DEPTH_LIMIT, WORKTREE_RECURSIVE_ENTRY_LIMIT, DEFAULT_REF_COMMIT_LIMIT, MAX_REF_COMMIT_LIMIT, COMMIT_FORMAT, ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS, repoStatusMapCache, HISTORY_FORMAT, MAX_HISTORY_LIMIT, LS_TREE_SYMLINK_MODE, untrackedScanCache, UNTRACKED_SCAN_CONCURRENCY;
+var BLAME_ZERO_SHA, WORKTREE_RECURSIVE_DEPTH_LIMIT, WORKTREE_RECURSIVE_ENTRY_LIMIT, DEFAULT_REF_COMMIT_LIMIT, MAX_REF_COMMIT_LIMIT, COMMIT_FORMAT, ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS, repoStatusMapCache, STATUS_PORCELAIN_ARGS, HISTORY_FORMAT, MAX_HISTORY_LIMIT, LS_TREE_SYMLINK_MODE, untrackedScanCache, UNTRACKED_SCAN_CONCURRENCY;
 var init_git = __esm({
   "web-src/server/git.ts"() {
+    init_error_detail();
+    init_worktree();
     init_cache();
     init_command_resolver();
     init_name_pattern();
@@ -3050,6 +3320,19 @@ var init_git = __esm({
     ];
     GIT_COMMAND_TIMEOUT_MS = 2e4;
     repoStatusMapCache = /* @__PURE__ */ new Map();
+    STATUS_PORCELAIN_ARGS = [
+      "git",
+      "-c",
+      "core.quotepath=false",
+      "status",
+      "--porcelain=v1",
+      "-z",
+      // "normal" (not "all") keeps a brand-new untracked directory collapsed
+      // to a single `?? dir/` record instead of walking into it: the tree
+      // explorer badges its descendants by ancestor lookup anyway, and "all"
+      // would make git enumerate every file under it on each poll.
+      "--untracked-files=normal"
+    ];
     HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b";
     MAX_HISTORY_LIMIT = 200;
     LS_TREE_SYMLINK_MODE = "120000";
@@ -3059,14 +3342,8 @@ var init_git = __esm({
 });
 
 // web-src/server/server-registry.ts
-import { createHash } from "node:crypto";
-import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join as join5 } from "node:path";
 function registryDir() {
@@ -3078,46 +3355,142 @@ function serverRegistryFilePath(root) {
   const hash = createHash("sha256").update(root).digest("hex").slice(0, 16);
   return join5(registryDir(), `${hash}.json`);
 }
-function writeServerRegistry(entry) {
+function serverStartLockFilePath(root) {
+  const hash = createHash("sha256").update(root).digest("hex").slice(0, 16);
+  return join5(registryDir(), `${hash}.start.lock`);
+}
+function errno(error) {
+  return error.code;
+}
+function processAlive(pid) {
   try {
-    mkdirSync(registryDir(), { recursive: true });
-    writeFileSync(
-      serverRegistryFilePath(entry.root),
-      `${JSON.stringify(entry, null, 2)}
-`,
-      "utf8"
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (errno(error) === "ESRCH") return false;
+    if (errno(error) === "EPERM") return true;
+    throw error;
+  }
+}
+function readServerStartLock(root) {
+  const file = serverStartLockFilePath(root);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(file, "utf8"));
+  } catch (error) {
+    if (errno(error) === "ENOENT") return null;
+    throw errorWithCause(`failed to read server start lock for ${root}`, error);
+  }
+  if (!raw || typeof raw !== "object") {
+    throw new Error(
+      `invalid server start lock for ${root}: expected an object`
     );
-  } catch {
   }
+  const entry = raw;
+  if (typeof entry.token !== "string" || !entry.token || !Number.isInteger(entry.pid) || entry.pid < 1 || typeof entry.createdAt !== "number" || !Number.isFinite(entry.createdAt)) {
+    throw new Error(
+      `invalid server start lock for ${root}: missing required fields`
+    );
+  }
+  return {
+    token: entry.token,
+    pid: entry.pid,
+    createdAt: entry.createdAt
+  };
+}
+function acquireServerStartLock(root, now = Date.now()) {
+  mkdirSync(registryDir(), { recursive: true });
+  const file = serverStartLockFilePath(root);
+  const token = randomUUID();
+  const entry = {
+    token,
+    pid: process.pid,
+    createdAt: now
+  };
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      writeFileSync(file, `${JSON.stringify(entry)}
+`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 384
+      });
+      return {
+        release() {
+          const current2 = readServerStartLock(root);
+          if (!current2 || current2.token !== token) return;
+          try {
+            unlinkSync(file);
+          } catch (error) {
+            if (errno(error) === "ENOENT") return;
+            throw error;
+          }
+        }
+      };
+    } catch (error) {
+      if (errno(error) !== "EEXIST") throw error;
+    }
+    const current = readServerStartLock(root);
+    if (!current) continue;
+    const stale = now - current.createdAt > SERVER_START_LOCK_STALE_MS || !processAlive(current.pid);
+    if (!stale) return null;
+    try {
+      unlinkSync(file);
+    } catch (error) {
+      if (errno(error) !== "ENOENT") throw error;
+    }
+  }
+  throw new Error(`server start lock kept changing for ${root}`);
+}
+function writeServerRegistry(entry) {
+  mkdirSync(registryDir(), { recursive: true });
+  writeFileSync(
+    serverRegistryFilePath(entry.root),
+    `${JSON.stringify(entry, null, 2)}
+`,
+    "utf8"
+  );
 }
 function readServerRegistry(root) {
   const file = serverRegistryFilePath(root);
-  if (!existsSync2(file)) return null;
+  let raw;
   try {
-    const raw = JSON.parse(readFileSync2(file, "utf8"));
-    if (!raw || typeof raw !== "object") return null;
-    const entry = raw;
-    if (typeof entry.url !== "string" || !entry.url) return null;
-    return {
-      url: entry.url,
-      pid: typeof entry.pid === "number" ? entry.pid : 0,
-      root: typeof entry.root === "string" ? entry.root : root,
-      started_at: typeof entry.started_at === "string" ? entry.started_at : ""
-    };
-  } catch {
-    return null;
+    raw = JSON.parse(readFileSync2(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw errorWithCause(`failed to read server registry for ${root}`, error);
+  }
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`invalid server registry for ${root}: expected an object`);
   }
+  const entry = raw;
+  if (typeof entry.url !== "string" || !entry.url || !Number.isInteger(entry.pid) || entry.pid < 1 || typeof entry.root !== "string" || !entry.root || typeof entry.started_at !== "string" || !entry.started_at) {
+    throw new Error(
+      `invalid server registry for ${root}: missing required fields`
+    );
+  }
+  return {
+    url: entry.url,
+    pid: entry.pid,
+    root: entry.root,
+    started_at: entry.started_at
+  };
 }
 function removeServerRegistry(root, pid) {
+  const entry = readServerRegistry(root);
+  if (!entry || entry.pid !== pid) return;
   try {
-    const entry = readServerRegistry(root);
-    if (!entry || entry.pid !== pid) return;
     unlinkSync(serverRegistryFilePath(root));
-  } catch {
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
   }
 }
+var SERVER_START_LOCK_STALE_MS;
 var init_server_registry = __esm({
   "web-src/server/server-registry.ts"() {
+    init_error_detail();
+    SERVER_START_LOCK_STALE_MS = 3e4;
   }
 });
 
@@ -4322,7 +4695,7 @@ __export(file_cli_exports, {
   safeWorktreePathFromRoot: () => safeWorktreePathFromRoot,
   sliceLines: () => sliceLines
 });
-import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync4, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
 import { join as join6, relative as relative3 } from "node:path";
 function validatePath(value) {
   return validateRepoRelativePathValue(value, "--path");
@@ -4709,7 +5082,7 @@ function sliceLines(text2, start, end) {
 function safeWorktreePathFromRoot(root, path) {
   if (validatePath(path)) return null;
   const full = join6(root, path);
-  if (!existsSync3(full)) return null;
+  if (!existsSync2(full)) return null;
   try {
     const realRoot = realpathSync4(root);
     const realFull = realpathSync4(full);
@@ -4736,8 +5109,8 @@ async function readShowTextAsync(root, command) {
     };
   }
   try {
-    const stat3 = statSync4(full);
-    if (!stat3.isFile()) {
+    const stat4 = statSync4(full);
+    if (!stat4.isFile()) {
       return { code: 1, stdout: "", stderr: "not a file" };
     }
     return { code: 0, stdout: readFileSync4(full, "utf8"), stderr: "" };
@@ -8907,8 +9280,8 @@ function computeFuzzyMatch(query, path) {
   const first = indices[0];
   score -= Math.min(first, 40);
   if (indices[0] >= baseStart) score += 20;
-  const basename6 = lowerPath.slice(baseStart);
-  const tier = pathMatchTier(q, lowerPath, basename6);
+  const basename7 = lowerPath.slice(baseStart);
+  const tier = pathMatchTier(q, lowerPath, basename7);
   const contiguousRange = contiguousPathRange(q, lowerPath, baseStart);
   return {
     score,
@@ -9060,8 +9433,8 @@ function createGlobPathMatcher(query) {
   const suffix = query.replace(/^\*+/, "").toLowerCase();
   return (path) => {
     const baseStart = basenameStart(path);
-    const basename6 = path.slice(baseStart);
-    if (!regex.test(path) && (query.includes("/") || !regex.test(basename6)))
+    const basename7 = path.slice(baseStart);
+    if (!regex.test(path) && (query.includes("/") || !regex.test(basename7)))
       return null;
     const ranges = [];
     const lowerPath = path.toLowerCase();
@@ -9696,13 +10069,13 @@ Parse failures and unreachable servers exit 1.
 });
 
 // web-src/server/root.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { dirname as dirname4, join as join7, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 function findRoot(start) {
   let current = start;
   for (let i = 0; i < 5; i++) {
-    if (existsSync4(join7(current, "package.json")) && existsSync4(join7(current, "web"))) {
+    if (existsSync3(join7(current, "package.json")) && existsSync3(join7(current, "web"))) {
       return normalize(current);
     }
     const parent = dirname4(current);
@@ -9728,7 +10101,7 @@ __export(skill_cli_exports, {
   parseSkillArgs: () => parseSkillArgs,
   runSkillCli: () => runSkillCli
 });
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "node:fs";
+import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join8, resolve } from "node:path";
 function parseAgentList(value) {
@@ -9782,9 +10155,9 @@ function parseSkillArgs(argv) {
   return { ok: true, args: { kind: "install", agents, global, cwd: cwd2 } };
 }
 function discoverBundledSkills(skillsRoot) {
-  if (!existsSync5(skillsRoot)) return [];
+  if (!existsSync4(skillsRoot)) return [];
   return readdirSync2(skillsRoot, { withFileTypes: true }).filter(
-    (entry) => entry.isDirectory() && existsSync5(join8(skillsRoot, entry.name, "SKILL.md"))
+    (entry) => entry.isDirectory() && existsSync4(join8(skillsRoot, entry.name, "SKILL.md"))
   ).map((entry) => entry.name).sort();
 }
 function installSkill(args, deps) {
@@ -9801,7 +10174,7 @@ function installSkill(args, deps) {
     for (const skill of skills) {
       const sourceDir = join8(deps.skillsRoot, skill);
       const target = join8(base, AGENT_SKILL_DIRS[agent], "skills", skill);
-      const action = existsSync5(target) ? "updated" : "installed";
+      const action = existsSync4(target) ? "updated" : "installed";
       try {
         mkdirSync2(target, { recursive: true });
         cpSync(sourceDir, target, { recursive: true });
@@ -16244,7 +16617,7 @@ var init_control_chars = __esm({
 // web-src/server/database/discovery.ts
 import {
   closeSync,
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   openSync,
   readSync,
   realpathSync as realpathSync5,
@@ -16254,8 +16627,8 @@ import { lstat, open as open2, readdir, readFile as readFile2, stat as stat2 } f
 import { basename, join as join11, relative as relative5 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
-    const stat3 = statSync5(fullPath);
-    if (!stat3.isFile() || stat3.size < 16) return false;
+    const stat4 = statSync5(fullPath);
+    if (!stat4.isFile() || stat4.size < 16) return false;
     const buf = Buffer.alloc(16);
     const fd = openSync(fullPath, "r");
     try {
@@ -16357,7 +16730,7 @@ function validateDbPath(cwd2, dbPath) {
   ))
     return null;
   const full = join11(cwd2, dbPath);
-  if (!existsSync6(full)) return null;
+  if (!existsSync5(full)) return null;
   let realCwd;
   let realFull;
   try {
@@ -17050,6 +17423,36 @@ var init_discovery = __esm({
   }
 });
 
+// web-src/server/abort.ts
+function createLinkedAbortController(parent, timeoutMs) {
+  const controller = new AbortController();
+  const abortFromParent = () => controller.abort(parent?.reason);
+  if (parent?.aborted) {
+    abortFromParent();
+  } else {
+    parent?.addEventListener("abort", abortFromParent, { once: true });
+  }
+  const timer2 = timeoutMs === void 0 ? null : setTimeout(
+    () => controller.abort(
+      new Error(`operation timed out after ${timeoutMs}ms`)
+    ),
+    timeoutMs
+  );
+  timer2?.unref?.();
+  return {
+    signal: controller.signal,
+    abort: () => controller.abort(),
+    cleanup() {
+      if (timer2) clearTimeout(timer2);
+      parent?.removeEventListener("abort", abortFromParent);
+    }
+  };
+}
+var init_abort2 = __esm({
+  "web-src/server/abort.ts"() {
+  }
+});
+
 // web-src/core/keymap.ts
 function sanitizeChord(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -18873,8 +19276,8 @@ async function runSecurityAsync(opts) {
       "refusing to run the real security binary in tests; use __setKeychainSpawnForTest"
     );
   }
-  const spawn4 = keychainSpawnOverride ?? spawnCollectAsync;
-  const result = await spawn4({
+  const spawn5 = keychainSpawnOverride ?? spawnCollectAsync;
+  const result = await spawn5({
     command: SECURITY_COMMAND,
     args: opts.args,
     ...opts.input === void 0 ? {} : { input: opts.input },
@@ -18994,7 +19397,7 @@ var init_credential_store = __esm({
 });
 
 // web-src/server/database/connections-store.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { chmod } from "node:fs/promises";
 import { join as join13 } from "node:path";
 function secretKey(cwd2, id) {
@@ -19198,7 +19601,7 @@ async function findDatastoreConnection(cwd2, id) {
 async function saveDatastoreConnection(cwd2, raw) {
   const input = raw && typeof raw === "object" ? raw : {};
   const requestedId = typeof input.id === "string" ? input.id : "";
-  const id = requestedId || `connection:${randomUUID()}`;
+  const id = requestedId || `connection:${randomUUID2()}`;
   const result = await store.update(cwd2, (state) => {
     const storedExisting = state.connections.find((entry) => entry.id === id);
     const existing = storedExisting ? withRuntimeSecrets(cwd2, storedExisting) : void 0;
@@ -22791,22 +23194,6 @@ async function handleTableCount(cwd2, url, omitDirNames, signal) {
 function makeHistoryId() {
   return makeId("qh");
 }
-function createLinkedAbortController(parent) {
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  if (parent?.aborted) {
-    controller.abort();
-  } else {
-    parent?.addEventListener("abort", abort, { once: true });
-  }
-  return {
-    signal: controller.signal,
-    abort,
-    cleanup() {
-      parent?.removeEventListener("abort", abort);
-    }
-  };
-}
 function unquoteSqlIdentifier(raw) {
   const trimmed = raw.trim();
   if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
@@ -24085,6 +24472,7 @@ var init_handle = __esm({
   "web-src/server/database/handle.ts"() {
     init_control_chars();
     init_id();
+    init_abort2();
     init_state_store();
     init_abort();
     init_async_facade();
@@ -24564,9 +24952,549 @@ var init_command = __esm({
   }
 });
 
+// web-src/server/worktree/open.ts
+import { spawn as spawn3 } from "node:child_process";
+import { realpathSync as realpathSync6 } from "node:fs";
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function errno2(error) {
+  return error.code;
+}
+function processAlive2(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (errno2(error) === "ESRCH") return false;
+    if (errno2(error) === "EPERM") return true;
+    throw error;
+  }
+}
+function registryKey(path) {
+  try {
+    return realpathSync6(path);
+  } catch (error) {
+    if (errno2(error) === "ENOENT") return path;
+    throw error;
+  }
+}
+function registryUrl(entry) {
+  let url;
+  try {
+    url = new URL(entry.url);
+  } catch (error) {
+    throw errorWithCause("server registry contains an invalid URL", error);
+  }
+  if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || !url.port || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error("server registry URL must be an HTTP loopback root URL");
+  }
+  const port = Number(url.port);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("server registry URL has an invalid port");
+  }
+  return url;
+}
+function settingsIdentity(value) {
+  if (!value || typeof value !== "object") return null;
+  const server2 = value.server;
+  if (!server2 || typeof server2 !== "object") return null;
+  const identity = server2;
+  if (!Number.isInteger(identity.pid) || identity.pid < 1 || typeof identity.root !== "string" || !identity.root) {
+    return null;
+  }
+  return { pid: identity.pid, root: identity.root };
+}
+async function waitForChildExit(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return true;
+  return new Promise((resolve4) => {
+    const onClose = () => finish(true);
+    const timer2 = setTimeout(() => finish(false), timeoutMs);
+    timer2.unref?.();
+    const finish = (exited) => {
+      clearTimeout(timer2);
+      child.off("close", onClose);
+      resolve4(exited);
+    };
+    child.once("close", onClose);
+  });
+}
+async function terminateChild(child) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  if (await waitForChildExit(child, STOP_GRACE_MS)) return;
+  child.kill("SIGKILL");
+  if (!await waitForChildExit(child, STOP_GRACE_MS)) {
+    throw new Error("spawned worktree server did not stop after SIGKILL");
+  }
+}
+function spawnServer(path) {
+  const entry = process.argv[1];
+  if (!entry) throw new Error("cannot locate code-viewer entry point");
+  const child = spawn3(
+    process.execPath,
+    [...process.execArgv, entry, "--cwd", path, "--port", "0"],
+    { cwd: path, detached: true, stdio: "ignore", env: process.env }
+  );
+  return {
+    onError(listener) {
+      child.once("error", listener);
+    },
+    terminate: () => terminateChild(child),
+    unref: () => child.unref()
+  };
+}
+async function signalProcess(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (errno2(error) === "ESRCH") return;
+    throw error;
+  }
+}
+async function terminatePid(pid) {
+  await signalProcess(pid, "SIGTERM");
+  const deadline = Date.now() + STOP_GRACE_MS;
+  while (processAlive2(pid) && Date.now() < deadline) await delay(50);
+  if (!processAlive2(pid)) return;
+  await signalProcess(pid, "SIGKILL");
+  const killDeadline = Date.now() + STOP_GRACE_MS;
+  while (processAlive2(pid) && Date.now() < killDeadline) await delay(50);
+  if (processAlive2(pid)) {
+    throw new Error(`worktree server process ${pid} did not stop`);
+  }
+}
+function createWorktreeServerController(overrides = {}) {
+  const runtime = { ...DEFAULT_RUNTIME, ...overrides };
+  const opening = /* @__PURE__ */ new Map();
+  async function runningServerResult2(path, options = {}) {
+    let key;
+    let entry;
+    try {
+      key = registryKey(path);
+      entry = readServerRegistry(key);
+    } catch (error) {
+      return { status: "invalid", error };
+    }
+    if (!entry) return { status: "absent" };
+    if (entry.root !== key) {
+      return {
+        status: "invalid",
+        error: new Error("server registry root does not match its file key")
+      };
+    }
+    let url;
+    try {
+      url = registryUrl(entry);
+      if (!processAlive2(entry.pid)) return { status: "absent" };
+    } catch (error) {
+      return { status: "invalid", error };
+    }
+    let response;
+    const healthAbort = createLinkedAbortController(
+      options.signal,
+      options.timeoutMs ?? HEALTH_TIMEOUT_MS
+    );
+    try {
+      response = await runtime.fetch(new URL("_settings", url).href, {
+        redirect: "error",
+        signal: healthAbort.signal
+      });
+    } catch (error) {
+      return { status: "unreachable", error };
+    } finally {
+      healthAbort.cleanup();
+    }
+    if (!response.ok) {
+      return {
+        status: "unreachable",
+        error: new Error(
+          `registered server health check returned ${response.status}`
+        )
+      };
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch (error) {
+      return {
+        status: "invalid",
+        error: errorWithCause(
+          "registered server returned invalid settings",
+          error
+        )
+      };
+    }
+    const identity = settingsIdentity(body);
+    if (!identity || identity.pid !== entry.pid || identity.root !== key) {
+      return {
+        status: "invalid",
+        error: new Error(
+          "registered server identity does not match the registry"
+        )
+      };
+    }
+    return { status: "running", url: url.href, pid: entry.pid };
+  }
+  async function spawnWhileLocked(key, deadline) {
+    const existing = await runningServerResult2(key);
+    if (existing.status === "running") {
+      return { status: "ok", url: existing.url, started: false };
+    }
+    if (existing.status === "invalid" || existing.status === "unreachable") {
+      return { status: "error", error: existing.error };
+    }
+    let child;
+    try {
+      child = runtime.spawnServer(key);
+    } catch (error) {
+      return { status: "error", error };
+    }
+    let spawnError = null;
+    child.onError((error) => {
+      spawnError = error;
+    });
+    child.unref();
+    const stopAfterFailure = async (result) => {
+      try {
+        await child.terminate();
+        return result;
+      } catch (error) {
+        const startupError = result.status === "error" ? result.error : new Error(`worktree server startup ended with ${result.status}`);
+        return {
+          status: "error",
+          error: errorWithCauses(
+            "failed to stop an unsuccessful worktree server",
+            [startupError, error]
+          )
+        };
+      }
+    };
+    try {
+      while (runtime.now() < deadline) {
+        await runtime.delay(runtime.pollIntervalMs);
+        if (spawnError) {
+          return stopAfterFailure({ status: "error", error: spawnError });
+        }
+        const found = await runningServerResult2(key);
+        if (found.status === "running") {
+          return { status: "ok", url: found.url, started: true };
+        }
+        if (found.status === "invalid") {
+          return stopAfterFailure({ status: "error", error: found.error });
+        }
+      }
+      return stopAfterFailure({ status: "timeout" });
+    } catch (error) {
+      return stopAfterFailure({ status: "error", error });
+    }
+  }
+  async function doOpen(path) {
+    let key;
+    try {
+      key = realpathSync6(path);
+    } catch (error) {
+      if (errno2(error) === "ENOENT") return { status: "missing" };
+      return { status: "error", error };
+    }
+    const deadline = runtime.now() + runtime.startTimeoutMs;
+    while (runtime.now() < deadline) {
+      const existing = await runningServerResult2(key);
+      if (existing.status === "running") {
+        return { status: "ok", url: existing.url, started: false };
+      }
+      if (existing.status === "invalid" || existing.status === "unreachable") {
+        return { status: "error", error: existing.error };
+      }
+      let lock;
+      try {
+        lock = acquireServerStartLock(key, runtime.now());
+      } catch (error) {
+        return { status: "error", error };
+      }
+      if (!lock) {
+        try {
+          await runtime.delay(runtime.pollIntervalMs);
+        } catch (error) {
+          return { status: "error", error };
+        }
+        continue;
+      }
+      let result;
+      try {
+        result = await spawnWhileLocked(key, deadline);
+      } catch (error) {
+        result = { status: "error", error };
+      }
+      try {
+        lock.release();
+      } catch (error) {
+        return {
+          status: "error",
+          error: result.status === "error" ? errorWithCauses(
+            "worktree server start and lock release both failed",
+            [result.error, error]
+          ) : errorWithCause(
+            "worktree server start lock could not be released",
+            error
+          )
+        };
+      }
+      return result;
+    }
+    return { status: "timeout" };
+  }
+  function openWorktreeServer2(path) {
+    let key;
+    try {
+      key = registryKey(path);
+    } catch (error) {
+      return Promise.resolve({ status: "error", error });
+    }
+    const pending = opening.get(key);
+    if (pending) return pending;
+    const started = doOpen(path).finally(() => {
+      if (opening.get(key) === started) opening.delete(key);
+    });
+    opening.set(key, started);
+    return started;
+  }
+  async function stopWorktreeServer2(path) {
+    const key = registryKey(path);
+    const pending = opening.get(key);
+    if (pending) await pending;
+    const running = await runningServerResult2(key);
+    if (running.status === "absent") return;
+    if (running.status !== "running") throw running.error;
+    await runtime.terminatePid(running.pid);
+    removeServerRegistry(key, running.pid);
+  }
+  return { openWorktreeServer: openWorktreeServer2, runningServerResult: runningServerResult2, stopWorktreeServer: stopWorktreeServer2 };
+}
+var START_TIMEOUT_MS, POLL_INTERVAL_MS, HEALTH_TIMEOUT_MS, STOP_GRACE_MS, DEFAULT_RUNTIME, DEFAULT_CONTROLLER, openWorktreeServer, runningServerResult, stopWorktreeServer;
+var init_open = __esm({
+  "web-src/server/worktree/open.ts"() {
+    init_error_detail();
+    init_abort2();
+    init_server_registry();
+    START_TIMEOUT_MS = 2e4;
+    POLL_INTERVAL_MS = 150;
+    HEALTH_TIMEOUT_MS = 1500;
+    STOP_GRACE_MS = 2e3;
+    DEFAULT_RUNTIME = {
+      delay,
+      fetch: (input, init) => fetch(input, init),
+      now: () => Date.now(),
+      pollIntervalMs: POLL_INTERVAL_MS,
+      spawnServer,
+      startTimeoutMs: START_TIMEOUT_MS,
+      terminatePid
+    };
+    DEFAULT_CONTROLLER = createWorktreeServerController();
+    openWorktreeServer = DEFAULT_CONTROLLER.openWorktreeServer;
+    runningServerResult = DEFAULT_CONTROLLER.runningServerResult;
+    stopWorktreeServer = DEFAULT_CONTROLLER.stopWorktreeServer;
+  }
+});
+
+// web-src/server/worktree/list.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { stat as stat3 } from "node:fs/promises";
+import { basename as basename2, join as join17, relative as relative6 } from "node:path";
+async function mapWithConcurrency(items, limit, mapper) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError("concurrency limit must be a positive integer");
+  }
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      results[index] = await mapper(items[index], index);
+    }
+  };
+  await Promise.all(
+    Array.from(
+      { length: Math.min(limit, Math.max(1, items.length)) },
+      () => worker()
+    )
+  );
+  return results;
+}
+function worktreeAddParent(repoRootPath) {
+  return join17(repoRootPath, WORKTREE_ADD_DIR_NAME);
+}
+function serverWorktreeRoot(cwd2) {
+  return repoRoot(cwd2) ?? cwd2;
+}
+function displayPathFor(root, path) {
+  const rel = relative6(root, path);
+  if (!rel) return ".";
+  return rel.startsWith("..") ? path : rel;
+}
+function joinErrors(...parts) {
+  return parts.filter((part) => !!part).join("\n");
+}
+function toFileChange(meta, origin) {
+  return {
+    path: meta.path,
+    ...meta.old_path ? { oldPath: meta.old_path } : {},
+    // 未追跡は git の name-status には出ないので、追加 ("A") と区別できる
+    // ように専用の文字にする。
+    status: meta.untracked ? "U" : meta.status || "M",
+    additions: meta.additions || 0,
+    deletions: meta.deletions || 0,
+    origin
+  };
+}
+async function collectFiles(ref, base) {
+  const comparable = !!base && !!ref.branch && ref.branch !== base;
+  const [uncommitted, committed] = await Promise.all([
+    fileMetaResultAsync(["HEAD"], ref.path, true),
+    comparable ? fileMetaResultAsync(
+      [`refs/heads/${base}...refs/heads/${ref.branch}`],
+      ref.path,
+      false
+    ) : Promise.resolve({ files: [] })
+  ]);
+  const files = [
+    ...uncommitted.files.map((meta) => toFileChange(meta, "uncommitted")),
+    ...committed.files.map((meta) => toFileChange(meta, "committed"))
+  ];
+  return {
+    files,
+    error: joinErrors(uncommitted.error, committed.error) || void 0
+  };
+}
+async function lastTouchedMs(ref, files) {
+  const targets = files.filter((file) => file.status !== "D");
+  const errors = [];
+  const mtimes = await mapWithConcurrency(targets, 8, async (file) => {
+    try {
+      return (await stat3(join17(ref.path, file.path))).mtimeMs;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        errors.push(formatErrorDetail(error));
+      }
+      return null;
+    }
+  });
+  const valid = mtimes.filter((value) => value !== null);
+  return {
+    at: valid.length ? Math.max(...valid) : null,
+    ...errors.length ? { error: errors.join("\n") } : {}
+  };
+}
+async function collectDivergence(root, ref, base) {
+  if (!base || !ref.branch || ref.branch === base) {
+    return { divergence: null };
+  }
+  const [counts, merge] = await Promise.all([
+    worktreeDivergenceResultAsync(root, base, ref.branch),
+    mergePreviewResultAsync(root, base, ref.branch)
+  ]);
+  if (counts.error) return { divergence: null, error: counts.error };
+  return {
+    divergence: {
+      base,
+      ahead: counts.ahead,
+      behind: counts.behind,
+      mergeState: merge.state,
+      conflicts: merge.conflicts
+    },
+    error: merge.error
+  };
+}
+function emptyItem(root, ref) {
+  return {
+    ...ref,
+    id: ref.path,
+    name: basename2(ref.path) || ref.path,
+    displayPath: displayPathFor(root, ref.path),
+    current: ref.path === root,
+    missing: !existsSync6(ref.path),
+    changedCount: 0,
+    error: "",
+    lastCommit: null,
+    lastTouched: null,
+    serverUrl: "",
+    divergence: null,
+    files: [],
+    fileCount: 0
+  };
+}
+async function buildItem(root, base, ref) {
+  const item = emptyItem(root, ref);
+  if (item.missing || ref.bare) return item;
+  const [history, changes, divergence, server2] = await Promise.all([
+    commitHistoryAsync(ref.path, { ref: "HEAD", skip: 0, limit: 1 }),
+    collectFiles(ref, base),
+    collectDivergence(root, ref, base),
+    runningServerResult(ref.path)
+  ]);
+  const commit = history.commits[0];
+  const touched = await lastTouchedMs(ref, changes.files);
+  return {
+    ...item,
+    changedCount: changes.files.filter((file) => file.origin === "uncommitted").length,
+    error: joinErrors(
+      changes.error,
+      divergence.error,
+      history.error,
+      touched.error,
+      server2.status === "invalid" || server2.status === "unreachable" ? formatErrorDetail(server2.error) : void 0
+    ),
+    lastCommit: commit ? {
+      sha: commit.sha,
+      subject: commit.subject,
+      author: commit.author,
+      when: commit.when
+    } : null,
+    // 変更が 1 つも無い作業ツリーは、最後のコミットの時刻に落とす。
+    lastTouched: touched.at !== null ? new Date(touched.at).toISOString() : commit?.when ?? null,
+    serverUrl: server2.status === "running" ? server2.url : "",
+    divergence: divergence.divergence,
+    files: changes.files,
+    fileCount: changes.files.length
+  };
+}
+async function buildWorktreeList(root) {
+  const [listed, baseResult] = await Promise.all([
+    worktreeListResultAsync(root),
+    defaultBranchResultAsync(root)
+  ]);
+  const baseBranch = baseResult.branch;
+  const worktrees = await mapWithConcurrency(
+    listed.worktrees,
+    WORKTREE_LIST_CONCURRENCY,
+    (ref) => buildItem(root, baseBranch, ref)
+  );
+  const error = joinErrors(listed.error, baseResult.error);
+  return {
+    worktrees,
+    repoRoot: root,
+    addParent: worktreeAddParent(root),
+    baseBranch,
+    overlaps: findWorktreeOverlaps(worktrees),
+    ...error ? { error } : {}
+  };
+}
+var WORKTREE_ADD_DIR_NAME, WORKTREE_LIST_CONCURRENCY;
+var init_list = __esm({
+  "web-src/server/worktree/list.ts"() {
+    init_error_detail();
+    init_worktree();
+    init_git();
+    init_open();
+    WORKTREE_ADD_DIR_NAME = ".worktrees";
+    WORKTREE_LIST_CONCURRENCY = 3;
+  }
+});
+
 // web-src/server/doctor.ts
 import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
-import { dirname as dirname5, join as join17, relative as relative6 } from "node:path";
+import { dirname as dirname5, join as join18, relative as relative7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function statusWorse(a, b) {
   const rank = { ok: 0, warn: 1, error: 2 };
@@ -24668,7 +25596,7 @@ function findCodeViewerPackageJson() {
       cursor = dirname5(process.argv[1] || ".");
     }
     for (let depth = 0; depth < 8; depth += 1) {
-      const candidate = join17(cursor, "package.json");
+      const candidate = join18(cursor, "package.json");
       try {
         const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
@@ -24765,7 +25693,7 @@ async function checkSqlite(cwd2) {
   return { id: "sqlite", title: "SQLite driver", rows };
 }
 async function trySnapshotDbOpen(cwd2) {
-  const dbPath = join17(cwd2, SNAPSHOT_DB_REL);
+  const dbPath = join18(cwd2, SNAPSHOT_DB_REL);
   try {
     statSync6(dbPath);
   } catch {
@@ -24787,7 +25715,7 @@ async function trySnapshotDbOpen(cwd2) {
   }
 }
 function checkSnapshotStore(cwd2) {
-  const dbPath = join17(cwd2, SNAPSHOT_DB_REL);
+  const dbPath = join18(cwd2, SNAPSHOT_DB_REL);
   const dir = dirname5(dbPath);
   let dirStatus = "ok";
   let dirDetail = dir;
@@ -24807,8 +25735,8 @@ function checkSnapshotStore(cwd2) {
   }
   let dbDetail = dbPath;
   try {
-    const stat3 = statSync6(dbPath);
-    dbDetail = `${dbPath} (${stat3.size.toLocaleString()} bytes)`;
+    const stat4 = statSync6(dbPath);
+    dbDetail = `${dbPath} (${stat4.size.toLocaleString()} bytes)`;
   } catch {
     dbDetail = `${dbPath} (not created yet — created on first snapshot)`;
   }
@@ -24884,7 +25812,7 @@ async function checkGit(cwd2, signal) {
       cwd2
     );
     const top = topRes?.stdout.trim() || cwd2;
-    const insideCwd = relative6(top, cwd2) || ".";
+    const insideCwd = relative7(top, cwd2) || ".";
     rows.push({
       id: "git.repo",
       title: "Working tree",
@@ -25707,7 +26635,7 @@ async function checkDatastoreConnectivity(cwd2, omitDirNames, signal, deps = DEF
   });
   return { id: "datastore", title: "Datastore connectivity", rows };
 }
-function checkServer(listenPort2) {
+async function checkServer(listenPort2, cwd2, signal) {
   const rows = [
     {
       id: "server.port",
@@ -25716,6 +26644,49 @@ function checkServer(listenPort2) {
       detail: listenPort2 > 0 ? `http://localhost:${listenPort2}/` : "port not yet bound"
     }
   ];
+  const root = serverWorktreeRoot(cwd2);
+  const listed = await worktreeListResultAsync(root, {
+    timeout: TIMEOUT.git,
+    signal
+  });
+  if (listed.error) {
+    rows.push({
+      id: "server.worktrees",
+      title: "Worktree servers",
+      status: "warn",
+      detail: `could not list worktrees: ${listed.error}`
+    });
+    return { id: "server", title: "Server", rows };
+  }
+  const checked = await mapWithConcurrency(
+    listed.worktrees.filter((entry) => entry.path !== root),
+    WORKTREE_LIST_CONCURRENCY,
+    async (entry) => ({
+      path: entry.path,
+      server: await runningServerResult(entry.path, {
+        signal,
+        timeoutMs: TIMEOUT.git
+      })
+    })
+  );
+  const running = checked.flatMap(
+    (entry) => entry.server.status === "running" ? [{ path: entry.path, url: entry.server.url }] : []
+  );
+  const serverErrors = checked.flatMap(
+    (entry) => entry.server.status === "invalid" || entry.server.status === "unreachable" ? [`${entry.path}: ${formatErrorDetail(entry.server.error)}`] : []
+  );
+  rows.push({
+    id: "server.worktrees",
+    title: "Worktree servers",
+    status: serverErrors.length ? "warn" : "ok",
+    detail: [
+      ...running.length ? running.map((entry) => `${entry.url} ${entry.path}`) : ["no other code-viewer is running for this repository's worktrees"],
+      ...serverErrors
+    ].join("\n"),
+    ...running.length ? {
+      hint: "stop one with `kill <pid>`; the pid is in ~/.cache/code-viewer/servers/"
+    } : {}
+  });
   return { id: "server", title: "Server", rows };
 }
 async function buildDoctorReport(ctx) {
@@ -25740,7 +26711,7 @@ async function buildDoctorReport(ctx) {
     ctx.signal
   );
   const terminal = await checkTerminalTools(ctx.signal);
-  const server2 = checkServer(ctx.listenPort);
+  const server2 = await checkServer(ctx.listenPort, ctx.cwd, ctx.signal);
   const groups = [
     runtime,
     packageGroup,
@@ -25784,6 +26755,7 @@ async function handleDoctor(ctx) {
 var SNAPSHOT_DB_REL, REQUIRED_NODE_MAJOR, TTL, TIMEOUT, versionCache, gitCache, dockerInfoCache, CACHE_KEY_SEP, composeConfigCache, composePsCache2, doctorGeneration, DEFAULT_DATASTORE_PROBE_TIMEOUT_MS, DEFAULT_DATASTORE_CONNECTIVITY_DEPS;
 var init_doctor = __esm({
   "web-src/server/doctor.ts"() {
+    init_error_detail();
     init_cli_helpers();
     init_command_resolver();
     init_docker();
@@ -25795,8 +26767,11 @@ var init_doctor = __esm({
     init_discovery();
     init_handle();
     init_sqlite_driver();
+    init_git();
     init_session();
     init_command();
+    init_list();
+    init_open();
     SNAPSHOT_DB_REL = ".code-viewer/db-snapshots.sqlite";
     REQUIRED_NODE_MAJOR = 20;
     TTL = {
@@ -26023,7 +26998,7 @@ var init_directory_name = __esm({
 });
 
 // web-src/server/dev-assets.ts
-import { basename as basename2 } from "node:path";
+import { basename as basename3 } from "node:path";
 function startDevAssetReload(options) {
   if (!options.enabled) return false;
   const watched = new Set(options.watchedFiles);
@@ -26032,7 +27007,7 @@ function startDevAssetReload(options) {
   const debounceMs = options.debounceMs ?? 150;
   let timer2 = null;
   options.watch(options.webRoot, { persistent: false }, (_event, filename) => {
-    if (!filename || !watched.has(basename2(filename.toString()))) return;
+    if (!filename || !watched.has(basename3(filename.toString()))) return;
     if (timer2) clearTimer(timer2);
     timer2 = setTimer(() => {
       timer2 = null;
@@ -26143,12 +27118,12 @@ var init_file_upload = __esm({
 });
 
 // web-src/server/journal.ts
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function dailyJournalFilePath(root) {
-  return join18(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
+  return join19(root, CODE_VIEWER_DIR, DAILY_JOURNAL_FILE_NAME);
 }
 function journalTasksFilePath(root) {
-  return join18(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
+  return join19(root, CODE_VIEWER_DIR, JOURNAL_TASKS_FILE_NAME);
 }
 function emptyDailyJournalState() {
   return { version: 1, entries: [] };
@@ -26738,9 +27713,9 @@ var init_file_filter = __esm({
 });
 
 // web-src/server/search-service.ts
-import { existsSync as existsSync7, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync7, realpathSync as realpathSync7 } from "node:fs";
 import { lstat as lstat2, readFile as readFile3 } from "node:fs/promises";
-import { join as join19, relative as relative7 } from "node:path";
+import { join as join20, relative as relative8 } from "node:path";
 async function rgAvailableAsync(cwd2) {
   if (rgAvailableCache !== null) return rgAvailableCache;
   const proc = await spawnTextAsync({
@@ -26767,17 +27742,17 @@ function isSafePath(path) {
 function safeWorktreePath(env, path) {
   if (!isSafePath(path)) return null;
   if (isGitInternalPath(path)) return null;
-  const full = join19(env.cwd, path);
+  const full = join20(env.cwd, path);
   if (!existsSync7(full)) return null;
   let realCwd;
   let realFull;
   try {
-    realCwd = realpathSync6(env.cwd);
-    realFull = realpathSync6(full);
+    realCwd = realpathSync7(env.cwd);
+    realFull = realpathSync7(full);
   } catch {
     return null;
   }
-  const rel = relative7(realCwd, realFull);
+  const rel = relative8(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
     return null;
   if (isGitInternalPath(rel)) return null;
@@ -26801,13 +27776,13 @@ async function grepWorktreeFallback(env, query, max, paths, excludeTests) {
       continue;
     const full = safeWorktreePath(env, path);
     if (!full) continue;
-    let stat3;
+    let stat4;
     try {
-      stat3 = await lstat2(full);
+      stat4 = await lstat2(full);
     } catch {
       continue;
     }
-    if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > GREP_MAX_FILE_BYTES)
+    if (!stat4.isFile() || stat4.isSymbolicLink() || stat4.size > GREP_MAX_FILE_BYTES)
       continue;
     let data;
     try {
@@ -28059,7 +29034,7 @@ var init_agent_state2 = __esm({
 });
 
 // web-src/server/terminal/rules.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function errorIssue(code, error) {
   return {
     path: "$",
@@ -28072,7 +29047,7 @@ function defaultResponse(errors = []) {
   return { rules: DEFAULT_AGENT_SCREEN_RULES, source: "default", errors };
 }
 function agentScreenRulesFilePath(root) {
-  return join20(root, ".code-viewer", RULES_FILE_NAME);
+  return join21(root, ".code-viewer", RULES_FILE_NAME);
 }
 function parseStoredRules(raw) {
   const parsed = parseAgentScreenRuleSet(raw);
@@ -28421,7 +29396,7 @@ var init_capture2 = __esm({
 
 // web-src/server/mcp.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function defaultMcpTools(options = {}) {
   return [
     {
@@ -30175,7 +31150,7 @@ var init_mcp = __esm({
     init_capture();
     MCP_PROTOCOL_VERSION = "2025-06-18";
     PACKAGE_VERSION = JSON.parse(
-      readFileSync7(join21(ROOT, "package.json"), "utf8")
+      readFileSync7(join22(ROOT, "package.json"), "utf8")
     ).version;
     MCP_SERVER_INFO = {
       name: "code-viewer",
@@ -30364,10 +31339,10 @@ var init_os_opener = __esm({
 });
 
 // web-src/server/os-trash.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync8, lstatSync as lstatSync5, mkdirSync as mkdirSync4, renameSync } from "node:fs";
 import { homedir as homedir3, release as osRelease2 } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join22, resolve as resolve2 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join23, resolve as resolve2 } from "node:path";
 function windowsTrashScript(path) {
   const quotedPath = path.replace(/'/g, "''");
   return [
@@ -30458,12 +31433,12 @@ async function runRequiredCommand(operation, command, cwd2) {
   }
 }
 function managedTrashRoot(cwd2) {
-  return join22(cwd2, ".code-viewer", "trash");
+  return join23(cwd2, ".code-viewer", "trash");
 }
 function movePathIntoTrashDirectory(path, trashRoot) {
   mkdirSync4(trashRoot, { recursive: true });
-  const name = basename3(path) || "trash-item";
-  const trashPath = join22(trashRoot, `${name}-${randomUUID2()}`);
+  const name = basename4(path) || "trash-item";
+  const trashPath = join23(trashRoot, `${name}-${randomUUID3()}`);
   if (existsSync8(trashPath)) {
     throw Object.assign(new Error("trash destination already exists"), {
       trashPath
@@ -30473,7 +31448,7 @@ function movePathIntoTrashDirectory(path, trashRoot) {
   return { trashPath };
 }
 function trashRootForHandle(cwd2, platform, release) {
-  if (platform === "darwin") return join22(homedir3(), ".Trash");
+  if (platform === "darwin") return join23(homedir3(), ".Trash");
   if (isWsl(platform, release)) return managedTrashRoot(cwd2);
   return null;
 }
@@ -30486,7 +31461,7 @@ function unsupportedTrashError(operation, platform, release) {
 async function movePathToTrash(path, cwd2, platform = process.platform, release = osRelease2()) {
   lstatSync5(path);
   if (platform === "darwin") {
-    return movePathIntoTrashDirectory(path, join22(homedir3(), ".Trash"));
+    return movePathIntoTrashDirectory(path, join23(homedir3(), ".Trash"));
   }
   if (isWsl(platform, release)) {
     return movePathIntoTrashDirectory(path, managedTrashRoot(cwd2));
@@ -30574,18 +31549,18 @@ var init_request_origin = __esm({
 });
 
 // web-src/server/watch-supervisor.ts
-import { spawn as spawn3 } from "node:child_process";
-import { join as join23 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function watchChildCommand() {
   const entry = process.argv[1] ?? "";
   const isTypeScriptEntry = entry.endsWith(".ts");
-  const script = isTypeScriptEntry ? join23(fileURLToPath3(new URL(".", import.meta.url)), "cli.ts") : entry;
+  const script = isTypeScriptEntry ? join24(fileURLToPath3(new URL(".", import.meta.url)), "cli.ts") : entry;
   const loaderArgs = isTypeScriptEntry ? process.execArgv : [];
   return [process.argv[0], ...loaderArgs, script, "watch-child"];
 }
 function startWatchSupervisor(options) {
-  const spawnChild = options.spawnFn || spawn3;
+  const spawnChild = options.spawnFn || spawn4;
   const now = options.nowFn || Date.now;
   const setTimer = options.setTimeoutFn || setTimeout;
   const setRepeating = options.setIntervalFn || setInterval;
@@ -30874,7 +31849,7 @@ async function openTmuxPaneInShell(paneId, cwd2, size = {}) {
   }
   return { status: "ok", session: created.session, action: "attached" };
 }
-var init_open = __esm({
+var init_open2 = __esm({
   "web-src/server/terminal/open.ts"() {
     init_error_detail();
     init_session();
@@ -30952,7 +31927,7 @@ var init_handle2 = __esm({
     init_error_detail();
     init_tmux();
     init_handle_shared();
-    init_open();
+    init_open2();
     init_clients();
     init_panes();
   }
@@ -31176,9 +32151,9 @@ var init_handle3 = __esm({
 });
 
 // web-src/server/terminal/images.ts
-import { realpathSync as realpathSync7, statSync as statSync7 } from "node:fs";
+import { realpathSync as realpathSync8, statSync as statSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename4, isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
 function resolveTerminalImage(cwd2, candidate) {
   if (typeof candidate !== "string" || candidate === "") return null;
   if (candidate.includes("\0")) return null;
@@ -31186,11 +32161,11 @@ function resolveTerminalImage(cwd2, candidate) {
   const expanded = candidate.startsWith("~/") ? resolve3(homedir4(), candidate.slice(2)) : candidate;
   const full = isAbsolute2(expanded) ? expanded : resolve3(cwd2, expanded);
   try {
-    const real = realpathSync7(full);
-    const stat3 = statSync7(real);
-    if (!stat3.isFile()) return null;
-    if (stat3.size === 0 || stat3.size > MAX_IMAGE_BYTES) return null;
-    return { path: real, bytes: stat3.size };
+    const real = realpathSync8(full);
+    const stat4 = statSync7(real);
+    if (!stat4.isFile()) return null;
+    if (stat4.size === 0 || stat4.size > MAX_IMAGE_BYTES) return null;
+    return { path: real, bytes: stat4.size };
   } catch {
     return null;
   }
@@ -31209,7 +32184,7 @@ function resolveTerminalImages(cwd2, candidates) {
       path: image.path,
       // 画面で探すのは、渡された綴りそのもの。実体のパスとは違うことがある。
       candidate,
-      name: basename4(image.path),
+      name: basename5(image.path),
       url: terminalImageUrl(image.path)
     });
   }
@@ -31226,7 +32201,7 @@ var init_images = __esm({
 
 // web-src/server/terminal/paste.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 async function savePastedImage(cwd2, mime, base64) {
   const extension = pasteImageExtension(mime);
   if (!extension) {
@@ -31251,8 +32226,8 @@ async function savePastedImage(cwd2, mime, base64) {
     return { status: "invalid", message: "image too large" };
   }
   const name = `${makeTimedId("paste")}.${extension}`;
-  const dir = join24(cwd2, PASTE_DIR);
-  const path = join24(dir, name);
+  const dir = join25(cwd2, PASTE_DIR);
+  const path = join25(dir, name);
   try {
     await mkdir2(dir, { recursive: true });
     await writeFile2(path, bytes);
@@ -31269,7 +32244,7 @@ var init_paste = __esm({
   "web-src/server/terminal/paste.ts"() {
     init_id();
     init_terminal_paste();
-    PASTE_DIR = join24(".code-viewer", "pasted");
+    PASTE_DIR = join25(".code-viewer", "pasted");
   }
 });
 
@@ -31476,6 +32451,260 @@ var init_handle4 = __esm({
   }
 });
 
+// web-src/server/worktree/handle.ts
+var handle_exports5 = {};
+__export(handle_exports5, {
+  handleWorktreeRoute: () => handleWorktreeRoute
+});
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join26 } from "node:path";
+function actionJson(body) {
+  return json(body);
+}
+function bodyString(body, key) {
+  const value = body[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+async function handleListGet(cwd2, generation2) {
+  const list = await buildWorktreeList(serverWorktreeRoot(cwd2));
+  const response = { ...list, generation: generation2 };
+  return json(response);
+}
+async function resolveListedPath(cwd2, path) {
+  const root = serverWorktreeRoot(cwd2);
+  if (!path) return textError("path is required", 400);
+  const listed = await worktreeListResultAsync(root);
+  if (listed.error) return textError(listed.error, listed.status ?? 500);
+  const found = findWorktree(listed.worktrees, path);
+  if (!found) return textError("unknown worktree", 404);
+  return {
+    path: found.path,
+    root,
+    branch: found.branch,
+    current: found.path === root,
+    ref: found
+  };
+}
+async function handleDiffGet(url, cwd2, generation2) {
+  const file = url.searchParams.get("file") || "";
+  if (!file) return textError("file is required", 400);
+  if (!isSafePath(file)) return textError("invalid file path", 400);
+  if (file.startsWith("-")) return textError("invalid file path", 400);
+  if (isGitInternalPath(file)) return textError("forbidden", 403);
+  const resolved = await resolveListedPath(
+    cwd2,
+    url.searchParams.get("path") || ""
+  );
+  if (resolved instanceof Response) return resolved;
+  const origin = url.searchParams.get("origin") === "committed" ? "committed" : "uncommitted";
+  const untracked = url.searchParams.get("untracked") === "1";
+  const extras = [];
+  if (url.searchParams.get("ignore_ws") === "1") extras.push("-w");
+  if (url.searchParams.get("ignore_blank") === "1") {
+    extras.push("--ignore-blank-lines");
+  }
+  const baseResult = origin === "committed" ? await defaultBranchResultAsync(resolved.root) : { branch: "" };
+  if (baseResult.error) {
+    return textError(baseResult.error, baseResult.status ?? 500);
+  }
+  const base = baseResult.branch;
+  let args = ["HEAD"];
+  if (origin === "committed") {
+    if (!base || !resolved.branch || base === resolved.branch) {
+      return textError("nothing to compare against", 409);
+    }
+    args = [`refs/heads/${base}...refs/heads/${resolved.branch}`];
+  }
+  const changes = await collectFiles(resolved.ref, base);
+  const listedFile = changes.files.find(
+    (change) => change.path === file && change.origin === origin
+  );
+  if (!listedFile) return textError("file is not changed here", 404);
+  if (!safeWorktreePathFromRoot(resolved.path, file)) {
+    return textError("forbidden", 403);
+  }
+  const res = untracked ? await untrackedFileDiffAsync(extras, file, resolved.path) : await fileDiffTextAsync([...extras, ...args], file, resolved.path);
+  const failed = untracked ? res.code > 1 : res.code !== 0;
+  if (failed) {
+    return textError(res.stderr.trim() || "git diff failed", res.status ?? 500);
+  }
+  const truncated = truncateToNHunks(
+    res.stdout,
+    DIFF_MAX_HUNKS,
+    DIFF_MAX_LINES
+  );
+  const response = {
+    file,
+    origin,
+    diff: truncated.text,
+    totalHunks: truncated.totalHunks,
+    renderedHunks: truncated.renderedHunks,
+    truncated: truncated.renderedHunks < truncated.totalHunks,
+    generation: generation2
+  };
+  return json(response);
+}
+async function handleAddPost(req, cwd2) {
+  const parsed = await parseBoundedJsonBody(
+    req,
+    BODY_MAX_BYTES,
+    "body too large"
+  );
+  if (parsed instanceof Response) return parsed;
+  const body = parsed ?? {};
+  const name = bodyString(body, "name");
+  const nameError = worktreeNameError(name);
+  if (nameError) return textError(`invalid name: ${nameError}`, 400);
+  const branch = bodyString(body, "branch") || name;
+  const branchError = worktreeBranchError(branch);
+  if (branchError) return textError(`invalid branch: ${branchError}`, 400);
+  const root = serverWorktreeRoot(cwd2);
+  const path = join26(worktreeAddParent(root), name);
+  if (existsSync9(path)) return textError("path already exists", 409);
+  const exists = await localBranchExistsResultAsync(root, branch);
+  if (exists.error) return textError(exists.error, exists.status ?? 500);
+  const result = await worktreeAddResultAsync(root, {
+    path,
+    branch,
+    createBranch: !exists.exists
+  });
+  if (result.error) return textError(result.error, result.status ?? 500);
+  return actionJson({ path });
+}
+async function handleRemovePost(req, cwd2) {
+  const parsed = await parseBoundedJsonBody(
+    req,
+    BODY_MAX_BYTES,
+    "body too large"
+  );
+  if (parsed instanceof Response) return parsed;
+  const body = parsed ?? {};
+  const resolved = await resolveListedPath(cwd2, bodyString(body, "path"));
+  if (resolved instanceof Response) return resolved;
+  if (resolved.current) {
+    return textError("cannot remove the worktree this server is serving", 409);
+  }
+  const pruning = !existsSync9(resolved.path);
+  const result = pruning ? await worktreePruneResultAsync(resolved.root) : await worktreeRemoveResultAsync(resolved.root, {
+    path: resolved.path,
+    force: body.force === true
+  });
+  if (result.error) return textError(result.error, result.status ?? 500);
+  if (pruning) {
+    const after = await worktreeListResultAsync(resolved.root);
+    if (after.error) return textError(after.error, after.status ?? 500);
+    if (findWorktree(after.worktrees, resolved.path)) {
+      return textError(
+        resolved.ref.locked ? "the entry is locked, so git worktree prune left it in place; unlock it first" : "git worktree prune left the entry in place",
+        409
+      );
+    }
+  }
+  try {
+    await stopWorktreeServer(resolved.path);
+  } catch (error) {
+    throw errorWithCause(
+      "worktree was removed but its code-viewer server could not be stopped",
+      error
+    );
+  }
+  return actionJson({});
+}
+async function handleStopPost(req, cwd2) {
+  const parsed = await parseBoundedJsonBody(
+    req,
+    BODY_MAX_BYTES,
+    "body too large"
+  );
+  if (parsed instanceof Response) return parsed;
+  const body = parsed ?? {};
+  const resolved = await resolveListedPath(cwd2, bodyString(body, "path"));
+  if (resolved instanceof Response) return resolved;
+  if (resolved.current) {
+    return textError("cannot stop the server serving this worktree", 409);
+  }
+  await stopWorktreeServer(resolved.path);
+  return actionJson({});
+}
+async function handleOpenPost2(req, cwd2) {
+  const parsed = await parseBoundedJsonBody(
+    req,
+    BODY_MAX_BYTES,
+    "body too large"
+  );
+  if (parsed instanceof Response) return parsed;
+  const body = parsed ?? {};
+  const resolved = await resolveListedPath(cwd2, bodyString(body, "path"));
+  if (resolved instanceof Response) return resolved;
+  const result = await openWorktreeServer(resolved.path);
+  if (result.status === "missing") return textError("worktree is gone", 410);
+  if (result.status === "timeout") {
+    return textError("code-viewer did not come up in time", 504);
+  }
+  if (result.status === "error") {
+    console.error("[code-viewer] worktree open failed", result.error);
+    return textError(formatErrorDetail(result.error), 500);
+  }
+  return actionJson({ url: result.url, started: result.started });
+}
+function handleWorktreeRoute(req, url, cwd2, generation2, sideEffectAllowed) {
+  return dispatchRoutes(
+    req,
+    url,
+    {
+      "/_worktree/list": {
+        methods: ["GET"],
+        sideEffect: false,
+        handler: () => handleListGet(cwd2, generation2)
+      },
+      "/_worktree/diff": {
+        methods: ["GET"],
+        sideEffect: false,
+        handler: () => handleDiffGet(url, cwd2, generation2)
+      },
+      "/_worktree/add": {
+        methods: ["POST"],
+        sideEffect: true,
+        handler: () => handleAddPost(req, cwd2)
+      },
+      "/_worktree/remove": {
+        methods: ["POST"],
+        sideEffect: true,
+        handler: () => handleRemovePost(req, cwd2)
+      },
+      "/_worktree/open": {
+        methods: ["POST"],
+        sideEffect: true,
+        handler: () => handleOpenPost2(req, cwd2)
+      },
+      "/_worktree/stop": {
+        methods: ["POST"],
+        sideEffect: true,
+        handler: () => handleStopPost(req, cwd2)
+      }
+    },
+    sideEffectAllowed,
+    (res) => res,
+    (err) => handleError("worktree", "handle worktree request", err)
+  );
+}
+var BODY_MAX_BYTES, DIFF_MAX_HUNKS, DIFF_MAX_LINES;
+var init_handle5 = __esm({
+  "web-src/server/worktree/handle.ts"() {
+    init_error_detail();
+    init_worktree();
+    init_handle_shared();
+    init_file_cli();
+    init_git();
+    init_search_service();
+    init_list();
+    init_open();
+    BODY_MAX_BYTES = 8 * 1024;
+    DIFF_MAX_HUNKS = 200;
+    DIFF_MAX_LINES = 2e4;
+  }
+});
+
 // web-src/server/state-route.ts
 var state_route_exports = {};
 __export(state_route_exports, {
@@ -31595,14 +32824,14 @@ var init_state_route = __esm({
 // web-src/server/preview.ts
 var preview_exports = {};
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync8,
-  realpathSync as realpathSync8,
+  realpathSync as realpathSync9,
   statSync as statSync8,
   watch
 } from "node:fs";
-import { basename as basename5, dirname as dirname7, extname as extname2, join as join25, relative as relative8 } from "node:path";
+import { basename as basename6, dirname as dirname7, extname as extname2, join as join27, relative as relative9 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2; i < process.argv.length; i++) {
@@ -31657,7 +32886,7 @@ Examples:
         process.exit(1);
       }
       try {
-        cwd = realpathSync8(next);
+        cwd = realpathSync9(next);
         cwdWasExplicit = true;
       } catch {
         console.error("--cwd must point to an existing directory");
@@ -31726,7 +32955,7 @@ Examples:
 }
 function warnIfLegacyConfigPresent() {
   try {
-    if (existsSync9(join25(cwd, ".code-viewer.json"))) {
+    if (existsSync10(join27(cwd, ".code-viewer.json"))) {
       console.warn(
         "[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed."
       );
@@ -31833,8 +33062,8 @@ function staticFile(pathname) {
   }
   const spec = map[pathname];
   if (!spec) return null;
-  const full = join25(WEB_ROOT, spec[0]);
-  if (!existsSync9(full)) return text("not found", 404);
+  const full = join27(WEB_ROOT, spec[0]);
+  if (!existsSync10(full)) return text("not found", 404);
   return new Response(readFileSync8(full), {
     headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
   });
@@ -31928,7 +33157,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
       files: [],
       totals: { files: 0, additions: 0, deletions: 0 },
       range: "worktree .. worktree",
-      project: basename5(cwd),
+      project: basename6(cwd),
       branch: await currentBranchMetadata(),
       generation: responseGeneration
     };
@@ -31937,8 +33166,11 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
   const fullArgs = pathFilter ? [...extras, ...args, "--", pathFilter] : [...extras, ...args];
   const metaResult = await fileMetaResultAsync(fullArgs, cwd, false);
   const files = metaResult.files;
+  let metaError = metaResult.error;
   if (!metaResult.error && includeUntracked(range, refs)) {
-    files.push(...await untrackedMetaAsync(cwd));
+    const untracked = await untrackedMetaAsync(cwd);
+    files.push(...untracked.files);
+    metaError = untracked.error;
   }
   const filteredFiles = pathFilter ? files.filter(
     (file) => file.path === pathFilter || file.old_path === pathFilter
@@ -31971,10 +33203,10 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
     files: meta,
     totals,
     range: label || "HEAD",
-    project: basename5(cwd),
+    project: basename6(cwd),
     branch: await currentBranchMetadata(),
     generation: responseGeneration,
-    ...metaResult.error ? { error: metaResult.error } : {}
+    ...metaError ? { error: metaError } : {}
   };
 }
 async function handleDiffJson(url) {
@@ -32092,12 +33324,12 @@ function safeWorktreePath2(path) {
   return safeWorktreePath(currentSearchEnv(), path);
 }
 function worktreePath(path) {
-  return join25(cwd, path);
+  return join27(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
     try {
-      const realCwd = realpathSync8(cwd);
+      const realCwd = realpathSync9(cwd);
       if (isGitInternalPath(realCwd)) return null;
       return realCwd;
     } catch {
@@ -32117,11 +33349,11 @@ function worktreeFileMetadata(path, knownSize) {
   const full = safeWorktreePath2(path);
   if (!full) return {};
   try {
-    const stat3 = statSync8(full);
+    const stat4 = statSync8(full);
     return {
-      size: knownSize ?? stat3.size,
-      created_at: isoDate(stat3.birthtimeMs),
-      updated_at: isoDate(stat3.mtimeMs)
+      size: knownSize ?? stat4.size,
+      created_at: isoDate(stat4.birthtimeMs),
+      updated_at: isoDate(stat4.mtimeMs)
     };
   } catch {
     return {};
@@ -32141,10 +33373,10 @@ async function directoryMetadata(target, path) {
     const full = path === "" ? safeOpenWorktreePath("") : safeWorktreePath2(path);
     if (!full) return {};
     try {
-      const stat3 = statSync8(full);
+      const stat4 = statSync8(full);
       return {
-        created_at: isoDate(stat3.birthtimeMs),
-        updated_at: isoDate(stat3.mtimeMs)
+        created_at: isoDate(stat4.birthtimeMs),
+        updated_at: isoDate(stat4.mtimeMs)
       };
     } catch {
       return {};
@@ -32256,7 +33488,7 @@ async function handleTree(url) {
   return json2({
     ref: target,
     path,
-    project: basename5(cwd),
+    project: basename6(cwd),
     branch: await currentBranchMetadata(),
     entries: recursive ? entries.map(withStatus) : [
       ...await Promise.all(
@@ -32272,9 +33504,10 @@ async function handleTree(url) {
 }
 async function handleSettings() {
   return json2({
-    project: basename5(cwd),
+    project: basename6(cwd),
     branch: await currentBranchMetadata(),
     repo_web_url: cwdHasGitRepository ? await remoteWebUrlAsync(cwd) : null,
+    server: { pid: process.pid, root: cwd },
     scope: {
       omit_dirs_effective: scopeOmitDirNames,
       omit_dirs_built_in: DEFAULT_WORKTREE_OMIT_DIR_NAMES,
@@ -32429,7 +33662,7 @@ async function handleLog(url) {
 }
 function blamePathKey(p) {
   try {
-    const st = statSync8(join25(cwd, p));
+    const st = statSync8(join27(cwd, p));
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "missing";
@@ -32585,8 +33818,8 @@ async function handleFileDiff(url) {
 }
 function worktreeLineIndexSignature(full) {
   try {
-    const stat3 = statSync8(full);
-    return `size:${stat3.size}|mtime:${stat3.mtimeMs}|ctime:${stat3.ctimeMs}|ino:${stat3.ino || 0}`;
+    const stat4 = statSync8(full);
+    return `size:${stat4.size}|mtime:${stat4.mtimeMs}|ctime:${stat4.ctimeMs}|ino:${stat4.ino || 0}`;
   } catch {
     return null;
   }
@@ -32600,11 +33833,11 @@ async function getWorktreeLineIndex(full) {
     lineIndexCache.set(full, cached);
     return cached.index;
   }
-  const stat3 = statSync8(full);
-  if (stat3.size > LINE_INDEX_MAX_FILE_BYTES) return null;
+  const stat4 = statSync8(full);
+  if (stat4.size > LINE_INDEX_MAX_FILE_BYTES) return null;
   const index = await buildLineOffsetIndexFromStream(
     fileReadableStream(full),
-    stat3.size
+    stat4.size
   );
   lineIndexCache.delete(full);
   lineIndexCache.set(full, { signature, index });
@@ -32960,10 +34193,10 @@ async function handleUploadFiles(req) {
     if (file.size > MAX_UPLOAD_FILE_BYTES) return text("file too large", 413);
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES) return text("upload too large", 413);
-    const target = join25(realDir, safeName);
-    if (relative8(realDir, dirname7(target)) !== "")
+    const target = join27(realDir, safeName);
+    if (relative9(realDir, dirname7(target)) !== "")
       return text("invalid filename", 400);
-    if (existsSync9(target)) return text("file exists", 409);
+    if (existsSync10(target)) return text("file exists", 409);
     uploads.push({ file, name: safeName, target });
   }
   try {
@@ -33111,8 +34344,8 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join25(parent, name);
-  if (existsSync9(target)) return text("already exists", 409);
+  const target = join27(parent, name);
+  if (existsSync10(target)) return text("already exists", 409);
   try {
     mkdirSync5(target, { recursive: false });
   } catch (error) {
@@ -33211,7 +34444,7 @@ async function handleMcp(req) {
 function journalSse(kind, id) {
   sendSse("journal", JSON.stringify({ kind, id }));
 }
-function bodyString(body, key) {
+function bodyString2(body, key) {
   const value = body[key];
   return typeof value === "string" ? value : void 0;
 }
@@ -33273,9 +34506,9 @@ async function handleJournal(req) {
         const result = addDailyJournalEntry(
           state,
           {
-            date: bodyString(body, "date") || "",
-            title: bodyString(body, "title"),
-            body: bodyString(body, "body") || "",
+            date: bodyString2(body, "date") || "",
+            title: bodyString2(body, "title"),
+            body: bodyString2(body, "body") || "",
             labels: body.labels,
             source: body.source === "ai" ? "ai" : "user"
           },
@@ -33288,30 +34521,30 @@ async function handleJournal(req) {
       return json2({ ok: true, entry, generation });
     }
     if (action === "list-github-issues") {
-      const label = bodyString(body, "label");
+      const label = bodyString2(body, "label");
       const labels = bodyStringList(body, "labels");
       if (label) labels.push(label);
       const issues = await readGithubIssueListAsync({
         cwd,
-        repo: bodyString(body, "repo"),
+        repo: bodyString2(body, "repo"),
         labels,
-        search: bodyString(body, "search"),
-        state: normalizeGithubIssueListState(bodyString(body, "state")),
+        search: bodyString2(body, "search"),
+        state: normalizeGithubIssueListState(bodyString2(body, "state")),
         limit: normalizeGithubIssueListLimit(bodyNumber(body, "limit"))
       });
       return json2({ ok: true, issues, generation });
     }
     if (action === "update-entry") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const entry = await updateDailyJournalState(cwd, (state) => {
         const result = updateDailyJournalEntry(
           state,
           id,
           {
-            date: bodyString(body, "date"),
-            title: bodyString(body, "title"),
-            body: bodyString(body, "body"),
+            date: bodyString2(body, "date"),
+            title: bodyString2(body, "title"),
+            body: bodyString2(body, "body"),
             labels: body.labels,
             source: body.source === "ai" ? "ai" : void 0
           },
@@ -33324,7 +34557,7 @@ async function handleJournal(req) {
       return json2({ ok: true, entry, generation });
     }
     if (action === "delete-entry") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const removed = await updateDailyJournalState(cwd, (state) => {
         const result = deleteDailyJournalEntry(state, id);
@@ -33339,15 +34572,15 @@ async function handleJournal(req) {
           state,
           {
             issue_number: bodyNumber(body, "issue_number") || 0,
-            repo: bodyString(body, "repo"),
-            title: bodyString(body, "title"),
-            url: bodyString(body, "url"),
-            memo_label: bodyString(body, "memo_label"),
+            repo: bodyString2(body, "repo"),
+            title: bodyString2(body, "title"),
+            url: bodyString2(body, "url"),
+            memo_label: bodyString2(body, "memo_label"),
             status: bodyTaskStatus(body, "status"),
             priority: bodyTaskPriority(body, "priority"),
             labels: body.labels,
-            before_id: bodyString(body, "before_id"),
-            after_id: bodyString(body, "after_id"),
+            before_id: bodyString2(body, "before_id"),
+            after_id: bodyString2(body, "after_id"),
             position: bodyNumber(body, "position")
           },
           now
@@ -33369,16 +34602,16 @@ async function handleJournal(req) {
         const result = addJournalTask(
           state,
           {
-            title: bodyString(body, "title") || "",
-            body: bodyString(body, "body"),
+            title: bodyString2(body, "title") || "",
+            body: bodyString2(body, "body"),
             status: bodyTaskStatus(body, "status"),
             priority: bodyTaskPriority(body, "priority"),
             labels: body.labels,
-            due_date: bodyString(body, "due_date"),
-            source_date: bodyString(body, "source_date"),
-            journal_entry_id: bodyString(body, "journal_entry_id"),
-            before_id: bodyString(body, "before_id"),
-            after_id: bodyString(body, "after_id"),
+            due_date: bodyString2(body, "due_date"),
+            source_date: bodyString2(body, "source_date"),
+            journal_entry_id: bodyString2(body, "journal_entry_id"),
+            before_id: bodyString2(body, "before_id"),
+            after_id: bodyString2(body, "after_id"),
             position: bodyNumber(body, "position")
           },
           now
@@ -33390,21 +34623,21 @@ async function handleJournal(req) {
       return json2({ ok: true, task, generation });
     }
     if (action === "update-task") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const task = await updateJournalTaskState(cwd, (state) => {
         const result = updateJournalTask(
           state,
           id,
           {
-            title: bodyString(body, "title"),
-            body: bodyString(body, "body"),
+            title: bodyString2(body, "title"),
+            body: bodyString2(body, "body"),
             status: bodyTaskStatus(body, "status"),
             priority: bodyTaskPriority(body, "priority"),
             labels: body.labels,
-            due_date: body.due_date === null ? null : bodyString(body, "due_date"),
-            source_date: body.source_date === null ? null : bodyString(body, "source_date"),
-            journal_entry_id: body.journal_entry_id === null ? null : bodyString(body, "journal_entry_id")
+            due_date: body.due_date === null ? null : bodyString2(body, "due_date"),
+            source_date: body.source_date === null ? null : bodyString2(body, "source_date"),
+            journal_entry_id: body.journal_entry_id === null ? null : bodyString2(body, "journal_entry_id")
           },
           now
         );
@@ -33415,7 +34648,7 @@ async function handleJournal(req) {
       return json2({ ok: true, task, generation });
     }
     if (action === "move-task") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const task = await updateJournalTaskState(cwd, (state) => {
         const result = moveJournalTask(
@@ -33423,8 +34656,8 @@ async function handleJournal(req) {
           id,
           {
             status: bodyTaskStatus(body, "status"),
-            before_id: bodyString(body, "before_id"),
-            after_id: bodyString(body, "after_id"),
+            before_id: bodyString2(body, "before_id"),
+            after_id: bodyString2(body, "after_id"),
             position: bodyNumber(body, "position")
           },
           now
@@ -33436,14 +34669,14 @@ async function handleJournal(req) {
       return json2({ ok: true, task, generation });
     }
     if (action === "claim-task") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const task = await updateJournalTaskState(cwd, (state) => {
         const result = claimJournalTask(
           state,
           id,
           {
-            by: bodyString(body, "by"),
+            by: bodyString2(body, "by"),
             lease_minutes: bodyNumber(body, "lease_minutes"),
             wip_limit: bodyNumber(body, "wip_limit")
           },
@@ -33456,15 +34689,15 @@ async function handleJournal(req) {
       return json2({ ok: true, task, generation });
     }
     if (action === "complete-task") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const task = await updateJournalTaskState(cwd, (state) => {
         const result = completeJournalTask(
           state,
           id,
           {
-            by: bodyString(body, "by"),
-            note: bodyString(body, "note"),
+            by: bodyString2(body, "by"),
+            note: bodyString2(body, "note"),
             source: body.source === "user" ? "user" : "ai"
           },
           now
@@ -33476,7 +34709,7 @@ async function handleJournal(req) {
       return json2({ ok: true, task, generation });
     }
     if (action === "delete-task") {
-      const id = bodyString(body, "id") || "";
+      const id = bodyString2(body, "id") || "";
       if (!id) return text("invalid id", 400);
       const removed = await updateJournalTaskState(cwd, (state) => {
         const result = deleteJournalTask(state, id);
@@ -33655,12 +34888,24 @@ function closeSseClients() {
     }
   }
 }
+function removeOwnServerRegistry() {
+  registryCleanupAttempted = true;
+  removeServerRegistry(cwd, process.pid);
+}
 async function shutdown(exitCode = 0) {
   if (shuttingDown) {
     process.exit(1);
   }
   shuttingDown = true;
-  removeServerRegistry(cwd, process.pid);
+  try {
+    removeOwnServerRegistry();
+  } catch (error) {
+    exitCode = 1;
+    console.error(
+      `code-viewer registry cleanup failed:
+${formatErrorDetail(error)}`
+    );
+  }
   closeSseClients();
   try {
     const [{ closeShellStreams: closeShellStreams2 }, { closeAllShellSessions: closeAllShellSessions2 }] = await Promise.all([shellHandleModule, Promise.resolve().then(() => (init_session(), session_exports))]);
@@ -33733,7 +34978,7 @@ function restartWorktreeWatch() {
   }
   worktreeWatch = startScopedWorktreeWatch();
 }
-var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT, PREVIEW_LINES_DEFAULT, WATCHED_ASSET_FILES, SIZE_SMALL, SIZE_MEDIUM, SIZE_LARGE, LINE_INDEX_MIN_START, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES, SAFE_UPLOAD_EXTENSIONS, generation, cwd, cliArgs, listenPort, openAfterStart, commandOverrides, cwdWasExplicit, cwdHasGitRepository, scopeOmitDirNames, scopeOmitDirCliOverride, scopeExcludeNames, scopeWatchLimit, uploadEnabled, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX, metaCache, diffMetaRequestSequence, latestDiffMetaRequest, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes, safePath, MCP_MAX_BODY_BYTES, MCP_INSTRUCTIONS, JournalRequestError, isCodeViewerInternalPath, watchLimitReached, databaseHandleModule, tmuxHandleModule, shellHandleModule, agentHandleModule, server, worktreeWatch, shuttingDown;
+var WEB_ROOT, VERSION, DEFAULT_ARGS, PREVIEW_HUNKS_DEFAULT, PREVIEW_LINES_DEFAULT, WATCHED_ASSET_FILES, SIZE_SMALL, SIZE_MEDIUM, SIZE_LARGE, LINE_INDEX_MIN_START, LINE_INDEX_MAX_FILE_BYTES, BLOB_LINE_CACHE_MAX_BYTES, MAX_UPLOAD_FILE_BYTES, MAX_UPLOAD_TOTAL_BYTES, MAX_UPLOAD_BODY_BYTES, MAX_UPLOAD_FILES, SAFE_UPLOAD_EXTENSIONS, generation, cwd, cliArgs, listenPort, openAfterStart, commandOverrides, cwdWasExplicit, cwdHasGitRepository, scopeOmitDirNames, scopeOmitDirCliOverride, scopeExcludeNames, scopeWatchLimit, uploadEnabled, enc, sseClients, sseKeepalives, fileCache, blameCache, BLAME_CACHE_MAX, metaCache, diffMetaRequestSequence, latestDiffMetaRequest, fileListCache, lineIndexCache, blobLineIndexCache, blobBytesCache, blobLineCacheBytes, safePath, MCP_MAX_BODY_BYTES, MCP_INSTRUCTIONS, JournalRequestError, isCodeViewerInternalPath, watchLimitReached, databaseHandleModule, tmuxHandleModule, shellHandleModule, agentHandleModule, worktreeHandleModule, server, worktreeWatch, shuttingDown, registryCleanupAttempted;
 var init_preview = __esm({
   async "web-src/server/preview.ts"() {
     init_directory_name();
@@ -33763,8 +35008,8 @@ var init_preview = __esm({
     init_state_store();
     init_watch_supervisor();
     init_worktree_watcher();
-    WEB_ROOT = join25(ROOT, "web");
-    VERSION = JSON.parse(readFileSync8(join25(ROOT, "package.json"), "utf8")).version;
+    WEB_ROOT = join27(ROOT, "web");
+    VERSION = JSON.parse(readFileSync8(join27(ROOT, "package.json"), "utf8")).version;
     DEFAULT_ARGS = ["HEAD"];
     PREVIEW_HUNKS_DEFAULT = 3;
     PREVIEW_LINES_DEFAULT = 1200;
@@ -33859,6 +35104,7 @@ var init_preview = __esm({
     tmuxHandleModule = Promise.resolve().then(() => (init_handle2(), handle_exports2));
     shellHandleModule = Promise.resolve().then(() => (init_handle3(), handle_exports3));
     agentHandleModule = Promise.resolve().then(() => (init_handle4(), handle_exports4));
+    worktreeHandleModule = Promise.resolve().then(() => (init_handle5(), handle_exports5));
     server = await startServer({
       hostname: "127.0.0.1",
       port: listenPort,
@@ -33873,7 +35119,8 @@ var init_preview = __esm({
           return handleDoctor({
             cwd,
             scopeOmitDirNames,
-            listenPort
+            listenPort,
+            signal: req.signal
           });
         if (url.pathname === "/_tree") return await handleTree(url);
         if (url.pathname === "/_files") return await handleFiles2(url);
@@ -33912,6 +35159,17 @@ var init_preview = __esm({
           );
           if (tmuxResponse) return tmuxResponse;
         }
+        if (url.pathname.startsWith("/_worktree/")) {
+          const { handleWorktreeRoute: handleWorktreeRoute2 } = await worktreeHandleModule;
+          const worktreeResponse = await handleWorktreeRoute2(
+            req,
+            url,
+            cwd,
+            generation,
+            sideEffectRequestAllowed2
+          );
+          if (worktreeResponse) return worktreeResponse;
+        }
         if (url.pathname.startsWith("/_shell/")) {
           const { handleShellRoute: handleShellRoute2 } = await shellHandleModule;
           const shellResponse = await handleShellRoute2(
@@ -34012,6 +35270,7 @@ data: ${watchLimitReached}
     });
     worktreeWatch = null;
     shuttingDown = false;
+    registryCleanupAttempted = false;
     process.on("uncaughtException", (error) => {
       console.error(
         "[code-viewer] uncaught exception (server kept running):",
@@ -34025,7 +35284,17 @@ data: ${watchLimitReached}
       );
     });
     process.on("exit", () => {
-      removeServerRegistry(cwd, process.pid);
+      if (!registryCleanupAttempted) {
+        try {
+          removeOwnServerRegistry();
+        } catch (error) {
+          process.exitCode = 1;
+          console.error(
+            `code-viewer registry cleanup failed:
+${formatErrorDetail(error)}`
+          );
+        }
+      }
       closeSseClients();
       worktreeWatch?.close();
     });