opencode-codebase-index 0.25.0 → 0.25.1

package/dist/index.js

@@ -328,7 +328,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(path30, checkUnignored, mode) {
+      test(path31, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -337,7 +337,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path30);
+          const matched = rule[mode].test(path31);
           if (!matched) {
             return;
           }
@@ -358,17 +358,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path30, originalPath, doThrow) => {
-      if (!isString(path30)) {
+    var checkPath = (path31, originalPath, doThrow) => {
+      if (!isString(path31)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path30) {
+      if (!path31) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path30)) {
+      if (checkPath.isNotRelative(path31)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -377,7 +377,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path30) => REGEX_TEST_INVALID_PATH.test(path30);
+    var isNotRelative = (path31) => REGEX_TEST_INVALID_PATH.test(path31);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -407,19 +407,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path30 = originalPath && checkPath.convert(originalPath);
+        const path31 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path30,
+          path31,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path30, cache, checkUnignored, slices);
+        return this._t(path31, cache, checkUnignored, slices);
       }
-      checkIgnore(path30) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path30)) {
-          return this.test(path30);
+      checkIgnore(path31) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path31)) {
+          return this.test(path31);
         }
-        const slices = path30.split(SLASH2).filter(Boolean);
+        const slices = path31.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -432,18 +432,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path30, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path31, false, MODE_CHECK_IGNORE);
       }
-      _t(path30, cache, checkUnignored, slices) {
-        if (path30 in cache) {
-          return cache[path30];
+      _t(path31, cache, checkUnignored, slices) {
+        if (path31 in cache) {
+          return cache[path31];
         }
         if (!slices) {
-          slices = path30.split(SLASH2).filter(Boolean);
+          slices = path31.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path30] = this._rules.test(path30, checkUnignored, MODE_IGNORE);
+          return cache[path31] = this._rules.test(path31, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -451,29 +451,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path30] = parent.ignored ? parent : this._rules.test(path30, checkUnignored, MODE_IGNORE);
+        return cache[path31] = parent.ignored ? parent : this._rules.test(path31, checkUnignored, MODE_IGNORE);
       }
-      ignores(path30) {
-        return this._test(path30, this._ignoreCache, false).ignored;
+      ignores(path31) {
+        return this._test(path31, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path30) => !this.ignores(path30);
+        return (path31) => !this.ignores(path31);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path30) {
-        return this._test(path30, this._testCache, true);
+      test(path31) {
+        return this._test(path31, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path30) => checkPath(path30 && checkPath.convert(path30), path30, RETURN_FALSE);
+    var isPathValid = (path31) => checkPath(path31 && checkPath.convert(path31), path31, 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 = (path30) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path30) || isNotRelative(path30);
+      checkPath.isNotRelative = (path31) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path31) || isNotRelative(path31);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,7 +651,7 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/adapters/opencode.ts
-import * as path29 from "path";
+import * as path30 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -1749,8 +1749,8 @@ function loadMergedConfig(projectRoot, host) {
 }
 
 // src/tools/operations.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5, statSync as statSync5 } from "fs";
-import * as path20 from "path";
+import { existsSync as existsSync13, realpathSync as realpathSync6, statSync as statSync5 } from "fs";
+import * as path21 from "path";
 
 // src/tools/knowledge-base-paths.ts
 import * as path8 from "path";
@@ -2599,8 +2599,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path30 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path30}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path31 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path31}:${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));
@@ -3242,9 +3242,9 @@ function formatEffectivenessMetrics(snapshot) {
 }
 
 // src/utils/auto-index.ts
-import { existsSync as existsSync7, realpathSync as realpathSync3 } from "fs";
-import * as os3 from "os";
-import * as path11 from "path";
+import { existsSync as existsSync8, realpathSync as realpathSync4 } from "fs";
+import * as os4 from "os";
+import * as path12 from "path";
 
 // src/indexer/index-lock.ts
 import { randomUUID } from "crypto";
@@ -3501,7 +3501,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path9.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath2 = path9.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os2.hostname(),
@@ -3510,19 +3510,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;
     }
@@ -3692,10 +3692,893 @@ function completeLeaseRecovery(lease) {
   }
 }
 
