opencode-codebase-index 0.25.0 → 0.25.1

package/dist/index.cjs

@@ -333,7 +333,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path30, checkUnignored, mode) {
+      test(path31, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -342,7 +342,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path30);
+          const matched = rule[mode].test(path31);
           if (!matched) {
             return;
           }
@@ -363,17 +363,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}"`,
@@ -382,7 +382,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 {
@@ -412,19 +412,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(
@@ -437,18 +437,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,
@@ -456,29 +456,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.
@@ -663,7 +663,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/adapters/opencode.ts
-var path29 = __toESM(require("path"), 1);
+var path30 = __toESM(require("path"), 1);
 var import_url = require("url");
 
 // src/config/constants.ts
@@ -1762,7 +1762,7 @@ function loadMergedConfig(projectRoot, host) {
 
 // src/tools/operations.ts
 var import_fs13 = require("fs");
-var path20 = __toESM(require("path"), 1);
+var path21 = __toESM(require("path"), 1);
 
 // src/tools/knowledge-base-paths.ts
 var path8 = __toESM(require("path"), 1);
@@ -2611,8 +2611,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));
@@ -3255,8 +3255,8 @@ function formatEffectivenessMetrics(snapshot) {
 
 // src/utils/auto-index.ts
 var import_fs7 = require("fs");
-var os3 = __toESM(require("os"), 1);
-var path11 = __toESM(require("path"), 1);
+var os4 = __toESM(require("os"), 1);
+var path12 = __toESM(require("path"), 1);
 
 // src/indexer/index-lock.ts
 var import_crypto = require("crypto");
@@ -3503,7 +3503,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(),
@@ -3512,19 +3512,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;
     }
@@ -3694,10 +3694,884 @@ function completeLeaseRecovery(lease) {
   }
 }
 
