opencode-codebase-index 0.25.0 → 0.25.1

package/dist/cbi.js

@@ -329,7 +329,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path34, checkUnignored, mode) {
+      test(path35, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -338,7 +338,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path34);
+          const matched = rule[mode].test(path35);
           if (!matched) {
             return;
           }
@@ -359,17 +359,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path34, originalPath, doThrow) => {
-      if (!isString(path34)) {
+    var checkPath = (path35, originalPath, doThrow) => {
+      if (!isString(path35)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path34) {
+      if (!path35) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path34)) {
+      if (checkPath.isNotRelative(path35)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -378,7 +378,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path34) => REGEX_TEST_INVALID_PATH.test(path34);
+    var isNotRelative = (path35) => REGEX_TEST_INVALID_PATH.test(path35);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -408,19 +408,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path34 = originalPath && checkPath.convert(originalPath);
+        const path35 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path34,
+          path35,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path34, cache, checkUnignored, slices);
+        return this._t(path35, cache, checkUnignored, slices);
       }
-      checkIgnore(path34) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path34)) {
-          return this.test(path34);
+      checkIgnore(path35) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path35)) {
+          return this.test(path35);
         }
-        const slices = path34.split(SLASH).filter(Boolean);
+        const slices = path35.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -433,18 +433,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path34, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path35, false, MODE_CHECK_IGNORE);
       }
-      _t(path34, cache, checkUnignored, slices) {
-        if (path34 in cache) {
-          return cache[path34];
+      _t(path35, cache, checkUnignored, slices) {
+        if (path35 in cache) {
+          return cache[path35];
         }
         if (!slices) {
-          slices = path34.split(SLASH).filter(Boolean);
+          slices = path35.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path34] = this._rules.test(path34, checkUnignored, MODE_IGNORE);
+          return cache[path35] = this._rules.test(path35, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -452,29 +452,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path34] = parent.ignored ? parent : this._rules.test(path34, checkUnignored, MODE_IGNORE);
+        return cache[path35] = parent.ignored ? parent : this._rules.test(path35, checkUnignored, MODE_IGNORE);
       }
-      ignores(path34) {
-        return this._test(path34, this._ignoreCache, false).ignored;
+      ignores(path35) {
+        return this._test(path35, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path34) => !this.ignores(path34);
+        return (path35) => !this.ignores(path35);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path34) {
-        return this._test(path34, this._testCache, true);
+      test(path35) {
+        return this._test(path35, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path34) => checkPath(path34 && checkPath.convert(path34), path34, RETURN_FALSE);
+    var isPathValid = (path35) => checkPath(path35 && checkPath.convert(path35), path35, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path34) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path34) || isNotRelative(path34);
+      checkPath.isNotRelative = (path35) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path35) || isNotRelative(path35);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -652,8 +652,8 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/adapters/cbi.ts
-import { realpathSync as realpathSync7 } from "fs";
-import * as path33 from "path";
+import { realpathSync as realpathSync8 } from "fs";
+import * as path34 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/config/host.ts
@@ -1720,8 +1720,8 @@ var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
 );
 
 // src/tools/operations.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5, statSync as statSync5 } from "fs";
-import * as path20 from "path";
+import { existsSync as existsSync13, realpathSync as realpathSync6, statSync as statSync5 } from "fs";
+import * as path21 from "path";
 
 // src/tools/knowledge-base-paths.ts
 import * as path8 from "path";
@@ -2521,9 +2521,9 @@ ${truncateContent(r.content)}
 }
 
 // src/utils/auto-index.ts
-import { existsSync as existsSync7, realpathSync as realpathSync3 } from "fs";
-import * as os3 from "os";
-import * as path11 from "path";
+import { existsSync as existsSync8, realpathSync as realpathSync4 } from "fs";
+import * as os4 from "os";
+import * as path12 from "path";
 
 // src/indexer/index-lock.ts
 import { randomUUID } from "crypto";
@@ -2780,7 +2780,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path9.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath2 = path9.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os2.hostname(),
@@ -2789,19 +2789,19 @@ function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
     expectedOwnerToken: expectedOwner.token
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
-    if (publishJsonDirectory(reclaimPath, reclaimOwner)) break;
+    if (publishJsonDirectory(reclaimPath2, reclaimOwner)) break;
     if (attempt === 0 && removeDeadReclaimMarker(lockPath, expectedOwner)) continue;
     return false;
   }
   try {
-    const currentReclaimer = readReclaimOwner(reclaimPath);
+    const currentReclaimer = readReclaimOwner(reclaimPath2);
     const currentOwner = readDirectoryOwner(lockPath);
     if (!currentReclaimer || !sameReclaimOwner(currentReclaimer, reclaimOwner) || !currentOwner || !sameOwner(currentOwner, expectedOwner) || getOwnerLiveness(currentOwner) !== "dead") {
       return false;
     }
     publishRecoveryMarker(indexPath, expectedOwner);
     const ownerBeforeQuarantine = readDirectoryOwner(lockPath);
-    const reclaimerBeforeQuarantine = readReclaimOwner(reclaimPath);
+    const reclaimerBeforeQuarantine = readReclaimOwner(reclaimPath2);
     if (!ownerBeforeQuarantine || !sameOwner(ownerBeforeQuarantine, expectedOwner) || getOwnerLiveness(ownerBeforeQuarantine) !== "dead" || !reclaimerBeforeQuarantine || !sameReclaimOwner(reclaimerBeforeQuarantine, reclaimOwner)) {
       return false;
     }
@@ -2971,10 +2971,889 @@ function completeLeaseRecovery(lease) {
   }
 }
 