+// src/utils/background-worker.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import {
+  existsSync as existsSync6,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5,
+  realpathSync as realpathSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import * as os3 from "os";
+import * as path10 from "path";
+var OWNER_FILE_NAME2 = "owner.json";
+var HEARTBEAT_FILE_PREFIX = "heartbeat.";
+var RECLAIM_DIRECTORY_NAME2 = "reclaim";
+var REFRESH_REQUEST_FILE_NAME = "refresh-request.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_LEASE_MS = 3e4;
+var RETRY_DELAY_MS = 5e3;
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var BackgroundWorkerStopError = class extends Error {
+  constructor(watcherError, autoIndexError) {
+    super("Failed to stop background worker");
+    this.watcherError = watcherError;
+    this.autoIndexError = autoIndexError;
+    this.name = "BackgroundWorkerStopError";
+  }
+  watcherError;
+  autoIndexError;
+};
+var workers = /* @__PURE__ */ new Map();
+var workerKeysByProject = /* @__PURE__ */ new Map();
+var workerReplacementBarriers = /* @__PURE__ */ new Map();
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function canonicalizePath(targetPath) {
+  const resolved = path10.resolve(targetPath);
+  if (existsSync6(resolved)) {
+    try {
+      return realpathSync3.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  const parent = path10.dirname(resolved);
+  if (parent === resolved) return resolved;
+  return path10.join(canonicalizePath(parent), path10.basename(resolved));
+}
+function projectLookupKey(projectRoot, host) {
+  return `${host}::${canonicalizePath(projectRoot)}`;
+}
+function resolveIdentity(projectRoot, config, host) {
+  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalIndexPath = canonicalizePath(resolveProjectIndexPath(projectRoot, config.scope, host));
+  return {
+    canonicalIndexPath,
+    canonicalProjectRoot,
+    key: `${canonicalIndexPath}::${canonicalProjectRoot}`
+  };
+}
+function controllerKey(identity, host) {
+  return `${identity.key}::${host}`;
+}
+function leaseDirectoryName(identity) {
+  const hash = createHash("sha256").update(identity.key).digest("hex").slice(0, 32);
+  return `background-worker.${hash}.lease`;
+}
+function leasePathFor(identity) {
+  return path10.join(identity.canonicalIndexPath, leaseDirectoryName(identity));
+}
+function parseOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  if (typeof candidate.projectRoot !== "string" || candidate.projectRoot.length === 0) return null;
+  if (typeof candidate.indexPath !== "string" || candidate.indexPath.length === 0) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  return candidate;
+}
+function parseHeartbeat(value, expectedToken) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1 || candidate.token !== expectedToken) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  return candidate;
+}
+function parseReclaimOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  if (candidate.expectedOwnerToken !== null && (typeof candidate.expectedOwnerToken !== "string" || !UUID_PATTERN2.test(candidate.expectedOwnerToken))) return null;
+  return candidate;
+}
+function heartbeatPath(leasePath, token) {
+  return path10.join(leasePath, `${HEARTBEAT_FILE_PREFIX}${token}.json`);
+}
+function reclaimPath(leasePath) {
+  return path10.join(leasePath, RECLAIM_DIRECTORY_NAME2);
+}
+function refreshRequestPath(leasePath) {
+  return path10.join(leasePath, REFRESH_REQUEST_FILE_NAME);
+}
+function readLeaseOwner(leasePath) {
+  try {
+    return parseOwner2(JSON.parse(readFileSync5(path10.join(leasePath, OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function readOwner(leasePath) {
+  const owner = readLeaseOwner(leasePath);
+  if (!owner) return null;
+  try {
+    const heartbeat = parseHeartbeat(
+      JSON.parse(readFileSync5(heartbeatPath(leasePath, owner.token), "utf-8")),
+      owner.token
+    );
+    return heartbeat ? { ...owner, heartbeatAt: heartbeat.heartbeatAt } : owner;
+  } catch {
+    return owner;
+  }
+}
+function readReclaimOwner2(leasePath) {
+  try {
+    return parseReclaimOwner2(JSON.parse(readFileSync5(path10.join(reclaimPath(leasePath), OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function ownerLiveness(owner) {
+  if (owner.hostname !== os3.hostname()) return "unknown";
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    const code = getErrorCode2(error);
+    if (code === "ESRCH") return "dead";
+    if (code === "EPERM") return "alive";
+    return "unknown";
+  }
+}
+function isHeartbeatExpired(owner) {
+  return Date.now() - Date.parse(owner.heartbeatAt) >= STALE_LEASE_MS;
+}
+function sameOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token;
+}
+function writeHeartbeat(leasePath, owner) {
+  const targetPath = heartbeatPath(leasePath, owner.token);
+  const temporaryPath = `${targetPath}.tmp.${process.pid}.${owner.token}.${randomUUID2()}`;
+  const heartbeat = {
+    version: 1,
+    token: owner.token,
+    heartbeatAt: owner.heartbeatAt
+  };
+  try {
+    writeFileSync2(temporaryPath, JSON.stringify(heartbeat), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync2(temporaryPath, targetPath);
+    const currentOwner = readLeaseOwner(leasePath);
+    return currentOwner !== null && sameOwner2(currentOwner, owner);
+  } finally {
+    if (existsSync6(temporaryPath)) rmSync2(temporaryPath, { force: true });
+  }
+}
+function requestRefreshFromLeader(leasePath, allowDisabledAutoIndex) {
+  const requestPath = refreshRequestPath(leasePath);
+  const temporaryPath = `${requestPath}.tmp.${process.pid}.${randomUUID2()}`;
+  try {
+    const request = {
+      allowDisabledAutoIndex,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    writeFileSync2(temporaryPath, JSON.stringify(request), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync2(temporaryPath, requestPath);
+  } catch (error) {
+    if (getErrorCode2(error) !== "ENOENT") {
+      console.error("[codebase-index] Failed to request background index refresh from the project worker:", error);
+    }
+  } finally {
+    if (existsSync6(temporaryPath)) rmSync2(temporaryPath, { force: true });
+  }
+}
+function consumeRefreshRequest(leasePath) {
+  const requestPath = refreshRequestPath(leasePath);
+  const claimedPath = `${requestPath}.handling.${process.pid}.${randomUUID2()}`;
+  try {
+    renameSync2(requestPath, claimedPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const value = JSON.parse(readFileSync5(claimedPath, "utf-8"));
+    return {
+      allowDisabledAutoIndex: value.version === 1 && value.allowDisabledAutoIndex === true,
+      requestedAt: typeof value.requestedAt === "string" ? value.requestedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+  } catch {
+    return { allowDisabledAutoIndex: false, requestedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  } finally {
+    rmSync2(claimedPath, { force: true });
+  }
+}
+function publishLease(leasePath, owner) {
+  const candidatePath = `${leasePath}.candidate.${process.pid}.${owner.token}`;
+  try {
+    mkdirSync2(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    writeFileSync2(path10.join(candidatePath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if (existsSync6(leasePath)) return false;
+    try {
+      renameSync2(candidatePath, leasePath);
+      return true;
+    } catch (error) {
+      if (existsSync6(leasePath) || getErrorCode2(error) === "ENOENT") return false;
+      throw error;
+    }
+  } finally {
+    if (existsSync6(candidatePath)) rmSync2(candidatePath, { recursive: true, force: true });
+  }
+}
+function sameReclaimOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token && left.expectedOwnerToken === right.expectedOwnerToken;
+}
+function reclaimerLiveness(owner) {
+  return ownerLiveness(owner);
+}
+function isReclaimMarkerExpired(leasePath, owner) {
+  const startedAt = owner ? Date.parse(owner.startedAt) : (() => {
+    try {
+      return lstatSync2(reclaimPath(leasePath)).mtimeMs;
+    } catch {
+      return Date.now();
+    }
+  })();
+  return Date.now() - startedAt >= STALE_LEASE_MS;
+}
+function hasActiveReclaimMarker(leasePath, owner) {
+  const marker = readReclaimOwner2(leasePath);
+  return marker !== null && marker.expectedOwnerToken === owner.token && (marker.hostname !== os3.hostname() || ownerLiveness(owner) !== "alive");
+}
+function publishReclaimMarker(leasePath, expectedOwner) {
+  const markerPath = reclaimPath(leasePath);
+  const owner = {
+    version: 1,
+    pid: process.pid,
+    hostname: os3.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token: randomUUID2(),
+    expectedOwnerToken: expectedOwner?.token ?? null
+  };
+  try {
+    mkdirSync2(markerPath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "EEXIST" || getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    writeFileSync2(path10.join(markerPath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    return owner;
+  } catch (error) {
+    rmSync2(markerPath, { recursive: true, force: true });
+    throw error;
+  }
+}
+function removeExpiredReclaimMarker(leasePath, expectedOwner) {
+  const marker = readReclaimOwner2(leasePath);
+  const markerPath = reclaimPath(leasePath);
+  if (!existsSync6(markerPath)) return false;
+  if (marker && marker.expectedOwnerToken !== (expectedOwner?.token ?? null)) return false;
+  if (marker && (reclaimerLiveness(marker) === "alive" || !isReclaimMarkerExpired(leasePath, marker))) return false;
+  if (!marker && !isReclaimMarkerExpired(leasePath, null)) return false;
+  const staleMarkerPath = `${markerPath}.stale.${marker?.pid ?? process.pid}.${marker?.token ?? randomUUID2()}.${randomUUID2()}`;
+  try {
+    renameSync2(markerPath, staleMarkerPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    let claimedMarker = null;
+    try {
+      claimedMarker = parseReclaimOwner2(
+        JSON.parse(readFileSync5(path10.join(staleMarkerPath, OWNER_FILE_NAME2), "utf-8"))
+      );
+    } catch {
+      claimedMarker = null;
+    }
+    const markerMatches = marker ? claimedMarker !== null && sameReclaimOwner2(claimedMarker, marker) : claimedMarker === null;
+    if (!markerMatches || !canReclaimLease(leasePath, expectedOwner)) {
+      if (!existsSync6(markerPath) && existsSync6(staleMarkerPath)) renameSync2(staleMarkerPath, markerPath);
+      return false;
+    }
+    rmSync2(staleMarkerPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+function canReclaimLease(leasePath, expectedOwner) {
+  if (!existsSync6(leasePath)) return false;
+  if (!expectedOwner) return false;
+  const currentOwner = readOwner(leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, expectedOwner)) return false;
+  if (currentOwner.hostname === os3.hostname()) {
+    return ownerLiveness(currentOwner) === "dead";
+  }
+  return isHeartbeatExpired(currentOwner);
+}
+function reclaimLease(leasePath, expectedOwner) {
+  let marker = null;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    marker = publishReclaimMarker(leasePath, expectedOwner);
+    if (marker) break;
+    if (attempt === 0 && removeExpiredReclaimMarker(leasePath, expectedOwner)) continue;
+    return false;
+  }
+  if (!marker) return false;
+  const markerPath = reclaimPath(leasePath);
+  try {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (!currentMarker || !sameReclaimOwner2(currentMarker, marker) || !canReclaimLease(leasePath, expectedOwner)) {
+      return false;
+    }
+    const stalePath = `${leasePath}.stale.${process.pid}.${marker.token}`;
+    renameSync2(leasePath, stalePath);
+    const quarantinedOwner = readOwner(stalePath);
+    const quarantinedMarker = readReclaimOwner2(stalePath);
+    if (!quarantinedMarker || !sameReclaimOwner2(quarantinedMarker, marker) || expectedOwner !== null && (!quarantinedOwner || !sameOwner2(quarantinedOwner, expectedOwner))) {
+      if (!existsSync6(leasePath) && existsSync6(stalePath)) renameSync2(stalePath, leasePath);
+      return false;
+    }
+    rmSync2(stalePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  } finally {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (currentMarker && sameReclaimOwner2(currentMarker, marker)) {
+      rmSync2(markerPath, { recursive: true, force: true });
+    }
+  }
+}
+function acquireLease(identity) {
+  mkdirSync2(identity.canonicalIndexPath, { recursive: true, mode: 448 });
+  const canonicalIndexPath = realpathSync3.native(identity.canonicalIndexPath);
+  const leasePath = path10.join(canonicalIndexPath, leaseDirectoryName({ ...identity, canonicalIndexPath }));
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const owner = {
+      version: 1,
+      pid: process.pid,
+      hostname: os3.hostname(),
+      startedAt: timestamp,
+      heartbeatAt: timestamp,
+      projectRoot: identity.canonicalProjectRoot,
+      indexPath: canonicalIndexPath,
+      token: randomUUID2()
+    };
+    if (publishLease(leasePath, owner)) {
+      return { leasePath, owner };
+    }
+    const existingOwner = readOwner(leasePath);
+    if (existingOwner) {
+      if (canReclaimLease(leasePath, existingOwner) && reclaimLease(leasePath, existingOwner)) continue;
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function releaseLease(lease) {
+  const currentOwner = readOwner(lease.leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) return false;
+  const releasePath = `${lease.leasePath}.release.${lease.owner.pid}.${lease.owner.token}`;
+  try {
+    renameSync2(lease.leasePath, releasePath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readOwner(releasePath);
+  if (!claimedOwner || !sameOwner2(claimedOwner, lease.owner)) {
+    if (!existsSync6(lease.leasePath) && existsSync6(releasePath)) {
+      renameSync2(releasePath, lease.leasePath);
+    }
+    return false;
+  }
+  rmSync2(releasePath, { recursive: true, force: true });
+  return true;
+}
+var BackgroundWorkerController = class {
+  constructor(projectRoot, host, config, hooks, identity) {
+    this.projectRoot = projectRoot;
+    this.host = host;
+    this.config = config;
+    this.hooks = hooks;
+    this.identity = identity;
+  }
+  projectRoot;
+  host;
+  config;
+  hooks;
+  identity;
+  lease = null;
+  watcher = null;
+  leaderReady = Promise.resolve();
+  heartbeatTimer = null;
+  retryTimer = null;
+  teardownRetryTimer = null;
+  transition = Promise.resolve();
+  stopPromise = null;
+  stopped = false;
+  stopping = false;
+  losingLeadership = false;
+  restartAfterStop = false;
+  leaderWorkStopped = false;
+  startingLeaderWork = false;
+  stopAutoIndexOnTeardown = true;
+  autoIndexStarted = false;
+  reportedError = null;
+  update(config, hooks, options) {
+    const autoIndexWasEnabled = this.config.indexing.autoIndex;
+    const shouldReplaceWatcher = this.watcher !== null && hooks.watcherFactory !== void 0 && (hooks.watcherFactory === null || hooks.replaceWatcher === true);
+    this.config = config;
+    this.hooks = {
+      ...this.hooks,
+      ...hooks,
+      watcherFactory: hooks.watcherFactory === void 0 ? this.hooks.watcherFactory : hooks.watcherFactory,
+      watcherFactoryForConfig: hooks.watcherFactoryForConfig === void 0 ? this.hooks.watcherFactoryForConfig : hooks.watcherFactoryForConfig
+    };
+    if (autoIndexWasEnabled && !config.indexing.autoIndex || options.restartAutoIndex === true && config.indexing.autoIndex && !this.startingLeaderWork) {
+      this.autoIndexStarted = false;
+    }
+    if (!this.canRun()) {
+      void this.stop().catch((error) => {
+        console.error("[codebase-index] Failed to stop background worker after disabling automatic work:", error);
+      });
+      return;
+    }
+    if (shouldReplaceWatcher) {
+      void this.enqueue(async () => {
+        const watcher = this.watcher;
+        if (watcher) {
+          await watcher.stop();
+          if (this.watcher === watcher) this.watcher = null;
+        }
+        if (this.lease && !this.stopped) this.startLeaderWork();
+      }).catch((error) => {
+        console.error("[codebase-index] Failed to replace background file watcher:", error);
+      });
+    }
+    this.start();
+  }
+  startAfter(activation) {
+    this.transition = activation.catch(() => void 0);
+    this.start();
+  }
+  start() {
+    if (!this.canRun() || this.losingLeadership) return;
+    if (this.stopping) {
+      this.restartAfterStop = true;
+      return;
+    }
+    this.stopped = false;
+    void this.enqueue(async () => {
+      if (this.stopped || this.stopping || this.losingLeadership || !this.canRun()) return;
+      if (!this.lease) {
+        try {
+          this.lease = acquireLease(this.identity);
+          this.reportedError = null;
+        } catch (error) {
+          this.reportAcquireError(error);
+          this.scheduleRetry();
+          return;
+        }
+      }
+      if (!this.lease) {
+        this.scheduleRetry();
+        return;
+      }
+      this.startHeartbeat();
+      this.startLeaderWork();
+    });
+  }
+  waitForStart() {
+    return this.transition.catch(() => void 0).then(() => this.leaderReady);
+  }
+  requestRefresh(allowDisabledAutoIndex = false) {
+    this.start();
+    if (!this.isLeader()) {
+      requestRefreshFromLeader(leasePathFor(this.identity), allowDisabledAutoIndex);
+      return;
+    }
+    void this.enqueue(async () => {
+      if (this.stopped || !this.lease) return;
+      this.hooks.startAutoIndex("retrieval", allowDisabledAutoIndex);
+    });
+  }
+  isLeader() {
+    return this.lease !== null && !this.stopping && !this.losingLeadership;
+  }
+  isStopping() {
+    return this.stopping;
+  }
+  getHooksForConfig(config) {
+    const watcherFactoryForConfig = this.hooks.watcherFactoryForConfig;
+    if (!watcherFactoryForConfig) return this.hooks;
+    return {
+      ...this.hooks,
+      watcherFactory: watcherFactoryForConfig(config),
+      replaceWatcher: true
+    };
+  }
+  attachWatcher(watcherFactory, watcherFactoryForConfig) {
+    if (this.hooks.watcherFactory !== void 0) return;
+    this.hooks = {
+      ...this.hooks,
+      watcherFactory,
+      watcherFactoryForConfig: watcherFactoryForConfig ?? this.hooks.watcherFactoryForConfig
+    };
+    this.start();
+  }
+  async stop(stopAutoIndex = true) {
+    if (this.stopPromise) return this.stopPromise;
+    this.stopped = true;
+    this.stopping = true;
+    this.stopAutoIndexOnTeardown &&= stopAutoIndex;
+    this.clearRetryTimer();
+    const attempt = this.enqueue(async () => {
+      try {
+        const lease = this.lease;
+        if (this.leaderWorkStopped) {
+          if (lease) {
+            this.releaseStoppedLease(lease);
+          } else {
+            this.finishStoppedLease();
+          }
+          return;
+        }
+        const hadLeaderWork = lease !== null || this.watcher !== null || this.autoIndexStarted;
+        const stopped = await this.stopLeaderWork(hadLeaderWork && this.stopAutoIndexOnTeardown);
+        if (!lease) {
+          this.finishStoppedLease();
+          return;
+        }
+        if (!stopped.completed) {
+          this.releaseLeaseWhenAutoIndexStops(lease, stopped.completion);
+          return;
+        }
+        this.leaderWorkStopped = true;
+        this.releaseStoppedLease(lease);
+      } catch (error) {
+        this.scheduleTeardownRetry();
+        throw error;
+      }
+    });
+    const completion = attempt.finally(() => {
+      if (this.stopPromise === completion) this.stopPromise = null;
+    });
+    this.stopPromise = completion;
+    return completion;
+  }
+  canRun() {
+    return this.config.indexing.autoIndex || this.hooks.watcherFactory != null;
+  }
+  enqueue(operation) {
+    const next = this.transition.catch(() => void 0).then(operation);
+    this.transition = next;
+    return next;
+  }
+  startLeaderWork() {
+    if (this.stopped || this.stopping || this.losingLeadership) return;
+    this.startingLeaderWork = true;
+    try {
+      if (this.config.indexing.autoIndex && !this.autoIndexStarted) {
+        this.autoIndexStarted = true;
+        this.hooks.startAutoIndex("startup");
+      }
+      if (!this.watcher && this.hooks.watcherFactory) {
+        try {
+          const watcher = this.hooks.watcherFactory();
+          this.watcher = watcher;
+          this.leaderReady = watcher.whenReady?.().catch((error) => {
+            console.error("[codebase-index] Failed while waiting for background file watcher startup:", error);
+          }) ?? Promise.resolve();
+        } catch (error) {
+          console.error("[codebase-index] Failed to start background file watcher:", error);
+          this.leaderReady = Promise.resolve();
+        }
+      }
+    } finally {
+      this.startingLeaderWork = false;
+    }
+  }
+  async stopLeaderWork(stopAutoIndex) {
+    const watcher = this.watcher;
+    let watcherError;
+    if (watcher) {
+      try {
+        await watcher.stop();
+        if (this.watcher === watcher) this.watcher = null;
+      } catch (error) {
+        watcherError = error;
+      }
+    }
+    let autoIndexError;
+    let autoIndexStop = {
+      completed: true,
+      completion: Promise.resolve()
+    };
+    if (stopAutoIndex) {
+      try {
+        autoIndexStop = await this.hooks.stopAutoIndex();
+        this.autoIndexStarted = false;
+      } catch (error) {
+        autoIndexError = error;
+      }
+    }
+    if (watcherError !== void 0 || autoIndexError !== void 0) {
+      throw new BackgroundWorkerStopError(watcherError, autoIndexError);
+    }
+    return autoIndexStop;
+  }
+  releaseLeaseWhenAutoIndexStops(lease, completion) {
+    void completion.then(
+      () => {
+        void this.enqueue(async () => {
+          if (this.lease !== lease || !this.stopping) return;
+          this.leaderWorkStopped = true;
+          this.releaseStoppedLease(lease);
+        }).catch((error) => {
+          console.error("[codebase-index] Failed to release background worker lease after automatic indexing stopped:", error);
+          this.scheduleTeardownRetry();
+        });
+      },
+      (error) => {
+        console.error("[codebase-index] Failed while waiting for automatic indexing to stop:", error);
+        this.scheduleTeardownRetry();
+      }
+    );
+  }
+  releaseStoppedLease(lease) {
+    if (this.lease !== lease) {
+      this.finishStoppedLease();
+      return;
+    }
+    releaseLease(lease);
+    this.lease = null;
+    this.finishStoppedLease();
+  }
+  finishStoppedLease() {
+    this.leaderWorkStopped = false;
+    this.stopAutoIndexOnTeardown = true;
+    this.stopping = false;
+    this.clearTimers();
+    this.restartAfterTeardown();
+    if (!this.stopped || this.stopping) return;
+    const projectKey = projectLookupKey(this.projectRoot, this.host);
+    const key = controllerKey(this.identity, this.host);
+    if (workers.get(key) === this) workers.delete(key);
+    if (workerKeysByProject.get(projectKey) === key) workerKeysByProject.delete(projectKey);
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    const heartbeat = () => {
+      void this.heartbeat();
+    };
+    this.heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimer.unref?.();
+  }
+  async heartbeat() {
+    const lease = this.lease;
+    if (!lease || this.losingLeadership || this.stopped && !this.stopping) return;
+    if (hasActiveReclaimMarker(lease.leasePath, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    const currentOwner = readOwner(lease.leasePath);
+    if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    try {
+      const nextOwner = { ...lease.owner, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+      if (!writeHeartbeat(lease.leasePath, nextOwner)) {
+        await this.loseLeadership();
+        return;
+      }
+      lease.owner = nextOwner;
+      const refreshRequest = !this.stopping ? consumeRefreshRequest(lease.leasePath) : null;
+      if (refreshRequest) {
+        this.hooks.startAutoIndex("retrieval", refreshRequest.allowDisabledAutoIndex);
+      }
+    } catch (error) {
+      const ownerAfterError = readOwner(lease.leasePath);
+      if (hasActiveReclaimMarker(lease.leasePath, lease.owner) || !ownerAfterError || !sameOwner2(ownerAfterError, lease.owner)) {
+        await this.loseLeadership();
+        return;
+      }
+      console.error("[codebase-index] Failed to renew background worker lease:", error);
+    }
+  }
+  async loseLeadership() {
+    if (this.losingLeadership) return;
+    this.losingLeadership = true;
+    this.clearHeartbeat();
+    await this.enqueue(async () => this.stopAfterLeadershipLoss());
+  }
+  async stopAfterLeadershipLoss() {
+    const lease = this.lease;
+    if (!lease) {
+      this.losingLeadership = false;
+      return;
+    }
+    try {
+      const stopped = await this.stopLeaderWork(true);
+      this.lease = null;
+      this.losingLeadership = false;
+      if (stopped.completed) {
+        this.scheduleRetry();
+      } else {
+        void stopped.completion.then(() => this.scheduleRetry());
+      }
+    } catch (error) {
+      console.error("[codebase-index] Failed to stop background work after losing its lease:", error);
+      this.scheduleLostLeadershipTeardownRetry();
+    }
+  }
+  scheduleRetry() {
+    if (this.stopped || !this.canRun() || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.start();
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  scheduleTeardownRetry() {
+    if (!this.stopping || this.teardownRetryTimer) return;
+    this.teardownRetryTimer = setTimeout(() => {
+      this.teardownRetryTimer = null;
+      void this.stop(this.stopAutoIndexOnTeardown).catch((error) => {
+        console.error("[codebase-index] Failed to retry background worker teardown:", error);
+      });
+    }, RETRY_DELAY_MS);
+    this.teardownRetryTimer.unref?.();
+  }
+  restartAfterTeardown() {
+    if (!this.restartAfterStop || !this.canRun() || this.losingLeadership) return;
+    this.restartAfterStop = false;
+    this.stopped = false;
+    this.start();
+  }
+  scheduleLostLeadershipTeardownRetry() {
+    if (this.stopped || !this.losingLeadership || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.enqueue(async () => this.stopAfterLeadershipLoss());
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  clearHeartbeat() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    this.clearRetryTimer();
+    if (this.teardownRetryTimer) {
+      clearTimeout(this.teardownRetryTimer);
+      this.teardownRetryTimer = null;
+    }
+  }
+  clearRetryTimer() {
+    if (!this.retryTimer) return;
+    clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  reportAcquireError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.reportedError === message) return;
+    this.reportedError = message;
+    console.error("[codebase-index] Failed to acquire background worker lease:", error);
+  }
+};
+function configureBackgroundWorker(projectRoot, host, config, hooks, options = {}) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const identity = resolveIdentity(projectRoot, config, host);
+  const key = controllerKey(identity, host);
+  const previousKey = workerKeysByProject.get(projectKey);
+  if (previousKey && previousKey !== key) {
+    const previous = workers.get(previousKey);
+    const previousBarrier = workerReplacementBarriers.get(projectKey) ?? Promise.resolve();
+    const stopPrevious = previous?.stop(options.stopPreviousAutoIndex ?? true) ?? Promise.resolve();
+    const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
+    workerReplacementBarriers.set(projectKey, activation);
+    workers.delete(previousKey);
+    const worker2 = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    worker2.startAfter(activation);
+    workers.set(key, worker2);
+    workerKeysByProject.set(projectKey, key);
+    return;
+  }
+  let worker = workers.get(key);
+  if (!worker) {
+    worker = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    workers.set(key, worker);
+  } else {
+    worker.update(config, hooks, options);
+  }
+  workerKeysByProject.set(projectKey, key);
+  worker.start();
+}
+function updateBackgroundWorkerConfig(projectRoot, host, config) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  configureBackgroundWorker(projectRoot, host, config, worker.getHooksForConfig(config), {
+    stopPreviousAutoIndex: false,
+    restartAutoIndex: true
+  });
+}
+function waitForBackgroundWorkerStart(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return workers.get(key ?? "")?.waitForStart() ?? Promise.resolve();
+}
+function requestBackgroundWorkerRefresh(projectRoot, host, allowDisabledAutoIndex = false) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  workers.get(key ?? "")?.requestRefresh(allowDisabledAutoIndex);
+}
+function isBackgroundWorkerManaged(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.has(key);
+}
+function isBackgroundWorkerLeader(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.get(key)?.isLeader() === true;
+}
+async function stopBackgroundWorker(projectRoot, host) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  await worker.stop();
+}
+
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync5, promises as fsPromises } from "fs";
-import * as path10 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, promises as fsPromises } from "fs";
+import * as path11 from "path";
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -3713,7 +4596,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if (existsSync6(path10.join(projectRoot, marker))) {
+    if (existsSync7(path11.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3740,33 +4623,53 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path10.join(projectRoot, ".gitignore");
-  if (existsSync6(gitignorePath)) {
-    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+  const gitignorePath = path11.join(projectRoot, ".gitignore");
+  if (existsSync7(gitignorePath)) {
+    const gitignoreContent = readFileSync6(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
-function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path10.relative(projectRoot, filePath);
-  if (hasFilteredPathSegment(relativePath, path10.sep)) {
-    return false;
-  }
-  if (ignoreFilter.ignores(relativePath)) {
-    return false;
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path11.sep).join("/");
+}
+function matchesAnyGlob(filePath, patterns) {
+  const normalized = toPosixRelativePath(filePath);
+  return patterns.some((pattern) => matchGlob(normalized, pattern));
+}
+function isExcludedByPatterns(relativePath, excludePatterns) {
+  return matchesAnyGlob(relativePath, excludePatterns);
+}
+function isExcludedDirectory(relativePath, excludePatterns) {
+  const normalized = toPosixRelativePath(relativePath);
+  if (matchesAnyGlob(normalized, excludePatterns)) {
+    return true;
   }
   for (const pattern of excludePatterns) {
-    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, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
+  const relativePath = toPosixRelativePath(path11.relative(projectRoot, 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);
@@ -3787,8 +4690,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path10.join(dir, entry.name);
-    const relativePath = path10.relative(projectRoot, fullPath);
+    const fullPath = path11.join(dir, entry.name);
+    const relativePath = toPosixRelativePath(path11.relative(projectRoot, fullPath));
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3806,6 +4709,10 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
       continue;
     }
     if (entry.isDirectory()) {
+      if (isExcludedDirectory(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
+      }
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
       const stat5 = await fsPromises.stat(fullPath);
@@ -3813,20 +4720,11 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
-      for (const pattern of excludePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          skipped.push({ path: relativePath, reason: "excluded" });
-          continue;
-        }
-      }
-      let matched = false;
-      for (const pattern of includePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          matched = true;
-          break;
-        }
+      if (isExcludedByPatterns(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
       }
-      if (matched) {
+      if (matchesAnyGlob(relativePath, includePatterns)) {
         filesInDir.push({ path: fullPath, size: stat5.size });
       }
     }
@@ -3837,7 +4735,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path10.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: toPosixRelativePath(path11.relative(projectRoot, filesInDir[i].path)), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3877,8 +4775,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path10.normalize(
-        path10.isAbsolute(kbRoot) ? kbRoot : path10.resolve(projectRoot, kbRoot)
+      const resolved = path11.normalize(
+        path11.isAbsolute(kbRoot) ? kbRoot : path11.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3919,7 +4817,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,
@@ -3929,7 +4827,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve17(stdout);
+        resolve18(stdout);
       }
     );
   });
@@ -4021,29 +4919,29 @@ var AutoIndexCancelledError = class extends Error {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function canonicalizePath(targetPath) {
-  const resolved = path11.resolve(targetPath);
-  if (existsSync7(resolved)) {
+function canonicalizePath2(targetPath) {
+  const resolved = path12.resolve(targetPath);
+  if (existsSync8(resolved)) {
     try {
-      return realpathSync3.native(resolved);
+      return realpathSync4.native(resolved);
     } catch {
       return resolved;
     }
   }
-  const parent = path11.dirname(resolved);
+  const parent = path12.dirname(resolved);
   if (parent === resolved) return resolved;
-  return path11.join(canonicalizePath(parent), path11.basename(resolved));
+  return path12.join(canonicalizePath2(parent), path12.basename(resolved));
 }
 function isHomeDirectory(projectRoot) {
-  return canonicalizePath(projectRoot) === canonicalizePath(os3.homedir());
+  return canonicalizePath2(projectRoot) === canonicalizePath2(os4.homedir());
 }
-function projectLookupKey(projectRoot, host) {
-  return `${host}::${canonicalizePath(projectRoot)}`;
+function projectLookupKey2(projectRoot, host) {
+  return `${host}::${canonicalizePath2(projectRoot)}`;
 }
 function coordinatorKey(projectRoot, config, host) {
-  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalProjectRoot = canonicalizePath2(projectRoot);
   const indexPath = resolveProjectIndexPath(projectRoot, config.scope, host);
-  return `${canonicalizePath(indexPath)}::${canonicalProjectRoot}`;
+  return `${canonicalizePath2(indexPath)}::${canonicalProjectRoot}`;
 }
 function getProjectSafety(projectRoot, config) {
   if (isHomeDirectory(projectRoot)) {
@@ -4074,10 +4972,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 = () => {
@@ -4089,18 +4987,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;
@@ -4111,6 +5035,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,
@@ -4172,11 +5097,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) {
@@ -4251,13 +5176,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)) {
@@ -4446,7 +5373,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");
@@ -4479,17 +5406,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() {
@@ -4497,9 +5424,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;
@@ -4512,12 +5439,25 @@ var AutoIndexCoordinator = class {
   }
 };
 function getCoordinator(projectRoot, host) {
-  const key = coordinatorKeysByProject.get(projectLookupKey(projectRoot, host));
+  const key = coordinatorKeysByProject.get(projectLookupKey2(projectRoot, host));
   return key ? coordinators.get(key) ?? null : null;
 }
-function configureAutoIndex(projectRoot, host, config, getIndexer) {
-  const projectKey = projectLookupKey(projectRoot, host);
+function synchronizeBackgroundWorker(projectRoot, host, config, safeToRun) {
+  if (safeToRun) {
+    updateBackgroundWorkerConfig(projectRoot, host, config);
+    return;
+  }
+  void stopBackgroundWorker(projectRoot, host).catch((error) => {
+    console.error("[codebase-index] Failed to stop background worker after project safety changed:", error);
+  });
+}
+function configureAutoIndex(projectRoot, host, config, getIndexer, options = {}) {
+  const projectKey = projectLookupKey2(projectRoot, host);
   const safety = getProjectSafety(projectRoot, config);
+  const synchronizeWorker = options.synchronizeBackgroundWorker ?? true;
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host)) {
+    return;
+  }
   const registration = {
     backgroundIndexingPolicy: createBackgroundIndexingPolicy(
       config.indexing.pauseBackgroundIndexingOnBattery
@@ -4535,6 +5475,9 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     const stopPrevious = previousCoordinator?.stop(true) ?? Promise.resolve();
     const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
     coordinatorReplacementBarriers.set(projectKey, activation);
+    if (synchronizeWorker) {
+      synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+    }
     coordinators.delete(previousKey);
     const coordinator2 = new AutoIndexCoordinator(registration);
     coordinator2.activateAfter(activation);
@@ -4550,11 +5493,17 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     coordinator.update(registration);
   }
   coordinatorKeysByProject.set(projectKey, key);
+  if (synchronizeWorker) {
+    synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+  }
 }
-function startAutoIndex(projectRoot, host, source = "startup") {
-  return getCoordinator(projectRoot, host)?.start(source) ?? null;
+function startAutoIndexForBackgroundWorker(projectRoot, host, source = "startup", allowDisabledAutoIndex = false) {
+  return getCoordinator(projectRoot, host)?.start(source, allowDisabledAutoIndex) ?? null;
 }
 function requestBackgroundIndex(projectRoot, host) {
+  if (isBackgroundWorkerManaged(projectRoot, host) && !isBackgroundWorkerLeader(projectRoot, host)) {
+    return null;
+  }
   return getCoordinator(projectRoot, host)?.request({
     checkFreshness: false,
     force: false,
@@ -4594,15 +5543,23 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     };
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) {
+      return { ready: true };
+    }
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
-  const job = coordinator.start("retrieval") ?? coordinator.currentJob();
+  const job = startRetrievalRefresh(projectRoot, host, coordinator);
   if (job) {
     await withTimeout(job, coordinator.getWaitMs());
+  } else if (isBackgroundWorkerManaged(projectRoot, host)) {
+    await waitForPublishedSnapshot(coordinator, coordinator.getWaitMs());
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) return { ready: true };
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
   const status = coordinator.snapshot();
@@ -4623,18 +5580,52 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     text: `Automatic indexing is ${status.state}. Retry shortly or call index_status for progress. You can also run index_codebase explicitly.`
   };
 }
-async function hasReadableCurrentIndex(coordinator) {
+async function stopAutoIndexForBackgroundWorker(projectRoot, host, waitForCompletion = false) {
+  const coordinator = getCoordinator(projectRoot, host);
+  if (!coordinator) {
+    return { completed: true, completion: Promise.resolve() };
+  }
+  return coordinator.stop(waitForCompletion);
+}
+async function getSearchReadiness(coordinator) {
   const indexer = coordinator.getIndexer();
   if (indexer.getIndexFreshness) {
     const freshness = await indexer.getIndexFreshness();
-    return freshness.readable && freshness.current;
+    const searchable = freshness.readable && freshness.current && freshness.reason === "current";
+    return {
+      blocked: freshness.reason === "unreadable" || freshness.reason === "incompatible" || freshness.reason === "failed-batches" || freshness.reason === "migration-required",
+      reason: freshness.reason,
+      searchable
+    };
+  }
+  const indexed = (await indexer.getStatus()).indexed;
+  return { blocked: false, searchable: indexed };
+}
+function unavailableSnapshotResult(reason) {
+  const detail = reason === "incompatible" ? "The existing index is incompatible with the configured embedding provider." : reason === "migration-required" ? "The existing index requires a storage migration." : reason === "failed-batches" ? "The existing index has failed embedding batches." : "The existing index is unreadable.";
+  return {
+    ready: false,
+    text: `${detail} Run index_codebase before retrying retrieval.`
+  };
+}
+function startRetrievalRefresh(projectRoot, host, coordinator) {
+  if (isBackgroundWorkerManaged(projectRoot, host)) {
+    requestBackgroundWorkerRefresh(projectRoot, host, true);
+    return isBackgroundWorkerLeader(projectRoot, host) ? coordinator.currentJob() : null;
+  }
+  return coordinator.start("retrieval") ?? coordinator.currentJob();
+}
+async function waitForPublishedSnapshot(coordinator, waitMs) {
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    if ((await getSearchReadiness(coordinator)).searchable) return;
+    await new Promise((resolve18) => setTimeout(resolve18, Math.min(250, deadline - Date.now())));
   }
-  return (await indexer.getStatus()).indexed;
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import * as path12 from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import * as path13 from "path";
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -4661,10 +5652,10 @@ function loadEditableConfig(projectRoot, host) {
 }
 function saveConfig(projectRoot, config, host) {
   const configPath = getConfigPath(projectRoot, host);
-  const configDir = path12.dirname(configPath);
-  const configBaseDir = path12.dirname(configDir);
-  if (!existsSync8(configDir)) {
-    mkdirSync2(configDir, { recursive: true });
+  const configDir = path13.dirname(configPath);
+  const configBaseDir = path13.dirname(configDir);
+  if (!existsSync9(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
   }
   const serializableConfig = { ...config };
   if (Array.isArray(serializableConfig.knowledgeBases)) {
@@ -4672,12 +5663,12 @@ function saveConfig(projectRoot, config, host) {
       (kb) => serializeConfigPathValue(kb, configBaseDir)
     );
   }
-  writeFileSync2(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+  writeFileSync3(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/indexer/index.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4, promises as fsPromises3 } from "fs";
-import * as path19 from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5, promises as fsPromises3 } from "fs";
+import * as path20 from "path";
 import { performance as performance2 } from "perf_hooks";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -4704,7 +5695,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}\``);
     }
@@ -4718,7 +5709,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;
     }
@@ -4726,7 +5717,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve17(fallback());
+          resolve18(fallback());
         } catch (error) {
           reject(error);
         }
@@ -4736,7 +5727,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve17();
+        resolve18();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -5138,7 +6129,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 () => {
@@ -5178,7 +6169,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve17(result);
+          resolve18(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -5366,13 +6357,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);
     });
@@ -5658,7 +6649,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);
@@ -5666,7 +6657,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve17();
+        resolve18();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -5727,17 +6718,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import * as path13 from "path";
-import * as os4 from "os";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import * as path14 from "path";
+import * as os5 from "os";
 function getOpenCodeAuthPath() {
-  return path13.join(os4.homedir(), ".local", "share", "opencode", "auth.json");
+  return path14.join(os5.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync9(authPath)) {
-      return JSON.parse(readFileSync6(authPath, "utf-8"));
+    if (existsSync10(authPath)) {
+      return JSON.parse(readFileSync7(authPath, "utf-8"));
     }
   } catch {
   }
@@ -6028,17 +7019,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 };
 }
@@ -7130,8 +8121,8 @@ function extractParamNames(params) {
 }
 
 // src/native/binding.ts
-import * as os5 from "os";
-import * as path14 from "path";
+import * as os6 from "os";
+import * as path15 from "path";
 import * as module from "module";
 import { fileURLToPath } from "url";
 
@@ -7167,7 +8158,7 @@ var MCP_BINARY_CURRENT_NAME = CURRENT_PRODUCT.mcpBinary;
 var STABLE_NATIVE_BINARY_NAME = IDENTITY_CATALOG.native.binaryName;
 
 // src/native/binding.ts
-function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()) {
+function getNativeBindingFilename(platform2 = os6.platform(), arch2 = os6.arch()) {
   if (platform2 === "darwin" && arch2 === "arm64") {
     return `${STABLE_NATIVE_BINARY_NAME}.darwin-arm64.node`;
   }
@@ -7185,25 +8176,25 @@ function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()
   }
   throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
 }
-function resolveNativeBindingPath(packageRoot, platform2 = os5.platform(), arch2 = os5.arch()) {
-  return path14.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
+function resolveNativeBindingPath(packageRoot, platform2 = os6.platform(), arch2 = os6.arch()) {
+  return path15.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
 }
 function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path14.dirname(fileURLToPath(import.meta.url));
+    currentDir = path15.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path14.join(currentDir, "index.js");
+    requireTarget = path15.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path14.join("src", "native"));
-  const packageRoot = isDevMode ? path14.resolve(currentDir, "../..") : path14.resolve(currentDir, "..");
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path15.join("src", "native"));
+  const packageRoot = isDevMode ? path15.resolve(currentDir, "../..") : path15.resolve(currentDir, "..");
   const nativePath = resolveNativeBindingPath(packageRoot);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
@@ -7787,8 +8778,8 @@ var Database = class _Database {
 
 // src/git/branch-materialization.ts
 import { promises as fsPromises2 } from "fs";
-import * as os6 from "os";
-import * as path15 from "path";
+import * as os7 from "os";
+import * as path16 from "path";
 
 // src/git/branch-resolution.ts
 import { execFile as execFile2 } from "child_process";
@@ -8107,13 +9098,13 @@ async function isWorktreeRegistered(projectRoot, worktreePath) {
   return false;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const relative14 = path15.relative(path15.resolve(rootPath), path15.resolve(filePath));
-  return relative14 === "" || !relative14.startsWith(`..${path15.sep}`) && relative14 !== ".." && !path15.isAbsolute(relative14);
+  const relative14 = path16.relative(path16.resolve(rootPath), path16.resolve(filePath));
+  return relative14 === "" || !relative14.startsWith(`..${path16.sep}`) && relative14 !== ".." && !path16.isAbsolute(relative14);
 }
 async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath) {
   if (await pathExists(worktreePath)) return false;
   const commonDir = await runGit(projectRoot, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  const registrationsRoot = path15.join(commonDir, "worktrees");
+  const registrationsRoot = path16.join(commonDir, "worktrees");
   let entries;
   try {
     entries = await fsPromises2.readdir(registrationsRoot, { withFileTypes: true });
@@ -8124,16 +9115,16 @@ async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath)
   const target = canonicalizePathForComparison(worktreePath);
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const registrationPath = path15.join(registrationsRoot, entry.name);
+    const registrationPath = path16.join(registrationsRoot, entry.name);
     if (!isPathWithinRoot(registrationPath, registrationsRoot)) continue;
     let gitdirPath;
     try {
-      gitdirPath = (await fsPromises2.readFile(path15.join(registrationPath, "gitdir"), "utf8")).trim();
+      gitdirPath = (await fsPromises2.readFile(path16.join(registrationPath, "gitdir"), "utf8")).trim();
     } catch {
       continue;
     }
-    const resolvedGitdirPath = path15.isAbsolute(gitdirPath) ? gitdirPath : path15.resolve(registrationPath, gitdirPath);
-    if (canonicalizePathForComparison(path15.dirname(resolvedGitdirPath)) !== target) continue;
+    const resolvedGitdirPath = path16.isAbsolute(gitdirPath) ? gitdirPath : path16.resolve(registrationPath, gitdirPath);
+    if (canonicalizePathForComparison(path16.dirname(resolvedGitdirPath)) !== target) continue;
     await fsPromises2.rm(registrationPath, { recursive: true, force: true });
     return true;
   }
@@ -8151,7 +9142,7 @@ async function removeWorktree(projectRoot, worktreePath) {
     registered = await isWorktreeRegistered(projectRoot, worktreePath);
   } catch (error) {
     errors.push(asError(error));
-    throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path16.dirname(worktreePath)}`);
   }
   if (registered) {
     try {
@@ -8167,7 +9158,7 @@ async function removeWorktree(projectRoot, worktreePath) {
       registered = await isWorktreeRegistered(projectRoot, worktreePath);
     } catch (error) {
       errors.push(asError(error));
-      throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path15.dirname(worktreePath)}`);
+      throw new AggregateError(errors, `Could not verify temporary worktree deregistration; preserved ${path16.dirname(worktreePath)}`);
     }
   }
   if (registered && !await pathExists(worktreePath)) {
@@ -8180,13 +9171,13 @@ async function removeWorktree(projectRoot, worktreePath) {
   }
   if (registered) {
     errors.push(new Error(`Temporary worktree remains registered: ${worktreePath}`));
-    throw new AggregateError(errors, `Failed to deregister temporary worktree; preserved ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Failed to deregister temporary worktree; preserved ${path16.dirname(worktreePath)}`);
   }
   try {
-    await fsPromises2.rm(path15.dirname(worktreePath), { recursive: true, force: true });
+    await fsPromises2.rm(path16.dirname(worktreePath), { recursive: true, force: true });
   } catch (error) {
     errors.push(asError(error));
-    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path16.dirname(worktreePath)}`);
   }
 }
 async function cleanupTemporaryWorktree(projectRoot, worktreePath, temporaryRoot) {
@@ -8222,9 +9213,9 @@ async function withMaterializedBranch(request, callback) {
       `Git ref ${JSON.stringify(request.ref ?? request.branch)} is not available locally. For an unfetched branch, pass a remote-qualified name such as origin/feature.`
     );
   }
-  const temporaryRoot = await fsPromises2.mkdtemp(path15.join(os6.tmpdir(), "codebase-index-branch-"));
-  const worktreePath = path15.join(temporaryRoot, "worktree");
-  const hooksPath = path15.join(temporaryRoot, "hooks");
+  const temporaryRoot = await fsPromises2.mkdtemp(path16.join(os7.tmpdir(), "codebase-index-branch-"));
+  const worktreePath = path16.join(temporaryRoot, "worktree");
+  const hooksPath = path16.join(temporaryRoot, "hooks");
   await fsPromises2.mkdir(hooksPath);
   const info = {
     branch: request.branch,
@@ -8275,8 +9266,8 @@ async function withMaterializedBranch(request, callback) {
 
 // src/tools/changed-files.ts
 import { execFile as execFile3 } from "child_process";
-import { realpathSync as realpathSync4 } from "fs";
-import * as path16 from "path";
+import { realpathSync as realpathSync5 } from "fs";
+import * as path17 from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile3);
 var GH_PR_VIEW_FIELDS = [
@@ -8418,9 +9409,9 @@ function getHeadRepositoryIdentity(data, host) {
   return `${host}/${owner.toLowerCase()}/${repository.replace(/\.git$/i, "").toLowerCase()}`;
 }
 function getLocalRepositoryIdentity(projectRoot) {
-  let canonicalRoot = path16.resolve(projectRoot);
+  let canonicalRoot = path17.resolve(projectRoot);
   try {
-    canonicalRoot = realpathSync4.native(canonicalRoot);
+    canonicalRoot = realpathSync5.native(canonicalRoot);
   } catch {
   }
   return `local:${canonicalRoot}`;
@@ -8479,17 +9470,17 @@ async function getMergeBase(projectRoot, baseCommit, headCommit) {
   return commit;
 }
 function normalizeFiles(rawFiles, projectRoot) {
-  const root = path16.resolve(projectRoot);
+  const root = path17.resolve(projectRoot);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const raw of rawFiles) {
     if (raw.length === 0) continue;
-    const absolute = path16.resolve(root, raw);
-    const relative14 = path16.relative(root, absolute);
-    if (path16.isAbsolute(raw) || relative14 === ".." || relative14.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative14)) {
+    const absolute = path17.resolve(root, raw);
+    const relative14 = path17.relative(root, absolute);
+    if (path17.isAbsolute(raw) || relative14 === ".." || relative14.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative14)) {
       throw new Error(`Changed file escapes the project root: ${JSON.stringify(raw)}`);
     }
-    const cleaned = relative14.startsWith(`.${path16.sep}`) ? relative14.slice(2) : relative14;
+    const cleaned = relative14.startsWith(`.${path17.sep}`) ? relative14.slice(2) : relative14;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -8500,7 +9491,7 @@ function normalizeFiles(rawFiles, projectRoot) {
 
 // src/indexer/git-blame.ts
 import { execFile as execFile4 } from "child_process";
-import * as path17 from "path";
+import * as path18 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile4);
 function parseGitBlamePorcelain(output) {
@@ -8538,7 +9529,7 @@ function parseGitBlamePorcelain(output) {
   return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
 }
 async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
-  const relativePath = path17.relative(projectRoot, filePath);
+  const relativePath = path18.relative(projectRoot, filePath);
   try {
     const { stdout } = await execFileAsync3(
       "git",
@@ -9117,8 +10108,8 @@ function pathSegmentsForAffinityMatch(filePath) {
   if (segments.length === 0) {
     return [];
   }
-  const basename9 = segments[segments.length - 1] ?? "";
-  const basenameWithoutExt = basename9.replace(/\.[^/.]+$/u, "");
+  const basename10 = segments[segments.length - 1] ?? "";
+  const basenameWithoutExt = basename10.replace(/\.[^/.]+$/u, "");
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
   return Array.from(/* @__PURE__ */ new Set([
     ...normalizedSegments,
@@ -9427,8 +10418,8 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
 
 // src/indexer/failed-state-persistence.ts
 import * as fs2 from "fs";
-import { createHash, randomBytes as randomBytes3 } from "crypto";
-import * as path18 from "path";
+import { createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
+import * as path19 from "path";
 import { StringDecoder } from "string_decoder";
 var CURRENT_FAILED_BATCH_VERSION = 1;
 var DEFAULT_MALFORMED_LINE_ACTION = "skip";
@@ -9446,7 +10437,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) {
@@ -9465,7 +10456,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");
   };
@@ -9473,7 +10464,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;
   };
@@ -9619,10 +10610,10 @@ function stripLeadingBomAndWhitespace(value) {
   return result;
 }
 function createTemporaryPath(targetPath) {
-  const randomId = createHash("sha1").update(`${Date.now()}:${randomBytes3(8).toString("hex")}`).digest("hex");
-  const targetDir = path18.dirname(targetPath);
-  const baseName = path18.basename(targetPath);
-  return path18.join(targetDir, `.${baseName}.${randomId}.tmp`);
+  const randomId = createHash2("sha1").update(`${Date.now()}:${randomBytes3(8).toString("hex")}`).digest("hex");
+  const targetDir = path19.dirname(targetPath);
+  const baseName = path19.basename(targetPath);
+  return path19.join(targetDir, `.${baseName}.${randomId}.tmp`);
 }
 function handleMalformedLine(filePath, lineNumber, line, error, options) {
   const action = options.malformedLineAction ?? DEFAULT_MALFORMED_LINE_ACTION;
@@ -9868,9 +10859,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) {
@@ -10201,10 +11192,10 @@ function matchesHardSearchFilters(candidate, options, projectRoot) {
   }
   if (options?.directory) {
     const candidatePath = canonicalizePathForComparison(
-      path19.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path20.sep))
     );
     const directoryPath = canonicalizePathForComparison(
-      path19.resolve(projectRoot, options.directory.trim().replace(/\\/g, path19.sep))
+      path20.resolve(projectRoot, options.directory.trim().replace(/\\/g, path20.sep))
     );
     if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
@@ -10317,26 +11308,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)}`);
     }
@@ -10360,7 +11362,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);
@@ -10377,10 +11379,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");
@@ -10393,14 +11395,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)
       );
     });
   }
@@ -10408,7 +11410,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path19.resolve(targetPath);
+      return path20.resolve(targetPath);
     }
   }
   getProjectIdentityHash(projectRoot) {
@@ -10489,7 +11491,7 @@ var Indexer = class _Indexer {
     } catch (error) {
       releaseError = error;
       this.writerArtifactFingerprint = null;
-      if (!existsSync11(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+      if (!existsSync12(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
         this.activeIndexLease = null;
       }
     }
@@ -10507,12 +11509,12 @@ var Indexer = class _Indexer {
     return this.activeIndexLease;
   }
   loadFileHashCache() {
-    if (!existsSync11(this.fileHashCachePath)) {
+    if (!existsSync12(this.fileHashCachePath)) {
       this.fileHashCache = /* @__PURE__ */ new Map();
       return;
     }
     try {
-      const data = readFileSync8(this.fileHashCachePath, "utf-8");
+      const data = readFileSync9(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -10534,24 +11536,24 @@ var Indexer = class _Indexer {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    mkdirSync4(path19.dirname(targetPath), { recursive: true });
+    mkdirSync5(path20.dirname(targetPath), { recursive: true });
     try {
-      writeFileSync3(tempPath, data);
-      renameSync3(tempPath, targetPath);
+      writeFileSync4(tempPath, data);
+      renameSync4(tempPath, targetPath);
     } finally {
       removeLeaseTemporaryPath(tempPath);
     }
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path19.join(this.indexPath, "inverted-index.json"),
+      path20.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots(projectRoot = this.projectRoot) {
     const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(this.getCanonicalPath(path19.resolve(projectRoot, kbRoot)));
+      roots.add(this.getCanonicalPath(path20.resolve(projectRoot, kbRoot)));
     }
     return Array.from(roots);
   }
@@ -10968,7 +11970,7 @@ var Indexer = class _Indexer {
     return configuredProviderInfo !== null && recovery.embeddingProvider === configuredProviderInfo.provider && recovery.embeddingModel === configuredProviderInfo.modelInfo.model && recovery.embeddingDimensions === configuredProviderInfo.modelInfo.dimensions && recovery.embeddingStrategyVersion === EMBEDDING_STRATEGY_VERSION;
   }
   hasUnknownLegacyForceIndexClear(owner) {
-    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && existsSync11(path19.join(this.indexPath, "force-index-phase"));
+    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && existsSync12(path20.join(this.indexPath, "force-index-phase"));
   }
   async recoverFromInterruptedIndexingUnlocked(owners) {
     for (const owner of owners) {
@@ -11154,7 +12156,7 @@ var Indexer = class _Indexer {
     }
   }
   clearFailedBatchState() {
-    if (existsSync11(this.failedBatchesPath)) {
+    if (existsSync12(this.failedBatchesPath)) {
       try {
         unlinkSync2(this.failedBatchesPath);
       } catch {
@@ -11356,7 +12358,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(
@@ -11775,12 +12777,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() {
@@ -11805,13 +12807,13 @@ var Indexer = class _Indexer {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
-      const vectorStoreExists = existsSync11(storePath);
-      const vectorMetadataExists = existsSync11(vectorMetadataPath);
+      const vectorStoreExists = existsSync12(storePath);
+      const vectorMetadataExists = existsSync12(vectorMetadataPath);
       if (vectorStoreExists && vectorMetadataExists) {
         try {
           const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
@@ -11826,8 +12828,8 @@ var Indexer = class _Indexer {
         setIssue("vectors", this.getVectorReadIssueMessage());
       }
     }
-    if (keywordChanged || retryDue("keyword") || !existsSync11(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
-      if (existsSync11(invertedIndexPath)) {
+    if (keywordChanged || retryDue("keyword") || !existsSync12(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if (existsSync12(invertedIndexPath)) {
         try {
           const invertedIndex = new InvertedIndex(invertedIndexPath);
           invertedIndex.load();
@@ -11842,7 +12844,7 @@ var Indexer = class _Indexer {
       }
     }
     if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
-      if (existsSync11(dbPath)) {
+      if (existsSync12(dbPath)) {
         try {
           const database = Database.openReadOnly(dbPath);
           if (this.database) {
@@ -11924,11 +12926,11 @@ var Indexer = class _Indexer {
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync11(dbPath);
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync12(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
       await fsPromises3.mkdir(this.indexPath, { recursive: true });
@@ -11960,14 +12962,14 @@ var Indexer = class _Indexer {
         }
       }
       this.store = new VectorStore(storePath, dimensions);
-      if (existsSync11(storePath) || existsSync11(vectorMetadataPath)) {
+      if (existsSync12(storePath) || existsSync12(vectorMetadataPath)) {
         this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
       try {
         this.invertedIndex.load();
       } catch {
-        if (existsSync11(invertedIndexPath)) {
+        if (existsSync12(invertedIndexPath)) {
           await fsPromises3.unlink(invertedIndexPath);
         }
         this.invertedIndex = new InvertedIndex(invertedIndexPath);
@@ -11985,8 +12987,8 @@ var Indexer = class _Indexer {
       }
     } else {
       this.store = new VectorStore(storePath, dimensions);
-      const vectorStoreExists = existsSync11(storePath);
-      const vectorMetadataExists = existsSync11(vectorMetadataPath);
+      const vectorStoreExists = existsSync12(storePath);
+      const vectorMetadataExists = existsSync12(vectorMetadataPath);
       const vectorReadFailureMessage = this.getVectorReadIssueMessage();
       if (vectorStoreExists !== vectorMetadataExists) {
         this.recordReadIssue("vectors", vectorReadFailureMessage);
@@ -11999,7 +13001,7 @@ var Indexer = class _Indexer {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if (existsSync11(invertedIndexPath)) {
+      if (existsSync12(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -12013,7 +13015,7 @@ var Indexer = class _Indexer {
       } else if (this.store.count() > 0) {
         this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
       }
-      if (existsSync11(dbPath)) {
+      if (existsSync12(dbPath)) {
         try {
           this.database = Database.openReadOnly(dbPath);
         } catch (error) {
@@ -12105,7 +13107,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;
@@ -12120,7 +13122,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();
@@ -12130,19 +13132,19 @@ var Indexer = class _Indexer {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync11(backupIndexPath)) {
+    if (existsSync12(backupIndexPath)) {
       unlinkSync2(backupIndexPath);
     }
-    if (existsSync11(backupMetadataPath)) {
+    if (existsSync12(backupMetadataPath)) {
       unlinkSync2(backupMetadataPath);
     }
     try {
-      if (existsSync11(storeIndexPath)) {
-        renameSync3(storeIndexPath, backupIndexPath);
+      if (existsSync12(storeIndexPath)) {
+        renameSync4(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync11(storeMetadataPath)) {
-        renameSync3(storeMetadataPath, backupMetadataPath);
+      if (existsSync12(storeMetadataPath)) {
+        renameSync4(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -12162,10 +13164,10 @@ var Indexer = class _Indexer {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync11(backupIndexPath)) {
+      if (backedUpIndex && existsSync12(backupIndexPath)) {
         unlinkSync2(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync12(backupMetadataPath)) {
         unlinkSync2(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -12178,17 +13180,17 @@ var Indexer = class _Indexer {
         store.clear();
       } catch {
       }
-      if (existsSync11(storeIndexPath)) {
+      if (existsSync12(storeIndexPath)) {
         unlinkSync2(storeIndexPath);
       }
-      if (existsSync11(storeMetadataPath)) {
+      if (existsSync12(storeMetadataPath)) {
         unlinkSync2(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync11(backupIndexPath)) {
-        renameSync3(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && existsSync12(backupIndexPath)) {
+        renameSync4(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
-        renameSync3(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && existsSync12(backupMetadataPath)) {
+        renameSync4(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -12203,11 +13205,11 @@ var Indexer = class _Indexer {
     return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
   }
   async removeProjectRuntimeStateArtifacts() {
-    if (!existsSync11(this.indexPath)) return;
+    if (!existsSync12(this.indexPath)) return;
     const names = await fsPromises3.readdir(this.indexPath);
     const runtimeStatePattern = /^(?:file-hashes|failed-batches)(?:\.[a-f0-9]{16})?\.json$/;
     await Promise.all(
-      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path19.join(this.indexPath, name), { force: true }))
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path20.join(this.indexPath, name), { force: true }))
     );
   }
   async resetLocalIndexArtifacts() {
@@ -12223,13 +13225,13 @@ var Indexer = class _Indexer {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path19.join(this.indexPath, "codebase.db"),
-      path19.join(this.indexPath, "codebase.db-shm"),
-      path19.join(this.indexPath, "codebase.db-wal"),
-      path19.join(this.indexPath, "vectors"),
-      path19.join(this.indexPath, "vectors.usearch"),
-      path19.join(this.indexPath, "vectors.meta.json"),
-      path19.join(this.indexPath, "inverted-index.json")
+      path20.join(this.indexPath, "codebase.db"),
+      path20.join(this.indexPath, "codebase.db-shm"),
+      path20.join(this.indexPath, "codebase.db-wal"),
+      path20.join(this.indexPath, "vectors"),
+      path20.join(this.indexPath, "vectors.usearch"),
+      path20.join(this.indexPath, "vectors.meta.json"),
+      path20.join(this.indexPath, "inverted-index.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => fsPromises3.rm(targetPath, { recursive: true, force: true })));
     await this.removeProjectRuntimeStateArtifacts();
@@ -12239,7 +13241,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") {
@@ -12626,10 +13628,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];
@@ -12673,8 +13675,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);
@@ -12733,7 +13735,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);
@@ -12837,7 +13839,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) {
@@ -13172,8 +14174,8 @@ var Indexer = class _Indexer {
           previousBranchSymbolIds,
           Array.from(allSymbolIds)
         );
-        const vectorPath = path19.join(this.indexPath, "vectors");
-        const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync11(vectorPath) && existsSync11(`${vectorPath}.meta.json`);
+        const vectorPath = path20.join(this.indexPath, "vectors");
+        const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync12(vectorPath) && existsSync12(`${vectorPath}.meta.json`);
         if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
           store.save();
         }
@@ -13968,7 +14970,7 @@ var Indexer = class _Indexer {
     const missingChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync11(this.toMaterializedFilePath(filePath))) {
+      if (!existsSync12(this.toMaterializedFilePath(filePath))) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           missingChunkKeys.push(key);
@@ -14031,7 +15033,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);
@@ -14061,7 +15063,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 };
@@ -14074,7 +15077,7 @@ var Indexer = class _Indexer {
       const retryableChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
         roots,
-        () => true,
+        shouldProcessFailedPath,
         maxChunkTokens
       );
       for (const retryBatch of iterateOrderedFileBatches(
@@ -14344,9 +15347,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path30 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path30.length > 0 && (shortest.length === 0 || path30.length < shortest.length)) {
-        shortest = path30;
+      const path31 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path31.length > 0 && (shortest.length === 0 || path31.length < shortest.length)) {
+        shortest = path31;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -14394,13 +15397,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path30 = [];
+      const path31 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path30.push({
+        path31.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -14410,9 +15413,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path30.reverse();
-      if (path30.length > 0 && (shortest.length === 0 || path30.length < shortest.length)) {
-        shortest = path30;
+      path31.reverse();
+      if (path31.length > 0 && (shortest.length === 0 || path31.length < shortest.length)) {
+        shortest = path31;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -14563,7 +15566,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);
@@ -14712,12 +15715,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;
           }
@@ -14834,15 +15837,24 @@ function getOrCreateIndexer(projectRoot, host) {
   }
   const indexer = new Indexer(projectRoot, config, host);
   indexerCache.set(key, indexer);
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: true,
+    synchronizeBackgroundWorker: false
+  });
   return indexer;
 }
-function initializeTools(projectRoot, config, host) {
+function initializeTools(projectRoot, config, host, options = {}) {
   defaultProjectRoots.set(host, projectRoot);
   const key = getIndexerCacheKey(projectRoot, host);
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host) && indexerCache.has(key)) {
+    return;
+  }
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: options.preserveManagedWorker,
+    synchronizeBackgroundWorker: false
+  });
 }
 function getIndexerForProject(projectRoot, host) {
   const root = getProjectRoot(projectRoot, host);
@@ -14856,7 +15868,9 @@ function refreshIndexerForDirectory(projectRoot, host, config = parseConfig(load
   const key = getIndexerCacheKey(projectRoot, host);
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    synchronizeBackgroundWorker: true
+  });
   return config;
 }
 var AutoIndexRetrievalUnavailableError = class extends Error {
@@ -14883,7 +15897,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);
   }
@@ -15076,12 +16090,12 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth, fromFileP
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path30 = await indexer.findCallPathBySymbolIds(
+  const path31 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path30 };
+  return { from: fromResolution, to: toResolution, path: path31 };
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
@@ -15267,15 +16281,15 @@ async function getIndexLogs(projectRoot, host, args) {
 function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot, 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 (!existsSync12(normalizedPath2)) {
+  if (!existsSync13(normalizedPath2)) {
     return `Error: Directory does not exist: ${normalizedPath2}`;
   }
   let realPath;
   try {
-    realPath = realpathSync5(normalizedPath2);
+    realPath = realpathSync6(normalizedPath2);
   } catch {
     return `Error: Cannot resolve path: ${normalizedPath2}`;
   }
@@ -15304,7 +16318,7 @@ function addKnowledgeBase(projectRoot, 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}`;
     }
@@ -15350,7 +16364,7 @@ function listKnowledgeBases(projectRoot, host) {
   for (let i = 0; i < knowledgeBases.length; i++) {
     const kb = knowledgeBases[i];
     const resolvedPath = resolveKnowledgeBasePath(kb, root);
-    const exists = existsSync12(resolvedPath);
+    const exists = existsSync13(resolvedPath);
     result += `[${i + 1}] ${kb}
 `;
     result += `    Resolved: ${resolvedPath}
@@ -15367,7 +16381,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync12(path20.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync13(path21.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -15401,7 +16415,7 @@ Run /index to rebuild the index without the removed knowledge base.`;
 }
 
 // src/watcher/file-watcher.ts
-import { existsSync as existsSync13, statSync as statSync6 } from "fs";
+import { existsSync as existsSync14, statSync as statSync6 } from "fs";
 
 // node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter2 } from "events";
@@ -15493,7 +16507,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path30) => statMethod(path30, { bigint: true });
+      this._stat = (path31) => statMethod(path31, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -15518,8 +16532,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path30, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
+          const { path: path31, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path31));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -15559,21 +16573,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path30, depth) {
+  async _exploreDir(path31, depth) {
     let files;
     try {
-      files = await readdir(path30, this._rdOptions);
+      files = await readdir(path31, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path30 };
+    return { files, depth, path: path31 };
   }
-  async _formatEntry(dirent, path30) {
+  async _formatEntry(dirent, path31) {
     let entry;
-    const basename9 = this._isDirent ? dirent.name : dirent;
+    const basename10 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path30, basename9));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
+      const fullPath = presolve(pjoin(path31, basename10));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename10 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -15972,16 +16986,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path31, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path30);
-    emitRaw(rawEvent, evPath, { watchedPath: path30 });
-    if (evPath && path30 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path30, evPath), KEY_LISTENERS, sp.join(path30, evPath));
+    listener(path31);
+    emitRaw(rawEvent, evPath, { watchedPath: path31 });
+    if (evPath && path31 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path31, evPath), KEY_LISTENERS, sp.join(path31, evPath));
     }
   };
   try {
-    return fs_watch(path30, {
+    return fs_watch(path31, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -15997,12 +17011,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path30, fullPath, options, handlers) => {
+var setFsWatchListener = (path31, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path31, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -16013,7 +17027,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path30,
+      path31,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -16028,7 +17042,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path30, "r");
+          const fd = await open(path31, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -16059,7 +17073,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -16081,7 +17095,7 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path30, curr));
+          foreach(cont.listeners, (listener2) => listener2(path31, curr));
         }
       })
     };
@@ -16111,13 +17125,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path30, listener) {
+  _watchWithNodeFs(path31, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path30);
-    const basename9 = sp.basename(path30);
+    const directory = sp.dirname(path31);
+    const basename10 = sp.basename(path31);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename9);
-    const absolutePath = sp.resolve(path30);
+    parent.add(basename10);
+    const absolutePath = sp.resolve(path31);
     const options = {
       persistent: opts.persistent
     };
@@ -16126,13 +17140,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path30, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path31, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path30, absolutePath, options, {
+      closer = setFsWatchListener(path31, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -16148,13 +17162,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname15 = sp.dirname(file);
-    const basename9 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname15);
+    const dirname16 = sp.dirname(file);
+    const basename10 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname16);
     let prevStats = stats;
-    if (parent.has(basename9))
+    if (parent.has(basename10))
       return;
-    const listener = async (path30, newStats) => {
+    const listener = async (path31, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -16168,18 +17182,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path30);
+            this.fsw._closeFile(path31);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path30, closer2);
+              this.fsw._addPathCloser(path31, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname15, basename9);
+          this.fsw._remove(dirname16, basename10);
         }
-      } else if (parent.has(basename9)) {
+      } else if (parent.has(basename10)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -16204,7 +17218,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, path30, item) {
+  async _handleSymlink(entry, directory, path31, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -16214,7 +17228,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path30);
+        linkPath = await fsrealpath(path31);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -16224,12 +17238,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, path30, entry.stats);
+          this.fsw._emit(EV.CHANGE, path31, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path30, entry.stats);
+        this.fsw._emit(EV.ADD, path31, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -16259,9 +17273,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path30 = sp.join(directory, item);
+      let path31 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path31, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -16270,11 +17284,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path30 = sp.join(dir, sp.relative(dir, path30));
-        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
+        path31 = sp.join(dir, sp.relative(dir, path31));
+        this._addToNodeFs(path31, 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, () => {
@@ -16283,7 +17297,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) => {
@@ -16340,13 +17354,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path31, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path31) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path30);
+    const wh = this.fsw._getWatchHelpers(path31);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -16362,8 +17376,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path30);
-        const targetPath = follow ? await fsrealpath(path30) : path30;
+        const absPath = sp.resolve(path31);
+        const targetPath = follow ? await fsrealpath(path31) : path31;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -16373,29 +17387,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path30) : path30;
+        const targetPath = follow ? await fsrealpath(path31) : path31;
         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, path30, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path31, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path30), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path31), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path30, closer);
+        this.fsw._addPathCloser(path31, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path30;
+        return path31;
       }
     }
   }
@@ -16438,24 +17452,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path30) {
-  if (typeof path30 !== "string")
+function normalizePath2(path31) {
+  if (typeof path31 !== "string")
     throw new Error("string expected");
-  path30 = sp2.normalize(path30);
-  path30 = path30.replace(/\\/g, "/");
+  path31 = sp2.normalize(path31);
+  path31 = path31.replace(/\\/g, "/");
   let prepend = false;
-  if (path30.startsWith("//"))
+  if (path31.startsWith("//"))
     prepend = true;
-  path30 = path30.replace(DOUBLE_SLASH_RE, "/");
+  path31 = path31.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path30 = "/" + path30;
-  return path30;
+    path31 = "/" + path31;
+  return path31;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path30 = normalizePath2(testString);
+  const path31 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path30, stats)) {
+    if (pattern(path31, stats)) {
       return true;
     }
   }
@@ -16493,19 +17507,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path30) => toUnix(sp2.normalize(toUnix(path30)));
-var normalizeIgnored = (cwd = "") => (path30) => {
-  if (typeof path30 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path30) ? path30 : sp2.join(cwd, path30));
+var normalizePathToUnix = (path31) => toUnix(sp2.normalize(toUnix(path31)));
+var normalizeIgnored = (cwd = "") => (path31) => {
+  if (typeof path31 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path31) ? path31 : sp2.join(cwd, path31));
   } else {
-    return path30;
+    return path31;
   }
 };
-var getAbsolutePath = (path30, cwd) => {
-  if (sp2.isAbsolute(path30)) {
-    return path30;
+var getAbsolutePath = (path31, cwd) => {
+  if (sp2.isAbsolute(path31)) {
+    return path31;
   }
-  return sp2.join(cwd, path30);
+  return sp2.join(cwd, path31);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -16570,10 +17584,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path30, follow, fsw) {
+  constructor(path31, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path30;
-    this.path = path30 = path30.replace(REPLACER_RE, "");
+    const watchPath = path31;
+    this.path = path31 = path31.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -16713,20 +17727,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path30) => {
-        const absPath = getAbsolutePath(path30, cwd);
+      paths = paths.map((path31) => {
+        const absPath = getAbsolutePath(path31, cwd);
         return absPath;
       });
     }
-    paths.forEach((path30) => {
-      this._removeIgnoredPath(path30);
+    paths.forEach((path31) => {
+      this._removeIgnoredPath(path31);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path30) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path31) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path31, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -16748,17 +17762,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path30) => {
-      if (!sp2.isAbsolute(path30) && !this._closers.has(path30)) {
+    paths.forEach((path31) => {
+      if (!sp2.isAbsolute(path31) && !this._closers.has(path31)) {
         if (cwd)
-          path30 = sp2.join(cwd, path30);
-        path30 = sp2.resolve(path30);
+          path31 = sp2.join(cwd, path31);
+        path31 = sp2.resolve(path31);
       }
-      this._closePath(path30);
-      this._addIgnoredPath(path30);
-      if (this._watched.has(path30)) {
+      this._closePath(path31);
+      this._addIgnoredPath(path31);
+      if (this._watched.has(path31)) {
         this._addIgnoredPath({
-          path: path30,
+          path: path31,
           recursive: true
         });
       }
@@ -16822,38 +17836,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @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, path30, stats) {
+  async _emit(event, path31, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path30 = sp2.normalize(path30);
+      path31 = sp2.normalize(path31);
     if (opts.cwd)
-      path30 = sp2.relative(opts.cwd, path30);
-    const args = [path30];
+      path31 = sp2.relative(opts.cwd, path31);
+    const args = [path31];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path30))) {
+    if (awf && (pw = this._pendingWrites.get(path31))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path30, [event, ...args]);
+        this._pendingUnlinks.set(path31, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path31) => {
+          this._pendingUnlinks.forEach((entry, path32) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path31);
+            this._pendingUnlinks.delete(path32);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path31)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path30);
+        this._pendingUnlinks.delete(path31);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -16871,16 +17885,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path31, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path31, 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, path30) : path30;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path31) : path31;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -16911,23 +17925,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path30, timeout) {
+  _throttle(actionType, path31, 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(path30);
+    const actionPath = action.get(path31);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path30);
+      const item = action.get(path31);
       const count = item ? item.count : 0;
-      action.delete(path30);
+      action.delete(path31);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -16935,7 +17949,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path30, thr);
+    action.set(path31, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -16949,44 +17963,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path30, threshold, event, awfEmit) {
+  _awaitWriteFinish(path31, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path30;
-    if (this.options.cwd && !sp2.isAbsolute(path30)) {
-      fullPath = sp2.join(this.options.cwd, path30);
+    let fullPath = path31;
+    if (this.options.cwd && !sp2.isAbsolute(path31)) {
+      fullPath = sp2.join(this.options.cwd, path31);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path30)) {
+        if (err || !writes.has(path31)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path30).lastChange = now3;
+          writes.get(path31).lastChange = now3;
         }
-        const pw = writes.get(path30);
+        const pw = writes.get(path31);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path30);
+          writes.delete(path31);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path30)) {
-      writes.set(path30, {
+    if (!writes.has(path31)) {
+      writes.set(path31, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path30);
+          writes.delete(path31);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -16997,8 +18011,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path30, stats) {
-    if (this.options.atomic && DOT_RE.test(path30))
+  _isIgnored(path31, stats) {
+    if (this.options.atomic && DOT_RE.test(path31))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -17008,17 +18022,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path30, stats);
+    return this._userIgnored(path31, stats);
   }
-  _isntIgnored(path30, stat5) {
-    return !this._isIgnored(path30, stat5);
+  _isntIgnored(path31, stat5) {
+    return !this._isIgnored(path31, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path30) {
-    return new WatchHelper(path30, this.options.followSymlinks, this);
+  _getWatchHelpers(path31) {
+    return new WatchHelper(path31, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -17050,63 +18064,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path30 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path30);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path30, 100))
+    const path31 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path31);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path31) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path31, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path30);
+    const wp = this._getWatchedDir(path31);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path31, 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 = path30;
+    let relPath = path31;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path30);
+      relPath = sp2.relative(this.options.cwd, path31);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path30);
+    this._watched.delete(path31);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path30))
-      this._emit(eventName, path30);
-    this._closePath(path30);
+    if (wasTracked && !this._isIgnored(path31))
+      this._emit(eventName, path31);
+    this._closePath(path31);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path30) {
-    this._closeFile(path30);
-    const dir = sp2.dirname(path30);
-    this._getWatchedDir(dir).remove(sp2.basename(path30));
+  _closePath(path31) {
+    this._closeFile(path31);
+    const dir = sp2.dirname(path31);
+    this._getWatchedDir(dir).remove(sp2.basename(path31));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path30) {
-    const closers = this._closers.get(path30);
+  _closeFile(path31) {
+    const closers = this._closers.get(path31);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path30);
+    this._closers.delete(path31);
   }
-  _addPathCloser(path30, closer) {
+  _addPathCloser(path31, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path30);
+    let list = this._closers.get(path31);
     if (!list) {
       list = [];
-      this._closers.set(path30, list);
+      this._closers.set(path31, list);
     }
     list.push(closer);
   }
@@ -17136,11 +18150,11 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-import * as path23 from "path";
+import * as path24 from "path";
 
 // src/watcher/native-recursive-watcher.ts
 import { watch as watch2 } from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 var NativeRecursiveWatcher = class {
   constructor(root, onChange, options = {}) {
     this.root = root;
@@ -17188,9 +18202,9 @@ 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) => watch2(root, options, listener);
@@ -17198,16 +18212,16 @@ var NativeRecursiveWatcher = class {
 
 // src/watcher/snapshot.ts
 import * as fsPromises4 from "fs/promises";
-import * as path22 from "path";
+import * as path23 from "path";
 async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
-  const normalizedProjectRoot = path22.resolve(projectRoot);
+  const normalizedProjectRoot = path23.resolve(projectRoot);
   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 });
@@ -17219,16 +18233,16 @@ async function buildFileSnapshotScan(projectRoot, 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()) {
@@ -17241,19 +18255,19 @@ async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
   return { entries: snapshot, unreadablePrefixes };
 }
 async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, targetPath) {
-  const normalizedProjectRoot = path22.resolve(projectRoot);
-  const normalizedTargetPath = path22.resolve(targetPath);
+  const normalizedProjectRoot = path23.resolve(projectRoot);
+  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,
@@ -17271,16 +18285,16 @@ async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, ta
     } 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()) {
@@ -17304,7 +18318,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 });
@@ -17314,12 +18328,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 {
@@ -17328,7 +18342,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;
@@ -17465,8 +18479,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;
   }
@@ -17497,7 +18511,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;
@@ -17505,10 +18519,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)) {
@@ -17599,13 +18613,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 (existsSync13(projectConfigPath)) {
+        if (existsSync14(projectConfigPath)) {
           return projectConfigPath;
         }
-        return this.getNearestExistingDirectory(path23.dirname(projectConfigPath));
+        return this.getNearestExistingDirectory(path24.dirname(projectConfigPath));
       })
     )];
   }
@@ -17667,7 +18681,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) {
@@ -17762,23 +18776,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 (!existsSync13(candidate)) {
-      const parent = path23.dirname(candidate);
+    while (!existsSync14(candidate)) {
+      const parent = path24.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -17786,7 +18800,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() {
@@ -17844,7 +18858,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path30, type]) => ({ path: path30, type })
+      ([path31, type]) => ({ path: path31, type })
     );
     this.pendingChanges.clear();
     try {
@@ -17890,7 +18904,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-import * as path24 from "path";
+import * as path25 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -17912,13 +18926,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,
@@ -17986,7 +19000,9 @@ var GitHeadWatcher = class {
 function createWatcherWithIndexer(getIndexer, projectRoot, config, host, options = {}) {
   const fileWatcher = new FileWatcher(projectRoot, config, host, options);
   const configPaths = getConfigPaths(projectRoot, host, options);
-  configureAutoIndex(projectRoot, host, parseConfig(config), getIndexer);
+  configureAutoIndex(projectRoot, host, parseConfig(config), getIndexer, {
+    synchronizeBackgroundWorker: false
+  });
   let stopped = false;
   const requestReindex = () => {
     if (stopped) return;
@@ -18006,7 +19022,9 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config, host, options
         const parsedConfig = options.configPath ? parseConfig(loadConfigFile(options.configPath)) : void 0;
         const refreshedConfig = refreshIndexerForDirectory(projectRoot, host, parsedConfig);
         if (refreshedConfig) {
-          configureAutoIndex(projectRoot, host, refreshedConfig, getIndexer);
+          configureAutoIndex(projectRoot, host, refreshedConfig, getIndexer, {
+            synchronizeBackgroundWorker: false
+          });
         }
       }
       requestReindex();
@@ -18782,7 +19800,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path30 = await getCallGraphPath(
+    const path31 = await getCallGraphPath(
       projectRoot,
       host,
       from,
@@ -18791,25 +19809,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path30);
-    if (path30.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path31);
+    if (path31.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path30.path.length)
+        details: fittedDetails("path", fitted2, path31.path.length)
       };
     }
-    if (path30.from.status !== "resolved" || path30.to.status !== "resolved") {
+    if (path31.from.status !== "resolved" || path31.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path30.from;
+    const resolvedFrom = path31.from;
     const { callers } = await getCallGraphData(projectRoot, host, {
       name: to,
       direction: "callers",
@@ -18970,7 +19988,7 @@ async function executeCallGraph(projectRoot, host, args) {
   return { text: formatCallGraphResult(await getCallGraphData(projectRoot, host, args)) };
 }
 async function executeCallGraphPath(projectRoot, host, args) {
-  const path30 = await getCallGraphPath(
+  const path31 = await getCallGraphPath(
     projectRoot,
     host,
     args.from,
@@ -18979,7 +19997,7 @@ async function executeCallGraphPath(projectRoot, host, args) {
     args.fromFilePath,
     args.toFilePath
   );
-  return { text: formatCallGraphPathResult(path30) };
+  return { text: formatCallGraphPathResult(path31) };
 }
 async function executeCodeCommunities(projectRoot, host, args) {
   const result = await getCodeCommunities(projectRoot, host, args);
@@ -18987,13 +20005,13 @@ async function executeCodeCommunities(projectRoot, host, args) {
 }
 
 // src/adapters/opencode/tools.ts
-import { writeFileSync as writeFileSync4 } from "fs";
-import * as os7 from "os";
-import * as path27 from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+import * as os8 from "os";
+import * as path28 from "path";
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path25 from "path";
+import * as path26 from "path";
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -19155,7 +20173,7 @@ function normalizePath3(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path25.isAbsolute(filePath) ? path25.relative(projectRoot, filePath) : filePath;
+  const relativePath = path26.isAbsolute(filePath) ? path26.relative(projectRoot, filePath) : filePath;
   return normalizePath3(relativePath);
 }
 
@@ -19413,7 +20431,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-import * as path26 from "path";
+import * as path27 from "path";
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -19673,7 +20691,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path26.dirname(s.filePath),
+    directory: path27.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -20002,8 +21020,8 @@ var index_visualize = tool({
       return "No connected symbols found for visualization. Try including orphans with includeOrphans=true, or check that the call graph has resolved edges.";
     }
     const html = generateVisualizationHtml(vizData);
-    const outputPath = path27.join(os7.tmpdir(), `call-graph-${Date.now()}.html`);
-    writeFileSync4(outputPath, html, "utf-8");
+    const outputPath = path28.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
+    writeFileSync5(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
 `;
@@ -20114,8 +21132,8 @@ var MCP_TOOL_NAMES = [
 ];
 
 // src/commands/loader.ts
-import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
-import * as path28 from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
+import * as path29 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -20136,21 +21154,21 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!existsSync14(commandsDir)) {
+  if (!existsSync15(commandsDir)) {
     return commands;
   }
   const files = readdirSync3(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path28.join(commandsDir, file);
+    const filePath = path29.join(commandsDir, file);
     let content;
     try {
-      content = readFileSync9(filePath, "utf-8");
+      content = readFileSync10(filePath, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path28.basename(file, ".md");
+    const name = path29.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -20485,42 +21503,13 @@ var RoutingHintController = class {
 };
 
 // src/adapters/opencode.ts
-var activeWatchers = /* @__PURE__ */ new Map();
-var watcherReplacementChains = /* @__PURE__ */ new Map();
-async function replaceActiveWatcher(projectRoot, createNextWatcher) {
-  const chain = (watcherReplacementChains.get(projectRoot) ?? Promise.resolve()).catch(() => void 0).then(async () => {
-    const existing = activeWatchers.get(projectRoot);
-    if (existing) {
-      try {
-        await existing.stop();
-      } catch (error) {
-        console.error("[codebase-index] Failed to stop replaced watcher:", error);
-        throw error;
-      }
-      if (activeWatchers.get(projectRoot) === existing) {
-        activeWatchers.delete(projectRoot);
-      }
-    }
-    if (createNextWatcher) {
-      activeWatchers.set(projectRoot, createNextWatcher());
-    }
-  });
-  watcherReplacementChains.set(projectRoot, chain);
-  try {
-    await chain;
-  } finally {
-    if (watcherReplacementChains.get(projectRoot) === chain) {
-      watcherReplacementChains.delete(projectRoot);
-    }
-  }
-}
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path29.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path30.dirname(fileURLToPath2(import.meta.url));
   }
-  const packageRoot = path29.basename(currentDir) === "adapters" ? path29.join(currentDir, "..", "..") : path29.join(currentDir, "..");
-  return path29.join(packageRoot, "commands");
+  const packageRoot = path30.basename(currentDir) === "adapters" ? path30.join(currentDir, "..", "..") : path30.join(currentDir, "..");
+  return path30.join(packageRoot, "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -20546,8 +21535,9 @@ var plugin = async ({ directory, worktree }) => {
     initializeTools2(projectRoot, config);
     const getProjectIndexer = () => getIndexerForProject2(projectRoot);
     const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus(), 200, config.search.routingGraphHandoffHints) : null;
-    const isHomeDir = isHomeDirectory(projectRoot);
-    const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(projectRoot));
+    const projectSafety = getProjectSafety(projectRoot, config);
+    const isHomeDir = projectSafety.blockedReason === "home-directory";
+    const isValidProject = projectSafety.safeToRun;
     if (isHomeDir) {
       console.warn(
         `[codebase-index] Refusing to watch or index home directory "${projectRoot}". Open a specific project directory instead.`
@@ -20557,16 +21547,24 @@ var plugin = async ({ directory, worktree }) => {
         `[codebase-index] Skipping file watching and auto-indexing: no project marker found in "${projectRoot}". Set "indexing.requireProjectMarker": false in config to override.`
       );
     }
-    if (config.indexing.autoIndex && isValidProject) {
-      startAutoIndex(projectRoot, "opencode", "startup");
-    }
-    if (config.indexing.watchFiles && isValidProject) {
-      await replaceActiveWatcher(
-        projectRoot,
-        () => createWatcherWithIndexer(getProjectIndexer, projectRoot, config, "opencode")
-      );
+    if (!isValidProject) {
+      await stopBackgroundWorker(projectRoot, "opencode").catch((error) => {
+        console.error("[codebase-index] Failed to stop unsafe OpenCode background worker:", error);
+      });
     } else {
-      await replaceActiveWatcher(projectRoot, null);
+      const watcherFactoryForConfig = (refreshedConfig) => refreshedConfig.indexing.watchFiles ? () => createWatcherWithIndexer(getProjectIndexer, projectRoot, refreshedConfig, "opencode") : null;
+      configureBackgroundWorker(projectRoot, "opencode", config, {
+        startAutoIndex: (source, allowDisabledAutoIndex) => {
+          startAutoIndexForBackgroundWorker(projectRoot, "opencode", source, allowDisabledAutoIndex);
+        },
+        stopAutoIndex: () => stopAutoIndexForBackgroundWorker(projectRoot, "opencode"),
+        watcherFactory: watcherFactoryForConfig(config),
+        watcherFactoryForConfig,
+        replaceWatcher: true
+      }, {
+        restartAutoIndex: true
+      });
+      await waitForBackgroundWorkerStart(projectRoot, "opencode");
     }
     return {
       tool: {