@moberg_hr/work-tree 1.5.0 → 1.5.1

package/dist/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import fs41 from "fs";
-import path42 from "path";
+import fs44 from "fs";
+import path43 from "path";
 import chalk27 from "chalk";
 
 // src/cli.ts
@@ -309,10 +309,15 @@ function fetchRemote(cwd) {
 }
 async function fetchRemoteAsync(cwd) {
   await new Promise((resolve, reject) => {
-    execFile("git", ["fetch", "--quiet"], { cwd, timeout: 3e4 }, (err) => {
-      if (err) reject(err);
-      else resolve();
-    });
+    execFile(
+      "git",
+      ["fetch", "--quiet"],
+      { cwd, timeout: 3e4, windowsHide: true },
+      (err) => {
+        if (err) reject(err);
+        else resolve();
+      }
+    );
   });
   if (!getDefaultBranch(cwd)) {
     git(["remote", "set-head", "origin", "--auto"], cwd);
@@ -411,7 +416,8 @@ function generateGroupClaudeMd(groupName, repoAliases, config) {
   const result = spawn2.sync("claude", ["-p"], {
     input: prompt,
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   });
   let content;
   if (result.status !== 0 || !result.stdout?.trim()) {
@@ -873,7 +879,11 @@ function getWindowsDocumentsFolder() {
     const result = spawn4.sync(
       exe,
       ["-NoProfile", "-Command", "[Environment]::GetFolderPath('MyDocuments')"],
-      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      }
     );
     if (result.status === 0 && result.stdout) {
       const dir = result.stdout.toString().trim();
@@ -886,7 +896,8 @@ function executableExists(name) {
   const cmd = process.platform === "win32" ? "where" : "which";
   const result = spawn4.sync(cmd, [name], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   });
   return result.status === 0;
 }
@@ -2795,10 +2806,8 @@ function collectPrunable(config, options = {}) {
   for (const [alias, repoPath] of Object.entries(config.repos)) {
     if (!fs19.existsSync(repoPath)) continue;
     if (skipAliases.has(alias)) continue;
-    const worktrees = parseWorktreeList(repoPath);
-    const normalizedRepoPath = path16.resolve(repoPath);
+    const worktrees = parseWorktreeList(repoPath).slice(1);
     for (const wt of worktrees) {
-      if (path16.resolve(wt.path) === normalizedRepoPath) continue;
       if (!wt.branch) continue;
       if (groupCoveredKeys.has(`${alias}:${wt.branch}`)) continue;
       const { merged, into, confidence } = isBranchMerged(wt.branch, repoPath);
@@ -3128,10 +3137,15 @@ import spawn7 from "cross-spawn";
 import { execFile as execFile2 } from "child_process";
 function execAsync(cmd, args, cwd, timeout) {
   return new Promise((resolve, reject) => {
-    execFile2(cmd, args, { cwd, encoding: "utf-8", timeout }, (err, stdout) => {
-      if (err) reject(err);
-      else resolve(stdout ?? "");
-    });
+    execFile2(
+      cmd,
+      args,
+      { cwd, encoding: "utf-8", timeout, windowsHide: true },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout ?? "");
+      }
+    );
   });
 }
 function parsePrJson(stdout, repoAlias, currentUser) {
@@ -3247,10 +3261,15 @@ async function isGhAvailable() {
 import { execFile as execFile3 } from "child_process";
 function execAsync2(cmd, args, timeout) {
   return new Promise((resolve, reject) => {
-    execFile3(cmd, args, { encoding: "utf-8", timeout }, (err, stdout) => {
-      if (err) reject(err);
-      else resolve(stdout ?? "");
-    });
+    execFile3(
+      cmd,
+      args,
+      { encoding: "utf-8", timeout, windowsHide: true },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout ?? "");
+      }
+    );
   });
 }
 async function isAcliAvailable() {
@@ -4665,7 +4684,7 @@ function generateSlug(summary) {
     const child = execFile4(
       "claude",
       ["-p", "--model", "haiku"],
-      { encoding: "utf-8", timeout: 1e4 },
+      { encoding: "utf-8", timeout: 1e4, windowsHide: true },
       (err, stdout) => {
         const result = stdout?.trim().toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/^-|-$/g, "");
         resolve(result || fallback);
@@ -6318,18 +6337,16 @@ var hydrateCommand = {
 };
 
 // src/commands/diff.ts
-import fs32 from "fs";
+import fs35 from "fs";
 import os9 from "os";
-import path31 from "path";
+import path32 from "path";
 import { spawn as childSpawn } from "child_process";
 import chalk21 from "chalk";
 
 // src/core/diff-pipeline.ts
-import fs27 from "fs";
-import os7 from "os";
-import path24 from "path";
-import crypto from "crypto";
-import spawn8 from "cross-spawn";
+import fs28 from "fs";
+import path25 from "path";
+import spawn9 from "cross-spawn";
 
 // src/core/diff-parse.ts
 var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
@@ -6621,19 +6638,65 @@ function coverageLookup(root, relPaths) {
   return { byPath: out, lcovMtimeMs: read.mtimeMs };
 }
 
+// src/core/git-tree-snapshot.ts
+import fs27 from "fs";
+import os7 from "os";
+import path24 from "path";
+import crypto from "crypto";
+import spawn8 from "cross-spawn";
+function writeTempTree(repoRoot, opts = {}) {
+  const includeWorkingTree = opts.includeWorkingTree ?? true;
+  const tmpIndex = path24.join(
+    os7.tmpdir(),
+    `wd-tree-${process.pid}-${crypto.randomBytes(6).toString("hex")}.idx`
+  );
+  const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+  const run2 = (args) => spawn8.sync("git", args, {
+    cwd: repoRoot,
+    encoding: "utf-8",
+    env,
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  try {
+    const headSha = (spawn8.sync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      windowsHide: true
+    }).stdout ?? "").trim() || null;
+    if (headSha) {
+      const r = run2(["read-tree", "HEAD"]);
+      if (r.status !== 0) return null;
+    }
+    if (includeWorkingTree) {
+      const add = run2(["add", "-A"]);
+      if (add.status !== 0) return null;
+    }
+    const wt = run2(["write-tree"]);
+    if (wt.status !== 0 || !wt.stdout) return null;
+    return { treeSha: wt.stdout.trim(), headSha };
+  } finally {
+    try {
+      if (fs27.existsSync(tmpIndex)) fs27.unlinkSync(tmpIndex);
+    } catch {
+    }
+  }
+}
+
 // src/core/diff-pipeline.ts
+var RENAME_DETECT = "-M";
 var MARKDOWN_EXT_RE = /\.(md|markdown|mdx)$/i;
 var MARKDOWN_SIZE_CAP = 256 * 1024;
 function isMarkdownPath(p) {
   return p !== "/dev/null" && MARKDOWN_EXT_RE.test(p);
 }
 function isInsideRoot(root, rel) {
-  const resolvedRoot = path24.resolve(root);
-  const resolvedTarget = path24.resolve(resolvedRoot, rel);
-  const r = path24.relative(resolvedRoot, resolvedTarget);
+  const resolvedRoot = path25.resolve(root);
+  const resolvedTarget = path25.resolve(resolvedRoot, rel);
+  const r = path25.relative(resolvedRoot, resolvedTarget);
   if (r === "") return true;
   if (r.startsWith("..")) return false;
-  if (path24.isAbsolute(r)) return false;
+  if (path25.isAbsolute(r)) return false;
   return true;
 }
 function readMarkdownContent(root, file, fromRef, toRef) {
@@ -6642,7 +6705,7 @@ function readMarkdownContent(root, file, fromRef, toRef) {
     return void 0;
   }
   const showAt = (ref, p) => {
-    const r = spawn8.sync("git", ["show", `${ref}:${p}`], {
+    const r = spawn9.sync("git", ["show", `${ref}:${p}`], {
       cwd: root,
       encoding: "utf-8",
       maxBuffer: 16 * 1024 * 1024,
@@ -6658,12 +6721,12 @@ function readMarkdownContent(root, file, fromRef, toRef) {
   if (file.status !== "deleted" && isMarkdownPath(file.newPath) && isInsideRoot(root, file.newPath)) {
     if (toRef === "working") {
       try {
-        const absPath = path24.join(root, file.newPath);
-        const realRoot2 = fs27.realpathSync(path24.resolve(root));
-        const realPath = fs27.realpathSync(absPath);
-        const sep = path24.sep;
+        const absPath = path25.join(root, file.newPath);
+        const realRoot2 = fs28.realpathSync(path25.resolve(root));
+        const realPath = fs28.realpathSync(absPath);
+        const sep = path25.sep;
         if (realPath === realRoot2 || realPath.startsWith(realRoot2 + sep)) {
-          result.after = fs27.readFileSync(absPath, "utf-8");
+          result.after = fs28.readFileSync(absPath, "utf-8");
         }
       } catch {
       }
@@ -6681,39 +6744,7 @@ function readMarkdownContent(root, file, fromRef, toRef) {
   return result;
 }
 function workingTreeTreeSha(root) {
-  const tmpIndex = path24.join(
-    os7.tmpdir(),
-    `wd-diff-${process.pid}-${crypto.randomBytes(6).toString("hex")}.idx`
-  );
-  const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
-  const run2 = (args) => spawn8.sync("git", args, {
-    cwd: root,
-    encoding: "utf-8",
-    env,
-    windowsHide: true,
-    maxBuffer: 64 * 1024 * 1024
-  });
-  try {
-    const headExists = (spawn8.sync("git", ["rev-parse", "--verify", "HEAD"], {
-      cwd: root,
-      encoding: "utf-8",
-      windowsHide: true
-    }).stdout ?? "").trim().length > 0;
-    if (headExists) {
-      const r = run2(["read-tree", "HEAD"]);
-      if (r.status !== 0) return null;
-    }
-    const add = run2(["add", "-A"]);
-    if (add.status !== 0) return null;
-    const wt = run2(["write-tree"]);
-    if (wt.status !== 0 || !wt.stdout) return null;
-    return wt.stdout.trim();
-  } finally {
-    try {
-      if (fs27.existsSync(tmpIndex)) fs27.unlinkSync(tmpIndex);
-    } catch {
-    }
-  }
+  return writeTempTree(root, { includeWorkingTree: true })?.treeSha ?? null;
 }
 function isBinaryContent(buffer) {
   const len = Math.min(buffer.length, 8192);
@@ -6723,10 +6754,10 @@ function isBinaryContent(buffer) {
   return false;
 }
 function synthesizeUntrackedDiff(root, relPath) {
-  const absPath = path24.join(root, relPath);
+  const absPath = path25.join(root, relPath);
   let buffer;
   try {
-    buffer = fs27.readFileSync(absPath);
+    buffer = fs28.readFileSync(absPath);
   } catch {
     return "";
   }
@@ -6762,11 +6793,13 @@ new file mode 100644
 }
 function computeDiff(opts) {
   const { root, diffArg } = opts;
-  const trackedResult = spawn8.sync(
+  const trackedResult = spawn9.sync(
     "git",
     // -w (ignore-all-space) hides pure whitespace changes so a reformat
-    // of indentation doesn't drown out the real changes.
-    ["diff", "--no-color", "--no-ext-diff", "-w", diffArg],
+    // of indentation doesn't drown out the real changes. RENAME_DETECT turns
+    // on rename detection so a `git mv` (+ edits) shows as one renamed entry
+    // with its inline diff instead of a separate delete + add pair.
+    ["diff", "--no-color", "--no-ext-diff", "-w", RENAME_DETECT, diffArg],
     {
       cwd: root,
       encoding: "utf-8",
@@ -6812,7 +6845,7 @@ function attachCoverage(root, files) {
       f.coverageMtimeMs = lcovMtimeMs;
       let srcMtimeMs = null;
       try {
-        srcMtimeMs = fs27.statSync(path24.join(root, f.path)).mtimeMs;
+        srcMtimeMs = fs28.statSync(path25.join(root, f.path)).mtimeMs;
       } catch {
         srcMtimeMs = null;
       }
@@ -6830,9 +6863,12 @@ function computeRangeDiff(opts) {
     }
     const wtTreeSha = workingTreeTreeSha(root);
     if (!wtTreeSha) return [];
-    const result2 = spawn8.sync(
+    const result2 = spawn9.sync(
       "git",
-      ["diff-tree", "-r", "-p", "--no-color", "--no-ext-diff", fromRef, wtTreeSha],
+      // RENAME_DETECT: detect renames between the checkpoint tree and the
+      // working tree so a rename (with or without edits) renders as one
+      // entry, matching the HEAD-vs-working path above.
+      ["diff-tree", "-r", "-p", RENAME_DETECT, "--no-color", "--no-ext-diff", fromRef, wtTreeSha],
       {
         cwd: root,
         encoding: "utf-8",
@@ -6851,9 +6887,11 @@ function computeRangeDiff(opts) {
     }
     return parsed;
   }
-  const result = spawn8.sync(
+  const result = spawn9.sync(
     "git",
-    ["diff", "--no-color", "--no-ext-diff", fromRef, toRef],
+    // RENAME_DETECT: rename detection between two checkpoint commits (no -w
+    // here — see the note above on why range diffs keep whitespace changes).
+    ["diff", "--no-color", "--no-ext-diff", RENAME_DETECT, fromRef, toRef],
     {
       cwd: root,
       encoding: "utf-8",
@@ -6874,69 +6912,82 @@ function computeRangeDiff(opts) {
 }
 
 // src/core/repo-spec.ts
-import fs28 from "fs";
-import path25 from "path";
+import fs29 from "fs";
+import path26 from "path";
 import os8 from "os";
 import crypto2 from "crypto";
-function stableDiffPath(keyPaths) {
+function scopeHashFor(keyPaths) {
   const key = keyPaths.slice().sort().join("|");
-  const id = crypto2.createHash("sha1").update(key).digest("hex").slice(0, 12);
-  const dir = path25.join(os8.homedir(), ".work", "diffs");
-  fs28.mkdirSync(dir, { recursive: true });
-  return path25.join(dir, id);
+  return crypto2.createHash("sha1").update(key).digest("hex").slice(0, 12);
+}
+function stableDiffPath(keyPaths) {
+  const dir = path26.join(os8.homedir(), ".work", "diffs");
+  fs29.mkdirSync(dir, { recursive: true });
+  return path26.join(dir, scopeHashFor(keyPaths));
 }
 
 // src/core/diff-scope.ts
-import path26 from "path";
+import fs30 from "fs";
+import path27 from "path";
 import chalk18 from "chalk";
 function normPath(p) {
-  return path26.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path27.resolve(p).replace(/\\/g, "/").toLowerCase();
+}
+function realNorm(p) {
+  try {
+    return normPath(fs30.realpathSync(p));
+  } catch {
+    return normPath(p);
+  }
 }
 function resolveScope(cwd) {
   const normCwd = normPath(cwd);
   const sessions = loadHistory();
+  const top = git(["rev-parse", "--show-toplevel"], cwd);
+  const toplevel = top.exitCode === 0 && top.stdout ? top.stdout : null;
+  const realTop = toplevel ? realNorm(toplevel) : null;
   for (const s of sessions) {
     for (const p of s.paths) {
       const np = normPath(p);
       if (normCwd === np || normCwd.startsWith(np + "/")) {
+        if (realTop && realNorm(p) !== realTop) continue;
         if (s.isGroup) {
           return {
             isGroup: true,
             session: s,
-            repos: s.paths.map((rp) => ({ name: path26.basename(rp), root: rp })),
-            activeRepoName: path26.basename(p)
+            repos: s.paths.map((rp) => ({ name: path27.basename(rp), root: rp })),
+            activeRepoName: path27.basename(p)
           };
         }
         return {
           isGroup: false,
           session: s,
-          repos: [{ name: path26.basename(p), root: p }],
-          activeRepoName: path26.basename(p)
+          repos: [{ name: path27.basename(p), root: p }],
+          activeRepoName: path27.basename(p)
         };
       }
     }
   }
   for (const s of sessions) {
     if (!s.isGroup || s.paths.length === 0) continue;
-    const parents = s.paths.map((p) => normPath(path26.dirname(p)));
+    const parents = s.paths.map((p) => normPath(path27.dirname(p)));
     const groupRoot = parents[0];
     if (!parents.every((par) => par === groupRoot)) continue;
     if (normCwd === groupRoot || normCwd.startsWith(groupRoot + "/")) {
       return {
         isGroup: true,
         session: s,
-        repos: s.paths.map((rp) => ({ name: path26.basename(rp), root: rp })),
+        repos: s.paths.map((rp) => ({ name: path27.basename(rp), root: rp })),
         activeRepoName: null
       };
     }
   }
-  const toplevel = git(["rev-parse", "--show-toplevel"], cwd);
-  if (toplevel.exitCode !== 0 || !toplevel.stdout) return null;
+  if (!toplevel) return null;
   return {
     isGroup: false,
     session: null,
-    repos: [{ name: path26.basename(toplevel.stdout), root: toplevel.stdout }],
-    activeRepoName: path26.basename(toplevel.stdout)
+    repos: [{ name: path27.basename(toplevel), root: toplevel }],
+    activeRepoName: path27.basename(toplevel)
   };
 }
 function findAnyParentBranch(cwd) {
@@ -7004,7 +7055,7 @@ function resolveRepoDiff(root, base, sessionBaseBranch) {
   if (base === "uncommitted") {
     return { resolvedBase: "HEAD", diffArg: "HEAD" };
   }
-  const parent = sessionBaseBranch ?? findAnyParentBranch(root);
+  const parent = sessionBaseBranch ?? detectParentBranch(root) ?? findAnyParentBranch(root);
   if (!parent) return { resolvedBase: "HEAD", diffArg: "HEAD" };
   let diffArg = "HEAD";
   const mb = git(["merge-base", parent, "HEAD"], root);
@@ -7099,36 +7150,86 @@ import { serve } from "@hono/node-server";
 import { streamSSE } from "hono/streaming";
 
 // src/core/fs-watcher.ts
-import path27 from "path";
+import fs31 from "fs";
+import path28 from "path";
 import chalk19 from "chalk";
 import chokidar from "chokidar";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "bin",
+  // .NET build output
+  "obj",
+  // .NET build output
+  "dist",
+  "build",
+  "out",
+  "target",
+  // Rust / JVM
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".gradle",
+  "coverage",
+  ".vs",
+  ".idea"
+]);
+function isIgnoredWatchPath(roots, filePath) {
+  for (const root of roots) {
+    const rel = path28.relative(root, filePath).replace(/\\/g, "/");
+    if (rel === "" || rel.startsWith("../")) continue;
+    if (rel.split("/").some((seg) => IGNORED_DIRS.has(seg))) return true;
+  }
+  return false;
+}
+var SUPPORTS_RECURSIVE_WATCH = process.platform === "darwin" || process.platform === "win32";
+function logWatchError(err) {
+  process.stderr.write(
+    chalk19.yellow("[watcher] fs error: ") + err.message + "\n"
+  );
+}
 function createFsWatcher(opts) {
   const debounceMs = opts.debounceMs ?? 150;
   let debounceTimer = null;
-  const watcher = chokidar.watch(opts.roots, {
-    ignored: (filePath) => {
-      for (const root of opts.roots) {
-        const rel = path27.relative(root, filePath).replace(/\\/g, "/");
-        if (rel === ".git" || rel.startsWith(".git/")) return true;
-      }
-      return false;
-    },
-    ignoreInitial: true,
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 20 }
-  });
-  watcher.on("all", () => {
+  const fire = () => {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
       debounceTimer = null;
       opts.onChange();
     }, debounceMs);
+  };
+  if (SUPPORTS_RECURSIVE_WATCH) {
+    const watchers = opts.roots.map((root) => {
+      const w = fs31.watch(root, { recursive: true }, (_event, filename) => {
+        if (filename && isIgnoredWatchPath([root], path28.join(root, filename.toString()))) {
+          return;
+        }
+        fire();
+      });
+      w.on("error", logWatchError);
+      return w;
+    });
+    return {
+      stop() {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        for (const w of watchers) {
+          try {
+            w.close();
+          } catch {
+          }
+        }
+      }
+    };
+  }
+  const watcher = chokidar.watch(opts.roots, {
+    ignored: (filePath) => isIgnoredWatchPath(opts.roots, filePath),
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 20 }
   });
-  watcher.on("error", (err) => {
-    process.stderr.write(
-      chalk19.yellow("[watcher] fs error: ") + err.message + "\n"
-    );
-  });
+  watcher.on("all", fire);
+  watcher.on("error", logWatchError);
   return {
     stop() {
       if (debounceTimer) clearTimeout(debounceTimer);
@@ -7139,30 +7240,30 @@ function createFsWatcher(opts) {
 }
 
 // src/core/web-static.ts
-import fs29 from "fs";
-import path28 from "path";
+import fs32 from "fs";
+import path29 from "path";
 import { fileURLToPath } from "url";
 function resolveWebRoot() {
-  const entryDir = path28.dirname(process.argv[1] ?? "");
-  const moduleDir = path28.dirname(fileURLToPath(import.meta.url));
+  const entryDir = path29.dirname(process.argv[1] ?? "");
+  const moduleDir = path29.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path28.join(entryDir, "web"),
+    path29.join(entryDir, "web"),
     // bundled: this module is inlined into dist/<bin>.js, so dist/web is a
     // sibling of the bundle. Works even when argv[1] is an npm bin symlink
     // (which is not realpath'd, so the entryDir candidate above misses).
-    path28.join(moduleDir, "web"),
+    path29.join(moduleDir, "web"),
     // dev/tsx fallback: walk up from src/core to repo root then into dist/web.
-    path28.resolve(moduleDir, "../../dist/web")
+    path29.resolve(moduleDir, "../../dist/web")
   ];
   for (const c of candidates) {
-    if (fs29.existsSync(path28.join(c, "index.html"))) return c;
+    if (fs32.existsSync(path29.join(c, "index.html"))) return c;
   }
   return null;
 }
 
 // src/core/spa-handler.ts
-import fs30 from "fs";
-import path29 from "path";
+import fs33 from "fs";
+import path30 from "path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -7176,18 +7277,18 @@ var MIME = {
 function readFile(root, relPath) {
   const clean = relPath.split("?")[0];
   const requested = clean === "/" ? "/index.html" : clean;
-  const filePath = path29.join(root, requested);
-  const norm = path29.normalize(filePath);
-  if (!norm.startsWith(path29.normalize(root))) return null;
+  const filePath = path30.join(root, requested);
+  const norm = path30.normalize(filePath);
+  if (!norm.startsWith(path30.normalize(root))) return null;
   let stat;
   try {
-    stat = fs30.statSync(norm);
+    stat = fs33.statSync(norm);
   } catch {
     return null;
   }
   if (!stat.isFile()) return null;
-  const ext = path29.extname(norm).toLowerCase();
-  return { body: fs30.readFileSync(norm), ext };
+  const ext = path30.extname(norm).toLowerCase();
+  return { body: fs33.readFileSync(norm), ext };
 }
 function serveSpa(c, webRoot) {
   const url = new URL(c.req.url);
@@ -7222,15 +7323,23 @@ async function startDiffServer(opts) {
     for (const cb of sseListeners) cb(payload);
   }
   const app = new Hono();
-  app.get(
-    "/api/context",
-    (c) => c.json({
+  app.get("/api/context", (c) => {
+    const primaryRoot = opts.repos[0]?.root;
+    let headBranch;
+    if (primaryRoot) {
+      const head = git(["rev-parse", "--abbrev-ref", "HEAD"], primaryRoot);
+      if (head.exitCode === 0 && head.stdout && head.stdout !== "HEAD") {
+        headBranch = head.stdout;
+      }
+    }
+    return c.json({
       mode: "review",
       scopeLabel: opts.scopeLabel,
       repos: opts.repos.map((r) => ({ name: r.name })),
-      readOnly: !!opts.readOnly
-    })
-  );
+      readOnly: !!opts.readOnly,
+      headBranch
+    });
+  });
   app.get("/api/diff", (c) => {
     const base = c.req.query("base") === "branch" ? "branch" : "uncommitted";
     try {
@@ -7421,16 +7530,6 @@ async function startCommentServer(opts) {
     stop: () => server.stop()
   };
 }
-async function startReadOnlyDiffServer(opts) {
-  const server = await startDiffServer({
-    repos: opts.repos,
-    scopeLabel: opts.scopeLabel,
-    sessionBaseBranch: opts.sessionBaseBranch,
-    watchDebounceMs: opts.watchDebounceMs,
-    readOnly: true
-  });
-  return { url: server.url, stop: () => server.stop() };
-}
 function formatSingleComment(c) {
   const bodyLines = c.body.split("\n").map((l) => `> ${l}`).join("\n");
   const header = c.side === "general" ? `**General review comment**` : `**${c.repo}/${c.file}** : line ${c.line} (${c.side})`;
@@ -7462,8 +7561,8 @@ function diffReviewSnapshot(snapshot, seen) {
 }
 
 // src/core/static-renderer.ts
-import fs31 from "fs";
-import path30 from "path";
+import fs34 from "fs";
+import path31 from "path";
 function buildDiff(specs, resolvedBase) {
   return {
     repos: specs.map((r) => ({
@@ -7479,8 +7578,8 @@ function renderStatic(opts) {
   if (!webRoot) {
     throw new Error("Could not find dist/web/. Run `npm run build` first.");
   }
-  const shellPath = path30.join(webRoot, "index.html");
-  let shell = fs31.readFileSync(shellPath, "utf-8");
+  const shellPath = path31.join(webRoot, "index.html");
+  let shell = fs34.readFileSync(shellPath, "utf-8");
   const uncommitted = buildDiff(opts.uncommitted, "HEAD");
   const branch = opts.branch ? buildDiff(opts.branch.specs, opts.branch.resolvedBase) : void 0;
   const initialBase = opts.initialBase ?? "uncommitted";
@@ -7529,10 +7628,10 @@ function escapeForScriptTag(json) {
 }
 function readAsset(webRoot, urlPath) {
   const clean = urlPath.split("?")[0].replace(/^\//, "");
-  const full = path30.join(webRoot, clean);
-  if (!path30.normalize(full).startsWith(path30.normalize(webRoot))) return null;
+  const full = path31.join(webRoot, clean);
+  if (!path31.normalize(full).startsWith(path31.normalize(webRoot))) return null;
   try {
-    return fs31.readFileSync(full, "utf-8");
+    return fs34.readFileSync(full, "utf-8");
   } catch {
     return null;
   }
@@ -7542,108 +7641,85 @@ function readAsset(webRoot, urlPath) {
 function info(message) {
   process.stderr.write(message + "\n");
 }
-function isPidAlive(pid) {
+function scopePathStem(repoSpecs) {
+  return stableDiffPath(repoSpecs.map((r) => r.root));
+}
+async function runStop(repoSpecs) {
+  const webUrl = readWebUrl();
+  if (!webUrl) {
+    info(chalk21.gray("No work web running \u2014 nothing to stop."));
+    return;
+  }
+  const hash = stableDiffPath(repoSpecs.map((r) => r.root)).split(/[\\/]/).pop();
   try {
-    process.kill(pid, 0);
-    return true;
+    const res = await fetch(`${webUrl}api/scopes/${hash}`, {
+      method: "DELETE"
+    });
+    if (res.ok) {
+      info(chalk21.gray("De-registered this scope from work web."));
+    } else {
+      info(
+        chalk21.yellow(
+          `work web responded ${res.status} \u2014 scope may not have been registered.`
+        )
+      );
+    }
+  } catch (err) {
+    console.error(
+      chalk21.red("Could not reach work web:"),
+      err.message
+    );
+  }
+}
+function webUrlFilePath() {
+  return path32.join(os9.homedir(), ".work", "web.url");
+}
+function resolveWorkBinPath(selfArgv1) {
+  let real = selfArgv1;
+  try {
+    real = fs35.realpathSync(selfArgv1);
   } catch {
-    return false;
   }
+  if (real.endsWith("wd-bin.js")) {
+    return path32.join(path32.dirname(real), "bin.js");
+  }
+  return real;
 }
-function readPid(pidPath) {
+function readWebUrl() {
   try {
-    const raw = fs32.readFileSync(pidPath, "utf-8").trim();
-    const n = Number(raw);
-    return Number.isFinite(n) && n > 0 ? n : null;
+    const v = fs35.readFileSync(webUrlFilePath(), "utf-8").trim();
+    return v || null;
   } catch {
     return null;
   }
 }
-function spawnDaemon(extraArgs, logPath2) {
-  const out = fs32.openSync(logPath2, "a");
+async function ensureWorkWebRunning() {
+  const existing = readWebUrl();
+  if (existing) return existing;
+  const workBin = resolveWorkBinPath(process.argv[1]);
+  const out = fs35.openSync(
+    path32.join(os9.homedir(), ".work", "web-autostart.log"),
+    "a"
+  );
   const child = childSpawn(
     process.execPath,
-    [process.argv[1], ...extraArgs, "--watch-daemon"],
+    [workBin, "web", "--lean", "--no-open"],
     {
       detached: true,
       stdio: ["ignore", out, out],
-      windowsHide: true,
-      cwd: process.cwd()
+      windowsHide: true
+      // Inherit cwd doesn't matter for work web — its file-watches use
+      // ~/.work paths exclusively.
     }
   );
   child.unref();
-  fs32.closeSync(out);
-  return child.pid ?? 0;
-}
-function pathsForScope(repoSpecs) {
-  const base = stableDiffPath(repoSpecs.map((r) => r.root));
-  return {
-    base,
-    pid: `${base}.pid`,
-    log: `${base}.log`,
-    url: `${base}.url`
-  };
-}
-function runStop(paths) {
-  const pid = readPid(paths.pid);
-  if (pid && isPidAlive(pid)) {
-    try {
-      process.kill(pid);
-      info(chalk21.gray(`Stopped watcher (PID ${pid}).`));
-    } catch (err) {
-      console.error(chalk21.red("Failed to stop watcher:"), err.message);
-    }
-  } else {
-    info(chalk21.gray("No watcher running for this scope."));
-  }
-  try {
-    fs32.unlinkSync(paths.pid);
-  } catch {
-  }
-  try {
-    fs32.unlinkSync(paths.url);
-  } catch {
-  }
-}
-async function runDaemon(ctx) {
-  fs32.writeFileSync(ctx.paths.pid, String(process.pid));
-  const handle = await startReadOnlyDiffServer({
-    repos: ctx.repoSpecs,
-    scopeLabel: ctx.scopeLabel,
-    sessionBaseBranch: ctx.scope.session?.baseBranch
-  });
-  fs32.writeFileSync(ctx.paths.url, handle.url);
-  info(
-    chalk21.gray(
-      `[live] watcher started, pid=${process.pid}, repos=${ctx.repoSpecs.map((r) => r.name).join(",")}, base=${ctx.base}, url=${handle.url}`
-    )
-  );
-  const shutdown = () => {
-    handle.stop();
-    try {
-      fs32.unlinkSync(ctx.paths.pid);
-    } catch {
-    }
-    try {
-      fs32.unlinkSync(ctx.paths.url);
-    } catch {
-    }
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  await new Promise(() => {
-  });
+  fs35.closeSync(out);
+  const url = await waitForUrlFile(webUrlFilePath(), 5e3);
+  return url;
 }
 async function tryRegisterWithWorkWeb(ctx, routeKind) {
-  const webUrlFile = path31.join(os9.homedir(), ".work", "web.url");
-  let webUrl;
-  try {
-    webUrl = fs32.readFileSync(webUrlFile, "utf-8").trim();
-    if (!webUrl) return null;
-  } catch {
-    return null;
-  }
+  const webUrl = await ensureWorkWebRunning();
+  if (!webUrl) return null;
   try {
     const res = await fetch(`${webUrl}api/scopes`, {
       method: "POST",
@@ -7664,42 +7740,19 @@ async function tryRegisterWithWorkWeb(ctx, routeKind) {
 async function runLauncher(ctx) {
   const webRouteUrl = await tryRegisterWithWorkWeb(ctx, "diff");
   if (webRouteUrl) {
-    info(chalk21.gray(`Opening in work web: ${webRouteUrl}`));
+    info(chalk21.gray(`Opening: ${webRouteUrl}`));
     openUrl(webRouteUrl);
     return;
   }
-  const existing = readPid(ctx.paths.pid);
-  let url = null;
-  if (existing && isPidAlive(existing)) {
-    info(chalk21.gray(`Watcher already running (PID ${existing}).`));
-    try {
-      url = fs32.readFileSync(ctx.paths.url, "utf-8").trim();
-    } catch {
-    }
-  } else {
-    try {
-      fs32.unlinkSync(ctx.paths.pid);
-    } catch {
-    }
-    try {
-      fs32.unlinkSync(ctx.paths.url);
-    } catch {
-    }
-    const passthrough = process.argv.slice(2).filter((a) => a !== "--stop" && a !== "--watch");
-    const pid = spawnDaemon(passthrough, ctx.paths.log);
-    info(chalk21.gray(`Started watcher (PID ${pid}). Log: ${ctx.paths.log}`));
-    info(chalk21.gray("Stop with: wd --stop"));
-    url = await waitForUrlFile(ctx.paths.url, 3e3);
-  }
-  if (!url) {
-    console.error(
-      chalk21.red("Watcher did not report a URL \u2014 check the log:"),
-      ctx.paths.log
-    );
-    return;
-  }
-  info(chalk21.gray(`URL: ${url}`));
-  openUrl(url);
+  console.error(
+    chalk21.red("Could not start or reach work web.")
+  );
+  console.error(
+    chalk21.gray(
+      `Tail ~/.work/web-autostart.log for diagnostics, or run \`work web\` in another shell to inspect startup directly.`
+    )
+  );
+  process.exitCode = 1;
 }
 function runStatic(ctx, initialBranch) {
   const uncommitted = buildRepoSpecs(ctx.scope, "HEAD");
@@ -7727,8 +7780,8 @@ function runStatic(ctx, initialBranch) {
     branch,
     initialBase: initialBranch && branch ? "branch" : "uncommitted"
   });
-  const filePath = `${ctx.paths.base}.html`;
-  fs32.writeFileSync(filePath, html, "utf-8");
+  const filePath = `${ctx.scopeStem}.html`;
+  fs35.writeFileSync(filePath, html, "utf-8");
   info(chalk21.gray(`Wrote ${filePath}`));
   openUrl(`file:///${filePath.replace(/\\/g, "/")}`);
 }
@@ -7737,7 +7790,7 @@ function waitForUrlFile(filePath, timeoutMs) {
     const start = Date.now();
     const tick = () => {
       try {
-        const v = fs32.readFileSync(filePath, "utf-8").trim();
+        const v = fs35.readFileSync(filePath, "utf-8").trim();
         if (v) return resolve(v);
       } catch {
       }
@@ -7748,14 +7801,8 @@ function waitForUrlFile(filePath, timeoutMs) {
   });
 }
 async function tryReviewViaWorkWeb(ctx) {
-  const webUrlFile = path31.join(os9.homedir(), ".work", "web.url");
-  let webUrl;
-  try {
-    webUrl = fs32.readFileSync(webUrlFile, "utf-8").trim();
-    if (!webUrl) return false;
-  } catch {
-    return false;
-  }
+  const webUrl = await ensureWorkWebRunning();
+  if (!webUrl) return false;
   let hash;
   try {
     const res = await fetch(`${webUrl}api/scopes`, {
@@ -7944,12 +7991,7 @@ var diffCommand = {
   }).option("stop", {
     type: "boolean",
     default: false,
-    describe: "Stop the background server for this scope."
-  }).option("watch-daemon", {
-    type: "boolean",
-    default: false,
-    hidden: true,
-    describe: "Internal: run the foreground watcher loop."
+    describe: "De-register this scope from work web. The work web server itself keeps running; use `work web --stop` to terminate the server."
   }).option("comments", {
     type: "boolean",
     alias: "c",
@@ -7967,7 +8009,8 @@ var diffCommand = {
       branch: argv.branch
     });
     const repoSpecs = buildRepoSpecs(scope, base);
-    const paths = pathsForScope(repoSpecs);
+    const scopeStem = scopePathStem(repoSpecs);
+    if (argv.stop) return runStop(repoSpecs);
     if (base === "HEAD") {
       info(chalk21.gray("Showing uncommitted changes vs HEAD."));
     } else {
@@ -7983,11 +8026,9 @@ var diffCommand = {
       base,
       baseSource,
       repoSpecs,
-      paths,
+      scopeStem,
       scopeLabel
     };
-    if (argv.stop) return runStop(ctx.paths);
-    if (argv["watch-daemon"]) return runDaemon(ctx);
     if (argv.comments) return runReview(ctx);
     if (argv.static) return runStatic(ctx, !!argv.branch);
     return runLauncher(ctx);
@@ -7995,21 +8036,21 @@ var diffCommand = {
 };
 
 // src/commands/web.ts
-import fs37 from "fs";
+import fs40 from "fs";
 import os13 from "os";
-import path40 from "path";
+import path41 from "path";
 import chalk23 from "chalk";
 
 // src/core/web-server.ts
-import fs36 from "fs";
+import fs39 from "fs";
 import os12 from "os";
-import path39 from "path";
+import path40 from "path";
 import chalk22 from "chalk";
 import { Hono as Hono3 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
 
 // src/core/web-state.ts
-import path32 from "path";
+import path33 from "path";
 import crypto4 from "crypto";
 import chokidar2 from "chokidar";
 function sessionIdFor(s) {
@@ -8030,7 +8071,7 @@ function subscribeSession(sessionId, onChange) {
     const watcher = chokidar2.watch(roots, {
       ignored: (filePath) => {
         for (const r of roots) {
-          const rel = path32.relative(r, filePath).replace(/\\/g, "/");
+          const rel = path33.relative(r, filePath).replace(/\\/g, "/");
           if (rel === ".git" || rel.startsWith(".git/")) return true;
         }
         return false;
@@ -8144,24 +8185,24 @@ function disposeAllPtys() {
 }
 
 // src/core/comment-file-store.ts
-import fs33 from "fs";
-import path33 from "path";
+import fs36 from "fs";
+import path34 from "path";
 import os10 from "os";
 function commentsDir() {
-  return path33.join(os10.homedir(), ".work", "comments");
+  return path34.join(os10.homedir(), ".work", "comments");
 }
 function ensureDir() {
-  fs33.mkdirSync(commentsDir(), { recursive: true });
+  fs36.mkdirSync(commentsDir(), { recursive: true });
 }
 function commentsFileFor(sessionId) {
-  return path33.join(commentsDir(), `${sessionId}.json`);
+  return path34.join(commentsDir(), `${sessionId}.json`);
 }
 function pathFor(sessionId) {
   return commentsFileFor(sessionId);
 }
 function readDisk(sessionId) {
   try {
-    const raw = fs33.readFileSync(pathFor(sessionId), "utf-8");
+    const raw = fs36.readFileSync(pathFor(sessionId), "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -8233,29 +8274,29 @@ function clearCommentStoreCache() {
 }
 
 // src/core/pending-delivery.ts
-import fs34 from "fs";
-import path34 from "path";
+import fs37 from "fs";
+import path35 from "path";
 function pathFor2(sessionId) {
   return {
     comments: commentsFileFor(sessionId),
-    delivered: path34.join(commentsDir(), `${sessionId}.delivered.json`)
+    delivered: path35.join(commentsDir(), `${sessionId}.delivered.json`)
   };
 }
 function readJson(filePath, fallback) {
   try {
-    return JSON.parse(fs34.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs37.readFileSync(filePath, "utf8"));
   } catch {
     return fallback;
   }
 }
 function writeAtomic2(filePath, content) {
-  fs34.mkdirSync(path34.dirname(filePath), { recursive: true });
+  fs37.mkdirSync(path35.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  fs34.writeFileSync(tmp, content, "utf-8");
-  fs34.renameSync(tmp, filePath);
+  fs37.writeFileSync(tmp, content, "utf-8");
+  fs37.renameSync(tmp, filePath);
 }
 function normalize(p) {
-  return path34.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path35.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function findSessionForCwd(cwd) {
   const norm = normalize(cwd);
@@ -8276,13 +8317,40 @@ function findSessionForCwd(cwd) {
   }
   return best?.session ?? null;
 }
+function isPendingFor(delivered) {
+  return (c) => c.status === "published" && c.author === "user" && !delivered.has(c.id);
+}
 function readPendingForSession(sessionId) {
   const paths = pathFor2(sessionId);
   const comments = getCommentFileStore(sessionId).snapshot();
   const delivered = new Set(readJson(paths.delivered, []));
-  return comments.filter(
-    (c) => c.status === "published" && c.author === "user" && !delivered.has(c.id)
+  return comments.filter(isPendingFor(delivered));
+}
+function scopeStoreIdsForPaths(paths) {
+  const resolved = paths.map((p) => path35.resolve(p));
+  const ids = /* @__PURE__ */ new Set();
+  ids.add(`scope-${scopeHashFor(resolved)}`);
+  for (const p of resolved) ids.add(`scope-${scopeHashFor([p])}`);
+  return [...ids];
+}
+function readPendingForWorktree(session) {
+  const sessionId = sessionIdFor(session);
+  const delivered = new Set(
+    readJson(pathFor2(sessionId).delivered, [])
   );
+  const pending = isPendingFor(delivered);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const collect = (storeId) => {
+    for (const c of getCommentFileStore(storeId).snapshot()) {
+      if (seen.has(c.id) || !pending(c)) continue;
+      seen.add(c.id);
+      out.push(c);
+    }
+  };
+  collect(sessionId);
+  for (const storeId of scopeStoreIdsForPaths(session.paths)) collect(storeId);
+  return out;
 }
 function markDelivered(sessionId, ids) {
   if (ids.length === 0) return;
@@ -8582,8 +8650,8 @@ function mountPanesRoutes(app, opts) {
 }
 
 // src/core/worktree-routes.ts
-import path35 from "path";
-import { spawn as spawn9 } from "child_process";
+import path36 from "path";
+import { spawn as spawn10 } from "child_process";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { z as z3 } from "zod";
 function mountWorktreeRoutes(app, opts) {
@@ -8706,10 +8774,10 @@ function mountWorktreeRoutes(app, opts) {
     const id = c.req.param("id");
     const session = findSession2(id);
     if (!session) return c.json({ error: "unknown session" }, 404);
-    const target = session.isGroup ? path35.dirname(session.paths[0]) : session.paths[0];
+    const target = session.isGroup ? path36.dirname(session.paths[0]) : session.paths[0];
     try {
       const cmd = process.platform === "win32" ? "code.cmd" : "code";
-      const child = spawn9(cmd, [target], {
+      const child = spawn10(cmd, [target], {
         detached: true,
         stdio: "ignore",
         shell: false
@@ -8726,28 +8794,27 @@ function mountWorktreeRoutes(app, opts) {
 import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { z as z4 } from "zod";
 import { EventEmitter } from "events";
-import path38 from "path";
-import spawn11 from "cross-spawn";
+import path39 from "path";
+import spawn12 from "cross-spawn";
 
 // src/core/checkpoint.ts
-import fs35 from "fs";
+import fs38 from "fs";
 import os11 from "os";
-import path36 from "path";
-import crypto5 from "crypto";
-import spawn10 from "cross-spawn";
+import path37 from "path";
+import spawn11 from "cross-spawn";
 function manifestPath(scopeHash) {
-  const dir = path36.join(os11.homedir(), ".work", "diffs");
-  fs35.mkdirSync(dir, { recursive: true });
-  return path36.join(dir, `${scopeHash}.checkpoints.json`);
+  const dir = path37.join(os11.homedir(), ".work", "diffs");
+  fs38.mkdirSync(dir, { recursive: true });
+  return path37.join(dir, `${scopeHash}.checkpoints.json`);
 }
 function emptyManifest(scopeHash) {
   return { version: 1, scopeHash, entries: [] };
 }
 function loadManifest(scopeHash) {
   const file = manifestPath(scopeHash);
-  if (!fs35.existsSync(file)) return emptyManifest(scopeHash);
+  if (!fs38.existsSync(file)) return emptyManifest(scopeHash);
   try {
-    const raw = fs35.readFileSync(file, "utf-8");
+    const raw = fs38.readFileSync(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !Array.isArray(parsed.entries)) {
       return emptyManifest(scopeHash);
@@ -8761,68 +8828,37 @@ function loadManifest(scopeHash) {
     return emptyManifest(scopeHash);
   }
 }
-function snapshotRepo(repoRoot, scopeHash, id) {
-  const tmpIndex = path36.join(
-    os11.tmpdir(),
-    `wd-cp-${process.pid}-${crypto5.randomBytes(6).toString("hex")}.idx`
-  );
-  const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
-  const run2 = (args) => spawn10.sync("git", args, {
+function snapshotRepo(repoRoot, scopeHash, id, includeWorkingTree = true) {
+  const tree = writeTempTree(repoRoot, { includeWorkingTree });
+  if (!tree) return null;
+  const { treeSha, headSha } = tree;
+  const commitArgs = ["commit-tree", treeSha, "-m", "wd checkpoint"];
+  if (headSha) commitArgs.push("-p", headSha);
+  const commitEnv = {
+    ...process.env,
+    GIT_AUTHOR_NAME: "wd",
+    GIT_AUTHOR_EMAIL: "wd@local",
+    GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z",
+    GIT_COMMITTER_NAME: "wd",
+    GIT_COMMITTER_EMAIL: "wd@local",
+    GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
+  };
+  const commit = spawn11.sync("git", commitArgs, {
     cwd: repoRoot,
     encoding: "utf-8",
-    env,
-    windowsHide: true,
-    maxBuffer: 64 * 1024 * 1024
+    env: commitEnv,
+    windowsHide: true
   });
-  try {
-    const headSha = (spawn10.sync("git", ["rev-parse", "--verify", "HEAD"], {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      windowsHide: true
-    }).stdout ?? "").trim();
-    const hasHead = headSha.length > 0;
-    if (hasHead) {
-      const r = run2(["read-tree", "HEAD"]);
-      if (r.status !== 0) return null;
-    }
-    const add = run2(["add", "-A"]);
-    if (add.status !== 0) return null;
-    const wt = run2(["write-tree"]);
-    if (wt.status !== 0 || !wt.stdout) return null;
-    const treeSha = wt.stdout.trim();
-    const commitArgs = ["commit-tree", treeSha, "-m", "wd checkpoint"];
-    if (hasHead) commitArgs.push("-p", headSha);
-    const commitEnv = {
-      ...process.env,
-      GIT_AUTHOR_NAME: "wd",
-      GIT_AUTHOR_EMAIL: "wd@local",
-      GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z",
-      GIT_COMMITTER_NAME: "wd",
-      GIT_COMMITTER_EMAIL: "wd@local",
-      GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
-    };
-    const commit = spawn10.sync("git", commitArgs, {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      env: commitEnv,
-      windowsHide: true
-    });
-    if (commit.status !== 0 || !commit.stdout) return null;
-    const commitSha = commit.stdout.trim();
-    const refName = `refs/wd/${scopeHash}/${id}`;
-    const updateRef = spawn10.sync(
-      "git",
-      ["update-ref", refName, commitSha],
-      { cwd: repoRoot, encoding: "utf-8", windowsHide: true }
-    );
-    if (updateRef.status !== 0) return null;
-    return commitSha;
-  } finally {
-    try {
-      if (fs35.existsSync(tmpIndex)) fs35.unlinkSync(tmpIndex);
-    } catch {
-    }
-  }
+  if (commit.status !== 0 || !commit.stdout) return null;
+  const commitSha = commit.stdout.trim();
+  const refName = `refs/wd/${scopeHash}/${id}`;
+  const updateRef = spawn11.sync("git", ["update-ref", refName, commitSha], {
+    cwd: repoRoot,
+    encoding: "utf-8",
+    windowsHide: true
+  });
+  if (updateRef.status !== 0) return null;
+  return commitSha;
 }
 async function takeCheckpoint(scopeHash, repos, opts = {}) {
   const file = manifestPath(scopeHash);
@@ -8833,12 +8869,17 @@ async function takeCheckpoint(scopeHash, repos, opts = {}) {
     const nextId = isFirst ? 0 : manifest.entries[manifest.entries.length - 1].id + 1;
     const captured = {};
     for (const repo of repos) {
-      captured[repo.name] = snapshotRepo(repo.root, scopeHash, nextId);
+      captured[repo.name] = snapshotRepo(
+        repo.root,
+        scopeHash,
+        nextId,
+        !isFirst
+      );
     }
     const rollbackRefs = () => {
       const refName = `refs/wd/${scopeHash}/${nextId}`;
       for (const repo of repos) {
-        spawn10.sync("git", ["update-ref", "-d", refName], {
+        spawn11.sync("git", ["update-ref", "-d", refName], {
           cwd: repo.root,
           encoding: "utf-8",
           windowsHide: true
@@ -8851,10 +8892,22 @@ async function takeCheckpoint(scopeHash, repos, opts = {}) {
     }
     if (!opts.force && !isFirst) {
       const prev = manifest.entries[manifest.entries.length - 1];
-      const allMatch = Object.keys(captured).every(
-        (k) => captured[k] === prev.repos[k]
-      );
-      if (allMatch) {
+      const treeOf = (root, commitSha) => {
+        if (!commitSha) return null;
+        const r = spawn11.sync(
+          "git",
+          ["rev-parse", `${commitSha}^{tree}`],
+          { cwd: root, encoding: "utf-8", windowsHide: true }
+        );
+        if (r.status !== 0 || typeof r.stdout !== "string") return null;
+        return r.stdout.trim() || null;
+      };
+      const allTreesMatch = repos.every((repo) => {
+        const curTree = treeOf(repo.root, captured[repo.name]);
+        const prevTree = treeOf(repo.root, prev.repos[repo.name] ?? null);
+        return curTree !== null && curTree === prevTree;
+      });
+      if (allTreesMatch) {
         rollbackRefs();
         return null;
       }
@@ -8876,7 +8929,7 @@ function clearCheckpoints(scopeHash, repoRoots) {
   for (const root of repoRoots) {
     for (const entry of manifest.entries) {
       const refName = `refs/wd/${scopeHash}/${entry.id}`;
-      spawn10.sync("git", ["update-ref", "-d", refName], {
+      spawn11.sync("git", ["update-ref", "-d", refName], {
         cwd: root,
         encoding: "utf-8",
         windowsHide: true
@@ -8884,21 +8937,21 @@ function clearCheckpoints(scopeHash, repoRoots) {
     }
   }
   const file = manifestPath(scopeHash);
-  if (fs35.existsSync(file)) {
+  if (fs38.existsSync(file)) {
     try {
-      fs35.unlinkSync(file);
+      fs38.unlinkSync(file);
     } catch {
     }
   }
 }
 
 // src/core/scope-manager.ts
-import path37 from "path";
-import crypto6 from "crypto";
+import path38 from "path";
+import crypto5 from "crypto";
 var scopes = /* @__PURE__ */ new Map();
 function hashFor(paths) {
   const key = paths.slice().sort().join("|");
-  return crypto6.createHash("sha1").update(key).digest("hex").slice(0, 12);
+  return crypto5.createHash("sha1").update(key).digest("hex").slice(0, 12);
 }
 var ScopePathRejectedError = class extends Error {
   constructor(rejected) {
@@ -8910,7 +8963,7 @@ var ScopePathRejectedError = class extends Error {
   }
 };
 function normaliseForCompare(p) {
-  return path37.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path38.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function rejectedPaths(normalised) {
   const config = loadConfig();
@@ -8928,7 +8981,7 @@ function rejectedPaths(normalised) {
   });
 }
 function registerScope(paths, label2) {
-  const normalised = paths.map((p) => path37.resolve(p));
+  const normalised = paths.map((p) => path38.resolve(p));
   const rejected = rejectedPaths(normalised);
   if (rejected.length > 0) throw new ScopePathRejectedError(rejected);
   const hash = hashFor(normalised);
@@ -8942,7 +8995,7 @@ function registerScope(paths, label2) {
   const scope = {
     hash,
     paths: normalised,
-    label: label2 ?? path37.basename(normalised[0]),
+    label: label2 ?? path38.basename(normalised[0]),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     ended: false
   };
@@ -9015,7 +9068,7 @@ function mountScopeRoutes(app, opts) {
   function workingTreeFingerprint(paths) {
     const parts = [];
     for (const p of paths) {
-      const r = spawn11.sync(
+      const r = spawn12.sync(
         "git",
         ["status", "--porcelain", "--no-renames", "-z"],
         { cwd: p, encoding: "utf-8", windowsHide: true }
@@ -9139,7 +9192,7 @@ function mountScopeRoutes(app, opts) {
           const fromSha = fromEntry.repos[p] ?? "HEAD";
           const toSha = toEntry === void 0 ? "working" : toEntry.repos[p] ?? "HEAD";
           return {
-            name: path38.basename(p),
+            name: path39.basename(p),
             root: p,
             files: computeRangeDiff({ root: p, fromRef: fromSha, toRef: toSha })
           };
@@ -9155,13 +9208,21 @@ function mountScopeRoutes(app, opts) {
       }
       const resolved = scope.paths.map((p) => resolveRepoDiff(p, base));
       const repos = scope.paths.map((p, i) => ({
-        name: path38.basename(p),
+        name: path39.basename(p),
         root: p,
         resolvedBase: resolved[i].resolvedBase,
         files: computeDiff({ root: p, diffArg: resolved[i].diffArg })
       }));
       const resolvedBase = resolved[0]?.resolvedBase ?? "HEAD";
-      return c.json({ scopeHash: scope.hash, base, resolvedBase, repos });
+      const head = git(["rev-parse", "--abbrev-ref", "HEAD"], scope.paths[0]);
+      const headBranch = head.exitCode === 0 && head.stdout && head.stdout !== "HEAD" ? head.stdout : void 0;
+      return c.json({
+        scopeHash: scope.hash,
+        base,
+        resolvedBase,
+        headBranch,
+        repos
+      });
     } catch (err) {
       return c.json({ error: err.message }, 500);
     }
@@ -9396,14 +9457,15 @@ function sessionToWire(s) {
 function computeSessionDiff(s, base) {
   const resolved = s.paths.map((p) => resolveRepoDiff(p, base, s.baseBranch));
   const repos = s.paths.map((p, i) => ({
-    name: path39.basename(p),
+    name: path40.basename(p),
     root: p,
     resolvedBase: resolved[i].resolvedBase,
     files: computeDiff({ root: p, diffArg: resolved[i].diffArg })
   }));
   return { repos, resolvedBase: resolved[0]?.resolvedBase ?? "HEAD" };
 }
-async function startWebServer() {
+async function startWebServer(opts = {}) {
+  const { lean = false } = opts;
   const webRoot = resolveWebRoot();
   if (!webRoot) {
     throw new Error(
@@ -9415,25 +9477,27 @@ async function startWebServer() {
     for (const cb of sseListeners) cb({ event, data });
   };
   const home = os12.homedir();
-  const historyPath = path39.join(home, ".work", "history.json");
+  const historyPath = path40.join(home, ".work", "history.json");
   const onHistoryChange = () => broadcast("sessions-changed", { ts: Date.now() });
-  fs36.watchFile(historyPath, { interval: 1e3 }, onHistoryChange);
-  const tasksPath = path39.join(home, ".work", "tasks.json");
+  fs39.watchFile(historyPath, { interval: 1e3 }, onHistoryChange);
+  const tasksPath = path40.join(home, ".work", "tasks.json");
   const onTasksChange = () => broadcast("tasks-changed", { ts: Date.now() });
-  fs36.watchFile(tasksPath, { interval: 1e3 }, onTasksChange);
+  fs39.watchFile(tasksPath, { interval: 1e3 }, onTasksChange);
   const projectsRoot = claudeProjectsRoot();
   let activityWatcher = null;
-  try {
-    if (fs36.existsSync(projectsRoot)) {
-      activityWatcher = createFsWatcher({
-        roots: [projectsRoot],
-        debounceMs: 250,
-        onChange: () => broadcast("sessions-changed", { ts: Date.now() })
-      });
+  if (!lean) {
+    try {
+      if (fs39.existsSync(projectsRoot)) {
+        activityWatcher = createFsWatcher({
+          roots: [projectsRoot],
+          debounceMs: 250,
+          onChange: () => broadcast("sessions-changed", { ts: Date.now() })
+        });
+      }
+    } catch {
     }
-  } catch {
   }
-  const decayTick = setInterval(
+  const decayTick = lean ? null : setInterval(
     () => broadcast("sessions-changed", { ts: Date.now() }),
     1e4
   );
@@ -9498,9 +9562,9 @@ async function startWebServer() {
     url: handle.url,
     port: handle.port,
     stop: async () => {
-      fs36.unwatchFile(historyPath, onHistoryChange);
-      fs36.unwatchFile(tasksPath, onTasksChange);
-      clearInterval(decayTick);
+      fs39.unwatchFile(historyPath, onHistoryChange);
+      fs39.unwatchFile(tasksPath, onTasksChange);
+      if (decayTick) clearInterval(decayTick);
       activityWatcher?.stop();
       disposeAllWatchers();
       for (const scope of listScopes()) {
@@ -9561,12 +9625,12 @@ function info2(message) {
   process.stderr.write(message + "\n");
 }
 function urlFilePath() {
-  return path40.join(os13.homedir(), ".work", "web.url");
+  return path41.join(os13.homedir(), ".work", "web.url");
 }
 function pidFilePath() {
-  return path40.join(os13.homedir(), ".work", "web.pid");
+  return path41.join(os13.homedir(), ".work", "web.pid");
 }
-function isPidAlive2(pid) {
+function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -9574,9 +9638,9 @@ function isPidAlive2(pid) {
     return false;
   }
 }
-function readPid2() {
+function readPid() {
   try {
-    const raw = fs37.readFileSync(pidFilePath(), "utf-8").trim();
+    const raw = fs40.readFileSync(pidFilePath(), "utf-8").trim();
     const n = Number(raw);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -9585,7 +9649,7 @@ function readPid2() {
 }
 function readUrl() {
   try {
-    const v = fs37.readFileSync(urlFilePath(), "utf-8").trim();
+    const v = fs40.readFileSync(urlFilePath(), "utf-8").trim();
     return v || null;
   } catch {
     return null;
@@ -9603,19 +9667,19 @@ async function pingsAlive(url, timeoutMs = 500) {
   }
 }
 function stopExisting() {
-  const pid = readPid2();
+  const pid = readPid();
   if (!pid) {
     info2(chalk23.gray("No work web running."));
     return false;
   }
-  if (!isPidAlive2(pid)) {
+  if (!isPidAlive(pid)) {
     info2(chalk23.gray(`Stale PID ${pid} \u2014 cleaning up.`));
     try {
-      fs37.unlinkSync(pidFilePath());
+      fs40.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs40.unlinkSync(urlFilePath());
     } catch {
     }
     return false;
@@ -9624,11 +9688,11 @@ function stopExisting() {
     process.kill(pid);
     info2(chalk23.gray(`Stopped work web (PID ${pid}).`));
     try {
-      fs37.unlinkSync(pidFilePath());
+      fs40.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs40.unlinkSync(urlFilePath());
     } catch {
     }
     return true;
@@ -9648,14 +9712,19 @@ var webCommand = {
     type: "boolean",
     default: false,
     describe: "Stop a running work web instance and exit."
+  }).option("lean", {
+    type: "boolean",
+    default: false,
+    hidden: true,
+    describe: "Internal: start without dashboard-only features (Claude activity watcher + hooks). Used by `wd` when it auto-starts work web for a diff-only session."
   }),
   handler: async (argv) => {
     if (argv.stop) {
       stopExisting();
       process.exit(0);
     }
-    const existingPid = readPid2();
-    if (existingPid && isPidAlive2(existingPid)) {
+    const existingPid = readPid();
+    if (existingPid && isPidAlive(existingPid)) {
       const url = readUrl();
       if (url && await pingsAlive(url)) {
         info2(
@@ -9674,55 +9743,64 @@ var webCommand = {
       process.exit(1);
     }
     try {
-      fs37.unlinkSync(pidFilePath());
+      fs40.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs40.unlinkSync(urlFilePath());
     } catch {
     }
-    const handle = await startWebServer();
+    const lean = !!argv.lean || process.env.WORK_WEB_LEAN === "1";
+    const handle = await startWebServer({ lean });
     try {
-      fs37.mkdirSync(path40.dirname(urlFilePath()), { recursive: true });
-      fs37.writeFileSync(urlFilePath(), handle.url);
-      fs37.writeFileSync(pidFilePath(), String(process.pid));
+      fs40.mkdirSync(path41.dirname(urlFilePath()), { recursive: true });
+      fs40.writeFileSync(urlFilePath(), handle.url);
+      fs40.writeFileSync(pidFilePath(), String(process.pid));
     } catch {
     }
-    info2(chalk23.gray(`work web running at ${handle.url}`));
+    info2(
+      chalk23.gray(
+        `work web running at ${handle.url}${lean ? " (lean \u2014 diff-only mode)" : ""}`
+      )
+    );
     info2(chalk23.gray("Press Ctrl+C to stop. Or: `work web --stop` from another shell."));
     if (argv.open) openUrl(handle.url);
-    await Promise.all([
-      installCommandHook({
-        owner: "web",
-        event: "UserPromptSubmit",
-        command: "work hook prompt-submit",
-        timeoutSec: 5
-      }),
-      installCommandHook({
-        owner: "web",
-        event: "Stop",
-        command: "work hook stop",
-        timeoutSec: 5
-      })
-    ]).catch(() => {
-    });
+    if (!lean) {
+      await Promise.all([
+        installCommandHook({
+          owner: "web",
+          event: "UserPromptSubmit",
+          command: "work hook prompt-submit",
+          timeoutSec: 5
+        }),
+        installCommandHook({
+          owner: "web",
+          event: "Stop",
+          command: "work hook stop",
+          timeoutSec: 5
+        })
+      ]).catch(() => {
+      });
+    }
     const shutdown = () => {
       info2(chalk23.gray("\nStopping work web."));
       try {
-        fs37.unlinkSync(urlFilePath());
-      } catch {
-      }
-      try {
-        fs37.unlinkSync(pidFilePath());
+        fs40.unlinkSync(urlFilePath());
       } catch {
       }
       try {
-        removeCommandHookSync("web", "UserPromptSubmit");
+        fs40.unlinkSync(pidFilePath());
       } catch {
       }
-      try {
-        removeCommandHookSync("web", "Stop");
-      } catch {
+      if (!lean) {
+        try {
+          removeCommandHookSync("web", "UserPromptSubmit");
+        } catch {
+        }
+        try {
+          removeCommandHookSync("web", "Stop");
+        } catch {
+        }
       }
       handle.stop();
       process.exit(0);
@@ -9731,11 +9809,11 @@ var webCommand = {
     process.on("SIGTERM", shutdown);
     process.on("exit", () => {
       try {
-        fs37.unlinkSync(pidFilePath());
+        fs40.unlinkSync(pidFilePath());
       } catch {
       }
       try {
-        fs37.unlinkSync(urlFilePath());
+        fs40.unlinkSync(urlFilePath());
       } catch {
       }
     });
@@ -9751,7 +9829,7 @@ function computeHookOutput(input2) {
   const activity = readSessionActivity(session);
   if (activity.state === "stale") return null;
   const sessionId = sessionIdFor(session);
-  const pending = readPendingForSession(sessionId);
+  const pending = readPendingForWorktree(session);
   if (pending.length === 0) return null;
   const text = formatPendingForPrompt(pending);
   if (!text) return null;
@@ -9810,7 +9888,7 @@ var hookCommand = {
 
 // src/commands/run.ts
 import chalk24 from "chalk";
-import spawn12 from "cross-spawn";
+import spawn13 from "cross-spawn";
 
 // src/core/fleet.ts
 function selectSessions(sessions, filter) {
@@ -9852,7 +9930,7 @@ function killAllChildren(signal = "SIGTERM") {
 function runInPath(unit, cmd, prefix) {
   const { bin, args } = shellInvocation(cmd);
   return new Promise((resolve) => {
-    const child = spawn12(bin, args, {
+    const child = spawn13(bin, args, {
       cwd: unit.path,
       stdio: prefix ? ["ignore", "pipe", "pipe"] : "inherit",
       shell: false
@@ -10084,15 +10162,15 @@ var runCommand = {
 };
 
 // src/commands/broadcast.ts
-import fs39 from "fs";
+import fs42 from "fs";
 import chalk25 from "chalk";
 
 // src/core/broadcast.ts
-import crypto7 from "crypto";
-import fs38 from "fs";
+import crypto6 from "crypto";
+import fs41 from "fs";
 function readComments(file) {
   try {
-    const parsed = JSON.parse(fs38.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs41.readFileSync(file, "utf-8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
@@ -10100,10 +10178,10 @@ function readComments(file) {
 }
 async function appendLocked(sessionId, body) {
   const file = commentsFileFor(sessionId);
-  fs38.mkdirSync(commentsDir(), { recursive: true });
+  fs41.mkdirSync(commentsDir(), { recursive: true });
   ensureFile(file, "[]");
   const comment = {
-    id: crypto7.randomBytes(8).toString("hex"),
+    id: crypto6.randomBytes(8).toString("hex"),
     repo: "",
     file: "",
     line: 0,
@@ -10137,7 +10215,7 @@ async function broadcastPrompt(sessions, filter, prompt) {
 // src/commands/broadcast.ts
 function readStdin() {
   try {
-    return fs39.readFileSync(0, "utf-8");
+    return fs42.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
@@ -10212,8 +10290,8 @@ var broadcastCommand = {
 };
 
 // src/completions/index.ts
-import fs40 from "fs";
-import path41 from "path";
+import fs43 from "fs";
+import path42 from "path";
 function completionHandler(current, argv, done) {
   const rawArgs = argv._;
   const args = rawArgs.slice(1, -1);
@@ -10317,7 +10395,7 @@ function completeTreeRemoveList(command, args, current, config, done) {
 }
 function completeRepoBranches(alias, current, config, done) {
   const repoPath = config.repos[alias];
-  if (!repoPath || !fs40.existsSync(repoPath)) {
+  if (!repoPath || !fs43.existsSync(repoPath)) {
     done([]);
     return;
   }
@@ -10326,19 +10404,19 @@ function completeRepoBranches(alias, current, config, done) {
   done(branches);
 }
 function completeGroupBranches(groupName, repoAliases, current, config, done) {
-  const groupDir = path41.join(config.worktreesRoot, groupName);
-  if (!fs40.existsSync(groupDir)) {
+  const groupDir = path42.join(config.worktreesRoot, groupName);
+  if (!fs43.existsSync(groupDir)) {
     done([]);
     return;
   }
   try {
-    const branchDirs = fs40.readdirSync(groupDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
-      const bdPath = path41.join(groupDir, d.name);
+    const branchDirs = fs43.readdirSync(groupDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+      const bdPath = path42.join(groupDir, d.name);
       for (const alias of repoAliases) {
         const repoPath = config.repos[alias];
         if (!repoPath) continue;
-        const subPath = path41.join(bdPath, path41.basename(repoPath));
-        if (fs40.existsSync(subPath)) {
+        const subPath = path42.join(bdPath, path42.basename(repoPath));
+        if (fs43.existsSync(subPath)) {
           const branch = getCurrentBranch(subPath);
           if (branch) return branch;
         }
@@ -10352,7 +10430,7 @@ function completeGroupBranches(groupName, repoAliases, current, config, done) {
 }
 
 // src/version.ts
-var VERSION = true ? "1.5.0" : "dev";
+var VERSION = true ? "1.5.1" : "dev";
 
 // src/cli.ts
 function showHelp() {
@@ -10449,8 +10527,8 @@ function handleFatalError(err) {
   }
   if (err instanceof Error && err.message?.includes("pty that has already exited")) {
     try {
-      fs41.appendFileSync(
-        path42.join(getConfigDir(), "debug.log"),
+      fs44.appendFileSync(
+        path43.join(getConfigDir(), "debug.log"),
         `${(/* @__PURE__ */ new Date()).toISOString()} [WARN] Ignored async node-pty error: ${err.message}
 `
       );
@@ -10460,8 +10538,8 @@ function handleFatalError(err) {
   }
   try {
     const msg = err instanceof Error ? err.stack || err.message : String(err);
-    fs41.appendFileSync(
-      path42.join(getConfigDir(), "debug.log"),
+    fs44.appendFileSync(
+      path43.join(getConfigDir(), "debug.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} [FATAL] handleFatalError: ${msg}
 `
     );