@moberg_hr/work-tree 1.5.1 → 1.7.0

package/dist/wd-bin.js

@@ -1573,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);
@@ -1592,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 = {
@@ -1604,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);
     }
@@ -1719,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 });
@@ -1924,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);
@@ -1933,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) {
@@ -1966,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..."));
@@ -2003,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,
@@ -2010,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;
@@ -2047,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}`));
@@ -2119,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",
@@ -2144,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;
@@ -2182,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;
@@ -2235,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;
@@ -6335,9 +6429,9 @@ var hydrateCommand = {
 };
 
 // src/commands/diff.ts
-import fs35 from "fs";
+import fs36 from "fs";
 import os9 from "os";
-import path32 from "path";
+import path33 from "path";
 import { spawn as childSpawn } from "child_process";
 import chalk21 from "chalk";
 
@@ -7039,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 };
@@ -7060,6 +7155,17 @@ function resolveRepoDiff(root, base, sessionBaseBranch) {
   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";
@@ -7147,9 +7253,56 @@ import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { streamSSE } from "hono/streaming";
 
-// src/core/fs-watcher.ts
+// 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 fs32 from "fs";
+import path29 from "path";
 import chalk19 from "chalk";
 import chokidar from "chokidar";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -7175,7 +7328,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function isIgnoredWatchPath(roots, filePath) {
   for (const root of roots) {
-    const rel = path28.relative(root, filePath).replace(/\\/g, "/");
+    const rel = path29.relative(root, filePath).replace(/\\/g, "/");
     if (rel === "" || rel.startsWith("../")) continue;
     if (rel.split("/").some((seg) => IGNORED_DIRS.has(seg))) return true;
   }
@@ -7199,8 +7352,8 @@ function createFsWatcher(opts) {
   };
   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()))) {
+      const w = fs32.watch(root, { recursive: true }, (_event, filename) => {
+        if (filename && isIgnoredWatchPath([root], path29.join(root, filename.toString()))) {
           return;
         }
         fire();
@@ -7238,30 +7391,30 @@ function createFsWatcher(opts) {
 }
 
 // src/core/web-static.ts
-import fs32 from "fs";
-import path29 from "path";
+import fs33 from "fs";
+import path30 from "path";
 import { fileURLToPath } from "url";
 function resolveWebRoot() {
-  const entryDir = path29.dirname(process.argv[1] ?? "");
-  const moduleDir = path29.dirname(fileURLToPath(import.meta.url));
+  const entryDir = path30.dirname(process.argv[1] ?? "");
+  const moduleDir = path30.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path29.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).
-    path29.join(moduleDir, "web"),
+    path30.join(moduleDir, "web"),
     // dev/tsx fallback: walk up from src/core to repo root then into dist/web.
-    path29.resolve(moduleDir, "../../dist/web")
+    path30.resolve(moduleDir, "../../dist/web")
   ];
   for (const c of candidates) {
-    if (fs32.existsSync(path29.join(c, "index.html"))) return c;
+    if (fs33.existsSync(path30.join(c, "index.html"))) return c;
   }
   return null;
 }
 
 // src/core/spa-handler.ts
-import fs33 from "fs";
-import path30 from "path";
+import fs34 from "fs";
+import path31 from "path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -7275,18 +7428,18 @@ var MIME = {
 function readFile(root, relPath) {
   const clean = relPath.split("?")[0];
   const requested = clean === "/" ? "/index.html" : clean;
-  const filePath = path30.join(root, requested);
-  const norm = path30.normalize(filePath);
-  if (!norm.startsWith(path30.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 = fs33.statSync(norm);
+    stat = fs34.statSync(norm);
   } catch {
     return null;
   }
   if (!stat.isFile()) return null;
-  const ext = path30.extname(norm).toLowerCase();
-  return { body: fs33.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);
@@ -7342,7 +7495,11 @@ async function startDiffServer(opts) {
     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,
@@ -7356,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) => {
@@ -7518,6 +7690,7 @@ async function startCommentServer(opts) {
     repos: opts.repos,
     scopeLabel: opts.scopeLabel,
     sessionBaseBranch: opts.sessionBaseBranch,
+    sessionBaseBranches: opts.sessionBaseBranches,
     watchDebounceMs: opts.watchDebounceMs,
     attachRoutes
   });
@@ -7559,8 +7732,8 @@ function diffReviewSnapshot(snapshot, seen) {
 }
 
 // src/core/static-renderer.ts
-import fs34 from "fs";
-import path31 from "path";
+import fs35 from "fs";
+import path32 from "path";
 function buildDiff(specs, resolvedBase) {
   return {
     repos: specs.map((r) => ({
@@ -7576,8 +7749,8 @@ function renderStatic(opts) {
   if (!webRoot) {
     throw new Error("Could not find dist/web/. Run `npm run build` first.");
   }
-  const shellPath = path31.join(webRoot, "index.html");
-  let shell = fs34.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";
@@ -7626,10 +7799,10 @@ function escapeForScriptTag(json) {
 }
 function readAsset(webRoot, urlPath) {
   const clean = urlPath.split("?")[0].replace(/^\//, "");
-  const full = path31.join(webRoot, clean);
-  if (!path31.normalize(full).startsWith(path31.normalize(webRoot))) return null;
+  const full = path32.join(webRoot, clean);
+  if (!path32.normalize(full).startsWith(path32.normalize(webRoot))) return null;
   try {
-    return fs34.readFileSync(full, "utf-8");
+    return fs35.readFileSync(full, "utf-8");
   } catch {
     return null;
   }
@@ -7670,22 +7843,22 @@ async function runStop(repoSpecs) {
   }
 }
 function webUrlFilePath() {
-  return path32.join(os9.homedir(), ".work", "web.url");
+  return path33.join(os9.homedir(), ".work", "web.url");
 }
 function resolveWorkBinPath(selfArgv1) {
   let real = selfArgv1;
   try {
-    real = fs35.realpathSync(selfArgv1);
+    real = fs36.realpathSync(selfArgv1);
   } catch {
   }
   if (real.endsWith("wd-bin.js")) {
-    return path32.join(path32.dirname(real), "bin.js");
+    return path33.join(path33.dirname(real), "bin.js");
   }
   return real;
 }
 function readWebUrl() {
   try {
-    const v = fs35.readFileSync(webUrlFilePath(), "utf-8").trim();
+    const v = fs36.readFileSync(webUrlFilePath(), "utf-8").trim();
     return v || null;
   } catch {
     return null;
@@ -7695,8 +7868,8 @@ 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"),
+  const out = fs36.openSync(
+    path33.join(os9.homedir(), ".work", "web-autostart.log"),
     "a"
   );
   const child = childSpawn(
@@ -7711,7 +7884,7 @@ async function ensureWorkWebRunning() {
     }
   );
   child.unref();
-  fs35.closeSync(out);
+  fs36.closeSync(out);
   const url = await waitForUrlFile(webUrlFilePath(), 5e3);
   return url;
 }
@@ -7755,9 +7928,10 @@ async function runLauncher(ctx) {
 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(
@@ -7779,7 +7953,7 @@ function runStatic(ctx, initialBranch) {
     initialBase: initialBranch && branch ? "branch" : "uncommitted"
   });
   const filePath = `${ctx.scopeStem}.html`;
-  fs35.writeFileSync(filePath, html, "utf-8");
+  fs36.writeFileSync(filePath, html, "utf-8");
   info(chalk21.gray(`Wrote ${filePath}`));
   openUrl(`file:///${filePath.replace(/\\/g, "/")}`);
 }
