@buildautomaton/cli 0.1.28 → 0.1.29

package/dist/cli.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path37 = __require("node:path");
-    var fs36 = __require("node:fs");
+    var path41 = __require("node:path");
+    var fs38 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path37.resolve(baseDir, baseName);
-          if (fs36.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path37.extname(baseName))) return void 0;
+          const localBin = path41.resolve(baseDir, baseName);
+          if (fs38.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path41.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs36.existsSync(`${localBin}${ext}`)
+            (ext) => fs38.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs36.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs38.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path37.resolve(
-            path37.dirname(resolvedScriptPath),
+          executableDir = path41.resolve(
+            path41.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path37.basename(
+            const legacyName = path41.basename(
               this._scriptPath,
-              path37.extname(this._scriptPath)
+              path41.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path37.extname(executableFile));
+        launchWithNode = sourceExt.includes(path41.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path37.basename(filename, path37.extname(filename));
+        this._name = path41.basename(filename, path41.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path38) {
-        if (path38 === void 0) return this._executableDir;
-        this._executableDir = path38;
+      executableDir(path42) {
+        if (path42 === void 0) return this._executableDir;
+        this._executableDir = path42;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path37, errorMaps, issueData } = params;
-      const fullPath = [...path37, ...issueData.path || []];
+      const { data, path: path41, errorMaps, issueData } = params;
+      const fullPath = [...path41, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path37, key) {
+      constructor(parent, value, path41, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path37;
+        this._path = path41;
         this._key = key;
       }
       get path() {
@@ -11235,7 +11235,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os8 = __require("os");
+    var os9 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -11283,7 +11283,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os8.release().split(".");
+        const osRelease = os9.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -11529,10 +11529,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(path37, isFile, isDirectory) {
-      log2(`checking %s`, path37);
+    function check2(path41, isFile, isDirectory) {
+      log2(`checking %s`, path41);
       try {
-        const stat3 = fs_1.statSync(path37);
+        const stat3 = fs_1.statSync(path41);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -11552,8 +11552,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path37, type = exports.READABLE) {
-      return check2(path37, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path41, type = exports.READABLE) {
+      return check2(path41, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -11850,10 +11850,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path37) {
-  if (!path37)
+function getElementAtPath(obj, path41) {
+  if (!path41)
     return obj;
-  return path37.reduce((acc, key) => acc?.[key], obj);
+  return path41.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12102,11 +12102,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path37, issues) {
+function prefixIssues(path41, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path37);
+    iss.path.unshift(path41);
     return iss;
   });
 }
@@ -12295,7 +12295,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path37 = []) => {
+  const processError = (error41, path41 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12305,7 +12305,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path37, ...issue2.path];
+        const fullpath = [...path41, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12335,9 +12335,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path37) {
+function toDotPath(path41) {
   const segs = [];
-  for (const seg of path37) {
+  for (const seg of path41) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -25064,15 +25064,15 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.28".length > 0 ? "0.1.28" : "0.0.0-dev";
+var CLI_VERSION = "0.1.29".length > 0 ? "0.1.29" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs35 from "node:fs";
-import * as path36 from "node:path";
+import * as fs37 from "node:fs";
+import * as path40 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -26696,6 +26696,321 @@ function runPendingAuth(options) {
   };
 }
 
+// src/sqlite/cli-database.ts
+import sqliteWasm from "node-sqlite3-wasm";
+
+// src/sqlite/cli-sqlite-paths.ts
+import fs8 from "node:fs";
+import path5 from "node:path";
+import os3 from "node:os";
+function getCliSqlitePath() {
+  const override = process.env.BUILDAMATON_CLI_SQLITE_PATH?.trim();
+  if (override) return path5.resolve(override);
+  return path5.join(os3.homedir(), ".buildautomaton", "cli.sqlite");
+}
+function ensureCliSqliteParentDir(sqlitePath) {
+  const dir = path5.dirname(sqlitePath);
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+}
+
+// src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts
+import fs13 from "node:fs";
+
+// src/files/index/constants.ts
+import path6 from "node:path";
+import os4 from "node:os";
+var INDEX_WORK_YIELD_EVERY = 256;
+var INDEX_DIR = path6.join(os4.homedir(), ".buildautomaton");
+var INDEX_HASH_LEN = 16;
+
+// src/prompt-turn-queue/paths.ts
+import path7 from "node:path";
+import os5 from "node:os";
+function getPromptQueuesDirectory() {
+  const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
+  if (override) return path7.resolve(override);
+  return path7.join(os5.homedir(), ".buildautomaton", "queues");
+}
+
+// src/sqlite/legacy_migration/archive-file-index-json.ts
+import fs10 from "node:fs";
+import path9 from "node:path";
+
+// src/sqlite/legacy_migration/archive-to-old-version.ts
+import fs9 from "node:fs";
+import path8 from "node:path";
+var OLD_VERSION_DIR = path8.join(INDEX_DIR, "old-version");
+function moveLegacyFileToOldVersionBackup(category, sourcePath) {
+  const destDir = path8.join(OLD_VERSION_DIR, category);
+  fs9.mkdirSync(destDir, { recursive: true });
+  const base = path8.basename(sourcePath);
+  let dest = path8.join(destDir, base);
+  if (fs9.existsSync(dest)) {
+    const ext = path8.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    dest = path8.join(destDir, `${stem}-${Date.now()}${ext}`);
+  }
+  fs9.renameSync(sourcePath, dest);
+}
+
+// src/sqlite/legacy_migration/archive-file-index-json.ts
+function archiveLegacyFileIndexJsonFiles() {
+  try {
+    if (!fs10.existsSync(INDEX_DIR)) return;
+    for (const name of fs10.readdirSync(INDEX_DIR)) {
+      if (name.startsWith(".file-index-") && name.endsWith(".json")) {
+        const full = path9.join(INDEX_DIR, name);
+        try {
+          moveLegacyFileToOldVersionBackup("file-index", full);
+        } catch (err) {
+          console.error(`[cli-sqlite] legacy import: could not archive ${name}`, err);
+        }
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: archive file-index json failed", e);
+  }
+}
+
+// src/sqlite/legacy_migration/import-agent-sessions-from-disk.ts
+import fs11 from "node:fs";
+import path10 from "node:path";
+import os6 from "node:os";
+var LEGACY_AGENT_SESSION_DIR = path10.join(os6.homedir(), ".buildautomaton", "agent-sessions");
+function importLegacyAgentSessionsFromDisk(db) {
+  try {
+    if (!fs11.existsSync(LEGACY_AGENT_SESSION_DIR)) return;
+    const names = fs11.readdirSync(LEGACY_AGENT_SESSION_DIR).filter((n) => n.endsWith(".json"));
+    for (const name of names) {
+      const sessionKey = name.slice(0, -".json".length);
+      const full = path10.join(LEGACY_AGENT_SESSION_DIR, name);
+      let raw;
+      try {
+        raw = fs11.readFileSync(full, "utf8");
+      } catch {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (parsed.v !== 1) continue;
+      const acpSessionId = typeof parsed.acpSessionId === "string" ? parsed.acpSessionId : null;
+      const backendAgentType = typeof parsed.backendAgentType === "string" ? parsed.backendAgentType : null;
+      const configOptionsJson = Array.isArray(parsed.configOptions) ? JSON.stringify(parsed.configOptions) : null;
+      const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
+      db.run(
+        `INSERT OR REPLACE INTO agent_session (session_key, acp_session_id, backend_agent_type, config_options_json, updated_at)
+         VALUES (?, ?, ?, ?, ?)`,
+        [sessionKey, acpSessionId, backendAgentType, configOptionsJson, updatedAt]
+      );
+      try {
+        moveLegacyFileToOldVersionBackup("agent-sessions", full);
+      } catch {
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: agent_sessions from disk failed", e);
+  }
+}
+
+// src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts
+import fs12 from "node:fs";
+import path11 from "node:path";
+
+// src/sqlite/legacy_migration/parse-persisted-queue-json.ts
+function parsePersistedQueueFromJson(raw) {
+  try {
+    const o = JSON.parse(raw);
+    const queueKey = typeof o.queueKey === "string" ? o.queueKey : typeof o.queueKeyHash === "string" ? o.queueKeyHash : null;
+    if (!queueKey || typeof o.updatedAt !== "string" || !Array.isArray(o.turns)) return null;
+    return { queueKey, updatedAt: o.updatedAt, turns: o.turns };
+  } catch {
+    return null;
+  }
+}
+
+// src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts
+function importLegacyPromptQueuesFromDisk(db) {
+  try {
+    const dir = getPromptQueuesDirectory();
+    if (!fs12.existsSync(dir)) return;
+    for (const name of fs12.readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const full = path11.join(dir, name);
+      let raw;
+      try {
+        raw = fs12.readFileSync(full, "utf8");
+      } catch {
+        continue;
+      }
+      const file2 = parsePersistedQueueFromJson(raw);
+      if (!file2) continue;
+      db.run(
+        `INSERT OR REPLACE INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)`,
+        [file2.queueKey, file2.updatedAt, JSON.stringify(file2.turns)]
+      );
+      try {
+        moveLegacyFileToOldVersionBackup("queues", full);
+      } catch {
+      }
+    }
+  } catch (e) {
+    console.error("[cli-sqlite] legacy import: prompt queues from disk failed", e);
+  }
+}
+
+// src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts
+function legacyCliDiskMigrationIsPending() {
+  try {
+    if (fs13.existsSync(INDEX_DIR)) {
+      for (const name of fs13.readdirSync(INDEX_DIR)) {
+        if (name.startsWith(".file-index-") && name.endsWith(".json")) return true;
+      }
+    }
+  } catch {
+  }
+  try {
+    if (fs13.existsSync(LEGACY_AGENT_SESSION_DIR)) {
+      if (fs13.readdirSync(LEGACY_AGENT_SESSION_DIR).some((n) => n.endsWith(".json"))) return true;
+    }
+  } catch {
+  }
+  try {
+    const dir = getPromptQueuesDirectory();
+    if (fs13.existsSync(dir) && fs13.readdirSync(dir).some((n) => n.endsWith(".json"))) return true;
+  } catch {
+  }
+  return false;
+}
+function importCliSqliteLegacyDiskData(db, log2) {
+  const pending = legacyCliDiskMigrationIsPending();
+  if (pending && log2) {
+    log2("Migrating legacy on-disk CLI data to SQLite\u2026");
+  }
+  archiveLegacyFileIndexJsonFiles();
+  importLegacyAgentSessionsFromDisk(db);
+  importLegacyPromptQueuesFromDisk(db);
+  if (pending && log2) {
+    log2("Legacy on-disk CLI data migration finished.");
+  }
+}
+
+// src/sqlite/load-cli-migration-sql.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function readCliSqliteMigrationSql(filename) {
+  const dir = dirname(fileURLToPath2(import.meta.url));
+  const resolved = join2(dir, "migrations", filename);
+  if (!existsSync(resolved)) {
+    throw new Error(`Missing CLI SQLite migration SQL: ${resolved}`);
+  }
+  return readFileSync(resolved, "utf8");
+}
+
+// src/sqlite/migrate-cli-sqlite.ts
+function checkpointSatisfiedByLegacyChain(applied2, replacesLegacyMigrations) {
+  return Array.isArray(replacesLegacyMigrations) && replacesLegacyMigrations.length > 0 && replacesLegacyMigrations.every((n) => applied2.has(n));
+}
+function recordMigrationAndPruneCheckpointLegacy(db, migration, applied2) {
+  db.run("INSERT INTO __migrations (name) VALUES (?)", [migration.name]);
+  applied2.add(migration.name);
+  if (migration.checkpoint !== true) return;
+  const legacy = migration.replacesLegacyMigrations;
+  if (!legacy?.length) return;
+  for (const legacyName of legacy) {
+    if (legacyName === migration.name) continue;
+    db.run("DELETE FROM __migrations WHERE name = ?", [legacyName]);
+    applied2.delete(legacyName);
+  }
+}
+var CHECKPOINT_V1 = "001_cli_sqlite_checkpoint_v1";
+var CHECKPOINT_V1_SQL = readCliSqliteMigrationSql("001_cli_sqlite_checkpoint_v1.sql");
+var CLI_SQLITE_MIGRATIONS = [
+  {
+    name: CHECKPOINT_V1,
+    checkpoint: true,
+    migrate: (db) => {
+      db.exec(CHECKPOINT_V1_SQL);
+    }
+  }
+];
+function migrateCliSqlite(db) {
+  db.exec(readCliSqliteMigrationSql("000_bootstrap_migrations_table.sql"));
+  const appliedRows = db.all("SELECT name FROM __migrations");
+  const applied2 = new Set(appliedRows.map((r) => r.name));
+  for (const migration of CLI_SQLITE_MIGRATIONS) {
+    if (applied2.has(migration.name)) continue;
+    if (migration.checkpoint === true && checkpointSatisfiedByLegacyChain(applied2, migration.replacesLegacyMigrations)) {
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied2);
+      continue;
+    }
+    if (migration.alreadyApplied?.(db)) {
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied2);
+      continue;
+    }
+    try {
+      migration.migrate(db);
+      recordMigrationAndPruneCheckpointLegacy(db, migration, applied2);
+    } catch (e) {
+      console.error(`[cli-sqlite] Migration failed: ${migration.name}`, e);
+      throw e;
+    }
+  }
+}
+
+// src/sqlite/cli-database.ts
+var { Database: SqliteDatabase } = sqliteWasm;
+var openDatabases = /* @__PURE__ */ new Map();
+var processExitCloseRegistered = false;
+function registerProcessExitSqliteClose() {
+  if (processExitCloseRegistered) return;
+  processExitCloseRegistered = true;
+  process.once("exit", () => {
+    for (const db of openDatabases.values()) {
+      safeCloseCliSqliteDatabase(db);
+    }
+    openDatabases.clear();
+  });
+}
+function safeCloseCliSqliteDatabase(db) {
+  if (db == null) return;
+  try {
+    if (db.isOpen) db.close();
+  } catch {
+  }
+}
+function closeAllCliSqliteConnections() {
+  for (const db of openDatabases.values()) {
+    safeCloseCliSqliteDatabase(db);
+  }
+  openDatabases.clear();
+}
+function getCliDatabase(options) {
+  const sqlitePath = getCliSqlitePath();
+  const existing = openDatabases.get(sqlitePath);
+  if (existing?.isOpen) return existing;
+  if (existing && !existing.isOpen) {
+    safeCloseCliSqliteDatabase(existing);
+    openDatabases.delete(sqlitePath);
+  }
+  ensureCliSqliteParentDir(sqlitePath);
+  const db = new SqliteDatabase(sqlitePath);
+  try {
+    migrateCliSqlite(db);
+    importCliSqliteLegacyDiskData(db, options?.logLegacyMigration);
+  } catch (e) {
+    safeCloseCliSqliteDatabase(db);
+    throw e;
+  }
+  openDatabases.set(sqlitePath, db);
+  registerProcessExitSqliteClose();
+  return db;
+}
+
 // src/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   const say = log2 ?? logImmediate;
@@ -26739,20 +27054,24 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
     say("Stopping local dev server processes\u2026");
     await devServerManager.shutdownAllGraceful();
   }
+  try {
+    closeAllCliSqliteConnections();
+  } catch {
+  }
   say("Shutdown complete.");
 }
 
 // src/paths/session-layout-paths.ts
-import * as path5 from "node:path";
+import * as path12 from "node:path";
 function resolveIsolatedSessionParentPathFromCheckouts(worktreePaths) {
-  const resolved = worktreePaths.map((p) => path5.resolve(p)).filter(Boolean);
+  const resolved = worktreePaths.map((p) => path12.resolve(p)).filter(Boolean);
   if (resolved.length === 0) return null;
   resolved.sort();
   return resolved[0];
 }
 function resolveSessionParentPathForAgentProcess(resolvedSessionParentPath) {
   if (resolvedSessionParentPath != null && String(resolvedSessionParentPath).trim() !== "") {
-    return path5.resolve(String(resolvedSessionParentPath).trim());
+    return path12.resolve(String(resolvedSessionParentPath).trim());
   }
   return getBridgeRoot();
 }
@@ -27084,9 +27403,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path37 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path37) continue;
-    rows.push({ path: path37, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path41 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path41) continue;
+    rows.push({ path: path41, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -27312,17 +27631,17 @@ function getCliPermissionModeFromAgentConfig(config2) {
 import { execFile as execFile7 } from "node:child_process";
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import { promisify as promisify7 } from "node:util";
-import * as path8 from "node:path";
+import * as path15 from "node:path";
 
 // src/git/pre-turn-snapshot.ts
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 
 // src/git/discover-repos.ts
-import * as fs8 from "node:fs";
-import * as path6 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 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);
@@ -27361,8 +27680,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path37) {
-  return path37 instanceof String && cache.has(path37);
+function isPathSpec(path41) {
+  return path41 instanceof String && cache.has(path41);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -27451,8 +27770,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path37) {
-  return (0, import_file_exists.exists)(path37, import_file_exists.FOLDER);
+function folderExists(path41) {
+  return (0, import_file_exists.exists)(path41, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -27856,8 +28175,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path37) {
-      return /^\.(git)?$/.test(path37.trim());
+    parser(path41) {
+      return /^\.(git)?$/.test(path41.trim());
     }
   };
 }
@@ -28291,11 +28610,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path37, line, preview] = input.split(NULL);
-    paths.add(path37);
-    (results[path37] = results[path37] || []).push({
+    const [path41, line, preview] = input.split(NULL);
+    paths.add(path41);
+    (results[path41] = results[path41] || []).push({
       line: asNumber(line),
-      path: path37,
+      path: path41,
       preview
     });
   });
@@ -29060,14 +29379,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path37, text) {
+function parseInit(bare, path41, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path37, false, result[1]);
+    return new InitSummary(bare, path41, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path37, true, result[1]);
+    return new InitSummary(bare, path41, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -29078,7 +29397,7 @@ function parseInit(bare, path37, text) {
       break;
     }
   }
-  return new InitSummary(bare, path37, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path41, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -29087,9 +29406,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path37, existing, gitDir) {
+      constructor(bare, path41, existing, gitDir) {
         this.bare = bare;
-        this.path = path37;
+        this.path = path41;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -29101,7 +29420,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path37, customArgs) {
+function initTask(bare = false, path41, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -29110,7 +29429,7 @@ function initTask(bare = false, path37, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path37, text);
+      return parseInit(commands.includes("--bare"), path41, text);
     }
   };
 }
@@ -29926,12 +30245,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path37, index, working_dir) {
-        this.path = path37;
+      constructor(path41, index, working_dir) {
+        this.path = path41;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path37) || [null, path37, path37];
+          const detail = fromPathRegex.exec(path41) || [null, path41, path41];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -29962,14 +30281,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path37) {
+  function data(index, workingDir, path41) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path37);
+      handler(result, path41);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path37, index, workingDir));
+      result.files.push(new FileStatusSummary(path41, index, workingDir));
     }
   }
 }
@@ -30242,15 +30561,15 @@ var init_simple_git_api = __esm2({
         this._executor = _executor;
       }
       _runTask(task, then) {
-        const chain = this._executor.chain();
-        const promise2 = chain.push(task);
+        const chain2 = this._executor.chain();
+        const promise2 = chain2.push(task);
         if (then) {
           taskCallback(task, promise2, then);
         }
         return Object.create(this, {
           then: { value: promise2.then.bind(promise2) },
           catch: { value: promise2.catch.bind(promise2) },
-          _executor: { value: chain }
+          _executor: { value: chain2 }
         });
       }
       add(files) {
@@ -30278,9 +30597,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path37, write) {
+      hashObject(path41, write) {
         return this._runTask(
-          hashObjectTask(path37, write === true),
+          hashObjectTask(path41, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -30633,8 +30952,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path37 = input.trim().replace(/^["']|["']$/g, "");
-  return path37 && normalize(path37);
+  const path41 = input.trim().replace(/^["']|["']$/g, "");
+  return path41 && normalize(path41);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -30948,8 +31267,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path37) {
-  return subModuleTask(["add", repo, path37]);
+function addSubModuleTask(repo, path41) {
+  return subModuleTask(["add", repo, path41]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -31282,8 +31601,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path37, then) {
-      return this._runTask(addSubModuleTask2(repo, path37), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path41, then) {
+      return this._runTask(addSubModuleTask2(repo, path41), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -31927,20 +32246,20 @@ async function isGitRepoDirectory(dirPath) {
 // src/git/discover-repos.ts
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path6.resolve(cwd);
+  const cwdResolved = path13.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
   }
   let entries;
   try {
-    entries = fs8.readdirSync(cwdResolved, { withFileTypes: true });
+    entries = fs14.readdirSync(cwdResolved, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path6.join(cwdResolved, ent.name);
+    const childPath = path13.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -31949,22 +32268,22 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootPath) {
-  const root = path6.resolve(rootPath);
+  const root = path13.resolve(rootPath);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path6.resolve(dir));
+      roots.push(path13.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path6.join(dir, ent.name));
+      await walk(path13.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -31980,7 +32299,7 @@ async function discoverGitReposUnderRoot(rootPath) {
 // src/git/pre-turn-snapshot.ts
 var execFileAsync5 = promisify6(execFile6);
 function snapshotsDirForCwd(agentCwd) {
-  return path7.join(agentCwd, ".buildautomaton", "snapshots");
+  return path14.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate(repoRoot, log2) {
   try {
@@ -32009,7 +32328,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path7.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path14.resolve(p)))];
     return uniq;
   }
   try {
@@ -32017,7 +32336,7 @@ async function resolveSnapshotRepoRoots(options) {
     const mapped = repos.map((r) => r.absolutePath);
     const sid = sessionId?.trim();
     if (sid) {
-      const filtered = mapped.filter((root) => path7.basename(root) === sid);
+      const filtered = mapped.filter((root) => path14.basename(root) === sid);
       if (filtered.length > 0) return filtered;
     }
     return mapped;
@@ -32038,7 +32357,7 @@ async function capturePreTurnSnapshot(options) {
   }
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs9.mkdirSync(dir, { recursive: true });
+    fs15.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -32047,9 +32366,9 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path7.join(dir, `${runId}.json`);
+  const filePath = path14.join(dir, `${runId}.json`);
   try {
-    fs9.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs15.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -32062,7 +32381,7 @@ async function capturePreTurnSnapshot(options) {
 async function applyPreTurnSnapshot(filePath, log2) {
   let data;
   try {
-    const raw = fs9.readFileSync(filePath, "utf8");
+    const raw = fs15.readFileSync(filePath, "utf8");
     data = JSON.parse(raw);
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -32085,7 +32404,7 @@ async function applyPreTurnSnapshot(filePath, log2) {
   return { ok: true };
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path7.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path14.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/git/session-git-queue.ts
@@ -32134,7 +32453,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
       continue;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
-    const slug = path8.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
+    const slug = path15.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
@@ -32148,7 +32467,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
         );
         if (!patchContent.trim()) continue;
         const displayPath = multiRepo ? `${slug}/${rel}` : rel;
-        const workspaceFilePath = path8.join(repo.path, rel);
+        const workspaceFilePath = path15.join(repo.path, rel);
         const newText = await readWorkspaceFileAsUtf8(workspaceFilePath);
         sendSessionUpdate({
           type: "session_file_change",
@@ -32170,9 +32489,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path37, summary }) => {
+  const entries = params.rows.map(({ path: path41, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path37, summary: JSON.stringify(enc) };
+    return { path: path41, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -32483,8 +32802,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
+import * as fs16 from "node:fs";
+import * as path19 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -32648,8 +32967,8 @@ function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
 }
 
 // src/agents/acp/clients/shared/acp-fs-read-write.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 
 // src/files/diff/unified-diff.ts
 function computeLineDiff(oldText, newText) {
@@ -32698,21 +33017,21 @@ function editSnippetToUnifiedDiff(filePath, oldText, newText) {
 }
 
 // src/agents/acp/safe-fs-path.ts
-import * as path9 from "node:path";
+import * as path16 from "node:path";
 function resolveSafePathUnderCwd(cwd, filePath) {
   const trimmed2 = filePath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path9.resolve(cwd);
-  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
-  const rel = path9.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
+  const normalizedCwd = path16.resolve(cwd);
+  const resolved = path16.isAbsolute(trimmed2) ? path16.normalize(trimmed2) : path16.resolve(normalizedCwd, trimmed2);
+  const rel = path16.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path16.isAbsolute(rel)) return null;
   return resolved;
 }
 function toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path9.resolve(cwd);
-  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
-  if (!rel || rel === "") return path9.basename(absolutePath);
-  return rel.split(path9.sep).join("/");
+  const normalizedCwd = path16.resolve(cwd);
+  const rel = path16.relative(normalizedCwd, path16.resolve(absolutePath));
+  if (!rel || rel === "") return path16.basename(absolutePath);
+  return rel.split(path16.sep).join("/");
 }
 
 // src/agents/acp/clients/shared/acp-fs-read-write.ts
@@ -32727,7 +33046,7 @@ function acpReadTextFileInProcess(ctx, filePath, line, limit) {
   const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
   if (!resolvedPath) throw new Error("Invalid or disallowed path");
   try {
-    let content = readFileSync2(resolvedPath, "utf8");
+    let content = readFileSync3(resolvedPath, "utf8");
     content = sliceFileContentForAcp(content, line, limit);
     return { content };
   } catch (e) {
@@ -32740,11 +33059,11 @@ function acpWriteTextFileInProcess(ctx, filePath, newText) {
   if (!resolvedPath) throw new Error("Invalid or disallowed path");
   let oldText = "";
   try {
-    oldText = readFileSync2(resolvedPath, "utf8");
+    oldText = readFileSync3(resolvedPath, "utf8");
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
-  mkdirSync2(dirname2(resolvedPath), { recursive: true });
+  mkdirSync2(dirname3(resolvedPath), { recursive: true });
   writeFileSync2(resolvedPath, newText, "utf8");
   const displayPath = toDisplayPathRelativeToCwd(ctx.cwd, resolvedPath);
   const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
@@ -33681,20 +34000,20 @@ function resolveAgentCommand(preferredAgentType) {
 
 // src/agents/acp/session-file-change-path-kind.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { existsSync as existsSync2, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as path10 from "node:path";
+import * as path17 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path10.resolve(startDir),
+      cwd: path17.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path10.resolve(out) : null;
+    return out ? path17.resolve(out) : null;
   } catch {
     return null;
   }
@@ -33702,26 +34021,26 @@ function getGitRepoRootSync(startDir) {
 
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync3 } from "node:fs";
-import * as path11 from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path18 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedSessionParent = path11.resolve(sessionParentPath);
+  const normalizedSessionParent = path18.resolve(sessionParentPath);
   let resolvedPath = resolveSafePathUnderCwd(sessionParentPath, trimmed2);
   if (!resolvedPath) {
-    const candidate = path11.isAbsolute(trimmed2) ? path11.normalize(trimmed2) : path11.normalize(path11.resolve(normalizedSessionParent, trimmed2));
+    const candidate = path18.isAbsolute(trimmed2) ? path18.normalize(trimmed2) : path18.normalize(path18.resolve(normalizedSessionParent, trimmed2));
     const gitRoot2 = getGitRepoRootSync(sessionParentPath);
     if (!gitRoot2) return null;
-    const rel = path11.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path11.isAbsolute(rel)) return null;
+    const rel = path18.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path18.isAbsolute(rel)) return null;
     resolvedPath = candidate;
   }
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const relFromRoot = path11.relative(gitRoot, resolvedPath);
-    if (!relFromRoot.startsWith("..") && !path11.isAbsolute(relFromRoot)) {
-      return { resolvedPath, display: relFromRoot.split(path11.sep).join("/") };
+    const relFromRoot = path18.relative(gitRoot, resolvedPath);
+    if (!relFromRoot.startsWith("..") && !path18.isAbsolute(relFromRoot)) {
+      return { resolvedPath, display: relFromRoot.split(path18.sep).join("/") };
     }
   }
   return { resolvedPath, display: toDisplayPathRelativeToCwd(sessionParentPath, resolvedPath) };
@@ -33730,11 +34049,11 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath2 = path11.resolve(gitRoot, displayPath);
-    const rel = path11.relative(gitRoot, resolvedPath2);
-    if (!rel.startsWith("..") && !path11.isAbsolute(rel)) {
+    const resolvedPath2 = path18.resolve(gitRoot, displayPath);
+    const rel = path18.relative(gitRoot, resolvedPath2);
+    if (!rel.startsWith("..") && !path18.isAbsolute(rel)) {
       try {
-        return readFileSync3(resolvedPath2, "utf8");
+        return readFileSync4(resolvedPath2, "utf8");
       } catch {
       }
     }
@@ -33742,7 +34061,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
   if (!resolvedPath) return "";
   try {
-    return readFileSync3(resolvedPath, "utf8");
+    return readFileSync4(resolvedPath, "utf8");
   } catch {
     return "";
   }
@@ -33751,9 +34070,9 @@ function tryWorkspaceDisplayToPath(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath = path11.resolve(gitRoot, displayPath);
-    const rel = path11.relative(gitRoot, resolvedPath);
-    if (!rel.startsWith("..") && !path11.isAbsolute(rel)) return resolvedPath;
+    const resolvedPath = path18.resolve(gitRoot, displayPath);
+    const rel = path18.relative(gitRoot, resolvedPath);
+    if (!rel.startsWith("..") && !path18.isAbsolute(rel)) return resolvedPath;
   }
   return resolveSafePathUnderCwd(sessionParentPath, displayPath);
 }
@@ -33788,7 +34107,7 @@ function gitHeadPathObjectType(sessionParentPath, displayPath) {
 }
 function getSessionFileChangeDirectoryFlags(sessionParentPath, displayPath) {
   const resolvedPath = tryWorkspaceDisplayToPath(sessionParentPath, displayPath);
-  if (resolvedPath && existsSync(resolvedPath)) {
+  if (resolvedPath && existsSync2(resolvedPath)) {
     try {
       if (statSync(resolvedPath).isDirectory()) {
         return { isDirectory: true, directoryRemoved: false };
@@ -33888,7 +34207,7 @@ function createBridgeOnRequest(opts) {
 }
 
 // src/agents/acp/hooks/extract-acp-file-diffs-from-update/paths-and-text.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function readOptionalTextField(v) {
   if (v === null || v === void 0) return "";
   if (typeof v === "string") return v;
@@ -33898,7 +34217,7 @@ function normalizePathField(raw) {
   const t = raw.trim();
   if (t.startsWith("file://")) {
     try {
-      return fileURLToPath2(t);
+      return fileURLToPath3(t);
     } catch {
       return t;
     }
@@ -34356,29 +34675,34 @@ function buildAcpSessionBridgeHooks(opts) {
 }
 
 // src/agents/acp/local-agent-session-file.ts
-import fs10 from "node:fs";
-import os3 from "node:os";
-import path12 from "node:path";
-var LOCAL_AGENT_SESSION_DIR = path12.join(os3.homedir(), ".buildautomaton", "agent-sessions");
-function safeFileSlug(cloudSessionId) {
+function sessionKeyForCloudSessionId(cloudSessionId) {
   const t = cloudSessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 220);
   return t.length > 0 ? t : "session";
 }
-function localAgentSessionFilePath(cloudSessionId) {
-  return path12.join(LOCAL_AGENT_SESSION_DIR, `${safeFileSlug(cloudSessionId)}.json`);
-}
 function readLocalAgentSessionFile(cloudSessionId) {
   try {
-    const p = localAgentSessionFilePath(cloudSessionId);
-    const raw = fs10.readFileSync(p, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.v !== 1) return null;
+    const db = getCliDatabase();
+    const key = sessionKeyForCloudSessionId(cloudSessionId);
+    const row = db.get(
+      "SELECT acp_session_id, backend_agent_type, config_options_json, updated_at FROM agent_session WHERE session_key = ?",
+      [key]
+    );
+    if (!row) return null;
+    let configOptions = null;
+    if (row.config_options_json != null && row.config_options_json !== "") {
+      try {
+        const parsed = JSON.parse(row.config_options_json);
+        configOptions = Array.isArray(parsed) ? parsed : null;
+      } catch {
+        configOptions = null;
+      }
+    }
     return {
       v: 1,
-      acpSessionId: typeof parsed.acpSessionId === "string" ? parsed.acpSessionId : null,
-      backendAgentType: typeof parsed.backendAgentType === "string" ? parsed.backendAgentType : null,
-      configOptions: Array.isArray(parsed.configOptions) ? parsed.configOptions : null,
-      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+      acpSessionId: row.acp_session_id,
+      backendAgentType: row.backend_agent_type,
+      configOptions,
+      updatedAt: row.updated_at
     };
   } catch {
     return null;
@@ -34386,9 +34710,8 @@ function readLocalAgentSessionFile(cloudSessionId) {
 }
 function writeLocalAgentSessionFile(cloudSessionId, patch) {
   try {
-    const dir = LOCAL_AGENT_SESSION_DIR;
-    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
-    const p = localAgentSessionFilePath(cloudSessionId);
+    const db = getCliDatabase();
+    const key = sessionKeyForCloudSessionId(cloudSessionId);
     const prev = readLocalAgentSessionFile(cloudSessionId);
     const next = {
       v: 1,
@@ -34397,7 +34720,17 @@ function writeLocalAgentSessionFile(cloudSessionId, patch) {
       configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs10.writeFileSync(p, JSON.stringify(next, null, 2), "utf8");
+    const configJson = next.configOptions != null ? JSON.stringify(next.configOptions) : null;
+    db.run(
+      `INSERT INTO agent_session (session_key, acp_session_id, backend_agent_type, config_options_json, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session_key) DO UPDATE SET
+         acp_session_id = excluded.acp_session_id,
+         backend_agent_type = excluded.backend_agent_type,
+         config_options_json = excluded.config_options_json,
+         updated_at = excluded.updated_at`,
+      [key, next.acpSessionId, next.backendAgentType, configJson, next.updatedAt]
+    );
   } catch {
   }
 }
@@ -34421,7 +34754,7 @@ async function ensureAcpClient(options) {
   if (state.acpStartPromise && !state.acpHandle) {
     await state.acpStartPromise;
   }
-  if (state.acpHandle && state.lastAcpCwd != null && path13.resolve(state.lastAcpCwd) !== path13.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path19.resolve(state.lastAcpCwd) !== path19.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -34456,7 +34789,7 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs11.statSync(targetSessionParentPath);
+      const st = fs16.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -34703,12 +35036,12 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path20 from "node:path";
-import os5 from "node:os";
+import * as path26 from "node:path";
+import os8 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs13 from "node:fs";
-import * as path15 from "node:path";
+import * as fs18 from "node:fs";
+import * as path21 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -34717,12 +35050,12 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs12 from "node:fs";
-import * as path14 from "node:path";
-import os4 from "node:os";
+import * as fs17 from "node:fs";
+import * as path20 from "node:path";
+import os7 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path14.join(os4.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path20.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -34734,8 +35067,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs12.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs12.readFileSync(p, "utf8"));
+    if (!fs17.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs17.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -34743,24 +35076,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path14.dirname(defaultWorktreeLayoutPath());
-    fs12.mkdirSync(dir, { recursive: true });
-    fs12.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path20.dirname(defaultWorktreeLayoutPath());
+    fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path14.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path20.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path14.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path14.resolve(e.absolutePath) === norm);
+  const norm = path20.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path20.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path14.resolve(bridgeRootPath2);
+  const norm = path20.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -34777,10 +35110,10 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2 } = options;
-  const bridgeResolved = path15.resolve(bridgeRoot);
+  const bridgeResolved = path21.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path15.join(worktreesRootPath, cwdKey);
-  const sessionDir = path15.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path21.join(worktreesRootPath, cwdKey);
+  const sessionDir = path21.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -34788,14 +35121,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs13.mkdirSync(sessionDir, { recursive: true });
+  fs18.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path15.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path15.isAbsolute(rel)) continue;
+    let rel = path21.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path21.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = relNorm === "." ? sessionDir : path15.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path21.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs13.mkdirSync(path15.dirname(wtPath), { recursive: true });
+      fs18.mkdirSync(path21.dirname(wtPath), { recursive: true });
     }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
@@ -34837,23 +35170,23 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs16 from "node:fs";
+import * as fs21 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs15 from "node:fs";
+import * as fs20 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
-import * as fs14 from "node:fs";
-import * as path16 from "node:path";
+import * as fs19 from "node:fs";
+import * as path22 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path16.join(wt, ".git");
-  if (!fs14.existsSync(gitDirFile) || !fs14.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs14.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path22.join(wt, ".git");
+  if (!fs19.existsSync(gitDirFile) || !fs19.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs19.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path16.resolve(wt, m[1].trim());
-  const gitDir = path16.dirname(path16.dirname(gitWorktreePath));
-  return path16.dirname(gitDir);
+  const gitWorktreePath = path22.resolve(wt, m[1].trim());
+  const gitDir = path22.dirname(path22.dirname(gitWorktreePath));
+  return path22.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -34862,7 +35195,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs15.rmSync(worktreePath, { recursive: true, force: true });
+    fs20.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -34875,7 +35208,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs16.rmSync(wt, { recursive: true, force: true });
+        fs21.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -35095,7 +35428,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path18 from "node:path";
+import * as path24 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -35215,8 +35548,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
-import * as fs18 from "node:fs";
-import * as path17 from "node:path";
+import * as fs23 from "node:fs";
+import * as path23 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -35240,7 +35573,7 @@ async function countTextFileLines(filePath) {
 }
 
 // src/git/working-directory/changes/hydrate-patch.ts
-import * as fs17 from "node:fs";
+import * as fs22 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;
@@ -35255,7 +35588,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs17.promises.readFile(filePath, "utf8");
+    const raw = await fs22.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -35390,7 +35723,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path17.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path23.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -35403,7 +35736,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs18.promises.stat(repoFilePath);
+          const st = await fs23.promises.stat(repoFilePath);
           if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
@@ -35429,7 +35762,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const filePath = path17.join(repoGitCwd, pathInRepo);
+    const filePath = path23.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
@@ -35445,8 +35778,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path18.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path18.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path24.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path24.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -35459,7 +35792,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (const target of options.commitTargetPaths) {
-    const t = path18.resolve(target);
+    const t = path24.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
     let branch = "HEAD";
@@ -35472,8 +35805,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path18.dirname(t) : t;
-      const relNorm = path18.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path24.dirname(t) : t;
+      const relNorm = path24.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -35482,8 +35815,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path18.relative(bridgeRoot, path18.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path18.basename(path18.resolve(top)) : rel;
+      const rel = path24.relative(bridgeRoot, path24.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path24.basename(path24.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -35548,11 +35881,11 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as fs24 from "node:fs";
+import * as path25 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs19.existsSync(path19.join(dirPath, ".git"));
+    return fs24.existsSync(path25.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -35561,23 +35894,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path19.resolve(dir));
+      out.push(path25.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs19.readdirSync(dir, { withFileTypes: true });
+      entries = fs24.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path19.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path19.resolve(rootPath));
+  walk(path25.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -35586,16 +35919,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs19.readdirSync(dir, { withFileTypes: true });
+      entries = fs24.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path19.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path19.resolve(full));
+        if (isGitDir(full)) out.push(path25.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -35607,14 +35940,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs19.statSync(sessionDir);
+    st = fs24.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path19.resolve(sessionDir);
+  const abs = path25.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -35624,20 +35957,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path19.resolve(checkoutPath);
+  const hintR = path25.resolve(checkoutPath);
   let best = null;
-  let cur = path19.dirname(hintR);
+  let cur = path25.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path19.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path19.resolve(paths[0]);
+    if (paths.some((p) => path25.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path25.resolve(paths[0]);
       best = {
-        sessionParentPath: path19.resolve(isolated),
-        workingTreeRelRoot: path19.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path19.resolve(p))
+        sessionParentPath: path25.resolve(isolated),
+        workingTreeRelRoot: path25.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path25.resolve(p))
       };
     }
-    const next = path19.dirname(cur);
+    const next = path25.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -35645,33 +35978,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs19.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs24.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs19.readdirSync(worktreesRootPath)) {
+    for (const name of fs24.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path19.join(worktreesRootPath, name);
-      if (!fs19.statSync(p).isDirectory()) continue;
+      const p = path25.join(worktreesRootPath, name);
+      if (!fs24.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path19.join(worktreesRootPath, key);
-    if (!fs19.existsSync(layoutRoot) || !fs19.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path19.join(layoutRoot, sessionId);
+    const layoutRoot = path25.join(worktreesRootPath, key);
+    if (!fs24.existsSync(layoutRoot) || !fs24.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path25.join(layoutRoot, sessionId);
     const nested = tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacyPaths = collectWorktreeRootsNamed(layoutRoot, sessionId, 24);
     if (legacyPaths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path25.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path19.resolve(isolated),
-        workingTreeRelRoot: path19.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
+        sessionParentPath: path25.resolve(isolated),
+        workingTreeRelRoot: path25.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
       };
     }
   }
@@ -35680,12 +36013,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path19.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path19.join(hint, sid));
+  const hint = path25.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path25.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path19.basename(hint) === sid && isGitDir(hint)) {
+    if (path25.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -35693,24 +36026,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path19.basename(hint) === sid && isGitDir(hint)) {
+  if (path25.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs19.statSync(hint);
+    st = fs24.statSync(hint);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const legacyPaths = collectWorktreeRootsNamed(hint, sid, 24);
   if (legacyPaths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path25.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path19.resolve(isolated),
+    sessionParentPath: path25.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
   };
 }
 
@@ -35733,10 +36066,10 @@ var SessionWorktreeManager = class {
     this.layout = loadWorktreeLayout();
   }
   rememberSessionWorktrees(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path20.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path26.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path20.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path20.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path26.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path26.resolve(binding.workingTreeRelRoot));
   }
   sessionParentPathAfterRemember(sessionId) {
     return this.sessionParentPathBySession.get(sessionId);
@@ -35753,7 +36086,7 @@ var SessionWorktreeManager = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path20.resolve(parent) !== path20.resolve(relRoot);
+    return path26.resolve(parent) !== path26.resolve(relRoot);
   }
   /**
    * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
@@ -35762,7 +36095,7 @@ var SessionWorktreeManager = class {
     if (!sessionId) return null;
     const sid = sessionId.trim();
     const cached2 = this.sessionParentPathBySession.get(sid);
-    if (cached2) return path20.resolve(cached2);
+    if (cached2) return path26.resolve(cached2);
     const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
     if (!paths?.length) return null;
     return resolveIsolatedSessionParentPathFromCheckouts(paths);
@@ -35776,7 +36109,7 @@ var SessionWorktreeManager = class {
     const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const resolved = path20.resolve(parentPathRaw);
+      const resolved = path26.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
         const diskFirst = this.tryDiscoverFromDisk(sid);
         if (diskFirst) {
@@ -35795,7 +36128,7 @@ var SessionWorktreeManager = class {
             this.rememberSessionWorktrees(sid, tryRoot);
             return this.sessionParentPathAfterRemember(sid);
           }
-          const next = path20.dirname(cur);
+          const next = path26.dirname(cur);
           if (next === cur) break;
           cur = next;
         }
@@ -35948,15 +36281,22 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootPath() {
-  return path20.join(os5.homedir(), ".buildautomaton", "worktrees");
+  return path26.join(os8.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
+import path31 from "node:path";
+
+// src/files/index/paths.ts
 import path27 from "node:path";
+import crypto2 from "node:crypto";
+function getCwdHashForFileIndex(resolvedCwd) {
+  return crypto2.createHash("sha256").update(path27.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+}
 
 // src/files/index/build-file-index.ts
-import path24 from "node:path";
+import path29 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
@@ -35964,47 +36304,12 @@ function yieldToEventLoop() {
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs20 from "node:fs";
-import path22 from "node:path";
-
-// src/files/index/constants.ts
-import path21 from "node:path";
-import os6 from "node:os";
-var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path21.join(os6.homedir(), ".buildautomaton");
-var INDEX_HASH_LEN = 16;
-var INDEX_VERSION = 2;
-var INDEX_LOG_PREFIX = "[file-index]";
-
-// src/files/index/walk-workspace-tree.ts
-function walkWorkspaceTreeSync(dir, baseDir, out) {
-  let names;
-  try {
-    names = fs20.readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const name of names) {
-    if (name.startsWith(".")) continue;
-    const full = path22.join(dir, name);
-    let stat3;
-    try {
-      stat3 = fs20.statSync(full);
-    } catch {
-      continue;
-    }
-    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
-    if (stat3.isDirectory()) {
-      walkWorkspaceTreeSync(full, baseDir, out);
-    } else if (stat3.isFile()) {
-      out.push(relative5);
-    }
-  }
-}
+import fs25 from "node:fs";
+import path28 from "node:path";
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs20.promises.readdir(dir);
+    names = await fs25.promises.readdir(dir);
   } catch {
     return;
   }
@@ -36014,14 +36319,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path22.join(dir, name);
+    const full = path28.join(dir, name);
     let stat3;
     try {
-      stat3 = await fs20.promises.stat(full);
+      stat3 = await fs25.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path28.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat3.isFile()) {
@@ -36033,205 +36338,124 @@ function createWalkYieldState() {
   return { n: 0 };
 }
 
-// src/files/index/trigram-utils.ts
-function getTrigrams(s) {
-  const lower = s.toLowerCase();
-  const out = [];
-  for (let i = 0; i <= lower.length - 3; i++) {
-    out.push(lower.slice(i, i + 3));
-  }
-  return out;
-}
-function binarySearch(arr, x) {
-  let lo = 0;
-  let hi = arr.length - 1;
-  while (lo <= hi) {
-    const mid = lo + hi >>> 1;
-    if (arr[mid] < x) lo = mid + 1;
-    else if (arr[mid] > x) hi = mid - 1;
-    else return mid;
-  }
-  return -1;
-}
-function intersectSortedTrigramSets(arrays) {
-  if (arrays.length === 0) return [];
-  if (arrays.length === 1) return arrays[0];
-  const byLength = arrays.slice().sort((a, b) => a.length - b.length);
-  const smallest = byLength[0];
-  const rest = byLength.slice(1);
-  const result = [];
-  for (const idx of smallest) {
-    if (rest.every((arr) => binarySearch(arr, idx) >= 0)) {
-      result.push(idx);
-    }
-  }
-  return result;
-}
-
-// src/files/index/build-trigram-map.ts
-function buildTrigramMapForPaths(paths) {
-  const trigramIndex = {};
-  for (let i = 0; i < paths.length; i++) {
-    const trigrams = getTrigrams(paths[i]);
-    const seen = /* @__PURE__ */ new Set();
-    for (const tri of trigrams) {
-      if (seen.has(tri)) continue;
-      seen.add(tri);
-      if (!trigramIndex[tri]) trigramIndex[tri] = [];
-      trigramIndex[tri].push(i);
-    }
-  }
-  return trigramIndex;
+// src/files/index/file-index-sqlite-lock.ts
+import fs26 from "node:fs";
+function isSqliteCorruptError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
 }
-async function buildTrigramMapForPathsAsync(paths) {
-  const trigramIndex = {};
-  for (let i = 0; i < paths.length; i++) {
-    if (i > 0 && i % INDEX_WORK_YIELD_EVERY === 0) {
-      await yieldToEventLoop();
-    }
-    const trigrams = getTrigrams(paths[i]);
-    const seen = /* @__PURE__ */ new Set();
-    for (const tri of trigrams) {
-      if (seen.has(tri)) continue;
-      seen.add(tri);
-      if (!trigramIndex[tri]) trigramIndex[tri] = [];
-      trigramIndex[tri].push(i);
+var chain = Promise.resolve();
+function withFileIndexSqliteLock(fn) {
+  const run = async () => {
+    try {
+      return await Promise.resolve(fn());
+    } catch (e) {
+      if (!isSqliteCorruptError(e)) throw e;
+      closeAllCliSqliteConnections();
+      try {
+        fs26.unlinkSync(getCliSqlitePath());
+      } catch {
+      }
+      chain = Promise.resolve();
+      return await Promise.resolve(fn());
     }
-  }
-  return trigramIndex;
-}
-
-// src/files/index/write-index-file.ts
-import fs21 from "node:fs";
-
-// src/files/index/paths.ts
-import path23 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 path23.join(INDEX_DIR, `.file-index-${hash}.json`);
-}
-
-// src/files/index/write-index-file.ts
-function writeIndexFileSync(resolvedCwd, data) {
-  const indexPath = getIndexPathForCwd(resolvedCwd);
-  try {
-    if (!fs21.existsSync(INDEX_DIR)) fs21.mkdirSync(INDEX_DIR, { recursive: true });
-    fs21.writeFileSync(indexPath, JSON.stringify(data), "utf8");
-  } catch (e) {
-    console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
-  }
-}
-async function writeIndexFileAsync(resolvedCwd, data) {
-  const indexPath = getIndexPathForCwd(resolvedCwd);
-  try {
-    await fs21.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs21.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
-  } catch (e) {
-    console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
-  }
-}
-function makeTrigramIndexData(paths, trigramIndex) {
-  return { version: INDEX_VERSION, paths, trigramIndex };
+  };
+  const next = chain.then(run);
+  chain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
 }
 
 // src/files/index/build-file-index.ts
 function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
-function buildFileIndex(cwd) {
-  const resolved = path24.resolve(cwd);
-  const paths = [];
-  walkWorkspaceTreeSync(resolved, resolved, paths);
-  sortPaths(paths);
-  const trigramIndex = buildTrigramMapForPaths(paths);
-  const data = makeTrigramIndexData(paths, trigramIndex);
-  writeIndexFileSync(resolved, data);
-  return data;
-}
-async function buildFileIndexAsync(cwd) {
-  const resolved = path24.resolve(cwd);
-  const paths = [];
-  await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
-  await yieldToEventLoop();
-  sortPaths(paths);
-  const trigramIndex = await buildTrigramMapForPathsAsync(paths);
-  const data = makeTrigramIndexData(paths, trigramIndex);
-  await writeIndexFileAsync(resolved, data);
-  return data;
-}
-
-// src/files/index/load-file-index.ts
-import fs22 from "node:fs";
-import path25 from "node:path";
-function loadFileIndex(cwd) {
-  const resolved = path25.resolve(cwd);
-  const indexPath = getIndexPathForCwd(resolved);
+function persistPathsToSqlite(resolved, paths) {
+  const db = getCliDatabase();
+  const h = getCwdHashForFileIndex(resolved);
+  db.run("BEGIN IMMEDIATE");
   try {
-    const raw = fs22.readFileSync(indexPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
-      const obj = parsed;
-      if (obj.version === INDEX_VERSION && obj.trigramIndex && typeof obj.trigramIndex === "object") {
-        return obj;
+    db.run("DELETE FROM file_index_path WHERE cwd_hash = ?", [h]);
+    const ins = db.prepare("INSERT INTO file_index_path (cwd_hash, path) VALUES (?, ?)");
+    try {
+      for (const rel of paths) {
+        ins.run([h, rel]);
       }
-      return buildFileIndex(resolved);
+    } finally {
+      ins.finalize();
     }
-    if (Array.isArray(parsed) && parsed.every((p) => typeof p === "string")) {
-      return buildFileIndex(resolved);
+    db.run("COMMIT");
+  } catch (e) {
+    try {
+      db.run("ROLLBACK");
+    } catch {
     }
-    return null;
-  } catch {
-    return null;
+    throw e;
   }
 }
+async function buildFileIndexAsync(cwd) {
+  return withFileIndexSqliteLock(async () => {
+    const resolved = path29.resolve(cwd);
+    const paths = [];
+    await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
+    await yieldToEventLoop();
+    sortPaths(paths);
+    persistPathsToSqlite(resolved, paths);
+    return { pathCount: paths.length };
+  });
+}
 
 // src/files/index/ensure-file-index.ts
-import path26 from "node:path";
-async function ensureFileIndexAsync(cwd) {
-  const resolved = path26.resolve(cwd);
-  const cached2 = loadFileIndex(resolved);
-  if (cached2 !== null) return { data: cached2, fromCache: true };
-  const data = await buildFileIndexAsync(resolved);
-  return { data, fromCache: false };
-}
+import path30 from "node:path";
 
 // src/files/index/search-file-index.ts
-function candidatePathIndices(index, q) {
-  const { paths, trigramIndex } = index;
-  if (q.length < 3) {
-    return paths.map((_, i) => i).filter((i) => paths[i].toLowerCase().includes(q));
-  }
-  const trigrams = getTrigrams(q);
-  if (trigrams.length === 0) {
-    return paths.map((_, i) => i).filter((i) => paths[i].toLowerCase().includes(q));
-  }
-  const arrays = trigrams.map((tri) => trigramIndex[tri]).filter((arr) => arr != null && arr.length > 0);
-  if (arrays.length === 0) return [];
-  return intersectSortedTrigramSets(arrays);
-}
-async function searchFileIndexAsync(index, query, limit = 100) {
-  await yieldToEventLoop();
+function escapeLikePattern(fragment) {
+  return fragment.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function bridgeFileIndexIsPopulated(resolvedCwd) {
+  const db = getCliDatabase();
+  const h = getCwdHashForFileIndex(resolvedCwd);
+  const row = db.get("SELECT 1 as ok FROM file_index_path WHERE cwd_hash = ? LIMIT 1", [h]);
+  return row != null;
+}
+function bridgeFileIndexPathCount(resolvedCwd) {
+  const db = getCliDatabase();
+  const h = getCwdHashForFileIndex(resolvedCwd);
+  const row = db.get("SELECT COUNT(*) as c FROM file_index_path WHERE cwd_hash = ?", [h]);
+  const c = row?.c ?? 0;
+  return Number(c);
+}
+function searchBridgeFilePaths(resolvedCwd, query, limit = 100) {
   const q = query.trim().toLowerCase();
   if (!q) return [];
-  const { paths } = index;
-  const candidateIndices = candidatePathIndices(index, q);
-  const out = [];
-  let n = 0;
-  for (const i of candidateIndices) {
-    if (n > 0 && n % INDEX_WORK_YIELD_EVERY === 0) {
-      await yieldToEventLoop();
-    }
-    const p = paths[i];
-    if (p.toLowerCase().includes(q)) {
-      out.push(p);
-      if (out.length >= limit) break;
-    }
-    n++;
-  }
+  const db = getCliDatabase();
+  const h = getCwdHashForFileIndex(resolvedCwd);
+  const pattern = `%${escapeLikePattern(q)}%`;
+  const lim = Math.max(0, Math.min(1e4, Math.floor(limit)));
+  const rows = db.all(
+    `SELECT path FROM file_index_path WHERE cwd_hash = ? AND lower(path) LIKE ? ESCAPE '\\' LIMIT ?`,
+    [h, pattern, lim]
+  );
+  return rows.map((r) => String(r.path));
+}
+async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
+  await yieldToEventLoop();
+  const out = searchBridgeFilePaths(resolvedCwd, query, limit);
+  if (out.length >= INDEX_WORK_YIELD_EVERY) await yieldToEventLoop();
   return out;
 }
 
+// src/files/index/ensure-file-index.ts
+async function ensureFileIndexAsync(cwd) {
+  const resolved = path30.resolve(cwd);
+  if (bridgeFileIndexIsPopulated(resolved)) {
+    return { fromCache: true, pathCount: bridgeFileIndexPathCount(resolved) };
+  }
+  return { ...await buildFileIndexAsync(resolved), fromCache: false };
+}
+
 // src/files/watch-file-index.ts
 var DEBOUNCE_MS = 900;
 function shouldIgnoreRelative(rel) {
@@ -36272,7 +36496,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path27.resolve(cwd);
+  const resolved = path31.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -36300,7 +36524,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path35 from "node:path";
+import * as path39 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -36344,7 +36568,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs23 from "node:fs";
+import fs27 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -36380,7 +36604,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs23.readFile(d.mergedLogPath, (err, buf) => {
+      fs27.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));
@@ -36418,7 +36642,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs23.readFile(mergedPath, (err, buf) => {
+      fs27.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -36520,13 +36744,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs24 from "node:fs";
+import fs28 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs24.rmSync(dir, { recursive: true, force: true });
+    fs28.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -36534,7 +36758,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs24.openSync(devPath, "r");
+    cachedDevNullReadFd = fs28.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -36608,15 +36832,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn6 } from "node:child_process";
-import fs25 from "node:fs";
+import fs29 from "node:fs";
 import { tmpdir } from "node:os";
-import path28 from "node:path";
+import path32 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
+  const tmpRoot = fs29.mkdtempSync(path32.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path32.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs25.openSync(logPath, "a");
+    logFd = fs29.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -36635,7 +36859,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn6("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs25.closeSync(logFd);
+    fs29.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -36644,7 +36868,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs25.closeSync(logFd);
+      fs29.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -36655,22 +36879,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs26 from "node:fs";
+import fs30 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path29 from "node:path";
+import path33 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path29.join(tmpRoot, "combined.log");
-  const innerPath = path29.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path29.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs30.mkdtempSync(path33.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path33.join(tmpRoot, "combined.log");
+  const innerPath = path33.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path33.join(tmpRoot, "_run.sh");
   try {
-    fs26.writeFileSync(innerPath, `#!/bin/sh
+    fs30.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs26.writeFileSync(
+    fs30.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -36696,13 +36920,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path29.join(tmpRoot, "combined.log");
-  const runnerPath = path29.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs30.mkdtempSync(path33.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path33.join(tmpRoot, "combined.log");
+  const runnerPath = path33.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs26.writeFileSync(
+    fs30.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -37639,30 +37863,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs27 from "node:fs";
-import path30 from "node:path";
+import fs31 from "node:fs";
+import path34 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 = path30.join(cwd, rel);
-    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
+    const base = path34.join(cwd, rel);
+    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs27.readdirSync(base);
+      entries = fs31.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path30.join(base, name);
+      const dir = path34.join(base, name);
       try {
-        if (!fs27.statSync(dir).isDirectory()) continue;
+        if (!fs31.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path30.join(dir, "SKILL.md");
-      if (!fs27.existsSync(skillMd)) continue;
+      const skillMd = path34.join(dir, "SKILL.md");
+      if (!fs31.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -37674,23 +37898,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path30.join(cwd, rel);
-    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
+    const base = path34.join(cwd, rel);
+    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs27.readdirSync(base);
+      entries = fs31.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path30.join(base, name);
+      const dir = path34.join(base, name);
       try {
-        if (!fs27.statSync(dir).isDirectory()) continue;
+        if (!fs31.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs27.existsSync(path30.join(dir, "SKILL.md"))) continue;
+      if (!fs31.existsSync(path34.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -37884,7 +38108,7 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/prompt-turn-queue/runner.ts
-import fs30 from "node:fs";
+import fs32 from "node:fs";
 
 // src/prompt-turn-queue/client-report.ts
 function sendPromptQueueClientReport(ws, queues) {
@@ -37893,32 +38117,6 @@ function sendPromptQueueClientReport(ws, queues) {
   return true;
 }
 
-// src/prompt-turn-queue/disk-store.ts
-import fs29 from "node:fs";
-
-// src/prompt-turn-queue/paths.ts
-import crypto3 from "node:crypto";
-import fs28 from "node:fs";
-import path31 from "node:path";
-import os7 from "node:os";
-var QUEUE_KEY_HEX_64 = /^[a-f0-9]{64}$/i;
-function queueStateFileSlug(queueKey) {
-  if (QUEUE_KEY_HEX_64.test(queueKey)) return queueKey.toLowerCase();
-  return crypto3.createHash("sha256").update(queueKey, "utf8").digest("hex");
-}
-function getPromptQueuesDirectory() {
-  const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
-  if (override) return path31.resolve(override);
-  return path31.join(os7.homedir(), ".buildautomaton", "queues");
-}
-function ensurePromptQueuesDirectory() {
-  const dir = getPromptQueuesDirectory();
-  if (!fs28.existsSync(dir)) fs28.mkdirSync(dir, { recursive: true });
-}
-function queueStateFilePath(queueKey) {
-  return path31.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
-}
-
 // src/prompt-turn-queue/disk-store.ts
 var MERGEABLE_SERVER_STATES = /* @__PURE__ */ new Set([
   "queued",
@@ -37928,28 +38126,27 @@ var MERGEABLE_SERVER_STATES = /* @__PURE__ */ new Set([
   "stopping",
   "discarded"
 ]);
-function parsePersistedQueueFile(raw) {
-  try {
-    const o = JSON.parse(raw);
-    const queueKey = typeof o.queueKey === "string" ? o.queueKey : typeof o.queueKeyHash === "string" ? o.queueKeyHash : null;
-    if (!queueKey || typeof o.updatedAt !== "string" || !Array.isArray(o.turns)) return null;
-    return { queueKey, updatedAt: o.updatedAt, turns: o.turns };
-  } catch {
-    return null;
-  }
-}
 function readPersistedQueue(queueKey) {
-  const p = queueStateFilePath(queueKey);
+  const db = getCliDatabase();
+  const row = db.get("SELECT queue_key, updated_at, turns_json FROM prompt_queue WHERE queue_key = ?", [
+    queueKey
+  ]);
+  if (!row) return null;
   try {
-    return parsePersistedQueueFile(fs29.readFileSync(p, "utf8"));
+    const turns = JSON.parse(row.turns_json);
+    if (!Array.isArray(turns)) return null;
+    return { queueKey: row.queue_key, updatedAt: row.updated_at, turns };
   } catch {
     return null;
   }
 }
 function writePersistedQueue(file2) {
-  ensurePromptQueuesDirectory();
-  const p = queueStateFilePath(file2.queueKey);
-  fs29.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
+  const db = getCliDatabase();
+  db.run(
+    `INSERT INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)
+     ON CONFLICT(queue_key) DO UPDATE SET updated_at = excluded.updated_at, turns_json = excluded.turns_json`,
+    [file2.queueKey, file2.updatedAt, JSON.stringify(file2.turns)]
+  );
 }
 function mergeServerQueueSnapshot(queueKey, serverTurns) {
   const prev = readPersistedQueue(queueKey);
@@ -38007,7 +38204,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const tid = typeof pl.snapshotRevertTurnId === "string" && pl.snapshotRevertTurnId.trim() !== "" ? pl.snapshotRevertTurnId.trim() : next.turnId;
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
-  if (!fs30.existsSync(file2)) {
+  if (!fs32.existsSync(file2)) {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
     );
@@ -38231,9 +38428,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path37 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path37) continue;
-    const row = { path: path37 };
+    const path41 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path41) continue;
+    const row = { path: path41 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -38450,8 +38647,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path37, body) {
-  const url2 = `http://127.0.0.1:${port}${path37}`;
+async function requestPreviewApi(port, secret, method, path41, body) {
+  const url2 = `http://127.0.0.1:${port}${path41}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -38463,7 +38660,7 @@ async function requestPreviewApi(port, secret, method, path37, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path37}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path41}: ${res.status}`);
   }
   return data;
 }
@@ -38628,15 +38825,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs31 from "node:fs";
-import path33 from "node:path";
+import fs33 from "node:fs";
+import path36 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path32 from "node:path";
+import path35 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path32.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path32.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path32.sep) && resolved !== cwd) {
+  const normalized = path35.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path35.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path35.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -38650,7 +38847,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs31.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs33.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -38658,12 +38855,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path33.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path33.join(resolved, d.name);
+      const entryPath = path36.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path36.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs31.promises.stat(fullPath);
+          const targetStat = await fs33.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -38688,25 +38885,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs32 from "node:fs";
+import fs34 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
   const resolved = ensureUnderCwd(relativePath, getBridgeRoot());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs32.realpathSync(resolved);
+    real = fs34.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat3 = fs32.statSync(real);
+  const stat3 = fs34.statSync(real);
   if (!stat3.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 = fs32.statSync(filePath).size;
-  const fd = fs32.openSync(filePath, "r");
+  const fileSize = fs34.statSync(filePath).size;
+  const fd = fs34.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -38719,7 +38916,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs32.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs34.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -38854,7 +39051,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs32.closeSync(fd);
+    fs34.closeSync(fd);
   }
 }
 function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -38865,8 +39062,8 @@ function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat3 = fs32.statSync(result);
-    const raw = fs32.readFileSync(result, "utf8");
+    const stat3 = fs34.statSync(result);
+    const raw = fs34.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat3.size };
   } catch (err) {
@@ -38879,14 +39076,14 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
 }
 
 // src/files/handle-file-browser-search.ts
+import path37 from "node:path";
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket, e2ee) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const cwd = getBridgeRoot();
-    const index = loadFileIndex(cwd);
-    if (index === null) {
+    const cwd = path37.resolve(getBridgeRoot());
+    if (!bridgeFileIndexIsPopulated(cwd)) {
       const payload2 = {
         type: "file_browser_search_response",
         id: msg.id,
@@ -38896,7 +39093,7 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
       sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload2, ["paths"]) : payload2);
       return;
     }
-    const results = await searchFileIndexAsync(index, q, SEARCH_LIMIT);
+    const results = await searchBridgeFilePathsAsync(cwd, q, SEARCH_LIMIT);
     const payload = {
       type: "file_browser_search_response",
       id: msg.id,
@@ -38984,8 +39181,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs33 from "node:fs";
-import path34 from "node:path";
+import fs35 from "node:fs";
+import path38 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -38996,15 +39193,15 @@ 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 = path34.join(cwd, targetDir, item.skillName);
+      const skillDir = path38.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path34.join(skillDir, f.path);
-        fs33.mkdirSync(path34.dirname(dest), { recursive: true });
+        const dest = path38.join(skillDir, f.path);
+        fs35.mkdirSync(path38.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs33.writeFileSync(dest, f.text, "utf8");
+          fs35.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs33.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs35.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -39154,7 +39351,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs34 from "node:fs";
+import * as fs36 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -39166,7 +39363,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs34.existsSync(file2)) {
+    if (!fs36.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -39582,6 +39779,7 @@ async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   const logFn = options.log ?? log;
+  getCliDatabase({ logLegacyMigration: logFn });
   const tokens = {
     accessToken: options.authToken,
     refreshToken: options.refreshToken
@@ -39647,8 +39845,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path35.resolve(getBridgeRoot()),
-    worktreesRootPath: path35.resolve(worktreesRootPath)
+    bridgeRootPath: path39.resolve(getBridgeRoot()),
+    worktreesRootPath: path39.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -39886,9 +40084,9 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path36.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path40.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs35.statSync(resolvedBridgeRoot);
+      const st = fs37.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -39908,7 +40106,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path36.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path40.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {