@buildautomaton/cli 0.1.13 → 0.1.14

package/dist/index.js

@@ -4065,8 +4065,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path29, errorMaps, issueData } = params;
-      const fullPath = [...path29, ...issueData.path || []];
+      const { data, path: path31, errorMaps, issueData } = params;
+      const fullPath = [...path31, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4374,11 +4374,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path29, key) {
+      constructor(parent, value, path31, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path29;
+        this._path = path31;
         this._key = key;
       }
       get path() {
@@ -7993,15 +7993,15 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path29) {
-  if (!path29)
+function getElementAtPath(obj, path31) {
+  if (!path31)
     return obj;
-  return path29.reduce((acc, key) => acc?.[key], obj);
+  return path31.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises3 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises3).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -8245,11 +8245,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path29, issues) {
+function prefixIssues(path31, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path29);
+    iss.path.unshift(path31);
     return iss;
   });
 }
@@ -8438,7 +8438,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path29 = []) => {
+  const processError = (error41, path31 = []) => {
     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 = [...path29, ...issue2.path];
+        const fullpath = [...path31, ...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(path29) {
+function toDotPath(path31) {
   const segs = [];
-  for (const seg of path29) {
+  for (const seg of path31) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -20943,8 +20943,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve14) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve14());
+        this.#closedPromise = new Promise((resolve15) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve15());
         });
         this.#receive();
       }
@@ -21093,8 +21093,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve14, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve14, reject });
+        const responsePromise = new Promise((resolve15, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve15, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -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(path29, isFile, isDirectory) {
-      log2(`checking %s`, path29);
+    function check2(path31, isFile, isDirectory) {
+      log2(`checking %s`, path31);
       try {
-        const stat2 = fs_1.statSync(path29);
+        const stat2 = fs_1.statSync(path31);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -21986,8 +21986,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path29, type = exports.READABLE) {
-      return check2(path29, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path31, type = exports.READABLE) {
+      return check2(path31, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22413,7 +22413,7 @@ async function createSdkStdioAcpClient(options) {
   child.once("close", (code, signal) => {
     onAgentSubprocessExit?.({ code, signal });
   });
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let initSettled = false;
     const settleReject = (err) => {
       if (initSettled) return;
@@ -22427,7 +22427,7 @@ async function createSdkStdioAcpClient(options) {
     const settleResolve = (handle) => {
       if (initSettled) return;
       initSettled = true;
-      resolve14(handle);
+      resolve15(handle);
     };
     child.on("error", (err) => {
       settleReject(new Error(formatSpawnError(err, command[0])));
@@ -22463,8 +22463,8 @@ async function createSdkStdioAcpClient(options) {
               });
             } catch {
             }
-            return await new Promise((resolve15) => {
-              pendingPermissionResolvers.set(requestId, resolve15);
+            return await new Promise((resolve16) => {
+              pendingPermissionResolvers.set(requestId, resolve16);
             });
           },
           async readTextFile(params) {
@@ -22572,9 +22572,9 @@ async function createSdkStdioAcpClient(options) {
             }
           },
           async cancel() {
-            for (const [id, resolve15] of [...pendingPermissionResolvers.entries()]) {
+            for (const [id, resolve16] of [...pendingPermissionResolvers.entries()]) {
               pendingPermissionResolvers.delete(id);
-              resolve15({ outcome: { outcome: "cancelled" } });
+              resolve16({ outcome: { outcome: "cancelled" } });
             }
             try {
               await connection.cancel({ sessionId });
@@ -22590,10 +22590,10 @@ async function createSdkStdioAcpClient(options) {
             }
           },
           resolveRequest(requestId, result) {
-            const resolve15 = pendingPermissionResolvers.get(requestId);
-            if (!resolve15) return;
+            const resolve16 = pendingPermissionResolvers.get(requestId);
+            if (!resolve16) return;
             pendingPermissionResolvers.delete(requestId);
-            resolve15(result);
+            resolve16(result);
           },
           disconnect() {
             child.kill();
@@ -22700,7 +22700,7 @@ async function proxyToLocal(request) {
   };
   const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const once = await new Promise((resolve14) => {
+    const once = await new Promise((resolve15) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -22711,7 +22711,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve14({
+          resolve15({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -22720,7 +22720,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve14({
+        resolve15({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -22802,8 +22802,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path29, body) {
-  const url2 = `http://127.0.0.1:${port}${path29}`;
+async function requestPreviewApi(port, secret, method, path31, body) {
+  const url2 = `http://127.0.0.1:${port}${path31}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -22815,7 +22815,7 @@ async function requestPreviewApi(port, secret, method, path29, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path29}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path31}: ${res.status}`);
   }
   return data;
 }
@@ -23027,6 +23027,19 @@ function clearConfigForApi(apiUrl) {
   }
 }
 
+// src/process-bridge-resilience.ts
+var installed = false;
+function installBridgeProcessResilience() {
+  if (installed) return;
+  installed = true;
+  process.on("uncaughtException", (err) => {
+    logImmediate(`[bridge] uncaughtException \u2014 continuing: ${err.stack ?? String(err)}`);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logImmediate(`[bridge] unhandledRejection \u2014 continuing: ${reason instanceof Error ? reason.stack : String(reason)}`);
+  });
+}
+
 // src/auth/open-browser.ts
 import { execSync } from "node:child_process";
 function isLocalApiUrl(apiUrl) {
@@ -23246,8 +23259,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve14) => {
-    resolveAuth = resolve14;
+  const authPromise = new Promise((resolve15) => {
+    resolveAuth = resolve15;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -23369,7 +23382,7 @@ function runPendingAuth(options) {
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
-  await new Promise((resolve14) => setImmediate(resolve14));
+  await new Promise((resolve15) => setImmediate(resolve15));
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
@@ -23464,8 +23477,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path29) {
-  return path29 instanceof String && cache.has(path29);
+function isPathSpec(path31) {
+  return path31 instanceof String && cache.has(path31);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -23554,8 +23567,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path29) {
-  return (0, import_file_exists.exists)(path29, import_file_exists.FOLDER);
+function folderExists(path31) {
+  return (0, import_file_exists.exists)(path31, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -23959,8 +23972,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path29) {
-      return /^\.(git)?$/.test(path29.trim());
+    parser(path31) {
+      return /^\.(git)?$/.test(path31.trim());
     }
   };
 }
@@ -24394,11 +24407,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path29, line, preview] = input.split(NULL);
-    paths.add(path29);
-    (results[path29] = results[path29] || []).push({
+    const [path31, line, preview] = input.split(NULL);
+    paths.add(path31);
+    (results[path31] = results[path31] || []).push({
       line: asNumber(line),
-      path: path29,
+      path: path31,
       preview
     });
   });
@@ -25163,14 +25176,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path29, text) {
+function parseInit(bare, path31, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path29, false, result[1]);
+    return new InitSummary(bare, path31, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path29, true, result[1]);
+    return new InitSummary(bare, path31, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -25181,7 +25194,7 @@ function parseInit(bare, path29, text) {
       break;
     }
   }
-  return new InitSummary(bare, path29, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path31, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -25190,9 +25203,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path29, existing, gitDir) {
+      constructor(bare, path31, existing, gitDir) {
         this.bare = bare;
-        this.path = path29;
+        this.path = path31;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -25204,7 +25217,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path29, customArgs) {
+function initTask(bare = false, path31, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -25213,7 +25226,7 @@ function initTask(bare = false, path29, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path29, text);
+      return parseInit(commands.includes("--bare"), path31, text);
     }
   };
 }
@@ -26029,12 +26042,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path29, index, working_dir) {
-        this.path = path29;
+      constructor(path31, index, working_dir) {
+        this.path = path31;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path29) || [null, path29, path29];
+          const detail = fromPathRegex.exec(path31) || [null, path31, path31];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -26065,14 +26078,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path29) {
+  function data(index, workingDir, path31) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path29);
+      handler(result, path31);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path29, index, workingDir));
+      result.files.push(new FileStatusSummary(path31, index, workingDir));
     }
   }
 }
@@ -26243,14 +26256,14 @@ var init_status = __esm2({
     ignoredOptions = ["--null", "-z"];
   }
 });
-function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed = true) {
+function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed2 = true) {
   return Object.defineProperty(
     {
       major,
       minor,
       patch,
       agent,
-      installed
+      installed: installed2
     },
     "toString",
     {
@@ -26381,9 +26394,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path29, write) {
+      hashObject(path31, write) {
         return this._runTask(
-          hashObjectTask(path29, write === true),
+          hashObjectTask(path31, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -26736,8 +26749,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path29 = input.trim().replace(/^["']|["']$/g, "");
-  return path29 && normalize2(path29);
+  const path31 = input.trim().replace(/^["']|["']$/g, "");
+  return path31 && normalize2(path31);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -27051,8 +27064,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path29) {
-  return subModuleTask(["add", repo, path29]);
+function addSubModuleTask(repo, path31) {
+  return subModuleTask(["add", repo, path31]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -27385,8 +27398,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path29, then) {
-      return this._runTask(addSubModuleTask2(repo, path29), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path31, then) {
+      return this._runTask(addSubModuleTask2(repo, path31), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -28475,7 +28488,7 @@ async function createCursorAcpClient(options) {
   });
   const stderrCapture = createStderrCapture(child);
   child.stderr?.on("data", (chunk) => stderrCapture.append(chunk));
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     child.on("error", (err) => {
       child.kill();
       reject(new Error(formatSpawnError2(err, command[0])));
@@ -28662,7 +28675,7 @@ async function createCursorAcpClient(options) {
         const newResult = await send("session/new", { cwd, mcpServers: [] });
         const sessionId = newResult?.sessionId ?? "";
         if (!sessionId) throw new Error("Cursor ACP session/new did not return sessionId");
-        resolve14({
+        resolve15({
           sessionId,
           async sendPrompt(prompt, _options) {
             promptOutputBuffer = "";
@@ -29720,7 +29733,7 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 import os3 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
@@ -29887,7 +29900,7 @@ async function removeSessionWorktrees(paths, log2) {
   }
 }
 
-// src/git/working-tree-status.ts
+// src/git/working-directory/status/working-tree-status.ts
 async function tryConfigGet(g, key) {
   try {
     const out = await g.raw(["config", "--get", key]);
@@ -29897,11 +29910,24 @@ async function tryConfigGet(g, key) {
     return null;
   }
 }
+async function revParseSafe(g, ref) {
+  try {
+    const v = (await g.raw(["rev-parse", ref])).trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
 async function resolveRemoteTrackingRefForAhead(g) {
   try {
-    await g.raw(["rev-parse", "--verify", "@{u}"]);
-    return "@{u}";
+    await g.raw(["rev-parse", "--verify", "HEAD@{upstream}"]);
+    return "HEAD@{upstream}";
   } catch {
+    try {
+      await g.raw(["rev-parse", "--verify", "@{u}"]);
+      return "@{u}";
+    } catch {
+    }
   }
   const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
   if (!branch || branch === "HEAD") return null;
@@ -29924,16 +29950,76 @@ async function resolveRemoteTrackingRefForAhead(g) {
     return null;
   }
 }
+async function remoteForCurrentBranch(g) {
+  const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  if (!branch || branch === "HEAD") return "origin";
+  return await tryConfigGet(g, `branch.${branch}.remote`) ?? "origin";
+}
+async function resolveDefaultRemoteBranchRef(g, remote) {
+  const headSym = `refs/remotes/${remote}/HEAD`;
+  try {
+    const resolved = (await g.raw(["symbolic-ref", "-q", "--verify", headSym])).trim();
+    if (resolved.startsWith("refs/remotes/")) return resolved;
+  } catch {
+  }
+  for (const name of ["main", "master", "trunk", "develop"]) {
+    const r = `refs/remotes/${remote}/${name}`;
+    try {
+      await g.raw(["rev-parse", "--verify", r]);
+      return r;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveBaseShaForUnpushedCommits(g) {
+  const trackingRef = await resolveRemoteTrackingRefForAhead(g);
+  if (trackingRef) {
+    const sha = await revParseSafe(g, trackingRef);
+    if (sha) return sha;
+  }
+  const remote = await remoteForCurrentBranch(g);
+  const defaultRef = await resolveDefaultRemoteBranchRef(g, remote);
+  if (!defaultRef) return null;
+  return revParseSafe(g, defaultRef);
+}
+function parseLogShaDateSubjectLines(raw) {
+  const out = [];
+  for (const line of String(raw).split("\n")) {
+    const l = line.trimEnd();
+    if (!l.trim()) continue;
+    const parts = l.split("	");
+    if (parts.length < 3) continue;
+    const sha = parts[0].trim();
+    const committedAt = parts[1].trim();
+    const subject = parts.slice(2).join("	").trim();
+    if (!/^[0-9a-f]{7,40}$/i.test(sha)) continue;
+    out.push({ sha, shortSha: sha.slice(0, 7), subject, committedAt });
+  }
+  return out;
+}
+async function gitLogNotReachableFromBase(g, baseSha, headSha) {
+  if (baseSha === headSha) return [];
+  try {
+    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `${baseSha}..${headSha}`]);
+    return parseLogShaDateSubjectLines(logOut);
+  } catch {
+    return [];
+  }
+}
 async function commitsAheadOfRemoteTracking(repoDir) {
   const g = simpleGit(repoDir);
-  const trackingRef = await resolveRemoteTrackingRefForAhead(g);
-  if (!trackingRef) return 0;
-  const localSha = (await g.raw(["rev-parse", "HEAD"])).trim();
-  const remoteSha = (await g.raw(["rev-parse", trackingRef])).trim();
-  if (localSha === remoteSha) return 0;
-  const out = await g.raw(["rev-list", "--count", `${trackingRef}..HEAD`]);
-  const n = parseInt(String(out).trim(), 10);
-  return Number.isNaN(n) ? 0 : n;
+  const headSha = await revParseSafe(g, "HEAD");
+  if (!headSha) return 0;
+  const baseSha = await resolveBaseShaForUnpushedCommits(g);
+  if (!baseSha || baseSha === headSha) return 0;
+  try {
+    const out = await g.raw(["rev-list", "--count", `${baseSha}..${headSha}`]);
+    const n = parseInt(String(out).trim(), 10);
+    return Number.isNaN(n) ? 0 : n;
+  } catch {
+    return 0;
+  }
 }
 async function getRepoWorkingTreeStatus(repoDir) {
   const g = simpleGit(repoDir);
@@ -29942,6 +30028,14 @@ async function getRepoWorkingTreeStatus(repoDir) {
   const ahead = await commitsAheadOfRemoteTracking(repoDir);
   return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0 };
 }
+async function listUnpushedCommits(repoDir) {
+  const g = simpleGit(repoDir);
+  const headSha = await revParseSafe(g, "HEAD");
+  if (!headSha) return [];
+  const baseSha = await resolveBaseShaForUnpushedCommits(g);
+  if (!baseSha) return [];
+  return gitLogNotReachableFromBase(g, baseSha, headSha);
+}
 async function aggregateSessionPathsWorkingTreeStatus(paths) {
   let hasUncommittedChanges = false;
   let hasUnpushedCommits = false;
@@ -29961,6 +30055,477 @@ async function pushAheadOfUpstreamForPaths(paths) {
   }
 }
 
+// src/git/working-directory/changes/types.ts
+var MAX_PATCH_CHARS = 35e4;
+
+// src/git/working-directory/changes/repo-format.ts
+function posixJoinDirFile(dir, file2) {
+  const d = dir === "." || dir === "" ? "" : dir.replace(/\\/g, "/").replace(/\/+$/, "");
+  const f = file2.replace(/\\/g, "/").replace(/^\/+/, "");
+  return d ? `${d}/${f}` : f;
+}
+function formatRepoShortTitle(remoteUrl, repoRelPath) {
+  const u = remoteUrl.trim();
+  if (u) {
+    try {
+      if (u.startsWith("git@")) {
+        const colon = u.indexOf(":");
+        if (colon > 0) {
+          const pathPart = u.slice(colon + 1).replace(/\.git$/i, "").replace(/\/+$/, "");
+          if (pathPart.includes("/")) return pathPart;
+        }
+      } else {
+        const parsed = new URL(u);
+        const p = parsed.pathname.replace(/^\//, "").replace(/\.git$/i, "");
+        const parts = p.split("/").filter(Boolean);
+        if (parts.length >= 2) {
+          return `${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+        }
+        if (parts.length === 1) return parts[0];
+      }
+    } catch {
+    }
+  }
+  if (repoRelPath && repoRelPath !== ".") {
+    const segments = repoRelPath.split("/").filter(Boolean);
+    const last2 = segments[segments.length - 1];
+    if (last2) return last2;
+  }
+  return "Repository";
+}
+function formatRemoteDisplayLabel(remoteUrl) {
+  const u = remoteUrl.trim();
+  if (!u) return "";
+  let hostPath = u;
+  try {
+    if (u.startsWith("git@")) {
+      const rest = u.slice("git@".length);
+      const slash = rest.indexOf(":");
+      if (slash > 0) hostPath = `${rest.slice(0, slash)}/${rest.slice(slash + 1)}`;
+    } else {
+      const parsed = new URL(u);
+      hostPath = `${parsed.hostname}${parsed.pathname}`.replace(/\/\.git$/i, "").replace(/\.git$/i, "");
+    }
+  } catch {
+    hostPath = u.replace(/^https?:\/\//i, "").replace(/\.git$/i, "");
+  }
+  return `origin \xB7 ${hostPath}`;
+}
+
+// src/git/working-directory/changes/get-working-tree-change-repo-details.ts
+import * as path14 from "node:path";
+
+// src/git/working-directory/changes/parse-git-status.ts
+function parseNameStatusLines(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const tabParts = line.split("	");
+    if (tabParts.length < 2) continue;
+    const status = tabParts[0].trim();
+    const code = status[0];
+    if (code === "A") {
+      m.set(tabParts[tabParts.length - 1], "added");
+    } else if (code === "D") {
+      m.set(tabParts[tabParts.length - 1], "removed");
+    } else if (code === "R" || code === "C") {
+      if (tabParts.length >= 3) m.set(tabParts[tabParts.length - 1], "modified");
+    } else if (code === "M" || code === "U" || code === "T") {
+      m.set(tabParts[tabParts.length - 1], "modified");
+    }
+  }
+  return m;
+}
+function parseNumstatFirstLine(line) {
+  const parts = line.split("	");
+  if (parts.length < 3) return null;
+  const [a, d] = parts;
+  const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
+  const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
+  return { additions, deletions };
+}
+function parseNumstat(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const [a, d, p] = parts;
+    const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
+    const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
+    m.set(p, { additions, deletions });
+  }
+  return m;
+}
+async function numstatFromGitNoIndex(g, pathInRepo) {
+  const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+  try {
+    const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
+    const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
+    return parseNumstatFirstLine(first2);
+  } catch {
+    return null;
+  }
+}
+
+// src/git/working-directory/changes/patch-truncate.ts
+function truncatePatch(s) {
+  if (s.length <= MAX_PATCH_CHARS) return s;
+  return `${s.slice(0, MAX_PATCH_CHARS)}
+
+\u2026 (diff truncated)`;
+}
+
+// src/git/working-directory/changes/list-changed-files-for-commit.ts
+var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+async function parentForCommitDiff(g, sha) {
+  try {
+    return (await g.raw(["rev-parse", `${sha}^1`])).trim();
+  } catch {
+    try {
+      return (await g.raw(["rev-parse", `${sha}^`])).trim();
+    } catch {
+      return EMPTY_TREE;
+    }
+  }
+}
+async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
+  const g = simpleGit(repoGitCwd);
+  const parent = await parentForCommitDiff(g, commitSha);
+  const range = `${parent}..${commitSha}`;
+  const [nameStatusRaw, numstatRaw] = await Promise.all([
+    g.raw(["diff", "--name-status", range]).catch(() => ""),
+    g.raw(["diff", "--numstat", range]).catch(() => "")
+  ]);
+  const kindByPath = parseNameStatusLines(String(nameStatusRaw).split("\n"));
+  const numByPath = parseNumstat(String(numstatRaw).split("\n"));
+  const paths = new Set([...kindByPath.keys(), ...numByPath.keys()].filter(Boolean));
+  const rows = [];
+  const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
+  for (const pathInRepo of paths) {
+    const relLauncher = posixJoinDirFile(normRel, pathInRepo.replace(/\\/g, "/"));
+    const nums = numByPath.get(pathInRepo);
+    let additions = nums?.additions ?? 0;
+    let deletions = nums?.deletions ?? 0;
+    let change = kindByPath.get(pathInRepo) ?? "modified";
+    if (!kindByPath.has(pathInRepo) && nums) {
+      if (additions > 0 && deletions === 0) change = "added";
+      else if (deletions > 0 && additions === 0) change = "removed";
+      else change = "modified";
+    }
+    rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
+  }
+  for (const row of rows) {
+    let pathInRepo;
+    if (normRel === ".") {
+      pathInRepo = row.pathRelLauncher;
+    } else if (row.pathRelLauncher.startsWith(`${normRel}/`)) {
+      pathInRepo = row.pathRelLauncher.slice(normRel.length + 1);
+    } else {
+      pathInRepo = row.pathRelLauncher;
+    }
+    const raw = await g.raw(["diff", "-U20000", range, "--", pathInRepo]).catch(() => "");
+    const t = String(raw).trim();
+    row.patchContent = t ? truncatePatch(t) : void 0;
+  }
+  rows.sort((a, b) => a.pathRelLauncher.localeCompare(b.pathRelLauncher));
+  return rows;
+}
+
+// src/git/working-directory/changes/list-changed-files-for-repo.ts
+import * as fs11 from "node:fs";
+import * as path13 from "node:path";
+
+// src/git/working-directory/changes/count-lines.ts
+import { createReadStream } from "node:fs";
+import * as readline2 from "node:readline";
+async function countTextFileLines(absFile) {
+  let bytes = 0;
+  const maxBytes = 512e3;
+  let lines = 0;
+  const stream = createReadStream(absFile, { encoding: "utf8" });
+  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const _line of rl) {
+    lines += 1;
+    bytes += Buffer.byteLength(String(_line), "utf8") + 1;
+    if (bytes > maxBytes) {
+      rl.close();
+      stream.destroy();
+      return lines;
+    }
+  }
+  return lines;
+}
+
+// src/git/working-directory/changes/hydrate-patch.ts
+import * as fs10 from "node:fs";
+var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var MAX_HYDRATE_LINES_PER_GAP = 8e3;
+var MAX_HYDRATE_LINES_PER_FILE = 8e4;
+async function readGitBlobLines(repoCwd, pathInRepo) {
+  try {
+    const rel = pathInRepo.replace(/\\/g, "/");
+    const raw = await simpleGit(repoCwd).show([`HEAD:${rel}`]);
+    return String(raw).split(/\r?\n/);
+  } catch {
+    return null;
+  }
+}
+async function readWorktreeFileLines(abs) {
+  try {
+    const raw = await fs10.promises.readFile(abs, "utf8");
+    return raw.split(/\r?\n/);
+  } catch {
+    return null;
+  }
+}
+async function hydrateUnifiedPatchWithFileContext(patch, absFile, repoGitCwd, pathInRepo, change) {
+  if (!patch.trim() || patch.includes("Binary files")) return patch;
+  const all = patch.split("\n");
+  const out = [];
+  let prevOldEnd = 0;
+  let prevNewEnd = 0;
+  let injectedTotal = 0;
+  let i = 0;
+  let blobCache;
+  let diskCache;
+  const blobLines = async () => {
+    if (blobCache !== void 0) return blobCache;
+    blobCache = await readGitBlobLines(repoGitCwd, pathInRepo);
+    return blobCache;
+  };
+  const diskLines = async () => {
+    if (diskCache !== void 0) return diskCache;
+    diskCache = await readWorktreeFileLines(absFile);
+    return diskCache;
+  };
+  while (i < all.length) {
+    const line = all[i];
+    const hm = line.match(UNIFIED_HUNK_HEADER_RE);
+    if (!hm) {
+      out.push(line);
+      i++;
+      continue;
+    }
+    const oldStart = parseInt(hm[1], 10) || 0;
+    const newStart = parseInt(hm[3], 10) || 0;
+    const gapOldStart = prevOldEnd + 1;
+    const gapOldEnd = oldStart - 1;
+    const gapNewStart = prevNewEnd + 1;
+    const gapNewEnd = newStart - 1;
+    if (injectedTotal < MAX_HYDRATE_LINES_PER_FILE) {
+      let inject = null;
+      if (gapNewEnd >= gapNewStart && change !== "removed") {
+        const nNew = gapNewEnd - gapNewStart + 1;
+        if (gapOldEnd < gapOldStart || gapOldEnd - gapOldStart + 1 === nNew) {
+          const cap = Math.min(nNew, MAX_HYDRATE_LINES_PER_GAP, MAX_HYDRATE_LINES_PER_FILE - injectedTotal);
+          const dl = await diskLines();
+          if (dl && cap > 0) {
+            inject = dl.slice(gapNewStart - 1, gapNewStart - 1 + cap);
+          }
+        }
+      } else if (gapOldEnd >= gapOldStart && change === "removed") {
+        const nOld = gapOldEnd - gapOldStart + 1;
+        const cap = Math.min(nOld, MAX_HYDRATE_LINES_PER_GAP, MAX_HYDRATE_LINES_PER_FILE - injectedTotal);
+        const bl = await blobLines();
+        if (bl && cap > 0) {
+          inject = bl.slice(gapOldStart - 1, gapOldStart - 1 + cap);
+        }
+      }
+      if (inject && inject.length > 0) {
+        for (const t of inject) {
+          out.push(` ${t}`);
+          injectedTotal++;
+        }
+      }
+    }
+    out.push(line);
+    i++;
+    let oldConsumed = 0;
+    let newConsumed = 0;
+    while (i < all.length) {
+      const bl = all[i];
+      if (UNIFIED_HUNK_HEADER_RE.test(bl)) break;
+      out.push(bl);
+      i++;
+      if (bl.startsWith("\\")) continue;
+      const ch = bl[0];
+      if (ch === " ") {
+        oldConsumed++;
+        newConsumed++;
+      } else if (ch === "-") {
+        oldConsumed++;
+      } else if (ch === "+") {
+        newConsumed++;
+      }
+    }
+    if (oldStart > 0) {
+      prevOldEnd = oldStart + oldConsumed - 1;
+    } else {
+      prevOldEnd = 0;
+    }
+    if (newStart > 0) {
+      prevNewEnd = newStart + newConsumed - 1;
+    } else {
+      prevNewEnd = 0;
+    }
+  }
+  return truncatePatch(out.join("\n"));
+}
+
+// src/git/working-directory/changes/unified-diff-for-file.ts
+async function unifiedDiffForFile(repoCwd, pathInRepo, change) {
+  const g = simpleGit(repoCwd);
+  try {
+    let raw;
+    if (change === "added") {
+      const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+      raw = await g.raw(["diff", "--no-index", "--", devNull, pathInRepo]);
+    } else {
+      raw = await g.raw(["diff", "HEAD", "--", pathInRepo]);
+    }
+    const t = String(raw).trim();
+    if (!t) return void 0;
+    return truncatePatch(t);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/git/working-directory/changes/list-changed-files-for-repo.ts
+async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
+  const g = simpleGit(repoGitCwd);
+  const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+    g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
+    g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
+    g.raw(["ls-files", "--others", "--exclude-standard"]).catch(() => "")
+  ]);
+  const kindByPath = parseNameStatusLines(String(nameStatusRaw).split("\n"));
+  const numByPath = parseNumstat(String(numstatRaw).split("\n"));
+  const paths = /* @__PURE__ */ new Set([...kindByPath.keys(), ...numByPath.keys()]);
+  const untracked = String(untrackedRaw).split("\n").map((s) => s.trim()).filter(Boolean);
+  for (const p of untracked) paths.add(p);
+  const rows = [];
+  for (const pathInRepo of paths) {
+    const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
+    const abs = path13.join(repoGitCwd, pathInRepo);
+    const nums = numByPath.get(pathInRepo);
+    let additions = nums?.additions ?? 0;
+    let deletions = nums?.deletions ?? 0;
+    let change = kindByPath.get(pathInRepo) ?? "modified";
+    if (untracked.includes(pathInRepo) && !kindByPath.has(pathInRepo)) {
+      change = "added";
+      const fromGit = await numstatFromGitNoIndex(g, pathInRepo);
+      if (fromGit) {
+        additions = fromGit.additions;
+        deletions = fromGit.deletions;
+      } else {
+        try {
+          const st = await fs11.promises.stat(abs);
+          if (st.isFile()) additions = await countTextFileLines(abs);
+          else additions = 0;
+        } catch {
+          additions = 0;
+        }
+        deletions = 0;
+      }
+    }
+    if (!kindByPath.has(pathInRepo) && nums) {
+      if (additions > 0 && deletions === 0) change = "added";
+      else if (deletions > 0 && additions === 0) change = "removed";
+      else change = "modified";
+    }
+    rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
+  }
+  const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
+  for (const row of rows) {
+    let pathInRepo;
+    if (normRel === ".") {
+      pathInRepo = row.pathRelLauncher;
+    } else if (row.pathRelLauncher.startsWith(`${normRel}/`)) {
+      pathInRepo = row.pathRelLauncher.slice(normRel.length + 1);
+    } else {
+      pathInRepo = row.pathRelLauncher;
+    }
+    const absFile = path13.join(repoGitCwd, pathInRepo);
+    let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
+    if (patch) {
+      patch = await hydrateUnifiedPatchWithFileContext(patch, absFile, repoGitCwd, pathInRepo, row.change);
+    }
+    row.patchContent = patch;
+  }
+  return rows;
+}
+
+// src/git/working-directory/changes/get-working-tree-change-repo-details.ts
+function normRepoRel(p) {
+  const x = p.replace(/\\/g, "/").trim();
+  return x === "" ? "." : x;
+}
+async function getWorkingTreeChangeRepoDetails(options) {
+  const launcher = path14.resolve(getBridgeWorkspaceDirectory());
+  const mirror = options.agentMirrorRootAbs ? path14.resolve(options.agentMirrorRootAbs) : null;
+  const out = [];
+  const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
+  const basisInput = options.basis ?? { kind: "working" };
+  if (basisInput.kind === "commit" && !filter) {
+    throw new Error("repoFilterRelPath is required for commit changes");
+  }
+  if (basisInput.kind === "commit" && !basisInput.sha.trim()) {
+    throw new Error("commit sha is required for commit changes");
+  }
+  const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
+  for (const target of options.commitTargetAbsDirs) {
+    const t = path14.resolve(target);
+    if (!await isGitRepoDirectory(t)) continue;
+    const g = simpleGit(t);
+    let branch = "HEAD";
+    try {
+      branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim() || "HEAD";
+    } catch {
+      branch = "HEAD";
+    }
+    const remoteUrl = await getRemoteOriginUrl(t);
+    const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
+    let repoRelPath;
+    if (mirror) {
+      const relNorm = path14.relative(mirror, path14.dirname(t));
+      repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
+    } else {
+      let top = t;
+      try {
+        top = (await g.raw(["rev-parse", "--show-toplevel"])).trim();
+      } catch {
+        top = t;
+      }
+      const rel = path14.relative(launcher, path14.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path14.basename(path14.resolve(top)) : rel;
+    }
+    const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
+    if (filter && norm !== filter) continue;
+    const repoDisplayName = formatRepoShortTitle(remoteUrl, norm === "." ? "." : norm);
+    const relForList = norm === "." ? "." : norm;
+    const files = basis.kind === "commit" ? await listChangedFilesForCommit(t, relForList, basis.sha.trim()) : await listChangedFilesForRepo(t, relForList);
+    const st = await g.status();
+    const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
+    const unpushedCommits = await listUnpushedCommits(t);
+    out.push({
+      repoRelPath: norm,
+      repoDisplayName,
+      branch,
+      remoteUrl,
+      remoteDisplay,
+      files,
+      hasUncommittedChanges,
+      unpushedCommits,
+      changesView: basis.kind === "commit" ? "commit" : "working",
+      changesCommitSha: basis.kind === "commit" ? basis.sha.trim() : null
+    });
+    if (filter) return out;
+  }
+  return out;
+}
+
 // src/git/commit-and-push.ts
 async function gitCommitAllIfDirty(repoDir, message, options) {
   const g = simpleGit(repoDir);
@@ -30026,7 +30591,7 @@ var SessionWorktreeManager = class {
     }
     if (!opts.isNewSession) {
       const agentCwd = this.sessionAgentCwd.get(sessionId);
-      if (agentCwd) return path13.resolve(agentCwd);
+      if (agentCwd) return path15.resolve(agentCwd);
       return void 0;
     }
     const prep = await prepareNewSessionWorktrees({
@@ -30039,7 +30604,7 @@ var SessionWorktreeManager = class {
     if (!prep) return void 0;
     this.sessionPaths.set(sessionId, prep.worktreePaths);
     this.sessionAgentCwd.set(sessionId, prep.agentCwd);
-    return path13.resolve(prep.agentCwd);
+    return path15.resolve(prep.agentCwd);
   }
   async renameSessionBranch(sessionId, newBranch) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30060,7 +30625,7 @@ var SessionWorktreeManager = class {
   getAgentCwdForSession(sessionId) {
     if (!sessionId) return null;
     const c = this.sessionAgentCwd.get(sessionId);
-    return c ? path13.resolve(c) : null;
+    return c ? path15.resolve(c) : null;
   }
   async removeSessionWorktrees(sessionId) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30086,6 +30651,17 @@ var SessionWorktreeManager = class {
   async getSessionWorkingTreeStatus(sessionId) {
     return aggregateSessionPathsWorkingTreeStatus(this.resolveCommitTargets(sessionId));
   }
+  /** Per-repo changed files vs HEAD (or a single commit vs parent) for the same git roots used for commit/push. */
+  async getSessionWorkingTreeChangeDetails(sessionId, opts) {
+    const targets = this.resolveCommitTargets(sessionId);
+    const mirror = this.getAgentCwdForSession(sessionId);
+    return getWorkingTreeChangeRepoDetails({
+      commitTargetAbsDirs: targets,
+      agentMirrorRootAbs: mirror,
+      repoFilterRelPath: opts?.repoRelPath?.trim() ? opts.repoRelPath.trim() : null,
+      basis: opts?.basis
+    });
+  }
   async pushSessionUpstream(sessionId) {
     try {
       await pushAheadOfUpstreamForPaths(this.resolveCommitTargets(sessionId));
@@ -30097,30 +30673,30 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootAbs() {
-  return path13.join(os3.homedir(), ".buildautomaton", "worktrees");
+  return path15.join(os3.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path20 from "node:path";
+import path22 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path17 from "node:path";
+import path19 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve14) => setImmediate(resolve14));
+  return new Promise((resolve15) => setImmediate(resolve15));
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs10 from "node:fs";
-import path15 from "node:path";
+import fs12 from "node:fs";
+import path17 from "node:path";
 
 // src/files/index/constants.ts
-import path14 from "node:path";
+import path16 from "node:path";
 import os4 from "node:os";
 var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path14.join(os4.homedir(), ".buildautomaton");
+var INDEX_DIR = path16.join(os4.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 var INDEX_VERSION = 2;
 var INDEX_LOG_PREFIX = "[file-index]";
@@ -30129,31 +30705,31 @@ var INDEX_LOG_PREFIX = "[file-index]";
 function walkWorkspaceTreeSync(dir, baseDir, out) {
   let names;
   try {
-    names = fs10.readdirSync(dir);
+    names = fs12.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path15.join(dir, name);
+    const full = path17.join(dir, name);
     let stat2;
     try {
-      stat2 = fs10.statSync(full);
+      stat2 = fs12.statSync(full);
     } catch {
       continue;
     }
-    const relative4 = path15.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path17.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       walkWorkspaceTreeSync(full, baseDir, out);
     } else if (stat2.isFile()) {
-      out.push(relative4);
+      out.push(relative5);
     }
   }
 }
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs10.promises.readdir(dir);
+    names = await fs12.promises.readdir(dir);
   } catch {
     return;
   }
@@ -30163,18 +30739,18 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path15.join(dir, name);
+    const full = path17.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs10.promises.stat(full);
+      stat2 = await fs12.promises.stat(full);
     } catch {
       continue;
     }
-    const relative4 = path15.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path17.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat2.isFile()) {
-      out.push(relative4);
+      out.push(relative5);
     }
   }
 }
@@ -30251,22 +30827,22 @@ async function buildTrigramMapForPathsAsync(paths) {
 }
 
 // src/files/index/write-index-file.ts
-import fs11 from "node:fs";
+import fs13 from "node:fs";
 
 // src/files/index/paths.ts
-import path16 from "node:path";
+import path18 from "node:path";
 import crypto2 from "node:crypto";
 function getIndexPathForCwd(resolvedCwd) {
   const hash = crypto2.createHash("sha256").update(resolvedCwd).digest("hex").slice(0, INDEX_HASH_LEN);
-  return path16.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path18.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 
 // src/files/index/write-index-file.ts
 function writeIndexFileSync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    if (!fs11.existsSync(INDEX_DIR)) fs11.mkdirSync(INDEX_DIR, { recursive: true });
-    fs11.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs13.existsSync(INDEX_DIR)) fs13.mkdirSync(INDEX_DIR, { recursive: true });
+    fs13.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -30274,8 +30850,8 @@ function writeIndexFileSync(resolvedCwd, data) {
 async function writeIndexFileAsync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    await fs11.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs11.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
+    await fs13.promises.mkdir(INDEX_DIR, { recursive: true });
+    await fs13.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -30289,7 +30865,7 @@ function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
 function buildFileIndex(cwd) {
-  const resolved = path17.resolve(cwd);
+  const resolved = path19.resolve(cwd);
   const paths = [];
   walkWorkspaceTreeSync(resolved, resolved, paths);
   sortPaths(paths);
@@ -30299,7 +30875,7 @@ function buildFileIndex(cwd) {
   return data;
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path17.resolve(cwd);
+  const resolved = path19.resolve(cwd);
   const paths = [];
   await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
   await yieldToEventLoop();
@@ -30311,13 +30887,13 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/load-file-index.ts
-import fs12 from "node:fs";
-import path18 from "node:path";
+import fs14 from "node:fs";
+import path20 from "node:path";
 function loadFileIndex(cwd) {
-  const resolved = path18.resolve(cwd);
+  const resolved = path20.resolve(cwd);
   const indexPath = getIndexPathForCwd(resolved);
   try {
-    const raw = fs12.readFileSync(indexPath, "utf8");
+    const raw = fs14.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -30336,9 +30912,9 @@ function loadFileIndex(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path19 from "node:path";
+import path21 from "node:path";
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path19.resolve(cwd);
+  const resolved = path21.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = await buildFileIndexAsync(resolved);
@@ -30421,7 +30997,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeWorkspaceDirectory()) {
-  const resolved = path20.resolve(cwd);
+  const resolved = path22.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -30468,15 +31044,15 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve14) => {
-    proc.once("exit", () => resolve14());
+  const exited = new Promise((resolve15) => {
+    proc.once("exit", () => resolve15());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve14) => setTimeout(resolve14, graceMs))]);
+  await Promise.race([exited, new Promise((resolve15) => setTimeout(resolve15, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -30490,7 +31066,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs13 from "node:fs";
+import fs15 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -30526,7 +31102,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs13.readFile(d.mergedLogPath, (err, buf) => {
+      fs15.readFile(d.mergedLogPath, (err, buf) => {
         if (err || (d.getSpawnGeneration() ?? 0) !== d.scheduledGen) return;
         if (buf.length <= d.mergedReadPos.value) return;
         const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
@@ -30564,7 +31140,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs13.readFile(mergedPath, (err, buf) => {
+      fs15.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -30666,13 +31242,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs14 from "node:fs";
+import fs16 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs14.rmSync(dir, { recursive: true, force: true });
+    fs16.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -30680,7 +31256,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs14.openSync(devPath, "r");
+    cachedDevNullReadFd = fs16.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -30754,15 +31330,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs15 from "node:fs";
+import fs17 from "node:fs";
 import { tmpdir } from "node:os";
-import path21 from "node:path";
+import path23 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs15.mkdtempSync(path21.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path21.join(tmpRoot, "combined.log");
+  const tmpRoot = fs17.mkdtempSync(path23.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path23.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs15.openSync(logPath, "a");
+    logFd = fs17.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -30781,7 +31357,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs15.closeSync(logFd);
+    fs17.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -30790,7 +31366,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs15.closeSync(logFd);
+      fs17.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -30801,22 +31377,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs16 from "node:fs";
+import fs18 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path22 from "node:path";
+import path24 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs16.mkdtempSync(path22.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path22.join(tmpRoot, "combined.log");
-  const innerPath = path22.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path22.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs18.mkdtempSync(path24.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path24.join(tmpRoot, "combined.log");
+  const innerPath = path24.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path24.join(tmpRoot, "_run.sh");
   try {
-    fs16.writeFileSync(innerPath, `#!/bin/sh
+    fs18.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs16.writeFileSync(
+    fs18.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -30842,13 +31418,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs16.mkdtempSync(path22.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path22.join(tmpRoot, "combined.log");
-  const runnerPath = path22.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs18.mkdtempSync(path24.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path24.join(tmpRoot, "combined.log");
+  const runnerPath = path24.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs16.writeFileSync(
+    fs18.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -31530,30 +32106,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs17 from "node:fs";
-import path23 from "node:path";
+import fs19 from "node:fs";
+import path25 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path23.join(cwd, rel);
-    if (!fs17.existsSync(base) || !fs17.statSync(base).isDirectory()) continue;
+    const base = path25.join(cwd, rel);
+    if (!fs19.existsSync(base) || !fs19.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs17.readdirSync(base);
+      entries = fs19.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path23.join(base, name);
+      const dir = path25.join(base, name);
       try {
-        if (!fs17.statSync(dir).isDirectory()) continue;
+        if (!fs19.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path23.join(dir, "SKILL.md");
-      if (!fs17.existsSync(skillMd)) continue;
+      const skillMd = path25.join(dir, "SKILL.md");
+      if (!fs19.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -31565,23 +32141,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path23.join(cwd, rel);
-    if (!fs17.existsSync(base) || !fs17.statSync(base).isDirectory()) continue;
+    const base = path25.join(cwd, rel);
+    if (!fs19.existsSync(base) || !fs19.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs17.readdirSync(base);
+      entries = fs19.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path23.join(base, name);
+      const dir = path25.join(base, name);
       try {
-        if (!fs17.statSync(dir).isDirectory()) continue;
+        if (!fs19.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs17.existsSync(path23.join(dir, "SKILL.md"))) continue;
+      if (!fs19.existsSync(path25.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -31726,12 +32302,12 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/agents/acp/from-bridge/handle-bridge-prompt.ts
-import * as path25 from "node:path";
+import * as path27 from "node:path";
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 
 // src/git/bridge-queue-key.ts
-import * as path24 from "node:path";
+import * as path26 from "node:path";
 import { createHash } from "node:crypto";
 function normalizeCanonicalGitUrl(url2) {
   let s = url2.trim();
@@ -31759,11 +32335,11 @@ function canonicalUrlToRepoIdSync(url2) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
 }
 function fallbackRepoIdFromPath(absPath) {
-  return createHash("sha256").update(path24.resolve(absPath)).digest("hex").slice(0, 32);
+  return createHash("sha256").update(path26.resolve(absPath)).digest("hex").slice(0, 32);
 }
 async function resolveBridgeQueueBindFields(options) {
   const { effectiveCwd, worktreePaths, primaryRepoRoots, log: log2 } = options;
-  const cwdAbs = worktreePaths.length > 0 ? path24.resolve(worktreePaths[0]) : path24.resolve(effectiveCwd);
+  const cwdAbs = worktreePaths.length > 0 ? path26.resolve(worktreePaths[0]) : path26.resolve(effectiveCwd);
   if (!primaryRepoRoots.length) {
     log2("[Bridge service] Prompt queue bind skipped: no Git repository roots under the working directory.");
     return null;
@@ -31828,7 +32404,7 @@ function handleBridgePrompt(msg, deps) {
   };
   async function preambleAndPrompt(resolvedCwd) {
     const s = getWs();
-    const effectiveCwd = path25.resolve(resolvedCwd ?? getBridgeWorkspaceDirectory());
+    const effectiveCwd = path27.resolve(resolvedCwd ?? getBridgeWorkspaceDirectory());
     const worktreePaths = sessionWorktreeManager.getWorktreePathsForSession(sessionId) ?? [];
     const repoRoots = await resolveSnapshotRepoRoots({
       worktreePaths,
@@ -31953,15 +32529,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs18 from "node:fs";
-import path27 from "node:path";
+import fs20 from "node:fs";
+import path29 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path26 from "node:path";
+import path28 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeWorkspaceDirectory()) {
-  const normalized = path26.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path26.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path26.sep) && resolved !== cwd) {
+  const normalized = path28.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path28.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path28.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -31975,7 +32551,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs18.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs20.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -31983,12 +32559,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path27.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path27.join(resolved, d.name);
+      const entryPath = path29.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path29.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs18.promises.stat(fullPath);
+          const targetStat = await fs20.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -32013,25 +32589,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs19 from "node:fs";
+import fs21 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
   const resolved = ensureUnderCwd(relativePath, getBridgeWorkspaceDirectory());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs19.realpathSync(resolved);
+    real = fs21.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat2 = fs19.statSync(real);
+  const stat2 = fs21.statSync(real);
   if (!stat2.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs19.statSync(filePath).size;
-  const fd = fs19.openSync(filePath, "r");
+  const fileSize = fs21.statSync(filePath).size;
+  const fd = fs21.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -32044,7 +32620,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs19.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs21.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -32179,7 +32755,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs19.closeSync(fd);
+    fs21.closeSync(fd);
   }
 }
 function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -32190,8 +32766,8 @@ function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat2 = fs19.statSync(result);
-    const raw = fs19.readFileSync(result, "utf8");
+    const stat2 = fs21.statSync(result);
+    const raw = fs21.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat2.size };
   } catch (err) {
@@ -32301,10 +32877,10 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs20 from "node:fs";
-import path28 from "node:path";
+import fs22 from "node:fs";
+import path30 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
-  const installed = [];
+  const installed2 = [];
   if (!Array.isArray(items)) {
     return { success: false, error: "Invalid items" };
   }
@@ -32313,24 +32889,24 @@ function installRemoteSkills(cwd, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path28.join(cwd, targetDir, item.skillName);
+      const skillDir = path30.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path28.join(skillDir, f.path);
-        fs20.mkdirSync(path28.dirname(dest), { recursive: true });
+        const dest = path30.join(skillDir, f.path);
+        fs22.mkdirSync(path30.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs20.writeFileSync(dest, f.text, "utf8");
+          fs22.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs20.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs22.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
-      installed.push({
+      installed2.push({
         sourceId: item.sourceId,
         skillName: item.skillName,
         versionHash: item.versionHash
       });
     }
-    return { success: true, installed };
+    return { success: true, installed: installed2 };
   } catch (e) {
     return { success: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -32367,7 +32943,8 @@ var handleSessionGitRequestMessage = (msg, deps) => {
   if (typeof msg.id !== "string") return;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const action = msg.action;
-  if (!sessionId || action !== "status" && action !== "push" && action !== "commit") return;
+  if (!sessionId || action !== "status" && action !== "push" && action !== "commit" && action !== "list_changes")
+    return;
   void (async () => {
     const ws = deps.getWs();
     const reply = (payload) => sendResult(ws, msg.id, payload);
@@ -32381,6 +32958,24 @@ var handleSessionGitRequestMessage = (msg, deps) => {
         });
         return;
       }
+      if (action === "list_changes") {
+        const repoRel = typeof msg.changesRepoRelPath === "string" ? msg.changesRepoRelPath.trim() : "";
+        const view = msg.changesView === "commit" ? "commit" : "working";
+        const commitSha = typeof msg.changesCommitSha === "string" ? msg.changesCommitSha.trim() : "";
+        if (view === "commit") {
+          if (!repoRel || !commitSha) {
+            reply({ ok: false, error: "changesRepoRelPath and changesCommitSha are required for commit view" });
+            return;
+          }
+        }
+        const opts = repoRel && view === "commit" && commitSha ? { repoRelPath: repoRel, basis: { kind: "commit", sha: commitSha } } : repoRel ? { repoRelPath: repoRel, basis: { kind: "working" } } : void 0;
+        const repos = await deps.sessionWorktreeManager.getSessionWorkingTreeChangeDetails(sessionId, opts);
+        reply({
+          ok: true,
+          repos
+        });
+        return;
+      }
       if (action === "push") {
         const pushRes = await deps.sessionWorktreeManager.pushSessionUpstream(sessionId);
         if (!pushRes.ok) {
@@ -32447,7 +33042,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs21 from "node:fs";
+import * as fs23 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -32459,7 +33054,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? getBridgeWorkspaceDirectory();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs21.existsSync(file2)) {
+    if (!fs23.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -32788,6 +33383,7 @@ async function createBridgeConnection(options) {
 
 // src/run-bridge.ts
 async function runBridge(options) {
+  installBridgeProcessResilience();
   const { apiUrl, workspaceId, authToken, refreshToken, bridgeName, justAuthenticated, worktreesRootAbs } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   const hasAuth = workspaceId && authToken;