opencode-codebase-index 0.25.0 → 0.25.1

package/dist/pi-extension.cjs

@@ -333,7 +333,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(path25, checkUnignored, mode) {
+      test(path26, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -342,7 +342,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path25);
+          const matched = rule[mode].test(path26);
           if (!matched) {
             return;
           }
@@ -363,17 +363,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path25, originalPath, doThrow) => {
-      if (!isString(path25)) {
+    var checkPath = (path26, originalPath, doThrow) => {
+      if (!isString(path26)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path25) {
+      if (!path26) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path25)) {
+      if (checkPath.isNotRelative(path26)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -382,7 +382,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path25) => REGEX_TEST_INVALID_PATH.test(path25);
+    var isNotRelative = (path26) => REGEX_TEST_INVALID_PATH.test(path26);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -412,19 +412,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path25 = originalPath && checkPath.convert(originalPath);
+        const path26 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path25,
+          path26,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path25, cache, checkUnignored, slices);
+        return this._t(path26, cache, checkUnignored, slices);
       }
-      checkIgnore(path25) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path25)) {
-          return this.test(path25);
+      checkIgnore(path26) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path26)) {
+          return this.test(path26);
         }
-        const slices = path25.split(SLASH2).filter(Boolean);
+        const slices = path26.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -437,18 +437,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path25, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path26, false, MODE_CHECK_IGNORE);
       }
