@moberg_hr/work-tree 1.5.0 → 1.7.0

package/dist/wd-bin.js

@@ -307,10 +307,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);
@@ -409,7 +414,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()) {
@@ -871,7 +877,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();
@@ -884,7 +894,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;
 }
@@ -1562,11 +1573,12 @@ async function upsertSession(target, isGroup, branch, paths, jiraKey, baseBranch
     saveHistory(sessions);
   });
 }
-async function upsertSessionWithPort(target, isGroup, branch, paths, config, jiraKey, baseBranch) {
+async function upsertSessionWithPort(target, isGroup, branch, paths, config, jiraKey, baseBranch, baseBranches) {
   return withHistoryLock(async () => {
     const sessions = loadHistory();
     const existing = findSession(sessions, target, branch);
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const hasPerRepo = baseBranches && Object.keys(baseBranches).length > 0;
     let port = existing?.port;
     if (port === void 0) {
       const seedKey = sessionKey(target, branch);
@@ -1581,6 +1593,7 @@ async function upsertSessionWithPort(target, isGroup, branch, paths, config, jir
       existing.lastAccessedAt = now;
       if (jiraKey) existing.jiraKey = jiraKey;
       if (baseBranch && !existing.baseBranch) existing.baseBranch = baseBranch;
+      if (hasPerRepo && !existing.baseBranches) existing.baseBranches = baseBranches;
       if (port !== void 0) existing.port = port;
     } else {
       const session = {
@@ -1593,6 +1606,7 @@ async function upsertSessionWithPort(target, isGroup, branch, paths, config, jir
       };
       if (jiraKey) session.jiraKey = jiraKey;
       if (baseBranch) session.baseBranch = baseBranch;
+      if (hasPerRepo) session.baseBranches = baseBranches;
       if (port !== void 0) session.port = port;
       sessions.push(session);
     }
@@ -1708,6 +1722,62 @@ function copyConfigFiles(repoPath, worktreePath, patterns) {
   }
 }
 
+// src/core/base-spec.ts
+var BaseSpecError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BaseSpecError";
+  }
+};
+function parseBaseSpec(raw) {
+  const spec = { perRepo: {} };
+  if (raw === void 0) return spec;
+  const values = Array.isArray(raw) ? raw : [raw];
+  for (const value of values) {
+    const v = value.trim();
+    if (!v) continue;
+    const eq = v.indexOf("=");
+    if (eq === -1) {
+      if (spec.default !== void 0 && spec.default !== v) {
+        throw new BaseSpecError(
+          `Conflicting default --base values: '${spec.default}' and '${v}'`
+        );
+      }
+      spec.default = v;
+    } else {
+      const alias = v.slice(0, eq).trim();
+      const branch = v.slice(eq + 1).trim();
+      if (!alias || !branch) {
+        throw new BaseSpecError(
+          `Invalid --base '${value}'. Use 'alias=branch' or a bare 'branch'.`
+        );
+      }
+      const prior = spec.perRepo[alias];
+      if (prior !== void 0 && prior !== branch) {
+        throw new BaseSpecError(
+          `Conflicting --base for '${alias}': '${prior}' and '${branch}'`
+        );
+      }
+      spec.perRepo[alias] = branch;
+    }
+  }
+  return spec;
+}
+function baseForAlias(spec, alias) {
+  return spec.perRepo[alias] ?? spec.default;
+}
+function isEmptyBaseSpec(spec) {
+  return spec.default === void 0 && Object.keys(spec.perRepo).length === 0;
+}
+function baseSpecOverrideAliases(spec) {
+  return Object.keys(spec.perRepo);
+}
+function toBaseSpec(base) {
+  if (base === void 0) return { perRepo: {} };
+  if (typeof base === "string") return { default: base, perRepo: {} };
+  return base;
+}
+
 // src/core/worktree.ts
 function createSingleWorktree(repoPath, worktreePath, branchName, config, baseBranch) {
   debug("createSingleWorktree", { repoPath, worktreePath, branchName, baseBranch });
@@ -1913,8 +1983,9 @@ function removeSingleWorktree(repoPath, worktreePath, branchName, force) {
     return false;
   }
 }
-async function setupWorktree(targetName, branchName, config, baseBranch, jiraKey) {
-  debug("setupWorktree", { targetName, branchName, baseBranch, jiraKey });
+async function setupWorktree(targetName, branchName, config, base, jiraKey) {
+  const spec = toBaseSpec(base);
+  debug("setupWorktree", { targetName, branchName, spec, jiraKey });
   const target = resolveProjectTarget(targetName, config);
   if (!target) {
     debug("setupWorktree: target not found", targetName);
@@ -1922,27 +1993,38 @@ async function setupWorktree(targetName, branchName, config, baseBranch, jiraKey
   }
   const workTreeDirName = branchName.replace(/\//g, "-");
   if (target.isGroup) {
-    return setupGroupWorktree(target.name, target.repoAliases, branchName, workTreeDirName, config, baseBranch, jiraKey);
+    return setupGroupWorktree(target.name, target.repoAliases, branchName, workTreeDirName, config, spec, jiraKey);
   } else {
-    return setupSingleWorktree(targetName, branchName, workTreeDirName, config, baseBranch, jiraKey);
+    return setupSingleWorktree(targetName, branchName, workTreeDirName, config, spec, jiraKey);
   }
 }
-async function setupGroupWorktree(groupName, repoAliases, branchName, workTreeDirName, config, baseBranch, jiraKey) {
+async function setupGroupWorktree(groupName, repoAliases, branchName, workTreeDirName, config, spec, jiraKey) {
   const groupWorktreePath = path12.join(config.worktreesRoot, groupName, workTreeDirName);
-  if (baseBranch) {
+  if (!isEmptyBaseSpec(spec)) {
+    const unknownAliases = baseSpecOverrideAliases(spec).filter(
+      (a) => !repoAliases.includes(a)
+    );
+    if (unknownAliases.length > 0) {
+      console.error(
+        `--base names repo(s) not in group '${groupName}': ${unknownAliases.join(", ")}. Group repos: ${repoAliases.join(", ")}`
+      );
+      return null;
+    }
     const missingBase = [];
     const branchExists = [];
     for (const alias of repoAliases) {
       const repoPath = config.repos[alias];
-      if (!localBranchExists(baseBranch, repoPath) && !remoteBranchExists(baseBranch, repoPath)) {
-        missingBase.push(alias);
+      const repoBase = baseForAlias(spec, alias);
+      if (!repoBase) continue;
+      if (!localBranchExists(repoBase, repoPath) && !remoteBranchExists(repoBase, repoPath)) {
+        missingBase.push(`${alias} (${repoBase})`);
       }
       if (localBranchExists(branchName, repoPath) || remoteBranchExists(branchName, repoPath)) {
         branchExists.push(alias);
       }
     }
     if (missingBase.length > 0) {
-      console.error(`Base branch '${baseBranch}' not found in: ${missingBase.join(", ")}`);
+      console.error(`Base branch not found in: ${missingBase.join(", ")}`);
       return null;
     }
     if (branchExists.length > 0) {
@@ -1955,14 +2037,17 @@ async function setupGroupWorktree(groupName, repoAliases, branchName, workTreeDi
   console.log("");
   fs13.mkdirSync(groupWorktreePath, { recursive: true });
   const createdWorktrees = [];
+  const baseBranches = {};
   for (const alias of repoAliases) {
     const repoPath = config.repos[alias];
     const repoName = path12.basename(repoPath);
     const subWorktreePath = path12.join(groupWorktreePath, repoName);
+    const repoBase = baseForAlias(spec, alias);
     console.log(chalk5.cyan(`[${alias}] (${repoName}):`));
-    const success = createSingleWorktree(repoPath, subWorktreePath, branchName, config, baseBranch);
+    const success = createSingleWorktree(repoPath, subWorktreePath, branchName, config, repoBase);
     if (success) {
       createdWorktrees.push({ repoPath, worktreePath: subWorktreePath });
+      if (repoBase) baseBranches[subWorktreePath] = repoBase;
     } else {
       console.log("");
       console.log(chalk5.yellow("Rolling back created worktrees due to failure..."));
@@ -1992,6 +2077,8 @@ async function setupGroupWorktree(groupName, repoAliases, branchName, workTreeDi
     console.log(chalk5.yellow(`Run 'work config regengroup ${groupName}' to generate it.`));
   }
   const allPaths = createdWorktrees.map((wt) => wt.worktreePath);
+  const distinctBases = [...new Set(Object.values(baseBranches))];
+  const representativeBase = spec.default ?? (distinctBases.length === 1 ? distinctBases[0] : void 0);
   const { port } = await upsertSessionWithPort(
     groupName,
     true,
@@ -1999,17 +2086,26 @@ async function setupGroupWorktree(groupName, repoAliases, branchName, workTreeDi
     allPaths,
     config,
     jiraKey,
-    baseBranch
+    representativeBase,
+    baseBranches
   );
   console.log("");
   console.log(`Branch: ${branchName}`);
   if (port !== void 0) console.log(chalk5.gray(`Dev-server port: ${port}`));
   return { launchDir: groupWorktreePath, paths: allPaths, isGroup: true, port };
 }
-async function setupSingleWorktree(targetName, branchName, workTreeDirName, config, baseBranch, jiraKey) {
+async function setupSingleWorktree(targetName, branchName, workTreeDirName, config, spec, jiraKey) {
   const repoPath = config.repos[targetName];
   const repoName = path12.basename(repoPath);
   let workTreePath = path12.join(config.worktreesRoot, repoName, workTreeDirName);
+  const unknownAliases = baseSpecOverrideAliases(spec).filter((a) => a !== targetName);
+  if (unknownAliases.length > 0) {
+    console.error(
+      `--base names repo(s) other than '${targetName}': ${unknownAliases.join(", ")}`
+    );
+    return null;
+  }
+  const baseBranch = baseForAlias(spec, targetName);
   if (!fs13.existsSync(repoPath)) {
     console.error(`Repository path does not exist: ${repoPath}`);
     return null;
@@ -2036,7 +2132,8 @@ async function setupSingleWorktree(targetName, branchName, workTreeDirName, conf
     [workTreePath],
     config,
     jiraKey,
-    baseBranch
+    baseBranch,
+    baseBranch ? { [workTreePath]: baseBranch } : void 0
   );
   console.log(`Branch: ${branchName}`);
   if (port !== void 0) console.log(chalk5.gray(`Dev-server port: ${port}`));
@@ -2108,7 +2205,7 @@ var treeCommand = {
     type: "boolean",
     default: false
   }).option("base", {
-    describe: "Create the new branch from this base branch instead of HEAD",
+    describe: "Base branch to fork from instead of HEAD. Repeatable. Use a bare branch (--base dev) for all repos, or alias=branch (--base backend=dev --base frontend=feat/x) for per-repo bases in a group.",
     type: "string"
   }).option("prompt", {
     describe: "Initial prompt to send to the AI tool on startup",
@@ -2133,7 +2230,17 @@ var treeCommand = {
     const open = argv.open;
     const unsafe = argv.unsafe;
     const setupOnly = argv["setup-only"];
-    const baseBranch = argv.base;
+    let baseSpec;
+    try {
+      baseSpec = parseBaseSpec(argv.base);
+    } catch (err) {
+      if (err instanceof BaseSpecError) {
+        console.error(err.message);
+        process.exitCode = 1;
+        return;
+      }
+      throw err;
+    }
     const jiraKey = argv["jira-key"];
     const promptFile = argv["prompt-file"];
     let initialPrompt = argv.prompt;
@@ -2171,12 +2278,10 @@ var treeCommand = {
       process.exitCode = 1;
       return;
     }
-    if (baseBranch && !branchName) {
+    if (!isEmptyBaseSpec(baseSpec) && !branchName) {
       console.error("--base requires a branch name");
       console.log(
-        chalk6.yellow(
-          `Usage: work tree ${targetName} <branch> --base ${baseBranch}`
-        )
+        chalk6.yellow(`Usage: work tree ${targetName} <branch> --base <base>`)
       );
       process.exitCode = 1;
       return;
@@ -2224,7 +2329,7 @@ var treeCommand = {
       }
       return;
     }
-    const result = await setupWorktree(targetName, branchName, config, baseBranch, jiraKey);
+    const result = await setupWorktree(targetName, branchName, config, baseSpec, jiraKey);
     if (!result) {
       process.exitCode = 1;
       return;
@@ -2793,10 +2898,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);
@@ -3126,10 +3229,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) {
@@ -3245,10 +3353,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() {
@@ -4663,7 +4776,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);
@@ -6316,18 +6429,16 @@ var hydrateCommand = {
 };
 
 // src/commands/diff.ts
-import fs32 from "fs";
+import fs36 from "fs";
 import os9 from "os";
-import path31 from "path";
+import path33 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+))? @@(.*)$/;
@@ -6619,19 +6730,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) {
@@ -6640,7 +6797,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,
@@ -6656,12 +6813,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 {
       }
@@ -6679,39 +6836,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);
@@ -6721,10 +6846,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 "";
   }
@@ -6760,11 +6885,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",
@@ -6810,7 +6937,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;
       }
@@ -6828,9 +6955,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",
@@ -6849,9 +6979,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",
@@ -6872,69 +7004,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) {
@@ -6988,11 +7133,12 @@ function resolveBase(scope, argv) {
   }
   return { base: "HEAD", source: "default" };
 }
-function buildRepoSpecs(scope, base) {
+function buildRepoSpecs(scope, base, perRepoBase) {
   return scope.repos.map((r) => {
-    let diffArg = base;
-    if (base !== "HEAD") {
-      const mb = git(["merge-base", base, "HEAD"], r.root);
+    const repoBase = perRepoBase?.[r.root] ?? base;
+    let diffArg = repoBase;
+    if (repoBase !== "HEAD") {
+      const mb = git(["merge-base", repoBase, "HEAD"], r.root);
       if (mb.exitCode === 0 && mb.stdout) diffArg = mb.stdout;
     }
     return { name: r.name, root: r.root, diffArg };
@@ -7002,13 +7148,24 @@ 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);
   if (mb.exitCode === 0 && mb.stdout) diffArg = mb.stdout;
   return { resolvedBase: parent, diffArg };
 }
+function sessionBaseForPath(root) {
+  const norm = normPath(root);
+  for (const s of loadHistory()) {
+    for (const p of s.paths) {
+      if (normPath(p) === norm) {
+        return s.baseBranches?.[p] ?? s.baseBranch;
+      }
+    }
+  }
+  return void 0;
+}
 
 // src/core/comment-server.ts
 import { Hono as Hono2 } from "hono";
@@ -7096,37 +7253,134 @@ import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { streamSSE } from "hono/streaming";
 
+// src/core/file-context.ts
+import fs31 from "fs";
+import path28 from "path";
+import spawn10 from "cross-spawn";
+function readContextLines(opts) {
+  const { root, relPath, ref } = opts;
+  if (!relPath || !isInsideRoot(root, relPath)) return null;
+  const start = Math.max(1, Math.floor(opts.start));
+  const end = Math.max(start, Math.floor(opts.end));
+  const content = !ref || ref === "working" ? readWorkingTree(root, relPath) : readAtRef(root, ref, relPath);
+  if (content === null) return null;
+  const all = content.split(/\r?\n/);
+  if (all.length > 0 && all[all.length - 1] === "") all.pop();
+  const totalLines = all.length;
+  const slice = all.slice(start - 1, end);
+  return {
+    lines: slice,
+    start,
+    totalLines,
+    eof: end >= totalLines
+  };
+}
+function readWorkingTree(root, relPath) {
+  try {
+    const absPath = path28.join(root, relPath);
+    const realRoot2 = fs31.realpathSync(path28.resolve(root));
+    const realPath = fs31.realpathSync(absPath);
+    const sep = path28.sep;
+    if (realPath !== realRoot2 && !realPath.startsWith(realRoot2 + sep)) {
+      return null;
+    }
+    return fs31.readFileSync(absPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readAtRef(root, ref, relPath) {
+  const r = spawn10.sync("git", ["show", `${ref}:${relPath}`], {
+    cwd: root,
+    encoding: "utf-8",
+    maxBuffer: 64 * 1024 * 1024,
+    windowsHide: true
+  });
+  if (r.status === 0 && typeof r.stdout === "string") return r.stdout;
+  return null;
+}
+
 // src/core/fs-watcher.ts
-import path27 from "path";
+import fs32 from "fs";
+import path29 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 = path29.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 = fs32.watch(root, { recursive: true }, (_event, filename) => {
+        if (filename && isIgnoredWatchPath([root], path29.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);
@@ -7137,30 +7391,30 @@ function createFsWatcher(opts) {
 }
 
 // src/core/web-static.ts
-import fs29 from "fs";
-import path28 from "path";
+import fs33 from "fs";
+import path30 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 = path30.dirname(process.argv[1] ?? "");
+  const moduleDir = path30.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path28.join(entryDir, "web"),
+    path30.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"),
+    path30.join(moduleDir, "web"),
     // dev/tsx fallback: walk up from src/core to repo root then into dist/web.
-    path28.resolve(moduleDir, "../../dist/web")
+    path30.resolve(moduleDir, "../../dist/web")
   ];
   for (const c of candidates) {
-    if (fs29.existsSync(path28.join(c, "index.html"))) return c;
+    if (fs33.existsSync(path30.join(c, "index.html"))) return c;
   }
   return null;
 }
 
 // src/core/spa-handler.ts
-import fs30 from "fs";
-import path29 from "path";
+import fs34 from "fs";
+import path31 from "path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -7174,18 +7428,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 = path31.join(root, requested);
+  const norm = path31.normalize(filePath);
+  if (!norm.startsWith(path31.normalize(root))) return null;
   let stat;
   try {
-    stat = fs30.statSync(norm);
+    stat = fs34.statSync(norm);
   } catch {
     return null;
   }
   if (!stat.isFile()) return null;
-  const ext = path29.extname(norm).toLowerCase();
-  return { body: fs30.readFileSync(norm), ext };
+  const ext = path31.extname(norm).toLowerCase();
+  return { body: fs34.readFileSync(norm), ext };
 }
 function serveSpa(c, webRoot) {
   const url = new URL(c.req.url);
@@ -7220,20 +7474,32 @@ 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 {
       const resolved = opts.repos.map(
-        (r) => base === "uncommitted" ? { resolvedBase: "HEAD", diffArg: r.diffArg } : resolveRepoDiff(r.root, "branch", opts.sessionBaseBranch)
+        (r) => base === "uncommitted" ? { resolvedBase: "HEAD", diffArg: r.diffArg } : resolveRepoDiff(
+          r.root,
+          "branch",
+          opts.sessionBaseBranches?.[r.root] ?? opts.sessionBaseBranch
+        )
       );
       const repos = opts.repos.map((r, i) => ({
         name: r.name,
@@ -7247,6 +7513,21 @@ async function startDiffServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/file-lines", (c) => {
+    const repoName = c.req.query("repo") ?? "";
+    const relPath = c.req.query("path") ?? "";
+    const start = Number(c.req.query("start"));
+    const end = Number(c.req.query("end"));
+    const ref = c.req.query("ref") || void 0;
+    if (!relPath || !Number.isInteger(start) || !Number.isInteger(end)) {
+      return c.json({ error: "bad path/start/end" }, 400);
+    }
+    const root = opts.repos.length === 1 ? opts.repos[0].root : opts.repos.find((r) => r.name === repoName)?.root;
+    if (!root) return c.json({ error: "unknown repo" }, 404);
+    const result = readContextLines({ root, relPath, start, end, ref });
+    if (!result) return c.json({ error: "cannot read file" }, 400);
+    return c.json(result);
+  });
   app.get(
     "/events",
     (c) => streamSSE(c, async (stream) => {
@@ -7409,6 +7690,7 @@ async function startCommentServer(opts) {
     repos: opts.repos,
     scopeLabel: opts.scopeLabel,
     sessionBaseBranch: opts.sessionBaseBranch,
+    sessionBaseBranches: opts.sessionBaseBranches,
     watchDebounceMs: opts.watchDebounceMs,
     attachRoutes
   });
@@ -7419,16 +7701,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})`;
@@ -7460,8 +7732,8 @@ function diffReviewSnapshot(snapshot, seen) {
 }
 
 // src/core/static-renderer.ts
-import fs31 from "fs";
-import path30 from "path";
+import fs35 from "fs";
+import path32 from "path";
 function buildDiff(specs, resolvedBase) {
   return {
     repos: specs.map((r) => ({
@@ -7477,8 +7749,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 = path32.join(webRoot, "index.html");
+  let shell = fs35.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";
@@ -7527,10 +7799,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 = path32.join(webRoot, clean);
+  if (!path32.normalize(full).startsWith(path32.normalize(webRoot))) return null;
   try {
-    return fs31.readFileSync(full, "utf-8");
+    return fs35.readFileSync(full, "utf-8");
   } catch {
     return null;
   }
@@ -7540,108 +7812,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 path33.join(os9.homedir(), ".work", "web.url");
+}
+function resolveWorkBinPath(selfArgv1) {
+  let real = selfArgv1;
+  try {
+    real = fs36.realpathSync(selfArgv1);
   } catch {
-    return false;
   }
+  if (real.endsWith("wd-bin.js")) {
+    return path33.join(path33.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 = fs36.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 = fs36.openSync(
+    path33.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(() => {
-  });
+  fs36.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",
@@ -7662,49 +7911,27 @@ 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");
   const primaryRoot = ctx.scope.repos.find((r) => r.name === ctx.scope.activeRepoName)?.root ?? ctx.scope.repos[0].root;
-  const parent = ctx.scope.session?.baseBranch ?? findAnyParentBranch(primaryRoot);
+  const perRepoBase = ctx.scope.session?.baseBranches;
+  const parent = perRepoBase?.[primaryRoot] ?? ctx.scope.session?.baseBranch ?? findAnyParentBranch(primaryRoot);
   const branch = parent === null ? void 0 : {
-    specs: buildRepoSpecs(ctx.scope, parent),
+    specs: buildRepoSpecs(ctx.scope, parent, perRepoBase),
     resolvedBase: parent
   };
   const uncommittedTotal = uncommitted.reduce(
@@ -7725,8 +7952,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`;
+  fs36.writeFileSync(filePath, html, "utf-8");
   info(chalk21.gray(`Wrote ${filePath}`));
   openUrl(`file:///${filePath.replace(/\\/g, "/")}`);
 }
@@ -7735,7 +7962,7 @@ function waitForUrlFile(filePath, timeoutMs) {
     const start = Date.now();
     const tick = () => {
       try {
-        const v = fs32.readFileSync(filePath, "utf-8").trim();
+        const v = fs36.readFileSync(filePath, "utf-8").trim();
         if (v) return resolve(v);
       } catch {
       }
@@ -7746,14 +7973,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`, {
@@ -7881,6 +8102,7 @@ summary-id: ${info3.summary.id}` : ""}
     repos: ctx.repoSpecs,
     scopeLabel: ctx.scopeLabel,
     sessionBaseBranch: ctx.scope.session?.baseBranch,
+    sessionBaseBranches: ctx.scope.session?.baseBranches,
     onComment,
     onCommentDeleted,
     onSubmitReviewStart,
@@ -7942,12 +8164,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",
@@ -7965,7 +8182,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 {
@@ -7981,11 +8199,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);
@@ -7993,21 +8209,21 @@ var diffCommand = {
 };
 
 // src/commands/web.ts
-import fs37 from "fs";
+import fs41 from "fs";
 import os13 from "os";
-import path40 from "path";
+import path42 from "path";
 import chalk23 from "chalk";
 
 // src/core/web-server.ts
-import fs36 from "fs";
+import fs40 from "fs";
 import os12 from "os";
-import path39 from "path";
+import path41 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 path34 from "path";
 import crypto4 from "crypto";
 import chokidar2 from "chokidar";
 function sessionIdFor(s) {
@@ -8028,7 +8244,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 = path34.relative(r, filePath).replace(/\\/g, "/");
           if (rel === ".git" || rel.startsWith(".git/")) return true;
         }
         return false;
@@ -8142,24 +8358,24 @@ function disposeAllPtys() {
 }
 
 // src/core/comment-file-store.ts
-import fs33 from "fs";
-import path33 from "path";
+import fs37 from "fs";
+import path35 from "path";
 import os10 from "os";
 function commentsDir() {
-  return path33.join(os10.homedir(), ".work", "comments");
+  return path35.join(os10.homedir(), ".work", "comments");
 }
 function ensureDir() {
-  fs33.mkdirSync(commentsDir(), { recursive: true });
+  fs37.mkdirSync(commentsDir(), { recursive: true });
 }
 function commentsFileFor(sessionId) {
-  return path33.join(commentsDir(), `${sessionId}.json`);
+  return path35.join(commentsDir(), `${sessionId}.json`);
 }
 function pathFor(sessionId) {
   return commentsFileFor(sessionId);
 }
 function readDisk(sessionId) {
   try {
-    const raw = fs33.readFileSync(pathFor(sessionId), "utf-8");
+    const raw = fs37.readFileSync(pathFor(sessionId), "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -8231,29 +8447,29 @@ function clearCommentStoreCache() {
 }
 
 // src/core/pending-delivery.ts
-import fs34 from "fs";
-import path34 from "path";
+import fs38 from "fs";
+import path36 from "path";
 function pathFor2(sessionId) {
   return {
     comments: commentsFileFor(sessionId),
-    delivered: path34.join(commentsDir(), `${sessionId}.delivered.json`)
+    delivered: path36.join(commentsDir(), `${sessionId}.delivered.json`)
   };
 }
 function readJson(filePath, fallback) {
   try {
-    return JSON.parse(fs34.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs38.readFileSync(filePath, "utf8"));
   } catch {
     return fallback;
   }
 }
 function writeAtomic2(filePath, content) {
-  fs34.mkdirSync(path34.dirname(filePath), { recursive: true });
+  fs38.mkdirSync(path36.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  fs34.writeFileSync(tmp, content, "utf-8");
-  fs34.renameSync(tmp, filePath);
+  fs38.writeFileSync(tmp, content, "utf-8");
+  fs38.renameSync(tmp, filePath);
 }
 function normalize(p) {
-  return path34.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path36.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function findSessionForCwd(cwd) {
   const norm = normalize(cwd);
@@ -8274,13 +8490,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) => path36.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;
@@ -8580,8 +8823,8 @@ function mountPanesRoutes(app, opts) {
 }
 
 // src/core/worktree-routes.ts
-import path35 from "path";
-import { spawn as spawn9 } from "child_process";
+import path37 from "path";
+import { spawn as spawn11 } from "child_process";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { z as z3 } from "zod";
 function mountWorktreeRoutes(app, opts) {
@@ -8704,10 +8947,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 ? path37.dirname(session.paths[0]) : session.paths[0];
     try {
       const cmd = process.platform === "win32" ? "code.cmd" : "code";
-      const child = spawn9(cmd, [target], {
+      const child = spawn11(cmd, [target], {
         detached: true,
         stdio: "ignore",
         shell: false
@@ -8724,28 +8967,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 path40 from "path";
+import spawn13 from "cross-spawn";
 
 // src/core/checkpoint.ts
-import fs35 from "fs";
+import fs39 from "fs";
 import os11 from "os";
-import path36 from "path";
-import crypto5 from "crypto";
-import spawn10 from "cross-spawn";
+import path38 from "path";
+import spawn12 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 = path38.join(os11.homedir(), ".work", "diffs");
+  fs39.mkdirSync(dir, { recursive: true });
+  return path38.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 (!fs39.existsSync(file)) return emptyManifest(scopeHash);
   try {
-    const raw = fs35.readFileSync(file, "utf-8");
+    const raw = fs39.readFileSync(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !Array.isArray(parsed.entries)) {
       return emptyManifest(scopeHash);
@@ -8759,68 +9001,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 = spawn12.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 = spawn12.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);
@@ -8831,12 +9042,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], {
+        spawn12.sync("git", ["update-ref", "-d", refName], {
           cwd: repo.root,
           encoding: "utf-8",
           windowsHide: true
@@ -8849,10 +9065,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 = spawn12.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;
       }
@@ -8874,7 +9102,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], {
+      spawn12.sync("git", ["update-ref", "-d", refName], {
         cwd: root,
         encoding: "utf-8",
         windowsHide: true
@@ -8882,21 +9110,21 @@ function clearCheckpoints(scopeHash, repoRoots) {
     }
   }
   const file = manifestPath(scopeHash);
-  if (fs35.existsSync(file)) {
+  if (fs39.existsSync(file)) {
     try {
-      fs35.unlinkSync(file);
+      fs39.unlinkSync(file);
     } catch {
     }
   }
 }
 
 // src/core/scope-manager.ts
-import path37 from "path";
-import crypto6 from "crypto";
+import path39 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) {
@@ -8908,7 +9136,7 @@ var ScopePathRejectedError = class extends Error {
   }
 };
 function normaliseForCompare(p) {
-  return path37.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path39.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function rejectedPaths(normalised) {
   const config = loadConfig();
@@ -8926,7 +9154,7 @@ function rejectedPaths(normalised) {
   });
 }
 function registerScope(paths, label2) {
-  const normalised = paths.map((p) => path37.resolve(p));
+  const normalised = paths.map((p) => path39.resolve(p));
   const rejected = rejectedPaths(normalised);
   if (rejected.length > 0) throw new ScopePathRejectedError(rejected);
   const hash = hashFor(normalised);
@@ -8940,7 +9168,7 @@ function registerScope(paths, label2) {
   const scope = {
     hash,
     paths: normalised,
-    label: label2 ?? path37.basename(normalised[0]),
+    label: label2 ?? path39.basename(normalised[0]),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     ended: false
   };
@@ -9013,7 +9241,7 @@ function mountScopeRoutes(app, opts) {
   function workingTreeFingerprint(paths) {
     const parts = [];
     for (const p of paths) {
-      const r = spawn11.sync(
+      const r = spawn13.sync(
         "git",
         ["status", "--porcelain", "--no-renames", "-z"],
         { cwd: p, encoding: "utf-8", windowsHide: true }
@@ -9137,7 +9365,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: path40.basename(p),
             root: p,
             files: computeRangeDiff({ root: p, fromRef: fromSha, toRef: toSha })
           };
@@ -9151,19 +9379,46 @@ function mountScopeRoutes(app, opts) {
           repos: repos2
         });
       }
-      const resolved = scope.paths.map((p) => resolveRepoDiff(p, base));
+      const resolved = scope.paths.map(
+        (p) => resolveRepoDiff(p, base, sessionBaseForPath(p))
+      );
       const repos = scope.paths.map((p, i) => ({
-        name: path38.basename(p),
+        name: path40.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);
     }
   });
+  app.get("/api/scopes/:hash/file-lines", (c) => {
+    const scope = getScope(c.req.param("hash"));
+    if (!scope) return c.json({ error: "unknown scope" }, 404);
+    const repoName = c.req.query("repo") ?? "";
+    const relPath = c.req.query("path") ?? "";
+    const start = Number(c.req.query("start"));
+    const end = Number(c.req.query("end"));
+    const ref = c.req.query("ref") || void 0;
+    if (!relPath || !Number.isInteger(start) || !Number.isInteger(end)) {
+      return c.json({ error: "bad path/start/end" }, 400);
+    }
+    const root = scope.paths.length === 1 ? scope.paths[0] : scope.paths.find((p) => path40.basename(p) === repoName);
+    if (!root) return c.json({ error: "unknown repo" }, 404);
+    const result = readContextLines({ root, relPath, start, end, ref });
+    if (!result) return c.json({ error: "cannot read file" }, 400);
+    return c.json(result);
+  });
   app.get("/api/scopes/:hash/checkpoints", (c) => {
     const scope = getScope(c.req.param("hash"));
     if (!scope) return c.json({ error: "unknown scope" }, 404);
@@ -9392,16 +9647,19 @@ function sessionToWire(s) {
   };
 }
 function computeSessionDiff(s, base) {
-  const resolved = s.paths.map((p) => resolveRepoDiff(p, base, s.baseBranch));
+  const resolved = s.paths.map(
+    (p) => resolveRepoDiff(p, base, s.baseBranches?.[p] ?? s.baseBranch)
+  );
   const repos = s.paths.map((p, i) => ({
-    name: path39.basename(p),
+    name: path41.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(
@@ -9413,25 +9671,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 = path41.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");
+  fs40.watchFile(historyPath, { interval: 1e3 }, onHistoryChange);
+  const tasksPath = path41.join(home, ".work", "tasks.json");
   const onTasksChange = () => broadcast("tasks-changed", { ts: Date.now() });
-  fs36.watchFile(tasksPath, { interval: 1e3 }, onTasksChange);
+  fs40.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 (fs40.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
   );
@@ -9496,9 +9756,9 @@ async function startWebServer() {
     url: handle.url,
     port: handle.port,
     stop: async () => {
-      fs36.unwatchFile(historyPath, onHistoryChange);
-      fs36.unwatchFile(tasksPath, onTasksChange);
-      clearInterval(decayTick);
+      fs40.unwatchFile(historyPath, onHistoryChange);
+      fs40.unwatchFile(tasksPath, onTasksChange);
+      if (decayTick) clearInterval(decayTick);
       activityWatcher?.stop();
       disposeAllWatchers();
       for (const scope of listScopes()) {
@@ -9559,12 +9819,12 @@ function info2(message) {
   process.stderr.write(message + "\n");
 }
 function urlFilePath() {
-  return path40.join(os13.homedir(), ".work", "web.url");
+  return path42.join(os13.homedir(), ".work", "web.url");
 }
 function pidFilePath() {
-  return path40.join(os13.homedir(), ".work", "web.pid");
+  return path42.join(os13.homedir(), ".work", "web.pid");
 }
-function isPidAlive2(pid) {
+function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -9572,9 +9832,9 @@ function isPidAlive2(pid) {
     return false;
   }
 }
-function readPid2() {
+function readPid() {
   try {
-    const raw = fs37.readFileSync(pidFilePath(), "utf-8").trim();
+    const raw = fs41.readFileSync(pidFilePath(), "utf-8").trim();
     const n = Number(raw);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -9583,7 +9843,7 @@ function readPid2() {
 }
 function readUrl() {
   try {
-    const v = fs37.readFileSync(urlFilePath(), "utf-8").trim();
+    const v = fs41.readFileSync(urlFilePath(), "utf-8").trim();
     return v || null;
   } catch {
     return null;
@@ -9601,19 +9861,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());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs41.unlinkSync(urlFilePath());
     } catch {
     }
     return false;
@@ -9622,11 +9882,11 @@ function stopExisting() {
     process.kill(pid);
     info2(chalk23.gray(`Stopped work web (PID ${pid}).`));
     try {
-      fs37.unlinkSync(pidFilePath());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs41.unlinkSync(urlFilePath());
     } catch {
     }
     return true;
@@ -9646,14 +9906,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(
@@ -9672,55 +9937,64 @@ var webCommand = {
       process.exit(1);
     }
     try {
-      fs37.unlinkSync(pidFilePath());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs37.unlinkSync(urlFilePath());
+      fs41.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));
+      fs41.mkdirSync(path42.dirname(urlFilePath()), { recursive: true });
+      fs41.writeFileSync(urlFilePath(), handle.url);
+      fs41.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());
+        fs41.unlinkSync(urlFilePath());
       } catch {
       }
       try {
-        fs37.unlinkSync(pidFilePath());
+        fs41.unlinkSync(pidFilePath());
       } catch {
       }
-      try {
-        removeCommandHookSync("web", "UserPromptSubmit");
-      } catch {
-      }
-      try {
-        removeCommandHookSync("web", "Stop");
-      } catch {
+      if (!lean) {
+        try {
+          removeCommandHookSync("web", "UserPromptSubmit");
+        } catch {
+        }
+        try {
+          removeCommandHookSync("web", "Stop");
+        } catch {
+        }
       }
       handle.stop();
       process.exit(0);
@@ -9729,11 +10003,11 @@ var webCommand = {
     process.on("SIGTERM", shutdown);
     process.on("exit", () => {
       try {
-        fs37.unlinkSync(pidFilePath());
+        fs41.unlinkSync(pidFilePath());
       } catch {
       }
       try {
-        fs37.unlinkSync(urlFilePath());
+        fs41.unlinkSync(urlFilePath());
       } catch {
       }
     });
@@ -9749,7 +10023,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;
@@ -9808,7 +10082,7 @@ var hookCommand = {
 
 // src/commands/run.ts
 import chalk24 from "chalk";
-import spawn12 from "cross-spawn";
+import spawn14 from "cross-spawn";
 
 // src/core/fleet.ts
 function selectSessions(sessions, filter) {
@@ -9850,7 +10124,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 = spawn14(bin, args, {
       cwd: unit.path,
       stdio: prefix ? ["ignore", "pipe", "pipe"] : "inherit",
       shell: false
@@ -10082,15 +10356,15 @@ var runCommand = {
 };
 
 // src/commands/broadcast.ts
-import fs39 from "fs";
+import fs43 from "fs";
 import chalk25 from "chalk";
 
 // src/core/broadcast.ts
-import crypto7 from "crypto";
-import fs38 from "fs";
+import crypto6 from "crypto";
+import fs42 from "fs";
 function readComments(file) {
   try {
-    const parsed = JSON.parse(fs38.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs42.readFileSync(file, "utf-8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
@@ -10098,10 +10372,10 @@ function readComments(file) {
 }
 async function appendLocked(sessionId, body) {
   const file = commentsFileFor(sessionId);
-  fs38.mkdirSync(commentsDir(), { recursive: true });
+  fs42.mkdirSync(commentsDir(), { recursive: true });
   ensureFile(file, "[]");
   const comment = {
-    id: crypto7.randomBytes(8).toString("hex"),
+    id: crypto6.randomBytes(8).toString("hex"),
     repo: "",
     file: "",
     line: 0,
@@ -10135,7 +10409,7 @@ async function broadcastPrompt(sessions, filter, prompt) {
 // src/commands/broadcast.ts
 function readStdin() {
   try {
-    return fs39.readFileSync(0, "utf-8");
+    return fs43.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
@@ -10210,8 +10484,8 @@ var broadcastCommand = {
 };
 
 // src/completions/index.ts
-import fs40 from "fs";
-import path41 from "path";
+import fs44 from "fs";
+import path43 from "path";
 function completionHandler(current, argv, done) {
   const rawArgs = argv._;
   const args = rawArgs.slice(1, -1);
@@ -10315,7 +10589,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 || !fs44.existsSync(repoPath)) {
     done([]);
     return;
   }
@@ -10324,19 +10598,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 = path43.join(config.worktreesRoot, groupName);
+  if (!fs44.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 = fs44.readdirSync(groupDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+      const bdPath = path43.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 = path43.join(bdPath, path43.basename(repoPath));
+        if (fs44.existsSync(subPath)) {
           const branch = getCurrentBranch(subPath);
           if (branch) return branch;
         }
@@ -10350,7 +10624,7 @@ function completeGroupBranches(groupName, repoAliases, current, config, done) {
 }
 
 // src/version.ts
-var VERSION = true ? "1.5.0" : "dev";
+var VERSION = true ? "1.7.0" : "dev";
 
 // src/cli.ts
 function showHelp() {