@@ -7788,7 +7962,7 @@ function waitForUrlFile(filePath, timeoutMs) {
     const start = Date.now();
     const tick = () => {
       try {
-        const v = fs35.readFileSync(filePath, "utf-8").trim();
+        const v = fs36.readFileSync(filePath, "utf-8").trim();
         if (v) return resolve(v);
       } catch {
       }
@@ -7928,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,
@@ -8034,21 +8209,21 @@ var diffCommand = {
 };
 
 // src/commands/web.ts
-import fs40 from "fs";
+import fs41 from "fs";
 import os13 from "os";
-import path41 from "path";
+import path42 from "path";
 import chalk23 from "chalk";
 
 // src/core/web-server.ts
-import fs39 from "fs";
+import fs40 from "fs";
 import os12 from "os";
-import path40 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 path33 from "path";
+import path34 from "path";
 import crypto4 from "crypto";
 import chokidar2 from "chokidar";
 function sessionIdFor(s) {
@@ -8069,7 +8244,7 @@ function subscribeSession(sessionId, onChange) {
     const watcher = chokidar2.watch(roots, {
       ignored: (filePath) => {
         for (const r of roots) {
-          const rel = path33.relative(r, filePath).replace(/\\/g, "/");
+          const rel = path34.relative(r, filePath).replace(/\\/g, "/");
           if (rel === ".git" || rel.startsWith(".git/")) return true;
         }
         return false;
@@ -8183,24 +8358,24 @@ function disposeAllPtys() {
 }
 
 // src/core/comment-file-store.ts
-import fs36 from "fs";
-import path34 from "path";
+import fs37 from "fs";
+import path35 from "path";
 import os10 from "os";
 function commentsDir() {
-  return path34.join(os10.homedir(), ".work", "comments");
+  return path35.join(os10.homedir(), ".work", "comments");
 }
 function ensureDir() {
-  fs36.mkdirSync(commentsDir(), { recursive: true });
+  fs37.mkdirSync(commentsDir(), { recursive: true });
 }
 function commentsFileFor(sessionId) {
-  return path34.join(commentsDir(), `${sessionId}.json`);
+  return path35.join(commentsDir(), `${sessionId}.json`);
 }
 function pathFor(sessionId) {
   return commentsFileFor(sessionId);
 }
 function readDisk(sessionId) {
   try {
-    const raw = fs36.readFileSync(pathFor(sessionId), "utf-8");
+    const raw = fs37.readFileSync(pathFor(sessionId), "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -8272,29 +8447,29 @@ function clearCommentStoreCache() {
 }
 
 // src/core/pending-delivery.ts
-import fs37 from "fs";
-import path35 from "path";
+import fs38 from "fs";
+import path36 from "path";
 function pathFor2(sessionId) {
   return {
     comments: commentsFileFor(sessionId),
-    delivered: path35.join(commentsDir(), `${sessionId}.delivered.json`)
+    delivered: path36.join(commentsDir(), `${sessionId}.delivered.json`)
   };
 }
 function readJson(filePath, fallback) {
   try {
-    return JSON.parse(fs37.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs38.readFileSync(filePath, "utf8"));
   } catch {
     return fallback;
   }
 }
 function writeAtomic2(filePath, content) {
-  fs37.mkdirSync(path35.dirname(filePath), { recursive: true });
+  fs38.mkdirSync(path36.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  fs37.writeFileSync(tmp, content, "utf-8");
-  fs37.renameSync(tmp, filePath);
+  fs38.writeFileSync(tmp, content, "utf-8");
+  fs38.renameSync(tmp, filePath);
 }
 function normalize(p) {
-  return path35.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path36.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function findSessionForCwd(cwd) {
   const norm = normalize(cwd);
@@ -8325,7 +8500,7 @@ function readPendingForSession(sessionId) {
   return comments.filter(isPendingFor(delivered));
 }
 function scopeStoreIdsForPaths(paths) {
-  const resolved = paths.map((p) => path35.resolve(p));
+  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])}`);
@@ -8648,8 +8823,8 @@ function mountPanesRoutes(app, opts) {
 }
 
 // src/core/worktree-routes.ts
-import path36 from "path";
-import { spawn as spawn10 } 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) {
@@ -8772,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 ? path36.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 = spawn10(cmd, [target], {
+      const child = spawn11(cmd, [target], {
         detached: true,
         stdio: "ignore",
         shell: false
@@ -8792,27 +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 path39 from "path";
-import spawn12 from "cross-spawn";
+import path40 from "path";
+import spawn13 from "cross-spawn";
 
 // src/core/checkpoint.ts
-import fs38 from "fs";
+import fs39 from "fs";
 import os11 from "os";
-import path37 from "path";
-import spawn11 from "cross-spawn";
+import path38 from "path";
+import spawn12 from "cross-spawn";
 function manifestPath(scopeHash) {
-  const dir = path37.join(os11.homedir(), ".work", "diffs");
-  fs38.mkdirSync(dir, { recursive: true });
-  return path37.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 (!fs38.existsSync(file)) return emptyManifest(scopeHash);
+  if (!fs39.existsSync(file)) return emptyManifest(scopeHash);
   try {
-    const raw = fs38.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);
@@ -8841,7 +9016,7 @@ function snapshotRepo(repoRoot, scopeHash, id, includeWorkingTree = true) {
     GIT_COMMITTER_EMAIL: "wd@local",
     GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
   };
-  const commit = spawn11.sync("git", commitArgs, {
+  const commit = spawn12.sync("git", commitArgs, {
     cwd: repoRoot,
     encoding: "utf-8",
     env: commitEnv,
@@ -8850,7 +9025,7 @@ function snapshotRepo(repoRoot, scopeHash, id, includeWorkingTree = true) {
   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], {
+  const updateRef = spawn12.sync("git", ["update-ref", refName, commitSha], {
     cwd: repoRoot,
     encoding: "utf-8",
     windowsHide: true
@@ -8877,7 +9052,7 @@ async function takeCheckpoint(scopeHash, repos, opts = {}) {
     const rollbackRefs = () => {
       const refName = `refs/wd/${scopeHash}/${nextId}`;
       for (const repo of repos) {
-        spawn11.sync("git", ["update-ref", "-d", refName], {
+        spawn12.sync("git", ["update-ref", "-d", refName], {
           cwd: repo.root,
           encoding: "utf-8",
           windowsHide: true
@@ -8892,7 +9067,7 @@ async function takeCheckpoint(scopeHash, repos, opts = {}) {
       const prev = manifest.entries[manifest.entries.length - 1];
       const treeOf = (root, commitSha) => {
         if (!commitSha) return null;
-        const r = spawn11.sync(
+        const r = spawn12.sync(
           "git",
           ["rev-parse", `${commitSha}^{tree}`],
           { cwd: root, encoding: "utf-8", windowsHide: true }
@@ -8927,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}`;
-      spawn11.sync("git", ["update-ref", "-d", refName], {
+      spawn12.sync("git", ["update-ref", "-d", refName], {
         cwd: root,
         encoding: "utf-8",
         windowsHide: true
@@ -8935,16 +9110,16 @@ function clearCheckpoints(scopeHash, repoRoots) {
     }
   }
   const file = manifestPath(scopeHash);
-  if (fs38.existsSync(file)) {
+  if (fs39.existsSync(file)) {
     try {
-      fs38.unlinkSync(file);
+      fs39.unlinkSync(file);
     } catch {
     }
   }
 }
 
 // src/core/scope-manager.ts
-import path38 from "path";
+import path39 from "path";
 import crypto5 from "crypto";
 var scopes = /* @__PURE__ */ new Map();
 function hashFor(paths) {
@@ -8961,7 +9136,7 @@ var ScopePathRejectedError = class extends Error {
   }
 };
 function normaliseForCompare(p) {
-  return path38.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path39.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function rejectedPaths(normalised) {
   const config = loadConfig();
@@ -8979,7 +9154,7 @@ function rejectedPaths(normalised) {
   });
 }
 function registerScope(paths, label2) {
-  const normalised = paths.map((p) => path38.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);
@@ -8993,7 +9168,7 @@ function registerScope(paths, label2) {
   const scope = {
     hash,
     paths: normalised,
-    label: label2 ?? path38.basename(normalised[0]),
+    label: label2 ?? path39.basename(normalised[0]),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     ended: false
   };
@@ -9066,7 +9241,7 @@ function mountScopeRoutes(app, opts) {
   function workingTreeFingerprint(paths) {
     const parts = [];
     for (const p of paths) {
-      const r = spawn12.sync(
+      const r = spawn13.sync(
         "git",
         ["status", "--porcelain", "--no-renames", "-z"],
         { cwd: p, encoding: "utf-8", windowsHide: true }
@@ -9190,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: path39.basename(p),
+            name: path40.basename(p),
             root: p,
             files: computeRangeDiff({ root: p, fromRef: fromSha, toRef: toSha })
           };
@@ -9204,9 +9379,11 @@ 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: path39.basename(p),
+        name: path40.basename(p),
         root: p,
         resolvedBase: resolved[i].resolvedBase,
         files: computeDiff({ root: p, diffArg: resolved[i].diffArg })
@@ -9225,6 +9402,23 @@ function mountScopeRoutes(app, opts) {
       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);
@@ -9453,9 +9647,11 @@ 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: path40.basename(p),
+    name: path41.basename(p),
     root: p,
     resolvedBase: resolved[i].resolvedBase,
     files: computeDiff({ root: p, diffArg: resolved[i].diffArg })
@@ -9475,17 +9671,17 @@ async function startWebServer(opts = {}) {
     for (const cb of sseListeners) cb({ event, data });
   };
   const home = os12.homedir();
-  const historyPath = path40.join(home, ".work", "history.json");
+  const historyPath = path41.join(home, ".work", "history.json");
   const onHistoryChange = () => broadcast("sessions-changed", { ts: Date.now() });
-  fs39.watchFile(historyPath, { interval: 1e3 }, onHistoryChange);
-  const tasksPath = path40.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() });
-  fs39.watchFile(tasksPath, { interval: 1e3 }, onTasksChange);
+  fs40.watchFile(tasksPath, { interval: 1e3 }, onTasksChange);
   const projectsRoot = claudeProjectsRoot();
   let activityWatcher = null;
   if (!lean) {
     try {
-      if (fs39.existsSync(projectsRoot)) {
+      if (fs40.existsSync(projectsRoot)) {
         activityWatcher = createFsWatcher({
           roots: [projectsRoot],
           debounceMs: 250,
@@ -9560,8 +9756,8 @@ async function startWebServer(opts = {}) {
     url: handle.url,
     port: handle.port,
     stop: async () => {
-      fs39.unwatchFile(historyPath, onHistoryChange);
-      fs39.unwatchFile(tasksPath, onTasksChange);
+      fs40.unwatchFile(historyPath, onHistoryChange);
+      fs40.unwatchFile(tasksPath, onTasksChange);
       if (decayTick) clearInterval(decayTick);
       activityWatcher?.stop();
       disposeAllWatchers();
@@ -9623,10 +9819,10 @@ function info2(message) {
   process.stderr.write(message + "\n");
 }
 function urlFilePath() {
-  return path41.join(os13.homedir(), ".work", "web.url");
+  return path42.join(os13.homedir(), ".work", "web.url");
 }
 function pidFilePath() {
-  return path41.join(os13.homedir(), ".work", "web.pid");
+  return path42.join(os13.homedir(), ".work", "web.pid");
 }
 function isPidAlive(pid) {
   try {
@@ -9638,7 +9834,7 @@ function isPidAlive(pid) {
 }
 function readPid() {
   try {
-    const raw = fs40.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 {
@@ -9647,7 +9843,7 @@ function readPid() {
 }
 function readUrl() {
   try {
-    const v = fs40.readFileSync(urlFilePath(), "utf-8").trim();
+    const v = fs41.readFileSync(urlFilePath(), "utf-8").trim();
     return v || null;
   } catch {
     return null;
@@ -9673,11 +9869,11 @@ function stopExisting() {
   if (!isPidAlive(pid)) {
     info2(chalk23.gray(`Stale PID ${pid} \u2014 cleaning up.`));
     try {
-      fs40.unlinkSync(pidFilePath());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs40.unlinkSync(urlFilePath());
+      fs41.unlinkSync(urlFilePath());
     } catch {
     }
     return false;
@@ -9686,11 +9882,11 @@ function stopExisting() {
     process.kill(pid);
     info2(chalk23.gray(`Stopped work web (PID ${pid}).`));
     try {
-      fs40.unlinkSync(pidFilePath());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs40.unlinkSync(urlFilePath());
+      fs41.unlinkSync(urlFilePath());
     } catch {
     }
     return true;
@@ -9741,19 +9937,19 @@ var webCommand = {
       process.exit(1);
     }
     try {
-      fs40.unlinkSync(pidFilePath());
+      fs41.unlinkSync(pidFilePath());
     } catch {
     }
     try {
-      fs40.unlinkSync(urlFilePath());
+      fs41.unlinkSync(urlFilePath());
     } catch {
     }
     const lean = !!argv.lean || process.env.WORK_WEB_LEAN === "1";
     const handle = await startWebServer({ lean });
     try {
-      fs40.mkdirSync(path41.dirname(urlFilePath()), { recursive: true });
-      fs40.writeFileSync(urlFilePath(), handle.url);
-      fs40.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(
@@ -9783,11 +9979,11 @@ var webCommand = {
     const shutdown = () => {
       info2(chalk23.gray("\nStopping work web."));
       try {
-        fs40.unlinkSync(urlFilePath());
+        fs41.unlinkSync(urlFilePath());
       } catch {
       }
       try {
-        fs40.unlinkSync(pidFilePath());
+        fs41.unlinkSync(pidFilePath());
       } catch {
       }
       if (!lean) {
@@ -9807,11 +10003,11 @@ var webCommand = {
     process.on("SIGTERM", shutdown);
     process.on("exit", () => {
       try {
-        fs40.unlinkSync(pidFilePath());
+        fs41.unlinkSync(pidFilePath());
       } catch {
       }
       try {
-        fs40.unlinkSync(urlFilePath());
+        fs41.unlinkSync(urlFilePath());
       } catch {
       }
     });
@@ -9886,7 +10082,7 @@ var hookCommand = {
 
 // src/commands/run.ts
 import chalk24 from "chalk";
-import spawn13 from "cross-spawn";
+import spawn14 from "cross-spawn";
 
 // src/core/fleet.ts
 function selectSessions(sessions, filter) {
@@ -9928,7 +10124,7 @@ function killAllChildren(signal = "SIGTERM") {
 function runInPath(unit, cmd, prefix) {
   const { bin, args } = shellInvocation(cmd);
   return new Promise((resolve) => {
-    const child = spawn13(bin, args, {
+    const child = spawn14(bin, args, {
       cwd: unit.path,
       stdio: prefix ? ["ignore", "pipe", "pipe"] : "inherit",
       shell: false
@@ -10160,15 +10356,15 @@ var runCommand = {
 };
 
 // src/commands/broadcast.ts
-import fs42 from "fs";
+import fs43 from "fs";
 import chalk25 from "chalk";
 
 // src/core/broadcast.ts
 import crypto6 from "crypto";
-import fs41 from "fs";
+import fs42 from "fs";
 function readComments(file) {
   try {
-    const parsed = JSON.parse(fs41.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs42.readFileSync(file, "utf-8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
@@ -10176,7 +10372,7 @@ function readComments(file) {
 }
 async function appendLocked(sessionId, body) {
   const file = commentsFileFor(sessionId);
-  fs41.mkdirSync(commentsDir(), { recursive: true });
+  fs42.mkdirSync(commentsDir(), { recursive: true });
   ensureFile(file, "[]");
   const comment = {
     id: crypto6.randomBytes(8).toString("hex"),
@@ -10213,7 +10409,7 @@ async function broadcastPrompt(sessions, filter, prompt) {
 // src/commands/broadcast.ts
 function readStdin() {
   try {
-    return fs42.readFileSync(0, "utf-8");
+    return fs43.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
@@ -10288,8 +10484,8 @@ var broadcastCommand = {
 };
 
 // src/completions/index.ts
-import fs43 from "fs";
-import path42 from "path";
+import fs44 from "fs";
+import path43 from "path";
 function completionHandler(current, argv, done) {
   const rawArgs = argv._;
   const args = rawArgs.slice(1, -1);
@@ -10393,7 +10589,7 @@ function completeTreeRemoveList(command, args, current, config, done) {
 }
 function completeRepoBranches(alias, current, config, done) {
   const repoPath = config.repos[alias];
-  if (!repoPath || !fs43.existsSync(repoPath)) {
+  if (!repoPath || !fs44.existsSync(repoPath)) {
     done([]);
     return;
   }
@@ -10402,19 +10598,19 @@ function completeRepoBranches(alias, current, config, done) {
   done(branches);
 }
 function completeGroupBranches(groupName, repoAliases, current, config, done) {
-  const groupDir = path42.join(config.worktreesRoot, groupName);
-  if (!fs43.existsSync(groupDir)) {
+  const groupDir = path43.join(config.worktreesRoot, groupName);
+  if (!fs44.existsSync(groupDir)) {
     done([]);
     return;
   }
   try {
-    const branchDirs = fs43.readdirSync(groupDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
-      const bdPath = path42.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 = path42.join(bdPath, path42.basename(repoPath));
-        if (fs43.existsSync(subPath)) {
+        const subPath = path43.join(bdPath, path43.basename(repoPath));
+        if (fs44.existsSync(subPath)) {
           const branch = getCurrentBranch(subPath);
           if (branch) return branch;
         }
@@ -10428,7 +10624,7 @@ function completeGroupBranches(groupName, repoAliases, current, config, done) {
 }
 
 // src/version.ts
-var VERSION = true ? "1.5.1" : "dev";
+var VERSION = true ? "1.7.0" : "dev";
 
 // src/cli.ts
 function showHelp() {