-      _t(path25, cache, checkUnignored, slices) {
-        if (path25 in cache) {
-          return cache[path25];
+      _t(path26, cache, checkUnignored, slices) {
+        if (path26 in cache) {
+          return cache[path26];
         }
         if (!slices) {
-          slices = path25.split(SLASH2).filter(Boolean);
+          slices = path26.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path25] = this._rules.test(path25, checkUnignored, MODE_IGNORE);
+          return cache[path26] = this._rules.test(path26, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -456,29 +456,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path25] = parent.ignored ? parent : this._rules.test(path25, checkUnignored, MODE_IGNORE);
+        return cache[path26] = parent.ignored ? parent : this._rules.test(path26, checkUnignored, MODE_IGNORE);
       }
-      ignores(path25) {
-        return this._test(path25, this._ignoreCache, false).ignored;
+      ignores(path26) {
+        return this._test(path26, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path25) => !this.ignores(path25);
+        return (path26) => !this.ignores(path26);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path25) {
-        return this._test(path25, this._testCache, true);
+      test(path26) {
+        return this._test(path26, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path25) => checkPath(path25 && checkPath.convert(path25), path25, RETURN_FALSE);
+    var isPathValid = (path26) => checkPath(path26 && checkPath.convert(path26), path26, 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 = (path25) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path25) || isNotRelative(path25);
+      checkPath.isNotRelative = (path26) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path26) || isNotRelative(path26);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -2254,7 +2254,7 @@ function formatCodeCommunities(result) {
 
 // src/tools/operations.ts
 var import_fs13 = require("fs");
-var path20 = __toESM(require("path"), 1);
+var path21 = __toESM(require("path"), 1);
 
 // src/tools/knowledge-base-paths.ts
 var path9 = __toESM(require("path"), 1);
@@ -2966,8 +2966,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path25 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path25}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path26 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path26}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
 }
 function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount, includeExactSearchHandoff) {
   const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
@@ -3610,8 +3610,8 @@ function formatEffectivenessMetrics(snapshot) {
 
 // src/utils/auto-index.ts
 var import_fs8 = require("fs");
-var os4 = __toESM(require("os"), 1);
-var path12 = __toESM(require("path"), 1);
+var os5 = __toESM(require("os"), 1);
+var path13 = __toESM(require("path"), 1);
 
 // src/indexer/index-lock.ts
 var import_crypto = require("crypto");
@@ -3858,7 +3858,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath2 = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os3.hostname(),
@@ -3867,19 +3867,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;
     }
@@ -4049,10 +4049,884 @@ function completeLeaseRecovery(lease) {
   }
 }
 
+// src/utils/background-worker.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var os4 = __toESM(require("os"), 1);
+var path11 = __toESM(require("path"), 1);
+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 = path11.resolve(targetPath);
+  if ((0, import_node_fs.existsSync)(resolved)) {
+    try {
+      return import_node_fs.realpathSync.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  const parent = path11.dirname(resolved);
+  if (parent === resolved) return resolved;
+  return path11.join(canonicalizePath(parent), path11.basename(resolved));
+}
+function projectLookupKey(projectRoot3, host) {
+  return `${host}::${canonicalizePath(projectRoot3)}`;
+}
+function resolveIdentity(projectRoot3, config, host) {
+  const canonicalProjectRoot = canonicalizePath(projectRoot3);
+  const canonicalIndexPath = canonicalizePath(resolveProjectIndexPath(projectRoot3, config.scope, host));
+  return {
+    canonicalIndexPath,
+    canonicalProjectRoot,
+    key: `${canonicalIndexPath}::${canonicalProjectRoot}`
+  };
+}
+function controllerKey(identity, host) {
+  return `${identity.key}::${host}`;
+}
+function leaseDirectoryName(identity) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update(identity.key).digest("hex").slice(0, 32);
+  return `background-worker.${hash}.lease`;
+}
+function leasePathFor(identity) {
+  return path11.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 path11.join(leasePath, `${HEARTBEAT_FILE_PREFIX}${token}.json`);
+}
+function reclaimPath(leasePath) {
+  return path11.join(leasePath, RECLAIM_DIRECTORY_NAME2);
+}
+function refreshRequestPath(leasePath) {
+  return path11.join(leasePath, REFRESH_REQUEST_FILE_NAME);
+}
+function readLeaseOwner(leasePath) {
+  try {
+    return parseOwner2(JSON.parse((0, import_node_fs.readFileSync)(path11.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((0, import_node_fs.readFileSync)(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((0, import_node_fs.readFileSync)(path11.join(reclaimPath(leasePath), OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function ownerLiveness(owner) {
+  if (owner.hostname !== os4.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}.${(0, import_node_crypto.randomUUID)()}`;
+  const heartbeat = {
+    version: 1,
+    token: owner.token,
+    heartbeatAt: owner.heartbeatAt
+  };
+  try {
+    (0, import_node_fs.writeFileSync)(temporaryPath, JSON.stringify(heartbeat), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    (0, import_node_fs.renameSync)(temporaryPath, targetPath);
+    const currentOwner = readLeaseOwner(leasePath);
+    return currentOwner !== null && sameOwner2(currentOwner, owner);
+  } finally {
+    if ((0, import_node_fs.existsSync)(temporaryPath)) (0, import_node_fs.rmSync)(temporaryPath, { force: true });
+  }
+}
+function requestRefreshFromLeader(leasePath, allowDisabledAutoIndex) {
+  const requestPath = refreshRequestPath(leasePath);
+  const temporaryPath = `${requestPath}.tmp.${process.pid}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    const request = {
+      allowDisabledAutoIndex,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    (0, import_node_fs.writeFileSync)(temporaryPath, JSON.stringify(request), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    (0, import_node_fs.renameSync)(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 ((0, import_node_fs.existsSync)(temporaryPath)) (0, import_node_fs.rmSync)(temporaryPath, { force: true });
+  }
+}
+function consumeRefreshRequest(leasePath) {
+  const requestPath = refreshRequestPath(leasePath);
+  const claimedPath = `${requestPath}.handling.${process.pid}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    (0, import_node_fs.renameSync)(requestPath, claimedPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const value = JSON.parse((0, import_node_fs.readFileSync)(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 {
+    (0, import_node_fs.rmSync)(claimedPath, { force: true });
+  }
+}
+function publishLease(leasePath, owner) {
+  const candidatePath = `${leasePath}.candidate.${process.pid}.${owner.token}`;
+  try {
+    (0, import_node_fs.mkdirSync)(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(path11.join(candidatePath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if ((0, import_node_fs.existsSync)(leasePath)) return false;
+    try {
+      (0, import_node_fs.renameSync)(candidatePath, leasePath);
+      return true;
+    } catch (error) {
+      if ((0, import_node_fs.existsSync)(leasePath) || getErrorCode2(error) === "ENOENT") return false;
+      throw error;
+    }
+  } finally {
+    if ((0, import_node_fs.existsSync)(candidatePath)) (0, import_node_fs.rmSync)(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 (0, import_node_fs.lstatSync)(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 !== os4.hostname() || ownerLiveness(owner) !== "alive");
+}
+function publishReclaimMarker(leasePath, expectedOwner) {
+  const markerPath = reclaimPath(leasePath);
+  const owner = {
+    version: 1,
+    pid: process.pid,
+    hostname: os4.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token: (0, import_node_crypto.randomUUID)(),
+    expectedOwnerToken: expectedOwner?.token ?? null
+  };
+  try {
+    (0, import_node_fs.mkdirSync)(markerPath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "EEXIST" || getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(path11.join(markerPath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    return owner;
+  } catch (error) {
+    (0, import_node_fs.rmSync)(markerPath, { recursive: true, force: true });
+    throw error;
+  }
+}
+function removeExpiredReclaimMarker(leasePath, expectedOwner) {
+  const marker = readReclaimOwner2(leasePath);
+  const markerPath = reclaimPath(leasePath);
+  if (!(0, import_node_fs.existsSync)(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 ?? (0, import_node_crypto.randomUUID)()}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    (0, import_node_fs.renameSync)(markerPath, staleMarkerPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    let claimedMarker = null;
+    try {
+      claimedMarker = parseReclaimOwner2(
+        JSON.parse((0, import_node_fs.readFileSync)(path11.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 (!(0, import_node_fs.existsSync)(markerPath) && (0, import_node_fs.existsSync)(staleMarkerPath)) (0, import_node_fs.renameSync)(staleMarkerPath, markerPath);
+      return false;
+    }
+    (0, import_node_fs.rmSync)(staleMarkerPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+function canReclaimLease(leasePath, expectedOwner) {
+  if (!(0, import_node_fs.existsSync)(leasePath)) return false;
+  if (!expectedOwner) return false;
+  const currentOwner = readOwner(leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, expectedOwner)) return false;
+  if (currentOwner.hostname === os4.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}`;
+    (0, import_node_fs.renameSync)(leasePath, stalePath);
+    const quarantinedOwner = readOwner(stalePath);
+    const quarantinedMarker = readReclaimOwner2(stalePath);
+    if (!quarantinedMarker || !sameReclaimOwner2(quarantinedMarker, marker) || expectedOwner !== null && (!quarantinedOwner || !sameOwner2(quarantinedOwner, expectedOwner))) {
+      if (!(0, import_node_fs.existsSync)(leasePath) && (0, import_node_fs.existsSync)(stalePath)) (0, import_node_fs.renameSync)(stalePath, leasePath);
+      return false;
+    }
+    (0, import_node_fs.rmSync)(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)) {
+      (0, import_node_fs.rmSync)(markerPath, { recursive: true, force: true });
+    }
+  }
+}
+function acquireLease(identity) {
+  (0, import_node_fs.mkdirSync)(identity.canonicalIndexPath, { recursive: true, mode: 448 });
+  const canonicalIndexPath = import_node_fs.realpathSync.native(identity.canonicalIndexPath);
+  const leasePath = path11.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: os4.hostname(),
+      startedAt: timestamp,
+      heartbeatAt: timestamp,
+      projectRoot: identity.canonicalProjectRoot,
+      indexPath: canonicalIndexPath,
+      token: (0, import_node_crypto.randomUUID)()
+    };
+    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 {
+    (0, import_node_fs.renameSync)(lease.leasePath, releasePath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readOwner(releasePath);
+  if (!claimedOwner || !sameOwner2(claimedOwner, lease.owner)) {
+    if (!(0, import_node_fs.existsSync)(lease.leasePath) && (0, import_node_fs.existsSync)(releasePath)) {
+      (0, import_node_fs.renameSync)(releasePath, lease.leasePath);
+    }
+    return false;
+  }
+  (0, import_node_fs.rmSync)(releasePath, { recursive: true, force: true });
+  return true;
+}
+var BackgroundWorkerController = class {
+  constructor(projectRoot3, host, config, hooks, identity) {
+    this.projectRoot = projectRoot3;
+    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(projectRoot3, host, config, hooks, options = {}) {
+  const projectKey = projectLookupKey(projectRoot3, host);
+  const identity = resolveIdentity(projectRoot3, 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(projectRoot3, 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(projectRoot3, host, config, hooks, identity);
+    workers.set(key, worker);
+  } else {
+    worker.update(config, hooks, options);
+  }
+  workerKeysByProject.set(projectKey, key);
+  worker.start();
+}
+function updateBackgroundWorkerConfig(projectRoot3, host, config) {
+  const projectKey = projectLookupKey(projectRoot3, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  configureBackgroundWorker(projectRoot3, host, config, worker.getHooksForConfig(config), {
+    stopPreviousAutoIndex: false,
+    restartAutoIndex: true
+  });
+}
+function waitForBackgroundWorkerStart(projectRoot3, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot3, host));
+  return workers.get(key ?? "")?.waitForStart() ?? Promise.resolve();
+}
+function requestBackgroundWorkerRefresh(projectRoot3, host, allowDisabledAutoIndex = false) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot3, host));
+  workers.get(key ?? "")?.requestRefresh(allowDisabledAutoIndex);
+}
+function isBackgroundWorkerManaged(projectRoot3, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot3, host));
+  return key !== void 0 && workers.has(key);
+}
+function isBackgroundWorkerLeader(projectRoot3, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot3, host));
+  return key !== void 0 && workers.get(key)?.isLeader() === true;
+}
+async function stopBackgroundWorker(projectRoot3, host) {
+  const projectKey = projectLookupKey(projectRoot3, 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);
 var import_fs7 = require("fs");
-var path11 = __toESM(require("path"), 1);
+var path12 = __toESM(require("path"), 1);
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -4070,7 +4944,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot3) {
   for (const marker of PROJECT_MARKERS) {
-    if ((0, import_fs7.existsSync)(path11.join(projectRoot3, marker))) {
+    if ((0, import_fs7.existsSync)(path12.join(projectRoot3, marker))) {
       return true;
     }
   }
@@ -4097,33 +4971,53 @@ function createIgnoreFilter(projectRoot3) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path11.join(projectRoot3, ".gitignore");
+  const gitignorePath = path12.join(projectRoot3, ".gitignore");
   if ((0, import_fs7.existsSync)(gitignorePath)) {
     const gitignoreContent = (0, import_fs7.readFileSync)(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
-function shouldIncludeFile(filePath, projectRoot3, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path11.relative(projectRoot3, filePath);
-  if (hasFilteredPathSegment(relativePath, path11.sep)) {
-    return false;
-  }
-  if (ignoreFilter.ignores(relativePath)) {
-    return false;
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path12.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) {
-    if (matchGlob(relativePath, pattern)) {
-      return false;
+    const posixPattern = toPosixRelativePath(pattern).replace(/\/+$/, "");
+    if (!posixPattern.endsWith("/**")) {
+      continue;
     }
-  }
-  for (const pattern of includePatterns) {
-    if (matchGlob(relativePath, pattern)) {
+    const directoryPattern = posixPattern.slice(0, -3);
+    if (directoryPattern && matchesAnyGlob(normalized, [directoryPattern])) {
       return true;
     }
   }
   return false;
 }
+function shouldIncludeFile(filePath, projectRoot3, includePatterns, excludePatterns, ignoreFilter) {
+  const relativePath = toPosixRelativePath(path12.relative(projectRoot3, filePath));
+  if (hasFilteredPathSegment(relativePath, "/")) {
+    return false;
+  }
+  if (ignoreFilter.ignores(relativePath)) {
+    return false;
+  }
+  if (isExcludedByPatterns(relativePath, excludePatterns)) {
+    return false;
+  }
+  return matchesAnyGlob(relativePath, includePatterns);
+}
 function matchGlob(filePath, pattern) {
   if (pattern.startsWith("**/")) {
     const withoutPrefix = pattern.slice(3);
@@ -4144,8 +5038,8 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path11.join(dir, entry.name);
-    const relativePath = path11.relative(projectRoot3, fullPath);
+    const fullPath = path12.join(dir, entry.name);
+    const relativePath = toPosixRelativePath(path12.relative(projectRoot3, fullPath));
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -4163,6 +5057,10 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
       continue;
     }
     if (entry.isDirectory()) {
+      if (isExcludedDirectory(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
+      }
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
       const stat5 = await import_fs7.promises.stat(fullPath);
@@ -4170,20 +5068,11 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
         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: stat5.size });
       }
     }
@@ -4194,7 +5083,7 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path11.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: toPosixRelativePath(path12.relative(projectRoot3, filesInDir[i].path)), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -4234,8 +5123,8 @@ async function collectFiles(projectRoot3, includePatterns, excludePatterns, maxF
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path11.normalize(
-        path11.isAbsolute(kbRoot) ? kbRoot : path11.resolve(projectRoot3, kbRoot)
+      const resolved = path12.normalize(
+        path12.isAbsolute(kbRoot) ? kbRoot : path12.resolve(projectRoot3, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -4276,7 +5165,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runCommand(file, args, options) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     childProcess.execFile(
       file,
       args,
@@ -4286,7 +5175,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve17(stdout);
+        resolve18(stdout);
       }
     );
   });
@@ -4378,8 +5267,8 @@ var AutoIndexCancelledError = class extends Error {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function canonicalizePath(targetPath) {
-  const resolved = path12.resolve(targetPath);
+function canonicalizePath2(targetPath) {
+  const resolved = path13.resolve(targetPath);
   if ((0, import_fs8.existsSync)(resolved)) {
     try {
       return import_fs8.realpathSync.native(resolved);
@@ -4387,20 +5276,20 @@ function canonicalizePath(targetPath) {
       return resolved;
     }
   }
-  const parent = path12.dirname(resolved);
+  const parent = path13.dirname(resolved);
   if (parent === resolved) return resolved;
-  return path12.join(canonicalizePath(parent), path12.basename(resolved));
+  return path13.join(canonicalizePath2(parent), path13.basename(resolved));
 }
 function isHomeDirectory(projectRoot3) {
-  return canonicalizePath(projectRoot3) === canonicalizePath(os4.homedir());
+  return canonicalizePath2(projectRoot3) === canonicalizePath2(os5.homedir());
 }
-function projectLookupKey(projectRoot3, host) {
-  return `${host}::${canonicalizePath(projectRoot3)}`;
+function projectLookupKey2(projectRoot3, host) {
+  return `${host}::${canonicalizePath2(projectRoot3)}`;
 }
 function coordinatorKey(projectRoot3, config, host) {
-  const canonicalProjectRoot = canonicalizePath(projectRoot3);
+  const canonicalProjectRoot = canonicalizePath2(projectRoot3);
   const indexPath = resolveProjectIndexPath(projectRoot3, config.scope, host);
-  return `${canonicalizePath(indexPath)}::${canonicalProjectRoot}`;
+  return `${canonicalizePath2(indexPath)}::${canonicalProjectRoot}`;
 }
 function getProjectSafety(projectRoot3, config) {
   if (isHomeDirectory(projectRoot3)) {
@@ -4431,10 +5320,10 @@ function safeFailureMessage(error) {
 }
 function cancellableDelay(delayMs, signal) {
   if (signal.aborted) return Promise.reject(new AutoIndexCancelledError());
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve17();
+      resolve18();
     }, delayMs);
     timer.unref?.();
     const onAbort = () => {
@@ -4446,18 +5335,44 @@ function cancellableDelay(delayMs, signal) {
 }
 function withTimeout(promise, timeoutMs) {
   if (timeoutMs <= 0) return Promise.resolve(void 0);
-  return new Promise((resolve17) => {
-    const timer = setTimeout(() => resolve17(void 0), timeoutMs);
+  return new Promise((resolve18) => {
+    const timer = setTimeout(() => resolve18(void 0), timeoutMs);
     timer.unref?.();
     void promise.then((value) => {
       clearTimeout(timer);
-      resolve17(value);
+      resolve18(value);
     }, () => {
       clearTimeout(timer);
-      resolve17(void 0);
+      resolve18(void 0);
     });
   });
 }
+function settlesWithin(promise, timeoutMs) {
+  if (timeoutMs <= 0) return Promise.resolve(false);
+  return new Promise((resolve18) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve18(false);
+    }, timeoutMs);
+    timer.unref?.();
+    void promise.then(
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve18(true);
+      },
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve18(true);
+      }
+    );
+  });
+}
 function requestPriority(request) {
   if (request.force) return 4;
   if (request.source === "manual") return 3;
@@ -4468,6 +5383,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,
@@ -4529,11 +5445,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) {
@@ -4608,13 +5524,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)) {
@@ -4803,7 +5721,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");
@@ -4836,17 +5754,17 @@ var AutoIndexCoordinator = class {
     }
   }
   waitForBatteryRetry(delayMs) {
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       const timer = setTimeout(() => {
         if (this.batteryRetryTimer === timer) {
           this.batteryRetryTimer = null;
           this.resolveBatteryRetry = null;
         }
-        resolve17();
+        resolve18();
       }, delayMs);
       timer.unref?.();
       this.batteryRetryTimer = timer;
-      this.resolveBatteryRetry = resolve17;
+      this.resolveBatteryRetry = resolve18;
     });
   }
   cancelBatteryRetry() {
@@ -4854,9 +5772,9 @@ var AutoIndexCoordinator = class {
       clearTimeout(this.batteryRetryTimer);
       this.batteryRetryTimer = null;
     }
-    const resolve17 = this.resolveBatteryRetry;
+    const resolve18 = this.resolveBatteryRetry;
     this.resolveBatteryRetry = null;
-    resolve17?.();
+    resolve18?.();
   }
   finishBatteryCheck(batteryCheck) {
     if (this.batteryCheck !== batteryCheck) return;
@@ -4869,12 +5787,25 @@ var AutoIndexCoordinator = class {
   }
 };
 function getCoordinator(projectRoot3, host) {
-  const key = coordinatorKeysByProject.get(projectLookupKey(projectRoot3, host));
+  const key = coordinatorKeysByProject.get(projectLookupKey2(projectRoot3, host));
   return key ? coordinators.get(key) ?? null : null;
 }
-function configureAutoIndex(projectRoot3, host, config, getIndexer) {
-  const projectKey = projectLookupKey(projectRoot3, host);
+function synchronizeBackgroundWorker(projectRoot3, host, config, safeToRun) {
+  if (safeToRun) {
+    updateBackgroundWorkerConfig(projectRoot3, host, config);
+    return;
+  }
+  void stopBackgroundWorker(projectRoot3, host).catch((error) => {
+    console.error("[codebase-index] Failed to stop background worker after project safety changed:", error);
+  });
+}
+function configureAutoIndex(projectRoot3, host, config, getIndexer, options = {}) {
+  const projectKey = projectLookupKey2(projectRoot3, host);
   const safety = getProjectSafety(projectRoot3, config);
+  const synchronizeWorker = options.synchronizeBackgroundWorker ?? true;
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot3, host)) {
+    return;
+  }
   const registration = {
     backgroundIndexingPolicy: createBackgroundIndexingPolicy(
       config.indexing.pauseBackgroundIndexingOnBattery
@@ -4892,6 +5823,9 @@ function configureAutoIndex(projectRoot3, 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(projectRoot3, host, config, safety.safeToRun);
+    }
     coordinators.delete(previousKey);
     const coordinator2 = new AutoIndexCoordinator(registration);
     coordinator2.activateAfter(activation);
@@ -4907,8 +5841,17 @@ function configureAutoIndex(projectRoot3, host, config, getIndexer) {
     coordinator.update(registration);
   }
   coordinatorKeysByProject.set(projectKey, key);
+  if (synchronizeWorker) {
+    synchronizeBackgroundWorker(projectRoot3, host, config, safety.safeToRun);
+  }
+}
+function startAutoIndexForBackgroundWorker(projectRoot3, host, source = "startup", allowDisabledAutoIndex = false) {
+  return getCoordinator(projectRoot3, host)?.start(source, allowDisabledAutoIndex) ?? null;
 }
 function requestBackgroundIndex(projectRoot3, host) {
+  if (isBackgroundWorkerManaged(projectRoot3, host) && !isBackgroundWorkerLeader(projectRoot3, host)) {
+    return null;
+  }
   return getCoordinator(projectRoot3, host)?.request({
     checkFreshness: false,
     force: false,
@@ -4948,15 +5891,23 @@ async function waitForAutoIndexForRetrieval(projectRoot3, 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(projectRoot3, host, coordinator);
   if (job) {
     await withTimeout(job, coordinator.getWaitMs());
+  } else if (isBackgroundWorkerManaged(projectRoot3, 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();
@@ -4977,21 +5928,52 @@ async function waitForAutoIndexForRetrieval(projectRoot3, host) {
     text: `Automatic indexing is ${status.state}. Retry shortly or call index_status for progress. You can also run index_codebase explicitly.`
   };
 }
-async function stopAutoIndex(projectRoot3, host) {
-  await getCoordinator(projectRoot3, host)?.stop();
+async function stopAutoIndexForBackgroundWorker(projectRoot3, host, waitForCompletion = false) {
+  const coordinator = getCoordinator(projectRoot3, host);
+  if (!coordinator) {
+    return { completed: true, completion: Promise.resolve() };
+  }
+  return coordinator.stop(waitForCompletion);
 }
-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(projectRoot3, host, coordinator) {
+  if (isBackgroundWorkerManaged(projectRoot3, host)) {
+    requestBackgroundWorkerRefresh(projectRoot3, host, true);
+    return isBackgroundWorkerLeader(projectRoot3, 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((resolve18) => setTimeout(resolve18, Math.min(250, deadline - Date.now())));
   }
-  return (await indexer.getStatus()).indexed;
 }
 
 // src/tools/config-state.ts
 var import_fs9 = require("fs");
-var path13 = __toESM(require("path"), 1);
+var path14 = __toESM(require("path"), 1);
 function normalizeKnowledgeBasePaths(config, projectRoot3) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -5018,8 +6000,8 @@ function loadEditableConfig(projectRoot3, host) {
 }
 function saveConfig(projectRoot3, config, host) {
   const configPath = getConfigPath(projectRoot3, host);
-  const configDir = path13.dirname(configPath);
-  const configBaseDir = path13.dirname(configDir);
+  const configDir = path14.dirname(configPath);
+  const configBaseDir = path14.dirname(configDir);
   if (!(0, import_fs9.existsSync)(configDir)) {
     (0, import_fs9.mkdirSync)(configDir, { recursive: true });
   }
@@ -5034,7 +6016,7 @@ function saveConfig(projectRoot3, config, host) {
 
 // src/indexer/index.ts
 var import_fs12 = require("fs");
-var path19 = __toESM(require("path"), 1);
+var path20 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
 var import_child_process4 = require("child_process");
 var import_util4 = require("util");
@@ -5061,7 +6043,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve17, reject) => {
+  const wrappedPromise = new Promise((resolve18, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -5075,7 +6057,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve17, reject);
+    promise.then(resolve18, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -5083,7 +6065,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve17(fallback());
+          resolve18(fallback());
         } catch (error) {
           reject(error);
         }
@@ -5093,7 +6075,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve17();
+        resolve18();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -5495,7 +6477,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve18, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -5535,7 +6517,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve17(result);
+          resolve18(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -5723,13 +6705,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve17();
+        resolve18();
       };
       this.on(event, listener);
     });
@@ -6015,7 +6997,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve17, reject) => {
+    await new Promise((resolve18, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -6023,7 +7005,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve17();
+        resolve18();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -6141,17 +7123,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 };
 }
@@ -7163,8 +8145,8 @@ function extractParamNames(params) {
 }
 
 // src/native/binding.ts
-var os5 = __toESM(require("os"), 1);
-var path14 = __toESM(require("path"), 1);
+var os6 = __toESM(require("os"), 1);
+var path15 = __toESM(require("path"), 1);
 var module2 = __toESM(require("module"), 1);
 var import_node_url = require("url");
 
@@ -7201,7 +8183,7 @@ var STABLE_NATIVE_BINARY_NAME = IDENTITY_CATALOG.native.binaryName;
 
 // src/native/binding.ts
 var import_meta = {};
-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`;
   }
@@ -7219,25 +8201,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((0, import_node_url.fileURLToPath)(import_meta.url));
+    currentDir = path15.dirname((0, import_node_url.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 = module2.createRequire(requireTarget);
   return require2(nativePath);
@@ -7821,8 +8803,8 @@ var Database = class _Database {
 
 // src/git/branch-materialization.ts
 var import_fs10 = require("fs");
-var os6 = __toESM(require("os"), 1);
-var path15 = __toESM(require("path"), 1);
+var os7 = __toESM(require("os"), 1);
+var path16 = __toESM(require("path"), 1);
 
 // src/git/branch-resolution.ts
 var import_child_process = require("child_process");
@@ -8141,13 +9123,13 @@ async function isWorktreeRegistered(projectRoot3, worktreePath) {
   return false;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const relative13 = path15.relative(path15.resolve(rootPath), path15.resolve(filePath));
-  return relative13 === "" || !relative13.startsWith(`..${path15.sep}`) && relative13 !== ".." && !path15.isAbsolute(relative13);
+  const relative13 = path16.relative(path16.resolve(rootPath), path16.resolve(filePath));
+  return relative13 === "" || !relative13.startsWith(`..${path16.sep}`) && relative13 !== ".." && !path16.isAbsolute(relative13);
 }
 async function pruneExactMissingWorktreeRegistration(projectRoot3, worktreePath) {
   if (await pathExists(worktreePath)) return false;
   const commonDir = await runGit(projectRoot3, ["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 import_fs10.promises.readdir(registrationsRoot, { withFileTypes: true });
@@ -8158,16 +9140,16 @@ async function pruneExactMissingWorktreeRegistration(projectRoot3, 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 import_fs10.promises.readFile(path15.join(registrationPath, "gitdir"), "utf8")).trim();
+      gitdirPath = (await import_fs10.promises.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 import_fs10.promises.rm(registrationPath, { recursive: true, force: true });
     return true;
   }
@@ -8185,7 +9167,7 @@ async function removeWorktree(projectRoot3, worktreePath) {
     registered = await isWorktreeRegistered(projectRoot3, 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 {
@@ -8201,7 +9183,7 @@ async function removeWorktree(projectRoot3, worktreePath) {
       registered = await isWorktreeRegistered(projectRoot3, 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)) {
@@ -8214,13 +9196,13 @@ async function removeWorktree(projectRoot3, 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 import_fs10.promises.rm(path15.dirname(worktreePath), { recursive: true, force: true });
+    await import_fs10.promises.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(projectRoot3, worktreePath, temporaryRoot) {
@@ -8256,9 +9238,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 import_fs10.promises.mkdtemp(path15.join(os6.tmpdir(), "codebase-index-branch-"));
-  const worktreePath = path15.join(temporaryRoot, "worktree");
-  const hooksPath = path15.join(temporaryRoot, "hooks");
+  const temporaryRoot = await import_fs10.promises.mkdtemp(path16.join(os7.tmpdir(), "codebase-index-branch-"));
+  const worktreePath = path16.join(temporaryRoot, "worktree");
+  const hooksPath = path16.join(temporaryRoot, "hooks");
   await import_fs10.promises.mkdir(hooksPath);
   const info = {
     branch: request.branch,
@@ -8310,7 +9292,7 @@ async function withMaterializedBranch(request, callback) {
 // src/tools/changed-files.ts
 var import_child_process2 = require("child_process");
 var import_fs11 = require("fs");
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_util2 = require("util");
 var execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
 var GH_PR_VIEW_FIELDS = [
@@ -8452,7 +9434,7 @@ function getHeadRepositoryIdentity(data, host) {
   return `${host}/${owner.toLowerCase()}/${repository.replace(/\.git$/i, "").toLowerCase()}`;
 }
 function getLocalRepositoryIdentity(projectRoot3) {
-  let canonicalRoot = path16.resolve(projectRoot3);
+  let canonicalRoot = path17.resolve(projectRoot3);
   try {
     canonicalRoot = import_fs11.realpathSync.native(canonicalRoot);
   } catch {
@@ -8513,17 +9495,17 @@ async function getMergeBase(projectRoot3, baseCommit, headCommit) {
   return commit;
 }
 function normalizeFiles(rawFiles, projectRoot3) {
-  const root = path16.resolve(projectRoot3);
+  const root = path17.resolve(projectRoot3);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const raw of rawFiles) {
     if (raw.length === 0) continue;
-    const absolute = path16.resolve(root, raw);
-    const relative13 = path16.relative(root, absolute);
-    if (path16.isAbsolute(raw) || relative13 === ".." || relative13.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative13)) {
+    const absolute = path17.resolve(root, raw);
+    const relative13 = path17.relative(root, absolute);
+    if (path17.isAbsolute(raw) || relative13 === ".." || relative13.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative13)) {
       throw new Error(`Changed file escapes the project root: ${JSON.stringify(raw)}`);
     }
-    const cleaned = relative13.startsWith(`.${path16.sep}`) ? relative13.slice(2) : relative13;
+    const cleaned = relative13.startsWith(`.${path17.sep}`) ? relative13.slice(2) : relative13;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -8534,7 +9516,7 @@ function normalizeFiles(rawFiles, projectRoot3) {
 
 // src/indexer/git-blame.ts
 var import_child_process3 = require("child_process");
-var path17 = __toESM(require("path"), 1);
+var path18 = __toESM(require("path"), 1);
 var import_util3 = require("util");
 var execFileAsync3 = (0, import_util3.promisify)(import_child_process3.execFile);
 function parseGitBlamePorcelain(output) {
@@ -8572,7 +9554,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(projectRoot3, filePath, startLine, endLine) {
-  const relativePath = path17.relative(projectRoot3, filePath);
+  const relativePath = path18.relative(projectRoot3, filePath);
   try {
     const { stdout } = await execFileAsync3(
       "git",
@@ -9151,8 +10133,8 @@ function pathSegmentsForAffinityMatch(filePath) {
   if (segments.length === 0) {
     return [];
   }
-  const basename7 = segments[segments.length - 1] ?? "";
-  const basenameWithoutExt = basename7.replace(/\.[^/.]+$/u, "");
+  const basename8 = segments[segments.length - 1] ?? "";
+  const basenameWithoutExt = basename8.replace(/\.[^/.]+$/u, "");
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
   return Array.from(/* @__PURE__ */ new Set([
     ...normalizedSegments,
@@ -9461,8 +10443,8 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
 
 // src/indexer/failed-state-persistence.ts
 var fs2 = __toESM(require("fs"), 1);
-var import_node_crypto = require("crypto");
-var path18 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+var path19 = __toESM(require("path"), 1);
 var import_node_string_decoder = require("string_decoder");
 var CURRENT_FAILED_BATCH_VERSION = 1;
 var DEFAULT_MALFORMED_LINE_ACTION = "skip";
@@ -9480,7 +10462,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) {
@@ -9499,7 +10481,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");
   };
@@ -9507,7 +10489,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;
   };
@@ -9653,10 +10635,10 @@ function stripLeadingBomAndWhitespace(value) {
   return result;
 }
 function createTemporaryPath(targetPath) {
-  const randomId = (0, import_node_crypto.createHash)("sha1").update(`${Date.now()}:${(0, import_node_crypto.randomBytes)(8).toString("hex")}`).digest("hex");
-  const targetDir = path18.dirname(targetPath);
-  const baseName = path18.basename(targetPath);
-  return path18.join(targetDir, `.${baseName}.${randomId}.tmp`);
+  const randomId = (0, import_node_crypto2.createHash)("sha1").update(`${Date.now()}:${(0, import_node_crypto2.randomBytes)(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;
@@ -9902,9 +10884,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) {
@@ -10235,10 +11217,10 @@ function matchesHardSearchFilters(candidate, options, projectRoot3) {
   }
   if (options?.directory) {
     const candidatePath = canonicalizePathForComparison(
-      path19.resolve(projectRoot3, candidate.metadata.filePath.replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot3, candidate.metadata.filePath.replace(/\\/g, path20.sep))
     );
     const directoryPath = canonicalizePathForComparison(
-      path19.resolve(projectRoot3, options.directory.trim().replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot3, options.directory.trim().replace(/\\/g, path20.sep))
     );
     if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
@@ -10351,26 +11333,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)}`);
     }
@@ -10394,7 +11387,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);
@@ -10411,10 +11404,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");
@@ -10427,14 +11420,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)
       );
     });
   }
@@ -10442,7 +11435,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path19.resolve(targetPath);
+      return path20.resolve(targetPath);
     }
   }
   getProjectIdentityHash(projectRoot3) {
@@ -10568,7 +11561,7 @@ var Indexer = class _Indexer {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    (0, import_fs12.mkdirSync)(path19.dirname(targetPath), { recursive: true });
+    (0, import_fs12.mkdirSync)(path20.dirname(targetPath), { recursive: true });
     try {
       (0, import_fs12.writeFileSync)(tempPath, data);
       (0, import_fs12.renameSync)(tempPath, targetPath);
@@ -10578,14 +11571,14 @@ var Indexer = class _Indexer {
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path19.join(this.indexPath, "inverted-index.json"),
+      path20.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots(projectRoot3 = this.projectRoot) {
     const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(projectRoot3)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(this.getCanonicalPath(path19.resolve(projectRoot3, kbRoot)));
+      roots.add(this.getCanonicalPath(path20.resolve(projectRoot3, kbRoot)));
     }
     return Array.from(roots);
   }
@@ -11002,7 +11995,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 && (0, import_fs12.existsSync)(path19.join(this.indexPath, "force-index-phase"));
+    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && (0, import_fs12.existsSync)(path20.join(this.indexPath, "force-index-phase"));
   }
   async recoverFromInterruptedIndexingUnlocked(owners) {
     for (const owner of owners) {
@@ -11390,7 +12383,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((resolve17) => setTimeout(resolve17, options.rateLimitState.backoffMs));
+          await new Promise((resolve18) => setTimeout(resolve18, options.rateLimitState.backoffMs));
         }
         try {
           const embeddingResult = await pRetry(
@@ -11809,12 +12802,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() {
@@ -11839,10 +12832,10 @@ 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 = (0, import_fs12.existsSync)(storePath);
       const vectorMetadataExists = (0, import_fs12.existsSync)(vectorMetadataPath);
@@ -11958,10 +12951,10 @@ 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");
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     let dbIsNew = !(0, import_fs12.existsSync)(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
@@ -12139,7 +13132,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;
@@ -12154,7 +13147,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();
@@ -12241,7 +13234,7 @@ var Indexer = class _Indexer {
     const names = await import_fs12.promises.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) => import_fs12.promises.rm(path19.join(this.indexPath, name), { force: true }))
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => import_fs12.promises.rm(path20.join(this.indexPath, name), { force: true }))
     );
   }
   async resetLocalIndexArtifacts() {
@@ -12257,13 +13250,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) => import_fs12.promises.rm(targetPath, { recursive: true, force: true })));
     await this.removeProjectRuntimeStateArtifacts();
@@ -12273,7 +13266,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") {
@@ -12660,10 +13653,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];
@@ -12707,8 +13700,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);
@@ -12767,7 +13760,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);
@@ -12871,7 +13864,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) {
@@ -13206,7 +14199,7 @@ var Indexer = class _Indexer {
           previousBranchSymbolIds,
           Array.from(allSymbolIds)
         );
-        const vectorPath = path19.join(this.indexPath, "vectors");
+        const vectorPath = path20.join(this.indexPath, "vectors");
         const shouldFingerprintLegacyPair = !store.hasFingerprint() && (0, import_fs12.existsSync)(vectorPath) && (0, import_fs12.existsSync)(`${vectorPath}.meta.json`);
         if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
           store.save();
@@ -14065,7 +15058,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);
@@ -14095,7 +15088,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 };
@@ -14108,7 +15102,7 @@ var Indexer = class _Indexer {
       const retryableChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
         roots,
-        () => true,
+        shouldProcessFailedPath,
         maxChunkTokens
       );
       for (const retryBatch of iterateOrderedFileBatches(
@@ -14378,9 +15372,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path25 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path25.length > 0 && (shortest.length === 0 || path25.length < shortest.length)) {
-        shortest = path25;
+      const path26 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path26.length > 0 && (shortest.length === 0 || path26.length < shortest.length)) {
+        shortest = path26;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -14428,13 +15422,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path25 = [];
+      const path26 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path25.push({
+        path26.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -14444,9 +15438,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path25.reverse();
-      if (path25.length > 0 && (shortest.length === 0 || path25.length < shortest.length)) {
-        shortest = path25;
+      path26.reverse();
+      if (path26.length > 0 && (shortest.length === 0 || path26.length < shortest.length)) {
+        shortest = path26;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -14597,7 +15591,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);
@@ -14746,12 +15740,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;
           }
@@ -14868,7 +15862,10 @@ function getOrCreateIndexer(projectRoot3, host) {
   }
   const indexer = new Indexer(projectRoot3, config, host);
   indexerCache.set(key, indexer);
-  configureAutoIndex(projectRoot3, host, config, () => getOrCreateIndexer(projectRoot3, host));
+  configureAutoIndex(projectRoot3, host, config, () => getOrCreateIndexer(projectRoot3, host), {
+    preserveManagedWorker: true,
+    synchronizeBackgroundWorker: false
+  });
   return indexer;
 }
 function getIndexerForProject(projectRoot3, host) {
@@ -14883,7 +15880,9 @@ function refreshIndexerForDirectory(projectRoot3, host, config = parseConfig(loa
   const key = getIndexerCacheKey(projectRoot3, host);
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot3, config, host));
-  configureAutoIndex(projectRoot3, host, config, () => getOrCreateIndexer(projectRoot3, host));
+  configureAutoIndex(projectRoot3, host, config, () => getOrCreateIndexer(projectRoot3, host), {
+    synchronizeBackgroundWorker: true
+  });
   return config;
 }
 var AutoIndexRetrievalUnavailableError = class extends Error {
@@ -14910,7 +15909,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);
   }
@@ -15103,12 +16102,12 @@ async function getCallGraphPath(projectRoot3, host, from, to, maxDepth, fromFile
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path25 = await indexer.findCallPathBySymbolIds(
+  const path26 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path25 };
+  return { from: fromResolution, to: toResolution, path: path26 };
 }
 async function runIndexCodebase(projectRoot3, host, args, onProgress) {
   const root = getProjectRoot(projectRoot3, host);
@@ -15306,8 +16305,8 @@ async function getIndexLogs(projectRoot3, host, args) {
 function addKnowledgeBase(projectRoot3, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot3, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath2 = path20.resolve(
-    path20.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  const normalizedPath2 = path21.resolve(
+    path21.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
   if (!(0, import_fs13.existsSync)(normalizedPath2)) {
     return `Error: Directory does not exist: ${normalizedPath2}`;
@@ -15343,7 +16342,7 @@ function addKnowledgeBase(projectRoot3, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path20.join(homeDir, dotDir);
+    const sensitiveDir = path21.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath2}`;
     }
@@ -15406,7 +16405,7 @@ function listKnowledgeBases(projectRoot3, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = (0, import_fs13.existsSync)(path20.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = (0, import_fs13.existsSync)(path21.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -15879,7 +16878,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot3, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path25 = await getCallGraphPath(
+    const path26 = await getCallGraphPath(
       projectRoot3,
       host,
       from,
@@ -15888,25 +16887,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot3, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path25);
-    if (path25.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path26);
+    if (path26.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path25.path.length)
+        details: fittedDetails("path", fitted2, path26.path.length)
       };
     }
-    if (path25.from.status !== "resolved" || path25.to.status !== "resolved") {
+    if (path26.from.status !== "resolved" || path26.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path25.from;
+    const resolvedFrom = path26.from;
     const { callers } = await getCallGraphData(projectRoot3, host, {
       name: to,
       direction: "callers",
@@ -16351,7 +17350,7 @@ var import_fs14 = require("fs");
 
 // node_modules/chokidar/index.js
 var import_node_events = require("events");
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises3 = require("fs/promises");
 var sp2 = __toESM(require("path"), 1);
 
@@ -16439,7 +17438,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path25) => statMethod(path25, { bigint: true });
+      this._stat = (path26) => statMethod(path26, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -16464,8 +17463,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path25, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path25));
+          const { path: path26, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path26));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -16505,21 +17504,21 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path25, depth) {
+  async _exploreDir(path26, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path25, this._rdOptions);
+      files = await (0, import_promises.readdir)(path26, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path25 };
+    return { files, depth, path: path26 };
   }
-  async _formatEntry(dirent, path25) {
+  async _formatEntry(dirent, path26) {
     let entry;
-    const basename7 = this._isDirent ? dirent.name : dirent;
+    const basename8 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path25, basename7));
-      entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename7 };
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path26, basename8));
+      entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename8 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -16589,7 +17588,7 @@ function readdirp(root, options = {}) {
 }
 
 // node_modules/chokidar/handler.js
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_node_os = require("os");
 var sp = __toESM(require("path"), 1);
@@ -16918,16 +17917,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path25, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path26, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path25);
-    emitRaw(rawEvent, evPath, { watchedPath: path25 });
-    if (evPath && path25 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path25, evPath), KEY_LISTENERS, sp.join(path25, evPath));
+    listener(path26);
+    emitRaw(rawEvent, evPath, { watchedPath: path26 });
+    if (evPath && path26 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path26, evPath), KEY_LISTENERS, sp.join(path26, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path25, {
+    return (0, import_node_fs2.watch)(path26, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -16943,12 +17942,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path25, fullPath, options, handlers) => {
+var setFsWatchListener = (path26, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path25, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path26, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -16959,7 +17958,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path25,
+      path26,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -16974,7 +17973,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path25, "r");
+          const fd = await (0, import_promises2.open)(path26, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -17005,12 +18004,12 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path26, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
   if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    (0, import_node_fs.unwatchFile)(fullPath);
+    (0, import_node_fs2.unwatchFile)(fullPath);
     cont = void 0;
   }
   if (cont) {
@@ -17021,13 +18020,13 @@ var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: (0, import_node_fs.watchFile)(fullPath, options, (curr, prev) => {
+      watcher: (0, import_node_fs2.watchFile)(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter2) => {
           rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path25, curr));
+          foreach(cont.listeners, (listener2) => listener2(path26, curr));
         }
       })
     };
@@ -17038,7 +18037,7 @@ var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      (0, import_node_fs.unwatchFile)(fullPath);
+      (0, import_node_fs2.unwatchFile)(fullPath);
       cont.options = cont.watcher = void 0;
       Object.freeze(cont);
     }
@@ -17057,13 +18056,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path25, listener) {
+  _watchWithNodeFs(path26, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path25);
-    const basename7 = sp.basename(path25);
+    const directory = sp.dirname(path26);
+    const basename8 = sp.basename(path26);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename7);
-    const absolutePath = sp.resolve(path25);
+    parent.add(basename8);
+    const absolutePath = sp.resolve(path26);
     const options = {
       persistent: opts.persistent
     };
@@ -17072,13 +18071,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path25, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path26, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path25, absolutePath, options, {
+      closer = setFsWatchListener(path26, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -17094,13 +18093,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname13 = sp.dirname(file);
-    const basename7 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname13);
+    const dirname14 = sp.dirname(file);
+    const basename8 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname14);
     let prevStats = stats;
-    if (parent.has(basename7))
+    if (parent.has(basename8))
       return;
-    const listener = async (path25, newStats) => {
+    const listener = async (path26, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -17114,18 +18113,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path25);
+            this.fsw._closeFile(path26);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path25, closer2);
+              this.fsw._addPathCloser(path26, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname13, basename7);
+          this.fsw._remove(dirname14, basename8);
         }
-      } else if (parent.has(basename7)) {
+      } else if (parent.has(basename8)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -17150,7 +18149,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path25, item) {
+  async _handleSymlink(entry, directory, path26, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -17160,7 +18159,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path25);
+        linkPath = await (0, import_promises2.realpath)(path26);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -17170,12 +18169,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path25, entry.stats);
+          this.fsw._emit(EV.CHANGE, path26, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path25, entry.stats);
+        this.fsw._emit(EV.ADD, path26, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -17205,9 +18204,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path25 = sp.join(directory, item);
+      let path26 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path25, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path26, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -17216,11 +18215,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path25 = sp.join(dir, sp.relative(dir, path25));
-        this._addToNodeFs(path25, initialAdd, wh, depth + 1);
+        path26 = sp.join(dir, sp.relative(dir, path26));
+        this._addToNodeFs(path26, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve18, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -17229,7 +18228,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve17(void 0);
+        resolve18(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -17286,13 +18285,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path25, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path26, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path25) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path26) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path25);
+    const wh = this.fsw._getWatchHelpers(path26);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -17308,8 +18307,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path25);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path25) : path25;
+        const absPath = sp.resolve(path26);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path26) : path26;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -17319,29 +18318,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path25) : path25;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path26) : path26;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path25, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path26, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path25), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path26), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path25, closer);
+        this.fsw._addPathCloser(path26, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path25;
+        return path26;
       }
     }
   }
@@ -17384,24 +18383,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path25) {
-  if (typeof path25 !== "string")
+function normalizePath2(path26) {
+  if (typeof path26 !== "string")
     throw new Error("string expected");
-  path25 = sp2.normalize(path25);
-  path25 = path25.replace(/\\/g, "/");
+  path26 = sp2.normalize(path26);
+  path26 = path26.replace(/\\/g, "/");
   let prepend = false;
-  if (path25.startsWith("//"))
+  if (path26.startsWith("//"))
     prepend = true;
-  path25 = path25.replace(DOUBLE_SLASH_RE, "/");
+  path26 = path26.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path25 = "/" + path25;
-  return path25;
+    path26 = "/" + path26;
+  return path26;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path25 = normalizePath2(testString);
+  const path26 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path25, stats)) {
+    if (pattern(path26, stats)) {
       return true;
     }
   }
@@ -17439,19 +18438,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path25) => toUnix(sp2.normalize(toUnix(path25)));
-var normalizeIgnored = (cwd = "") => (path25) => {
-  if (typeof path25 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path25) ? path25 : sp2.join(cwd, path25));
+var normalizePathToUnix = (path26) => toUnix(sp2.normalize(toUnix(path26)));
+var normalizeIgnored = (cwd = "") => (path26) => {
+  if (typeof path26 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path26) ? path26 : sp2.join(cwd, path26));
   } else {
-    return path25;
+    return path26;
   }
 };
-var getAbsolutePath = (path25, cwd) => {
-  if (sp2.isAbsolute(path25)) {
-    return path25;
+var getAbsolutePath = (path26, cwd) => {
+  if (sp2.isAbsolute(path26)) {
+    return path26;
   }
-  return sp2.join(cwd, path25);
+  return sp2.join(cwd, path26);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -17516,10 +18515,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path25, follow, fsw) {
+  constructor(path26, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path25;
-    this.path = path25 = path25.replace(REPLACER_RE, "");
+    const watchPath = path26;
+    this.path = path26 = path26.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -17659,20 +18658,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path25) => {
-        const absPath = getAbsolutePath(path25, cwd);
+      paths = paths.map((path26) => {
+        const absPath = getAbsolutePath(path26, cwd);
         return absPath;
       });
     }
-    paths.forEach((path25) => {
-      this._removeIgnoredPath(path25);
+    paths.forEach((path26) => {
+      this._removeIgnoredPath(path26);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path25) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path25, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path26) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path26, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -17694,17 +18693,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path25) => {
-      if (!sp2.isAbsolute(path25) && !this._closers.has(path25)) {
+    paths.forEach((path26) => {
+      if (!sp2.isAbsolute(path26) && !this._closers.has(path26)) {
         if (cwd)
-          path25 = sp2.join(cwd, path25);
-        path25 = sp2.resolve(path25);
+          path26 = sp2.join(cwd, path26);
+        path26 = sp2.resolve(path26);
       }
-      this._closePath(path25);
-      this._addIgnoredPath(path25);
-      if (this._watched.has(path25)) {
+      this._closePath(path26);
+      this._addIgnoredPath(path26);
+      if (this._watched.has(path26)) {
         this._addIgnoredPath({
-          path: path25,
+          path: path26,
           recursive: true
         });
       }
@@ -17768,38 +18767,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path25, stats) {
+  async _emit(event, path26, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path25 = sp2.normalize(path25);
+      path26 = sp2.normalize(path26);
     if (opts.cwd)
-      path25 = sp2.relative(opts.cwd, path25);
-    const args = [path25];
+      path26 = sp2.relative(opts.cwd, path26);
+    const args = [path26];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path25))) {
+    if (awf && (pw = this._pendingWrites.get(path26))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path25, [event, ...args]);
+        this._pendingUnlinks.set(path26, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path26) => {
+          this._pendingUnlinks.forEach((entry, path27) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path26);
+            this._pendingUnlinks.delete(path27);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path25)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path26)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path25);
+        this._pendingUnlinks.delete(path26);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -17817,16 +18816,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path25, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path26, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path25, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path26, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path25) : path25;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path26) : path26;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -17857,23 +18856,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path25, timeout) {
+  _throttle(actionType, path26, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path25);
+    const actionPath = action.get(path26);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path25);
+      const item = action.get(path26);
       const count = item ? item.count : 0;
-      action.delete(path25);
+      action.delete(path26);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -17881,7 +18880,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path25, thr);
+    action.set(path26, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -17895,44 +18894,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path25, threshold, event, awfEmit) {
+  _awaitWriteFinish(path26, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path25;
-    if (this.options.cwd && !sp2.isAbsolute(path25)) {
-      fullPath = sp2.join(this.options.cwd, path25);
+    let fullPath = path26;
+    if (this.options.cwd && !sp2.isAbsolute(path26)) {
+      fullPath = sp2.join(this.options.cwd, path26);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
-      (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path25)) {
+      (0, import_node_fs3.stat)(fullPath, (err, curStat) => {
+        if (err || !writes.has(path26)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path25).lastChange = now3;
+          writes.get(path26).lastChange = now3;
         }
-        const pw = writes.get(path25);
+        const pw = writes.get(path26);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path25);
+          writes.delete(path26);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path25)) {
-      writes.set(path25, {
+    if (!writes.has(path26)) {
+      writes.set(path26, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path25);
+          writes.delete(path26);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -17943,8 +18942,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path25, stats) {
-    if (this.options.atomic && DOT_RE.test(path25))
+  _isIgnored(path26, stats) {
+    if (this.options.atomic && DOT_RE.test(path26))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -17954,17 +18953,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path25, stats);
+    return this._userIgnored(path26, stats);
   }
-  _isntIgnored(path25, stat5) {
-    return !this._isIgnored(path25, stat5);
+  _isntIgnored(path26, stat5) {
+    return !this._isIgnored(path26, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path25) {
-    return new WatchHelper(path25, this.options.followSymlinks, this);
+  _getWatchHelpers(path26) {
+    return new WatchHelper(path26, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -17996,63 +18995,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path25 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path25);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path25) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path25, 100))
+    const path26 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path26);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path26) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path26, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path25);
+    const wp = this._getWatchedDir(path26);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path25, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path26, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path25;
+    let relPath = path26;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path25);
+      relPath = sp2.relative(this.options.cwd, path26);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path25);
+    this._watched.delete(path26);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path25))
-      this._emit(eventName, path25);
-    this._closePath(path25);
+    if (wasTracked && !this._isIgnored(path26))
+      this._emit(eventName, path26);
+    this._closePath(path26);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path25) {
-    this._closeFile(path25);
-    const dir = sp2.dirname(path25);
-    this._getWatchedDir(dir).remove(sp2.basename(path25));
+  _closePath(path26) {
+    this._closeFile(path26);
+    const dir = sp2.dirname(path26);
+    this._getWatchedDir(dir).remove(sp2.basename(path26));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path25) {
-    const closers = this._closers.get(path25);
+  _closeFile(path26) {
+    const closers = this._closers.get(path26);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path25);
+    this._closers.delete(path26);
   }
-  _addPathCloser(path25, closer) {
+  _addPathCloser(path26, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path25);
+    let list = this._closers.get(path26);
     if (!list) {
       list = [];
-      this._closers.set(path25, list);
+      this._closers.set(path26, list);
     }
     list.push(closer);
   }
@@ -18082,11 +19081,11 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-var path23 = __toESM(require("path"), 1);
+var path24 = __toESM(require("path"), 1);
 
 // src/watcher/native-recursive-watcher.ts
-var import_node_fs3 = require("fs");
-var path21 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var path22 = __toESM(require("path"), 1);
 var NativeRecursiveWatcher = class {
   constructor(root, onChange, options = {}) {
     this.root = root;
@@ -18134,26 +19133,26 @@ var NativeRecursiveWatcher = class {
   toAbsolutePath(filename) {
     if (filename == null) return null;
     const normalizedFilename = typeof filename === "string" ? filename : filename.toString();
-    const absolutePath = path21.resolve(this.root, normalizedFilename);
-    const relativePath = path21.relative(this.root, absolutePath);
-    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path21.sep}`) || path21.isAbsolute(relativePath);
+    const absolutePath = path22.resolve(this.root, normalizedFilename);
+    const relativePath = path22.relative(this.root, absolutePath);
+    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path22.sep}`) || path22.isAbsolute(relativePath);
     return outsideRoot ? null : absolutePath;
   }
-  defaultWatchFactory = (root, listener, options) => (0, import_node_fs3.watch)(root, options, listener);
+  defaultWatchFactory = (root, listener, options) => (0, import_node_fs4.watch)(root, options, listener);
 };
 
 // src/watcher/snapshot.ts
 var fsPromises4 = __toESM(require("fs/promises"), 1);
-var path22 = __toESM(require("path"), 1);
+var path23 = __toESM(require("path"), 1);
 async function buildFileSnapshotScan(projectRoot3, config, configPaths = []) {
-  const normalizedProjectRoot = path22.resolve(projectRoot3);
+  const normalizedProjectRoot = path23.resolve(projectRoot3);
   const ignoreFilter = createIgnoreFilter(normalizedProjectRoot);
   const includePatterns = [...config.include, ...config.additionalInclude ?? []];
   const maxDepth = config.indexing?.maxDepth ?? -1;
   const snapshot = /* @__PURE__ */ new Map();
   const unreadablePrefixes = /* @__PURE__ */ new Set();
   const includeFile = async (filePath) => {
-    const normalizedPath2 = path22.resolve(filePath);
+    const normalizedPath2 = path23.resolve(filePath);
     if (!shouldIncludeFile(normalizedPath2, normalizedProjectRoot, includePatterns, config.exclude, ignoreFilter)) return;
     const stat5 = await readStatIfFile(normalizedPath2, unreadablePrefixes);
     if (stat5) snapshot.set(normalizedPath2, { size: stat5.size, mtimeMs: stat5.mtimeMs });
@@ -18165,16 +19164,16 @@ async function buildFileSnapshotScan(projectRoot3, config, configPaths = []) {
     } catch (error) {
       if (isMissingFsError(error)) return;
       if (isPermissionFsError(error)) {
-        unreadablePrefixes.add(path22.resolve(directoryPath));
+        unreadablePrefixes.add(path23.resolve(directoryPath));
         return;
       }
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path22.join(directoryPath, entry.name);
-      const relativePath = path22.relative(normalizedProjectRoot, fullPath);
+      const fullPath = path23.join(directoryPath, entry.name);
+      const relativePath = path23.relative(normalizedProjectRoot, fullPath);
       if (entry.isDirectory()) {
-        if (hasFilteredPathSegment(relativePath, path22.sep) || isRestrictedDirectory(relativePath, path22.sep)) continue;
+        if (hasFilteredPathSegment(relativePath, path23.sep) || isRestrictedDirectory(relativePath, path23.sep)) continue;
         if (ignoreFilter.ignores(relativePath)) continue;
         if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -18187,19 +19186,19 @@ async function buildFileSnapshotScan(projectRoot3, config, configPaths = []) {
   return { entries: snapshot, unreadablePrefixes };
 }
 async function buildFileSnapshotForPathScan(projectRoot3, config, configPaths, targetPath) {
-  const normalizedProjectRoot = path22.resolve(projectRoot3);
-  const normalizedTargetPath = path22.resolve(targetPath);
+  const normalizedProjectRoot = path23.resolve(projectRoot3);
+  const normalizedTargetPath = path23.resolve(targetPath);
   if (!isWithinPath(normalizedProjectRoot, normalizedTargetPath)) {
     return { entries: /* @__PURE__ */ new Map(), unreadablePrefixes: /* @__PURE__ */ new Set() };
   }
   const ignoreFilter = createIgnoreFilter(normalizedProjectRoot);
   const includePatterns = [...config.include, ...config.additionalInclude ?? []];
   const maxDepth = config.indexing?.maxDepth ?? -1;
-  const explicitConfigPaths = new Set(configPaths.map((configPath) => path22.resolve(configPath)));
+  const explicitConfigPaths = new Set(configPaths.map((configPath) => path23.resolve(configPath)));
   const snapshot = /* @__PURE__ */ new Map();
   const unreadablePrefixes = /* @__PURE__ */ new Set();
   const includeFile = async (filePath) => {
-    const normalizedPath2 = path22.resolve(filePath);
+    const normalizedPath2 = path23.resolve(filePath);
     if (!explicitConfigPaths.has(normalizedPath2) && !shouldIncludeFile(
       normalizedPath2,
       normalizedProjectRoot,
@@ -18217,16 +19216,16 @@ async function buildFileSnapshotForPathScan(projectRoot3, config, configPaths, t
     } catch (error) {
       if (isMissingFsError(error)) return;
       if (isPermissionFsError(error)) {
-        unreadablePrefixes.add(path22.resolve(directoryPath));
+        unreadablePrefixes.add(path23.resolve(directoryPath));
         return;
       }
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path22.join(directoryPath, entry.name);
-      const relativePath = path22.relative(normalizedProjectRoot, fullPath);
+      const fullPath = path23.join(directoryPath, entry.name);
+      const relativePath = path23.relative(normalizedProjectRoot, fullPath);
       if (entry.isDirectory()) {
-        if (hasFilteredPathSegment(relativePath, path22.sep) || isRestrictedDirectory(relativePath, path22.sep)) continue;
+        if (hasFilteredPathSegment(relativePath, path23.sep) || isRestrictedDirectory(relativePath, path23.sep)) continue;
         if (ignoreFilter.ignores(relativePath)) continue;
         if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -18250,7 +19249,7 @@ function completeFileSnapshot(previous, scan) {
   return completed;
 }
 async function includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths) {
-  for (const configPath of [...new Set(configPaths.map((value) => path22.resolve(value)))]) {
+  for (const configPath of [...new Set(configPaths.map((value) => path23.resolve(value)))]) {
     if (snapshot.has(configPath)) continue;
     const stat5 = await readStatIfFile(configPath, unreadablePrefixes);
     if (stat5) snapshot.set(configPath, { size: stat5.size, mtimeMs: stat5.mtimeMs });
@@ -18260,12 +19259,12 @@ async function includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, co
   await includeExplicitConfigPaths(
     snapshot,
     unreadablePrefixes,
-    configPaths.filter((configPath) => isWithinPath(targetPath, path22.resolve(configPath)))
+    configPaths.filter((configPath) => isWithinPath(targetPath, path23.resolve(configPath)))
   );
 }
 function isWithinPath(parentPath, childPath) {
-  const relativePath = path22.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith(`..${path22.sep}`) && relativePath !== ".." && !path22.isAbsolute(relativePath);
+  const relativePath = path23.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path23.sep}`) && relativePath !== ".." && !path23.isAbsolute(relativePath);
 }
 async function readStatIfFile(filePath, unreadablePrefixes) {
   try {
@@ -18274,7 +19273,7 @@ async function readStatIfFile(filePath, unreadablePrefixes) {
   } catch (error) {
     if (isMissingFsError(error)) return null;
     if (isPermissionFsError(error)) {
-      unreadablePrefixes.add(path22.resolve(filePath));
+      unreadablePrefixes.add(path23.resolve(filePath));
       return null;
     }
     throw error;
@@ -18411,8 +19410,8 @@ var FileWatcher = class {
     this.createWatcher();
   }
   resetReady() {
-    this.readyPromise = new Promise((resolve17) => {
-      this.resolveReady = resolve17;
+    this.readyPromise = new Promise((resolve18) => {
+      this.resolveReady = resolve18;
     });
     this.startupReadySignals = 1;
   }
@@ -18443,7 +19442,7 @@ var FileWatcher = class {
     const resolvedWatchTargets = watchTargets ?? this.getFullChokidarWatchTargets();
     const watcherOptions = {
       ignored: (filePath) => {
-        const relativePath = path23.relative(this.projectRoot, filePath);
+        const relativePath = path24.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
@@ -18451,10 +19450,10 @@ var FileWatcher = class {
         if (this.isOutsideProjectPath(relativePath)) {
           return true;
         }
-        if (hasFilteredPathSegment(relativePath, path23.sep)) {
+        if (hasFilteredPathSegment(relativePath, path24.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path23.sep)) {
+        if (isRestrictedDirectory(relativePath, path24.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -18545,13 +19544,13 @@ var FileWatcher = class {
   getExternalConfigWatchTargets() {
     return [...new Set(
       this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path23.relative(this.projectRoot, projectConfigPath);
+        const relativeConfigPath = path24.relative(this.projectRoot, projectConfigPath);
         return this.isOutsideProjectPath(relativeConfigPath);
       }).map((projectConfigPath) => {
         if ((0, import_fs14.existsSync)(projectConfigPath)) {
           return projectConfigPath;
         }
-        return this.getNearestExistingDirectory(path23.dirname(projectConfigPath));
+        return this.getNearestExistingDirectory(path24.dirname(projectConfigPath));
       })
     )];
   }
@@ -18613,7 +19612,7 @@ var FileWatcher = class {
   }
   scheduleNativeReconciliation(generation, filePath) {
     if (!this.isCurrentNativeSetup(generation)) return;
-    const requiresFullReconciliation = filePath === path23.join(this.projectRoot, ".gitignore");
+    const requiresFullReconciliation = filePath === path24.join(this.projectRoot, ".gitignore");
     const invalidatedPath = requiresFullReconciliation ? null : filePath;
     this.nativeInvalidatedPaths.set(invalidatedPath, invalidatedPath !== null);
     if (this.nativeReconcileTimer) {
@@ -18708,23 +19707,23 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path23.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path23.normalize(relativePath);
+    const relativePath = path24.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path24.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path23.normalize(relativePath);
+    const normalizedRelativePath = path24.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path23.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path24.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path23.sep}`) || path23.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path24.sep}`) || path24.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
     while (!(0, import_fs14.existsSync)(candidate)) {
-      const parent = path23.dirname(candidate);
+      const parent = path24.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -18732,7 +19731,7 @@ var FileWatcher = class {
   }
   getProjectConfigRelativePaths() {
     return this.projectConfigPaths.map(
-      (configPath) => path23.normalize(path23.relative(this.projectRoot, configPath))
+      (configPath) => path24.normalize(path24.relative(this.projectRoot, configPath))
     );
   }
   getConfigPathStates() {
@@ -18790,7 +19789,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path25, type]) => ({ path: path25, type })
+      ([path26, type]) => ({ path: path26, type })
     );
     this.pendingChanges.clear();
     try {
@@ -18836,7 +19835,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-var path24 = __toESM(require("path"), 1);
+var path25 = __toESM(require("path"), 1);
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -18858,13 +19857,13 @@ var GitHeadWatcher = class {
       this.readyPromise = Promise.resolve();
       return;
     }
-    this.readyPromise = new Promise((resolve17) => {
-      this.resolveReady = resolve17;
+    this.readyPromise = new Promise((resolve18) => {
+      this.resolveReady = resolve18;
     });
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path24.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path25.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -18932,7 +19931,9 @@ var GitHeadWatcher = class {
 function createWatcherWithIndexer(getIndexer, projectRoot3, config, host, options = {}) {
   const fileWatcher = new FileWatcher(projectRoot3, config, host, options);
   const configPaths = getConfigPaths(projectRoot3, host, options);
-  configureAutoIndex(projectRoot3, host, parseConfig(config), getIndexer);
+  configureAutoIndex(projectRoot3, host, parseConfig(config), getIndexer, {
+    synchronizeBackgroundWorker: false
+  });
   let stopped = false;
   const requestReindex = () => {
     if (stopped) return;
@@ -18952,7 +19953,9 @@ function createWatcherWithIndexer(getIndexer, projectRoot3, config, host, option
         const parsedConfig = options.configPath ? parseConfig(loadConfigFile(options.configPath)) : void 0;
         const refreshedConfig = refreshIndexerForDirectory(projectRoot3, host, parsedConfig);
         if (refreshedConfig) {
-          configureAutoIndex(projectRoot3, host, refreshedConfig, getIndexer);
+          configureAutoIndex(projectRoot3, host, refreshedConfig, getIndexer, {
+            synchronizeBackgroundWorker: false
+          });
         }
       }
       requestReindex();
@@ -19000,7 +20003,6 @@ function getConfigPaths(projectRoot3, host, options) {
 
 // src/adapters/pi/extension.ts
 var HOST2 = "pi";
-var activeWatchers = /* @__PURE__ */ new Map();
 var ChunkType = import_typebox2.Type.Union([
   import_typebox2.Type.Literal("function"),
   import_typebox2.Type.Literal("class"),
@@ -19019,24 +20021,30 @@ function projectRoot2(ctx) {
 function isValidProject(projectRoot3, requireProjectMarker) {
   return !isHomeDirectory(projectRoot3) && (!requireProjectMarker || hasProjectMarker(projectRoot3));
 }
-function ensureWatcher(projectRoot3) {
-  if (activeWatchers.has(projectRoot3)) return;
+async function ensureWatcher(projectRoot3) {
   const config = parseConfig(loadMergedConfig(projectRoot3, HOST2));
-  if (!config.indexing.watchFiles || !isValidProject(projectRoot3, config.indexing.requireProjectMarker)) {
+  if (!isValidProject(projectRoot3, config.indexing.requireProjectMarker)) {
+    await stopBackgroundWorker(projectRoot3, HOST2).catch((error) => {
+      console.error("[codebase-index] Failed to stop Pi background worker:", error);
+    });
     return;
   }
-  activeWatchers.set(projectRoot3, createWatcherWithIndexer(
+  getIndexerForProject(projectRoot3, HOST2);
+  const watcherFactoryForConfig = (refreshedConfig) => refreshedConfig.indexing.watchFiles ? () => createWatcherWithIndexer(
     () => getIndexerForProject(projectRoot3, HOST2),
     projectRoot3,
-    config,
+    refreshedConfig,
     HOST2
-  ));
-}
-async function stopWatcher(projectRoot3) {
-  const watcher = activeWatchers.get(projectRoot3);
-  if (!watcher) return;
-  activeWatchers.delete(projectRoot3);
-  await watcher.stop();
+  ) : null;
+  configureBackgroundWorker(projectRoot3, HOST2, config, {
+    startAutoIndex: (source, allowDisabledAutoIndex) => {
+      startAutoIndexForBackgroundWorker(projectRoot3, HOST2, source, allowDisabledAutoIndex);
+    },
+    stopAutoIndex: () => stopAutoIndexForBackgroundWorker(projectRoot3, HOST2),
+    watcherFactory: watcherFactoryForConfig(config),
+    watcherFactoryForConfig
+  });
+  await waitForBackgroundWorkerStart(projectRoot3, HOST2);
 }
 function codebaseIndexPiExtension(pi) {
   pi.registerTool({
@@ -19269,7 +20277,7 @@ function codebaseIndexPiExtension(pi) {
   });
   registerPiCallGraphTools(pi);
   pi.on("before_agent_start", async (event, ctx) => {
-    ensureWatcher(projectRoot2(ctx));
+    await ensureWatcher(projectRoot2(ctx));
     return {
       systemPrompt: `${event.systemPrompt}
 
@@ -19278,7 +20286,7 @@ Check index_status first when index readiness is unknown. Use codebase_context o
   });
   pi.on("session_shutdown", async (_event, ctx) => {
     const root = projectRoot2(ctx);
-    await Promise.all([stopWatcher(root), stopAutoIndex(root, HOST2)]);
+    await stopBackgroundWorker(root, HOST2);
   });
   pi.registerTool({
     name: TOOL_NAME.PR_IMPACT,