+// src/utils/background-worker.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var os3 = __toESM(require("os"), 1);
+var path10 = __toESM(require("path"), 1);
+var OWNER_FILE_NAME2 = "owner.json";
+var HEARTBEAT_FILE_PREFIX = "heartbeat.";
+var RECLAIM_DIRECTORY_NAME2 = "reclaim";
+var REFRESH_REQUEST_FILE_NAME = "refresh-request.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_LEASE_MS = 3e4;
+var RETRY_DELAY_MS = 5e3;
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var BackgroundWorkerStopError = class extends Error {
+  constructor(watcherError, autoIndexError) {
+    super("Failed to stop background worker");
+    this.watcherError = watcherError;
+    this.autoIndexError = autoIndexError;
+    this.name = "BackgroundWorkerStopError";
+  }
+  watcherError;
+  autoIndexError;
+};
+var workers = /* @__PURE__ */ new Map();
+var workerKeysByProject = /* @__PURE__ */ new Map();
+var workerReplacementBarriers = /* @__PURE__ */ new Map();
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function canonicalizePath(targetPath) {
+  const resolved = path10.resolve(targetPath);
+  if ((0, import_node_fs.existsSync)(resolved)) {
+    try {
+      return import_node_fs.realpathSync.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 = (0, import_node_crypto.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((0, import_node_fs.readFileSync)(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((0, import_node_fs.readFileSync)(heartbeatPath(leasePath, owner.token), "utf-8")),
+      owner.token
+    );
+    return heartbeat ? { ...owner, heartbeatAt: heartbeat.heartbeatAt } : owner;
+  } catch {
+    return owner;
+  }
+}
+function readReclaimOwner2(leasePath) {
+  try {
+    return parseReclaimOwner2(JSON.parse((0, import_node_fs.readFileSync)(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}.${(0, import_node_crypto.randomUUID)()}`;
+  const heartbeat = {
+    version: 1,
+    token: owner.token,
+    heartbeatAt: owner.heartbeatAt
+  };
+  try {
+    (0, import_node_fs.writeFileSync)(temporaryPath, JSON.stringify(heartbeat), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    (0, import_node_fs.renameSync)(temporaryPath, targetPath);
+    const currentOwner = readLeaseOwner(leasePath);
+    return currentOwner !== null && sameOwner2(currentOwner, owner);
+  } finally {
+    if ((0, import_node_fs.existsSync)(temporaryPath)) (0, import_node_fs.rmSync)(temporaryPath, { force: true });
+  }
+}
+function requestRefreshFromLeader(leasePath, allowDisabledAutoIndex) {
+  const requestPath = refreshRequestPath(leasePath);
+  const temporaryPath = `${requestPath}.tmp.${process.pid}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    const request = {
+      allowDisabledAutoIndex,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    (0, import_node_fs.writeFileSync)(temporaryPath, JSON.stringify(request), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    (0, import_node_fs.renameSync)(temporaryPath, requestPath);
+  } catch (error) {
+    if (getErrorCode2(error) !== "ENOENT") {
+      console.error("[codebase-index] Failed to request background index refresh from the project worker:", error);
+    }
+  } finally {
+    if ((0, import_node_fs.existsSync)(temporaryPath)) (0, import_node_fs.rmSync)(temporaryPath, { force: true });
+  }
+}
+function consumeRefreshRequest(leasePath) {
+  const requestPath = refreshRequestPath(leasePath);
+  const claimedPath = `${requestPath}.handling.${process.pid}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    (0, import_node_fs.renameSync)(requestPath, claimedPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const value = JSON.parse((0, import_node_fs.readFileSync)(claimedPath, "utf-8"));
+    return {
+      allowDisabledAutoIndex: value.version === 1 && value.allowDisabledAutoIndex === true,
+      requestedAt: typeof value.requestedAt === "string" ? value.requestedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+  } catch {
+    return { allowDisabledAutoIndex: false, requestedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  } finally {
+    (0, import_node_fs.rmSync)(claimedPath, { force: true });
+  }
+}
+function publishLease(leasePath, owner) {
+  const candidatePath = `${leasePath}.candidate.${process.pid}.${owner.token}`;
+  try {
+    (0, import_node_fs.mkdirSync)(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(path10.join(candidatePath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if ((0, import_node_fs.existsSync)(leasePath)) return false;
+    try {
+      (0, import_node_fs.renameSync)(candidatePath, leasePath);
+      return true;
+    } catch (error) {
+      if ((0, import_node_fs.existsSync)(leasePath) || getErrorCode2(error) === "ENOENT") return false;
+      throw error;
+    }
+  } finally {
+    if ((0, import_node_fs.existsSync)(candidatePath)) (0, import_node_fs.rmSync)(candidatePath, { recursive: true, force: true });
+  }
+}
+function sameReclaimOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token && left.expectedOwnerToken === right.expectedOwnerToken;
+}
+function reclaimerLiveness(owner) {
+  return ownerLiveness(owner);
+}
+function isReclaimMarkerExpired(leasePath, owner) {
+  const startedAt = owner ? Date.parse(owner.startedAt) : (() => {
+    try {
+      return (0, import_node_fs.lstatSync)(reclaimPath(leasePath)).mtimeMs;
+    } catch {
+      return Date.now();
+    }
+  })();
+  return Date.now() - startedAt >= STALE_LEASE_MS;
+}
+function hasActiveReclaimMarker(leasePath, owner) {
+  const marker = readReclaimOwner2(leasePath);
+  return marker !== null && marker.expectedOwnerToken === owner.token && (marker.hostname !== 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: (0, import_node_crypto.randomUUID)(),
+    expectedOwnerToken: expectedOwner?.token ?? null
+  };
+  try {
+    (0, import_node_fs.mkdirSync)(markerPath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "EEXIST" || getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(path10.join(markerPath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    return owner;
+  } catch (error) {
+    (0, import_node_fs.rmSync)(markerPath, { recursive: true, force: true });
+    throw error;
+  }
+}
+function removeExpiredReclaimMarker(leasePath, expectedOwner) {
+  const marker = readReclaimOwner2(leasePath);
+  const markerPath = reclaimPath(leasePath);
+  if (!(0, import_node_fs.existsSync)(markerPath)) return false;
+  if (marker && marker.expectedOwnerToken !== (expectedOwner?.token ?? null)) return false;
+  if (marker && (reclaimerLiveness(marker) === "alive" || !isReclaimMarkerExpired(leasePath, marker))) return false;
+  if (!marker && !isReclaimMarkerExpired(leasePath, null)) return false;
+  const staleMarkerPath = `${markerPath}.stale.${marker?.pid ?? process.pid}.${marker?.token ?? (0, import_node_crypto.randomUUID)()}.${(0, import_node_crypto.randomUUID)()}`;
+  try {
+    (0, import_node_fs.renameSync)(markerPath, staleMarkerPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    let claimedMarker = null;
+    try {
+      claimedMarker = parseReclaimOwner2(
+        JSON.parse((0, import_node_fs.readFileSync)(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 (!(0, import_node_fs.existsSync)(markerPath) && (0, import_node_fs.existsSync)(staleMarkerPath)) (0, import_node_fs.renameSync)(staleMarkerPath, markerPath);
+      return false;
+    }
+    (0, import_node_fs.rmSync)(staleMarkerPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+function canReclaimLease(leasePath, expectedOwner) {
+  if (!(0, import_node_fs.existsSync)(leasePath)) return false;
+  if (!expectedOwner) return false;
+  const currentOwner = readOwner(leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, expectedOwner)) return false;
+  if (currentOwner.hostname === 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}`;
+    (0, import_node_fs.renameSync)(leasePath, stalePath);
+    const quarantinedOwner = readOwner(stalePath);
+    const quarantinedMarker = readReclaimOwner2(stalePath);
+    if (!quarantinedMarker || !sameReclaimOwner2(quarantinedMarker, marker) || expectedOwner !== null && (!quarantinedOwner || !sameOwner2(quarantinedOwner, expectedOwner))) {
+      if (!(0, import_node_fs.existsSync)(leasePath) && (0, import_node_fs.existsSync)(stalePath)) (0, import_node_fs.renameSync)(stalePath, leasePath);
+      return false;
+    }
+    (0, import_node_fs.rmSync)(stalePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  } finally {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (currentMarker && sameReclaimOwner2(currentMarker, marker)) {
+      (0, import_node_fs.rmSync)(markerPath, { recursive: true, force: true });
+    }
+  }
+}
+function acquireLease(identity) {
+  (0, import_node_fs.mkdirSync)(identity.canonicalIndexPath, { recursive: true, mode: 448 });
+  const canonicalIndexPath = import_node_fs.realpathSync.native(identity.canonicalIndexPath);
+  const leasePath = 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: (0, import_node_crypto.randomUUID)()
+    };
+    if (publishLease(leasePath, owner)) {
+      return { leasePath, owner };
+    }
+    const existingOwner = readOwner(leasePath);
+    if (existingOwner) {
+      if (canReclaimLease(leasePath, existingOwner) && reclaimLease(leasePath, existingOwner)) continue;
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function releaseLease(lease) {
+  const currentOwner = readOwner(lease.leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) return false;
+  const releasePath = `${lease.leasePath}.release.${lease.owner.pid}.${lease.owner.token}`;
+  try {
+    (0, import_node_fs.renameSync)(lease.leasePath, releasePath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readOwner(releasePath);
+  if (!claimedOwner || !sameOwner2(claimedOwner, lease.owner)) {
+    if (!(0, import_node_fs.existsSync)(lease.leasePath) && (0, import_node_fs.existsSync)(releasePath)) {
+      (0, import_node_fs.renameSync)(releasePath, lease.leasePath);
+    }
+    return false;
+  }
+  (0, import_node_fs.rmSync)(releasePath, { recursive: true, force: true });
+  return true;
+}
+var BackgroundWorkerController = class {
+  constructor(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);
 var import_fs6 = require("fs");
-var path10 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -3715,7 +4589,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if ((0, import_fs6.existsSync)(path10.join(projectRoot, marker))) {
+    if ((0, import_fs6.existsSync)(path11.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3742,33 +4616,53 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path10.join(projectRoot, ".gitignore");
+  const gitignorePath = path11.join(projectRoot, ".gitignore");
   if ((0, import_fs6.existsSync)(gitignorePath)) {
     const gitignoreContent = (0, import_fs6.readFileSync)(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);
@@ -3789,8 +4683,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" });
@@ -3808,6 +4702,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 import_fs6.promises.stat(fullPath);
@@ -3815,20 +4713,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 });
       }
     }
@@ -3839,7 +4728,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) {
@@ -3879,8 +4768,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);
     }
@@ -3921,7 +4810,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,
@@ -3931,7 +4820,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve17(stdout);
+        resolve18(stdout);
       }
     );
   });
@@ -4023,8 +4912,8 @@ var AutoIndexCancelledError = class extends Error {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function canonicalizePath(targetPath) {
-  const resolved = path11.resolve(targetPath);
+function canonicalizePath2(targetPath) {
+  const resolved = path12.resolve(targetPath);
   if ((0, import_fs7.existsSync)(resolved)) {
     try {
       return import_fs7.realpathSync.native(resolved);
@@ -4032,20 +4921,20 @@ function canonicalizePath(targetPath) {
       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)) {
@@ -4076,10 +4965,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 = () => {
@@ -4091,18 +4980,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;
@@ -4113,6 +5028,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,
@@ -4174,11 +5090,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) {
@@ -4253,13 +5169,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)) {
@@ -4448,7 +5366,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");
@@ -4481,17 +5399,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() {
@@ -4499,9 +5417,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;
@@ -4514,12 +5432,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
@@ -4537,6 +5468,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);
@@ -4552,11 +5486,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,
@@ -4596,15 +5536,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();
@@ -4625,18 +5573,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
 var import_fs8 = require("fs");
-var path12 = __toESM(require("path"), 1);
+var path13 = __toESM(require("path"), 1);
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -4663,8 +5645,8 @@ function loadEditableConfig(projectRoot, host) {
 }
 function saveConfig(projectRoot, config, host) {
   const configPath = getConfigPath(projectRoot, host);
-  const configDir = path12.dirname(configPath);
-  const configBaseDir = path12.dirname(configDir);
+  const configDir = path13.dirname(configPath);
+  const configBaseDir = path13.dirname(configDir);
   if (!(0, import_fs8.existsSync)(configDir)) {
     (0, import_fs8.mkdirSync)(configDir, { recursive: true });
   }
@@ -4679,7 +5661,7 @@ function saveConfig(projectRoot, config, host) {
 
 // src/indexer/index.ts
 var import_fs12 = require("fs");
-var path19 = __toESM(require("path"), 1);
+var path20 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
 var import_child_process4 = require("child_process");
 var import_util4 = require("util");
@@ -4706,7 +5688,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}\``);
     }
@@ -4720,7 +5702,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;
     }
@@ -4728,7 +5710,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve17(fallback());
+          resolve18(fallback());
         } catch (error) {
           reject(error);
         }
@@ -4738,7 +5720,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve17();
+        resolve18();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -5140,7 +6122,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 () => {
@@ -5180,7 +6162,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve17(result);
+          resolve18(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -5368,13 +6350,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);
     });
@@ -5660,7 +6642,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);
@@ -5668,7 +6650,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve17();
+        resolve18();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -5730,10 +6712,10 @@ async function pRetry(input, options = {}) {
 
 // src/embeddings/detector.ts
 var import_fs9 = require("fs");
-var path13 = __toESM(require("path"), 1);
-var os4 = __toESM(require("os"), 1);
+var path14 = __toESM(require("path"), 1);
+var os5 = __toESM(require("os"), 1);
 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();
@@ -6030,17 +7012,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 };
 }
@@ -7132,8 +8114,8 @@ function extractParamNames(params) {
 }
 
 // src/native/binding.ts
-var os5 = __toESM(require("os"), 1);
-var path14 = __toESM(require("path"), 1);
+var os6 = __toESM(require("os"), 1);
+var path15 = __toESM(require("path"), 1);
 var module2 = __toESM(require("module"), 1);
 var import_node_url = require("url");
 
@@ -7170,7 +8152,7 @@ var STABLE_NATIVE_BINARY_NAME = IDENTITY_CATALOG.native.binaryName;
 
 // src/native/binding.ts
 var import_meta = {};
-function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()) {
+function getNativeBindingFilename(platform2 = os6.platform(), arch2 = os6.arch()) {
   if (platform2 === "darwin" && arch2 === "arm64") {
     return `${STABLE_NATIVE_BINARY_NAME}.darwin-arm64.node`;
   }
@@ -7188,25 +8170,25 @@ function getNativeBindingFilename(platform2 = os5.platform(), arch2 = os5.arch()
   }
   throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
 }
-function resolveNativeBindingPath(packageRoot, platform2 = os5.platform(), arch2 = os5.arch()) {
-  return path14.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
+function resolveNativeBindingPath(packageRoot, platform2 = os6.platform(), arch2 = os6.arch()) {
+  return path15.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
 }
 function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import_meta !== "undefined" && import_meta.url) {
-    currentDir = path14.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+    currentDir = path15.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
     requireTarget = import_meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path14.join(currentDir, "index.js");
+    requireTarget = path15.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path14.join("src", "native"));
-  const packageRoot = isDevMode ? path14.resolve(currentDir, "../..") : path14.resolve(currentDir, "..");
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path15.join("src", "native"));
+  const packageRoot = isDevMode ? path15.resolve(currentDir, "../..") : path15.resolve(currentDir, "..");
   const nativePath = resolveNativeBindingPath(packageRoot);
   const require2 = module2.createRequire(requireTarget);
   return require2(nativePath);
@@ -7790,8 +8772,8 @@ var Database = class _Database {
 
 // src/git/branch-materialization.ts
 var import_fs10 = require("fs");
-var os6 = __toESM(require("os"), 1);
-var path15 = __toESM(require("path"), 1);
+var os7 = __toESM(require("os"), 1);
+var path16 = __toESM(require("path"), 1);
 
 // src/git/branch-resolution.ts
 var import_child_process = require("child_process");
@@ -8110,13 +9092,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 import_fs10.promises.readdir(registrationsRoot, { withFileTypes: true });
@@ -8127,16 +9109,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 import_fs10.promises.readFile(path15.join(registrationPath, "gitdir"), "utf8")).trim();
+      gitdirPath = (await import_fs10.promises.readFile(path16.join(registrationPath, "gitdir"), "utf8")).trim();
     } catch {
       continue;
     }
-    const resolvedGitdirPath = path15.isAbsolute(gitdirPath) ? gitdirPath : path15.resolve(registrationPath, gitdirPath);
-    if (canonicalizePathForComparison(path15.dirname(resolvedGitdirPath)) !== target) continue;
+    const resolvedGitdirPath = path16.isAbsolute(gitdirPath) ? gitdirPath : path16.resolve(registrationPath, gitdirPath);
+    if (canonicalizePathForComparison(path16.dirname(resolvedGitdirPath)) !== target) continue;
     await import_fs10.promises.rm(registrationPath, { recursive: true, force: true });
     return true;
   }
@@ -8154,7 +9136,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 {
@@ -8170,7 +9152,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)) {
@@ -8183,13 +9165,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 import_fs10.promises.rm(path15.dirname(worktreePath), { recursive: true, force: true });
+    await import_fs10.promises.rm(path16.dirname(worktreePath), { recursive: true, force: true });
   } catch (error) {
     errors.push(asError(error));
-    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path15.dirname(worktreePath)}`);
+    throw new AggregateError(errors, `Deregistered the temporary worktree but could not remove ${path16.dirname(worktreePath)}`);
   }
 }
 async function cleanupTemporaryWorktree(projectRoot, worktreePath, temporaryRoot) {
@@ -8225,9 +9207,9 @@ async function withMaterializedBranch(request, callback) {
       `Git ref ${JSON.stringify(request.ref ?? request.branch)} is not available locally. For an unfetched branch, pass a remote-qualified name such as origin/feature.`
     );
   }
-  const temporaryRoot = await import_fs10.promises.mkdtemp(path15.join(os6.tmpdir(), "codebase-index-branch-"));
-  const worktreePath = path15.join(temporaryRoot, "worktree");
-  const hooksPath = path15.join(temporaryRoot, "hooks");
+  const temporaryRoot = await import_fs10.promises.mkdtemp(path16.join(os7.tmpdir(), "codebase-index-branch-"));
+  const worktreePath = path16.join(temporaryRoot, "worktree");
+  const hooksPath = path16.join(temporaryRoot, "hooks");
   await import_fs10.promises.mkdir(hooksPath);
   const info = {
     branch: request.branch,
@@ -8279,7 +9261,7 @@ async function withMaterializedBranch(request, callback) {
 // src/tools/changed-files.ts
 var import_child_process2 = require("child_process");
 var import_fs11 = require("fs");
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_util2 = require("util");
 var execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
 var GH_PR_VIEW_FIELDS = [
@@ -8421,7 +9403,7 @@ 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 = import_fs11.realpathSync.native(canonicalRoot);
   } catch {
@@ -8482,17 +9464,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);
@@ -8503,7 +9485,7 @@ function normalizeFiles(rawFiles, projectRoot) {
 
 // src/indexer/git-blame.ts
 var import_child_process3 = require("child_process");
-var path17 = __toESM(require("path"), 1);
+var path18 = __toESM(require("path"), 1);
 var import_util3 = require("util");
 var execFileAsync3 = (0, import_util3.promisify)(import_child_process3.execFile);
 function parseGitBlamePorcelain(output) {
@@ -8541,7 +9523,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",
@@ -9120,8 +10102,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,
@@ -9430,8 +10412,8 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
 
 // src/indexer/failed-state-persistence.ts
 var fs2 = __toESM(require("fs"), 1);
-var import_node_crypto = require("crypto");
-var path18 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+var path19 = __toESM(require("path"), 1);
 var import_node_string_decoder = require("string_decoder");
 var CURRENT_FAILED_BATCH_VERSION = 1;
 var DEFAULT_MALFORMED_LINE_ACTION = "skip";
@@ -9449,7 +10431,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) {
@@ -9468,7 +10450,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");
   };
@@ -9476,7 +10458,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;
   };
@@ -9622,10 +10604,10 @@ function stripLeadingBomAndWhitespace(value) {
   return result;
 }
 function createTemporaryPath(targetPath) {
-  const randomId = (0, import_node_crypto.createHash)("sha1").update(`${Date.now()}:${(0, import_node_crypto.randomBytes)(8).toString("hex")}`).digest("hex");
-  const targetDir = path18.dirname(targetPath);
-  const baseName = path18.basename(targetPath);
-  return path18.join(targetDir, `.${baseName}.${randomId}.tmp`);
+  const randomId = (0, import_node_crypto2.createHash)("sha1").update(`${Date.now()}:${(0, import_node_crypto2.randomBytes)(8).toString("hex")}`).digest("hex");
+  const targetDir = path19.dirname(targetPath);
+  const baseName = path19.basename(targetPath);
+  return path19.join(targetDir, `.${baseName}.${randomId}.tmp`);
 }
 function handleMalformedLine(filePath, lineNumber, line, error, options) {
   const action = options.malformedLineAction ?? DEFAULT_MALFORMED_LINE_ACTION;
@@ -9871,9 +10853,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) {
@@ -10204,10 +11186,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;
   }
@@ -10320,26 +11302,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)}`);
     }
