@buildautomaton/cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -4065,8 +4065,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path22, errorMaps, issueData } = params;
-      const fullPath = [...path22, ...issueData.path || []];
+      const { data, path: path23, errorMaps, issueData } = params;
+      const fullPath = [...path23, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4374,11 +4374,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path22, key) {
+      constructor(parent, value, path23, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path22;
+        this._path = path23;
         this._key = key;
       }
       get path() {
@@ -7993,10 +7993,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path22) {
-  if (!path22)
+function getElementAtPath(obj, path23) {
+  if (!path23)
     return obj;
-  return path22.reduce((acc, key) => acc?.[key], obj);
+  return path23.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8245,11 +8245,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path22, issues) {
+function prefixIssues(path23, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path22);
+    iss.path.unshift(path23);
     return iss;
   });
 }
@@ -8438,7 +8438,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path22 = []) => {
+  const processError = (error41, path23 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8448,7 +8448,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path22, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8478,9 +8478,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path22) {
+function toDotPath(path23) {
   const segs = [];
-  for (const seg of path22) {
+  for (const seg of path23) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21963,10 +21963,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(path22, isFile, isDirectory) {
-      log2(`checking %s`, path22);
+    function check2(path23, isFile, isDirectory) {
+      log2(`checking %s`, path23);
       try {
-        const stat4 = fs_1.statSync(path22);
+        const stat4 = fs_1.statSync(path23);
         if (stat4.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -21986,8 +21986,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path22, type = exports.READABLE) {
-      return check2(path22, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path23, type = exports.READABLE) {
+      return check2(path23, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22114,24 +22114,48 @@ function sendWsMessage(ws, payload) {
 
 // src/acp/clients/acp-client.ts
 import { spawn } from "node:child_process";
+import path from "node:path";
 import { Readable, Writable } from "node:stream";
+
+// src/acp/format-acp-rpc-error.ts
+function formatAcpRpcError(err) {
+  if (err instanceof Error) return err.message;
+  if (err != null && typeof err === "object") {
+    const o = err;
+    if (typeof o.message === "string") {
+      const code = typeof o.code === "number" ? ` (code ${o.code})` : "";
+      return `${o.message}${code}`;
+    }
+  }
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function isAcpAuthenticationRequiredError(err) {
+  if (err == null || typeof err !== "object") return false;
+  const o = err;
+  if (o.code === -32e3 && typeof o.message === "string") {
+    const m2 = o.message.toLowerCase();
+    if (m2.includes("authentication") || m2.includes("auth")) return true;
+  }
+  const m = typeof o.message === "string" ? o.message.toLowerCase() : "";
+  return m.includes("authentication required") || m.includes("auth_required");
+}
+
+// src/acp/clients/acp-client.ts
 function formatSpawnError(err, command) {
   if (err.code === "ENOENT") {
     return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
   }
   return err.message || String(err);
 }
-function toErrorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (err != null && typeof err === "object" && "message" in err)
-    return String(err.message);
-  if (typeof err === "string") return err;
-  if (err != null && typeof err === "object") return JSON.stringify(err);
-  return String(err);
-}
 async function createAcpClient(options) {
-  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
+  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const { command, cwd: cwd3 = process.cwd(), onSessionUpdate } = options;
+  const sessionCwd = path.resolve(cwd3);
   const isWindows2 = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
     cwd: cwd3,
@@ -22162,11 +22186,13 @@ async function createAcpClient(options) {
           child.kill();
         });
         await connection.initialize({
-          protocolVersion: "0.1.0",
-          capabilities: {},
+          protocolVersion: PROTOCOL_VERSION2,
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        const newSessionRes = await connection.newSession({ workingDirectory: cwd3 });
+        const newSessionRes = await connection.newSession({
+          cwd: sessionCwd,
+          mcpServers: []
+        });
         const sessionId = newSessionRes.sessionId;
         resolve16({
           sessionId,
@@ -22174,7 +22200,7 @@ async function createAcpClient(options) {
             try {
               const response = await connection.prompt({
                 sessionId,
-                prompt: { type: "text", text: prompt }
+                prompt: [{ type: "text", text: prompt }]
               });
               const r = response;
               const cancelled = (r?.stopReason ?? "").toLowerCase() === "cancelled";
@@ -22187,7 +22213,8 @@ async function createAcpClient(options) {
             } catch (err) {
               return {
                 success: false,
-                error: err instanceof Error ? err.message : String(err)
+                error: formatAcpRpcError(err),
+                ...isAcpAuthenticationRequiredError(err) ? { authRequired: true } : {}
               };
             }
           },
@@ -22205,7 +22232,7 @@ async function createAcpClient(options) {
         });
       } catch (err) {
         child.kill();
-        reject(new Error(toErrorMessage(err)));
+        reject(new Error(formatAcpRpcError(err)));
       }
     })();
   });
@@ -22339,8 +22366,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path22, body) {
-  const url2 = `http://127.0.0.1:${port}${path22}`;
+async function requestPreviewApi(port, secret, method, path23, body) {
+  const url2 = `http://127.0.0.1:${port}${path23}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -22352,7 +22379,7 @@ async function requestPreviewApi(port, secret, method, path22, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path22}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path23}: ${res.status}`);
   }
   return data;
 }
@@ -22503,11 +22530,11 @@ function log(line) {
 
 // src/config.ts
 import fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import os from "node:os";
 function getConfigPath() {
-  const dir = path.join(os.homedir(), ".buildautomaton");
-  return path.join(dir, "config.json");
+  const dir = path2.join(os.homedir(), ".buildautomaton");
+  return path2.join(dir, "config.json");
 }
 function normalizeApiUrl(url2) {
   return url2.replace(/\/$/, "");
@@ -22523,7 +22550,7 @@ function readRawConfig() {
 }
 function writeConfigForApi(apiUrl, auth) {
   const p = getConfigPath();
-  const dir = path.dirname(p);
+  const dir = path2.dirname(p);
   const key = normalizeApiUrl(apiUrl);
   const prev = readRawConfig() ?? {};
   const servers = { ...prev.servers ?? {}, [key]: { ...auth } };
@@ -22715,13 +22742,13 @@ function runPendingAuth(options) {
 
 // src/skills/discover-local-agent-skills.ts
 import fs2 from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd3) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path2.join(cwd3, rel);
+    const base = path3.join(cwd3, rel);
     if (!fs2.existsSync(base) || !fs2.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -22730,13 +22757,13 @@ function discoverLocalSkills(cwd3) {
       continue;
     }
     for (const name of entries) {
-      const dir = path2.join(base, name);
+      const dir = path3.join(base, name);
       try {
         if (!fs2.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path2.join(dir, "SKILL.md");
+      const skillMd = path3.join(dir, "SKILL.md");
       if (!fs2.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
@@ -22749,7 +22776,7 @@ function discoverLocalSkills(cwd3) {
 function discoverSkillLayoutRoots(cwd3) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path2.join(cwd3, rel);
+    const base = path3.join(cwd3, rel);
     if (!fs2.existsSync(base) || !fs2.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -22759,13 +22786,13 @@ function discoverSkillLayoutRoots(cwd3) {
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path2.join(base, name);
+      const dir = path3.join(base, name);
       try {
         if (!fs2.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs2.existsSync(path2.join(dir, "SKILL.md"))) continue;
+      if (!fs2.existsSync(path3.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -22785,7 +22812,7 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
 
 // src/git/discover-repos.ts
 import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // ../../node_modules/.pnpm/simple-git@3.32.3/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -22824,8 +22851,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path22) {
-  return path22 instanceof String && cache.has(path22);
+function isPathSpec(path23) {
+  return path23 instanceof String && cache.has(path23);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -22914,8 +22941,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path22) {
-  return (0, import_file_exists.exists)(path22, import_file_exists.FOLDER);
+function folderExists(path23) {
+  return (0, import_file_exists.exists)(path23, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -23319,8 +23346,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path22) {
-      return /^\.(git)?$/.test(path22.trim());
+    parser(path23) {
+      return /^\.(git)?$/.test(path23.trim());
     }
   };
 }
@@ -23754,11 +23781,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path22, line, preview] = input.split(NULL);
-    paths.add(path22);
-    (results[path22] = results[path22] || []).push({
+    const [path23, line, preview] = input.split(NULL);
+    paths.add(path23);
+    (results[path23] = results[path23] || []).push({
       line: asNumber(line),
-      path: path22,
+      path: path23,
       preview
     });
   });
@@ -24523,14 +24550,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path22, text) {
+function parseInit(bare, path23, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path22, false, result[1]);
+    return new InitSummary(bare, path23, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path22, true, result[1]);
+    return new InitSummary(bare, path23, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -24541,7 +24568,7 @@ function parseInit(bare, path22, text) {
       break;
     }
   }
-  return new InitSummary(bare, path22, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path23, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -24550,9 +24577,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path22, existing, gitDir) {
+      constructor(bare, path23, existing, gitDir) {
         this.bare = bare;
-        this.path = path22;
+        this.path = path23;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -24564,7 +24591,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path22, customArgs) {
+function initTask(bare = false, path23, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -24573,7 +24600,7 @@ function initTask(bare = false, path22, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path22, text);
+      return parseInit(commands.includes("--bare"), path23, text);
     }
   };
 }
@@ -25389,12 +25416,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path22, index, working_dir) {
-        this.path = path22;
+      constructor(path23, index, working_dir) {
+        this.path = path23;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path22) || [null, path22, path22];
+          const detail = fromPathRegex.exec(path23) || [null, path23, path23];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -25425,14 +25452,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path22) {
+  function data(index, workingDir, path23) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path22);
+      handler(result, path23);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path22, index, workingDir));
+      result.files.push(new FileStatusSummary(path23, index, workingDir));
     }
   }
 }
@@ -25741,9 +25768,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path22, write) {
+      hashObject(path23, write) {
         return this._runTask(
-          hashObjectTask(path22, write === true),
+          hashObjectTask(path23, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -26096,8 +26123,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path22 = input.trim().replace(/^["']|["']$/g, "");
-  return path22 && normalize(path22);
+  const path23 = input.trim().replace(/^["']|["']$/g, "");
+  return path23 && normalize(path23);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -26411,8 +26438,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path22) {
-  return subModuleTask(["add", repo, path22]);
+function addSubModuleTask(repo, path23) {
+  return subModuleTask(["add", repo, path23]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -26745,8 +26772,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path22, then) {
-      return this._runTask(addSubModuleTask2(repo, path22), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path23, then) {
+      return this._runTask(addSubModuleTask2(repo, path23), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -27372,7 +27399,7 @@ async function isGitRepoDirectory(dirPath) {
 // src/git/discover-repos.ts
 async function discoverGitRepos(cwd3 = process.cwd()) {
   const result = [];
-  const cwdResolved = path3.resolve(cwd3);
+  const cwdResolved = path4.resolve(cwd3);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -27385,7 +27412,7 @@ async function discoverGitRepos(cwd3 = process.cwd()) {
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path3.join(cwdResolved, ent.name);
+    const childPath = path4.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -27394,11 +27421,11 @@ async function discoverGitRepos(cwd3 = process.cwd()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootAbs) {
-  const root = path3.resolve(rootAbs);
+  const root = path4.resolve(rootAbs);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path3.resolve(dir));
+      roots.push(path4.resolve(dir));
       return;
     }
     let entries;
@@ -27409,7 +27436,7 @@ async function discoverGitReposUnderRoot(rootAbs) {
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path3.join(dir, ent.name));
+      await walk(path4.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -27598,7 +27625,7 @@ function connectProxy(options) {
 // src/git/session-git-queue.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var execFileAsync = promisify(execFile);
 var sessionBoundaryBySessionId = /* @__PURE__ */ new Map();
 async function gitStashCreate(repoRoot, log2) {
@@ -27649,7 +27676,7 @@ async function collectSessionDiffAndNotify(options) {
       continue;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
-    const slug = path4.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
+    const slug = path5.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
@@ -27688,6 +27715,7 @@ async function sendPromptToAgent(options) {
     sendResult,
     sendSessionUpdate,
     collectSessionDiffAfterTurn,
+    agentType,
     log: log2
   } = options;
   log2("[prompt] Sending to agent\u2026");
@@ -27701,7 +27729,12 @@ async function sendPromptToAgent(options) {
       id: promptId,
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
-      ...result
+      success: result.success,
+      ...typeof result.stopReason === "string" ? { stopReason: result.stopReason } : {},
+      ...typeof result.output === "string" ? { output: result.output } : {},
+      ...typeof result.error === "string" ? { error: result.error } : {},
+      ...result.authRequired ? { authRequired: true } : {},
+      ...agentType ? { agentType } : {}
     });
     if (result.success) {
       const out = result.output ?? "";
@@ -27709,10 +27742,11 @@ async function sendPromptToAgent(options) {
       log2(`[prompt] Done; sent response (${out.length} chars)`);
       if (preview) log2(`[prompt] Response: ${preview}`);
     } else {
-      log2(`[prompt] Agent error: ${result.error}`);
+      log2(`[prompt] Agent error: ${result.error ?? "(unknown)"}`);
     }
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMsg = formatAcpRpcError(err);
+    const authRequired = isAcpAuthenticationRequiredError(err);
     log2(`[prompt] Send failed: ${errMsg}`);
     if (err instanceof Error && err.stack) log2(`[prompt] ${err.stack}`);
     sendResult({
@@ -27721,13 +27755,15 @@ async function sendPromptToAgent(options) {
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
       success: false,
-      error: errMsg
+      error: errMsg,
+      ...authRequired ? { authRequired: true } : {},
+      ...agentType ? { agentType } : {}
     });
   }
 }
 
 // src/acp/ensure-acp-client.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -27739,6 +27775,17 @@ function errorMessage(err) {
   return String(err);
 }
 
+// src/acp/clients/claude-agent-acp-client.ts
+var DEFAULT_CLAUDE_AGENT_ACP_COMMAND = ["npx", "--yes", "@agentclientprotocol/claude-agent-acp"];
+function isClaudeAgentAcpCommand(command) {
+  const i = command.indexOf("@agentclientprotocol/claude-agent-acp");
+  return i >= 0 && (i === 0 || command[i - 1] === "npx" || command[i - 1] === "bunx");
+}
+async function createClaudeAgentAcpClient(options) {
+  const command = options.command?.length && options.command.some((a) => a.includes("claude-agent-acp")) ? options.command : [...DEFAULT_CLAUDE_AGENT_ACP_COMMAND];
+  return createAcpClient({ ...options, command });
+}
+
 // src/acp/clients/codex-acp-client.ts
 var DEFAULT_CODEX_ACP_COMMAND = ["npx", "--yes", "@zed-industries/codex-acp"];
 function isCodexAcpCommand(command) {
@@ -27757,21 +27804,21 @@ import { spawn as spawn4 } from "node:child_process";
 import * as readline from "node:readline";
 
 // src/acp/safe-fs-path.ts
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 function resolveSafePathUnderCwd(cwd3, filePath) {
   const trimmed2 = filePath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path5.resolve(cwd3);
-  const resolved = path5.isAbsolute(trimmed2) ? path5.normalize(trimmed2) : path5.resolve(normalizedCwd, trimmed2);
-  const rel = path5.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path5.isAbsolute(rel)) return null;
+  const normalizedCwd = path6.resolve(cwd3);
+  const resolved = path6.isAbsolute(trimmed2) ? path6.normalize(trimmed2) : path6.resolve(normalizedCwd, trimmed2);
+  const rel = path6.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
   return resolved;
 }
 function toDisplayPathRelativeToCwd(cwd3, absolutePath) {
-  const normalizedCwd = path5.resolve(cwd3);
-  const rel = path5.relative(normalizedCwd, path5.resolve(absolutePath));
-  if (!rel || rel === "") return path5.basename(absolutePath);
-  return rel.split(path5.sep).join("/");
+  const normalizedCwd = path6.resolve(cwd3);
+  const rel = path6.relative(normalizedCwd, path6.resolve(absolutePath));
+  if (!rel || rel === "") return path6.basename(absolutePath);
+  return rel.split(path6.sep).join("/");
 }
 
 // src/files/diff/unified-diff.ts
@@ -28073,7 +28120,7 @@ async function createCursorAcpClient(options) {
 var AGENT_TYPE_DEFAULT_COMMANDS = {
   "cursor-cli": ["agent", "acp"],
   "codex-acp": [...DEFAULT_CODEX_ACP_COMMAND],
-  "claude-code": ["npx", "--yes", "@anthropic-ai/claude-code"]
+  "claude-code": [...DEFAULT_CLAUDE_AGENT_ACP_COMMAND]
 };
 function useCursorAcp(agentType, command) {
   if (agentType === "cursor-cli") return true;
@@ -28083,12 +28130,16 @@ function useCodexAcp(agentType, command) {
   if (agentType === "codex-acp") return true;
   return isCodexAcpCommand(command);
 }
+function useClaudeAgentAcp(agentType, command) {
+  if (agentType === "claude-code") return true;
+  return isClaudeAgentAcpCommand(command);
+}
 function resolveAgentCommand(agentCommand, preferredAgentType) {
   const explicitCmd = agentCommand?.length ? agentCommand : void 0;
   const typeCmd = preferredAgentType ? AGENT_TYPE_DEFAULT_COMMANDS[preferredAgentType] : void 0;
   const command = explicitCmd ?? typeCmd;
   if (!command?.length) return null;
-  const createClient = useCursorAcp(preferredAgentType, command) ? createCursorAcpClient : useCodexAcp(preferredAgentType, command) ? createCodexAcpClient : createAcpClient;
+  const createClient = useCursorAcp(preferredAgentType, command) ? createCursorAcpClient : useCodexAcp(preferredAgentType, command) ? createCodexAcpClient : useClaudeAgentAcp(preferredAgentType, command) ? createClaudeAgentAcpClient : createAcpClient;
   const label = preferredAgentType ?? "--agent";
   return { command, label, createClient };
 }
@@ -28099,16 +28150,16 @@ import { existsSync, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync } from "node:child_process";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path6.resolve(startDir),
+      cwd: path7.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path6.resolve(out) : null;
+    return out ? path7.resolve(out) : null;
   } catch {
     return null;
   }
@@ -28117,25 +28168,25 @@ function getGitRepoRootSync(startDir) {
 // src/acp/workspace-files.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { readFileSync as readFileSync2 } from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function resolveWorkspaceFilePath(cwd3, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path7.resolve(cwd3);
+  const normalizedCwd = path8.resolve(cwd3);
   let abs = resolveSafePathUnderCwd(cwd3, trimmed2);
   if (!abs) {
-    const candidate = path7.isAbsolute(trimmed2) ? path7.normalize(trimmed2) : path7.normalize(path7.resolve(normalizedCwd, trimmed2));
+    const candidate = path8.isAbsolute(trimmed2) ? path8.normalize(trimmed2) : path8.normalize(path8.resolve(normalizedCwd, trimmed2));
     const gitRoot2 = getGitRepoRootSync(cwd3);
     if (!gitRoot2) return null;
-    const rel = path7.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path7.isAbsolute(rel)) return null;
+    const rel = path8.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path8.isAbsolute(rel)) return null;
     abs = candidate;
   }
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const relFromRoot = path7.relative(gitRoot, abs);
-    if (!relFromRoot.startsWith("..") && !path7.isAbsolute(relFromRoot)) {
-      return { abs, display: relFromRoot.split(path7.sep).join("/") };
+    const relFromRoot = path8.relative(gitRoot, abs);
+    if (!relFromRoot.startsWith("..") && !path8.isAbsolute(relFromRoot)) {
+      return { abs, display: relFromRoot.split(path8.sep).join("/") };
     }
   }
   return { abs, display: toDisplayPathRelativeToCwd(cwd3, abs) };
@@ -28144,9 +28195,9 @@ function readUtf8WorkspaceFile(cwd3, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const abs2 = path7.resolve(gitRoot, displayPath);
-    const rel = path7.relative(gitRoot, abs2);
-    if (!rel.startsWith("..") && !path7.isAbsolute(rel)) {
+    const abs2 = path8.resolve(gitRoot, displayPath);
+    const rel = path8.relative(gitRoot, abs2);
+    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) {
       try {
         return readFileSync2(abs2, "utf8");
       } catch {
@@ -28165,9 +28216,9 @@ function tryWorkspaceDisplayToAbs(cwd3, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const abs = path7.resolve(gitRoot, displayPath);
-    const rel = path7.relative(gitRoot, abs);
-    if (!rel.startsWith("..") && !path7.isAbsolute(rel)) return abs;
+    const abs = path8.resolve(gitRoot, displayPath);
+    const rel = path8.relative(gitRoot, abs);
+    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) return abs;
   }
   return resolveSafePathUnderCwd(cwd3, displayPath);
 }
@@ -28461,6 +28512,11 @@ function isCompletedToolStatus(status) {
   const s = status.toLowerCase();
   return s === "completed" || s === "complete" || s === "succeeded" || s === "success";
 }
+function isTerminalToolStatus(status) {
+  if (typeof status !== "string") return false;
+  const s = status.toLowerCase();
+  return isCompletedToolStatus(status) || s === "failed" || s === "cancelled" || s === "canceled";
+}
 function accumulateToolPaths(toolKey, paths, acc) {
   if (!toolKey || paths.length === 0) return;
   let s = acc.get(toolKey);
@@ -28723,7 +28779,7 @@ function buildAcpSessionBridgeHooks(opts) {
 async function ensureAcpClient(options) {
   const { state, agentCommand, preferredAgentType, mode, cwd: cwd3, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
   const targetCwd = cwd3 ?? process.cwd();
-  if (state.acpHandle && state.lastAcpCwd != null && path8.resolve(state.lastAcpCwd) !== path8.resolve(targetCwd)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path9.resolve(state.lastAcpCwd) !== path9.resolve(targetCwd)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -28865,6 +28921,7 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
+        agentType: preferredForPrompt,
         sendResult,
         sendSessionUpdate,
         collectSessionDiffAfterTurn,
@@ -28952,12 +29009,12 @@ function handleBridgeAgentConfig(msg, { acpManager }) {
 var handleAgentConfigMessage = (msg, deps) => handleBridgeAgentConfig(msg, deps);
 
 // src/acp/from-bridge/handle-bridge-prompt.ts
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 
 // src/git/bridge-queue-key.ts
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { createHash } from "node:crypto";
 function normalizeCanonicalGitUrl(url2) {
   let s = url2.trim();
@@ -28985,11 +29042,11 @@ function canonicalUrlToRepoIdSync(url2) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
 }
 function fallbackRepoIdFromPath(absPath) {
-  return createHash("sha256").update(path9.resolve(absPath)).digest("hex").slice(0, 32);
+  return createHash("sha256").update(path10.resolve(absPath)).digest("hex").slice(0, 32);
 }
 async function resolveBridgeQueueBindFields(options) {
   const { effectiveCwd, worktreePaths, primaryRepoRoots, log: log2 } = options;
-  const cwdAbs = worktreePaths.length > 0 ? path9.resolve(worktreePaths[0]) : path9.resolve(effectiveCwd);
+  const cwdAbs = worktreePaths.length > 0 ? path10.resolve(worktreePaths[0]) : path10.resolve(effectiveCwd);
   if (!primaryRepoRoots.length) {
     log2("[bridge-queue] bind skipped: no git repo roots");
     return null;
@@ -29013,12 +29070,12 @@ async function resolveBridgeQueueBindFields(options) {
 
 // src/git/pre-turn-snapshot.ts
 import * as fs4 from "node:fs";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
 function snapshotsDirForCwd(agentCwd) {
-  return path10.join(agentCwd, ".buildautomaton", "snapshots");
+  return path11.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate2(repoRoot, log2) {
   try {
@@ -29045,7 +29102,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path10.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path11.resolve(p)))];
     return uniq;
   }
   try {
@@ -29077,7 +29134,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path10.join(dir, `${runId}.json`);
+  const filePath = path11.join(dir, `${runId}.json`);
   try {
     fs4.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -29112,7 +29169,7 @@ async function applyPreTurnSnapshot(filePath, log2) {
   return { ok: true };
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path10.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path11.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/acp/from-bridge/handle-bridge-prompt.ts
@@ -29152,15 +29209,27 @@ function handleBridgePrompt(msg, deps) {
       return;
     }
     const p = payload;
-    const patchHint = p.type === "session_file_change" && typeof p.patchContent === "string" ? ` patchBytes=${p.patchContent.length}` : "";
-    log2(
-      `[bridge\u2192ws] ${p.type ?? "payload"} runId=${p.runId?.slice(0, 8) ?? "?"}\u2026 kind=${p.kind ?? "?"}${p.path ? ` path=${p.path}` : ""}${patchHint}`
-    );
+    if (p.type === "session_file_change" && typeof p.path === "string") {
+      log2(
+        `[bridge\u2192ws] session_file_change runId=${p.runId?.slice(0, 8) ?? "?"}\u2026 path=${p.path}`
+      );
+    } else if (p.type === "session_update" && (p.kind === "tool_call_update" || p.kind === "tool_call")) {
+      const inner = p.payload && typeof p.payload === "object" ? p.payload : null;
+      const status = inner?.status;
+      if (isTerminalToolStatus(status)) {
+        const tc = inner?.toolCall ?? inner?.tool_call;
+        const toolName = typeof tc?.name === "string" ? tc.name : "";
+        const st = typeof status === "string" ? status : String(status);
+        log2(
+          `[bridge\u2192ws] tool finished runId=${p.runId?.slice(0, 8) ?? "?"}\u2026 tool=${toolName || "?"} status=${st}`
+        );
+      }
+    }
     sendWsMessage(s, payload);
   };
   async function preambleAndPrompt(resolvedCwd) {
     const s = getWs();
-    const effectiveCwd = path11.resolve(resolvedCwd ?? process.cwd());
+    const effectiveCwd = path12.resolve(resolvedCwd ?? process.cwd());
     const worktreePaths = sessionWorktreeManager.getWorktreePathsForSession(sessionId) ?? [];
     const repoRoots = await resolveSnapshotRepoRoots({
       worktreePaths,
@@ -29282,14 +29351,14 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 
 // src/files/list-dir.ts
 import fs5 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path12 from "node:path";
+import path13 from "node:path";
 function ensureUnderCwd(relativePath, cwd3 = process.cwd()) {
-  const normalized = path12.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path12.resolve(cwd3, normalized);
-  if (!resolved.startsWith(cwd3 + path12.sep) && resolved !== cwd3) {
+  const normalized = path13.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path13.resolve(cwd3, normalized);
+  if (!resolved.startsWith(cwd3 + path13.sep) && resolved !== cwd3) {
     return null;
   }
   return resolved;
@@ -29305,8 +29374,8 @@ function listDir(relativePath) {
   try {
     const names = fs5.readdirSync(resolved, { withFileTypes: true });
     const entries = names.filter((d) => !d.name.startsWith(".")).map((d) => {
-      const entryPath = path13.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path13.join(resolved, d.name);
+      const entryPath = path14.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path14.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
@@ -29523,15 +29592,15 @@ function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize =
 
 // src/files/file-index.ts
 import fs7 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 import os2 from "node:os";
 import crypto2 from "node:crypto";
-var INDEX_DIR = path14.join(os2.homedir(), ".buildautomaton");
+var INDEX_DIR = path15.join(os2.homedir(), ".buildautomaton");
 var HASH_LEN = 16;
 var INDEX_VERSION = 2;
 function getIndexPath(cwd3) {
   const hash = crypto2.createHash("sha256").update(cwd3).digest("hex").slice(0, HASH_LEN);
-  return path14.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path15.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 function getTrigrams(s) {
   const lower = s.toLowerCase();
@@ -29575,14 +29644,14 @@ function walkDir(dir, baseDir, out) {
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path14.join(dir, name);
+    const full = path15.join(dir, name);
     let stat4;
     try {
       stat4 = fs7.statSync(full);
     } catch {
       continue;
     }
-    const relative6 = path14.relative(baseDir, full).replace(/\\/g, "/");
+    const relative6 = path15.relative(baseDir, full).replace(/\\/g, "/");
     if (stat4.isDirectory()) {
       walkDir(full, baseDir, out);
     } else if (stat4.isFile()) {
@@ -29591,7 +29660,7 @@ function walkDir(dir, baseDir, out) {
   }
 }
 function buildFileIndex(cwd3) {
-  const resolved = path14.resolve(cwd3);
+  const resolved = path15.resolve(cwd3);
   const paths = [];
   walkDir(resolved, resolved, paths);
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
@@ -29617,7 +29686,7 @@ function buildFileIndex(cwd3) {
   return data;
 }
 function loadFileIndex(cwd3) {
-  const resolved = path14.resolve(cwd3);
+  const resolved = path15.resolve(cwd3);
   const indexPath = getIndexPath(resolved);
   try {
     const raw = fs7.readFileSync(indexPath, "utf8");
@@ -29638,7 +29707,7 @@ function loadFileIndex(cwd3) {
   }
 }
 function ensureFileIndex(cwd3) {
-  const resolved = path14.resolve(cwd3);
+  const resolved = path15.resolve(cwd3);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = buildFileIndex(resolved);
@@ -29777,7 +29846,7 @@ function registerFileBrowserHandlers(router2) {
 
 // src/skills/install-remote-skills.ts
 import fs8 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function installRemoteSkills(cwd3, targetDir, items) {
   const installed = [];
   if (!Array.isArray(items)) {
@@ -29788,11 +29857,11 @@ function installRemoteSkills(cwd3, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path15.join(cwd3, targetDir, item.skillName);
+      const skillDir = path16.join(cwd3, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path15.join(skillDir, f.path);
-        fs8.mkdirSync(path15.dirname(dest), { recursive: true });
+        const dest = path16.join(skillDir, f.path);
+        fs8.mkdirSync(path16.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
           fs8.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
@@ -29902,7 +29971,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
 import * as fs9 from "node:fs";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   if (msg.type !== "revert_turn_snapshot") return false;
   const id = typeof msg.id === "string" ? msg.id : "";
@@ -29913,7 +29982,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
   void (async () => {
     const s = getWs();
     if (!s) return;
-    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? path16.resolve(process.cwd());
+    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? path17.resolve(process.cwd());
     const file2 = snapshotFilePath(agentBase, turnId);
     if (!fs9.existsSync(file2)) {
       sendWsMessage(s, {
@@ -29960,12 +30029,12 @@ function handleBridgeMessage(data, deps) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 import os4 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
 import * as fs11 from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -29975,11 +30044,11 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 
 // src/worktrees/worktree-layout-file.ts
 import * as fs10 from "node:fs";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 import os3 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path17.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path18.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -30000,18 +30069,18 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path17.dirname(defaultWorktreeLayoutPath());
+    const dir = path18.dirname(defaultWorktreeLayoutPath());
     fs10.mkdirSync(dir, { recursive: true });
     fs10.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(abs) {
-  return path17.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path18.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
-  const norm = path17.resolve(launcherCwdAbs);
-  const existing = layout.launcherCwds.find((e) => path17.resolve(e.absolutePath) === norm);
+  const norm = path18.resolve(launcherCwdAbs);
+  const existing = layout.launcherCwds.find((e) => path18.resolve(e.absolutePath) === norm);
   if (existing) return existing.dirName;
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
@@ -30029,9 +30098,9 @@ function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
   const { rootAbs, launcherCwd, sessionId, layout, log: log2 } = options;
-  const launcherResolved = path18.resolve(launcherCwd);
+  const launcherResolved = path19.resolve(launcherCwd);
   const cwdKey = allocateDirNameForLauncherCwd(layout, launcherResolved);
-  const agentMirrorRoot = path18.join(rootAbs, cwdKey);
+  const agentMirrorRoot = path19.join(rootAbs, cwdKey);
   const repos = await discoverGitReposUnderRoot(launcherResolved);
   if (repos.length === 0) {
     log2("[worktrees] No git repos under launcher cwd; skipping worktree creation");
@@ -30041,11 +30110,11 @@ async function prepareNewSessionWorktrees(options) {
   const worktreePaths = [];
   fs11.mkdirSync(agentMirrorRoot, { recursive: true });
   for (const repo of repos) {
-    let rel = path18.relative(launcherResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path18.isAbsolute(rel)) continue;
+    let rel = path19.relative(launcherResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path19.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = path18.join(agentMirrorRoot, relNorm, sessionId);
-    fs11.mkdirSync(path18.dirname(wtPath), { recursive: true });
+    const wtPath = path19.join(agentMirrorRoot, relNorm, sessionId);
+    fs11.mkdirSync(path19.dirname(wtPath), { recursive: true });
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
       log2(`[worktrees] Added worktree ${wtPath} (branch ${branch})`);
@@ -30087,16 +30156,16 @@ import * as fs13 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
 import * as fs12 from "node:fs";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path19.join(wt, ".git");
+  const gitDirFile = path20.join(wt, ".git");
   if (!fs12.existsSync(gitDirFile) || !fs12.statSync(gitDirFile).isFile()) return "";
   const first2 = fs12.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path19.resolve(wt, m[1].trim());
-  const gitDir = path19.dirname(path19.dirname(gitWorktreePath));
-  return path19.dirname(gitDir);
+  const gitWorktreePath = path20.resolve(wt, m[1].trim());
+  const gitDir = path20.dirname(path20.dirname(gitWorktreePath));
+  return path20.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -30179,7 +30248,7 @@ var SessionWorktreeManager = class {
     }
     if (!opts.isNewSession) {
       const agentCwd = this.sessionAgentCwd.get(sessionId);
-      if (agentCwd) return path20.resolve(agentCwd);
+      if (agentCwd) return path21.resolve(agentCwd);
       return void 0;
     }
     const prep = await prepareNewSessionWorktrees({
@@ -30192,7 +30261,7 @@ var SessionWorktreeManager = class {
     if (!prep) return void 0;
     this.sessionPaths.set(sessionId, prep.worktreePaths);
     this.sessionAgentCwd.set(sessionId, prep.agentCwd);
-    return path20.resolve(prep.agentCwd);
+    return path21.resolve(prep.agentCwd);
   }
   async renameSessionBranch(sessionId, newBranch) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30213,7 +30282,7 @@ var SessionWorktreeManager = class {
   getAgentCwdForSession(sessionId) {
     if (!sessionId) return null;
     const c = this.sessionAgentCwd.get(sessionId);
-    return c ? path20.resolve(c) : null;
+    return c ? path21.resolve(c) : null;
   }
   async removeSessionWorktrees(sessionId) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30234,7 +30303,7 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootAbs() {
-  return path20.join(os4.homedir(), ".buildautomaton", "worktrees");
+  return path21.join(os4.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/auth/refresh-bridge-tokens.ts
@@ -30265,7 +30334,7 @@ async function refreshBridgeTokens(params) {
 }
 
 // src/files/watch-file-index.ts
-import path21 from "node:path";
+import path22 from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -30343,7 +30412,7 @@ var ReaddirpStream = class extends Readable2 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path22) => statMethod(path22, { bigint: true });
+      this._stat = (path23) => statMethod(path23, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -30368,8 +30437,8 @@ var ReaddirpStream = class extends Readable2 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path22, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+          const { path: path23, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -30409,20 +30478,20 @@ var ReaddirpStream = class extends Readable2 {
       this.reading = false;
     }
   }
-  async _exploreDir(path22, depth) {
+  async _exploreDir(path23, depth) {
     let files;
     try {
-      files = await readdir(path22, this._rdOptions);
+      files = await readdir(path23, this._rdOptions);
     } catch (error40) {
       this._onError(error40);
     }
-    return { files, depth, path: path22 };
+    return { files, depth, path: path23 };
   }
-  async _formatEntry(dirent, path22) {
+  async _formatEntry(dirent, path23) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path22, basename6));
+      const fullPath = presolve(pjoin(path23, basename6));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -30822,16 +30891,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path22, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path22, evPath), KEY_LISTENERS, sysPath.join(path22, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, evPath));
     }
   };
   try {
-    return fs_watch(path22, {
+    return fs_watch(path23, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error40) {
@@ -30847,12 +30916,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path22, fullPath, options, handlers) => {
+var setFsWatchListener = (path23, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path22, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -30863,7 +30932,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path22,
+      path23,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -30878,7 +30947,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error40.code === "EPERM") {
         try {
-          const fd = await open(path22, "r");
+          const fd = await open(path23, "r");
           await fd.close();
           broadcastErr(error40);
         } catch (err) {
@@ -30909,7 +30978,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -30931,7 +31000,7 @@ var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path23, curr));
         }
       })
     };
@@ -30959,13 +31028,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path23, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path22);
-    const basename6 = sysPath.basename(path22);
+    const directory = sysPath.dirname(path23);
+    const basename6 = sysPath.basename(path23);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sysPath.resolve(path22);
+    const absolutePath = sysPath.resolve(path23);
     const options = {
       persistent: opts.persistent
     };
@@ -30975,12 +31044,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options, {
+      closer = setFsWatchFileListener(path23, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options, {
+      closer = setFsWatchListener(path23, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -31002,7 +31071,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path23, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -31016,11 +31085,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path23);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path23, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -31052,7 +31121,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path22, item) {
+  async _handleSymlink(entry, directory, path23, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -31062,7 +31131,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path22);
+        linkPath = await fsrealpath(path23);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -31072,12 +31141,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path23, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path23, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -31106,9 +31175,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path22 = sysPath.join(directory, item);
+      let path23 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -31117,8 +31186,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sysPath.join(dir, sysPath.relative(dir, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path23 = sysPath.join(dir, sysPath.relative(dir, path23));
+        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve16, reject) => {
@@ -31187,13 +31256,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path23);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -31209,8 +31278,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path22);
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const absPath = sysPath.resolve(path23);
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -31220,29 +31289,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path23), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path23, closer);
       return false;
     } catch (error40) {
       if (this.fsw._handleError(error40)) {
         ready();
-        return path22;
+        return path23;
       }
     }
   }
@@ -31285,26 +31354,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path22 = sysPath2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path23 = sysPath2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path22.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path22.match(DOUBLE_SLASH_RE2))
-    path22 = path22.replace(DOUBLE_SLASH_RE2, "/");
+  while (path23.match(DOUBLE_SLASH_RE2))
+    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path22 = "/" + path22;
-  return path22;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path22, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -31344,19 +31413,19 @@ var toUnix = (string4) => {
   }
   return str;
 };
-var normalizePathToUnix = (path22) => toUnix(sysPath2.normalize(toUnix(path22)));
-var normalizeIgnored = (cwd3 = "") => (path22) => {
-  if (typeof path22 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path22) ? path22 : sysPath2.join(cwd3, path22));
+var normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
+var normalizeIgnored = (cwd3 = "") => (path23) => {
+  if (typeof path23 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd3, path23));
   } else {
-    return path22;
+    return path23;
   }
 };
-var getAbsolutePath = (path22, cwd3) => {
-  if (sysPath2.isAbsolute(path22)) {
-    return path22;
+var getAbsolutePath = (path23, cwd3) => {
+  if (sysPath2.isAbsolute(path23)) {
+    return path23;
   }
-  return sysPath2.join(cwd3, path22);
+  return sysPath2.join(cwd3, path23);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -31411,10 +31480,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path22, follow, fsw) {
+  constructor(path23, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path23;
+    this.path = path23 = path23.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -31536,20 +31605,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd3) {
-      paths = paths.map((path22) => {
-        const absPath = getAbsolutePath(path22, cwd3);
+      paths = paths.map((path23) => {
+        const absPath = getAbsolutePath(path23, cwd3);
         return absPath;
       });
     }
-    paths.forEach((path22) => {
-      this._removeIgnoredPath(path22);
+    paths.forEach((path23) => {
+      this._removeIgnoredPath(path23);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path22) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path23) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -31571,17 +31640,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd: cwd3 } = this.options;
-    paths.forEach((path22) => {
-      if (!sysPath2.isAbsolute(path22) && !this._closers.has(path22)) {
+    paths.forEach((path23) => {
+      if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
         if (cwd3)
-          path22 = sysPath2.join(cwd3, path22);
-        path22 = sysPath2.resolve(path22);
+          path23 = sysPath2.join(cwd3, path23);
+        path23 = sysPath2.resolve(path23);
       }
-      this._closePath(path22);
-      this._addIgnoredPath(path22);
-      if (this._watched.has(path22)) {
+      this._closePath(path23);
+      this._addIgnoredPath(path23);
+      if (this._watched.has(path23)) {
         this._addIgnoredPath({
-          path: path22,
+          path: path23,
           recursive: true
         });
       }
@@ -31645,38 +31714,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path22, stats) {
+  async _emit(event, path23, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path22 = sysPath2.normalize(path22);
+      path23 = sysPath2.normalize(path23);
     if (opts.cwd)
-      path22 = sysPath2.relative(opts.cwd, path22);
-    const args = [path22];
+      path23 = sysPath2.relative(opts.cwd, path23);
+    const args = [path23];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path22))) {
+    if (awf && (pw = this._pendingWrites.get(path23))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path22, [event, ...args]);
+        this._pendingUnlinks.set(path23, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path23) => {
+          this._pendingUnlinks.forEach((entry, path24) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path22);
+        this._pendingUnlinks.delete(path23);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -31694,16 +31763,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path22) : path22;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path23) : path23;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -31734,23 +31803,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path22, timeout) {
+  _throttle(actionType, path23, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path22);
+    const actionPath = action.get(path23);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path22);
+      const item = action.get(path23);
       const count = item ? item.count : 0;
-      action.delete(path22);
+      action.delete(path23);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -31758,7 +31827,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path22, thr);
+    action.set(path23, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -31772,44 +31841,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path22, threshold, event, awfEmit) {
+  _awaitWriteFinish(path23, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path22;
-    if (this.options.cwd && !sysPath2.isAbsolute(path22)) {
-      fullPath = sysPath2.join(this.options.cwd, path22);
+    let fullPath = path23;
+    if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
+      fullPath = sysPath2.join(this.options.cwd, path23);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path22)) {
+        if (err || !writes.has(path23)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path22).lastChange = now2;
+          writes.get(path23).lastChange = now2;
         }
-        const pw = writes.get(path22);
+        const pw = writes.get(path23);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path22);
+          writes.delete(path23);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path22)) {
-      writes.set(path22, {
+    if (!writes.has(path23)) {
+      writes.set(path23, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path22);
+          writes.delete(path23);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -31820,8 +31889,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path22, stats) {
-    if (this.options.atomic && DOT_RE.test(path22))
+  _isIgnored(path23, stats) {
+    if (this.options.atomic && DOT_RE.test(path23))
       return true;
     if (!this._userIgnored) {
       const { cwd: cwd3 } = this.options;
@@ -31831,17 +31900,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd3)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path22, stats);
+    return this._userIgnored(path23, stats);
   }
-  _isntIgnored(path22, stat4) {
-    return !this._isIgnored(path22, stat4);
+  _isntIgnored(path23, stat4) {
+    return !this._isIgnored(path23, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path22) {
-    return new WatchHelper(path22, this.options.followSymlinks, this);
+  _getWatchHelpers(path23) {
+    return new WatchHelper(path23, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -31873,63 +31942,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path22 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path22);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path22, 100))
+    const path23 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path23);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path23, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path22);
+    const wp = this._getWatchedDir(path23);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path22;
+    let relPath = path23;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path22);
+      relPath = sysPath2.relative(this.options.cwd, path23);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path22);
+    this._watched.delete(path23);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path22))
-      this._emit(eventName, path22);
-    this._closePath(path22);
+    if (wasTracked && !this._isIgnored(path23))
+      this._emit(eventName, path23);
+    this._closePath(path23);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path22) {
-    this._closeFile(path22);
-    const dir = sysPath2.dirname(path22);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path22));
+  _closePath(path23) {
+    this._closeFile(path23);
+    const dir = sysPath2.dirname(path23);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path23));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path22) {
-    const closers = this._closers.get(path22);
+  _closeFile(path23) {
+    const closers = this._closers.get(path23);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path22);
+    this._closers.delete(path23);
   }
-  _addPathCloser(path22, closer) {
+  _addPathCloser(path23, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path22);
+    let list = this._closers.get(path23);
     if (!list) {
       list = [];
-      this._closers.set(path22, list);
+      this._closers.set(path23, list);
     }
     list.push(closer);
   }
@@ -31968,7 +32037,7 @@ function shouldIgnoreRelative(rel) {
   return false;
 }
 function startFileIndexWatcher(cwd3 = process.cwd()) {
-  const resolved = path21.resolve(cwd3);
+  const resolved = path22.resolve(cwd3);
   let timer = null;
   const runRebuild = () => {
     try {
@@ -31989,7 +32058,7 @@ function startFileIndexWatcher(cwd3 = process.cwd()) {
     ignoreInitial: true,
     persistent: true,
     ignored: (p) => {
-      const rel = path21.isAbsolute(p) ? path21.relative(resolved, p).replace(/\\/g, "/") : p.replace(/\\/g, "/");
+      const rel = path22.isAbsolute(p) ? path22.relative(resolved, p).replace(/\\/g, "/") : p.replace(/\\/g, "/");
       return shouldIgnoreRelative(rel || ".");
     },
     awaitWriteFinish: { stabilityThreshold: 250, pollInterval: 100 }