@buildautomaton/cli 0.1.58 → 0.1.59

package/dist/cli.js

@@ -973,7 +973,7 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path75 = __require("node:path");
+    var path76 = __require("node:path");
     var fs53 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1906,9 +1906,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path75.resolve(baseDir, baseName);
+          const localBin = path76.resolve(baseDir, baseName);
           if (fs53.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path75.extname(baseName))) return void 0;
+          if (sourceExt.includes(path76.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs53.existsSync(`${localBin}${ext}`)
           );
@@ -1926,17 +1926,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path75.resolve(
-            path75.dirname(resolvedScriptPath),
+          executableDir = path76.resolve(
+            path76.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path75.basename(
+            const legacyName = path76.basename(
               this._scriptPath,
-              path75.extname(this._scriptPath)
+              path76.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path75.extname(executableFile));
+        launchWithNode = sourceExt.includes(path76.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path75.basename(filename, path75.extname(filename));
+        this._name = path76.basename(filename, path76.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path76) {
-        if (path76 === void 0) return this._executableDir;
-        this._executableDir = path76;
+      executableDir(path77) {
+        if (path77 === void 0) return this._executableDir;
+        this._executableDir = path77;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path75, errorMaps, issueData } = params;
-      const fullPath = [...path75, ...issueData.path || []];
+      const { data, path: path76, errorMaps, issueData } = params;
+      const fullPath = [...path76, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path75, key) {
+      constructor(parent, value, path76, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path75;
+        this._path = path76;
         this._key = key;
       }
       get path() {
@@ -11099,10 +11099,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path75) {
-  if (!path75)
+function getElementAtPath(obj, path76) {
+  if (!path76)
     return obj;
-  return path75.reduce((acc, key) => acc?.[key], obj);
+  return path76.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11351,11 +11351,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path75, issues) {
+function prefixIssues(path76, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path75);
+    iss.path.unshift(path76);
     return iss;
   });
 }
@@ -11544,7 +11544,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path75 = []) => {
+  const processError = (error41, path76 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -11554,7 +11554,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path75, ...issue2.path];
+        const fullpath = [...path76, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11584,9 +11584,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path75) {
+function toDotPath(path76) {
   const segs = [];
-  for (const seg of path75) {
+  for (const seg of path76) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24592,7 +24592,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path75, checkUnignored, mode) {
+      test(path76, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -24601,7 +24601,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path75);
+          const matched = rule[mode].test(path76);
           if (!matched) {
             return;
           }
@@ -24622,17 +24622,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path75, originalPath, doThrow) => {
-      if (!isString(path75)) {
+    var checkPath = (path76, originalPath, doThrow) => {
+      if (!isString(path76)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path75) {
+      if (!path76) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path75)) {
+      if (checkPath.isNotRelative(path76)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -24641,7 +24641,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path75) => REGEX_TEST_INVALID_PATH.test(path75);
+    var isNotRelative = (path76) => REGEX_TEST_INVALID_PATH.test(path76);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -24671,19 +24671,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path75 = originalPath && checkPath.convert(originalPath);
+        const path76 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path75,
+          path76,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path75, cache2, checkUnignored, slices);
+        return this._t(path76, cache2, checkUnignored, slices);
       }
-      checkIgnore(path75) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path75)) {
-          return this.test(path75);
+      checkIgnore(path76) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path76)) {
+          return this.test(path76);
         }
-        const slices = path75.split(SLASH).filter(Boolean);
+        const slices = path76.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -24696,18 +24696,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path75, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path76, false, MODE_CHECK_IGNORE);
       }
-      _t(path75, cache2, checkUnignored, slices) {
-        if (path75 in cache2) {
-          return cache2[path75];
+      _t(path76, cache2, checkUnignored, slices) {
+        if (path76 in cache2) {
+          return cache2[path76];
         }
         if (!slices) {
-          slices = path75.split(SLASH).filter(Boolean);
+          slices = path76.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path75] = this._rules.test(path75, checkUnignored, MODE_IGNORE);
+          return cache2[path76] = this._rules.test(path76, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -24715,29 +24715,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path75] = parent.ignored ? parent : this._rules.test(path75, checkUnignored, MODE_IGNORE);
+        return cache2[path76] = parent.ignored ? parent : this._rules.test(path76, checkUnignored, MODE_IGNORE);
       }
-      ignores(path75) {
-        return this._test(path75, this._ignoreCache, false).ignored;
+      ignores(path76) {
+        return this._test(path76, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path75) => !this.ignores(path75);
+        return (path76) => !this.ignores(path76);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path75) {
-        return this._test(path75, this._testCache, true);
+      test(path76) {
+        return this._test(path76, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path75) => checkPath(path75 && checkPath.convert(path75), path75, RETURN_FALSE);
+    var isPathValid = (path76) => checkPath(path76 && checkPath.convert(path76), path76, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path75) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path75) || isNotRelative(path75);
+      checkPath.isNotRelative = (path76) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path76) || isNotRelative(path76);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -25526,10 +25526,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path75, isFile, isDirectory) {
-      log2(`checking %s`, path75);
+    function check2(path76, isFile, isDirectory) {
+      log2(`checking %s`, path76);
       try {
-        const stat3 = fs_1.statSync(path75);
+        const stat3 = fs_1.statSync(path76);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -25549,8 +25549,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path75, type = exports.READABLE) {
-      return check2(path75, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path76, type = exports.READABLE) {
+      return check2(path76, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -25631,7 +25631,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.58".length > 0 ? "0.1.58" : "0.0.0-dev";
+var CLI_VERSION = "0.1.59".length > 0 ? "0.1.59" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -25639,7 +25639,7 @@ var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
 import * as fs52 from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -27859,7 +27859,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join2(moduleDir, "..", sub, filename),
     join2(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path75) => existsSync(path75));
+  const resolved = candidates.find((path76) => existsSync(path76));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -28888,9 +28888,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path75 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path75) continue;
-    rows.push({ path: path75, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path76 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path76) continue;
+    rows.push({ path: path76, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -35246,8 +35246,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path75) {
-  return path75.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path76) {
+  return path76.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -35534,9 +35534,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path75, summary }) => {
+  const entries = params.rows.map(({ path: path76, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path75, summary: JSON.stringify(enc) };
+    return { path: path76, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -36569,8 +36569,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path75) {
-  return path75 instanceof String && cache.has(path75);
+function isPathSpec(path76) {
+  return path76 instanceof String && cache.has(path76);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -36659,8 +36659,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path75) {
-  return (0, import_file_exists.exists)(path75, import_file_exists.FOLDER);
+function folderExists(path76) {
+  return (0, import_file_exists.exists)(path76, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -37064,8 +37064,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path75) {
-      return /^\.(git)?$/.test(path75.trim());
+    parser(path76) {
+      return /^\.(git)?$/.test(path76.trim());
     }
   };
 }
@@ -37499,11 +37499,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path75, line, preview] = input.split(NULL);
-    paths.add(path75);
-    (results[path75] = results[path75] || []).push({
+    const [path76, line, preview] = input.split(NULL);
+    paths.add(path76);
+    (results[path76] = results[path76] || []).push({
       line: asNumber(line),
-      path: path75,
+      path: path76,
       preview
     });
   });
@@ -38268,14 +38268,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path75, text) {
+function parseInit(bare, path76, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path75, false, result[1]);
+    return new InitSummary(bare, path76, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path75, true, result[1]);
+    return new InitSummary(bare, path76, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -38286,7 +38286,7 @@ function parseInit(bare, path75, text) {
       break;
     }
   }
-  return new InitSummary(bare, path75, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path76, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -38295,9 +38295,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path75, existing, gitDir) {
+      constructor(bare, path76, existing, gitDir) {
         this.bare = bare;
-        this.path = path75;
+        this.path = path76;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -38309,7 +38309,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path75, customArgs) {
+function initTask(bare = false, path76, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -38318,7 +38318,7 @@ function initTask(bare = false, path75, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path75, text);
+      return parseInit(commands.includes("--bare"), path76, text);
     }
   };
 }
@@ -39134,12 +39134,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path75, index, working_dir) {
-        this.path = path75;
+      constructor(path76, index, working_dir) {
+        this.path = path76;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path75) || [null, path75, path75];
+          const detail = fromPathRegex.exec(path76) || [null, path76, path76];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -39170,14 +39170,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path75) {
+  function data(index, workingDir, path76) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path75);
+      handler(result, path76);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path75, index, workingDir));
+      result.files.push(new FileStatusSummary(path76, index, workingDir));
     }
   }
 }
@@ -39486,9 +39486,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path75, write) {
+      hashObject(path76, write) {
         return this._runTask(
-          hashObjectTask(path75, write === true),
+          hashObjectTask(path76, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -39841,8 +39841,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path75 = input.trim().replace(/^["']|["']$/g, "");
-  return path75 && normalize3(path75);
+  const path76 = input.trim().replace(/^["']|["']$/g, "");
+  return path76 && normalize3(path76);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -40156,8 +40156,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path75) {
-  return subModuleTask(["add", repo, path75]);
+function addSubModuleTask(repo, path76) {
+  return subModuleTask(["add", repo, path76]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -40490,8 +40490,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path75, then) {
-      return this._runTask(addSubModuleTask2(repo, path75), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path76, then) {
+      return this._runTask(addSubModuleTask2(repo, path76), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -41227,8 +41227,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path75, entry] of parseNumstatEntries(lines)) {
-    m.set(path75, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path76, entry] of parseNumstatEntries(lines)) {
+    m.set(path76, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -42535,18 +42535,32 @@ import * as fs28 from "node:fs";
 // src/git/worktrees/worktree-remove.ts
 import * as fs27 from "node:fs";
 
+// src/worktrees/is-removable-session-worktree-checkout-path.ts
+import path43 from "node:path";
+function isBridgeRootCheckoutPath(checkoutPath) {
+  return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
+}
+function isRemovableSessionWorktreeCheckoutPath(checkoutPath, worktreesRootPath) {
+  if (isBridgeRootCheckoutPath(checkoutPath)) return false;
+  const normalized = normalizeResolvedPath(checkoutPath);
+  const worktreesRoot = normalizeResolvedPath(worktreesRootPath);
+  const rel = path43.relative(worktreesRoot, normalized);
+  if (rel === "" || rel.startsWith("..") || path43.isAbsolute(rel)) return false;
+  return true;
+}
+
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
 import * as fs26 from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path43.join(wt, ".git");
+  const gitDirFile = path44.join(wt, ".git");
   if (!fs26.existsSync(gitDirFile) || !fs26.statSync(gitDirFile).isFile()) return "";
   const first2 = fs26.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path43.resolve(wt, m[1].trim());
-  const gitDir = path43.dirname(path43.dirname(gitWorktreePath));
-  return path43.dirname(gitDir);
+  const gitWorktreePath = path44.resolve(wt, m[1].trim());
+  const gitDir = path44.dirname(path44.dirname(gitWorktreePath));
+  return path44.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -42554,32 +42568,44 @@ async function gitWorktreeRemoveForce(worktreePath) {
   const mainRepo = resolveMainRepoFromWorktreeGitFile(worktreePath);
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
-  } else {
-    fs27.rmSync(worktreePath, { recursive: true, force: true });
+    return true;
   }
+  if (isBridgeRootCheckoutPath(worktreePath)) return false;
+  fs27.rmSync(worktreePath, { recursive: true, force: true });
+  return true;
 }
 
 // src/worktrees/remove-session-worktrees.ts
-async function removeSessionWorktrees(paths, log2) {
+async function removeSessionWorktrees(paths, worktreesRootPath, log2) {
   for (const wt of paths) {
+    if (!isRemovableSessionWorktreeCheckoutPath(wt, worktreesRootPath)) {
+      log2(`[worktrees] Skipping removal of ${wt} (bridge root or outside worktrees root).`);
+      continue;
+    }
     try {
-      await gitWorktreeRemoveForce(wt);
-      log2(`[worktrees] Removed worktree ${wt}`);
+      const removed = await gitWorktreeRemoveForce(wt);
+      if (removed) {
+        log2(`[worktrees] Removed worktree ${wt}`);
+      } else {
+        log2(`[worktrees] Skipping removal of ${wt} (bridge root).`);
+      }
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
-      try {
-        fs28.rmSync(wt, { recursive: true, force: true });
-      } catch {
+      if (isRemovableSessionWorktreeCheckoutPath(wt, worktreesRootPath)) {
+        try {
+          fs28.rmSync(wt, { recursive: true, force: true });
+        } catch {
+        }
       }
     }
   }
 }
 
 // src/worktrees/manager/git/remove-session-worktree-checkouts.ts
-async function removeSessionWorktreeCheckouts(cache2, sessionId, log2) {
+async function removeSessionWorktreeCheckouts(cache2, sessionId, worktreesRootPath, log2) {
   const paths = cache2.clearSession(sessionId);
   if (!paths?.length) return;
-  await removeSessionWorktrees(paths, log2);
+  await removeSessionWorktrees(paths, worktreesRootPath, log2);
 }
 
 // src/git/branches/rename-branch.ts
@@ -42612,11 +42638,11 @@ async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
 
 // src/worktrees/discovery/discover-session-worktree-on-disk.ts
 import * as fs32 from "node:fs";
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 
 // src/worktrees/discovery/collect-worktree-paths.ts
 import * as fs30 from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 
 // src/worktrees/discovery/disk-walk-constants.ts
 var DISK_WALK_YIELD_EVERY = 64;
@@ -42645,7 +42671,7 @@ function shouldSkipDiskWalkEntry(name) {
 
 // src/worktrees/discovery/disk-walk-utils.ts
 import * as fs29 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -42655,7 +42681,7 @@ async function yieldDuringDiskWalk(state) {
 }
 async function isGitDir(dirPath) {
   try {
-    await fs29.promises.access(path44.join(dirPath, ".git"));
+    await fs29.promises.access(path45.join(dirPath, ".git"));
     return true;
   } catch {
     return false;
@@ -42669,7 +42695,7 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
   const walk = async (dir) => {
     if (!await yieldDuringDiskWalk(state)) return;
     if (await isGitDir(dir)) {
-      out.push(path45.resolve(dir));
+      out.push(path46.resolve(dir));
       return;
     }
     let entries;
@@ -42680,12 +42706,12 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path45.join(dir, e.name);
+      const full = path46.join(dir, e.name);
       if (!e.isDirectory()) continue;
       await walk(full);
     }
   };
-  await walk(path45.resolve(rootPath));
+  await walk(path46.resolve(rootPath));
   return { paths: [...new Set(out)], entriesVisited: state.entries };
 }
 async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK_MAX_DEPTH) {
@@ -42702,10 +42728,10 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path45.join(dir, e.name);
+      const full = path46.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (await isGitDir(full)) out.push(path45.resolve(full));
+        if (await isGitDir(full)) out.push(path46.resolve(full));
         continue;
       }
       if (await isGitDir(full)) continue;
@@ -42717,14 +42743,14 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
 }
 
 // src/worktrees/discovery/layout-keys-for-bridge-root.ts
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
-  const bridge = path46.resolve(bridgeRoot);
+  const bridge = path47.resolve(bridgeRoot);
   const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const relevant = layout.launcherCwds.filter((e) => {
-    const entry = path46.resolve(e.absolutePath);
-    return bridge === entry || bridge.startsWith(entry + path46.sep) || entry.startsWith(bridge + path46.sep);
-  }).sort((a, b) => path46.resolve(b.absolutePath).length - path46.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
+    const entry = path47.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path47.sep) || entry.startsWith(bridge + path47.sep);
+  }).sort((a, b) => path47.resolve(b.absolutePath).length - path47.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
   const ordered = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (k) => {
@@ -42743,7 +42769,7 @@ function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
 
 // src/worktrees/discovery/try-binding-from-session-directory.ts
 import * as fs31 from "node:fs";
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 async function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
@@ -42754,7 +42780,7 @@ async function tryBindingFromSessionDirectory(sessionDir) {
   if (!st.isDirectory()) return null;
   const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path47.resolve(sessionDir);
+  const abs = path48.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -42778,7 +42804,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   try {
     for (const name of await fs32.promises.readdir(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path48.join(worktreesRootPath, name);
+      const p = path49.join(worktreesRootPath, name);
       let st;
       try {
         st = await fs32.promises.stat(p);
@@ -42795,7 +42821,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   for (const key of keys) {
     if (isCliImmediateShutdownRequested()) return null;
     await yieldToEventLoop();
-    const layoutRoot = path48.join(worktreesRootPath, key);
+    const layoutRoot = path49.join(worktreesRootPath, key);
     let layoutSt;
     try {
       layoutSt = await fs32.promises.stat(layoutRoot);
@@ -42803,16 +42829,16 @@ async function discoverSessionWorktreeOnDisk(options) {
       continue;
     }
     if (!layoutSt.isDirectory()) continue;
-    const sessionDir = path48.join(layoutRoot, sid);
+    const sessionDir = path49.join(layoutRoot, sid);
     const nested = await tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacy = await collectWorktreeRootsNamed(layoutRoot, sid);
     if (legacy.paths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path48.resolve(legacy.paths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path49.resolve(legacy.paths[0]);
       return {
-        sessionParentPath: path48.resolve(isolated),
-        workingTreeRelRoot: path48.resolve(layoutRoot),
-        repoCheckoutPaths: legacy.paths.map((p) => path48.resolve(p))
+        sessionParentPath: path49.resolve(isolated),
+        workingTreeRelRoot: path49.resolve(layoutRoot),
+        repoCheckoutPaths: legacy.paths.map((p) => path49.resolve(p))
       };
     }
   }
@@ -42821,29 +42847,29 @@ async function discoverSessionWorktreeOnDisk(options) {
 
 // src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
 import * as fs33 from "node:fs";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path49.resolve(checkoutPath);
+  const hintR = path50.resolve(checkoutPath);
   let best = null;
-  let cur = path49.dirname(hintR);
+  let cur = path50.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     if (isCliImmediateShutdownRequested()) return best;
     await yieldToEventLoop();
     const paths = await collectWorktreeRootsNamed(cur, sid);
-    if (paths.paths.some((p) => path49.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path49.resolve(paths.paths[0]);
+    if (paths.paths.some((p) => path50.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path50.resolve(paths.paths[0]);
       best = {
-        sessionParentPath: path49.resolve(isolated),
-        workingTreeRelRoot: path49.resolve(cur),
-        repoCheckoutPaths: paths.paths.map((p) => path49.resolve(p))
+        sessionParentPath: path50.resolve(isolated),
+        workingTreeRelRoot: path50.resolve(cur),
+        repoCheckoutPaths: paths.paths.map((p) => path50.resolve(p))
       };
     }
-    const next = path49.dirname(cur);
+    const next = path50.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -42854,12 +42880,12 @@ async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPat
 async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path50.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = await tryBindingFromSessionDirectory(path50.join(hint, sid));
+  const hint = path51.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path51.join(hint, sid));
   if (underHint) return underHint;
   const direct = await tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path50.basename(hint) === sid && await isGitDir(hint)) {
+    if (path51.basename(hint) === sid && await isGitDir(hint)) {
       const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -42867,7 +42893,7 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeR
     }
     return direct;
   }
-  if (path50.basename(hint) === sid && await isGitDir(hint)) {
+  if (path51.basename(hint) === sid && await isGitDir(hint)) {
     const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
@@ -42880,11 +42906,11 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeR
   if (!st.isDirectory()) return null;
   const legacyPaths = await collectWorktreeRootsNamed(hint, sid);
   if (legacyPaths.paths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path50.resolve(legacyPaths.paths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path51.resolve(legacyPaths.paths[0]);
   return {
-    sessionParentPath: path50.resolve(isolated),
+    sessionParentPath: path51.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.paths.map((p) => path50.resolve(p))
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path51.resolve(p))
   };
 }
 
@@ -42946,11 +42972,11 @@ function parseSessionParent(v) {
 
 // src/worktrees/prepare-new-session-worktrees.ts
 import * as fs35 from "node:fs";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 
 // src/git/discover-repos.ts
 import * as fs34 from "node:fs";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 var GIT_DISCOVER_YIELD_EVERY = 32;
 async function yieldGitDiscoverWork(entryCount) {
   if (entryCount > 0 && entryCount % GIT_DISCOVER_YIELD_EVERY === 0) {
@@ -42959,7 +42985,7 @@ async function yieldGitDiscoverWork(entryCount) {
 }
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path51.resolve(cwd);
+  const cwdResolved = path52.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -42974,7 +43000,7 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath2 = path51.join(cwdResolved, ent.name);
+    const childPath2 = path52.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath2)) {
       const remoteUrl = await getRemoteOriginUrl(childPath2);
       result.push({ absolutePath: childPath2, remoteUrl });
@@ -42983,12 +43009,12 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootPath) {
-  const root = path51.resolve(rootPath);
+  const root = path52.resolve(rootPath);
   const roots = [];
   let walkEntries = 0;
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path51.resolve(dir));
+      roots.push(path52.resolve(dir));
       return;
     }
     let entries;
@@ -43001,7 +43027,7 @@ async function discoverGitReposUnderRoot(rootPath) {
       await yieldGitDiscoverWork(++walkEntries);
       const ent = entries[i];
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path51.join(dir, ent.name));
+      await walk(path52.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -43036,10 +43062,10 @@ function resolveBaseRefForRepo(relNorm, baseBranches) {
 }
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
-  const bridgeResolved = path52.resolve(bridgeRoot);
+  const bridgeResolved = path53.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path52.join(worktreesRootPath, cwdKey);
-  const sessionDir = path52.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path53.join(worktreesRootPath, cwdKey);
+  const sessionDir = path53.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -43049,12 +43075,12 @@ async function prepareNewSessionWorktrees(options) {
   const worktreePaths = [];
   fs35.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path52.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path52.isAbsolute(rel)) continue;
+    let rel = path53.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path53.isAbsolute(rel)) continue;
     const relNorm = normalizeRepoRelPath2(rel === "" ? "." : rel);
-    const wtPath = relNorm === "." ? sessionDir : path52.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path53.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs35.mkdirSync(path52.dirname(wtPath), { recursive: true });
+      fs35.mkdirSync(path53.dirname(wtPath), { recursive: true });
     }
     const baseRef = resolveBaseRefForRepo(relNorm, worktreeBaseBranches);
     try {
@@ -43107,9 +43133,9 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 }
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 async function resolveExplicitSessionParentPath(params) {
-  const resolved = path53.resolve(params.parentPathRaw);
+  const resolved = path54.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
     return resolved;
   }
@@ -43126,7 +43152,7 @@ async function resolveExplicitSessionParentPath(params) {
     await yieldToEventLoop();
     const tryRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
     if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path53.dirname(cur);
+    const next = path54.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -43236,7 +43262,7 @@ function createSessionWorktreeGitApi(ctx) {
       await renameSessionWorktreeBranch(ctx.cache, sessionId, newBranch, ctx.log);
     },
     async removeSessionWorktrees(sessionId) {
-      await removeSessionWorktreeCheckouts(ctx.cache, sessionId, ctx.log);
+      await removeSessionWorktreeCheckouts(ctx.cache, sessionId, ctx.worktreesRootPath, ctx.log);
     },
     async commitSession(params) {
       return commitSessionWorktree(ctx.cache, params);
@@ -43265,17 +43291,17 @@ var SessionWorktreeManager = class {
 };
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 import os9 from "node:os";
 function defaultWorktreesRootPath() {
-  return path54.join(os9.homedir(), ".buildautomaton", "worktrees");
+  return path55.join(os9.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
-import path59 from "node:path";
+import path60 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path55 from "node:path";
+import path56 from "node:path";
 
 // src/files/index/file-index-sqlite-lock.ts
 var fileIndexChain = Promise.resolve();
@@ -43366,7 +43392,7 @@ function assertNotShutdown2() {
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path55.resolve(cwd);
+  const resolved = path56.resolve(cwd);
   await yieldToEventLoop();
   assertNotShutdown2();
   const paths = await collectWorkspacePathsAsync(resolved);
@@ -43379,7 +43405,7 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path56 from "node:path";
+import path57 from "node:path";
 
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
@@ -43431,7 +43457,7 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path56.resolve(cwd);
+  const resolved = path57.resolve(cwd);
   if (await bridgeFileIndexIsPopulated(resolved)) {
     return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
@@ -43480,10 +43506,10 @@ function createFileIndexFsWatcher(resolved, schedule) {
 
 // src/files/index/file-index-incremental-symbol-updates.ts
 import fs36 from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
   for (const rel of relPaths) {
-    const absPath = path57.join(resolved, rel);
+    const absPath = path58.join(resolved, rel);
     try {
       const stat3 = await fs36.promises.stat(absPath);
       if (stat3.isFile()) {
@@ -43503,9 +43529,9 @@ async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
 }
 
 // src/files/index/file-index-initial-builds.ts
-import path58 from "node:path";
+import path59 from "node:path";
 async function runInitialIndexBuilds(cwd = getBridgeRoot()) {
-  const resolved = path58.resolve(cwd);
+  const resolved = path59.resolve(cwd);
   try {
     await buildFileIndexAsync(resolved);
     await buildSymbolIndexAsync(resolved);
@@ -43523,7 +43549,7 @@ function scheduleInitialIndexBuilds(cwd = getBridgeRoot()) {
 // src/files/watch-file-index.ts
 var MAX_INCREMENTAL_SYMBOL_UPDATES = 512;
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path59.resolve(cwd);
+  const resolved = path60.resolve(cwd);
   let timer = null;
   const pendingSymbolUpdates = /* @__PURE__ */ new Set();
   let needsFullSymbolRebuild = false;
@@ -43585,7 +43611,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -43895,10 +43921,10 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 import { spawn as spawn7 } from "node:child_process";
 import fs39 from "node:fs";
 import { tmpdir } from "node:os";
-import path60 from "node:path";
+import path61 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs39.mkdtempSync(path60.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path60.join(tmpRoot, "combined.log");
+  const tmpRoot = fs39.mkdtempSync(path61.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path61.join(tmpRoot, "combined.log");
   let logFd;
   try {
     logFd = fs39.openSync(logPath, "a");
@@ -43942,15 +43968,15 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 import { spawn as spawn8 } from "node:child_process";
 import fs40 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path61 from "node:path";
+import path62 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path61.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path61.join(tmpRoot, "combined.log");
-  const innerPath = path61.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path61.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs40.mkdtempSync(path62.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path62.join(tmpRoot, "combined.log");
+  const innerPath = path62.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path62.join(tmpRoot, "_run.sh");
   try {
     fs40.writeFileSync(innerPath, `#!/bin/sh
 ${command}
@@ -43981,9 +44007,9 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path61.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path61.join(tmpRoot, "combined.log");
-  const runnerPath = path61.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs40.mkdtempSync(path62.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path62.join(tmpRoot, "combined.log");
+  const runnerPath = path62.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
@@ -44933,15 +44959,15 @@ async function yieldSkillDiscoveryWork(entryCount) {
 
 // src/skills/discovery/discover-local-skills.ts
 import fs41 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 function collectSkillFromDir(rel, base, name, seenKeys, out) {
-  const dir = path62.join(base, name);
+  const dir = path63.join(base, name);
   try {
     if (!fs41.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  const skillMd = path62.join(dir, "SKILL.md");
+  const skillMd = path63.join(dir, "SKILL.md");
   if (!fs41.existsSync(skillMd)) return;
   const key = `${rel}/${name}`;
   if (seenKeys.has(key)) return;
@@ -44954,7 +44980,7 @@ async function discoverLocalSkillsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path62.join(cwd, rel);
+    const base = path63.join(cwd, rel);
     if (!fs41.existsSync(base) || !fs41.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -44972,15 +44998,15 @@ async function discoverLocalSkillsAsync(cwd) {
 
 // src/skills/discovery/discover-skill-layout-roots.ts
 import fs42 from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 function collectLayoutSkill(rel, base, name, skills2) {
-  const dir = path63.join(base, name);
+  const dir = path64.join(base, name);
   try {
     if (!fs42.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  if (!fs42.existsSync(path63.join(dir, "SKILL.md"))) return;
+  if (!fs42.existsSync(path64.join(dir, "SKILL.md"))) return;
   const relPath = `${rel}/${name}`.replace(/\\/g, "/");
   skills2.push({ name, relPath });
 }
@@ -44989,7 +45015,7 @@ async function discoverSkillLayoutRootsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path63.join(cwd, rel);
+    const base = path64.join(cwd, rel);
     if (!fs42.existsSync(base) || !fs42.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -45341,7 +45367,7 @@ import fs44 from "node:fs";
 
 // src/git/snapshot/capture.ts
 import * as fs43 from "node:fs";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 
 // src/git/snapshot/git.ts
 async function gitStashCreate(repoRoot, log2) {
@@ -45381,7 +45407,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path64.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path65.resolve(p)))];
     return uniq;
   }
   try {
@@ -45389,7 +45415,7 @@ async function resolveSnapshotRepoRoots(options) {
     const mapped = repos.map((r) => r.absolutePath);
     const sid = sessionId?.trim();
     if (sid) {
-      const filtered = mapped.filter((root) => path64.basename(root) === sid);
+      const filtered = mapped.filter((root) => path65.basename(root) === sid);
       if (filtered.length > 0) return filtered;
     }
     return mapped;
@@ -45420,7 +45446,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path64.join(dir, `${runId}.json`);
+  const filePath = path65.join(dir, `${runId}.json`);
   try {
     fs43.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -45763,9 +45789,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path75 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path75) continue;
-    const row = { path: path75 };
+    const path76 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path76) continue;
+    const row = { path: path76 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -45976,8 +46002,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path75, body) {
-  const url2 = `http://127.0.0.1:${port}${path75}`;
+async function requestPreviewApi(port, secret, method, path76, body) {
+  const url2 = `http://127.0.0.1:${port}${path76}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -45989,7 +46015,7 @@ async function requestPreviewApi(port, secret, method, path75, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path75}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path76}: ${res.status}`);
   }
   return data;
 }
@@ -46168,11 +46194,11 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
 import fs46 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path65 from "node:path";
+import path66 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path65.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path65.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path65.sep) && resolved !== cwd) {
+  const normalized = path66.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path66.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path66.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -46182,11 +46208,11 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path66 from "node:path";
+import path67 from "node:path";
 import fs45 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path66.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path66.join(resolved, d.name);
+  const entryPath = path67.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path67.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
@@ -46236,13 +46262,13 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
 }
 
 // src/files/handle-file-browser-search.ts
-import path67 from "node:path";
+import path68 from "node:path";
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const sessionParentPath = path67.resolve(
+    const sessionParentPath = path68.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -46452,13 +46478,13 @@ function triggerSymbolIndexBuild(parentPath) {
 }
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path68.resolve(bridgeRoot);
+  const bridgeResolved = path69.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path68.join(bridgeResolved, rel);
-  const resolved = path68.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path68.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path69.join(bridgeResolved, rel);
+  const resolved = path69.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path69.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -47241,7 +47267,7 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 import fs50 from "node:fs";
-import path69 from "node:path";
+import path70 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -47252,8 +47278,8 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path69.join(skillDir, f.path);
-  await fs50.promises.mkdir(path69.dirname(dest), { recursive: true });
+  const dest = path70.join(skillDir, f.path);
+  await fs50.promises.mkdir(path70.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
     await fs50.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
@@ -47269,7 +47295,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path69.join(cwd, targetDir, item.skillName);
+      const skillDir = path70.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -47608,7 +47634,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -47658,12 +47684,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path70.basename(path70.resolve(bridgeRoot)) || "repo";
+    return path71.basename(path71.resolve(bridgeRoot)) || "repo";
   }
-  return path70.basename(relPath) || relPath;
+  return path71.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path70.resolve(bridgeRoot);
+  const root = path71.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -47671,19 +47697,19 @@ async function discoverGitReposForBridgeContext(bridgeRoot) {
   const [deep, shallow] = await Promise.all([discoverGitReposUnderRoot(root), discoverGitRepos(root)]);
   const byPath = /* @__PURE__ */ new Map();
   for (const repo of [...deep, ...shallow]) {
-    byPath.set(path70.resolve(repo.absolutePath), repo);
+    byPath.set(path71.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path70.resolve(bridgeRoot);
+  const bridgeResolved = path71.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (let i = 0; i < repos.length; i++) {
     if (i > 0) await yieldToEventLoop();
     const repo = repos[i];
-    let rel = path70.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path70.isAbsolute(rel)) continue;
+    let rel = path71.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path71.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -47698,11 +47724,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path70.resolve(bridgeRoot);
+  const bridgeResolved = path71.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path70.join(bridgeResolved, rel);
-  const resolved = path70.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path70.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path71.join(bridgeResolved, rel);
+  const resolved = path71.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path71.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -48579,7 +48605,7 @@ async function createBridgeAccessState(options = {}) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/sqlite/hash-json-sha256.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -48646,7 +48672,7 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -48684,7 +48710,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path71.resolve(cwd),
+      cwd: path72.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -48762,7 +48788,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path72.resolve(getBridgeRoot());
+  const cwd = path73.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -48997,8 +49023,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   });
   const identifyReportedPaths = {
-    bridgeRootPath: path73.resolve(getBridgeRoot()),
-    worktreesRootPath: path73.resolve(worktreesRootPath)
+    bridgeRootPath: path74.resolve(getBridgeRoot()),
+    worktreesRootPath: path74.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -49255,7 +49281,7 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path74.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path75.resolve(process.cwd(), bridgeRootOpt);
     try {
       const st = fs52.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
@@ -49277,7 +49303,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path74.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path75.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {