@youtyan/code-viewer 0.8.2 → 0.8.4

package/dist/code-viewer.js

@@ -94,6 +94,157 @@ var init_sqlite_driver = __esm(() => {
   NPX_CACHE_GUIDE = 'Stale npx cache likely contains a binary compiled for a different Node.js version. Fix: `rm -rf ~/.npm/_npx` (macOS / Linux) or `Remove-Item -Recurse -Force "$(npm config get cache)\\_npx"` (Windows), ' + "then re-run `npx -y @youtyan/code-viewer@latest …`.";
 });
 
+// web-src/core/id.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function bytesToBase36(bytes) {
+  return Array.from(bytes, (b) => BASE36_ALPHABET[b % BASE36_ALPHABET.length]).join("");
+}
+function randomBase36(length) {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    const bytes = new Uint8Array(length);
+    cryptoApi.getRandomValues(bytes);
+    return bytesToBase36(bytes);
+  }
+  return Math.random().toString(36).slice(2, 2 + length).padEnd(length, "0");
+}
+function makeId(prefix) {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === "function") {
+    return `${prefix}-${cryptoApi.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  }
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    const bytes = new Uint8Array(8);
+    cryptoApi.getRandomValues(bytes);
+    return `${prefix}-${bytesToHex(bytes)}`;
+  }
+  return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function makeTimedId(prefix) {
+  const time = Date.now().toString(36);
+  const random = randomBase36(6);
+  return `${prefix}-${time}${random}`;
+}
+var BASE36_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+// web-src/core/routes.ts
+function assertNever(value) {
+  throw new Error(`unhandled route: ${JSON.stringify(value)}`);
+}
+function parseLineTarget(value) {
+  const raw = value || "";
+  const range = /^(\d+)-(\d+)$/.exec(raw);
+  if (range) {
+    const a = Number(range[1]);
+    const b = Number(range[2]);
+    const start = Math.min(a, b);
+    const end = Math.max(a, b);
+    if (start > 0)
+      return { start, end };
+    return;
+  }
+  const line = Number(raw);
+  return Number.isInteger(line) && line > 0 ? line : undefined;
+}
+function formatLineTarget(line) {
+  return typeof line === "number" ? String(line) : `${line.start}-${line.end}`;
+}
+function buildRoute(route) {
+  switch (route.screen) {
+    case "repo": {
+      const params = new URLSearchParams;
+      if (route.ref && route.ref !== "worktree")
+        params.set("ref", route.ref);
+      if (route.path)
+        params.set("path", route.path);
+      const qs = params.toString();
+      return `/${qs ? `?${qs}` : ""}`;
+    }
+    case "file":
+      if (route.view === "blob") {
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=blob" + (route.preview ? "&preview=1" : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
+      }
+      if (route.view === "blame") {
+        const ref = route.ref || "worktree";
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(ref) + "&view=blame" + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+      }
+      if (route.view === "history") {
+        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=history" + (route.commit ? `&commit=${encodeURIComponent(route.commit)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
+      }
+      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 "help": {
+      const params = new URLSearchParams;
+      if (route.lang && route.lang !== "en")
+        params.set("lang", route.lang);
+      if (route.section && route.section !== "overview")
+        params.set("section", route.section);
+      const qs = params.toString();
+      return `/help${qs ? `?${qs}` : ""}`;
+    }
+    case "history": {
+      const params = new URLSearchParams;
+      if (route.ref && route.ref !== "HEAD")
+        params.set("ref", route.ref);
+      if (route.commit)
+        params.set("commit", route.commit);
+      const qs = params.toString();
+      return `/history${qs ? `?${qs}` : ""}`;
+    }
+    case "journal": {
+      const params = new URLSearchParams;
+      if (route.tab && route.tab !== "journal")
+        params.set("tab", route.tab);
+      if (route.date)
+        params.set("date", route.date);
+      if (route.label)
+        params.set("label", route.label);
+      if (route.task)
+        params.set("task", route.task);
+      const qs = params.toString();
+      return `/journal${qs ? `?${qs}` : ""}`;
+    }
+    case "database": {
+      const params = new URLSearchParams;
+      if (route.db)
+        params.set("db", route.db);
+      if (route.schema)
+        params.set("schema", route.schema);
+      if (route.table)
+        params.set("table", route.table);
+      if (route.tab)
+        params.set("tab", route.tab);
+      if (route.diffBefore)
+        params.set("diffBefore", route.diffBefore);
+      if (route.diffAfter)
+        params.set("diffAfter", route.diffAfter);
+      const qs = params.toString();
+      return `/database${qs ? `?${qs}` : ""}`;
+    }
+    case "unknown":
+      return "/todif?from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree");
+    default:
+      return assertNever(route);
+  }
+}
+var SPA_PATHS, APP_ENTRY_PATHS;
+var init_routes = __esm(() => {
+  SPA_PATHS = [
+    "/todif",
+    "/todiff",
+    "/file",
+    "/help",
+    "/history",
+    "/journal",
+    "/database",
+    "/doctor"
+  ];
+  APP_ENTRY_PATHS = ["/", "/index.html"];
+});
+
 // web-src/server/json-store.ts
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
@@ -205,6 +356,11 @@ function createJsonFileStore(options) {
 }
 var init_json_store = () => {};
 