@@ -10363,7 +11356,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);
@@ -10380,10 +11373,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");
@@ -10396,14 +11389,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)
       );
     });
   }
@@ -10411,7 +11404,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path19.resolve(targetPath);
+      return path20.resolve(targetPath);
     }
   }
   getProjectIdentityHash(projectRoot) {
@@ -10537,7 +11530,7 @@ var Indexer = class _Indexer {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    (0, import_fs12.mkdirSync)(path19.dirname(targetPath), { recursive: true });
+    (0, import_fs12.mkdirSync)(path20.dirname(targetPath), { recursive: true });
     try {
       (0, import_fs12.writeFileSync)(tempPath, data);
       (0, import_fs12.renameSync)(tempPath, targetPath);
@@ -10547,14 +11540,14 @@ var Indexer = class _Indexer {
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path19.join(this.indexPath, "inverted-index.json"),
+      path20.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots(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);
   }
@@ -10971,7 +11964,7 @@ var Indexer = class _Indexer {
     return configuredProviderInfo !== null && recovery.embeddingProvider === configuredProviderInfo.provider && recovery.embeddingModel === configuredProviderInfo.modelInfo.model && recovery.embeddingDimensions === configuredProviderInfo.modelInfo.dimensions && recovery.embeddingStrategyVersion === EMBEDDING_STRATEGY_VERSION;
   }
   hasUnknownLegacyForceIndexClear(owner) {
-    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && (0, import_fs12.existsSync)(path19.join(this.indexPath, "force-index-phase"));
+    return owner.operation === "force-index" && owner.clearRecovery === void 0 && owner.recoveryProtocolVersion !== 1 && (0, import_fs12.existsSync)(path20.join(this.indexPath, "force-index-phase"));
   }
   async recoverFromInterruptedIndexingUnlocked(owners) {
     for (const owner of owners) {
@@ -11359,7 +12352,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(
@@ -11778,12 +12771,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() {
@@ -11808,10 +12801,10 @@ var Indexer = class _Indexer {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
       const vectorStoreExists = (0, import_fs12.existsSync)(storePath);
       const vectorMetadataExists = (0, import_fs12.existsSync)(vectorMetadataPath);
@@ -11927,10 +12920,10 @@ var Indexer = class _Indexer {
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path19.join(this.indexPath, "vectors");
+    const storePath = path20.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
-    const dbPath = path19.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path20.join(this.indexPath, "inverted-index.json");
+    const dbPath = path20.join(this.indexPath, "codebase.db");
     let dbIsNew = !(0, import_fs12.existsSync)(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
@@ -12108,7 +13101,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;
@@ -12123,7 +13116,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();
@@ -12210,7 +13203,7 @@ var Indexer = class _Indexer {
     const names = await import_fs12.promises.readdir(this.indexPath);
     const runtimeStatePattern = /^(?:file-hashes|failed-batches)(?:\.[a-f0-9]{16})?\.json$/;
     await Promise.all(
-      names.filter((name) => runtimeStatePattern.test(name)).map((name) => import_fs12.promises.rm(path19.join(this.indexPath, name), { force: true }))
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => import_fs12.promises.rm(path20.join(this.indexPath, name), { force: true }))
     );
   }
   async resetLocalIndexArtifacts() {
@@ -12226,13 +13219,13 @@ var Indexer = class _Indexer {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path19.join(this.indexPath, "codebase.db"),
-      path19.join(this.indexPath, "codebase.db-shm"),
-      path19.join(this.indexPath, "codebase.db-wal"),
-      path19.join(this.indexPath, "vectors"),
-      path19.join(this.indexPath, "vectors.usearch"),
-      path19.join(this.indexPath, "vectors.meta.json"),
-      path19.join(this.indexPath, "inverted-index.json")
+      path20.join(this.indexPath, "codebase.db"),
+      path20.join(this.indexPath, "codebase.db-shm"),
+      path20.join(this.indexPath, "codebase.db-wal"),
+      path20.join(this.indexPath, "vectors"),
+      path20.join(this.indexPath, "vectors.usearch"),
+      path20.join(this.indexPath, "vectors.meta.json"),
+      path20.join(this.indexPath, "inverted-index.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => import_fs12.promises.rm(targetPath, { recursive: true, force: true })));
     await this.removeProjectRuntimeStateArtifacts();
@@ -12242,7 +13235,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") {
@@ -12629,10 +13622,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];
@@ -12676,8 +13669,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);
@@ -12736,7 +13729,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);
@@ -12840,7 +13833,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) {
@@ -13175,7 +14168,7 @@ var Indexer = class _Indexer {
           previousBranchSymbolIds,
           Array.from(allSymbolIds)
         );
-        const vectorPath = path19.join(this.indexPath, "vectors");
+        const vectorPath = path20.join(this.indexPath, "vectors");
         const shouldFingerprintLegacyPair = !store.hasFingerprint() && (0, import_fs12.existsSync)(vectorPath) && (0, import_fs12.existsSync)(`${vectorPath}.meta.json`);
         if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
           store.save();
@@ -14034,7 +15027,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);
@@ -14064,7 +15057,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 };
@@ -14077,7 +15071,7 @@ var Indexer = class _Indexer {
       const retryableChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
         roots,
-        () => true,
+        shouldProcessFailedPath,
         maxChunkTokens
       );
       for (const retryBatch of iterateOrderedFileBatches(
@@ -14347,9 +15341,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));
@@ -14397,13 +15391,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,
@@ -14413,9 +15407,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));
@@ -14566,7 +15560,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);
@@ -14715,12 +15709,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;
           }
@@ -14837,15 +15831,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);
@@ -14859,7 +15862,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 {
@@ -14886,7 +15891,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);
   }
@@ -15079,12 +16084,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);
@@ -15270,8 +16275,8 @@ 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 (!(0, import_fs13.existsSync)(normalizedPath2)) {
     return `Error: Directory does not exist: ${normalizedPath2}`;
@@ -15307,7 +16312,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}`;
     }
@@ -15370,7 +16375,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = (0, import_fs13.existsSync)(path20.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = (0, import_fs13.existsSync)(path21.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -15408,7 +16413,7 @@ var import_fs14 = require("fs");
 
 // node_modules/chokidar/index.js
 var import_node_events = require("events");
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises3 = require("fs/promises");
 var sp2 = __toESM(require("path"), 1);
 
@@ -15496,7 +16501,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path30) => statMethod(path30, { bigint: true });
+      this._stat = (path31) => statMethod(path31, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -15521,8 +16526,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: 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)
@@ -15562,21 +16567,21 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path30, depth) {
+  async _exploreDir(path31, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path30, this._rdOptions);
+      files = await (0, import_promises.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 = (0, import_node_path.resolve)((0, import_node_path.join)(path30, basename9));
-      entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename9 };
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path31, basename10));
+      entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -15646,7 +16651,7 @@ function readdirp(root, options = {}) {
 }
 
 // node_modules/chokidar/handler.js
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_node_os = require("os");
 var sp = __toESM(require("path"), 1);
@@ -15975,16 +16980,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 (0, import_node_fs.watch)(path30, {
+    return (0, import_node_fs2.watch)(path31, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -16000,12 +17005,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);
@@ -16016,7 +17021,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,
@@ -16031,7 +17036,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path30, "r");
+          const fd = await (0, import_promises2.open)(path31, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -16062,12 +17067,12 @@ 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;
   if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    (0, import_node_fs.unwatchFile)(fullPath);
+    (0, import_node_fs2.unwatchFile)(fullPath);
     cont = void 0;
   }
   if (cont) {
@@ -16078,13 +17083,13 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: (0, import_node_fs.watchFile)(fullPath, options, (curr, prev) => {
+      watcher: (0, import_node_fs2.watchFile)(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter2) => {
           rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path30, curr));
+          foreach(cont.listeners, (listener2) => listener2(path31, curr));
         }
       })
     };
@@ -16095,7 +17100,7 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      (0, import_node_fs.unwatchFile)(fullPath);
+      (0, import_node_fs2.unwatchFile)(fullPath);
       cont.options = cont.watcher = void 0;
       Object.freeze(cont);
     }
@@ -16114,13 +17119,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
     };
@@ -16129,13 +17134,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
@@ -16151,13 +17156,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) {
@@ -16171,18 +17176,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) {
@@ -16207,7 +17212,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;
     }
@@ -16217,7 +17222,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path30);
+        linkPath = await (0, import_promises2.realpath)(path31);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -16227,12 +17232,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;
@@ -16262,9 +17267,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) {
@@ -16273,11 +17278,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, () => {
@@ -16286,7 +17291,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) => {
@@ -16343,13 +17348,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);
@@ -16365,8 +17370,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path30);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path30) : path30;
+        const absPath = sp.resolve(path31);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path31) : path31;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -16376,29 +17381,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path30) : path30;
+        const targetPath = follow ? await (0, import_promises2.realpath)(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;
       }
     }
   }
@@ -16441,24 +17446,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;
     }
   }
@@ -16496,19 +17501,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 {
@@ -16573,10 +17578,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 = [];
@@ -16716,20 +17721,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     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;
@@ -16751,17 +17756,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       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
         });
       }
@@ -16825,38 +17830,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, 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) {
@@ -16874,16 +17879,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           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 (0, import_promises3.stat)(fullPath);
@@ -16914,23 +17919,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, 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);
@@ -16938,7 +17943,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path30, thr);
+    action.set(path31, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -16952,44 +17957,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(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) {
-      (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path30)) {
+      (0, import_node_fs3.stat)(fullPath, (err, curStat) => {
+        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;
         }
@@ -17000,8 +18005,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * 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;
@@ -17011,17 +18016,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(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
   // -----------------
@@ -17053,63 +18058,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @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);
   }
@@ -17139,11 +18144,11 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-var path23 = __toESM(require("path"), 1);
+var path24 = __toESM(require("path"), 1);
 
 // src/watcher/native-recursive-watcher.ts
-var import_node_fs3 = require("fs");
-var path21 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var path22 = __toESM(require("path"), 1);
 var NativeRecursiveWatcher = class {
   constructor(root, onChange, options = {}) {
     this.root = root;
@@ -17191,26 +18196,26 @@ var NativeRecursiveWatcher = class {
   toAbsolutePath(filename) {
     if (filename == null) return null;
     const normalizedFilename = typeof filename === "string" ? filename : filename.toString();
-    const absolutePath = path21.resolve(this.root, normalizedFilename);
-    const relativePath = path21.relative(this.root, absolutePath);
-    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path21.sep}`) || path21.isAbsolute(relativePath);
+    const absolutePath = path22.resolve(this.root, normalizedFilename);
+    const relativePath = path22.relative(this.root, absolutePath);
+    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path22.sep}`) || path22.isAbsolute(relativePath);
     return outsideRoot ? null : absolutePath;
   }
-  defaultWatchFactory = (root, listener, options) => (0, import_node_fs3.watch)(root, options, listener);
+  defaultWatchFactory = (root, listener, options) => (0, import_node_fs4.watch)(root, options, listener);
 };
 
 // src/watcher/snapshot.ts
 var fsPromises4 = __toESM(require("fs/promises"), 1);
-var path22 = __toESM(require("path"), 1);
+var path23 = __toESM(require("path"), 1);
 async function buildFileSnapshotScan(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 });
@@ -17222,16 +18227,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()) {
@@ -17244,19 +18249,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,
@@ -17274,16 +18279,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()) {
@@ -17307,7 +18312,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 });
@@ -17317,12 +18322,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 {
@@ -17331,7 +18336,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;
@@ -17468,8 +18473,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;
   }
@@ -17500,7 +18505,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;
@@ -17508,10 +18513,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)) {
@@ -17602,13 +18607,13 @@ var FileWatcher = class {
   getExternalConfigWatchTargets() {
     return [...new Set(
       this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path23.relative(this.projectRoot, projectConfigPath);
+        const relativeConfigPath = path24.relative(this.projectRoot, projectConfigPath);
         return this.isOutsideProjectPath(relativeConfigPath);
       }).map((projectConfigPath) => {
         if ((0, import_fs14.existsSync)(projectConfigPath)) {
           return projectConfigPath;
         }
-        return this.getNearestExistingDirectory(path23.dirname(projectConfigPath));
+        return this.getNearestExistingDirectory(path24.dirname(projectConfigPath));
       })
     )];
   }
@@ -17670,7 +18675,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) {
@@ -17765,23 +18770,23 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path23.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path23.normalize(relativePath);
+    const relativePath = path24.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path24.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path23.normalize(relativePath);
+    const normalizedRelativePath = path24.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path23.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path24.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path23.sep}`) || path23.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path24.sep}`) || path24.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
     while (!(0, import_fs14.existsSync)(candidate)) {
-      const parent = path23.dirname(candidate);
+      const parent = path24.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -17789,7 +18794,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() {
@@ -17847,7 +18852,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 {
@@ -17893,7 +18898,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-var path24 = __toESM(require("path"), 1);
+var path25 = __toESM(require("path"), 1);
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -17915,13 +18920,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,
@@ -17989,7 +18994,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;
@@ -18009,7 +19016,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();
@@ -18785,7 +19794,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,
@@ -18794,25 +19803,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",
@@ -18973,7 +19982,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,
@@ -18982,7 +19991,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);
@@ -18991,12 +20000,12 @@ async function executeCodeCommunities(projectRoot, host, args) {
 
 // src/adapters/opencode/tools.ts
 var import_fs15 = require("fs");
-var os7 = __toESM(require("os"), 1);
-var path27 = __toESM(require("path"), 1);
+var os8 = __toESM(require("os"), 1);
+var path28 = __toESM(require("path"), 1);
 
 // src/tools/visualize/activity.ts
 var import_child_process5 = require("child_process");
-var path25 = __toESM(require("path"), 1);
+var path26 = __toESM(require("path"), 1);
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -19158,7 +20167,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);
 }
 
@@ -19416,7 +20425,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-var path26 = __toESM(require("path"), 1);
+var path27 = __toESM(require("path"), 1);
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -19676,7 +20685,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: ""
   }));
@@ -20005,7 +21014,7 @@ 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`);
+    const outputPath = path28.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
     (0, import_fs15.writeFileSync)(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
@@ -20118,7 +21127,7 @@ var MCP_TOOL_NAMES = [
 
 // src/commands/loader.ts
 var import_fs16 = require("fs");
-var path28 = __toESM(require("path"), 1);
+var path29 = __toESM(require("path"), 1);
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -20144,7 +21153,7 @@ function loadCommandsFromDirectory(commandsDir) {
   }
   const files = (0, import_fs16.readdirSync)(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 = (0, import_fs16.readFileSync)(filePath, "utf-8");
@@ -20153,7 +21162,7 @@ function loadCommandsFromDirectory(commandsDir) {
       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,
@@ -20489,42 +21498,13 @@ var RoutingHintController = class {
 
 // src/adapters/opencode.ts
 var import_meta2 = {};
-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_meta2 !== "undefined" && import_meta2.url) {
-    currentDir = path29.dirname((0, import_url.fileURLToPath)(import_meta2.url));
+    currentDir = path30.dirname((0, import_url.fileURLToPath)(import_meta2.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;
@@ -20550,8 +21530,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.`
@@ -20561,16 +21542,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: {