+// src/utils/background-worker.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import {
+  existsSync as existsSync6,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5,
+  realpathSync as realpathSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import * as os3 from "os";
+import * as path10 from "path";
+var OWNER_FILE_NAME2 = "owner.json";
+var HEARTBEAT_FILE_PREFIX = "heartbeat.";
+var RECLAIM_DIRECTORY_NAME2 = "reclaim";
+var REFRESH_REQUEST_FILE_NAME = "refresh-request.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_LEASE_MS = 3e4;
+var RETRY_DELAY_MS = 5e3;
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var BackgroundWorkerStopError = class extends Error {
+  constructor(watcherError, autoIndexError) {
+    super("Failed to stop background worker");
+    this.watcherError = watcherError;
+    this.autoIndexError = autoIndexError;
+    this.name = "BackgroundWorkerStopError";
+  }
+  watcherError;
+  autoIndexError;
+};
+var workers = /* @__PURE__ */ new Map();
+var workerKeysByProject = /* @__PURE__ */ new Map();
+var workerReplacementBarriers = /* @__PURE__ */ new Map();
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function canonicalizePath(targetPath) {
+  const resolved = path10.resolve(targetPath);
+  if (existsSync6(resolved)) {
+    try {
+      return realpathSync3.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  const parent = path10.dirname(resolved);
+  if (parent === resolved) return resolved;
+  return path10.join(canonicalizePath(parent), path10.basename(resolved));
+}
+function projectLookupKey(projectRoot, host) {
+  return `${host}::${canonicalizePath(projectRoot)}`;
+}
+function resolveIdentity(projectRoot, config, host) {
+  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalIndexPath = canonicalizePath(resolveProjectIndexPath(projectRoot, config.scope, host));
+  return {
+    canonicalIndexPath,
+    canonicalProjectRoot,
+    key: `${canonicalIndexPath}::${canonicalProjectRoot}`
+  };
+}
+function controllerKey(identity, host) {
+  return `${identity.key}::${host}`;
+}
+function leaseDirectoryName(identity) {
+  const hash = createHash("sha256").update(identity.key).digest("hex").slice(0, 32);
+  return `background-worker.${hash}.lease`;
+}
+function leasePathFor(identity) {
+  return path10.join(identity.canonicalIndexPath, leaseDirectoryName(identity));
+}
+function parseOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  if (typeof candidate.projectRoot !== "string" || candidate.projectRoot.length === 0) return null;
+  if (typeof candidate.indexPath !== "string" || candidate.indexPath.length === 0) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  return candidate;
+}
+function parseHeartbeat(value, expectedToken) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1 || candidate.token !== expectedToken) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  return candidate;
+}
+function parseReclaimOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  if (candidate.expectedOwnerToken !== null && (typeof candidate.expectedOwnerToken !== "string" || !UUID_PATTERN2.test(candidate.expectedOwnerToken))) return null;
+  return candidate;
+}
+function heartbeatPath(leasePath, token) {
+  return path10.join(leasePath, `${HEARTBEAT_FILE_PREFIX}${token}.json`);
+}
+function reclaimPath(leasePath) {
+  return path10.join(leasePath, RECLAIM_DIRECTORY_NAME2);
+}
+function refreshRequestPath(leasePath) {
+  return path10.join(leasePath, REFRESH_REQUEST_FILE_NAME);
+}
+function readLeaseOwner(leasePath) {
+  try {
+    return parseOwner2(JSON.parse(readFileSync5(path10.join(leasePath, OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function readOwner(leasePath) {
+  const owner = readLeaseOwner(leasePath);
+  if (!owner) return null;
+  try {
+    const heartbeat = parseHeartbeat(
+      JSON.parse(readFileSync5(heartbeatPath(leasePath, owner.token), "utf-8")),
+      owner.token
+    );
+    return heartbeat ? { ...owner, heartbeatAt: heartbeat.heartbeatAt } : owner;
+  } catch {
+    return owner;
+  }
+}
+function readReclaimOwner2(leasePath) {
+  try {
+    return parseReclaimOwner2(JSON.parse(readFileSync5(path10.join(reclaimPath(leasePath), OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function ownerLiveness(owner) {
+  if (owner.hostname !== os3.hostname()) return "unknown";
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    const code = getErrorCode2(error);
+    if (code === "ESRCH") return "dead";
+    if (code === "EPERM") return "alive";
+    return "unknown";
+  }
+}
+function isHeartbeatExpired(owner) {
+  return Date.now() - Date.parse(owner.heartbeatAt) >= STALE_LEASE_MS;
+}
+function sameOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token;
+}
+function writeHeartbeat(leasePath, owner) {
+  const targetPath = heartbeatPath(leasePath, owner.token);
+  const temporaryPath = `${targetPath}.tmp.${process.pid}.${owner.token}.${randomUUID2()}`;
+  const heartbeat = {
+    version: 1,
+    token: owner.token,
+    heartbeatAt: owner.heartbeatAt
+  };
+  try {
+    writeFileSync2(temporaryPath, JSON.stringify(heartbeat), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync2(temporaryPath, targetPath);
+    const currentOwner = readLeaseOwner(leasePath);
+    return currentOwner !== null && sameOwner2(currentOwner, owner);
+  } finally {
+    if (existsSync6(temporaryPath)) rmSync2(temporaryPath, { force: true });
+  }
+}
+function requestRefreshFromLeader(leasePath, allowDisabledAutoIndex) {
+  const requestPath = refreshRequestPath(leasePath);
+  const temporaryPath = `${requestPath}.tmp.${process.pid}.${randomUUID2()}`;
+  try {
+    const request = {
+      allowDisabledAutoIndex,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    writeFileSync2(temporaryPath, JSON.stringify(request), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync2(temporaryPath, requestPath);
+  } catch (error) {
+    if (getErrorCode2(error) !== "ENOENT") {
+      console.error("[codebase-index] Failed to request background index refresh from the project worker:", error);
+    }
+  } finally {
+    if (existsSync6(temporaryPath)) rmSync2(temporaryPath, { force: true });
+  }
+}
+function consumeRefreshRequest(leasePath) {
+  const requestPath = refreshRequestPath(leasePath);
+  const claimedPath = `${requestPath}.handling.${process.pid}.${randomUUID2()}`;
+  try {
+    renameSync2(requestPath, claimedPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const value = JSON.parse(readFileSync5(claimedPath, "utf-8"));
+    return {
+      allowDisabledAutoIndex: value.version === 1 && value.allowDisabledAutoIndex === true,
+      requestedAt: typeof value.requestedAt === "string" ? value.requestedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+  } catch {
+    return { allowDisabledAutoIndex: false, requestedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  } finally {
+    rmSync2(claimedPath, { force: true });
+  }
+}
+function publishLease(leasePath, owner) {
+  const candidatePath = `${leasePath}.candidate.${process.pid}.${owner.token}`;
+  try {
+    mkdirSync2(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    writeFileSync2(path10.join(candidatePath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if (existsSync6(leasePath)) return false;
+    try {
+      renameSync2(candidatePath, leasePath);
+      return true;
+    } catch (error) {
+      if (existsSync6(leasePath) || getErrorCode2(error) === "ENOENT") return false;
+      throw error;
+    }
+  } finally {
+    if (existsSync6(candidatePath)) rmSync2(candidatePath, { recursive: true, force: true });
+  }
+}
+function sameReclaimOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token && left.expectedOwnerToken === right.expectedOwnerToken;
+}
+function reclaimerLiveness(owner) {
+  return ownerLiveness(owner);
+}
+function isReclaimMarkerExpired(leasePath, owner) {
+  const startedAt = owner ? Date.parse(owner.startedAt) : (() => {
+    try {
+      return lstatSync2(reclaimPath(leasePath)).mtimeMs;
+    } catch {
+      return Date.now();
+    }
+  })();
+  return Date.now() - startedAt >= STALE_LEASE_MS;
+}
+function hasActiveReclaimMarker(leasePath, owner) {
+  const marker = readReclaimOwner2(leasePath);
+  return marker !== null && marker.expectedOwnerToken === owner.token && (marker.hostname !== os3.hostname() || ownerLiveness(owner) !== "alive");
+}
+function publishReclaimMarker(leasePath, expectedOwner) {
+  const markerPath = reclaimPath(leasePath);
+  const owner = {
+    version: 1,
+    pid: process.pid,
+    hostname: os3.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token: randomUUID2(),
+    expectedOwnerToken: expectedOwner?.token ?? null
+  };
+  try {
+    mkdirSync2(markerPath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "EEXIST" || getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    writeFileSync2(path10.join(markerPath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    return owner;
+  } catch (error) {
+    rmSync2(markerPath, { recursive: true, force: true });
+    throw error;
+  }
+}
+function removeExpiredReclaimMarker(leasePath, expectedOwner) {
+  const marker = readReclaimOwner2(leasePath);
+  const markerPath = reclaimPath(leasePath);
+  if (!existsSync6(markerPath)) return false;
+  if (marker && marker.expectedOwnerToken !== (expectedOwner?.token ?? null)) return false;
+  if (marker && (reclaimerLiveness(marker) === "alive" || !isReclaimMarkerExpired(leasePath, marker))) return false;
+  if (!marker && !isReclaimMarkerExpired(leasePath, null)) return false;
+  const staleMarkerPath = `${markerPath}.stale.${marker?.pid ?? process.pid}.${marker?.token ?? randomUUID2()}.${randomUUID2()}`;
+  try {
+    renameSync2(markerPath, staleMarkerPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    let claimedMarker = null;
+    try {
+      claimedMarker = parseReclaimOwner2(
+        JSON.parse(readFileSync5(path10.join(staleMarkerPath, OWNER_FILE_NAME2), "utf-8"))
+      );
+    } catch {
+      claimedMarker = null;
+    }
+    const markerMatches = marker ? claimedMarker !== null && sameReclaimOwner2(claimedMarker, marker) : claimedMarker === null;
+    if (!markerMatches || !canReclaimLease(leasePath, expectedOwner)) {
+      if (!existsSync6(markerPath) && existsSync6(staleMarkerPath)) renameSync2(staleMarkerPath, markerPath);
+      return false;
+    }
+    rmSync2(staleMarkerPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+function canReclaimLease(leasePath, expectedOwner) {
+  if (!existsSync6(leasePath)) return false;
+  if (!expectedOwner) return false;
+  const currentOwner = readOwner(leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, expectedOwner)) return false;
+  if (currentOwner.hostname === os3.hostname()) {
+    return ownerLiveness(currentOwner) === "dead";
+  }
+  return isHeartbeatExpired(currentOwner);
+}
+function reclaimLease(leasePath, expectedOwner) {
+  let marker = null;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    marker = publishReclaimMarker(leasePath, expectedOwner);
+    if (marker) break;
+    if (attempt === 0 && removeExpiredReclaimMarker(leasePath, expectedOwner)) continue;
+    return false;
+  }
+  if (!marker) return false;
+  const markerPath = reclaimPath(leasePath);
+  try {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (!currentMarker || !sameReclaimOwner2(currentMarker, marker) || !canReclaimLease(leasePath, expectedOwner)) {
+      return false;
+    }
+    const stalePath = `${leasePath}.stale.${process.pid}.${marker.token}`;
+    renameSync2(leasePath, stalePath);
+    const quarantinedOwner = readOwner(stalePath);
+    const quarantinedMarker = readReclaimOwner2(stalePath);
+    if (!quarantinedMarker || !sameReclaimOwner2(quarantinedMarker, marker) || expectedOwner !== null && (!quarantinedOwner || !sameOwner2(quarantinedOwner, expectedOwner))) {
+      if (!existsSync6(leasePath) && existsSync6(stalePath)) renameSync2(stalePath, leasePath);
+      return false;
+    }
+    rmSync2(stalePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  } finally {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (currentMarker && sameReclaimOwner2(currentMarker, marker)) {
+      rmSync2(markerPath, { recursive: true, force: true });
+    }
+  }
+}
+function acquireLease(identity) {
+  mkdirSync2(identity.canonicalIndexPath, { recursive: true, mode: 448 });
+  const canonicalIndexPath = realpathSync3.native(identity.canonicalIndexPath);
+  const leasePath = path10.join(canonicalIndexPath, leaseDirectoryName({ ...identity, canonicalIndexPath }));
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const owner = {
+      version: 1,
+      pid: process.pid,
+      hostname: os3.hostname(),
+      startedAt: timestamp,
+      heartbeatAt: timestamp,
+      projectRoot: identity.canonicalProjectRoot,
+      indexPath: canonicalIndexPath,
+      token: randomUUID2()
+    };
+    if (publishLease(leasePath, owner)) {
+      return { leasePath, owner };
+    }
+    const existingOwner = readOwner(leasePath);
+    if (existingOwner) {
+      if (canReclaimLease(leasePath, existingOwner) && reclaimLease(leasePath, existingOwner)) continue;
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function releaseLease(lease) {
+  const currentOwner = readOwner(lease.leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) return false;
+  const releasePath = `${lease.leasePath}.release.${lease.owner.pid}.${lease.owner.token}`;
+  try {
+    renameSync2(lease.leasePath, releasePath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readOwner(releasePath);
+  if (!claimedOwner || !sameOwner2(claimedOwner, lease.owner)) {
+    if (!existsSync6(lease.leasePath) && existsSync6(releasePath)) {
+      renameSync2(releasePath, lease.leasePath);
+    }
+    return false;
+  }
+  rmSync2(releasePath, { recursive: true, force: true });
+  return true;
+}
+var BackgroundWorkerController = class {
+  constructor(projectRoot, host, config, hooks, identity) {
+    this.projectRoot = projectRoot;
+    this.host = host;
+    this.config = config;
+    this.hooks = hooks;
+    this.identity = identity;
+  }
+  projectRoot;
+  host;
+  config;
+  hooks;
+  identity;
+  lease = null;
+  watcher = null;
+  leaderReady = Promise.resolve();
+  heartbeatTimer = null;
+  retryTimer = null;
+  teardownRetryTimer = null;
+  transition = Promise.resolve();
+  stopPromise = null;
+  stopped = false;
+  stopping = false;
+  losingLeadership = false;
+  restartAfterStop = false;
+  leaderWorkStopped = false;
+  startingLeaderWork = false;
+  stopAutoIndexOnTeardown = true;
+  autoIndexStarted = false;
+  reportedError = null;
+  update(config, hooks, options) {
+    const autoIndexWasEnabled = this.config.indexing.autoIndex;
+    const shouldReplaceWatcher = this.watcher !== null && hooks.watcherFactory !== void 0 && (hooks.watcherFactory === null || hooks.replaceWatcher === true);
+    this.config = config;
+    this.hooks = {
+      ...this.hooks,
+      ...hooks,
+      watcherFactory: hooks.watcherFactory === void 0 ? this.hooks.watcherFactory : hooks.watcherFactory,
+      watcherFactoryForConfig: hooks.watcherFactoryForConfig === void 0 ? this.hooks.watcherFactoryForConfig : hooks.watcherFactoryForConfig
+    };
+    if (autoIndexWasEnabled && !config.indexing.autoIndex || options.restartAutoIndex === true && config.indexing.autoIndex && !this.startingLeaderWork) {
+      this.autoIndexStarted = false;
+    }
+    if (!this.canRun()) {
+      void this.stop().catch((error) => {
+        console.error("[codebase-index] Failed to stop background worker after disabling automatic work:", error);
+      });
+      return;
+    }
+    if (shouldReplaceWatcher) {
+      void this.enqueue(async () => {
+        const watcher = this.watcher;
+        if (watcher) {
+          await watcher.stop();
+          if (this.watcher === watcher) this.watcher = null;
+        }
+        if (this.lease && !this.stopped) this.startLeaderWork();
+      }).catch((error) => {
+        console.error("[codebase-index] Failed to replace background file watcher:", error);
+      });
+    }
+    this.start();
+  }
+  startAfter(activation) {
+    this.transition = activation.catch(() => void 0);
+    this.start();
+  }
+  start() {
+    if (!this.canRun() || this.losingLeadership) return;
+    if (this.stopping) {
+      this.restartAfterStop = true;
+      return;
+    }
+    this.stopped = false;
+    void this.enqueue(async () => {
+      if (this.stopped || this.stopping || this.losingLeadership || !this.canRun()) return;
+      if (!this.lease) {
+        try {
+          this.lease = acquireLease(this.identity);
+          this.reportedError = null;
+        } catch (error) {
+          this.reportAcquireError(error);
+          this.scheduleRetry();
+          return;
+        }
+      }
+      if (!this.lease) {
+        this.scheduleRetry();
+        return;
+      }
+      this.startHeartbeat();
+      this.startLeaderWork();
+    });
+  }
+  waitForStart() {
+    return this.transition.catch(() => void 0).then(() => this.leaderReady);
+  }
+  requestRefresh(allowDisabledAutoIndex = false) {
+    this.start();
+    if (!this.isLeader()) {
+      requestRefreshFromLeader(leasePathFor(this.identity), allowDisabledAutoIndex);
+      return;
+    }
+    void this.enqueue(async () => {
+      if (this.stopped || !this.lease) return;
+      this.hooks.startAutoIndex("retrieval", allowDisabledAutoIndex);
+    });
+  }
+  isLeader() {
+    return this.lease !== null && !this.stopping && !this.losingLeadership;
+  }
+  isStopping() {
+    return this.stopping;
+  }
+  getHooksForConfig(config) {
+    const watcherFactoryForConfig = this.hooks.watcherFactoryForConfig;
+    if (!watcherFactoryForConfig) return this.hooks;
+    return {
+      ...this.hooks,
+      watcherFactory: watcherFactoryForConfig(config),
+      replaceWatcher: true
+    };
+  }
+  attachWatcher(watcherFactory, watcherFactoryForConfig) {
+    if (this.hooks.watcherFactory !== void 0) return;
+    this.hooks = {
+      ...this.hooks,
+      watcherFactory,
+      watcherFactoryForConfig: watcherFactoryForConfig ?? this.hooks.watcherFactoryForConfig
+    };
+    this.start();
+  }
+  async stop(stopAutoIndex = true) {
+    if (this.stopPromise) return this.stopPromise;
+    this.stopped = true;
+    this.stopping = true;
+    this.stopAutoIndexOnTeardown &&= stopAutoIndex;
+    this.clearRetryTimer();
+    const attempt = this.enqueue(async () => {
+      try {
+        const lease = this.lease;
+        if (this.leaderWorkStopped) {
+          if (lease) {
+            this.releaseStoppedLease(lease);
+          } else {
+            this.finishStoppedLease();
+          }
+          return;
+        }
+        const hadLeaderWork = lease !== null || this.watcher !== null || this.autoIndexStarted;
+        const stopped = await this.stopLeaderWork(hadLeaderWork && this.stopAutoIndexOnTeardown);
+        if (!lease) {
+          this.finishStoppedLease();
+          return;
+        }
+        if (!stopped.completed) {
+          this.releaseLeaseWhenAutoIndexStops(lease, stopped.completion);
+          return;
+        }
+        this.leaderWorkStopped = true;
+        this.releaseStoppedLease(lease);
+      } catch (error) {
+        this.scheduleTeardownRetry();
+        throw error;
+      }
+    });
+    const completion = attempt.finally(() => {
+      if (this.stopPromise === completion) this.stopPromise = null;
+    });
+    this.stopPromise = completion;
+    return completion;
+  }
+  canRun() {
+    return this.config.indexing.autoIndex || this.hooks.watcherFactory != null;
+  }
+  enqueue(operation) {
+    const next = this.transition.catch(() => void 0).then(operation);
+    this.transition = next;
+    return next;
+  }
+  startLeaderWork() {
+    if (this.stopped || this.stopping || this.losingLeadership) return;
+    this.startingLeaderWork = true;
+    try {
+      if (this.config.indexing.autoIndex && !this.autoIndexStarted) {
+        this.autoIndexStarted = true;
+        this.hooks.startAutoIndex("startup");
+      }
+      if (!this.watcher && this.hooks.watcherFactory) {
+        try {
+          const watcher = this.hooks.watcherFactory();
+          this.watcher = watcher;
+          this.leaderReady = watcher.whenReady?.().catch((error) => {
+            console.error("[codebase-index] Failed while waiting for background file watcher startup:", error);
+          }) ?? Promise.resolve();
+        } catch (error) {
+          console.error("[codebase-index] Failed to start background file watcher:", error);
+          this.leaderReady = Promise.resolve();
+        }
+      }
+    } finally {
+      this.startingLeaderWork = false;
+    }
+  }
+  async stopLeaderWork(stopAutoIndex) {
+    const watcher = this.watcher;
+    let watcherError;
+    if (watcher) {
+      try {
+        await watcher.stop();
+        if (this.watcher === watcher) this.watcher = null;
+      } catch (error) {
+        watcherError = error;
+      }
+    }
+    let autoIndexError;
+    let autoIndexStop = {
+      completed: true,
+      completion: Promise.resolve()
+    };
+    if (stopAutoIndex) {
+      try {
+        autoIndexStop = await this.hooks.stopAutoIndex();
+        this.autoIndexStarted = false;
+      } catch (error) {
+        autoIndexError = error;
+      }
+    }
+    if (watcherError !== void 0 || autoIndexError !== void 0) {
+      throw new BackgroundWorkerStopError(watcherError, autoIndexError);
+    }
+    return autoIndexStop;
+  }
+  releaseLeaseWhenAutoIndexStops(lease, completion) {
+    void completion.then(
+      () => {
+        void this.enqueue(async () => {
+          if (this.lease !== lease || !this.stopping) return;
+          this.leaderWorkStopped = true;
+          this.releaseStoppedLease(lease);
+        }).catch((error) => {
+          console.error("[codebase-index] Failed to release background worker lease after automatic indexing stopped:", error);
+          this.scheduleTeardownRetry();
+        });
+      },
+      (error) => {
+        console.error("[codebase-index] Failed while waiting for automatic indexing to stop:", error);
+        this.scheduleTeardownRetry();
+      }
+    );
+  }
+  releaseStoppedLease(lease) {
+    if (this.lease !== lease) {
+      this.finishStoppedLease();
+      return;
+    }
+    releaseLease(lease);
+    this.lease = null;
+    this.finishStoppedLease();
+  }
+  finishStoppedLease() {
+    this.leaderWorkStopped = false;
+    this.stopAutoIndexOnTeardown = true;
+    this.stopping = false;
+    this.clearTimers();
+    this.restartAfterTeardown();
+    if (!this.stopped || this.stopping) return;
+    const projectKey = projectLookupKey(this.projectRoot, this.host);
+    const key = controllerKey(this.identity, this.host);
+    if (workers.get(key) === this) workers.delete(key);
+    if (workerKeysByProject.get(projectKey) === key) workerKeysByProject.delete(projectKey);
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    const heartbeat = () => {
+      void this.heartbeat();
+    };
+    this.heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimer.unref?.();
+  }
+  async heartbeat() {
+    const lease = this.lease;
+    if (!lease || this.losingLeadership || this.stopped && !this.stopping) return;
+    if (hasActiveReclaimMarker(lease.leasePath, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    const currentOwner = readOwner(lease.leasePath);
+    if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    try {
+      const nextOwner = { ...lease.owner, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+      if (!writeHeartbeat(lease.leasePath, nextOwner)) {
+        await this.loseLeadership();
+        return;
+      }
+      lease.owner = nextOwner;
+      const refreshRequest = !this.stopping ? consumeRefreshRequest(lease.leasePath) : null;
+      if (refreshRequest) {
+        this.hooks.startAutoIndex("retrieval", refreshRequest.allowDisabledAutoIndex);
+      }
+    } catch (error) {
+      const ownerAfterError = readOwner(lease.leasePath);
+      if (hasActiveReclaimMarker(lease.leasePath, lease.owner) || !ownerAfterError || !sameOwner2(ownerAfterError, lease.owner)) {
+        await this.loseLeadership();
+        return;
+      }
+      console.error("[codebase-index] Failed to renew background worker lease:", error);
+    }
+  }
+  async loseLeadership() {
+    if (this.losingLeadership) return;
+    this.losingLeadership = true;
+    this.clearHeartbeat();
+    await this.enqueue(async () => this.stopAfterLeadershipLoss());
+  }
+  async stopAfterLeadershipLoss() {
+    const lease = this.lease;
+    if (!lease) {
+      this.losingLeadership = false;
+      return;
+    }
+    try {
+      const stopped = await this.stopLeaderWork(true);
+      this.lease = null;
+      this.losingLeadership = false;
+      if (stopped.completed) {
+        this.scheduleRetry();
+      } else {
+        void stopped.completion.then(() => this.scheduleRetry());
+      }
+    } catch (error) {
+      console.error("[codebase-index] Failed to stop background work after losing its lease:", error);
+      this.scheduleLostLeadershipTeardownRetry();
+    }
+  }
+  scheduleRetry() {
+    if (this.stopped || !this.canRun() || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.start();
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  scheduleTeardownRetry() {
+    if (!this.stopping || this.teardownRetryTimer) return;
+    this.teardownRetryTimer = setTimeout(() => {
+      this.teardownRetryTimer = null;
+      void this.stop(this.stopAutoIndexOnTeardown).catch((error) => {
+        console.error("[codebase-index] Failed to retry background worker teardown:", error);
+      });
+    }, RETRY_DELAY_MS);
+    this.teardownRetryTimer.unref?.();
+  }
+  restartAfterTeardown() {
+    if (!this.restartAfterStop || !this.canRun() || this.losingLeadership) return;
+    this.restartAfterStop = false;
+    this.stopped = false;
+    this.start();
+  }
+  scheduleLostLeadershipTeardownRetry() {
+    if (this.stopped || !this.losingLeadership || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.enqueue(async () => this.stopAfterLeadershipLoss());
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  clearHeartbeat() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    this.clearRetryTimer();
+    if (this.teardownRetryTimer) {
+      clearTimeout(this.teardownRetryTimer);
+      this.teardownRetryTimer = null;
+    }
+  }
+  clearRetryTimer() {
+    if (!this.retryTimer) return;
+    clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  reportAcquireError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.reportedError === message) return;
+    this.reportedError = message;
+    console.error("[codebase-index] Failed to acquire background worker lease:", error);
+  }
+};
+function configureBackgroundWorker(projectRoot, host, config, hooks, options = {}) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const identity = resolveIdentity(projectRoot, config, host);
+  const key = controllerKey(identity, host);
+  const previousKey = workerKeysByProject.get(projectKey);
+  if (previousKey && previousKey !== key) {
+    const previous = workers.get(previousKey);
+    const previousBarrier = workerReplacementBarriers.get(projectKey) ?? Promise.resolve();
+    const stopPrevious = previous?.stop(options.stopPreviousAutoIndex ?? true) ?? Promise.resolve();
+    const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
+    workerReplacementBarriers.set(projectKey, activation);
+    workers.delete(previousKey);
+    const worker2 = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    worker2.startAfter(activation);
+    workers.set(key, worker2);
+    workerKeysByProject.set(projectKey, key);
+    return;
+  }
+  let worker = workers.get(key);
+  if (!worker) {
+    worker = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    workers.set(key, worker);
+  } else {
+    worker.update(config, hooks, options);
+  }
+  workerKeysByProject.set(projectKey, key);
+  worker.start();
+}
+function updateBackgroundWorkerConfig(projectRoot, host, config) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  configureBackgroundWorker(projectRoot, host, config, worker.getHooksForConfig(config), {
+    stopPreviousAutoIndex: false,
+    restartAutoIndex: true
+  });
+}
+function requestBackgroundWorkerRefresh(projectRoot, host, allowDisabledAutoIndex = false) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  workers.get(key ?? "")?.requestRefresh(allowDisabledAutoIndex);
+}
+function isBackgroundWorkerManaged(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.has(key);
+}
+function isBackgroundWorkerLeader(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.get(key)?.isLeader() === true;
+}
+async function stopBackgroundWorker(projectRoot, host) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  await worker.stop();
+}
+
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync5, promises as fsPromises } from "fs";
-import * as path10 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, promises as fsPromises } from "fs";
+import * as path11 from "path";
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -2992,7 +3871,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if (existsSync6(path10.join(projectRoot, marker))) {
+    if (existsSync7(path11.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3019,13 +3898,40 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path10.join(projectRoot, ".gitignore");
-  if (existsSync6(gitignorePath)) {
-    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+  const gitignorePath = path11.join(projectRoot, ".gitignore");
+  if (existsSync7(gitignorePath)) {
+    const gitignoreContent = readFileSync6(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path11.sep).join("/");
+}
+function matchesAnyGlob(filePath, patterns) {
+  const normalized = toPosixRelativePath(filePath);
+  return patterns.some((pattern) => matchGlob(normalized, pattern));
+}
+function isExcludedByPatterns(relativePath, excludePatterns) {
+  return matchesAnyGlob(relativePath, excludePatterns);
+}
+function isExcludedDirectory(relativePath, excludePatterns) {
+  const normalized = toPosixRelativePath(relativePath);
+  if (matchesAnyGlob(normalized, excludePatterns)) {
+    return true;
+  }
+  for (const pattern of excludePatterns) {
+    const posixPattern = toPosixRelativePath(pattern).replace(/\/+$/, "");
+    if (!posixPattern.endsWith("/**")) {
+      continue;
+    }
+    const directoryPattern = posixPattern.slice(0, -3);
+    if (directoryPattern && matchesAnyGlob(normalized, [directoryPattern])) {
+      return true;
+    }
+  }
+  return false;
+}
 function matchGlob(filePath, pattern) {
   if (pattern.startsWith("**/")) {
     const withoutPrefix = pattern.slice(3);
@@ -3046,8 +3952,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path10.join(dir, entry.name);
-    const relativePath = path10.relative(projectRoot, fullPath);
+    const fullPath = path11.join(dir, entry.name);
+    const relativePath = toPosixRelativePath(path11.relative(projectRoot, fullPath));
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3065,6 +3971,10 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
       continue;
     }
     if (entry.isDirectory()) {
+      if (isExcludedDirectory(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
+      }
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
       const stat2 = await fsPromises.stat(fullPath);
@@ -3072,20 +3982,11 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
-      for (const pattern of excludePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          skipped.push({ path: relativePath, reason: "excluded" });
-          continue;
-        }
-      }
-      let matched = false;
-      for (const pattern of includePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          matched = true;
-          break;
-        }
+      if (isExcludedByPatterns(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
       }
-      if (matched) {
+      if (matchesAnyGlob(relativePath, includePatterns)) {
         filesInDir.push({ path: fullPath, size: stat2.size });
       }
     }
@@ -3096,7 +3997,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path10.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: toPosixRelativePath(path11.relative(projectRoot, filesInDir[i].path)), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3136,8 +4037,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path10.normalize(
-        path10.isAbsolute(kbRoot) ? kbRoot : path10.resolve(projectRoot, kbRoot)
+      const resolved = path11.normalize(
+        path11.isAbsolute(kbRoot) ? kbRoot : path11.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3178,7 +4079,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runCommand(file, args, options) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     childProcess.execFile(
       file,
       args,
@@ -3188,7 +4089,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve19(stdout);
+        resolve20(stdout);
       }
     );
   });
@@ -3280,29 +4181,29 @@ var AutoIndexCancelledError = class extends Error {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function canonicalizePath(targetPath) {
-  const resolved = path11.resolve(targetPath);
-  if (existsSync7(resolved)) {
+function canonicalizePath2(targetPath) {
+  const resolved = path12.resolve(targetPath);
+  if (existsSync8(resolved)) {
     try {
-      return realpathSync3.native(resolved);
+      return realpathSync4.native(resolved);
     } catch {
       return resolved;
     }
   }
-  const parent = path11.dirname(resolved);
+  const parent = path12.dirname(resolved);
   if (parent === resolved) return resolved;
-  return path11.join(canonicalizePath(parent), path11.basename(resolved));
+  return path12.join(canonicalizePath2(parent), path12.basename(resolved));
 }
 function isHomeDirectory(projectRoot) {
-  return canonicalizePath(projectRoot) === canonicalizePath(os3.homedir());
+  return canonicalizePath2(projectRoot) === canonicalizePath2(os4.homedir());
 }
-function projectLookupKey(projectRoot, host) {
-  return `${host}::${canonicalizePath(projectRoot)}`;
+function projectLookupKey2(projectRoot, host) {
+  return `${host}::${canonicalizePath2(projectRoot)}`;
 }
 function coordinatorKey(projectRoot, config, host) {
-  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalProjectRoot = canonicalizePath2(projectRoot);
   const indexPath = resolveProjectIndexPath(projectRoot, config.scope, host);
-  return `${canonicalizePath(indexPath)}::${canonicalProjectRoot}`;
+  return `${canonicalizePath2(indexPath)}::${canonicalProjectRoot}`;
 }
 function getProjectSafety(projectRoot, config) {
   if (isHomeDirectory(projectRoot)) {
@@ -3333,10 +4234,10 @@ function safeFailureMessage(error) {
 }
 function cancellableDelay(delayMs, signal) {
   if (signal.aborted) return Promise.reject(new AutoIndexCancelledError());
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve19();
+      resolve20();
     }, delayMs);
     timer.unref?.();
     const onAbort = () => {
@@ -3348,18 +4249,44 @@ function cancellableDelay(delayMs, signal) {
 }
 function withTimeout(promise, timeoutMs) {
   if (timeoutMs <= 0) return Promise.resolve(void 0);
-  return new Promise((resolve19) => {
-    const timer = setTimeout(() => resolve19(void 0), timeoutMs);
+  return new Promise((resolve20) => {
+    const timer = setTimeout(() => resolve20(void 0), timeoutMs);
     timer.unref?.();
     void promise.then((value) => {
       clearTimeout(timer);
-      resolve19(value);
+      resolve20(value);
     }, () => {
       clearTimeout(timer);
-      resolve19(void 0);
+      resolve20(void 0);
     });
   });
 }
+function settlesWithin(promise, timeoutMs) {
+  if (timeoutMs <= 0) return Promise.resolve(false);
+  return new Promise((resolve20) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve20(false);
+    }, timeoutMs);
+    timer.unref?.();
+    void promise.then(
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve20(true);
+      },
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve20(true);
+      }
+    );
+  });
+}
 function requestPriority(request) {
   if (request.force) return 4;
   if (request.source === "manual") return 3;
@@ -3370,6 +4297,7 @@ function mergeRequests(current, next) {
   if (!current) return next;
   const preferred = requestPriority(next) > requestPriority(current) ? next : current;
   return {
+    allowDisabledAutoIndex: current.allowDisabledAutoIndex || next.allowDisabledAutoIndex,
     checkFreshness: current.checkFreshness && next.checkFreshness,
     force: current.force || next.force,
     onProgress: next.onProgress ?? current.onProgress,
@@ -3431,11 +4359,11 @@ var AutoIndexCoordinator = class {
       progress: this.status.progress ? { ...this.status.progress } : void 0
     };
   }
-  start(source) {
+  start(source, allowDisabledAutoIndex = false) {
     this.refreshSafety();
-    if (!this.registration.config.indexing.autoIndex || !this.registration.safeToRun) return null;
+    if (!this.registration.config.indexing.autoIndex && !allowDisabledAutoIndex || !this.registration.safeToRun) return null;
     if (this.status.state === "failed") return this.inFlight;
-    return this.request({ checkFreshness: true, force: false, source });
+    return this.request({ allowDisabledAutoIndex, checkFreshness: true, force: false, source });
   }
   request(request) {
     if (this.stopped) {
@@ -3510,13 +4438,15 @@ var AutoIndexCoordinator = class {
       retryAttempt: void 0
     });
     const inFlight = this.inFlight;
-    if (inFlight) {
-      if (waitForCompletion) {
-        await inFlight;
-      } else {
-        await withTimeout(inFlight, SHUTDOWN_WAIT_MS);
-      }
+    const completion = inFlight ? inFlight.then(() => void 0, () => void 0) : Promise.resolve();
+    if (!inFlight) {
+      return { completed: true, completion };
     }
+    if (waitForCompletion) {
+      await completion;
+      return { completed: true, completion };
+    }
+    return { completed: await settlesWithin(completion, SHUTDOWN_WAIT_MS), completion };
   }
   startRequest(request) {
     if (this.stopped || !this.canRun(request)) {
@@ -3705,7 +4635,7 @@ var AutoIndexCoordinator = class {
     if (request.source === "manual" || request.source === "watcher") {
       return true;
     }
-    return this.registration.safeToRun && this.registration.config.indexing.autoIndex;
+    return this.registration.safeToRun && (this.registration.config.indexing.autoIndex || request.allowDisabledAutoIndex === true);
   }
   shouldDeferForBattery(request) {
     return this.registration.backgroundIndexingPolicy !== null && (request.source === "startup" || request.source === "watcher");
@@ -3738,17 +4668,17 @@ var AutoIndexCoordinator = class {
     }
   }
   waitForBatteryRetry(delayMs) {
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       const timer = setTimeout(() => {
         if (this.batteryRetryTimer === timer) {
           this.batteryRetryTimer = null;
           this.resolveBatteryRetry = null;
         }
-        resolve19();
+        resolve20();
       }, delayMs);
       timer.unref?.();
       this.batteryRetryTimer = timer;
-      this.resolveBatteryRetry = resolve19;
+      this.resolveBatteryRetry = resolve20;
     });
   }
   cancelBatteryRetry() {
@@ -3756,9 +4686,9 @@ var AutoIndexCoordinator = class {
       clearTimeout(this.batteryRetryTimer);
       this.batteryRetryTimer = null;
     }
-    const resolve19 = this.resolveBatteryRetry;
+    const resolve20 = this.resolveBatteryRetry;
     this.resolveBatteryRetry = null;
-    resolve19?.();
+    resolve20?.();
   }
   finishBatteryCheck(batteryCheck) {
     if (this.batteryCheck !== batteryCheck) return;
@@ -3771,12 +4701,25 @@ var AutoIndexCoordinator = class {
   }
 };
 function getCoordinator(projectRoot, host) {
-  const key = coordinatorKeysByProject.get(projectLookupKey(projectRoot, host));
+  const key = coordinatorKeysByProject.get(projectLookupKey2(projectRoot, host));
   return key ? coordinators.get(key) ?? null : null;
 }
-function configureAutoIndex(projectRoot, host, config, getIndexer) {
-  const projectKey = projectLookupKey(projectRoot, host);
+function synchronizeBackgroundWorker(projectRoot, host, config, safeToRun) {
+  if (safeToRun) {
+    updateBackgroundWorkerConfig(projectRoot, host, config);
+    return;
+  }
+  void stopBackgroundWorker(projectRoot, host).catch((error) => {
+    console.error("[codebase-index] Failed to stop background worker after project safety changed:", error);
+  });
+}
+function configureAutoIndex(projectRoot, host, config, getIndexer, options = {}) {
+  const projectKey = projectLookupKey2(projectRoot, host);
   const safety = getProjectSafety(projectRoot, config);
+  const synchronizeWorker = options.synchronizeBackgroundWorker ?? true;
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host)) {
+    return;
+  }
   const registration = {
     backgroundIndexingPolicy: createBackgroundIndexingPolicy(
       config.indexing.pauseBackgroundIndexingOnBattery
@@ -3794,6 +4737,9 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     const stopPrevious = previousCoordinator?.stop(true) ?? Promise.resolve();
     const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
     coordinatorReplacementBarriers.set(projectKey, activation);
+    if (synchronizeWorker) {
+      synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+    }
     coordinators.delete(previousKey);
     const coordinator2 = new AutoIndexCoordinator(registration);
     coordinator2.activateAfter(activation);
@@ -3809,6 +4755,9 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     coordinator.update(registration);
   }
   coordinatorKeysByProject.set(projectKey, key);
+  if (synchronizeWorker) {
+    synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+  }
 }
 function runCoordinatedIndex(projectRoot, host, force, onProgress) {
   return getCoordinator(projectRoot, host)?.request({
@@ -3843,15 +4792,23 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     };
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) {
+      return { ready: true };
+    }
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
-  const job = coordinator.start("retrieval") ?? coordinator.currentJob();
+  const job = startRetrievalRefresh(projectRoot, host, coordinator);
   if (job) {
     await withTimeout(job, coordinator.getWaitMs());
+  } else if (isBackgroundWorkerManaged(projectRoot, host)) {
+    await waitForPublishedSnapshot(coordinator, coordinator.getWaitMs());
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) return { ready: true };
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
   const status = coordinator.snapshot();
@@ -3872,18 +4829,45 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     text: `Automatic indexing is ${status.state}. Retry shortly or call index_status for progress. You can also run index_codebase explicitly.`
   };
 }
-async function hasReadableCurrentIndex(coordinator) {
+async function getSearchReadiness(coordinator) {
   const indexer = coordinator.getIndexer();
   if (indexer.getIndexFreshness) {
     const freshness = await indexer.getIndexFreshness();
-    return freshness.readable && freshness.current;
+    const searchable = freshness.readable && freshness.current && freshness.reason === "current";
+    return {
+      blocked: freshness.reason === "unreadable" || freshness.reason === "incompatible" || freshness.reason === "failed-batches" || freshness.reason === "migration-required",
+      reason: freshness.reason,
+      searchable
+    };
+  }
+  const indexed = (await indexer.getStatus()).indexed;
+  return { blocked: false, searchable: indexed };
+}
+function unavailableSnapshotResult(reason) {
+  const detail = reason === "incompatible" ? "The existing index is incompatible with the configured embedding provider." : reason === "migration-required" ? "The existing index requires a storage migration." : reason === "failed-batches" ? "The existing index has failed embedding batches." : "The existing index is unreadable.";
+  return {
+    ready: false,
+    text: `${detail} Run index_codebase before retrying retrieval.`
+  };
+}
+function startRetrievalRefresh(projectRoot, host, coordinator) {
+  if (isBackgroundWorkerManaged(projectRoot, host)) {
+    requestBackgroundWorkerRefresh(projectRoot, host, true);
+    return isBackgroundWorkerLeader(projectRoot, host) ? coordinator.currentJob() : null;
+  }
+  return coordinator.start("retrieval") ?? coordinator.currentJob();
+}
+async function waitForPublishedSnapshot(coordinator, waitMs) {
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    if ((await getSearchReadiness(coordinator)).searchable) return;
+    await new Promise((resolve20) => setTimeout(resolve20, Math.min(250, deadline - Date.now())));
   }
-  return (await indexer.getStatus()).indexed;
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import * as path12 from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import * as path13 from "path";
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -3904,8 +4888,8 @@ function loadRuntimeConfig(projectRoot, host) {
 }
 
 // src/indexer/index.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4, promises as fsPromises3 } from "fs";
-import * as path19 from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5, promises as fsPromises3 } from "fs";
+import * as path20 from "path";
 import { performance as performance2 } from "perf_hooks";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -3932,7 +4916,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve19, reject) => {
+  const wrappedPromise = new Promise((resolve20, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -3946,7 +4930,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve19, reject);
+    promise.then(resolve20, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -3954,7 +4938,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve19(fallback());
+          resolve20(fallback());
         } catch (error) {
           reject(error);
         }
@@ -3964,7 +4948,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve19();
+        resolve20();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -4366,7 +5350,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve19, reject) => {
+    return new Promise((resolve20, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -4406,7 +5390,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve19(result);
+          resolve20(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -4594,13 +5578,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve19();
+        resolve20();
       };
       this.on(event, listener);
     });
@@ -4886,7 +5870,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve19, reject) => {
+    await new Promise((resolve20, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -4894,7 +5878,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve19();
+        resolve20();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -4955,17 +5939,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import * as path13 from "path";
-import * as os4 from "os";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import * as path14 from "path";
+import * as os5 from "os";
 function getOpenCodeAuthPath() {
-  return path13.join(os4.homedir(), ".local", "share", "opencode", "auth.json");
+  return path14.join(os5.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync9(authPath)) {
-      return JSON.parse(readFileSync6(authPath, "utf-8"));
+    if (existsSync10(authPath)) {
+      return JSON.parse(readFileSync7(authPath, "utf-8"));
     }
   } catch {
   }
@@ -5256,17 +6240,17 @@ function validateExternalUrl(urlString) {
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
     return { valid: false, reason: `Blocked protocol: ${parsed.protocol}` };
   }
-  const hostname2 = parsed.hostname.toLowerCase();
-  if (BLOCKED_HOSTNAMES.has(hostname2)) {
-    return { valid: false, reason: `Blocked: cloud metadata service (${hostname2})` };
+  const hostname3 = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname3)) {
+    return { valid: false, reason: `Blocked: cloud metadata service (${hostname3})` };
   }
   for (const pattern of BLOCKED_METADATA_IPS) {
-    if (pattern.test(hostname2)) {
-      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname2})` };
+    if (pattern.test(hostname3)) {
+      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname3})` };
     }
   }
-  if (/^169\.254\./.test(hostname2)) {
-    return { valid: false, reason: `Blocked: link-local address (${hostname2})` };
+  if (/^169\.254\./.test(hostname3)) {
+    return { valid: false, reason: `Blocked: link-local address (${hostname3})` };
   }
   return { valid: true };
 }
@@ -6358,8 +7342,8 @@ function extractParamNames(params) {
 }
 
 // src/native/binding.ts
-import * as os5 from "os";
-import * as path14 from "path";
+import * as os6 from "os";
+import * as path15 from "path";
 import * as module from "module";
 import { fileURLToPath } from "url";
 
@@ -6395,7 +7379,7 @@ var MCP_BINARY_CURRENT_NAME = CURRENT_PRODUCT.mcpBinary;
 var STABLE_NATIVE_BINARY_NAME = IDENTITY_CATALOG.native.binaryName;
 
 // src/native/binding.ts
-function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()) {
+function getNativeBindingFilename(platform2 = os6.platform(), arch2 = os6.arch()) {
   if (platform2 === "darwin" && arch2 === "arm64") {
     return `${STABLE_NATIVE_BINARY_NAME}.darwin-arm64.node`;
   }
@@ -6413,25 +7397,25 @@ function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()
   }
   throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
 }
-function resolveNativeBindingPath(packageRoot, platform2 = os5.platform(), arch2 = os5.arch()) {
-  return path14.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
+function resolveNativeBindingPath(packageRoot, platform2 = os6.platform(), arch2 = os6.arch()) {
+  return path15.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
 }
 function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path14.dirname(fileURLToPath(import.meta.url));
+    currentDir = path15.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path14.join(currentDir, "index.js");
+    requireTarget = path15.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path14.join("src", "native"));
-  const packageRoot = isDevMode ? path14.resolve(currentDir, "../..") : path14.resolve(currentDir, "..");
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path15.join("src", "native"));
+  const packageRoot = isDevMode ? path15.resolve(currentDir, "../..") : path15.resolve(currentDir, "..");
   const nativePath = resolveNativeBindingPath(packageRoot);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
@@ -7015,8 +7999,8 @@ var Database = class _Database {
 
 // src/git/branch-materialization.ts
 import { promises as fsPromises2 } from "fs";
-import * as os6 from "os";
-import * as path15 from "path";
+import * as os7 from "os";
+import * as path16 from "path";
 
 // src/git/branch-resolution.ts
 import { execFile as execFile2 } from "child_process";
@@ -7335,13 +8319,13 @@ async function isWorktreeRegistered(projectRoot, worktreePath) {
   return false;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const relative12 = path15.relative(path15.resolve(rootPath), path15.resolve(filePath));
-  return relative12 === "" || !relative12.startsWith(`..${path15.sep}`) && relative12 !== ".." && !path15.isAbsolute(relative12);
+  const relative12 = path16.relative(path16.resolve(rootPath), path16.resolve(filePath));
+  return relative12 === "" || !relative12.startsWith(`..${path16.sep}`) && relative12 !== ".." && !path16.isAbsolute(relative12);
 }
 async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath) {
   if (await pathExists(worktreePath)) return false;
   const commonDir = await runGit(projectRoot, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  const registrationsRoot = path15.join(commonDir, "worktrees");
+  const registrationsRoot = path16.join(commonDir, "worktrees");
   let entries;
   try {
     entries = await fsPromises2.readdir(registrationsRoot, { withFileTypes: true });
@@ -7352,16 +8336,16 @@ async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath)
   const target = canonicalizePathForComparison(worktreePath);
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const registrationPath = path15.join(registrationsRoot, entry.name);
+    const registrationPath = path16.join(registrationsRoot, entry.name);
     if (!isPathWithinRoot(registrationPath, registrationsRoot)) continue;
     let gitdirPath;
     try {
-      gitdirPath = (await fsPromises2.readFile(path15.join(registrationPath, "gitdir"), "utf8")).trim();
+      gitdirPath = (await fsPromises2.readFile(path16.join(registrationPath, "gitdir"), "utf8")).trim();
     } catch {
       continue;
     }
-    const resolvedGitdirPath = path15.isAbsolute(gitdirPath) ? gitdirPath : path15.resolve(registrationPath, gitdirPath);
-    if (canonicalizePathForComparison(path15.dirname(resolvedGitdirPath)) !== target) continue;
+    const resolvedGitdirPath = path16.isAbsolute(gitdirPath) ? gitdirPath : path16.resolve(registrationPath, gitdirPath);
+    if (canonicalizePathForComparison(path16.dirname(resolvedGitdirPath)) !== target) continue;
     await fsPromises2.rm(registrationPath, { recursive: true, force: true });
     return true;
   }
@@ -7379,7 +8363,7 @@ async function removeWorktree(projectRoot, worktreePath) {
     registered = await isWorktreeRegistered(projectRoot, worktreePath);
   } catch (error) {
     errors.push(asError(error));
-    throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path16.dirname(worktreePath)}`);
   }
   if (registered) {
     try {
@@ -7395,7 +8379,7 @@ async function removeWorktree(projectRoot, worktreePath) {
       registered = await isWorktreeRegistered(projectRoot, worktreePath);
     } catch (error) {
       errors.push(asError(error));
-      throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path15.dirname(worktreePath)}`);
+      throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path16.dirname(worktreePath)}`);
     }
   }
   if (registered && !await pathExists(worktreePath)) {
@@ -7408,13 +8392,13 @@ async function removeWorktree(projectRoot, worktreePath) {
   }
   if (registered) {
     errors.push(new Error(`Temporary worktree remains registered: ${worktreePath}`));
-    throw new AggregateError(errors, `Failed to deregister temporary worktree; preserved ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Failed to deregister temporary worktree; preserved ${path16.dirname(worktreePath)}`);
   }
   try {
-    await fsPromises2.rm(path15.dirname(worktreePath), { recursive: true, force: true });
+    await fsPromises2.rm(path16.dirname(worktreePath), { recursive: true, force: true });
   } catch (error) {
     errors.push(asError(error));
-    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path16.dirname(worktreePath)}`);
   }
 }
 async function cleanupTemporaryWorktree(projectRoot, worktreePath, temporaryRoot) {
@@ -7450,9 +8434,9 @@ async function withMaterializedBranch(request, callback) {
       `Git ref ${JSON.stringify(request.ref ?? request.branch)} is not available locally. For an unfetched branch, pass a remote-qualified name such as origin/feature.`
     );
   }
-  const temporaryRoot = await fsPromises2.mkdtemp(path15.join(os6.tmpdir(), "codebase-index-branch-"));
-  const worktreePath = path15.join(temporaryRoot, "worktree");
-  const hooksPath = path15.join(temporaryRoot, "hooks");
+  const temporaryRoot = await fsPromises2.mkdtemp(path16.join(os7.tmpdir(), "codebase-index-branch-"));
+  const worktreePath = path16.join(temporaryRoot, "worktree");
+  const hooksPath = path16.join(temporaryRoot, "hooks");
   await fsPromises2.mkdir(hooksPath);
   const info = {
     branch: request.branch,
@@ -7503,8 +8487,8 @@ async function withMaterializedBranch(request, callback) {
 
 // src/tools/changed-files.ts
 import { execFile as execFile3 } from "child_process";
-import { realpathSync as realpathSync4 } from "fs";
-import * as path16 from "path";
+import { realpathSync as realpathSync5 } from "fs";
+import * as path17 from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile3);
 var GH_PR_VIEW_FIELDS = [
@@ -7646,9 +8630,9 @@ function getHeadRepositoryIdentity(data, host) {
   return `${host}/${owner.toLowerCase()}/${repository.replace(/\.git$/i, "").toLowerCase()}`;
 }
 function getLocalRepositoryIdentity(projectRoot) {
-  let canonicalRoot = path16.resolve(projectRoot);
+  let canonicalRoot = path17.resolve(projectRoot);
   try {
-    canonicalRoot = realpathSync4.native(canonicalRoot);
+    canonicalRoot = realpathSync5.native(canonicalRoot);
   } catch {
   }
   return `local:${canonicalRoot}`;
@@ -7707,17 +8691,17 @@ async function getMergeBase(projectRoot, baseCommit, headCommit) {
   return commit;
 }
 function normalizeFiles(rawFiles, projectRoot) {
-  const root = path16.resolve(projectRoot);
+  const root = path17.resolve(projectRoot);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const raw of rawFiles) {
     if (raw.length === 0) continue;
-    const absolute = path16.resolve(root, raw);
-    const relative12 = path16.relative(root, absolute);
-    if (path16.isAbsolute(raw) || relative12 === ".." || relative12.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative12)) {
+    const absolute = path17.resolve(root, raw);
+    const relative12 = path17.relative(root, absolute);
+    if (path17.isAbsolute(raw) || relative12 === ".." || relative12.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative12)) {
       throw new Error(`Changed file escapes the project root: ${JSON.stringify(raw)}`);
     }
-    const cleaned = relative12.startsWith(`.${path16.sep}`) ? relative12.slice(2) : relative12;
+    const cleaned = relative12.startsWith(`.${path17.sep}`) ? relative12.slice(2) : relative12;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -7728,7 +8712,7 @@ function normalizeFiles(rawFiles, projectRoot) {
 
 // src/indexer/git-blame.ts
 import { execFile as execFile4 } from "child_process";
-import * as path17 from "path";
+import * as path18 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile4);
 function parseGitBlamePorcelain(output) {
@@ -7766,7 +8750,7 @@ function parseGitBlamePorcelain(output) {
   return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
 }
 async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
-  const relativePath = path17.relative(projectRoot, filePath);
+  const relativePath = path18.relative(projectRoot, filePath);
   try {
     const { stdout } = await execFileAsync3(
       "git",
@@ -8345,8 +9329,8 @@ function pathSegmentsForAffinityMatch(filePath) {
   if (segments.length === 0) {
     return [];
   }
-  const basename6 = segments[segments.length - 1] ?? "";
-  const basenameWithoutExt = basename6.replace(/\.[^/.]+$/u, "");
+  const basename7 = segments[segments.length - 1] ?? "";
+  const basenameWithoutExt = basename7.replace(/\.[^/.]+$/u, "");
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
   return Array.from(/* @__PURE__ */ new Set([
     ...normalizedSegments,
@@ -8655,8 +9639,8 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
 
 // src/indexer/failed-state-persistence.ts
 import * as fs2 from "fs";
-import { createHash, randomBytes as randomBytes3 } from "crypto";
-import * as path18 from "path";
+import { createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
+import * as path19 from "path";
 import { StringDecoder } from "string_decoder";
 var CURRENT_FAILED_BATCH_VERSION = 1;
 var DEFAULT_MALFORMED_LINE_ACTION = "skip";
@@ -8674,7 +9658,7 @@ function* readFailedBatchRecords(filePath, options = {}) {
 function createFailedBatchWriter(targetPath) {
   const temporaryPath = createTemporaryPath(targetPath);
   let finalized = false;
-  fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+  fs2.mkdirSync(path19.dirname(targetPath), { recursive: true });
   fs2.closeSync(fs2.openSync(temporaryPath, "w"));
   const write = (record) => {
     if (finalized) {
@@ -8693,7 +9677,7 @@ function createFailedBatchWriter(targetPath) {
     if (lines.length === 0) {
       return;
     }
-    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.mkdirSync(path19.dirname(targetPath), { recursive: true });
     fs2.appendFileSync(temporaryPath, `${lines.join("\n")}
 `, "utf-8");
   };
@@ -8701,7 +9685,7 @@ function createFailedBatchWriter(targetPath) {
     if (finalized) {
       return;
     }
-    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.mkdirSync(path19.dirname(targetPath), { recursive: true });
     fs2.renameSync(temporaryPath, targetPath);
     finalized = true;
   };
@@ -8847,10 +9831,10 @@ function stripLeadingBomAndWhitespace(value) {
   return result;
 }
 function createTemporaryPath(targetPath) {
-  const randomId = createHash("sha1").update(`${Date.now()}:${randomBytes3(8).toString("hex")}`).digest("hex");
-  const targetDir = path18.dirname(targetPath);
-  const baseName = path18.basename(targetPath);
-  return path18.join(targetDir, `.${baseName}.${randomId}.tmp`);
+  const randomId = createHash2("sha1").update(`${Date.now()}:${randomBytes3(8).toString("hex")}`).digest("hex");
+  const targetDir = path19.dirname(targetPath);
+  const baseName = path19.basename(targetPath);
+  return path19.join(targetDir, `.${baseName}.${randomId}.tmp`);
 }
 function handleMalformedLine(filePath, lineNumber, line, error, options) {
   const action = options.malformedLineAction ?? DEFAULT_MALFORMED_LINE_ACTION;
@@ -9096,9 +10080,9 @@ var SWIFT_PARSER_VERSION = "1";
 var METAL_PARSER_VERSION = "1";
 var SYMBOL_EXTRACTOR_VERSION = "1";
 function isPathWithinRoot2(filePath, rootPath) {
-  const normalizedFilePath = path19.resolve(filePath);
-  const normalizedRoot = path19.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path19.sep}`);
+  const normalizedFilePath = path20.resolve(filePath);
+  const normalizedRoot = path20.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path20.sep}`);
 }
 function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCandidates, database, branchChunkIds, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
   if (combined.length === 0) {
@@ -9429,10 +10413,10 @@ function matchesHardSearchFilters(candidate, options, projectRoot) {
   }
   if (options?.directory) {
     const candidatePath = canonicalizePathForComparison(
-      path19.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path20.sep))
     );
     const directoryPath = canonicalizePathForComparison(
-      path19.resolve(projectRoot, options.directory.trim().replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot, options.directory.trim().replace(/\\/g, path20.sep))
     );
     if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
@@ -9545,26 +10529,37 @@ var Indexer = class _Indexer {
     return this.indexPathOverride ?? resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   toCanonicalFilePath(filePath) {
-    if (!path19.isAbsolute(filePath)) {
+    if (!path20.isAbsolute(filePath)) {
       return this.resolveStoredFilePath(filePath, this.projectRoot);
     }
-    if (path19.resolve(this.materializedProjectRoot) === path19.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.materializedProjectRoot)) {
+    if (path20.resolve(this.materializedProjectRoot) === path20.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.materializedProjectRoot)) {
       return filePath;
     }
-    return path19.resolve(this.projectRoot, path19.relative(this.materializedProjectRoot, filePath));
+    return path20.resolve(this.projectRoot, path20.relative(this.materializedProjectRoot, filePath));
   }
   toStoredFilePath(filePath) {
     const canonicalFilePath = this.toCanonicalFilePath(filePath);
     if (this.config.scope !== "project" || !isPathWithinRoot2(canonicalFilePath, this.projectRoot)) {
       return canonicalFilePath;
     }
-    return path19.relative(this.projectRoot, canonicalFilePath).split(path19.sep).join("/");
+    return path20.relative(this.projectRoot, canonicalFilePath).split(path20.sep).join("/");
+  }
+  isStoredPathExcluded(storedPath) {
+    let matchPath = storedPath.split(path20.sep).join("/");
+    if (path20.isAbsolute(storedPath)) {
+      const relativePath = path20.relative(this.projectRoot, storedPath).split(path20.sep).join("/");
+      if (relativePath.startsWith("..") || path20.isAbsolute(relativePath)) {
+        return false;
+      }
+      matchPath = relativePath;
+    }
+    return isExcludedByPatterns(matchPath, this.config.exclude);
   }
   resolveStoredFilePath(filePath, rootPath = this.projectRoot) {
-    if (path19.isAbsolute(filePath)) {
+    if (path20.isAbsolute(filePath)) {
       return filePath;
     }
-    const resolvedPath = path19.resolve(rootPath, ...filePath.split("/"));
+    const resolvedPath = path20.resolve(rootPath, ...filePath.split("/"));
     if (!isPathWithinRoot2(resolvedPath, rootPath)) {
       throw new Error(`Stored project path escapes project root: ${JSON.stringify(filePath)}`);
     }
@@ -9588,7 +10583,7 @@ var Indexer = class _Indexer {
   }
   toMaterializedFilePath(filePath) {
     const storedFilePath = this.toStoredFilePath(filePath);
-    if (path19.isAbsolute(storedFilePath)) {
+    if (path20.isAbsolute(storedFilePath)) {
       return storedFilePath;
     }
     return this.resolveStoredFilePath(storedFilePath, this.materializedProjectRoot);
@@ -9605,10 +10600,10 @@ var Indexer = class _Indexer {
   }
   getRuntimeArtifactPath(fileName) {
     const namespace = this.getRuntimeArtifactNamespace();
-    if (!namespace) return path19.join(this.indexPath, fileName);
-    const extension = path19.extname(fileName);
+    if (!namespace) return path20.join(this.indexPath, fileName);
+    const extension = path20.extname(fileName);
     const baseName = fileName.slice(0, fileName.length - extension.length);
-    return path19.join(this.indexPath, `${baseName}.${namespace}${extension}`);
+    return path20.join(this.indexPath, `${baseName}.${namespace}${extension}`);
   }
   refreshRuntimeArtifactPaths() {
     this.fileHashCachePath = this.getRuntimeArtifactPath("file-hashes.json");
@@ -9621,14 +10616,14 @@ var Indexer = class _Indexer {
   getMaterializedKnowledgeBases() {
     const canonicalProjectRoot = this.getCanonicalPath(this.projectRoot);
     return this.config.knowledgeBases.map((knowledgeBase) => {
-      const configuredPath = path19.isAbsolute(knowledgeBase) ? knowledgeBase : path19.resolve(this.projectRoot, knowledgeBase);
+      const configuredPath = path20.isAbsolute(knowledgeBase) ? knowledgeBase : path20.resolve(this.projectRoot, knowledgeBase);
       const canonicalPath = this.getCanonicalPath(configuredPath);
       if (!isPathWithinRoot2(canonicalPath, canonicalProjectRoot)) {
         return canonicalPath;
       }
-      return path19.resolve(
+      return path20.resolve(
         this.materializedProjectRoot,
-        path19.relative(canonicalProjectRoot, canonicalPath)
+        path20.relative(canonicalProjectRoot, canonicalPath)
       );
     });
   }
@@ -9636,7 +10631,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path19.resolve(targetPath);
+      return path20.resolve(targetPath);
     }
   }
   getProjectIdentityHash(projectRoot) {
@@ -9717,7 +10712,7 @@ var Indexer = class _Indexer {
     } catch (error) {
       releaseError = error;
       this.writerArtifactFingerprint = null;
-      if (!existsSync11(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+      if (!existsSync12(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
         this.activeIndexLease = null;
       }
     }
@@ -9735,12 +10730,12 @@ var Indexer = class _Indexer {
     return this.activeIndexLease;
   }
   loadFileHashCache() {
-    if (!existsSync11(this.fileHashCachePath)) {
+    if (!existsSync12(this.fileHashCachePath)) {
       this.fileHashCache = /* @__PURE__ */ new Map();
       return;
     }
     try {
-      const data = readFileSync8(this.fileHashCachePath, "utf-8");
+      const data = readFileSync9(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -9762,24 +10757,24 @@ var Indexer = class _Indexer {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    mkdirSync4(path19.dirname(targetPath), { recursive: true });
+    mkdirSync5(path20.dirname(targetPath), { recursive: true });
     try {
-      writeFileSync3(tempPath, data);
-      renameSync3(tempPath, targetPath);
+      writeFileSync4(tempPath, data);
+      renameSync4(tempPath, targetPath);
     } finally {
       removeLeaseTemporaryPath(tempPath);
     }
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path19.join(this.indexPath, "inverted-index.json"),
+      path20.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots(projectRoot = this.projectRoot) {
     const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(this.getCanonicalPath(path19.resolve(projectRoot, kbRoot)));
+      roots.add(this.getCanonicalPath(path20.resolve(projectRoot, kbRoot)));
     }
     return Array.from(roots);
   }
@@ -10196,7 +11191,7 @@ var Indexer = class _Indexer {
     return configuredProviderInfo !== null && recovery.embeddingProvider === configuredProviderInfo.provider && recovery.embeddingModel === configuredProviderInfo.modelInfo.model && recovery.embeddingDimensions === configuredProviderInfo.modelInfo.dimensions && recovery.embeddingStrategyVersion === EMBEDDING_STRATEGY_VERSION;
   }
   hasUnknownLegacyForceIndexClear(owner) {
-    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && existsSync11(path19.join(this.indexPath, "force-index-phase"));
+    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && existsSync12(path20.join(this.indexPath, "force-index-phase"));
   }
   async recoverFromInterruptedIndexingUnlocked(owners) {
     for (const owner of owners) {
@@ -10382,7 +11377,7 @@ var Indexer = class _Indexer {
     }
   }
   clearFailedBatchState() {
-    if (existsSync11(this.failedBatchesPath)) {
+    if (existsSync12(this.failedBatchesPath)) {
       try {
         unlinkSync2(this.failedBatchesPath);
       } catch {
@@ -10584,7 +11579,7 @@ var Indexer = class _Indexer {
       await options.queue.onSizeLessThan(Math.max(1, options.providerRateLimits.concurrency));
       const task = options.queue.add(async () => {
         if (options.rateLimitState.backoffMs > 0) {
-          await new Promise((resolve19) => setTimeout(resolve19, options.rateLimitState.backoffMs));
+          await new Promise((resolve20) => setTimeout(resolve20, options.rateLimitState.backoffMs));
         }
         try {
           const embeddingResult = await pRetry(
@@ -11003,12 +11998,12 @@ var Indexer = class _Indexer {
     }
   }
   captureReaderArtifactFingerprint() {
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     return {
       vectors: `${this.getReaderFileFingerprint(storePath)}|${this.getReaderFileFingerprint(`${storePath}.meta.json`)}`,
-      keyword: this.getReaderFileFingerprint(path19.join(this.indexPath, "inverted-index.json")),
-      database: this.getReaderFileFingerprint(path19.join(this.indexPath, "codebase.db")),
-      databaseIdentity: this.getReaderFileFingerprint(path19.join(this.indexPath, "codebase.db"), true)
+      keyword: this.getReaderFileFingerprint(path20.join(this.indexPath, "inverted-index.json")),
+      database: this.getReaderFileFingerprint(path20.join(this.indexPath, "codebase.db")),
+      databaseIdentity: this.getReaderFileFingerprint(path20.join(this.indexPath, "codebase.db"), true)
     };
   }
   refreshReaderArtifacts() {
@@ -11033,13 +12028,13 @@ var Indexer = class _Indexer {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
-      const vectorStoreExists = existsSync11(storePath);
-      const vectorMetadataExists = existsSync11(vectorMetadataPath);
+      const vectorStoreExists = existsSync12(storePath);
+      const vectorMetadataExists = existsSync12(vectorMetadataPath);
       if (vectorStoreExists && vectorMetadataExists) {
         try {
           const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
@@ -11054,8 +12049,8 @@ var Indexer = class _Indexer {
         setIssue("vectors", this.getVectorReadIssueMessage());
       }
     }
-    if (keywordChanged || retryDue("keyword") || !existsSync11(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
-      if (existsSync11(invertedIndexPath)) {
+    if (keywordChanged || retryDue("keyword") || !existsSync12(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if (existsSync12(invertedIndexPath)) {
         try {
           const invertedIndex = new InvertedIndex(invertedIndexPath);
           invertedIndex.load();
@@ -11070,7 +12065,7 @@ var Indexer = class _Indexer {
       }
     }
     if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
-      if (existsSync11(dbPath)) {
+      if (existsSync12(dbPath)) {
         try {
           const database = Database.openReadOnly(dbPath);
           if (this.database) {
@@ -11152,11 +12147,11 @@ var Indexer = class _Indexer {
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync11(dbPath);
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync12(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
       await fsPromises3.mkdir(this.indexPath, { recursive: true });
@@ -11188,14 +12183,14 @@ var Indexer = class _Indexer {
         }
       }
       this.store = new VectorStore(storePath, dimensions);
-      if (existsSync11(storePath) || existsSync11(vectorMetadataPath)) {
+      if (existsSync12(storePath) || existsSync12(vectorMetadataPath)) {
         this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
       try {
         this.invertedIndex.load();
       } catch {
-        if (existsSync11(invertedIndexPath)) {
+        if (existsSync12(invertedIndexPath)) {
           await fsPromises3.unlink(invertedIndexPath);
         }
         this.invertedIndex = new InvertedIndex(invertedIndexPath);
@@ -11213,8 +12208,8 @@ var Indexer = class _Indexer {
       }
     } else {
       this.store = new VectorStore(storePath, dimensions);
-      const vectorStoreExists = existsSync11(storePath);
-      const vectorMetadataExists = existsSync11(vectorMetadataPath);
+      const vectorStoreExists = existsSync12(storePath);
+      const vectorMetadataExists = existsSync12(vectorMetadataPath);
       const vectorReadFailureMessage = this.getVectorReadIssueMessage();
       if (vectorStoreExists !== vectorMetadataExists) {
         this.recordReadIssue("vectors", vectorReadFailureMessage);
@@ -11227,7 +12222,7 @@ var Indexer = class _Indexer {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if (existsSync11(invertedIndexPath)) {
+      if (existsSync12(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -11241,7 +12236,7 @@ var Indexer = class _Indexer {
       } else if (this.store.count() > 0) {
         this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
       }
-      if (existsSync11(dbPath)) {
+      if (existsSync12(dbPath)) {
         try {
           this.database = Database.openReadOnly(dbPath);
         } catch (error) {
@@ -11333,7 +12328,7 @@ var Indexer = class _Indexer {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path19.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path20.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -11348,7 +12343,7 @@ var Indexer = class _Indexer {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path19.join(this.indexPath, "vectors");
+    const storeBasePath = path20.join(this.indexPath, "vectors");
     const storeIndexPath = storeBasePath;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const lease = this.requireActiveLease();
@@ -11358,19 +12353,19 @@ var Indexer = class _Indexer {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync11(backupIndexPath)) {
+    if (existsSync12(backupIndexPath)) {
       unlinkSync2(backupIndexPath);
     }
-    if (existsSync11(backupMetadataPath)) {
+    if (existsSync12(backupMetadataPath)) {
       unlinkSync2(backupMetadataPath);
     }
     try {
-      if (existsSync11(storeIndexPath)) {
-        renameSync3(storeIndexPath, backupIndexPath);
+      if (existsSync12(storeIndexPath)) {
+        renameSync4(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync11(storeMetadataPath)) {
-        renameSync3(storeMetadataPath, backupMetadataPath);
+      if (existsSync12(storeMetadataPath)) {
+        renameSync4(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -11390,10 +12385,10 @@ var Indexer = class _Indexer {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync11(backupIndexPath)) {
+      if (backedUpIndex && existsSync12(backupIndexPath)) {
         unlinkSync2(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync12(backupMetadataPath)) {
         unlinkSync2(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -11406,17 +12401,17 @@ var Indexer = class _Indexer {
         store.clear();
       } catch {
       }
-      if (existsSync11(storeIndexPath)) {
+      if (existsSync12(storeIndexPath)) {
         unlinkSync2(storeIndexPath);
       }
-      if (existsSync11(storeMetadataPath)) {
+      if (existsSync12(storeMetadataPath)) {
         unlinkSync2(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync11(backupIndexPath)) {
-        renameSync3(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && existsSync12(backupIndexPath)) {
+        renameSync4(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
-        renameSync3(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && existsSync12(backupMetadataPath)) {
+        renameSync4(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -11431,11 +12426,11 @@ var Indexer = class _Indexer {
     return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
   }
   async removeProjectRuntimeStateArtifacts() {
-    if (!existsSync11(this.indexPath)) return;
+    if (!existsSync12(this.indexPath)) return;
     const names = await fsPromises3.readdir(this.indexPath);
     const runtimeStatePattern = /^(?:file-hashes|failed-batches)(?:\.[a-f0-9]{16})?\.json$/;
     await Promise.all(
-      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path19.join(this.indexPath, name), { force: true }))
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path20.join(this.indexPath, name), { force: true }))
     );
   }
   async resetLocalIndexArtifacts() {
@@ -11451,13 +12446,13 @@ var Indexer = class _Indexer {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path19.join(this.indexPath, "codebase.db"),
-      path19.join(this.indexPath, "codebase.db-shm"),
-      path19.join(this.indexPath, "codebase.db-wal"),
-      path19.join(this.indexPath, "vectors"),
-      path19.join(this.indexPath, "vectors.usearch"),
-      path19.join(this.indexPath, "vectors.meta.json"),
-      path19.join(this.indexPath, "inverted-index.json")
+      path20.join(this.indexPath, "codebase.db"),
+      path20.join(this.indexPath, "codebase.db-shm"),
+      path20.join(this.indexPath, "codebase.db-wal"),
+      path20.join(this.indexPath, "vectors"),
+      path20.join(this.indexPath, "vectors.usearch"),
+      path20.join(this.indexPath, "vectors.meta.json"),
+      path20.join(this.indexPath, "inverted-index.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => fsPromises3.rm(targetPath, { recursive: true, force: true })));
     await this.removeProjectRuntimeStateArtifacts();
@@ -11467,7 +12462,7 @@ var Indexer = class _Indexer {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path19.join(this.indexPath, "codebase.db");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage4(error);
     if (this.config.scope === "global") {
@@ -11854,10 +12849,10 @@ var Indexer = class _Indexer {
     const reparseCachedMetalFiles = database.getMetadata(metalParserMetadataKey) !== METAL_PARSER_VERSION;
     const symbolExtractorMetadataKey = this.getSymbolExtractorVersionMetadataKey();
     const refreshCachedSymbols = database.getMetadata(symbolExtractorMetadataKey) !== SYMBOL_EXTRACTOR_VERSION;
-    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path19.extname(filePath).toLowerCase() === ".swift")) {
+    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path20.extname(filePath).toLowerCase() === ".swift")) {
       this.logger.info("Reindexing cached Swift files for parser support");
     }
-    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path19.extname(filePath).toLowerCase() === ".metal")) {
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path20.extname(filePath).toLowerCase() === ".metal")) {
       this.logger.info("Reindexing cached Metal files for parser support");
     }
     const includePatterns = [...this.config.include, ...this.config.additionalInclude];
@@ -11901,8 +12896,8 @@ var Indexer = class _Indexer {
       const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(storedPath).some(
         (chunk) => chunk.language === "php" || chunk.language === "c" || chunk.language === "cpp"
       );
-      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path19.extname(storedPath).toLowerCase() === ".swift";
-      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path19.extname(storedPath).toLowerCase() === ".metal";
+      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path20.extname(storedPath).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path20.extname(storedPath).toLowerCase() === ".metal";
       const inMigrationScope = forceScopedReembed && scopedRoots !== null && this.isFileInCurrentScope(storedPath, scopedRoots);
       if (cachedHashMatches && !inMigrationScope && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade && !refreshCachedSymbols) {
         unchangedFilePaths.add(storedPath);
@@ -11961,7 +12956,7 @@ var Indexer = class _Indexer {
         }
       }
     }
-    const shouldRetryFailedPath = (filePath) => filePath !== null && currentFileHashes.has(filePath) && unchangedFilePaths.has(filePath);
+    const shouldRetryFailedPath = (filePath) => filePath !== null && !this.isStoredPathExcluded(filePath) && currentFileHashes.has(filePath) && unchangedFilePaths.has(filePath);
     const failedProcessing = this.prepareFailedBatchProcessing(scopedRoots, shouldRetryFailedPath);
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
@@ -12065,7 +13060,7 @@ var Indexer = class _Indexer {
             throw new Error(`Parsed file was not present in its source batch: ${parsed.path}`);
           }
           if (parsed.chunks.length === 0) {
-            stats.parseFailures.push(path19.isAbsolute(parsed.path) ? path19.relative(this.projectRoot, parsed.path) : parsed.path);
+            stats.parseFailures.push(path20.isAbsolute(parsed.path) ? path20.relative(this.projectRoot, parsed.path) : parsed.path);
           }
           let chunksToProcess = parsed.chunks;
           if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
@@ -12400,8 +13395,8 @@ var Indexer = class _Indexer {
           previousBranchSymbolIds,
           Array.from(allSymbolIds)
         );
-        const vectorPath = path19.join(this.indexPath, "vectors");
-        const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync11(vectorPath) && existsSync11(`${vectorPath}.meta.json`);
+        const vectorPath = path20.join(this.indexPath, "vectors");
+        const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync12(vectorPath) && existsSync12(`${vectorPath}.meta.json`);
         if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
           store.save();
         }
@@ -13196,7 +14191,7 @@ var Indexer = class _Indexer {
     const missingChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync11(this.toMaterializedFilePath(filePath))) {
+      if (!existsSync12(this.toMaterializedFilePath(filePath))) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           missingChunkKeys.push(key);
@@ -13259,7 +14254,7 @@ var Indexer = class _Indexer {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path19.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path20.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -13289,7 +14284,8 @@ var Indexer = class _Indexer {
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
     const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
-    const failedProcessing = this.prepareFailedBatchProcessing(roots, () => true);
+    const shouldProcessFailedPath = (filePath) => filePath === null || !this.isStoredPathExcluded(filePath);
+    const failedProcessing = this.prepareFailedBatchProcessing(roots, shouldProcessFailedPath);
     if (failedProcessing.latestById.size === 0) {
       this.finalizeFailedBatchWriteState(failedProcessing.state);
       return { succeeded: 0, failed: 0, remaining: 0 };
@@ -13302,7 +14298,7 @@ var Indexer = class _Indexer {
       const retryableChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
         roots,
-        () => true,
+        shouldProcessFailedPath,
         maxChunkTokens
       );
       for (const retryBatch of iterateOrderedFileBatches(
@@ -13572,9 +14568,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path34 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path34.length > 0 && (shortest.length === 0 || path34.length < shortest.length)) {
-        shortest = path34;
+      const path35 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path35.length > 0 && (shortest.length === 0 || path35.length < shortest.length)) {
+        shortest = path35;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13622,13 +14618,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path34 = [];
+      const path35 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path34.push({
+        path35.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -13638,9 +14634,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path34.reverse();
-      if (path34.length > 0 && (shortest.length === 0 || path34.length < shortest.length)) {
-        shortest = path34;
+      path35.reverse();
+      if (path35.length > 0 && (shortest.length === 0 || path35.length < shortest.length)) {
+        shortest = path35;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13791,7 +14787,7 @@ var Indexer = class _Indexer {
         );
       }
     }
-    const toStoredChangedFiles = (filePaths) => filePaths.map((filePath) => this.toStoredFilePath(path19.resolve(this.projectRoot, filePath)));
+    const toStoredChangedFiles = (filePaths) => filePaths.map((filePath) => this.toStoredFilePath(path20.resolve(this.projectRoot, filePath)));
     const storedChangedFiles = toStoredChangedFiles(changedFiles);
     const directSymbols = database.getSymbolsForFiles(storedChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
@@ -13940,12 +14936,12 @@ var Indexer = class _Indexer {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path19.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path20.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
           const absoluteFilePath = this.resolveStoredFilePath(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path19.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path20.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -14034,15 +15030,24 @@ function getOrCreateIndexer(projectRoot, host) {
   }
   const indexer = new Indexer(projectRoot, config, host);
   indexerCache.set(key, indexer);
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: true,
+    synchronizeBackgroundWorker: false
+  });
   return indexer;
 }
-function initializeTools(projectRoot, config, host) {
+function initializeTools(projectRoot, config, host, options = {}) {
   defaultProjectRoots.set(host, projectRoot);
   const key = getIndexerCacheKey(projectRoot, host);
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host) && indexerCache.has(key)) {
+    return;
+  }
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: options.preserveManagedWorker,
+    synchronizeBackgroundWorker: false
+  });
 }
 function getIndexerForProject(projectRoot, host) {
   const root = getProjectRoot(projectRoot, host);
@@ -14072,7 +15077,7 @@ function trimOrUndefined(value) {
   return normalized || void 0;
 }
 function normalizeCallGraphPath(value) {
-  let normalized = path20.posix.normalize(value.trim().replaceAll("\\", "/"));
+  let normalized = path21.posix.normalize(value.trim().replaceAll("\\", "/"));
   if (normalized.startsWith("./")) {
     normalized = normalized.slice(2);
   }
@@ -14287,39 +15292,39 @@ async function executeCallGraph(projectRoot, host, args) {
 
 // src/adapters/mcp/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { realpathSync as realpathSync6, writeFileSync as writeFileSync6 } from "fs";
-import * as os8 from "os";
-import * as path32 from "path";
+import { realpathSync as realpathSync7, writeFileSync as writeFileSync7 } from "fs";
+import * as os9 from "os";
+import * as path33 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/eval/reports.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
-import * as path21 from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import * as path22 from "path";
 
 // src/eval/runner.ts
 import * as crypto2 from "crypto";
-import { existsSync as existsSync14 } from "fs";
-import * as path23 from "path";
+import { existsSync as existsSync15 } from "fs";
+import * as path24 from "path";
 
 // src/eval/runner-config.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import * as os7 from "os";
-import * as path22 from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import * as os8 from "os";
+import * as path23 from "path";
 
 // src/eval/schema.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 
 // src/eval/cli.ts
-import * as path25 from "path";
+import * as path26 from "path";
 
 // src/eval/cli-parser.ts
-import * as path24 from "path";
+import * as path25 from "path";
 
 // src/adapters/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/package-metadata.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 
 // src/adapters/mcp/register-prompts.ts
 import { z } from "zod";
@@ -14418,26 +15423,26 @@ var MCP_TOOL_NAMES = [
 ];
 
 // src/watcher/file-watcher.ts
-import { existsSync as existsSync15, statSync as statSync6 } from "fs";
-import * as path28 from "path";
+import { existsSync as existsSync16, statSync as statSync6 } from "fs";
+import * as path29 from "path";
 
 // src/watcher/native-recursive-watcher.ts
 import { watch } from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 
 // src/watcher/snapshot.ts
 import * as fsPromises4 from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 
 // src/watcher/git-head-watcher.ts
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path30 from "path";
+import * as path31 from "path";
 
 // src/tools/visualize/transform.ts
-import * as path31 from "path";
+import * as path32 from "path";
 
 // src/adapters/mcp/cli.ts
 function parseIndexArgs(argv, cwd) {
@@ -14459,7 +15464,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--project=")) {
         i += 1;
       }
-      project = path32.resolve(cwd, value);
+      project = path33.resolve(cwd, value);
       continue;
     }
     if (arg === "--config" || arg.startsWith("--config=")) {
@@ -14470,7 +15475,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--config=")) {
         i += 1;
       }
-      config = path32.resolve(cwd, value);
+      config = path33.resolve(cwd, value);
       continue;
     }
     if (arg === "--host" || arg.startsWith("--host=")) {
@@ -14634,7 +15639,7 @@ function parseCbiCommandArgs(command, args, cwd) {
     if (arg === "--help" || arg === "-h") throw new Error("help-requested");
     if (arg === "--project" || arg.startsWith("--project=")) {
       const parsed = optionValue(args, index, "project");
-      project = path33.resolve(cwd, parsed.value);
+      project = path34.resolve(cwd, parsed.value);
       index += parsed.consumed;
       continue;
     }
@@ -14646,7 +15651,7 @@ function parseCbiCommandArgs(command, args, cwd) {
     }
     if (arg === "--config" || arg.startsWith("--config=")) {
       const parsed = optionValue(args, index, "config");
-      config = path33.resolve(cwd, parsed.value);
+      config = path34.resolve(cwd, parsed.value);
       index += parsed.consumed;
       continue;
     }
@@ -14659,7 +15664,7 @@ function parseCbiCommandArgs(command, args, cwd) {
     }
     if (command === "graph" && (arg === "--file" || arg.startsWith("--file="))) {
       const parsed = optionValue(args, index, "file");
-      filePath = path33.resolve(cwd, parsed.value);
+      filePath = path34.resolve(cwd, parsed.value);
       index += parsed.consumed;
       continue;
     }
@@ -14758,7 +15763,7 @@ async function runCbiCli(argv, cwd, deps = {}) {
   }
 }
 function isCbiEntrypoint(moduleUrl, argvPath) {
-  return argvPath !== void 0 && realpathSync7(fileURLToPath3(moduleUrl)) === realpathSync7(argvPath);
+  return argvPath !== void 0 && realpathSync8(fileURLToPath3(moduleUrl)) === realpathSync8(argvPath);
 }
 
 // src/cbi.ts