+// web-src/server/ordered-insert.ts
+function orderedInsertOptionCount(input) {
+  return (input.before_id ? 1 : 0) + (input.after_id ? 1 : 0) + (input.position !== undefined ? 1 : 0);
+}
+
 // web-src/server/annotations.ts
 import { join } from "node:path";
 function annotationsFilePath(root) {
@@ -214,9 +370,7 @@ function emptyAnnotationsState() {
   return { version: 1, sessions: [] };
 }
 function makeAnnotationId(prefix) {
-  const random = Math.random().toString(36).slice(2, 8);
-  const time = Date.now().toString(36);
-  return `${prefix}-${time}${random}`;
+  return makeTimedId(prefix);
 }
 function normalizeLineRange(raw) {
   if (!raw || typeof raw !== "object")
@@ -229,16 +383,10 @@ function normalizeLineRange(raw) {
   return { start, end: endValue };
 }
 function parseAnnotationLine(raw) {
-  const range = /^(\d+)-(\d+)$/.exec(raw);
-  if (range) {
-    const a = Number(range[1]);
-    const b = Number(range[2]);
-    const start = Math.min(a, b);
-    const end = Math.max(a, b);
-    return start > 0 ? { start, end } : undefined;
-  }
-  const line = Number(raw);
-  return Number.isInteger(line) && line > 0 ? { start: line, end: line } : undefined;
+  const target = parseLineTarget(raw);
+  if (target === undefined)
+    return;
+  return typeof target === "number" ? { start: target, end: target } : target;
 }
 function normalizeRange(raw) {
   const from = raw && typeof raw === "object" && typeof raw.from === "string" ? raw.from || "HEAD" : "HEAD";
@@ -441,11 +589,8 @@ function startAnnotationSession(state, title, now, id = makeAnnotationId("s")) {
     session
   };
 }
-function insertOptionCount(input) {
-  return (input.before_id ? 1 : 0) + (input.after_id ? 1 : 0) + (input.position !== undefined ? 1 : 0);
-}
 function entryInsertIndex(entries, input) {
-  if (insertOptionCount(input) > 1)
+  if (orderedInsertOptionCount(input) > 1)
     return { ok: false, error: "use only one of before, after, or position" };
   if (input.before_id) {
     const index = entries.findIndex((entry) => entry.id === input.before_id);
@@ -471,7 +616,7 @@ function entryInsertIndex(entries, input) {
 function findSessionByEntryId(sessions, entryId) {
   return sessions.find((session) => session.entries.some((entry) => entry.id === entryId));
 }
-function addAnnotationEntry(state, input, now, makeId = makeAnnotationId) {
+function addAnnotationEntry(state, input, now, makeId2 = makeAnnotationId) {
   const target = normalizeAnnotationTarget(input.target);
   if (target?.kind === "database" && !target.db)
     return { ok: false, error: "database annotation requires db" };
@@ -514,13 +659,13 @@ function addAnnotationEntry(state, input, now, makeId = makeAnnotationId) {
     session = sessions[sessions.length - 1];
   }
   if (!session) {
-    const started = startAnnotationSession(state, input.session_title || "", now, makeId("s"));
+    const started = startAnnotationSession(state, input.session_title || "", now, makeId2("s"));
     sessions = started.state.sessions;
     session = started.session;
     createdSession = true;
   }
   const entry = {
-    id: makeId("a"),
+    id: makeId2("a"),
     created_at: now,
     path,
     range: normalizeRange(input.range),
@@ -554,7 +699,7 @@ function addAnnotationEntry(state, input, now, makeId = makeAnnotationId) {
   };
 }
 function moveAnnotationEntry(state, id, input) {
-  if (insertOptionCount(input) !== 1)
+  if (orderedInsertOptionCount(input) !== 1)
     return { ok: false, error: "move requires before, after, or position" };
   const sourceSession = findSessionByEntryId(state.sessions, id);
   const entry = sourceSession?.entries.find((e) => e.id === id);
@@ -654,6 +799,7 @@ function deleteAnnotationById(state, id) {
 }
 var CODE_VIEWER_DIR = ".code-viewer", ANNOTATIONS_FILE_NAME = "annotations.json", ANNOTATION_BODY_MAX_BYTES, ANNOTATION_TITLE_MAX_CHARS = 300, MAX_ANNOTATIONS_JSON_BYTES = 5000000, annotationsStore;
 var init_annotations = __esm(() => {
+  init_routes();
   init_json_store();
   ANNOTATION_BODY_MAX_BYTES = 64 * 1024;
   annotationsStore = createJsonFileStore({
@@ -835,6 +981,44 @@ var init_command_resolver = __esm(() => {
   activeOverrides = new Map;
 });
 
+// web-src/server/cache.ts
+import { lstatSync } from "node:fs";
+import { join as join3 } from "node:path";
+function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
+  return !!cached && now - cached.storedAt <= ttlMs;
+}
+function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
+  cache.set(key, { ...value, storedAt: now });
+  while (cache.size > maxEntries) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+function worktreeFileSignature(path, cwd) {
+  try {
+    const stats = lstatSync(join3(cwd, path));
+    const inode = "ino" in stats ? stats.ino : 0;
+    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
+  } catch {
+    return "state:missing";
+  }
+}
+function fileDiffCacheKey(options) {
+  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
+  if (options.isUntracked && !worktreeTarget) {
+    throw new Error("untracked file diffs require a worktree range");
+  }
+  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
+  if (options.isUntracked) {
+    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
+  }
+  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
+}
+var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
+var init_cache = () => {};
+
 // web-src/server/name-pattern.ts
 function parseGlobSegment(pattern) {
   const matchers = [];
@@ -947,6 +1131,21 @@ import {
 } from "node:http";
 import { Readable } from "node:stream";
 function runSync(args, cwd, options = {}) {
+  const proc = runBytesSync(args, cwd, options);
+  return {
+    code: proc.code,
+    stdout: new TextDecoder().decode(proc.stdout),
+    stderr: proc.stderr
+  };
+}
+function runAsync(args, cwd, options = {}) {
+  return runBytesAsync(args, cwd, options).then((proc) => ({
+    code: proc.code,
+    stdout: new TextDecoder().decode(proc.stdout),
+    stderr: proc.stderr
+  }));
+}
+function runBytesSync(args, cwd, options = {}) {
   const proc = spawnSync(args[0], args.slice(1), {
     cwd,
     encoding: "buffer",
@@ -957,17 +1156,10 @@ function runSync(args, cwd, options = {}) {
   });
   return {
     code: proc.status ?? (proc.error ? 1 : 0),
-    stdout: new TextDecoder().decode(proc.stdout || new Uint8Array),
+    stdout: new Uint8Array(proc.stdout || new Uint8Array),
     stderr: appendProcessError(new TextDecoder().decode(proc.stderr || new Uint8Array), proc.error)
   };
 }
-function runAsync(args, cwd, options = {}) {
-  return runBytesAsync(args, cwd, options).then((proc) => ({
-    code: proc.code,
-    stdout: new TextDecoder().decode(proc.stdout),
-    stderr: proc.stderr
-  }));
-}
 function runBytesAsync(args, cwd, options = {}) {
   const maxBuffer = options.maxBuffer ?? 64 * 1024 * 1024;
   return new Promise((resolve) => {
@@ -1217,14 +1409,16 @@ var init_runtime = () => {};
 import {
   closeSync,
   existsSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   openSync,
   readdirSync,
   readFileSync,
+  readlinkSync,
   readSync,
+  realpathSync as realpathSync2,
   statSync as statSync2
 } from "node:fs";
-import { join as join3 } from "node:path";
+import { dirname as dirname3, join as join4, posix, relative as relative2 } from "node:path";
 function normalizeBlameRef(ref, base) {
   const rawRef = ref || "worktree";
   if (base === "worktree" && rawRef !== "worktree") {
@@ -1322,12 +1516,76 @@ async function statusPorcelainForPathAsync(path, cwd) {
     error: gitFailureMessage(res, "git status failed")
   };
 }
+async function repoStatusMapAsync(cwd, now = Date.now()) {
+  const cached = repoStatusMapCache.get(cwd);
+  if (cacheFresh(cached, now))
+    return cached.map;
+  const map = new Map;
+  const res = await runGitAsync([
+    "git",
+    "-c",
+    "core.quotepath=false",
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ], cwd);
+  if (res.code !== 0)
+    return map;
+  const records = res.stdout.split("\x00").filter(Boolean);
+  for (let i = 0;i < records.length; i++) {
+    const record = records[i];
+    const xy = record.slice(0, 2);
+    const path = record.slice(3);
+    if (!path)
+      continue;
+    if (xy === "??") {
+      map.set(path, "A");
+      continue;
+    }
+    if (xy[0] === "R" || xy[0] === "C" || xy[1] === "R" || xy[1] === "C") {
+      i++;
+      map.set(path, "R");
+      continue;
+    }
+    const code = xy[0] !== " " ? xy[0] : xy[1];
+    if (code && code !== " ")
+      map.set(path, code);
+  }
+  setTimedCacheEntry(repoStatusMapCache, cwd, { map }, now);
+  return map;
+}
 function show(ref, path, cwd) {
   return run(["git", "show", `${ref}:${path}`], cwd);
 }
 function showAsync(ref, path, cwd) {
   return runGitAsync(["git", "show", `${ref}:${path}`], cwd);
 }
+function resolveSymlinkPath(linkPath, target) {
+  if (!target || target.startsWith("/") || target.includes("\x00"))
+    return null;
+  const baseDir = dirname3(linkPath);
+  const combined = baseDir === "." ? target : `${baseDir}/${target}`;
+  const normalized = posix.normalize(combined);
+  if (normalized === "." || normalized === "")
+    return "";
+  if (normalized === ".." || normalized.startsWith("../"))
+    return null;
+  return normalized;
+}
+async function gitSymlinkTargetMetadataAsync(ref, path, cwd) {
+  const res = await showAsync(ref, path, cwd);
+  if (res.code !== 0)
+    return { symlink_target_type: "missing" };
+  const target = res.stdout;
+  const resolved = resolveSymlinkPath(path, target);
+  if (resolved === null)
+    return { symlink_target: target, symlink_target_type: "missing" };
+  const type = await runGitAsync(["git", "cat-file", "-t", `${ref}:${resolved}`], cwd);
+  const kind = type.stdout.trim();
+  const symlink_target_type = kind === "tree" ? "tree" : kind === "blob" ? "blob" : "missing";
+  return symlink_target_type === "missing" ? { symlink_target: target, symlink_target_type } : { symlink_target: target, symlink_target_type, resolved_path: resolved };
+}
 function catFileBlobStream(oid, cwd) {
   return spawnStream(resolveGitArgs(["git", "cat-file", "blob", oid]), cwd);
 }
@@ -1958,7 +2216,7 @@ function isGitInternalPath(path) {
   return pathHasSegment(path, ".git");
 }
 function syntheticUncommittedBlameFromWorktree(cwd, path) {
-  const filePath = join3(cwd, path);
+  const filePath = join4(cwd, path);
   try {
     const stat = statSync2(filePath);
     if (!stat.isFile())
@@ -2217,7 +2475,7 @@ function omittedWorktreeDirectoryReason(name, omitDirNames) {
   return omitDirNames.matches(name) ? "heavy" : undefined;
 }
 function worktreeSubmodulePaths(cwd) {
-  if (!existsSync(join3(cwd, ".gitmodules")))
+  if (!existsSync(join4(cwd, ".gitmodules")))
     return new Set;
   const res = run(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
   if (res.code !== 0)
@@ -2229,7 +2487,7 @@ function worktreeSubmodulePaths(cwd) {
   }).filter(Boolean));
 }
 async function worktreeSubmodulePathsAsync(cwd) {
-  if (!existsSync(join3(cwd, ".gitmodules")))
+  if (!existsSync(join4(cwd, ".gitmodules")))
     return new Set;
   const res = await runGitAsync(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
   if (res.code !== 0)
@@ -2240,7 +2498,48 @@ async function worktreeSubmodulePathsAsync(cwd) {
     return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
   }).filter(Boolean));
 }
-function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, excludeNames, submodulePaths) {
+function realpathWithinRepo(cwd, full, allowRoot) {
+  try {
+    const realCwd = realpathSync2(cwd);
+    const realFull = realpathSync2(full);
+    const rel = relative2(realCwd, realFull);
+    if (rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
+      return null;
+    if (rel === "" && !allowRoot)
+      return null;
+    return realFull;
+  } catch {
+    return null;
+  }
+}
+function resolveWorktreeSymlinkTarget(cwd, full) {
+  let symlink_target;
+  try {
+    symlink_target = readlinkSync(full);
+  } catch {
+    symlink_target = undefined;
+  }
+  let symlink_target_type = "missing";
+  if (realpathWithinRepo(cwd, full, false) !== null) {
+    try {
+      const stat = statSync2(full);
+      symlink_target_type = stat.isDirectory() ? "tree" : stat.isFile() ? "blob" : "missing";
+    } catch {
+      symlink_target_type = "missing";
+    }
+  }
+  return symlink_target === undefined ? { symlink_target_type } : { symlink_target, symlink_target_type };
+}
+function recursiveWorktreeFileEntry(cwd, full, name, path, isSymlink) {
+  const symlinkInfo = isSymlink ? resolveWorktreeSymlinkTarget(cwd, full) : null;
+  return {
+    name,
+    path,
+    type: "blob",
+    ...symlinkInfo ? { is_symlink: true, ...symlinkInfo } : {}
+  };
+}
+function worktreeEntryFromDirent(cwd, base, dir, name, isDirectory, isSymlink, omitDirNames, excludeNames, submodulePaths) {
   if (excludeNames.matches(name))
     return {
       name,
@@ -2248,10 +2547,18 @@ function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, exc
       type: isDirectory ? "tree" : "blob"
     };
   const entryPath = base ? `${base}/${name}` : name;
-  const type = isDirectory ? hasDotGitEntry(join3(dir, name)) ? "commit" : "tree" : "blob";
+  const symlinkInfo = isSymlink ? resolveWorktreeSymlinkTarget(cwd, join4(dir, name)) : null;
+  const resolvedIsDirectory = symlinkInfo ? symlinkInfo.symlink_target_type === "tree" : isDirectory;
+  const type = symlinkInfo && symlinkInfo.symlink_target_type === "missing" ? "blob" : resolvedIsDirectory ? hasDotGitEntry(join4(dir, name)) ? "commit" : "tree" : "blob";
   const omittedReason = type === "tree" ? omittedWorktreeDirectoryReason(name, omitDirNames) : undefined;
   const submodule = type === "commit" && submodulePaths.has(entryPath) ? true : undefined;
-  const baseEntry = submodule ? { name, path: entryPath, type, submodule } : { name, path: entryPath, type };
+  const baseEntry = {
+    name,
+    path: entryPath,
+    type,
+    ...submodule ? { submodule } : {},
+    ...symlinkInfo ? { is_symlink: true, ...symlinkInfo } : {}
+  };
   return omittedReason ? {
     ...baseEntry,
     children_omitted: true,
@@ -2260,14 +2567,16 @@ function worktreeEntryFromDirent(base, dir, name, isDirectory, omitDirNames, exc
 }
 function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
-  const root = join3(cwd, base);
+  const root = join4(cwd, base);
+  if (realpathWithinRepo(cwd, root, true) === null)
+    return [];
   const omitDirNameSet = compileNamePatterns(omitDirNames);
   const excludeNameSet = compileNamePatterns(excludeNames);
   const submodulePaths = worktreeSubmodulePaths(cwd);
   let directEntries;
   try {
     const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(cwd, base, root, entry.name, entry.isDirectory(), entry.isSymbolicLink(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
   } catch {
     return [];
   }
@@ -2307,7 +2616,7 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
       if (excludeNameSet.matches(entry.name))
         continue;
       const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
         if (omittedReason) {
@@ -2325,11 +2634,7 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
           continue;
         walk(full, entryPath, depth + 1);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
-        if (!pushRecursiveEntry({
-          name: entry.name,
-          path: entryPath,
-          type: "blob"
-        }))
+        if (!pushRecursiveEntry(recursiveWorktreeFileEntry(cwd, full, entry.name, entryPath, entry.isSymbolicLink())))
           return;
       }
     }
@@ -2339,14 +2644,16 @@ function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_
 }
 async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
-  const root = join3(cwd, base);
+  const root = join4(cwd, base);
+  if (realpathWithinRepo(cwd, root, true) === null)
+    return [];
   const omitDirNameSet = compileNamePatterns(omitDirNames);
   const excludeNameSet = compileNamePatterns(excludeNames);
   const submodulePaths = await worktreeSubmodulePathsAsync(cwd);
   let directEntries;
   try {
     const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
+    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(cwd, base, root, entry.name, entry.isDirectory(), entry.isSymbolicLink(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
   } catch {
     return [];
   }
@@ -2394,7 +2701,7 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
       if (excludeNameSet.matches(entry.name))
         continue;
       const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const full = join3(dir, entry.name);
+      const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
         const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
         if (omittedReason) {
@@ -2412,11 +2719,7 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
           continue;
         await walk(full, entryPath, depth + 1);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
-        if (!pushRecursiveEntry({
-          name: entry.name,
-          path: entryPath,
-          type: "blob"
-        }))
+        if (!pushRecursiveEntry(recursiveWorktreeFileEntry(cwd, full, entry.name, entryPath, entry.isSymbolicLink())))
           return;
       }
     }
@@ -2426,12 +2729,24 @@ async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames
 }
 function hasDotGitEntry(dir) {
   try {
-    lstatSync(join3(dir, ".git"));
+    lstatSync2(join4(dir, ".git"));
     return true;
   } catch (err) {
     return !!err && typeof err === "object" && "code" in err && err.code !== "ENOENT";
   }
 }
+function parseLsTreeRecord(rec, allowedTypes) {
+  const match = rec.match(new RegExp(`^(\\d+)\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
+  if (!match)
+    return null;
+  const [, mode, type, entryPath] = match;
+  return {
+    name: entryPath.split("/").pop() || entryPath,
+    path: entryPath,
+    type,
+    ...mode === LS_TREE_SYMLINK_MODE ? { is_symlink: true } : {}
+  };
+}
 function gitTreeEntries(ref, path, cwd, recursive) {
   const base = normalizeTreePath(path);
   const args = ["git", "-c", "core.quotepath=false", "ls-tree"];
@@ -2444,17 +2759,7 @@ function gitTreeEntries(ref, path, cwd, recursive) {
   if (res.code !== 0)
     return { code: res.code, entries: [], stderr: res.stderr };
   const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match)
-      return null;
-    const entryPath = match[2];
-    return {
-      name: entryPath.split("/").pop() || entryPath,
-      path: entryPath,
-      type: match[1]
-    };
-  }).filter((entry) => !!entry);
+  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
   if (recursive)
     entries.sort((a, b) => a.path.localeCompare(b.path));
   else
@@ -2473,17 +2778,7 @@ async function gitTreeEntriesAsync(ref, path, cwd, recursive) {
   if (res.code !== 0)
     return { code: res.code, entries: [], stderr: res.stderr };
   const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => {
-    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
-    if (!match)
-      return null;
-    const entryPath = match[2];
-    return {
-      name: entryPath.split("/").pop() || entryPath,
-      path: entryPath,
-      type: match[1]
-    };
-  }).filter((entry) => !!entry);
+  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
   if (recursive)
     entries.sort((a, b) => a.path.localeCompare(b.path));
   else
@@ -2547,7 +2842,7 @@ async function listTreeResultAsync(ref, path, cwd, options = {}) {
 }
 function untrackedMeta(cwd) {
   return untracked(cwd).flatMap((path) => {
-    const full = join3(cwd, path);
+    const full = join4(cwd, path);
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
@@ -2579,7 +2874,7 @@ function untrackedMeta(cwd) {
 async function untrackedMetaAsync(cwd) {
   const paths = await untrackedAsync(cwd);
   return paths.flatMap((path) => {
-    const full = join3(cwd, path);
+    const full = join4(cwd, path);
     let fileExists = false;
     try {
       fileExists = existsSync(full) && statSync2(full).isFile();
@@ -2827,8 +3122,9 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
+var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, repoStatusMapCache, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200, LS_TREE_SYMLINK_MODE = "120000";
 var init_git = __esm(() => {
+  init_cache();
   init_command_resolver();
   init_name_pattern();
   init_runtime();
@@ -2877,6 +3173,7 @@ var init_git = __esm(() => {
     "bin",
     "obj"
   ];
+  repoStatusMapCache = new Map;
 });
 
 // web-src/server/server-registry.ts
@@ -2889,16 +3186,16 @@ import {
   writeFileSync
 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function registryDir() {
   const override = process.env.CODE_VIEWER_TEST_SERVER_REGISTRY_DIR;
   if (override)
     return override;
-  return join4(homedir(), ".cache", "code-viewer", "servers");
+  return join5(homedir(), ".cache", "code-viewer", "servers");
 }
 function serverRegistryFilePath(root) {
   const hash = createHash("sha256").update(root).digest("hex").slice(0, 16);
-  return join4(registryDir(), `${hash}.json`);
+  return join5(registryDir(), `${hash}.json`);
 }
 function writeServerRegistry(entry) {
   try {
@@ -2939,13 +3236,40 @@ function removeServerRegistry(root, pid) {
 var init_server_registry = () => {};
 
 // web-src/server/cli-helpers.ts
-import { realpathSync as realpathSync2 } from "node:fs";
+import { realpathSync as realpathSync3 } from "node:fs";
 function takeValue(argv, index, flag) {
   const value = argv[index + 1];
   if (value === undefined)
     return { error: `${flag} requires a value` };
   return { value, next: index + 1 };
 }
+function takeGlobalCliOption(argv, index, options) {
+  const flag = argv[index];
+  if (flag === "--cwd" || flag === "--server" && options.allowServer) {
+    const taken = takeValue(argv, index, flag);
+    if ("error" in taken)
+      return { kind: "error", error: taken.error };
+    return {
+      kind: flag === "--cwd" ? "cwd" : "server",
+      value: taken.value,
+      next: taken.next
+    };
+  }
+  if (flag === "--bin" && options.allowedCommands) {
+    const taken = takeValue(argv, index, flag);
+    if ("error" in taken)
+      return { kind: "error", error: taken.error };
+    const parsed = parseExternalCommandOverride(taken.value, "--bin", options.allowedCommands);
+    if (parsed.ok === false)
+      return { kind: "error", error: parsed.error };
+    return {
+      kind: "command-override",
+      override: parsed.override,
+      next: taken.next
+    };
+  }
+  return { kind: "unhandled" };
+}
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -2965,7 +3289,7 @@ function isUnsafeText(value) {
     return true;
   return false;
 }
-function validateRefValue(value, flag) {
+function validateSafeCliValue(value, flag) {
   if (!value)
     return `${flag} requires a non-empty value`;
   if (isUnsafeText(value))
@@ -2974,13 +3298,16 @@ function validateRefValue(value, flag) {
     return `${flag} must not start with '-'`;
   return;
 }
+function validateRefValue(value, flag) {
+  const error = validateSafeCliValue(value, flag);
+  if (error)
+    return error;
+  return;
+}
 function validateRepoRelativePathValue(value, flag) {
-  if (!value)
-    return `${flag} requires a non-empty value`;
-  if (isUnsafeText(value))
-    return `${flag} must be single-line and must not contain NUL`;
-  if (value.startsWith("-"))
-    return `${flag} must not start with '-'`;
+  const error = validateSafeCliValue(value, flag);
+  if (error)
+    return error;
   if (value.startsWith("/") || value.startsWith("\\"))
     return `${flag} must be repo-relative`;
   const parts = value.split(/[\\/]+/);
@@ -2998,7 +3325,7 @@ function resolveRepoRootSafe(cwdOption) {
   const base = cwdOption || process.cwd();
   let baseReal;
   try {
-    baseReal = realpathSync2(base);
+    baseReal = realpathSync3(base);
   } catch {
     return {
       ok: false,
@@ -3094,6 +3421,7 @@ function extractErrorDetail(rawBody, isJson, status) {
   return trimmed;
 }
 var init_cli_helpers = __esm(() => {
+  init_command_resolver();
   init_git();
   init_server_registry();
 });
@@ -3113,6 +3441,28 @@ function parsePosition(value) {
   const n = Number(value);
   return Number.isInteger(n) && n > 0 ? n : Number.NaN;
 }
+function parseAnnotationAddOptions(options) {
+  const body = options.get("--body");
+  const bodyFile = options.get("--body-file");
+  if (body !== undefined && bodyFile !== undefined)
+    return { ok: false, error: "use either --body or --body-file" };
+  const position = parsePosition(options.get("--position"));
+  if (Number.isNaN(position))
+    return { ok: false, error: "--position must be a positive integer" };
+  return {
+    ok: true,
+    options: {
+      title: options.get("--title"),
+      session: options.get("--session"),
+      sessionTitle: options.get("--session-title"),
+      body,
+      bodyFile,
+      before: options.get("--before"),
+      after: options.get("--after"),
+      position
+    }
+  };
+}
 function parseFilter(value) {
   const idx = value.indexOf("=");
   if (idx <= 0)
@@ -3167,15 +3517,15 @@ function parseAnnotateArgs(argv) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h")
       return { ok: true, args: { command: { kind: "help" } } };
-    if (arg === "--cwd" || arg === "--server") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      if (arg === "--cwd")
-        cwd = taken.value;
-      else
-        server = taken.value;
-      i = taken.next;
+    const global = takeGlobalCliOption(argv, i, { allowServer: true });
+    if (global.kind === "error")
+      return { ok: false, error: global.error };
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
+    } else if (global.kind === "server") {
+      server = global.value;
+      i = global.next;
     } else if (valueFlags.has(arg)) {
       const taken = takeValue(argv, i, arg);
       if ("error" in taken)
@@ -3220,13 +3570,9 @@ function parseAnnotateArgs(argv) {
       if (!line)
         return { ok: false, error: "--line must be <n> or <n>-<m>" };
     }
-    const body = options.get("--body");
-    const bodyFile = options.get("--body-file");
-    if (body !== undefined && bodyFile !== undefined)
-      return { ok: false, error: "use either --body or --body-file" };
-    const position = parsePosition(options.get("--position"));
-    if (Number.isNaN(position))
-      return { ok: false, error: "--position must be a positive integer" };
+    const commonOptions = parseAnnotationAddOptions(options);
+    if (commonOptions.ok === false)
+      return { ok: false, error: commonOptions.error };
     return {
       ok: true,
       args: {
@@ -3236,14 +3582,7 @@ function parseAnnotateArgs(argv) {
           line,
           from: options.get("--from"),
           to: options.get("--to"),
-          title: options.get("--title"),
-          session: options.get("--session"),
-          sessionTitle: options.get("--session-title"),
-          body,
-          bodyFile,
-          before: options.get("--before"),
-          after: options.get("--after"),
-          position
+          ...commonOptions.options
         },
         cwd,
         server
@@ -3253,13 +3592,9 @@ function parseAnnotateArgs(argv) {
   if (subcommand === "add-db") {
     if (!options.get("--db"))
       return { ok: false, error: "add-db requires --db <id>" };
-    const body = options.get("--body");
-    const bodyFile = options.get("--body-file");
-    if (body !== undefined && bodyFile !== undefined)
-      return { ok: false, error: "use either --body or --body-file" };
-    const position = parsePosition(options.get("--position"));
-    if (Number.isNaN(position))
-      return { ok: false, error: "--position must be a positive integer" };
+    const commonOptions = parseAnnotationAddOptions(options);
+    if (commonOptions.ok === false)
+      return { ok: false, error: commonOptions.error };
     const rawTab = options.get("--tab");
     const tab = normalizeDatabaseTab(rawTab);
     if (rawTab !== undefined && tab === undefined)
@@ -3334,14 +3669,7 @@ function parseAnnotateArgs(argv) {
           searchTerm: options.get("--search-term"),
           includeNonText: flags.has("--include-non-text") || undefined,
           searchAutoRun: flags.has("--run-search"),
-          title: options.get("--title"),
-          session: options.get("--session"),
-          sessionTitle: options.get("--session-title"),
-          body,
-          bodyFile,
-          before: options.get("--before"),
-          after: options.get("--after"),
-          position
+          ...commonOptions.options
         },
         cwd,
         server
@@ -3454,6 +3782,14 @@ function printList(state) {
     });
   }
 }
+function printAddedAnnotation(result, location, serverUrl) {
+  const sessionTitle = result.session_title || "Untitled session";
+  if (result.created_session) {
+    console.error(`created new annotation session ${result.session_id} (${sessionTitle})`);
+  }
+  console.log(`annotated ${location} ` + `[${result.entry.id}] in session ${result.session_id} (${sessionTitle})`);
+  console.error(`view annotations at ${serverUrl}/ with the code annotations panel`);
+}
 async function annotationBodyFromCommand(command) {
   let body = command.body;
   if (body === undefined && command.bodyFile !== undefined) {
@@ -3514,11 +3850,7 @@ async function runAnnotateCli(argv) {
       after_id: command.after,
       position: command.position
     });
-    if (result.created_session) {
-      console.error(`created new annotation session ${result.session_id} (${result.session_title || "Untitled session"})`);
-    }
-    console.log(`annotated ${result.entry.path}${formatLine(result.entry.line)} ` + `[${result.entry.id}] in session ${result.session_id} (${result.session_title || "Untitled session"})`);
-    console.error(`view annotations at ${serverUrl}/ with the code annotations panel`);
+    printAddedAnnotation(result, `${result.entry.path}${formatLine(result.entry.line)}`, serverUrl);
     return;
   }
   if (command.kind === "add-db") {
@@ -3568,11 +3900,7 @@ async function runAnnotateCli(argv) {
       after_id: command.after,
       position: command.position
     });
-    if (result.created_session) {
-      console.error(`created new annotation session ${result.session_id} (${result.session_title || "Untitled session"})`);
-    }
-    console.log(`annotated ${result.entry.path} ` + `[${result.entry.id}] in session ${result.session_id} (${result.session_title || "Untitled session"})`);
-    console.error(`view annotations at ${serverUrl}/ with the code annotations panel`);
+    printAddedAnnotation(result, result.entry.path, serverUrl);
     return;
   }
   if (command.kind === "list") {
@@ -4108,8 +4436,8 @@ __export(exports_file_cli, {
   FILE_DEFAULT_HISTORY_LIMIT: () => FILE_DEFAULT_HISTORY_LIMIT,
   FILE_AGENT_HELP: () => FILE_AGENT_HELP
 });
-import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
-import { join as join5, relative as relative2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
+import { join as join6, relative as relative3 } from "node:path";
 function validatePath(value) {
   return validateRepoRelativePathValue(value, "--path");
 }
@@ -4133,23 +4461,17 @@ function parseFileArgs(argv) {
     if (arg === "--help" || arg === "-h") {
       return { ok: true, args: { command: { kind: "help" } } };
     }
-    if (arg === "--cwd") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      cwd = taken.value;
-      i = taken.next;
-    } else if (arg === "--bin") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      const parsed = parseExternalCommandOverride(taken.value, "--bin", [
-        "git"
-      ]);
-      if (parsed.ok === false)
-        return { ok: false, error: parsed.error };
-      commandOverrides.push(parsed.override);
-      i = taken.next;
+    const global = takeGlobalCliOption(argv, i, {
+      allowedCommands: ["git"]
+    });
+    if (global.kind === "error")
+      return { ok: false, error: global.error };
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
+    } else if (global.kind === "command-override") {
+      commandOverrides.push(global.override);
+      i = global.next;
     } else if (VALUE_FLAGS.has(arg)) {
       const taken = takeValue(argv, i, arg);
       if ("error" in taken)
@@ -4513,13 +4835,13 @@ function sliceLines(text, start, end) {
 function safeWorktreePathFromRoot(root, path) {
   if (validatePath(path))
     return null;
-  const full = join5(root, path);
+  const full = join6(root, path);
   if (!existsSync3(full))
     return null;
   try {
-    const realRoot = realpathSync3(root);
-    const realFull = realpathSync3(full);
-    const rel = relative2(realRoot, realFull);
+    const realRoot = realpathSync4(root);
+    const realFull = realpathSync4(full);
+    const rel = relative3(realRoot, realFull);
     if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\")) {
       return null;
     }
@@ -5391,26 +5713,21 @@ function parseJournalArgs(argv) {
       const arg = argv[i];
       if (arg === "--help" || arg === "-h")
         return { ok: true, args: { command: { kind: "help" }, dryRun: false } };
-      if (arg === "--cwd" || arg === "--server") {
-        const taken = takeValue(argv, i, arg);
-        if ("error" in taken)
-          return { ok: false, error: taken.error };
-        if (arg === "--cwd")
-          cwd = taken.value;
-        else
-          server = taken.value;
-        i = taken.next;
-      } else if (arg === "--bin") {
-        const taken = takeValue(argv, i, arg);
-        if ("error" in taken)
-          return { ok: false, error: taken.error };
-        const parsed = parseExternalCommandOverride(taken.value, "--bin", [
-          "gh"
-        ]);
-        if (parsed.ok === false)
-          return { ok: false, error: parsed.error };
-        commandOverrides.push(parsed.override);
-        i = taken.next;
+      const global = takeGlobalCliOption(argv, i, {
+        allowServer: true,
+        allowedCommands: ["gh"]
+      });
+      if (global.kind === "error")
+        return { ok: false, error: global.error };
+      if (global.kind === "cwd") {
+        cwd = global.value;
+        i = global.next;
+      } else if (global.kind === "server") {
+        server = global.value;
+        i = global.next;
+      } else if (global.kind === "command-override") {
+        commandOverrides.push(global.override);
+        i = global.next;
       } else if (valueFlags.has(arg)) {
         const taken = takeValue(argv, i, arg);
         if ("error" in taken)
@@ -6138,162 +6455,61 @@ Usage:
       [--priority <p0|p1|p2|p3>] [--label <label>...] [--clear-labels]
       [--due <YYYY-MM-DD|none>] [--source-date <YYYY-MM-DD|today|none>]
       [--body <markdown> | --body-file <path>]
-  code-viewer journal task-next [--label <label>...] [--status <status>]
-      [--limit <n>] [--json]
-  code-viewer journal github-issues [--repo <owner/repo>]
-      [--state <open|closed|all>] [--gh-label <label>...]
-      [--search <query>] [--limit <n>] [--json] [--bin gh=<path>]
-  code-viewer journal task-link-issue <number> [--repo <owner/repo>]
-      [--status <status>] [--priority <p0|p1|p2|p3>] [--label <label>...]
-      [--before <id> | --after <id> | --position <n>] [--json]
-      [--dry-run] [--bin gh=<path>]
-  code-viewer journal task-claim <id> [--by <agent>] [--lease-minutes <n>]
-      [--wip-limit <n>]
-  code-viewer journal task-done <id> --by <agent>
-      [--note <markdown> | --note-file <path>]
-  code-viewer journal task-delete <id>
-
-Global options:
-  --cwd <dir>      repository root (default: current directory)
-  --server <url>   code-viewer server URL (default: auto-discovered)
-  --bin gh=<p>     override gh executable path for github-issues
-  --dry-run        print the write payload without sending it
-`, JOURNAL_AGENT_HELP = `code-viewer journal — agent guide
-
-You are an AI coding agent. Use this tool to write daily work notes and process
-explicit task queues without guessing from memory.
-
-## Workflow
-
-1. Check the queue before doing label-scoped work:
-     code-viewer journal task-next --label ai-ready --limit 5 --json
-2. Claim exactly one task before editing code:
-     code-viewer journal task-claim <task-id> --by agent --wip-limit 1
-3. When finished, mark it done with a short note:
-     code-viewer journal task-done <task-id> --by agent --note "Implemented and verified."
-4. Add a daily journal entry for work that is not already represented by a task:
-     code-viewer journal add --date today --label ai --body "..."
-5. Inspect GitHub issues read-only before deciding what local task to create:
-     code-viewer journal github-issues --repo owner/repo --json
-6. Link a GitHub issue to the local board without updating GitHub:
-     code-viewer journal task-link-issue 123 --repo owner/repo --status draft --label ai-ready
-
-## Rules
-
-- Treat labels as filters, priority as importance, and card order as human order.
-- Do not process draft tasks unless the human asked for drafts.
-- Use task-next for ordering; do not sort the JSON yourself unless asked.
-- Use --dry-run before large generated entries.
-- GitHub issue listing is read-only. Create or update local tasks explicitly.
-- task-link-issue reads issue metadata only and stores a local task link plus
-  your local labels. It does not copy the issue body or update GitHub.
-`;
-var init_journal_cli = __esm(() => {
-  init_journal();
-  init_cli_helpers();
-  init_command_resolver();
-  init_github_issues();
-});
-
-// web-src/core/routes.ts
-function assertNever(value) {
-  throw new Error(`unhandled route: ${JSON.stringify(value)}`);
-}
-function formatLineTarget(line) {
-  return typeof line === "number" ? String(line) : `${line.start}-${line.end}`;
-}
-function buildRoute(route) {
-  switch (route.screen) {
-    case "repo": {
-      const params = new URLSearchParams;
-      if (route.ref && route.ref !== "worktree")
-        params.set("ref", route.ref);
-      if (route.path)
-        params.set("path", route.path);
-      const qs = params.toString();
-      return `/${qs ? `?${qs}` : ""}`;
-    }
-    case "file":
-      if (route.view === "blob") {
-        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=blob" + (route.preview ? "&preview=1" : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "") + (route.virtual === "off" ? "&virtual=off" : "");
-      }
-      if (route.view === "blame") {
-        const ref = route.ref || "worktree";
-        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(ref) + "&view=blame" + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
-      }
-      if (route.view === "history") {
-        return "/file?path=" + encodeURIComponent(route.path) + "&target=" + encodeURIComponent(route.ref || "worktree") + "&view=history" + (route.commit ? `&commit=${encodeURIComponent(route.commit)}` : "") + (route.line ? `&line=${encodeURIComponent(formatLineTarget(route.line))}` : "");
-      }
-      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 "help": {
-      const params = new URLSearchParams;
-      if (route.lang && route.lang !== "en")
-        params.set("lang", route.lang);
-      if (route.section && route.section !== "overview")
-        params.set("section", route.section);
-      const qs = params.toString();
-      return `/help${qs ? `?${qs}` : ""}`;
-    }
-    case "history": {
-      const params = new URLSearchParams;
-      if (route.ref && route.ref !== "HEAD")
-        params.set("ref", route.ref);
-      if (route.commit)
-        params.set("commit", route.commit);
-      const qs = params.toString();
-      return `/history${qs ? `?${qs}` : ""}`;
-    }
-    case "journal": {
-      const params = new URLSearchParams;
-      if (route.tab && route.tab !== "journal")
-        params.set("tab", route.tab);
-      if (route.date)
-        params.set("date", route.date);
-      if (route.label)
-        params.set("label", route.label);
-      if (route.task)
-        params.set("task", route.task);
-      const qs = params.toString();
-      return `/journal${qs ? `?${qs}` : ""}`;
-    }
-    case "database": {
-      const params = new URLSearchParams;
-      if (route.db)
-        params.set("db", route.db);
-      if (route.schema)
-        params.set("schema", route.schema);
-      if (route.table)
-        params.set("table", route.table);
-      if (route.tab)
-        params.set("tab", route.tab);
-      if (route.diffBefore)
-        params.set("diffBefore", route.diffBefore);
-      if (route.diffAfter)
-        params.set("diffAfter", route.diffAfter);
-      const qs = params.toString();
-      return `/database${qs ? `?${qs}` : ""}`;
-    }
-    case "unknown":
-      return "/todif?from=" + encodeURIComponent(route.range.from || "") + "&to=" + encodeURIComponent(route.range.to || "worktree");
-    default:
-      return assertNever(route);
-  }
-}
-var SPA_PATHS, APP_ENTRY_PATHS;
-var init_routes = __esm(() => {
-  SPA_PATHS = [
-    "/todif",
-    "/todiff",
-    "/file",
-    "/help",
-    "/history",
-    "/journal",
-    "/database",
-    "/doctor"
-  ];
-  APP_ENTRY_PATHS = ["/", "/index.html"];
+  code-viewer journal task-next [--label <label>...] [--status <status>]
+      [--limit <n>] [--json]
+  code-viewer journal github-issues [--repo <owner/repo>]
+      [--state <open|closed|all>] [--gh-label <label>...]
+      [--search <query>] [--limit <n>] [--json] [--bin gh=<path>]
+  code-viewer journal task-link-issue <number> [--repo <owner/repo>]
+      [--status <status>] [--priority <p0|p1|p2|p3>] [--label <label>...]
+      [--before <id> | --after <id> | --position <n>] [--json]
+      [--dry-run] [--bin gh=<path>]
+  code-viewer journal task-claim <id> [--by <agent>] [--lease-minutes <n>]
+      [--wip-limit <n>]
+  code-viewer journal task-done <id> --by <agent>
+      [--note <markdown> | --note-file <path>]
+  code-viewer journal task-delete <id>
+
+Global options:
+  --cwd <dir>      repository root (default: current directory)
+  --server <url>   code-viewer server URL (default: auto-discovered)
+  --bin gh=<p>     override gh executable path for github-issues
+  --dry-run        print the write payload without sending it
+`, JOURNAL_AGENT_HELP = `code-viewer journal — agent guide
+
+You are an AI coding agent. Use this tool to write daily work notes and process
+explicit task queues without guessing from memory.
+
+## Workflow
+
+1. Check the queue before doing label-scoped work:
+     code-viewer journal task-next --label ai-ready --limit 5 --json
+2. Claim exactly one task before editing code:
+     code-viewer journal task-claim <task-id> --by agent --wip-limit 1
+3. When finished, mark it done with a short note:
+     code-viewer journal task-done <task-id> --by agent --note "Implemented and verified."
+4. Add a daily journal entry for work that is not already represented by a task:
+     code-viewer journal add --date today --label ai --body "..."
+5. Inspect GitHub issues read-only before deciding what local task to create:
+     code-viewer journal github-issues --repo owner/repo --json
+6. Link a GitHub issue to the local board without updating GitHub:
+     code-viewer journal task-link-issue 123 --repo owner/repo --status draft --label ai-ready
+
+## Rules
+
+- Treat labels as filters, priority as importance, and card order as human order.
+- Do not process draft tasks unless the human asked for drafts.
+- Use task-next for ordering; do not sort the JSON yourself unless asked.
+- Use --dry-run before large generated entries.
+- GitHub issue listing is read-only. Create or update local tasks explicitly.
+- task-link-issue reads issue metadata only and stores a local task link plus
+  your local labels. It does not copy the issue body or update GitHub.
+`;
+var init_journal_cli = __esm(() => {
+  init_journal();
+  init_cli_helpers();
+  init_command_resolver();
+  init_github_issues();
 });
 
 // web-src/server/query-cli.ts
@@ -6338,26 +6554,21 @@ function parseQueryArgs(argv) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h")
       return { ok: true, args: { command: { kind: "help" } } };
-    if (arg === "--cwd" || arg === "--server") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      if (arg === "--cwd")
-        cwd = taken.value;
-      else
-        server = taken.value;
-      i = taken.next;
-    } else if (arg === "--bin") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      const parsed = parseExternalCommandOverride(taken.value, "--bin", [
-        "git"
-      ]);
-      if (parsed.ok === false)
-        return { ok: false, error: parsed.error };
-      commandOverrides.push(parsed.override);
-      i = taken.next;
+    const global = takeGlobalCliOption(argv, i, {
+      allowServer: true,
+      allowedCommands: ["git"]
+    });
+    if (global.kind === "error")
+      return { ok: false, error: global.error };
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
+    } else if (global.kind === "server") {
+      server = global.value;
+      i = global.next;
+    } else if (global.kind === "command-override") {
+      commandOverrides.push(global.override);
+      i = global.next;
     } else if (VALUE_FLAGS2.has(arg)) {
       const taken = takeValue(argv, i, arg);
       if ("error" in taken)
@@ -8996,6 +9207,18 @@ __export(exports_search_cli, {
   SEARCH_AGENT_HELP: () => SEARCH_AGENT_HELP,
   FILE_NAME_SEARCH_DEFAULT_MAX: () => FILE_NAME_SEARCH_DEFAULT_MAX
 });
+function parseSearchMax(raw, hardCap) {
+  if (raw === undefined)
+    return { value: undefined };
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    return { error: `--max must be a positive integer (got ${raw})` };
+  }
+  if (value > hardCap) {
+    return { error: `--max must be <= ${hardCap} (got ${value})` };
+  }
+  return { value };
+}
 function parseSearchArgs(argv) {
   const rest = [];
   let cwd;
@@ -9009,26 +9232,21 @@ function parseSearchArgs(argv) {
     if (arg === "--help" || arg === "-h") {
       return { ok: true, args: { command: { kind: "help" } } };
     }
-    if (arg === "--cwd" || arg === "--server") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      if (arg === "--cwd")
-        cwd = taken.value;
-      else
-        server = taken.value;
-      i = taken.next;
-    } else if (arg === "--bin") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      const parsed = parseExternalCommandOverride(taken.value, "--bin", [
-        "git"
-      ]);
-      if (parsed.ok === false)
-        return { ok: false, error: parsed.error };
-      commandOverrides.push(parsed.override);
-      i = taken.next;
+    const global = takeGlobalCliOption(argv, i, {
+      allowServer: true,
+      allowedCommands: ["git"]
+    });
+    if (global.kind === "error")
+      return { ok: false, error: global.error };
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
+    } else if (global.kind === "server") {
+      server = global.value;
+      i = global.next;
+    } else if (global.kind === "command-override") {
+      commandOverrides.push(global.override);
+      i = global.next;
     } else if (REPEATABLE_VALUE_FLAGS.has(arg)) {
       const taken = takeValue(argv, i, arg);
       if ("error" in taken)
@@ -9087,24 +9305,10 @@ function parseSearchArgs(argv) {
         error: "search files does not accept --path"
       };
     }
-    const maxRaw2 = options.get("--max");
-    let max2 = FILE_NAME_SEARCH_DEFAULT_MAX;
-    if (maxRaw2 !== undefined) {
-      const n = Number(maxRaw2);
-      if (!Number.isInteger(n) || n <= 0) {
-        return {
-          ok: false,
-          error: `--max must be a positive integer (got ${maxRaw2})`
-        };
-      }
-      if (n > FILE_SEARCH_ABSOLUTE_MAX) {
-        return {
-          ok: false,
-          error: `--max must be <= ${FILE_SEARCH_ABSOLUTE_MAX} (got ${n})`
-        };
-      }
-      max2 = n;
-    }
+    const parsedMax2 = parseSearchMax(options.get("--max"), FILE_SEARCH_ABSOLUTE_MAX);
+    if ("error" in parsedMax2)
+      return { ok: false, error: parsedMax2.error };
+    const max = parsedMax2.value ?? FILE_NAME_SEARCH_DEFAULT_MAX;
     return {
       ok: true,
       args: {
@@ -9112,7 +9316,7 @@ function parseSearchArgs(argv) {
           kind: "files",
           term,
           ref: options.get("--ref"),
-          max: max2,
+          max,
           json: flags.has("--json")
         },
         cwd,
@@ -9121,24 +9325,9 @@ function parseSearchArgs(argv) {
       }
     };
   }
-  const maxRaw = options.get("--max");
-  let max;
-  if (maxRaw !== undefined) {
-    const n = Number(maxRaw);
-    if (!Number.isInteger(n) || n <= 0) {
-      return {
-        ok: false,
-        error: `--max must be a positive integer (got ${maxRaw})`
-      };
-    }
-    if (n > GREP_ABSOLUTE_MAX) {
-      return {
-        ok: false,
-        error: `--max must be <= ${GREP_ABSOLUTE_MAX} (got ${n})`
-      };
-    }
-    max = n;
-  }
+  const parsedMax = parseSearchMax(options.get("--max"), GREP_ABSOLUTE_MAX);
+  if ("error" in parsedMax)
+    return { ok: false, error: parsedMax.error };
   return {
     ok: true,
     args: {
@@ -9148,7 +9337,7 @@ function parseSearchArgs(argv) {
         ref: options.get("--ref"),
         paths,
         regex: flags.has("--regex"),
-        max,
+        max: parsedMax.value,
         json: flags.has("--json")
       },
       cwd,
@@ -9423,24 +9612,24 @@ Parse failures and unreachable servers exit 1.
 
 // web-src/server/root.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname3, join as join6, normalize } from "node:path";
+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(join6(current, "package.json")) && existsSync4(join6(current, "web"))) {
+    if (existsSync4(join7(current, "package.json")) && existsSync4(join7(current, "web"))) {
       return normalize(current);
     }
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current)
       break;
     current = parent;
   }
-  return normalize(join6(start, "..", ".."));
+  return normalize(join7(start, "..", ".."));
 }
 var ROOT;
 var init_root = __esm(() => {
-  ROOT = findRoot(dirname3(fileURLToPath(import.meta.url)));
+  ROOT = findRoot(dirname4(fileURLToPath(import.meta.url)));
 });
 
 // web-src/server/skill-cli.ts
@@ -9455,7 +9644,7 @@ __export(exports_skill_cli, {
 });
 import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join7, resolve } from "node:path";
+import { join as join8, resolve } from "node:path";
 function parseAgentList(value) {
   if (value === "all")
     return [...AGENT_NAMES];
@@ -9515,7 +9704,7 @@ function parseSkillArgs(argv) {
 function discoverBundledSkills(skillsRoot) {
   if (!existsSync5(skillsRoot))
     return [];
-  return readdirSync2(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync5(join7(skillsRoot, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
+  return readdirSync2(skillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync5(join8(skillsRoot, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
 }
 function installSkill(args, deps) {
   const skills = discoverBundledSkills(deps.skillsRoot);
@@ -9529,8 +9718,8 @@ function installSkill(args, deps) {
   const results = [];
   for (const agent of args.agents) {
     for (const skill of skills) {
-      const sourceDir = join7(deps.skillsRoot, skill);
-      const target = join7(base, AGENT_SKILL_DIRS[agent], "skills", skill);
+      const sourceDir = join8(deps.skillsRoot, skill);
+      const target = join8(base, AGENT_SKILL_DIRS[agent], "skills", skill);
       const action = existsSync5(target) ? "updated" : "installed";
       try {
         mkdirSync2(target, { recursive: true });
@@ -9559,7 +9748,7 @@ function runSkillCli(argv) {
     return;
   }
   const result = installSkill(parsed.args, {
-    skillsRoot: join7(ROOT, "skills"),
+    skillsRoot: join8(ROOT, "skills"),
     homeDir: homedir2(),
     projectDir: process.cwd()
   });
@@ -9700,23 +9889,17 @@ function parseStatusArgs(argv) {
     if (arg === "--help" || arg === "-h") {
       return { ok: true, args: { command: { kind: "help" } } };
     }
-    if (arg === "--cwd") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      cwd = taken.value;
-      i = taken.next;
-    } else if (arg === "--bin") {
-      const taken = takeValue(argv, i, arg);
-      if ("error" in taken)
-        return { ok: false, error: taken.error };
-      const parsed = parseExternalCommandOverride(taken.value, "--bin", [
-        "git"
-      ]);
-      if (parsed.ok === false)
-        return { ok: false, error: parsed.error };
-      commandOverrides.push(parsed.override);
-      i = taken.next;
+    const global = takeGlobalCliOption(argv, i, {
+      allowedCommands: ["git"]
+    });
+    if (global.kind === "error")
+      return { ok: false, error: global.error };
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
+    } else if (global.kind === "command-override") {
+      commandOverrides.push(global.override);
+      i = global.next;
     } else if (VALUE_FLAGS4.has(arg)) {
       const taken = takeValue(argv, i, arg);
       if ("error" in taken)
@@ -10278,6 +10461,9 @@ function placeValue(coerced, kind, useParams, params) {
 function coerceCell(cell, columnType) {
   return coerceDbValue(cell.value, columnType);
 }
+function formatWriteComparisons(cells, columnTypes, kind, useParams, params, separator) {
+  return cells.map((cell) => `${sanitizeIdentifier(cell.column, kind)} = ${placeValue(coerceCell(cell, columnTypes.get(cell.column) ?? "TEXT"), kind, useParams, params)}`).join(separator);
+}
 function buildInsertSql(table, cells, columnTypes, kind) {
   if (cells.length === 0) {
     throw new Error("insert requires at least one column value");
@@ -10298,8 +10484,8 @@ function buildUpdateSql(table, set, pk, columnTypes, kind) {
   }
   const useParams = useParamsFor(kind);
   const params = [];
-  const setSql = set.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(", ");
-  const whereSql = pk.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(" AND ");
+  const setSql = formatWriteComparisons(set, columnTypes, kind, useParams, params, ", ");
+  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
   const sql = `UPDATE ${sanitizeIdentifier(table, kind)} SET ${setSql} WHERE ${whereSql}`;
   return { sql, params };
 }
@@ -10309,7 +10495,7 @@ function buildDeleteSql(table, pk, columnTypes, kind) {
   }
   const useParams = useParamsFor(kind);
   const params = [];
-  const whereSql = pk.map((c) => `${sanitizeIdentifier(c.column, kind)} = ${placeValue(coerceCell(c, columnTypes.get(c.column) ?? "TEXT"), kind, useParams, params)}`).join(" AND ");
+  const whereSql = formatWriteComparisons(pk, columnTypes, kind, useParams, params, " AND ");
   const sql = `DELETE FROM ${sanitizeIdentifier(table, kind)} WHERE ${whereSql}`;
   return { sql, params };
 }
@@ -14623,11 +14809,11 @@ import {
   existsSync as existsSync6,
   openSync as openSync2,
   readSync as readSync2,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   statSync as statSync4
 } from "node:fs";
 import { lstat, open, readdir, readFile as readFile2, stat } from "node:fs/promises";
-import { basename, join as join8, relative as relative3 } from "node:path";
+import { basename, join as join9, relative as relative4 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
     const stat2 = statSync4(fullPath);
@@ -14698,7 +14884,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
         return;
       if (omitSet.has(entry.toLowerCase()))
         continue;
-      const full = join8(dir, entry);
+      const full = join9(dir, entry);
       let entryStat;
       try {
         entryStat = await lstat(full);
@@ -14715,7 +14901,7 @@ async function discoverSqliteFilesAsync(cwd, omitDirNames, signal) {
           continue;
         if (!await isSqliteFileAsync(full))
           continue;
-        const rel = relative3(cwd, full);
+        const rel = relative4(cwd, full);
         if (rel.startsWith("..") || rel.startsWith("/"))
           continue;
         results.push({
@@ -14742,18 +14928,18 @@ function validateDbPath(cwd, dbPath) {
   const parts = dbPath.split(/[\\/]+/);
   if (parts.some((p) => p === ".." || p.toLowerCase() === ".git" || p.toLowerCase() === ".code-viewer"))
     return null;
-  const full = join8(cwd, dbPath);
+  const full = join9(cwd, dbPath);
   if (!existsSync6(full))
     return null;
   let realCwd;
   let realFull;
   try {
-    realCwd = realpathSync4(cwd);
-    realFull = realpathSync4(full);
+    realCwd = realpathSync5(cwd);
+    realFull = realpathSync5(full);
   } catch {
     return null;
   }
-  const rel = relative3(realCwd, realFull);
+  const rel = relative4(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/"))
     return null;
   if (!isSqliteFile(realFull))
@@ -14912,7 +15098,7 @@ function resolveEnvValue(raw, composeDirEnv = {}) {
 }
 async function readDotenvAsync(composeDir) {
   try {
-    const content = await readFile2(join8(composeDir, ".env"), "utf-8");
+    const content = await readFile2(join9(composeDir, ".env"), "utf-8");
     return parseDotenvContent(content);
   } catch {
     return {};
@@ -15034,7 +15220,7 @@ function parseComposeContent(content, filepath, composeDir, cwd, composeDirEnv,
   for (let match = serviceRegex.exec(servicesBlock);match !== null; match = serviceRegex.exec(servicesBlock)) {
     servicePositions.push({ name: match[1], start: match.index });
   }
-  const relDir = relative3(cwd, composeDir);
+  const relDir = relative4(cwd, composeDir);
   const isRoot = relDir === "" || relDir === ".";
   const relDirSlash = relDir.replace(/\\/g, "/");
   const filename = basename(filepath);
@@ -15139,7 +15325,7 @@ async function walkForMarkerFileAsync(dir, depth, omitSet, hasCapacity, visitDir
       return;
     if (omitSet.has(entry.toLowerCase()))
       continue;
-    const full = join8(dir, entry);
+    const full = join9(dir, entry);
     let entryStat;
     try {
       entryStat = await lstat(full);
@@ -15166,7 +15352,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   omitSet.add("node_modules");
   await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_DOCKER_SERVICES, async (dir) => {
     for (const filename of COMPOSE_FILENAMES) {
-      const filepath = join8(dir, filename);
+      const filepath = join9(dir, filename);
       if (await pathExistsAsync(filepath)) {
         await parseComposeFileAsync(filepath, dir, cwd, results);
         break;
@@ -15330,7 +15516,7 @@ async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal)
   omitSet.add("node_modules");
   const results = [];
   await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
-    const configPath = join8(dir, "supabase", "config.toml");
+    const configPath = join9(dir, "supabase", "config.toml");
     if (!await pathExistsAsync(configPath))
       return;
     try {
@@ -15338,7 +15524,7 @@ async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal)
       const parsed = parseSupabaseConfigToml(content);
       if (!parsed)
         return;
-      const relDir = relative3(cwd, dir);
+      const relDir = relative4(cwd, dir);
       const isRoot = relDir === "" || relDir === ".";
       const relDirSlash = relDir.replace(/\\/g, "/");
       const id = isRoot ? `supabase:${parsed.projectId}` : `supabase:${parsed.projectId}@${encodeURIComponent(relDirSlash)}`;
@@ -15420,35 +15606,18 @@ var init_discovery = __esm(() => {
   supabaseDiscoveryCache = new Map;
 });
 
-// web-src/core/id.ts
-function bytesToHex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function makeId(prefix) {
-  const cryptoApi = globalThis.crypto;
-  if (typeof cryptoApi?.randomUUID === "function") {
-    return `${prefix}-${cryptoApi.randomUUID().replace(/-/g, "").slice(0, 16)}`;
-  }
-  if (typeof cryptoApi?.getRandomValues === "function") {
-    const bytes = new Uint8Array(8);
-    cryptoApi.getRandomValues(bytes);
-    return `${prefix}-${bytesToHex(bytes)}`;
-  }
-  return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
-}
-
 // web-src/server/worktree-watcher.ts
 import {
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   readdirSync as nodeReaddirSync,
   watch as nodeWatch
 } from "node:fs";
-import { join as join9, relative as relative4 } from "node:path";
+import { join as join10, relative as relative5 } from "node:path";
 function normalizeRelativePath(path) {
   return path.replace(/\\/g, "/").replace(/^\/+/, "");
 }
 function isInsideRoot(root, path) {
-  const rel = relative4(root, path).replace(/\\/g, "/");
+  const rel = relative5(root, path).replace(/\\/g, "/");
   return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
 }
 function startWorktreeUpdateWatch(options) {
@@ -15456,14 +15625,14 @@ function startWorktreeUpdateWatch(options) {
   const readDirs = options.readdirSync || ((path) => nodeReaddirSync(path, { withFileTypes: true }));
   const isDirectory = options.isDirectory || ((path) => {
     try {
-      return lstatSync2(path).isDirectory();
+      return lstatSync3(path).isDirectory();
     } catch {
       return false;
     }
   });
   const directorySignature = options.directorySignature || ((path) => {
     try {
-      const stats = lstatSync2(path);
+      const stats = lstatSync3(path);
       if (!stats.isDirectory())
         return null;
       return `${stats.dev}:${stats.ino}`;
@@ -15486,7 +15655,7 @@ function startWorktreeUpdateWatch(options) {
   const pendingChangedPaths = new Set;
   let watchLimitReported = false;
   const ignored = (path) => isSkippableSearchPath(normalizeRelativePath(path), options.omitDirNames, options.excludeNames);
-  const directoryRelativePath = (dir) => normalizeRelativePath(relative4(options.root, dir));
+  const directoryRelativePath = (dir) => normalizeRelativePath(relative5(options.root, dir));
   const ignoredDirectory = (dir) => {
     const rel = directoryRelativePath(dir);
     return Boolean(rel && ignored(rel));
@@ -15552,7 +15721,7 @@ function startWorktreeUpdateWatch(options) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = join9(dir, entry.name);
+      const child = join10(dir, entry.name);
       if (ignoredDirectory(child))
         continue;
       children.push(child);
@@ -15636,10 +15805,10 @@ function startWorktreeUpdateWatch(options) {
           scheduleUpdate();
           return;
         }
-        const changed = normalizeRelativePath(join9(rel, filename.toString()));
+        const changed = normalizeRelativePath(join10(rel, filename.toString()));
         if (ignored(changed))
           return;
-        const fullChangedPath = join9(options.root, changed);
+        const fullChangedPath = join10(options.root, changed);
         if (!isInsideRoot(options.root, fullChangedPath))
           return;
         if (initialScanAsync) {
@@ -15688,9 +15857,9 @@ var init_worktree_watcher = __esm(() => {
 });
 
 // web-src/server/state-store.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function codeViewerPath(root, fileName) {
-  return join10(root, CODE_VIEWER_DIR2, fileName);
+  return join11(root, CODE_VIEWER_DIR2, fileName);
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -15707,15 +15876,17 @@ function optionalString(value, maxLen) {
 function optionalBoolean(value) {
   return typeof value === "boolean" ? value : undefined;
 }
-function optionalNumber(value, min, max) {
+function optionalFiniteNumber(value, min, max, round) {
   if (typeof value !== "number" || !Number.isFinite(value))
     return;
-  return Math.max(min, Math.min(max, Math.round(value)));
+  const normalized = round ? Math.round(value) : value;
+  return Math.max(min, Math.min(max, normalized));
+}
+function optionalNumber(value, min, max) {
+  return optionalFiniteNumber(value, min, max, true);
 }
 function optionalFloat(value, min, max) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    return;
-  return Math.max(min, Math.min(max, value));
+  return optionalFiniteNumber(value, min, max, false);
 }
 function optionalFontSize(value) {
   return value === "compact" || value === "regular" || value === "large" || value === "xlarge" ? value : undefined;
@@ -16547,6 +16718,25 @@ function asStringArray(value) {
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
+function asDynamoDbItemsResult(raw) {
+  return {
+    items: Array.isArray(raw.Items) ? raw.Items : [],
+    count: asNumber(raw.Count),
+    scannedCount: asNumber(raw.ScannedCount),
+    ...raw.LastEvaluatedKey ? { lastEvaluatedKey: asObject(raw.LastEvaluatedKey) } : {}
+  };
+}
+function dynamoDbItemsRequestFields(opts) {
+  return {
+    ...opts.limit ? { Limit: Math.min(1000, Math.max(1, opts.limit)) } : {},
+    ...opts.exclusiveStartKey ? { ExclusiveStartKey: opts.exclusiveStartKey } : {},
+    ...opts.indexName ? { IndexName: opts.indexName } : {},
+    ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
+    ...opts.filterExpression ? { FilterExpression: opts.filterExpression } : {},
+    ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
+    ...opts.expressionAttributeValues ? { ExpressionAttributeValues: opts.expressionAttributeValues } : {}
+  };
+}
 function createDynamoDbAdapter(config) {
   async function signedJsonRequest(action, body, signal, deadline = createDynamoDbTransportDeadline(config)) {
     const requestBody = JSON.stringify(body);
@@ -16629,41 +16819,19 @@ function createDynamoDbAdapter(config) {
     assertTableName(opts.tableName);
     const raw = await signedJsonRequest("Scan", {
       TableName: opts.tableName,
-      ...opts.limit ? { Limit: Math.min(1000, Math.max(1, opts.limit)) } : {},
-      ...opts.exclusiveStartKey ? { ExclusiveStartKey: opts.exclusiveStartKey } : {},
-      ...opts.indexName ? { IndexName: opts.indexName } : {},
-      ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
-      ...opts.filterExpression ? { FilterExpression: opts.filterExpression } : {},
-      ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
-      ...opts.expressionAttributeValues ? { ExpressionAttributeValues: opts.expressionAttributeValues } : {}
+      ...dynamoDbItemsRequestFields(opts)
     }, opts.signal);
-    return {
-      items: Array.isArray(raw.Items) ? raw.Items : [],
-      count: asNumber(raw.Count),
-      scannedCount: asNumber(raw.ScannedCount),
-      ...raw.LastEvaluatedKey ? { lastEvaluatedKey: asObject(raw.LastEvaluatedKey) } : {}
-    };
+    return asDynamoDbItemsResult(raw);
   }
   async function queryAsync(opts) {
     assertTableName(opts.tableName);
     const raw = await signedJsonRequest("Query", {
       TableName: opts.tableName,
       KeyConditionExpression: opts.keyConditionExpression,
-      ...opts.limit ? { Limit: Math.min(1000, Math.max(1, opts.limit)) } : {},
-      ...opts.exclusiveStartKey ? { ExclusiveStartKey: opts.exclusiveStartKey } : {},
-      ...opts.indexName ? { IndexName: opts.indexName } : {},
-      ...opts.projectionExpression ? { ProjectionExpression: opts.projectionExpression } : {},
-      ...opts.filterExpression ? { FilterExpression: opts.filterExpression } : {},
-      ...opts.expressionAttributeNames ? { ExpressionAttributeNames: opts.expressionAttributeNames } : {},
-      ...opts.expressionAttributeValues ? { ExpressionAttributeValues: opts.expressionAttributeValues } : {},
+      ...dynamoDbItemsRequestFields(opts),
       ...opts.scanIndexForward !== undefined ? { ScanIndexForward: opts.scanIndexForward } : {}
     }, opts.signal);
-    return {
-      items: Array.isArray(raw.Items) ? raw.Items : [],
-      count: asNumber(raw.Count),
-      scannedCount: asNumber(raw.ScannedCount),
-      ...raw.LastEvaluatedKey ? { lastEvaluatedKey: asObject(raw.LastEvaluatedKey) } : {}
-    };
+    return asDynamoDbItemsResult(raw);
   }
   async function getItemAsync(opts) {
     assertTableName(opts.tableName);
@@ -16806,7 +16974,7 @@ var init_connection_pool = __esm(() => {
 // web-src/server/database/connections-store.ts
 import { randomUUID } from "node:crypto";
 import { chmod } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function secretKey(cwd, id) {
   return `${cwd}\x00${id}`;
 }
@@ -16827,7 +16995,7 @@ function withRuntimeSecrets(cwd, connection) {
   };
 }
 function connectionsFilePath(root) {
-  return join11(root, ".code-viewer", CONNECTIONS_FILE_NAME);
+  return join12(root, ".code-viewer", CONNECTIONS_FILE_NAME);
 }
 function emptyState() {
   return { version: 1, connections: [] };
@@ -18609,9 +18777,9 @@ var init_handle_s3 = __esm(() => {
 });
 
 // web-src/server/database/query-history.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function historyFilePath(root) {
-  return join12(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
+  return join13(root, CODE_VIEWER_DIR3, HISTORY_FILE_NAME);
 }
 function emptyState2() {
   return { version: 1, entries: [] };
@@ -18761,9 +18929,9 @@ var init_query_history = __esm(() => {
 // web-src/server/database/snapshot-store.ts
 import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function getStoreDb(cwd) {
-  const dbPath = join13(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
+  const dbPath = join14(cwd, CODE_VIEWER_DIR4, SNAPSHOT_DB_NAME);
   if (storeDb && storeDbPath === dbPath)
     return storeDb;
   if (storeDb) {
@@ -18771,7 +18939,7 @@ async function getStoreDb(cwd) {
       storeDb.close();
     } catch {}
   }
-  mkdirSync3(join13(cwd, CODE_VIEWER_DIR4), { recursive: true });
+  mkdirSync3(join14(cwd, CODE_VIEWER_DIR4), { recursive: true });
   const DbClass = await loadSqliteClass();
   storeDb = new DbClass(dbPath);
   storeDbPath = dbPath;
@@ -19377,9 +19545,9 @@ var init_snapshot_runner = __esm(() => {
 });
 
 // web-src/server/database/tabs-store.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function tabsFilePath(root) {
-  return join14(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
+  return join15(root, CODE_VIEWER_DIR5, TABS_FILE_NAME);
 }
 function emptyState3() {
   return { version: 1, tabs: [], activeTabId: null };
@@ -21316,7 +21484,7 @@ var init_handle = __esm(() => {
 
 // web-src/server/doctor.ts
 import { accessSync as accessSync2, constants as constants2, readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
-import { dirname as dirname4, join as join15, relative as relative5 } from "node:path";
+import { dirname as dirname5, join as join16, relative as relative6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function statusWorse(a, b) {
   const rank = { ok: 0, warn: 1, error: 2 };
@@ -21405,12 +21573,12 @@ function findCodeViewerPackageJson() {
   try {
     let cursor;
     try {
-      cursor = dirname4(fileURLToPath2(import.meta.url));
+      cursor = dirname5(fileURLToPath2(import.meta.url));
     } catch {
-      cursor = dirname4(process.argv[1] || ".");
+      cursor = dirname5(process.argv[1] || ".");
     }
     for (let depth = 0;depth < 8; depth += 1) {
-      const candidate = join15(cursor, "package.json");
+      const candidate = join16(cursor, "package.json");
       try {
         const raw = readFileSync6(candidate, "utf8");
         const pkg = JSON.parse(raw);
@@ -21418,7 +21586,7 @@ function findCodeViewerPackageJson() {
           return { version: pkg.version, path: candidate };
         }
       } catch {}
-      const next = dirname4(cursor);
+      const next = dirname5(cursor);
       if (next === cursor)
         break;
       cursor = next;
@@ -21506,7 +21674,7 @@ async function checkSqlite(cwd) {
   return { id: "sqlite", title: "SQLite driver", rows };
 }
 async function trySnapshotDbOpen(cwd) {
-  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
+  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
   try {
     statSync5(dbPath);
   } catch {
@@ -21527,8 +21695,8 @@ async function trySnapshotDbOpen(cwd) {
   }
 }
 function checkSnapshotStore(cwd) {
-  const dbPath = join15(cwd, SNAPSHOT_DB_REL);
-  const dir = dirname4(dbPath);
+  const dbPath = join16(cwd, SNAPSHOT_DB_REL);
+  const dir = dirname5(dbPath);
   let dirStatus = "ok";
   let dirDetail = dir;
   let dirHint;
@@ -21601,7 +21769,7 @@ async function checkGit(cwd, signal) {
   if (repoCheck && repoCheck.code === 0 && /true/.test(repoCheck.stdout)) {
     const topRes = await runCached(gitCache, TTL.gitRepo, commandForExternal("git"), ["rev-parse", "--show-toplevel"], TIMEOUT.git, signal, cwd);
     const top = topRes?.stdout.trim() || cwd;
-    const insideCwd = relative5(top, cwd) || ".";
+    const insideCwd = relative6(top, cwd) || ".";
     rows.push({
       id: "git.repo",
       title: "Working tree",
@@ -22354,29 +22522,20 @@ function parseDoctorCliArgs(argv) {
       json2 = true;
       continue;
     }
-    if (arg === "--cwd") {
-      const next = argv[++i];
-      if (!next)
-        return { kind: "error", message: "--cwd requires a value" };
-      cwd = next;
+    const global = takeGlobalCliOption(argv, i, {
+      allowedCommands: ["git", "docker", "gh"]
+    });
+    if (global.kind === "error") {
+      return { kind: "error", message: global.error };
+    }
+    if (global.kind === "cwd") {
+      cwd = global.value;
+      i = global.next;
       continue;
     }
-    if (arg === "--bin") {
-      const next = argv[++i];
-      if (!next) {
-        return {
-          kind: "error",
-          message: "--bin requires <name>=<absolute-path>"
-        };
-      }
-      const parsed = parseExternalCommandOverride(next, "--bin", [
-        "git",
-        "docker",
-        "gh"
-      ]);
-      if (parsed.ok === false)
-        return { kind: "error", message: parsed.error };
-      commandOverrides.push(parsed.override);
+    if (global.kind === "command-override") {
+      commandOverrides.push(global.override);
+      i = global.next;
       continue;
     }
     if (arg === "--port") {
@@ -22503,6 +22662,7 @@ Exit codes:
 `, STATUS_SYMBOL;
 var init_doctor_cli = __esm(() => {
   init_command_resolver();
+  init_cli_helpers();
   init_doctor();
   init_git();
   STATUS_SYMBOL = {
@@ -22529,44 +22689,6 @@ function normalizeNewDirectoryName(name) {
   return trimmed;
 }
 
-// web-src/server/cache.ts
-import { lstatSync as lstatSync3 } from "node:fs";
-import { join as join16 } from "node:path";
-function cacheFresh(cached, now = Date.now(), ttlMs = CACHE_TTL_MS) {
-  return !!cached && now - cached.storedAt <= ttlMs;
-}
-function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MAX_TIMED_CACHE_ENTRIES) {
-  cache.set(key, { ...value, storedAt: now });
-  while (cache.size > maxEntries) {
-    const oldest = cache.keys().next().value;
-    if (oldest === undefined)
-      break;
-    cache.delete(oldest);
-  }
-}
-function worktreeFileSignature(path, cwd) {
-  try {
-    const stats = lstatSync3(join16(cwd, path));
-    const inode = "ino" in stats ? stats.ino : 0;
-    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
-  } catch {
-    return "state:missing";
-  }
-}
-function fileDiffCacheKey(options) {
-  const worktreeTarget = options.range.from === "worktree" || !options.range.to || options.range.to === "worktree";
-  if (options.isUntracked && !worktreeTarget) {
-    throw new Error("untracked file diffs require a worktree range");
-  }
-  const signature = worktreeTarget ? `\x00${worktreeFileSignature(options.path, options.cwd)}` : "";
-  if (options.isUntracked) {
-    return `u\x00${options.path}${signature}\x00${options.extras.join("\x00")}`;
-  }
-  return `t\x00${options.path}\x00${options.oldPath || ""}${signature}\x00${[...options.extras, ...options.args].join("\x00")}`;
-}
-var CACHE_TTL_MS = 1500, MAX_TIMED_CACHE_ENTRIES = 200;
-var init_cache = () => {};
-
 // web-src/server/dev-assets.ts
 import { basename as basename2 } from "node:path";
 function startDevAssetReload(options) {
@@ -22606,9 +22728,7 @@ function emptyJournalTaskState() {
   return { version: 1, tasks: [] };
 }
 function makeJournalId(prefix) {
-  const random = Math.random().toString(36).slice(2, 8);
-  const time = Date.now().toString(36);
-  return `${prefix}-${time}${random}`;
+  return makeTimedId(prefix);
 }
 function optionalString4(value, maxLen) {
   if (typeof value !== "string")
@@ -22762,11 +22882,8 @@ async function updateDailyJournalState(root, updater) {
 async function updateJournalTaskState(root, updater) {
   return journalTaskStore.update(root, updater);
 }
-function insertOptionCount2(input) {
-  return (input.before_id ? 1 : 0) + (input.after_id ? 1 : 0) + (input.position !== undefined ? 1 : 0);
-}
 function taskInsertIndex(tasks, status, input) {
-  if (insertOptionCount2(input) > 1)
+  if (orderedInsertOptionCount(input) > 1)
     return { ok: false, error: "use only one of before, after, or position" };
   if (input.before_id || input.after_id) {
     const anchorId = input.before_id || input.after_id || "";
@@ -22934,6 +23051,16 @@ function addJournalTask(state, input, now, makeId3 = makeJournalId) {
   tasks.splice(insertAt.index, 0, task);
   return { ok: true, state: { version: 1, tasks }, task };
 }
+function journalTaskResult(state, task) {
+  return {
+    ok: true,
+    state: {
+      version: 1,
+      tasks: state.tasks.map((item) => item.id === task.id ? task : item)
+    },
+    task
+  };
+}
 function updateJournalTask(state, id, patch, now) {
   const task = state.tasks.find((item) => item.id === id);
   if (!task)
@@ -22988,14 +23115,7 @@ function updateJournalTask(state, id, patch, now) {
     else
       delete next.journal_entry_id;
   }
-  return {
-    ok: true,
-    state: {
-      version: 1,
-      tasks: state.tasks.map((item) => item.id === id ? next : item)
-    },
-    task: next
-  };
+  return journalTaskResult(state, next);
 }
 function moveJournalTask(state, id, input, now) {
   const source = state.tasks.find((task) => task.id === id);
@@ -23105,8 +23225,7 @@ function claimJournalTask(state, id, input, now) {
   if (!task)
     return { ok: false, error: "task not found" };
   const nowMs = Date.parse(now);
-  const activeClaim = task.claim && Number.isFinite(Date.parse(task.claim.lease_expires_at)) && Date.parse(task.claim.lease_expires_at) > nowMs;
-  if (activeClaim)
+  if (taskClaimActive(task, nowMs))
     return { ok: false, error: "task is already claimed" };
   if (task.status !== "todo" && task.status !== "doing")
     return {
@@ -23117,12 +23236,9 @@ function claimJournalTask(state, id, input, now) {
   const wipLimit = input.wip_limit;
   if (wipLimit !== undefined && wipLimit > 0) {
     const activeDoing = state.tasks.filter((item) => {
-      if (item.status !== "doing" || !item.claim)
+      if (item.status !== "doing" || item.claim?.by !== by)
         return false;
-      if (item.claim.by !== by)
-        return false;
-      const expires = Date.parse(item.claim.lease_expires_at);
-      return Number.isFinite(expires) && expires > nowMs;
+      return taskClaimActive(item, nowMs);
     }).length;
     if (activeDoing >= wipLimit)
       return { ok: false, error: "WIP limit reached" };
@@ -23139,14 +23255,7 @@ function claimJournalTask(state, id, input, now) {
       lease_expires_at: leaseExpiresAt
     }
   };
-  return {
-    ok: true,
-    state: {
-      version: 1,
-      tasks: state.tasks.map((item) => item.id === id ? next : item)
-    },
-    task: next
-  };
+  return journalTaskResult(state, next);
 }
 function completeJournalTask(state, id, input, now, makeId3 = makeJournalId) {
   const task = state.tasks.find((item) => item.id === id);
@@ -23155,8 +23264,7 @@ function completeJournalTask(state, id, input, now, makeId3 = makeJournalId) {
   if (task.status !== "doing")
     return { ok: false, error: "only doing tasks can be completed" };
   const nowMs = Date.parse(now);
-  const activeClaim = task.claim && Number.isFinite(Date.parse(task.claim.lease_expires_at)) && Date.parse(task.claim.lease_expires_at) > nowMs;
-  if (!activeClaim)
+  if (!taskClaimActive(task, nowMs))
     return { ok: false, error: "task must be claimed before completion" };
   const by = optionalString4(input.by, 128);
   if (!by)
@@ -23186,14 +23294,7 @@ function completeJournalTask(state, id, input, now, makeId3 = makeJournalId) {
     ...notes.length ? { notes } : {}
   };
   delete next.claim;
-  return {
-    ok: true,
-    state: {
-      version: 1,
-      tasks: state.tasks.map((item) => item.id === id ? next : item)
-    },
-    task: next
-  };
+  return journalTaskResult(state, next);
 }
 function deleteJournalTask(state, id) {
   const tasks = state.tasks.filter((task) => task.id !== id);
@@ -23229,8 +23330,8 @@ var init_journal2 = __esm(() => {
 });
 
 // web-src/server/search-service.ts
-import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
-import { join as join18, relative as relative6 } from "node:path";
+import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync6 } from "node:fs";
+import { join as join18, relative as relative7 } from "node:path";
 async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
     return rgAvailableCache;
@@ -23266,12 +23367,12 @@ function safeWorktreePath(env, path) {
   let realCwd;
   let realFull;
   try {
-    realCwd = realpathSync5(env.cwd);
-    realFull = realpathSync5(full);
+    realCwd = realpathSync6(env.cwd);
+    realFull = realpathSync6(full);
   } catch {
     return null;
   }
-  const rel = relative6(realCwd, realFull);
+  const rel = relative7(realCwd, realFull);
   if (rel === "" || rel.startsWith("..") || rel.startsWith("/") || rel.startsWith("\\"))
     return null;
   if (isGitInternalPath(rel))
@@ -25015,7 +25116,7 @@ import {
   mkdirSync as mkdirSync4,
   openSync as openSync3,
   readFileSync as readFileSync9,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   renameSync,
   statSync as statSync6,
   unlinkSync as unlinkSync2,
@@ -25023,7 +25124,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname5, extname as extname2, join as join20, relative as relative7 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname as extname2, join as join20, relative as relative8 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2;i < process.argv.length; i++) {
@@ -25077,7 +25178,7 @@ Examples:
         process.exit(1);
       }
       try {
-        cwd = realpathSync6(next);
+        cwd = realpathSync7(next);
         cwdWasExplicit = true;
       } catch {
         console.error("--cwd must point to an existing directory");
@@ -25508,7 +25609,7 @@ function worktreePath(path) {
 function safeOpenWorktreePath(path) {
   if (path === "") {
     try {
-      const realCwd = realpathSync6(cwd);
+      const realCwd = realpathSync7(cwd);
       if (isGitInternalPath(realCwd))
         return null;
       return realCwd;
@@ -25519,7 +25620,7 @@ function safeOpenWorktreePath(path) {
   return safeWorktreePath2(path);
 }
 function parentRepoPath(path) {
-  const parent = dirname5(path);
+  const parent = dirname6(path);
   return parent === "." ? "" : parent;
 }
 function isoDate(ms) {
@@ -25577,6 +25678,21 @@ async function attachTreeEntryMetadata(target, entry) {
     return { ...entry, ...await directoryMetadata(target, entry.path) };
   if (entry.type !== "blob")
     return entry;
+  if (entry.is_symlink && target !== "worktree" && target !== "") {
+    const symlinkMeta = await gitSymlinkTargetMetadataAsync(target, entry.path, cwd);
+    if (symlinkMeta.symlink_target_type === "tree")
+      return {
+        ...entry,
+        ...symlinkMeta,
+        type: "tree",
+        ...await directoryMetadata(target, entry.path)
+      };
+    return {
+      ...entry,
+      ...symlinkMeta,
+      ...await fileMetadataForTarget(target, entry.path)
+    };
+  }
   return { ...entry, ...await fileMetadataForTarget(target, entry.path) };
 }
 async function readReadme(target, dirPath) {
@@ -25599,6 +25715,22 @@ async function readReadme(target, dirPath) {
   }
   return null;
 }
+function deletedTreeEntriesForPath(statusMap, basePath) {
+  const entries = [];
+  for (const [path, status] of statusMap) {
+    if (status !== "D")
+      continue;
+    if (basePath) {
+      if (!path.startsWith(`${basePath}/`))
+        continue;
+    }
+    const rel = basePath ? path.slice(basePath.length + 1) : path;
+    if (!rel || rel.includes("/"))
+      continue;
+    entries.push({ name: rel, path, type: "blob", status: "D" });
+  }
+  return entries;
+}
 async function handleTree(url) {
   const target = url.searchParams.get("ref") || url.searchParams.get("target") || "worktree";
   const path = (url.searchParams.get("path") || "").replace(/^\/+|\/+$/g, "");
@@ -25625,12 +25757,21 @@ async function handleTree(url) {
   if (tree.error)
     return text(tree.error, tree.status ?? 500);
   const entries = tree.entries.filter((entry) => !isExcludedScopePath(entry.path, excludeNames));
+  const statusMap = target === "worktree" || target === "" ? await repoStatusMapAsync(cwd) : null;
+  const withStatus = (entry) => {
+    const status = statusMap?.get(entry.path);
+    return status ? { ...entry, status } : entry;
+  };
+  const deletedEntries = !recursive && statusMap ? deletedTreeEntriesForPath(statusMap, path) : [];
   return json2({
     ref: target,
     path,
     project: basename3(cwd),
     branch: await currentBranchMetadata(),
-    entries: recursive ? entries : await Promise.all(entries.map((entry) => attachTreeEntryMetadata(target, entry))),
+    entries: recursive ? entries.map(withStatus) : [
+      ...await Promise.all(entries.map((entry) => attachTreeEntryMetadata(target, entry).then(withStatus))),
+      ...deletedEntries
+    ],
     readme: await readReadme(target, path),
     upload_enabled: uploadEnabled && (target === "worktree" || target === "")
   });
@@ -26326,7 +26467,7 @@ async function handleUploadFiles(req) {
     if (total > MAX_UPLOAD_TOTAL_BYTES)
       return text("upload too large", 413);
     const target = join20(realDir, safeName);
-    if (relative7(realDir, dirname5(target)) !== "")
+    if (relative8(realDir, dirname6(target)) !== "")
       return text("invalid filename", 400);
     if (existsSync8(target))
       return text("file exists", 409);
@@ -26492,10 +26633,10 @@ async function restoreTrashPath(originalPath, trashPath) {
       return { ok: false, error: "trash item not found" };
     try {
       const trashRoot = join20(homedir3(), ".Trash");
-      const trashRelative = relative7(trashRoot, trashPath);
+      const trashRelative = relative8(trashRoot, trashPath);
       if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
         return { ok: false, error: "invalid trash handle" };
-      mkdirSync4(dirname5(original), { recursive: true });
+      mkdirSync4(dirname6(original), { recursive: true });
       renameSync(trashPath, original);
       return { ok: true };
     } catch (error) {