@buildautomaton/cli 0.1.27 → 0.1.29

package/dist/index.js

@@ -4065,8 +4065,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path35, errorMaps, issueData } = params;
-      const fullPath = [...path35, ...issueData.path || []];
+      const { data, path: path39, errorMaps, issueData } = params;
+      const fullPath = [...path39, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4374,11 +4374,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path35, key) {
+      constructor(parent, value, path39, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path35;
+        this._path = path39;
         this._key = key;
       }
       get path() {
@@ -7993,10 +7993,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path35) {
-  if (!path35)
+function getElementAtPath(obj, path39) {
+  if (!path39)
     return obj;
-  return path35.reduce((acc, key) => acc?.[key], obj);
+  return path39.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8245,11 +8245,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path35, issues) {
+function prefixIssues(path39, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path35);
+    iss.path.unshift(path39);
     return iss;
   });
 }
@@ -8438,7 +8438,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path35 = []) => {
+  const processError = (error41, path39 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8448,7 +8448,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path35, ...issue2.path];
+        const fullpath = [...path39, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8478,9 +8478,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path35) {
+function toDotPath(path39) {
   const segs = [];
-  for (const seg of path35) {
+  for (const seg of path39) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21669,7 +21669,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;
@@ -21717,7 +21717,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;
         }
@@ -21963,10 +21963,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path35, isFile, isDirectory) {
-      log2(`checking %s`, path35);
+    function check2(path39, isFile, isDirectory) {
+      log2(`checking %s`, path39);
       try {
-        const stat2 = fs_1.statSync(path35);
+        const stat2 = fs_1.statSync(path39);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -21986,8 +21986,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path35, type = exports.READABLE) {
-      return check2(path35, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path39, type = exports.READABLE) {
+      return check2(path39, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22792,9 +22792,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 path35 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path35) continue;
-    rows.push({ path: path35, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path39 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path39) continue;
+    rows.push({ path: path39, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -23668,8 +23668,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path35, body) {
-  const url2 = `http://127.0.0.1:${port}${path35}`;
+async function requestPreviewApi(port, secret, method, path39, body) {
+  const url2 = `http://127.0.0.1:${port}${path39}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -23681,7 +23681,7 @@ async function requestPreviewApi(port, secret, method, path35, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path35}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path39}: ${res.status}`);
   }
   return data;
 }
@@ -23896,7 +23896,13 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.27".length > 0 ? "0.1.27" : "0.0.0-dev";
+var CLI_VERSION = "0.1.29".length > 0 ? "0.1.29" : "0.0.0-dev";
+
+// src/connection/heartbeat/constants.ts
+var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
+var BRIDGE_HEARTBEAT_SEQ_MAX = 2147483646;
+var BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT = 4;
+var BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX = 5;
 
 // ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
 import process7 from "node:process";
@@ -24876,14 +24882,18 @@ function runPendingAuth(options) {
   }
   function connect() {
     const url2 = buildPendingBridgeUrl(apiUrl, connectionId);
+    let pendingHbSeq = -1;
     ws = createWsBridge({
       url: url2,
       onOpen: () => {
         clearQuietOnOpen();
+        pendingHbSeq = -1;
         sendWsMessage(ws, { type: "identify", role: "cli", cliVersion: CLI_VERSION });
         keepaliveInterval = setInterval(() => {
           if (resolved || !ws || ws.readyState !== 1) return;
-          sendWsMessage(ws, { type: "ping", timestamp: Date.now() });
+          pendingHbSeq = pendingHbSeq >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : pendingHbSeq + 1;
+          const hb = { t: "h", s: pendingHbSeq };
+          sendWsMessage(ws, hb);
         }, PENDING_KEEPALIVE_MS);
         if (browserFallback) {
           clearTimeout(browserFallback);
@@ -24946,6 +24956,321 @@ function runPendingAuth(options) {
   };
 }
 
+// src/sqlite/cli-database.ts
+import sqliteWasm from "node-sqlite3-wasm";
+
+// src/sqlite/cli-sqlite-paths.ts
+import fs7 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 (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+}
+
+// src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts
+import fs12 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 fs9 from "node:fs";
+import path9 from "node:path";
+
+// src/sqlite/legacy_migration/archive-to-old-version.ts
+import fs8 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);
+  fs8.mkdirSync(destDir, { recursive: true });
+  const base = path8.basename(sourcePath);
+  let dest = path8.join(destDir, base);
+  if (fs8.existsSync(dest)) {
+    const ext = path8.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    dest = path8.join(destDir, `${stem}-${Date.now()}${ext}`);
+  }
+  fs8.renameSync(sourcePath, dest);
+}
+
+// src/sqlite/legacy_migration/archive-file-index-json.ts
+function archiveLegacyFileIndexJsonFiles() {
+  try {
+    if (!fs9.existsSync(INDEX_DIR)) return;
+    for (const name of fs9.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 fs10 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 (!fs10.existsSync(LEGACY_AGENT_SESSION_DIR)) return;
+    const names = fs10.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 = fs10.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 fs11 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 (!fs11.existsSync(dir)) return;
+    for (const name of fs11.readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const full = path11.join(dir, name);
+      let raw;
+      try {
+        raw = fs11.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 (fs12.existsSync(INDEX_DIR)) {
+      for (const name of fs12.readdirSync(INDEX_DIR)) {
+        if (name.startsWith(".file-index-") && name.endsWith(".json")) return true;
+      }
+    }
+  } catch {
+  }
+  try {
+    if (fs12.existsSync(LEGACY_AGENT_SESSION_DIR)) {
+      if (fs12.readdirSync(LEGACY_AGENT_SESSION_DIR).some((n) => n.endsWith(".json"))) return true;
+    }
+  } catch {
+  }
+  try {
+    const dir = getPromptQueuesDirectory();
+    if (fs12.existsSync(dir) && fs12.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 as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function readCliSqliteMigrationSql(filename) {
+  const dir = dirname2(fileURLToPath2(import.meta.url));
+  const resolved = join(dir, "migrations", filename);
+  if (!existsSync(resolved)) {
+    throw new Error(`Missing CLI SQLite migration SQL: ${resolved}`);
+  }
+  return readFileSync2(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;
@@ -24989,20 +25314,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();
 }
@@ -25011,17 +25340,17 @@ function resolveSessionParentPathForAgentProcess(resolvedSessionParentPath) {
 import { execFile as execFile7 } from "node:child_process";
 import { readFile, stat } 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 fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs14 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 fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs13 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);
@@ -25060,8 +25389,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path35) {
-  return path35 instanceof String && cache.has(path35);
+function isPathSpec(path39) {
+  return path39 instanceof String && cache.has(path39);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -25150,8 +25479,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path35) {
-  return (0, import_file_exists.exists)(path35, import_file_exists.FOLDER);
+function folderExists(path39) {
+  return (0, import_file_exists.exists)(path39, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -25555,8 +25884,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path35) {
-      return /^\.(git)?$/.test(path35.trim());
+    parser(path39) {
+      return /^\.(git)?$/.test(path39.trim());
     }
   };
 }
@@ -25990,11 +26319,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path35, line, preview] = input.split(NULL);
-    paths.add(path35);
-    (results[path35] = results[path35] || []).push({
+    const [path39, line, preview] = input.split(NULL);
+    paths.add(path39);
+    (results[path39] = results[path39] || []).push({
       line: asNumber(line),
-      path: path35,
+      path: path39,
       preview
     });
   });
@@ -26759,14 +27088,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path35, text) {
+function parseInit(bare, path39, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path35, false, result[1]);
+    return new InitSummary(bare, path39, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path35, true, result[1]);
+    return new InitSummary(bare, path39, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -26777,7 +27106,7 @@ function parseInit(bare, path35, text) {
       break;
     }
   }
-  return new InitSummary(bare, path35, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path39, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -26786,9 +27115,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path35, existing, gitDir) {
+      constructor(bare, path39, existing, gitDir) {
         this.bare = bare;
-        this.path = path35;
+        this.path = path39;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -26800,7 +27129,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path35, customArgs) {
+function initTask(bare = false, path39, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -26809,7 +27138,7 @@ function initTask(bare = false, path35, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path35, text);
+      return parseInit(commands.includes("--bare"), path39, text);
     }
   };
 }
@@ -27625,12 +27954,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path35, index, working_dir) {
-        this.path = path35;
+      constructor(path39, index, working_dir) {
+        this.path = path39;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path35) || [null, path35, path35];
+          const detail = fromPathRegex.exec(path39) || [null, path39, path39];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -27661,14 +27990,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path35) {
+  function data(index, workingDir, path39) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path35);
+      handler(result, path39);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path35, index, workingDir));
+      result.files.push(new FileStatusSummary(path39, index, workingDir));
     }
   }
 }
@@ -27941,15 +28270,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) {
@@ -27977,9 +28306,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path35, write) {
+      hashObject(path39, write) {
         return this._runTask(
-          hashObjectTask(path35, write === true),
+          hashObjectTask(path39, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -28332,8 +28661,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path35 = input.trim().replace(/^["']|["']$/g, "");
-  return path35 && normalize2(path35);
+  const path39 = input.trim().replace(/^["']|["']$/g, "");
+  return path39 && normalize2(path39);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -28647,8 +28976,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path35) {
-  return subModuleTask(["add", repo, path35]);
+function addSubModuleTask(repo, path39) {
+  return subModuleTask(["add", repo, path39]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -28981,8 +29310,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path35, then) {
-      return this._runTask(addSubModuleTask2(repo, path35), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path39, then) {
+      return this._runTask(addSubModuleTask2(repo, path39), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -29626,20 +29955,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 = fs7.readdirSync(cwdResolved, { withFileTypes: true });
+    entries = fs13.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 });
@@ -29648,22 +29977,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 = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs13.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);
@@ -29679,7 +30008,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 {
@@ -29708,7 +30037,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 {
@@ -29716,7 +30045,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;
@@ -29737,7 +30066,7 @@ async function capturePreTurnSnapshot(options) {
   }
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs8.mkdirSync(dir, { recursive: true });
+    fs14.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -29746,9 +30075,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 {
-    fs8.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs14.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -29761,7 +30090,7 @@ async function capturePreTurnSnapshot(options) {
 async function applyPreTurnSnapshot(filePath, log2) {
   let data;
   try {
-    const raw = fs8.readFileSync(filePath, "utf8");
+    const raw = fs14.readFileSync(filePath, "utf8");
     data = JSON.parse(raw);
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -29784,7 +30113,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
@@ -29833,7 +30162,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 {
@@ -29847,7 +30176,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",
@@ -29869,9 +30198,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: path35, summary }) => {
+  const entries = params.rows.map(({ path: path39, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path35, summary: JSON.stringify(enc) };
+    return { path: path39, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -30208,8 +30537,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs10 from "node:fs";
-import * as path12 from "node:path";
+import * as fs15 from "node:fs";
+import * as path18 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -30711,20 +31040,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 path9 from "node:path";
+import * as path16 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path9.resolve(startDir),
+      cwd: path16.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path9.resolve(out) : null;
+    return out ? path16.resolve(out) : null;
   } catch {
     return null;
   }
@@ -30732,26 +31061,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 path10 from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path17 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedSessionParent = path10.resolve(sessionParentPath);
+  const normalizedSessionParent = path17.resolve(sessionParentPath);
   let resolvedPath = resolveSafePathUnderCwd(sessionParentPath, trimmed2);
   if (!resolvedPath) {
-    const candidate = path10.isAbsolute(trimmed2) ? path10.normalize(trimmed2) : path10.normalize(path10.resolve(normalizedSessionParent, trimmed2));
+    const candidate = path17.isAbsolute(trimmed2) ? path17.normalize(trimmed2) : path17.normalize(path17.resolve(normalizedSessionParent, trimmed2));
     const gitRoot2 = getGitRepoRootSync(sessionParentPath);
     if (!gitRoot2) return null;
-    const rel = path10.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path10.isAbsolute(rel)) return null;
+    const rel = path17.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path17.isAbsolute(rel)) return null;
     resolvedPath = candidate;
   }
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const relFromRoot = path10.relative(gitRoot, resolvedPath);
-    if (!relFromRoot.startsWith("..") && !path10.isAbsolute(relFromRoot)) {
-      return { resolvedPath, display: relFromRoot.split(path10.sep).join("/") };
+    const relFromRoot = path17.relative(gitRoot, resolvedPath);
+    if (!relFromRoot.startsWith("..") && !path17.isAbsolute(relFromRoot)) {
+      return { resolvedPath, display: relFromRoot.split(path17.sep).join("/") };
     }
   }
   return { resolvedPath, display: toDisplayPathRelativeToCwd(sessionParentPath, resolvedPath) };
@@ -30760,11 +31089,11 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath2 = path10.resolve(gitRoot, displayPath);
-    const rel = path10.relative(gitRoot, resolvedPath2);
-    if (!rel.startsWith("..") && !path10.isAbsolute(rel)) {
+    const resolvedPath2 = path17.resolve(gitRoot, displayPath);
+    const rel = path17.relative(gitRoot, resolvedPath2);
+    if (!rel.startsWith("..") && !path17.isAbsolute(rel)) {
       try {
-        return readFileSync3(resolvedPath2, "utf8");
+        return readFileSync4(resolvedPath2, "utf8");
       } catch {
       }
     }
@@ -30772,7 +31101,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
   if (!resolvedPath) return "";
   try {
-    return readFileSync3(resolvedPath, "utf8");
+    return readFileSync4(resolvedPath, "utf8");
   } catch {
     return "";
   }
@@ -30781,9 +31110,9 @@ function tryWorkspaceDisplayToPath(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath = path10.resolve(gitRoot, displayPath);
-    const rel = path10.relative(gitRoot, resolvedPath);
-    if (!rel.startsWith("..") && !path10.isAbsolute(rel)) return resolvedPath;
+    const resolvedPath = path17.resolve(gitRoot, displayPath);
+    const rel = path17.relative(gitRoot, resolvedPath);
+    if (!rel.startsWith("..") && !path17.isAbsolute(rel)) return resolvedPath;
   }
   return resolveSafePathUnderCwd(sessionParentPath, displayPath);
 }
@@ -30818,7 +31147,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 };
@@ -30918,7 +31247,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;
@@ -30928,7 +31257,7 @@ function normalizePathField(raw) {
   const t = raw.trim();
   if (t.startsWith("file://")) {
     try {
-      return fileURLToPath2(t);
+      return fileURLToPath3(t);
     } catch {
       return t;
     }
@@ -31386,29 +31715,34 @@ function buildAcpSessionBridgeHooks(opts) {
 }
 
 // src/agents/acp/local-agent-session-file.ts
-import fs9 from "node:fs";
-import os3 from "node:os";
-import path11 from "node:path";
-var LOCAL_AGENT_SESSION_DIR = path11.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 path11.join(LOCAL_AGENT_SESSION_DIR, `${safeFileSlug(cloudSessionId)}.json`);
-}
 function readLocalAgentSessionFile(cloudSessionId) {
   try {
-    const p = localAgentSessionFilePath(cloudSessionId);
-    const raw = fs9.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;
@@ -31416,9 +31750,8 @@ function readLocalAgentSessionFile(cloudSessionId) {
 }
 function writeLocalAgentSessionFile(cloudSessionId, patch) {
   try {
-    const dir = LOCAL_AGENT_SESSION_DIR;
-    if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
-    const p = localAgentSessionFilePath(cloudSessionId);
+    const db = getCliDatabase();
+    const key = sessionKeyForCloudSessionId(cloudSessionId);
     const prev = readLocalAgentSessionFile(cloudSessionId);
     const next = {
       v: 1,
@@ -31427,7 +31760,17 @@ function writeLocalAgentSessionFile(cloudSessionId, patch) {
       configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs9.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 {
   }
 }
@@ -31451,7 +31794,7 @@ async function ensureAcpClient(options) {
   if (state.acpStartPromise && !state.acpHandle) {
     await state.acpStartPromise;
   }
-  if (state.acpHandle && state.lastAcpCwd != null && path12.resolve(state.lastAcpCwd) !== path12.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path18.resolve(state.lastAcpCwd) !== path18.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -31486,7 +31829,7 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs10.statSync(targetSessionParentPath);
+      const st = fs15.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -31733,12 +32076,12 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path19 from "node:path";
-import os5 from "node:os";
+import * as path25 from "node:path";
+import os8 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs12 from "node:fs";
-import * as path14 from "node:path";
+import * as fs17 from "node:fs";
+import * as path20 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -31747,12 +32090,12 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
-import os4 from "node:os";
+import * as fs16 from "node:fs";
+import * as path19 from "node:path";
+import os7 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path13.join(os4.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path19.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -31764,8 +32107,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs11.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
+    if (!fs16.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs16.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -31773,24 +32116,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path13.dirname(defaultWorktreeLayoutPath());
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path19.dirname(defaultWorktreeLayoutPath());
+    fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path13.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path19.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path13.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path13.resolve(e.absolutePath) === norm);
+  const norm = path19.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path19.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path13.resolve(bridgeRootPath2);
+  const norm = path19.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -31807,10 +32150,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 = path14.resolve(bridgeRoot);
+  const bridgeResolved = path20.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path14.join(worktreesRootPath, cwdKey);
-  const sessionDir = path14.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path20.join(worktreesRootPath, cwdKey);
+  const sessionDir = path20.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -31818,14 +32161,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs12.mkdirSync(sessionDir, { recursive: true });
+  fs17.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path14.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path14.isAbsolute(rel)) continue;
+    let rel = path20.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path20.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = relNorm === "." ? sessionDir : path14.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path20.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs12.mkdirSync(path14.dirname(wtPath), { recursive: true });
+      fs17.mkdirSync(path20.dirname(wtPath), { recursive: true });
     }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
@@ -31867,23 +32210,23 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs15 from "node:fs";
+import * as fs20 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs14 from "node:fs";
+import * as fs19 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.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";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path15.join(wt, ".git");
-  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path21.join(wt, ".git");
+  if (!fs18.existsSync(gitDirFile) || !fs18.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs18.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path15.resolve(wt, m[1].trim());
-  const gitDir = path15.dirname(path15.dirname(gitWorktreePath));
-  return path15.dirname(gitDir);
+  const gitWorktreePath = path21.resolve(wt, m[1].trim());
+  const gitDir = path21.dirname(path21.dirname(gitWorktreePath));
+  return path21.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -31892,7 +32235,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs14.rmSync(worktreePath, { recursive: true, force: true });
+    fs19.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -31905,7 +32248,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs15.rmSync(wt, { recursive: true, force: true });
+        fs20.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -32125,7 +32468,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path17 from "node:path";
+import * as path23 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -32245,8 +32588,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
-import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as fs22 from "node:fs";
+import * as path22 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -32270,7 +32613,7 @@ async function countTextFileLines(filePath) {
 }
 
 // src/git/working-directory/changes/hydrate-patch.ts
-import * as fs16 from "node:fs";
+import * as fs21 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;
@@ -32285,7 +32628,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs16.promises.readFile(filePath, "utf8");
+    const raw = await fs21.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -32420,7 +32763,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path16.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path22.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -32433,7 +32776,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs17.promises.stat(repoFilePath);
+          const st = await fs22.promises.stat(repoFilePath);
           if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
@@ -32459,7 +32802,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const filePath = path16.join(repoGitCwd, pathInRepo);
+    const filePath = path22.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
@@ -32475,8 +32818,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path17.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path17.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path23.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path23.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -32489,7 +32832,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (const target of options.commitTargetPaths) {
-    const t = path17.resolve(target);
+    const t = path23.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
     let branch = "HEAD";
@@ -32502,8 +32845,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path17.dirname(t) : t;
-      const relNorm = path17.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path23.dirname(t) : t;
+      const relNorm = path23.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -32512,8 +32855,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path17.relative(bridgeRoot, path17.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path17.basename(path17.resolve(top)) : rel;
+      const rel = path23.relative(bridgeRoot, path23.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path23.basename(path23.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -32578,11 +32921,11 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs23 from "node:fs";
+import * as path24 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs18.existsSync(path18.join(dirPath, ".git"));
+    return fs23.existsSync(path24.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -32591,23 +32934,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path18.resolve(dir));
+      out.push(path24.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path24.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path18.resolve(rootPath));
+  walk(path24.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -32616,16 +32959,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path24.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path18.resolve(full));
+        if (isGitDir(full)) out.push(path24.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -32637,14 +32980,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs18.statSync(sessionDir);
+    st = fs23.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path18.resolve(sessionDir);
+  const abs = path24.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -32654,20 +32997,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path18.resolve(checkoutPath);
+  const hintR = path24.resolve(checkoutPath);
   let best = null;
-  let cur = path18.dirname(hintR);
+  let cur = path24.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path18.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path18.resolve(paths[0]);
+    if (paths.some((p) => path24.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path24.resolve(paths[0]);
       best = {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path18.resolve(p))
+        sessionParentPath: path24.resolve(isolated),
+        workingTreeRelRoot: path24.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path24.resolve(p))
       };
     }
-    const next = path18.dirname(cur);
+    const next = path24.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -32675,33 +33018,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs18.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs23.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs18.readdirSync(worktreesRootPath)) {
+    for (const name of fs23.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path18.join(worktreesRootPath, name);
-      if (!fs18.statSync(p).isDirectory()) continue;
+      const p = path24.join(worktreesRootPath, name);
+      if (!fs23.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path18.join(worktreesRootPath, key);
-    if (!fs18.existsSync(layoutRoot) || !fs18.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path18.join(layoutRoot, sessionId);
+    const layoutRoot = path24.join(worktreesRootPath, key);
+    if (!fs23.existsSync(layoutRoot) || !fs23.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path24.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) ?? path18.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path24.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+        sessionParentPath: path24.resolve(isolated),
+        workingTreeRelRoot: path24.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path24.resolve(p))
       };
     }
   }
@@ -32710,12 +33053,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path18.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path18.join(hint, sid));
+  const hint = path24.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path24.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path18.basename(hint) === sid && isGitDir(hint)) {
+    if (path24.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -32723,24 +33066,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path18.basename(hint) === sid && isGitDir(hint)) {
+  if (path24.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs18.statSync(hint);
+    st = fs23.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) ?? path18.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path24.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path18.resolve(isolated),
+    sessionParentPath: path24.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path24.resolve(p))
   };
 }
 
@@ -32763,10 +33106,10 @@ var SessionWorktreeManager = class {
     this.layout = loadWorktreeLayout();
   }
   rememberSessionWorktrees(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path19.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path25.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path19.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path19.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path25.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path25.resolve(binding.workingTreeRelRoot));
   }
   sessionParentPathAfterRemember(sessionId) {
     return this.sessionParentPathBySession.get(sessionId);
@@ -32783,7 +33126,7 @@ var SessionWorktreeManager = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path19.resolve(parent) !== path19.resolve(relRoot);
+    return path25.resolve(parent) !== path25.resolve(relRoot);
   }
   /**
    * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
@@ -32792,7 +33135,7 @@ var SessionWorktreeManager = class {
     if (!sessionId) return null;
     const sid = sessionId.trim();
     const cached2 = this.sessionParentPathBySession.get(sid);
-    if (cached2) return path19.resolve(cached2);
+    if (cached2) return path25.resolve(cached2);
     const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
     if (!paths?.length) return null;
     return resolveIsolatedSessionParentPathFromCheckouts(paths);
@@ -32806,7 +33149,7 @@ var SessionWorktreeManager = class {
     const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const resolved = path19.resolve(parentPathRaw);
+      const resolved = path25.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
         const diskFirst = this.tryDiscoverFromDisk(sid);
         if (diskFirst) {
@@ -32825,7 +33168,7 @@ var SessionWorktreeManager = class {
             this.rememberSessionWorktrees(sid, tryRoot);
             return this.sessionParentPathAfterRemember(sid);
           }
-          const next = path19.dirname(cur);
+          const next = path25.dirname(cur);
           if (next === cur) break;
           cur = next;
         }
@@ -32978,15 +33321,22 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootPath() {
-  return path19.join(os5.homedir(), ".buildautomaton", "worktrees");
+  return path25.join(os8.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
+import path30 from "node:path";
+
+// src/files/index/paths.ts
 import path26 from "node:path";
+import crypto2 from "node:crypto";
+function getCwdHashForFileIndex(resolvedCwd) {
+  return crypto2.createHash("sha256").update(path26.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+}
 
 // src/files/index/build-file-index.ts
-import path23 from "node:path";
+import path28 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
@@ -32994,47 +33344,12 @@ function yieldToEventLoop() {
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs19 from "node:fs";
-import path21 from "node:path";
-
-// src/files/index/constants.ts
-import path20 from "node:path";
-import os6 from "node:os";
-var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path20.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 = fs19.readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const name of names) {
-    if (name.startsWith(".")) continue;
-    const full = path21.join(dir, name);
-    let stat2;
-    try {
-      stat2 = fs19.statSync(full);
-    } catch {
-      continue;
-    }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
-    if (stat2.isDirectory()) {
-      walkWorkspaceTreeSync(full, baseDir, out);
-    } else if (stat2.isFile()) {
-      out.push(relative5);
-    }
-  }
-}
+import fs24 from "node:fs";
+import path27 from "node:path";
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs19.promises.readdir(dir);
+    names = await fs24.promises.readdir(dir);
   } catch {
     return;
   }
@@ -33044,14 +33359,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path21.join(dir, name);
+    const full = path27.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs19.promises.stat(full);
+      stat2 = await fs24.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path27.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat2.isFile()) {
@@ -33063,205 +33378,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 fs25 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 {
+        fs25.unlinkSync(getCliSqlitePath());
+      } catch {
+      }
+      chain = Promise.resolve();
+      return await Promise.resolve(fn());
     }
-  }
-  return trigramIndex;
-}
-
-// src/files/index/write-index-file.ts
-import fs20 from "node:fs";
-
-// src/files/index/paths.ts
-import path22 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 path22.join(INDEX_DIR, `.file-index-${hash}.json`);
-}
-
-// src/files/index/write-index-file.ts
-function writeIndexFileSync(resolvedCwd, data) {
-  const indexPath = getIndexPathForCwd(resolvedCwd);
-  try {
-    if (!fs20.existsSync(INDEX_DIR)) fs20.mkdirSync(INDEX_DIR, { recursive: true });
-    fs20.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 fs20.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs20.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 = path23.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 = path23.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 fs21 from "node:fs";
-import path24 from "node:path";
-function loadFileIndex(cwd) {
-  const resolved = path24.resolve(cwd);
-  const indexPath = getIndexPathForCwd(resolved);
+function persistPathsToSqlite(resolved, paths) {
+  const db = getCliDatabase();
+  const h = getCwdHashForFileIndex(resolved);
+  db.run("BEGIN IMMEDIATE");
   try {
-    const raw = fs21.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 = path28.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 path25 from "node:path";
-async function ensureFileIndexAsync(cwd) {
-  const resolved = path25.resolve(cwd);
-  const cached2 = loadFileIndex(resolved);
-  if (cached2 !== null) return { data: cached2, fromCache: true };
-  const data = await buildFileIndexAsync(resolved);
-  return { data, fromCache: false };
-}
+import path29 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 = path29.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) {
@@ -33302,7 +33536,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path26.resolve(cwd);
+  const resolved = path30.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -33330,7 +33564,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path34 from "node:path";
+import * as path38 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -33374,7 +33608,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs22 from "node:fs";
+import fs26 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -33410,7 +33644,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs22.readFile(d.mergedLogPath, (err, buf) => {
+      fs26.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));
@@ -33448,7 +33682,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs22.readFile(mergedPath, (err, buf) => {
+      fs26.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -33550,13 +33784,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs23 from "node:fs";
+import fs27 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs23.rmSync(dir, { recursive: true, force: true });
+    fs27.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -33564,7 +33798,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs23.openSync(devPath, "r");
+    cachedDevNullReadFd = fs27.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -33638,15 +33872,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs24 from "node:fs";
+import fs28 from "node:fs";
 import { tmpdir } from "node:os";
-import path27 from "node:path";
+import path31 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
+  const tmpRoot = fs28.mkdtempSync(path31.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path31.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs24.openSync(logPath, "a");
+    logFd = fs28.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -33665,7 +33899,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs24.closeSync(logFd);
+    fs28.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -33674,7 +33908,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs24.closeSync(logFd);
+      fs28.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -33685,22 +33919,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs25 from "node:fs";
+import fs29 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path28 from "node:path";
+import path32 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const innerPath = path28.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path28.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs29.mkdtempSync(path32.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path32.join(tmpRoot, "combined.log");
+  const innerPath = path32.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path32.join(tmpRoot, "_run.sh");
   try {
-    fs25.writeFileSync(innerPath, `#!/bin/sh
+    fs29.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs25.writeFileSync(
+    fs29.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -33726,13 +33960,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const runnerPath = path28.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs29.mkdtempSync(path32.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path32.join(tmpRoot, "combined.log");
+  const runnerPath = path32.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs25.writeFileSync(
+    fs29.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -34501,30 +34735,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs26 from "node:fs";
-import path29 from "node:path";
+import fs30 from "node:fs";
+import path33 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 = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path33.join(cwd, rel);
+    if (!fs30.existsSync(base) || !fs30.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs30.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path33.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs30.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path29.join(dir, "SKILL.md");
-      if (!fs26.existsSync(skillMd)) continue;
+      const skillMd = path33.join(dir, "SKILL.md");
+      if (!fs30.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -34536,23 +34770,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path33.join(cwd, rel);
+    if (!fs30.existsSync(base) || !fs30.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs30.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path33.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs30.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs26.existsSync(path29.join(dir, "SKILL.md"))) continue;
+      if (!fs30.existsSync(path33.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -34654,6 +34888,7 @@ function reportGitRepos(getWs, log2) {
 var API_TO_BRIDGE_MESSAGE_TYPES = [
   "auth_token",
   "bridge_identified",
+  "ha",
   "dev_servers_config",
   "server_control",
   "agent_config",
@@ -34682,6 +34917,10 @@ function parseApiToBridgeMessage(data, log2) {
     }
     return null;
   }
+  if (t === "ha") {
+    const s = data.s;
+    if (typeof s !== "number" || !Number.isFinite(s)) return null;
+  }
   return data;
 }
 
@@ -34722,6 +34961,13 @@ var handleBridgeIdentified = (msg, deps) => {
   });
 };
 
+// src/connection/heartbeat/ack.ts
+var handleBridgeHeartbeatAck = (msg, deps) => {
+  const raw = msg.s;
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return;
+  deps.onBridgeHeartbeatAck?.(Math.trunc(raw));
+};
+
 // src/agents/acp/from-bridge/handle-bridge-agent-config.ts
 function handleBridgeAgentConfig(msg, { acpManager }) {
   if (!Array.isArray(msg.agents) || msg.agents.length === 0) return;
@@ -34734,7 +34980,7 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/prompt-turn-queue/runner.ts
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 
 // src/prompt-turn-queue/client-report.ts
 function sendPromptQueueClientReport(ws, queues) {
@@ -34743,32 +34989,6 @@ function sendPromptQueueClientReport(ws, queues) {
   return true;
 }
 
-// src/prompt-turn-queue/disk-store.ts
-import fs28 from "node:fs";
-
-// src/prompt-turn-queue/paths.ts
-import crypto3 from "node:crypto";
-import fs27 from "node:fs";
-import path30 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 path30.resolve(override);
-  return path30.join(os7.homedir(), ".buildautomaton", "queues");
-}
-function ensurePromptQueuesDirectory() {
-  const dir = getPromptQueuesDirectory();
-  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
-}
-function queueStateFilePath(queueKey) {
-  return path30.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
-}
-
 // src/prompt-turn-queue/disk-store.ts
 var MERGEABLE_SERVER_STATES = /* @__PURE__ */ new Set([
   "queued",
@@ -34778,28 +34998,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(fs28.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);
-  fs28.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);
@@ -34857,7 +35076,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 (!fs29.existsSync(file2)) {
+  if (!fs31.existsSync(file2)) {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
     );
@@ -35081,9 +35300,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path35 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path35) continue;
-    const row = { path: path35 };
+    const path39 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path39) continue;
+    const row = { path: path39 };
     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;
@@ -35304,15 +35523,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs30 from "node:fs";
-import path32 from "node:path";
+import fs32 from "node:fs";
+import path35 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path31 from "node:path";
+import path34 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path31.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path31.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path31.sep) && resolved !== cwd) {
+  const normalized = path34.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path34.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path34.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -35326,7 +35545,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs30.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs32.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -35334,12 +35553,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path32.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path32.join(resolved, d.name);
+      const entryPath = path35.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path35.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs30.promises.stat(fullPath);
+          const targetStat = await fs32.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -35364,25 +35583,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs31 from "node:fs";
+import fs33 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 = fs31.realpathSync(resolved);
+    real = fs33.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat2 = fs31.statSync(real);
+  const stat2 = fs33.statSync(real);
   if (!stat2.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs31.statSync(filePath).size;
-  const fd = fs31.openSync(filePath, "r");
+  const fileSize = fs33.statSync(filePath).size;
+  const fd = fs33.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -35395,7 +35614,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs31.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs33.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -35530,7 +35749,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs31.closeSync(fd);
+    fs33.closeSync(fd);
   }
 }
 function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -35541,8 +35760,8 @@ function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat2 = fs31.statSync(result);
-    const raw = fs31.readFileSync(result, "utf8");
+    const stat2 = fs33.statSync(result);
+    const raw = fs33.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat2.size };
   } catch (err) {
@@ -35555,14 +35774,14 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
 }
 
 // src/files/handle-file-browser-search.ts
+import path36 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 = path36.resolve(getBridgeRoot());
+    if (!bridgeFileIndexIsPopulated(cwd)) {
       const payload2 = {
         type: "file_browser_search_response",
         id: msg.id,
@@ -35572,7 +35791,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,
@@ -35660,8 +35879,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs32 from "node:fs";
-import path33 from "node:path";
+import fs34 from "node:fs";
+import path37 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -35672,15 +35891,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 = path33.join(cwd, targetDir, item.skillName);
+      const skillDir = path37.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path33.join(skillDir, f.path);
-        fs32.mkdirSync(path33.dirname(dest), { recursive: true });
+        const dest = path37.join(skillDir, f.path);
+        fs34.mkdirSync(path37.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs32.writeFileSync(dest, f.text, "utf8");
+          fs34.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs32.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs34.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -35830,7 +36049,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs33 from "node:fs";
+import * as fs35 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -35842,7 +36061,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs33.existsSync(file2)) {
+    if (!fs35.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -35891,6 +36110,9 @@ function dispatchBridgeMessage(msg, deps) {
     case "bridge_identified":
       handleBridgeIdentified(msg, deps);
       break;
+    case "ha":
+      handleBridgeHeartbeatAck(msg, deps);
+      break;
     case "dev_servers_config":
       handleDevServersConfig(msg, deps);
       break;
@@ -35946,9 +36168,17 @@ function dispatchBridgeMessage(msg, deps) {
 }
 
 // src/routing/handle-bridge-message.ts
+function normalizeInboundBridgeWebSocketJson(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return data;
+  const o = data;
+  if (o.t === "ha" && typeof o.s === "number" && Number.isFinite(o.s)) {
+    return { type: "ha", s: Math.trunc(o.s) };
+  }
+  return data;
+}
 function handleBridgeMessage(data, deps) {
   if (!deps.getWs()) return;
-  const msg = parseApiToBridgeMessage(data, deps.log);
+  const msg = parseApiToBridgeMessage(normalizeInboundBridgeWebSocketJson(data), deps.log);
   if (!msg) return;
   setImmediate(() => {
     dispatchBridgeMessage(msg, deps);
@@ -35996,7 +36226,8 @@ function createMainBridgeWebSocketLifecycle(params) {
     persistTokens,
     onAuthInvalid,
     e2ee,
-    identifyReportedPaths
+    identifyReportedPaths,
+    bridgeHeartbeat
   } = params;
   let authRefreshInFlight = false;
   function handleOpen() {
@@ -36028,6 +36259,7 @@ function createMainBridgeWebSocketLifecycle(params) {
     }
   }
   function handleClose(code, reason) {
+    bridgeHeartbeat?.stop();
     try {
       const was = state.currentWs;
       state.currentWs = null;
@@ -36062,6 +36294,7 @@ function createMainBridgeWebSocketLifecycle(params) {
       } catch {
       }
     }
+    bridgeHeartbeat?.stop();
     const prev = state.currentWs;
     if (prev) {
       prev.removeAllListeners();
@@ -36232,11 +36465,98 @@ function createCliE2eeRuntime(key) {
   };
 }
 
+// src/connection/heartbeat/controller.ts
+function meanRttMs(samples) {
+  if (samples.length === 0) return void 0;
+  let sum = 0;
+  for (const x of samples) sum += x;
+  return sum / samples.length;
+}
+function createBridgeHeartbeatController(params) {
+  const { getWs, log: log2 } = params;
+  let interval = null;
+  let seqCursor = -1;
+  let awaitingSeq = null;
+  let sentAtMs = 0;
+  let missed = 0;
+  const rttSamples = [];
+  function clearTimer() {
+    if (interval != null) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+  function nextSeq() {
+    seqCursor = seqCursor >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : seqCursor + 1;
+    return seqCursor;
+  }
+  function tick() {
+    const ws = getWs();
+    if (!ws || ws.readyState !== wrapper_default.OPEN) return;
+    if (awaitingSeq !== null) {
+      missed++;
+      if (missed >= BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT) {
+        try {
+          log2("[Bridge service] Heartbeat missed repeatedly; reconnecting\u2026");
+        } catch {
+        }
+        clearTimer();
+        awaitingSeq = null;
+        missed = 0;
+        rttSamples.length = 0;
+        safeCloseWebSocket(ws);
+        return;
+      }
+    }
+    const seq = nextSeq();
+    const mean = meanRttMs(rttSamples);
+    const payload = mean !== void 0 && Number.isFinite(mean) ? { t: "h", s: seq, m: Math.round(mean) } : { t: "h", s: seq };
+    sendWsMessage(ws, payload);
+    awaitingSeq = seq;
+    sentAtMs = Date.now();
+  }
+  return {
+    start() {
+      clearTimer();
+      awaitingSeq = null;
+      missed = 0;
+      seqCursor = -1;
+      rttSamples.length = 0;
+      interval = setInterval(tick, BRIDGE_APP_HEARTBEAT_INTERVAL_MS);
+    },
+    stop() {
+      clearTimer();
+      awaitingSeq = null;
+      missed = 0;
+      rttSamples.length = 0;
+    },
+    onAck(seq) {
+      if (awaitingSeq === null) return;
+      if (!Number.isFinite(seq)) return;
+      const ack = Math.trunc(seq);
+      const pending = awaitingSeq;
+      if (ack < pending) return;
+      if (ack === pending) {
+        const rtt = Date.now() - sentAtMs;
+        if (Number.isFinite(rtt) && rtt >= 0 && rtt < 6e5) {
+          rttSamples.push(rtt);
+          if (rttSamples.length > BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX) {
+            rttSamples.splice(0, rttSamples.length - BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX);
+          }
+        }
+      }
+      awaitingSeq = null;
+      missed = 0;
+    }
+  };
+}
+
 // src/connection/create-bridge-connection.ts
 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
@@ -36271,13 +36591,18 @@ async function createBridgeConnection(options) {
   }
   const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
   const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
-  const onBridgeIdentified = createOnBridgeIdentified({
+  const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: logFn });
+  const baseOnBridgeIdentified = createOnBridgeIdentified({
     devServerManager,
     firehoseServerUrl,
     workspaceId,
     state,
     logFn
   });
+  const onBridgeIdentified = (msg) => {
+    baseOnBridgeIdentified(msg);
+    bridgeHeartbeat.start();
+  };
   const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, logFn);
   const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, logFn);
   const messageDeps = {
@@ -36286,6 +36611,9 @@ async function createBridgeConnection(options) {
     acpManager,
     sessionWorktreeManager,
     onBridgeIdentified,
+    onBridgeHeartbeatAck: (seq) => {
+      bridgeHeartbeat.onAck(seq);
+    },
     sendLocalSkillsReport,
     reportAutoDetectedAgents,
     devServerManager,
@@ -36294,8 +36622,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path34.resolve(getBridgeRoot()),
-    worktreesRootPath: path34.resolve(worktreesRootPath)
+    bridgeRootPath: path38.resolve(getBridgeRoot()),
+    worktreesRootPath: path38.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -36309,13 +36637,15 @@ async function createBridgeConnection(options) {
     persistTokens,
     onAuthInvalid,
     e2ee,
-    identifyReportedPaths
+    identifyReportedPaths,
+    bridgeHeartbeat
   });
   connect();
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
       stopFileIndexWatcher();
+      bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
     }
   };