opencode-codebase-index 0.22.5 → 0.23.0

package/dist/index.js

@@ -328,7 +328,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path28, checkUnignored, mode) {
+      test(path30, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -337,7 +337,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path28);
+          const matched = rule[mode].test(path30);
           if (!matched) {
             return;
           }
@@ -358,17 +358,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path28, originalPath, doThrow) => {
-      if (!isString(path28)) {
+    var checkPath = (path30, originalPath, doThrow) => {
+      if (!isString(path30)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path28) {
+      if (!path30) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path28)) {
+      if (checkPath.isNotRelative(path30)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -377,7 +377,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path28) => REGEX_TEST_INVALID_PATH.test(path28);
+    var isNotRelative = (path30) => REGEX_TEST_INVALID_PATH.test(path30);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -407,19 +407,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path28 = originalPath && checkPath.convert(originalPath);
+        const path30 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path28,
+          path30,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path28, cache, checkUnignored, slices);
+        return this._t(path30, cache, checkUnignored, slices);
       }
-      checkIgnore(path28) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path28)) {
-          return this.test(path28);
+      checkIgnore(path30) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path30)) {
+          return this.test(path30);
         }
-        const slices = path28.split(SLASH2).filter(Boolean);
+        const slices = path30.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -432,18 +432,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path28, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path30, false, MODE_CHECK_IGNORE);
       }
-      _t(path28, cache, checkUnignored, slices) {
-        if (path28 in cache) {
-          return cache[path28];
+      _t(path30, cache, checkUnignored, slices) {
+        if (path30 in cache) {
+          return cache[path30];
         }
         if (!slices) {
-          slices = path28.split(SLASH2).filter(Boolean);
+          slices = path30.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path28] = this._rules.test(path28, checkUnignored, MODE_IGNORE);
+          return cache[path30] = this._rules.test(path30, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -451,29 +451,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path28] = parent.ignored ? parent : this._rules.test(path28, checkUnignored, MODE_IGNORE);
+        return cache[path30] = parent.ignored ? parent : this._rules.test(path30, checkUnignored, MODE_IGNORE);
       }
-      ignores(path28) {
-        return this._test(path28, this._ignoreCache, false).ignored;
+      ignores(path30) {
+        return this._test(path30, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path28) => !this.ignores(path28);
+        return (path30) => !this.ignores(path30);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path28) {
-        return this._test(path28, this._testCache, true);
+      test(path30) {
+        return this._test(path30, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path28) => checkPath(path28 && checkPath.convert(path28), path28, RETURN_FALSE);
+    var isPathValid = (path30) => checkPath(path30 && checkPath.convert(path30), path30, 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 = (path28) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path28) || isNotRelative(path28);
+      checkPath.isNotRelative = (path30) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path30) || isNotRelative(path30);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,7 +651,7 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/adapters/opencode.ts
-import * as path27 from "path";
+import * as path29 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -1129,11 +1129,11 @@ function resolveGitDir(repoRoot) {
     return null;
   }
   try {
-    const stat4 = statSync2(gitPath);
-    if (stat4.isDirectory()) {
+    const stat5 = statSync2(gitPath);
+    if (stat5.isDirectory()) {
       return gitPath;
     }
-    if (stat4.isFile()) {
+    if (stat5.isFile()) {
       const content = readFileSync2(gitPath, "utf-8").trim();
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
@@ -2202,7 +2202,7 @@ function analyzeQueryIntent(query) {
 }
 function isTestPath(filePath) {
   const normalized = normalizePath(filePath);
-  return /(?:^|\/)(?:test|tests|__tests__|spec|specs)(?:\/|$)/u.test(normalized) || /\.(?:test|spec)\.[^/]+$/u.test(normalized);
+  return /(?:^|\/)(?:test|tests|__tests__|spec|specs)(?:\/|$)/u.test(normalized) || /(?:\.(?:test|spec)|_(?:test|spec))\.[^/]+$/u.test(normalized) || /(?:^|\/)(?:test|spec)_[^/]+\.[^/]+$/u.test(normalized);
 }
 function isFixturePath(filePath) {
   const normalized = normalizePath(filePath);
@@ -2577,8 +2577,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path28 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path28}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path30 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path30}:${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));
@@ -3741,8 +3741,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     if (entry.isDirectory()) {
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
-      const stat4 = await fsPromises.stat(fullPath);
-      if (stat4.size > maxFileSize) {
+      const stat5 = await fsPromises.stat(fullPath);
+      if (stat5.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
@@ -3760,7 +3760,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         }
       }
       if (matched) {
-        filesInDir.push({ path: fullPath, size: stat4.size });
+        filesInDir.push({ path: fullPath, size: stat5.size });
       }
     }
   }
@@ -3817,8 +3817,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
     }
     for (const resolvedKbRoot of normalizedRoots) {
       try {
-        const stat4 = await fsPromises.stat(resolvedKbRoot);
-        if (!stat4.isDirectory()) {
+        const stat5 = await fsPromises.stat(resolvedKbRoot);
+        if (!stat5.isDirectory()) {
           skipped.push({ path: resolvedKbRoot, reason: "excluded" });
           continue;
         }
@@ -3852,7 +3852,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runCommand(file, args, options) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve17, reject) => {
     childProcess.execFile(
       file,
       args,
@@ -3862,7 +3862,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve15(stdout);
+        resolve17(stdout);
       }
     );
   });
@@ -4007,10 +4007,10 @@ function safeFailureMessage(error) {
 }
 function cancellableDelay(delayMs, signal) {
   if (signal.aborted) return Promise.reject(new AutoIndexCancelledError());
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve17, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve15();
+      resolve17();
     }, delayMs);
     timer.unref?.();
     const onAbort = () => {
@@ -4022,15 +4022,15 @@ function cancellableDelay(delayMs, signal) {
 }
 function withTimeout(promise, timeoutMs) {
   if (timeoutMs <= 0) return Promise.resolve(void 0);
-  return new Promise((resolve15) => {
-    const timer = setTimeout(() => resolve15(void 0), timeoutMs);
+  return new Promise((resolve17) => {
+    const timer = setTimeout(() => resolve17(void 0), timeoutMs);
     timer.unref?.();
     void promise.then((value) => {
       clearTimeout(timer);
-      resolve15(value);
+      resolve17(value);
     }, () => {
       clearTimeout(timer);
-      resolve15(void 0);
+      resolve17(void 0);
     });
   });
 }
@@ -4412,17 +4412,17 @@ var AutoIndexCoordinator = class {
     }
   }
   waitForBatteryRetry(delayMs) {
-    return new Promise((resolve15) => {
+    return new Promise((resolve17) => {
       const timer = setTimeout(() => {
         if (this.batteryRetryTimer === timer) {
           this.batteryRetryTimer = null;
           this.resolveBatteryRetry = null;
         }
-        resolve15();
+        resolve17();
       }, delayMs);
       timer.unref?.();
       this.batteryRetryTimer = timer;
-      this.resolveBatteryRetry = resolve15;
+      this.resolveBatteryRetry = resolve17;
     });
   }
   cancelBatteryRetry() {
@@ -4430,9 +4430,9 @@ var AutoIndexCoordinator = class {
       clearTimeout(this.batteryRetryTimer);
       this.batteryRetryTimer = null;
     }
-    const resolve15 = this.resolveBatteryRetry;
+    const resolve17 = this.resolveBatteryRetry;
     this.resolveBatteryRetry = null;
-    resolve15?.();
+    resolve17?.();
   }
   finishBatteryCheck(batteryCheck) {
     if (this.batteryCheck !== batteryCheck) return;
@@ -4637,7 +4637,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve15, reject) => {
+  const wrappedPromise = new Promise((resolve17, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -4651,7 +4651,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve15, reject);
+    promise.then(resolve17, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -4659,7 +4659,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve15(fallback());
+          resolve17(fallback());
         } catch (error) {
           reject(error);
         }
@@ -4669,7 +4669,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve15();
+        resolve17();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -5071,7 +5071,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve17, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -5111,7 +5111,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve15(result);
+          resolve17(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -5299,13 +5299,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve15) => {
+    return new Promise((resolve17) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve15();
+        resolve17();
       };
       this.on(event, listener);
     });
@@ -5591,7 +5591,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve15, reject) => {
+    await new Promise((resolve17, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -5599,7 +5599,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve15();
+        resolve17();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -6405,85 +6405,6 @@ function createEmbeddingProvider(configuredProviderInfo) {
   }
 }
 
-// src/rerank/index.ts
-function createReranker(config) {
-  if (!config.enabled) {
-    return new NoOpReranker();
-  }
-  return new SiliconFlowReranker(config);
-}
-var NoOpReranker = class {
-  isAvailable() {
-    return false;
-  }
-  async rerank(_query, documents, _topN) {
-    return {
-      results: documents.map((_, index) => ({ index, relevanceScore: 0 }))
-    };
-  }
-};
-var SiliconFlowReranker = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  isAvailable() {
-    return this.config.enabled && !!this.config.baseUrl && !!this.config.model;
-  }
-  async rerank(query, documents, topN) {
-    if (documents.length === 0) {
-      return { results: [] };
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    const baseUrl = this.config.baseUrl;
-    if (!baseUrl) {
-      throw new Error("Reranker baseUrl is required. Configure reranker.baseUrl in your codebase-index.json.");
-    }
-    const timeoutMs = this.config.timeoutMs ?? 3e4;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(`${baseUrl}/rerank`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          model: this.config.model,
-          query,
-          documents,
-          top_n: topN ?? this.config.topN ?? 20,
-          return_documents: false
-        }),
-        signal: controller.signal
-      });
-      clearTimeout(timeout);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Rerank API error: ${response.status} - ${errorText}`);
-      }
-      const data = await response.json();
-      return {
-        results: data.results.map((r) => ({
-          index: r.index,
-          relevanceScore: r.relevance_score,
-          document: r.document?.text
-        })),
-        tokensUsed: data.meta?.tokens?.input_tokens
-      };
-    } catch (error) {
-      clearTimeout(timeout);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Rerank API request timed out after ${timeoutMs}ms`);
-      }
-      throw error;
-    }
-  }
-};
-
 // src/utils/cost.ts
 function estimateChunksFromFiles(files) {
   let totalChunks = 0;
@@ -8043,8 +7964,8 @@ async function isWorktreeRegistered(projectRoot, worktreePath) {
   return false;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const relative12 = path15.relative(path15.resolve(rootPath), path15.resolve(filePath));
-  return relative12 === "" || !relative12.startsWith(`..${path15.sep}`) && relative12 !== ".." && !path15.isAbsolute(relative12);
+  const relative14 = path15.relative(path15.resolve(rootPath), path15.resolve(filePath));
+  return relative14 === "" || !relative14.startsWith(`..${path15.sep}`) && relative14 !== ".." && !path15.isAbsolute(relative14);
 }
 async function pruneExactMissingWorktreeRegistration(projectRoot, worktreePath) {
   if (await pathExists(worktreePath)) return false;
@@ -8421,11 +8342,11 @@ function normalizeFiles(rawFiles, projectRoot) {
   for (const raw of rawFiles) {
     if (raw.length === 0) continue;
     const absolute = path16.resolve(root, raw);
-    const relative12 = path16.relative(root, absolute);
-    if (path16.isAbsolute(raw) || relative12 === ".." || relative12.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative12)) {
+    const relative14 = path16.relative(root, absolute);
+    if (path16.isAbsolute(raw) || relative14 === ".." || relative14.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative14)) {
       throw new Error(`Changed file escapes the project root: ${JSON.stringify(raw)}`);
     }
-    const cleaned = relative12.startsWith(`.${path16.sep}`) ? relative12.slice(2) : relative12;
+    const cleaned = relative14.startsWith(`.${path16.sep}`) ? relative14.slice(2) : relative14;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -8657,7 +8578,8 @@ function rankHybridResults(query, semanticResults, keywordResults, options) {
       return cached;
     }
   }
-  const overfetchLimit = Math.max(options.limit * 4, options.limit);
+  const overfetchFactor = prioritizeSourcePaths ? 12 : 4;
+  const overfetchLimit = Math.max(options.limit * overfetchFactor, options.limit);
   const fused = options.fusionStrategy === "rrf" ? fuseResultsRrf(semanticResults, keywordResults, options.rrfK, overfetchLimit) : fuseResultsWeighted(semanticResults, keywordResults, options.hybridWeight, overfetchLimit);
   const rerankPoolLimit = Math.max(overfetchLimit, options.rerankTopN * 3, options.limit * 6);
   const rerankPool = fused.slice(0, rerankPoolLimit);
@@ -10168,7 +10090,6 @@ var Indexer = class _Indexer {
   database = null;
   provider = null;
   configuredProviderInfo = null;
-  reranker = null;
   fileHashCache = /* @__PURE__ */ new Map();
   fileHashCachePath = "";
   failedBatchesPath = "";
@@ -10328,7 +10249,6 @@ var Indexer = class _Indexer {
     this.database = null;
     this.provider = null;
     this.configuredProviderInfo = null;
-    this.reranker = null;
     this.indexCompatibility = null;
     this.initializationMode = "none";
     this.readIssues = [];
@@ -11058,7 +10978,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((resolve15) => setTimeout(resolve15, options.rateLimitState.backoffMs));
+          await new Promise((resolve17) => setTimeout(resolve17, options.rateLimitState.backoffMs));
         }
         try {
           const embeddingResult = await pRetry(
@@ -11625,15 +11545,6 @@ var Indexer = class _Indexer {
       rerankerEnabled: this.config.reranker?.enabled ?? false
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
-    if (this.config.reranker?.enabled) {
-      this.reranker = createReranker(this.config.reranker);
-      if (this.reranker.isAvailable()) {
-        this.logger.info("Reranker initialized", {
-          model: this.config.reranker.model,
-          baseUrl: this.config.reranker.baseUrl
-        });
-      }
-    }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
     const storePath = path19.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
@@ -13038,6 +12949,7 @@ var Indexer = class _Indexer {
     const filterByBranch = options?.filterByBranch ?? true;
     const sourceIntent = options?.definitionIntent === true || classifyQueryIntentRaw(query) === "source";
     const identifierHints = extractIdentifierHints(query);
+    const candidateLimit = maxResults * (sourceIntent ? 12 : 4);
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
@@ -13074,7 +12986,7 @@ var Indexer = class _Indexer {
     const semanticCandidates = embedding ? this.searchSemanticCandidates(
       store,
       embedding,
-      maxResults * 4,
+      candidateLimit,
       branchChunkIds,
       shouldPrefilterByBranch
     ) : [];
@@ -13082,7 +12994,7 @@ var Indexer = class _Indexer {
     const keywordStartTime = performance2.now();
     const keywordCandidates = await this.keywordSearch(
       query,
-      maxResults * 4,
+      candidateLimit,
       store,
       invertedIndex,
       branchChunkIds,
@@ -13840,9 +13752,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path28 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path28.length > 0 && (shortest.length === 0 || path28.length < shortest.length)) {
-        shortest = path28;
+      const path30 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path30.length > 0 && (shortest.length === 0 || path30.length < shortest.length)) {
+        shortest = path30;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13890,13 +13802,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path28 = [];
+      const path30 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path28.push({
+        path30.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -13906,9 +13818,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path28.reverse();
-      if (path28.length > 0 && (shortest.length === 0 || path28.length < shortest.length)) {
-        shortest = path28;
+      path30.reverse();
+      if (path30.length > 0 && (shortest.length === 0 || path30.length < shortest.length)) {
+        shortest = path30;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -14244,7 +14156,6 @@ var Indexer = class _Indexer {
     this.store = null;
     this.invertedIndex = null;
     this.provider = null;
-    this.reranker = null;
     this.configuredProviderInfo = null;
     this.indexCompatibility = null;
     this.initializationMode = "none";
@@ -14569,12 +14480,12 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth, fromFileP
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path28 = await indexer.findCallPathBySymbolIds(
+  const path30 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path28 };
+  return { from: fromResolution, to: toResolution, path: path30 };
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
@@ -14800,8 +14711,8 @@ function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
     }
   }
   try {
-    const stat4 = statSync5(normalizedPath2);
-    if (!stat4.isDirectory()) {
+    const stat5 = statSync5(normalizedPath2);
+    if (!stat5.isDirectory()) {
       return `Error: Path is not a directory: ${normalizedPath2}`;
     }
   } catch (error) {
@@ -14849,8 +14760,8 @@ function listKnowledgeBases(projectRoot, host) {
 `;
     if (exists) {
       try {
-        const stat4 = statSync5(resolvedPath);
-        result += `    Type: ${stat4.isDirectory() ? "Directory" : "File"}
+        const stat5 = statSync5(resolvedPath);
+        result += `    Type: ${stat5.isDirectory() ? "Directory" : "File"}
 `;
       } catch {
       }
@@ -14891,7 +14802,7 @@ Run /index to rebuild the index without the removed knowledge base.`;
 }
 
 // src/watcher/file-watcher.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync13, statSync as statSync6 } from "fs";
 
 // node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter2 } from "events";
@@ -14983,7 +14894,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path28) => statMethod(path28, { bigint: true });
+      this._stat = (path30) => statMethod(path30, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -15008,8 +14919,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path28, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
+          const { path: path30, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -15049,20 +14960,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path28, depth) {
+  async _exploreDir(path30, depth) {
     let files;
     try {
-      files = await readdir(path28, this._rdOptions);
+      files = await readdir(path30, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path28 };
+    return { files, depth, path: path30 };
   }
-  async _formatEntry(dirent, path28) {
+  async _formatEntry(dirent, path30) {
     let entry;
     const basename9 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path28, basename9));
+      const fullPath = presolve(pjoin(path30, basename9));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -15462,16 +15373,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path28, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path28);
-    emitRaw(rawEvent, evPath, { watchedPath: path28 });
-    if (evPath && path28 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path28, evPath), KEY_LISTENERS, sp.join(path28, evPath));
+    listener(path30);
+    emitRaw(rawEvent, evPath, { watchedPath: path30 });
+    if (evPath && path30 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path30, evPath), KEY_LISTENERS, sp.join(path30, evPath));
     }
   };
   try {
-    return fs_watch(path28, {
+    return fs_watch(path30, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -15487,12 +15398,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path28, fullPath, options, handlers) => {
+var setFsWatchListener = (path30, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path28, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -15503,7 +15414,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path28,
+      path30,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -15518,7 +15429,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path28, "r");
+          const fd = await open(path30, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -15549,7 +15460,7 @@ var setFsWatchListener = (path28, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path28, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -15571,7 +15482,7 @@ var setFsWatchFileListener = (path28, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path28, curr));
+          foreach(cont.listeners, (listener2) => listener2(path30, curr));
         }
       })
     };
@@ -15601,13 +15512,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path28, listener) {
+  _watchWithNodeFs(path30, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path28);
-    const basename9 = sp.basename(path28);
+    const directory = sp.dirname(path30);
+    const basename9 = sp.basename(path30);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename9);
-    const absolutePath = sp.resolve(path28);
+    const absolutePath = sp.resolve(path30);
     const options = {
       persistent: opts.persistent
     };
@@ -15617,12 +15528,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path28, absolutePath, options, {
+      closer = setFsWatchFileListener(path30, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path28, absolutePath, options, {
+      closer = setFsWatchListener(path30, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -15644,7 +15555,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename9))
       return;
-    const listener = async (path28, newStats) => {
+    const listener = async (path30, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -15658,11 +15569,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path28);
+            this.fsw._closeFile(path30);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path28, closer2);
+              this.fsw._addPathCloser(path30, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -15694,7 +15605,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, path28, item) {
+  async _handleSymlink(entry, directory, path30, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -15704,7 +15615,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path28);
+        linkPath = await fsrealpath(path30);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -15714,12 +15625,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, path28, entry.stats);
+          this.fsw._emit(EV.CHANGE, path30, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path28, entry.stats);
+        this.fsw._emit(EV.ADD, path30, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -15749,9 +15660,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path28 = sp.join(directory, item);
+      let path30 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -15760,11 +15671,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path28 = sp.join(dir, sp.relative(dir, path28));
-        this._addToNodeFs(path28, initialAdd, wh, depth + 1);
+        path30 = sp.join(dir, sp.relative(dir, path30));
+        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve17, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -15773,7 +15684,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve15(void 0);
+        resolve17(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -15830,13 +15741,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path28) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path28);
+    const wh = this.fsw._getWatchHelpers(path30);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -15852,8 +15763,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path28);
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const absPath = sp.resolve(path30);
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -15863,29 +15774,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path28) : path28;
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         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, path28, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path28), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path30), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path28, closer);
+        this.fsw._addPathCloser(path30, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path28;
+        return path30;
       }
     }
   }
@@ -15917,35 +15828,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative12 = sp2.relative(matcher.path, string);
-        if (!relative12) {
+        const relative14 = sp2.relative(matcher.path, string);
+        if (!relative14) {
           return false;
         }
-        return !relative12.startsWith("..") && !sp2.isAbsolute(relative12);
+        return !relative14.startsWith("..") && !sp2.isAbsolute(relative14);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath2(path28) {
-  if (typeof path28 !== "string")
+function normalizePath2(path30) {
+  if (typeof path30 !== "string")
     throw new Error("string expected");
-  path28 = sp2.normalize(path28);
-  path28 = path28.replace(/\\/g, "/");
+  path30 = sp2.normalize(path30);
+  path30 = path30.replace(/\\/g, "/");
   let prepend = false;
-  if (path28.startsWith("//"))
+  if (path30.startsWith("//"))
     prepend = true;
-  path28 = path28.replace(DOUBLE_SLASH_RE, "/");
+  path30 = path30.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path28 = "/" + path28;
-  return path28;
+    path30 = "/" + path30;
+  return path30;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path28 = normalizePath2(testString);
+  const path30 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path28, stats)) {
+    if (pattern(path30, stats)) {
       return true;
     }
   }
@@ -15983,19 +15894,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path28) => toUnix(sp2.normalize(toUnix(path28)));
-var normalizeIgnored = (cwd = "") => (path28) => {
-  if (typeof path28 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path28) ? path28 : sp2.join(cwd, path28));
+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));
   } else {
-    return path28;
+    return path30;
   }
 };
-var getAbsolutePath = (path28, cwd) => {
-  if (sp2.isAbsolute(path28)) {
-    return path28;
+var getAbsolutePath = (path30, cwd) => {
+  if (sp2.isAbsolute(path30)) {
+    return path30;
   }
-  return sp2.join(cwd, path28);
+  return sp2.join(cwd, path30);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -16060,10 +15971,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path28, follow, fsw) {
+  constructor(path30, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path28;
-    this.path = path28 = path28.replace(REPLACER_RE, "");
+    const watchPath = path30;
+    this.path = path30 = path30.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -16203,20 +16114,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path28) => {
-        const absPath = getAbsolutePath(path28, cwd);
+      paths = paths.map((path30) => {
+        const absPath = getAbsolutePath(path30, cwd);
         return absPath;
       });
     }
-    paths.forEach((path28) => {
-      this._removeIgnoredPath(path28);
+    paths.forEach((path30) => {
+      this._removeIgnoredPath(path30);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path28) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path30) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -16238,17 +16149,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path28) => {
-      if (!sp2.isAbsolute(path28) && !this._closers.has(path28)) {
+    paths.forEach((path30) => {
+      if (!sp2.isAbsolute(path30) && !this._closers.has(path30)) {
         if (cwd)
-          path28 = sp2.join(cwd, path28);
-        path28 = sp2.resolve(path28);
+          path30 = sp2.join(cwd, path30);
+        path30 = sp2.resolve(path30);
       }
-      this._closePath(path28);
-      this._addIgnoredPath(path28);
-      if (this._watched.has(path28)) {
+      this._closePath(path30);
+      this._addIgnoredPath(path30);
+      if (this._watched.has(path30)) {
         this._addIgnoredPath({
-          path: path28,
+          path: path30,
           recursive: true
         });
       }
@@ -16312,38 +16223,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path28, stats) {
+  async _emit(event, path30, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path28 = sp2.normalize(path28);
+      path30 = sp2.normalize(path30);
     if (opts.cwd)
-      path28 = sp2.relative(opts.cwd, path28);
-    const args = [path28];
+      path30 = sp2.relative(opts.cwd, path30);
+    const args = [path30];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path28))) {
+    if (awf && (pw = this._pendingWrites.get(path30))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path28, [event, ...args]);
+        this._pendingUnlinks.set(path30, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path29) => {
+          this._pendingUnlinks.forEach((entry, path31) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path29);
+            this._pendingUnlinks.delete(path31);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path28);
+        this._pendingUnlinks.delete(path30);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -16361,16 +16272,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 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, path28) : path28;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path30) : path30;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -16401,23 +16312,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path28, timeout) {
+  _throttle(actionType, path30, 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(path28);
+    const actionPath = action.get(path30);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path28);
+      const item = action.get(path30);
       const count = item ? item.count : 0;
-      action.delete(path28);
+      action.delete(path30);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -16425,7 +16336,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path28, thr);
+    action.set(path30, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -16439,44 +16350,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path28, threshold, event, awfEmit) {
+  _awaitWriteFinish(path30, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path28;
-    if (this.options.cwd && !sp2.isAbsolute(path28)) {
-      fullPath = sp2.join(this.options.cwd, path28);
+    let fullPath = path30;
+    if (this.options.cwd && !sp2.isAbsolute(path30)) {
+      fullPath = sp2.join(this.options.cwd, path30);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path28)) {
+        if (err || !writes.has(path30)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path28).lastChange = now3;
+          writes.get(path30).lastChange = now3;
         }
-        const pw = writes.get(path28);
+        const pw = writes.get(path30);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path28);
+          writes.delete(path30);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path28)) {
-      writes.set(path28, {
+    if (!writes.has(path30)) {
+      writes.set(path30, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path28);
+          writes.delete(path30);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -16487,8 +16398,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path28, stats) {
-    if (this.options.atomic && DOT_RE.test(path28))
+  _isIgnored(path30, stats) {
+    if (this.options.atomic && DOT_RE.test(path30))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -16498,17 +16409,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path28, stats);
+    return this._userIgnored(path30, stats);
   }
-  _isntIgnored(path28, stat4) {
-    return !this._isIgnored(path28, stat4);
+  _isntIgnored(path30, stat5) {
+    return !this._isIgnored(path30, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path28) {
-    return new WatchHelper(path28, this.options.followSymlinks, this);
+  _getWatchHelpers(path30) {
+    return new WatchHelper(path30, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -16540,63 +16451,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path28 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path28);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path28, 100))
+    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))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path28);
+    const wp = this._getWatchedDir(path30);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path28, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path30, 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 = path28;
+    let relPath = path30;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path28);
+      relPath = sp2.relative(this.options.cwd, path30);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path28);
+    this._watched.delete(path30);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path28))
-      this._emit(eventName, path28);
-    this._closePath(path28);
+    if (wasTracked && !this._isIgnored(path30))
+      this._emit(eventName, path30);
+    this._closePath(path30);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path28) {
-    this._closeFile(path28);
-    const dir = sp2.dirname(path28);
-    this._getWatchedDir(dir).remove(sp2.basename(path28));
+  _closePath(path30) {
+    this._closeFile(path30);
+    const dir = sp2.dirname(path30);
+    this._getWatchedDir(dir).remove(sp2.basename(path30));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path28) {
-    const closers = this._closers.get(path28);
+  _closeFile(path30) {
+    const closers = this._closers.get(path30);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path28);
+    this._closers.delete(path30);
   }
-  _addPathCloser(path28, closer) {
+  _addPathCloser(path30, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path28);
+    let list = this._closers.get(path30);
     if (!list) {
       list = [];
-      this._closers.set(path28, list);
+      this._closers.set(path30, list);
     }
     list.push(closer);
   }
@@ -16626,12 +16537,291 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
+import * as path23 from "path";
+
+// src/watcher/native-recursive-watcher.ts
+import { watch as watch2 } from "fs";
 import * as path21 from "path";
+var NativeRecursiveWatcher = class {
+  constructor(root, onChange, options = {}) {
+    this.root = root;
+    this.onChange = onChange;
+    this.watchFactory = options.watchFactory ?? this.defaultWatchFactory;
+    this.onError = options.onError;
+  }
+  root;
+  onChange;
+  watcher = null;
+  listenerToken = 0;
+  watchFactory;
+  onError;
+  start() {
+    if (this.watcher) return;
+    const token = ++this.listenerToken;
+    const listener = (_eventType, filename) => {
+      if (this.watcher === null || this.listenerToken !== token) return;
+      const absolutePath = this.toAbsolutePath(filename);
+      const nextResult = this.onChange(absolutePath);
+      if (nextResult instanceof Promise) {
+        void nextResult.catch((error) => {
+          console.error("[codebase-index] Error handling native watcher event:", error);
+        });
+      }
+    };
+    const watcher = this.watchFactory(this.root, listener, {
+      persistent: true,
+      recursive: true
+    });
+    watcher.on?.("error", (error) => {
+      if (this.watcher === watcher && this.listenerToken === token) {
+        this.onError?.(error);
+      }
+    });
+    this.watcher = watcher;
+  }
+  async stop() {
+    const watcher = this.watcher;
+    this.watcher = null;
+    this.listenerToken += 1;
+    if (!watcher) return;
+    await watcher.close();
+  }
+  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);
+    return outsideRoot ? null : absolutePath;
+  }
+  defaultWatchFactory = (root, listener, options) => watch2(root, options, listener);
+};
+
+// src/watcher/snapshot.ts
+import * as fsPromises4 from "fs/promises";
+import * as path22 from "path";
+async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
+  const normalizedProjectRoot = path22.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);
+    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 });
+  };
+  const walk = async (directoryPath, depth) => {
+    let entries;
+    try {
+      entries = await fsPromises4.readdir(directoryPath, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingFsError(error)) return;
+      if (isPermissionFsError(error)) {
+        unreadablePrefixes.add(path22.resolve(directoryPath));
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const fullPath = path22.join(directoryPath, entry.name);
+      const relativePath = path22.relative(normalizedProjectRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (hasFilteredPathSegment(relativePath, path22.sep) || isRestrictedDirectory(relativePath, path22.sep)) continue;
+        if (ignoreFilter.ignores(relativePath)) continue;
+        if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        await includeFile(fullPath);
+      }
+    }
+  };
+  await walk(normalizedProjectRoot, 0);
+  await includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths);
+  return { entries: snapshot, unreadablePrefixes };
+}
+async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, targetPath) {
+  const normalizedProjectRoot = path22.resolve(projectRoot);
+  const normalizedTargetPath = path22.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 snapshot = /* @__PURE__ */ new Map();
+  const unreadablePrefixes = /* @__PURE__ */ new Set();
+  const includeFile = async (filePath) => {
+    const normalizedPath2 = path22.resolve(filePath);
+    if (!explicitConfigPaths.has(normalizedPath2) && !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 });
+  };
+  const walk = async (directoryPath, depth) => {
+    let entries;
+    try {
+      entries = await fsPromises4.readdir(directoryPath, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingFsError(error)) return;
+      if (isPermissionFsError(error)) {
+        unreadablePrefixes.add(path22.resolve(directoryPath));
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      const fullPath = path22.join(directoryPath, entry.name);
+      const relativePath = path22.relative(normalizedProjectRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (hasFilteredPathSegment(relativePath, path22.sep) || isRestrictedDirectory(relativePath, path22.sep)) continue;
+        if (ignoreFilter.ignores(relativePath)) continue;
+        if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        await includeFile(fullPath);
+      }
+    }
+  };
+  const targetStat = await readStatIfFile(normalizedTargetPath, unreadablePrefixes);
+  if (targetStat) await includeFile(normalizedTargetPath);
+  else await walk(normalizedTargetPath, 0);
+  await includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, configPaths, normalizedTargetPath);
+  return { entries: snapshot, unreadablePrefixes };
+}
+function completeFileSnapshot(previous, scan) {
+  const completed = new Map(scan.entries);
+  for (const unreadablePrefix of scan.unreadablePrefixes) {
+    for (const [entryPath, entry] of previous) {
+      if (isWithinPath(unreadablePrefix, entryPath) && !completed.has(entryPath)) completed.set(entryPath, entry);
+    }
+  }
+  return completed;
+}
+async function includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths) {
+  for (const configPath of [...new Set(configPaths.map((value) => path22.resolve(value)))]) {
+    if (snapshot.has(configPath)) continue;
+    const stat5 = await readStatIfFile(configPath, unreadablePrefixes);
+    if (stat5) snapshot.set(configPath, { size: stat5.size, mtimeMs: stat5.mtimeMs });
+  }
+}
+async function includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, configPaths, targetPath) {
+  await includeExplicitConfigPaths(
+    snapshot,
+    unreadablePrefixes,
+    configPaths.filter((configPath) => isWithinPath(targetPath, path22.resolve(configPath)))
+  );
+}
+function isWithinPath(parentPath, childPath) {
+  const relativePath = path22.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path22.sep}`) && relativePath !== ".." && !path22.isAbsolute(relativePath);
+}
+async function readStatIfFile(filePath, unreadablePrefixes) {
+  try {
+    const stat5 = await fsPromises4.stat(filePath);
+    return stat5.isFile() ? stat5 : null;
+  } catch (error) {
+    if (isMissingFsError(error)) return null;
+    if (isPermissionFsError(error)) {
+      unreadablePrefixes.add(path22.resolve(filePath));
+      return null;
+    }
+    throw error;
+  }
+}
+function isMissingFsError(error) {
+  return error instanceof Error && ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+}
+function isPermissionFsError(error) {
+  return error instanceof Error && ["EACCES", "EPERM"].includes(error.code ?? "");
+}
+var diffTypeOrder = { add: 0, change: 1, unlink: 2 };
+function diffFileSnapshots(previous, current, forcedChanges = /* @__PURE__ */ new Set()) {
+  const changes = [];
+  for (const [filePath, previousEntry] of previous) {
+    const currentEntry = current.get(filePath);
+    if (!currentEntry) changes.push({ type: "unlink", path: filePath });
+    else if (forcedChanges.has(filePath) || currentEntry.size !== previousEntry.size || currentEntry.mtimeMs !== previousEntry.mtimeMs) {
+      changes.push({ type: "change", path: filePath });
+    }
+  }
+  for (const [filePath] of current) {
+    if (!previous.has(filePath)) changes.push({ type: "add", path: filePath });
+  }
+  return changes.sort((left, right) => left.path.localeCompare(right.path) || diffTypeOrder[left.type] - diffTypeOrder[right.type]);
+}
+
+// src/watcher/snapshot-reconciler.ts
+var FileSnapshotReconciler = class {
+  constructor(projectRoot, config, configPaths) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.configPaths = configPaths;
+  }
+  projectRoot;
+  config;
+  configPaths;
+  snapshot = null;
+  reconciliationTail = Promise.resolve();
+  async initialize() {
+    this.snapshot = (await buildFileSnapshotScan(this.projectRoot, this.config, this.configPaths)).entries;
+  }
+  async reconcile(invalidations = []) {
+    if (this.snapshot === null) {
+      throw new Error("FileSnapshotReconciler is not initialized. Call initialize() before reconcile().");
+    }
+    const reconciliation = this.reconciliationTail.then(async () => {
+      const previousSnapshot = this.snapshot;
+      if (previousSnapshot === null) {
+        throw new Error("FileSnapshotReconciler is not initialized. Call initialize() before reconcile().");
+      }
+      const normalizedInvalidations = invalidations.map((invalidation) => typeof invalidation === "string" || invalidation === null ? { path: invalidation, forceChange: false } : { path: invalidation.path, forceChange: invalidation.forceChange === true });
+      const scopedPaths = normalizedInvalidations.map((invalidation) => invalidation.path).filter((filePath) => filePath !== null);
+      const scan = scopedPaths.length === 0 || scopedPaths.length !== normalizedInvalidations.length ? await buildFileSnapshotScan(this.projectRoot, this.config, this.configPaths) : await this.reconcilePaths(previousSnapshot, scopedPaths);
+      const nextSnapshot = completeFileSnapshot(previousSnapshot, scan);
+      const forcedChanges = new Set(normalizedInvalidations.filter((invalidation) => invalidation.path !== null && invalidation.forceChange).map((invalidation) => invalidation.path));
+      const changes = diffFileSnapshots(previousSnapshot, nextSnapshot, forcedChanges);
+      this.snapshot = nextSnapshot;
+      return changes;
+    });
+    this.reconciliationTail = reconciliation.then(() => void 0, () => void 0);
+    return reconciliation;
+  }
+  async reconcilePaths(previousSnapshot, invalidatedPaths) {
+    const scopes = this.getScopes(invalidatedPaths);
+    const entries = new Map(previousSnapshot);
+    const unreadablePrefixes = /* @__PURE__ */ new Set();
+    for (const scope of scopes) {
+      for (const previousPath of entries.keys()) {
+        if (isWithinPath(scope, previousPath)) entries.delete(previousPath);
+      }
+      const scopedScan = await buildFileSnapshotForPathScan(this.projectRoot, this.config, this.configPaths, scope);
+      for (const [filePath, entry] of scopedScan.entries) entries.set(filePath, entry);
+      for (const unreadablePrefix of scopedScan.unreadablePrefixes) unreadablePrefixes.add(unreadablePrefix);
+    }
+    return { entries, unreadablePrefixes };
+  }
+  getScopes(invalidatedPaths) {
+    const uniquePaths = [...new Set(invalidatedPaths)].sort((left, right) => left.length - right.length);
+    return uniquePaths.filter((candidate, index) => !uniquePaths.slice(0, index).some(
+      (ancestor) => isWithinPath(ancestor, candidate)
+    ));
+  }
+};
+
+// src/watcher/file-watcher.ts
 var FileWatcher = class {
   watcher = null;
   projectRoot;
   config;
   configPath;
+  backend;
   projectConfigPaths;
   pendingChanges = /* @__PURE__ */ new Map();
   debounceTimer = null;
@@ -16641,44 +16831,74 @@ var FileWatcher = class {
   resolveReady = null;
   pollingFallbackAttempted = false;
   pendingClose = null;
+  startupReadySignals = 1;
+  nativeWatcher = null;
+  nativeReconciler = null;
+  nativeSetupGeneration = 0;
+  nativeStarting = false;
+  nativeInitializing = false;
+  nativeReconcileTimer = null;
+  nativeInvalidatedPaths = /* @__PURE__ */ new Map();
+  configPathStates = /* @__PURE__ */ new Map();
   constructor(projectRoot, config, host, options = {}) {
     this.projectRoot = projectRoot;
     this.config = config;
+    this.backend = options.backend ?? "auto";
     this.configPath = options.configPath;
     this.projectConfigPaths = options.configPath ? [options.configPath] : getProjectConfigCandidatePaths(projectRoot, host);
   }
   start(handler) {
-    if (this.watcher) {
+    if (this.watcher || this.nativeWatcher || this.nativeStarting) {
       return;
     }
     this.onChanges = handler;
     this.pollingFallbackAttempted = false;
     this.resetReady();
+    if (this.shouldUseNativeWatcher()) {
+      if (this.hasExternalConfigWatchTarget()) {
+        this.setStartupReadySignals(2);
+        this.startExternalConfigWatcher();
+      }
+      this.nativeStarting = true;
+      void this.createNativeWatcher();
+      return;
+    }
     this.createWatcher();
   }
   resetReady() {
-    this.readyPromise = new Promise((resolve15) => {
-      this.resolveReady = resolve15;
+    this.readyPromise = new Promise((resolve17) => {
+      this.resolveReady = resolve17;
     });
+    this.startupReadySignals = 1;
   }
-  createWatcher(usePolling = false) {
-    const ignoreFilter = createIgnoreFilter(this.projectRoot);
-    let watchTargets = this.projectRoot;
-    if (this.configPath) {
-      watchTargets = [this.projectRoot, this.configPath];
-    } else {
-      const externalConfigTargets = this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path21.relative(this.projectRoot, projectConfigPath);
-        return this.isOutsideProjectPath(relativeConfigPath);
-      }).map((projectConfigPath) => existsSync13(projectConfigPath) ? projectConfigPath : this.getNearestExistingDirectory(path21.dirname(projectConfigPath)));
-      const uniqueExternalConfigTargets = [...new Set(externalConfigTargets)];
-      if (uniqueExternalConfigTargets.length > 0) {
-        watchTargets = [this.projectRoot, ...uniqueExternalConfigTargets];
-      }
+  setStartupReadySignals(expectedSignals) {
+    if (!this.readyPromise) {
+      return;
+    }
+    this.startupReadySignals = Math.max(0, expectedSignals);
+  }
+  reportStartupReadySignal() {
+    if (!this.readyPromise || !this.resolveReady) {
+      return;
     }
+    if (this.startupReadySignals <= 0) {
+      return;
+    }
+    this.startupReadySignals -= 1;
+    if (this.startupReadySignals !== 0) {
+      return;
+    }
+    this.resolveReady();
+    this.resolveReady = null;
+  }
+  createWatcher(watchTargets, usePolling = false, reportsStartupReady = true) {
+    let reportedStartupReady = false;
+    this.configPathStates = this.getConfigPathStates();
+    const ignoreFilter = createIgnoreFilter(this.projectRoot);
+    const resolvedWatchTargets = watchTargets ?? this.getFullChokidarWatchTargets();
     const watcherOptions = {
       ignored: (filePath) => {
-        const relativePath = path21.relative(this.projectRoot, filePath);
+        const relativePath = path23.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
@@ -16686,10 +16906,10 @@ var FileWatcher = class {
         if (this.isOutsideProjectPath(relativePath)) {
           return true;
         }
-        if (hasFilteredPathSegment(relativePath, path21.sep)) {
+        if (hasFilteredPathSegment(relativePath, path23.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path21.sep)) {
+        if (isRestrictedDirectory(relativePath, path23.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -16722,10 +16942,13 @@ var FileWatcher = class {
       watcher = new FSWatcher(watcherOptions);
     }
     this.watcher = watcher;
-    watcher.once("ready", () => {
+    watcher.on("ready", () => {
       if (this.watcher !== watcher) return;
-      this.resolveReady?.();
-      this.resolveReady = null;
+      this.reconcileConfigPathStates();
+      if (reportsStartupReady) {
+        this.reportStartupReadySignal();
+        reportedStartupReady = true;
+      }
     });
     watcher.on("error", (error) => {
       const err = error instanceof Error ? error : null;
@@ -16739,10 +16962,13 @@ var FileWatcher = class {
           console.error("[codebase-index] Failed to close exhausted file watcher:", closeError);
         });
         if (this.onChanges) {
+          const replacementReportsStartupReady = reportsStartupReady || reportedStartupReady;
           if (!this.resolveReady) {
             this.resetReady();
+          } else if (reportedStartupReady) {
+            this.startupReadySignals += 1;
           }
-          this.createWatcher(true);
+          this.createWatcher(resolvedWatchTargets, true, replacementReportsStartupReady);
         } else {
           this.watcher = null;
         }
@@ -16753,13 +16979,166 @@ var FileWatcher = class {
     watcher.on("add", (filePath) => this.handleChange(watcher, "add", filePath));
     watcher.on("change", (filePath) => this.handleChange(watcher, "change", filePath));
     watcher.on("unlink", (filePath) => this.handleChange(watcher, "unlink", filePath));
-    watcher.add(watchTargets);
+    watcher.add(resolvedWatchTargets);
+  }
+  shouldUseNativeWatcher() {
+    if (this.backend === "chokidar") {
+      return false;
+    }
+    return true;
+  }
+  getFullChokidarWatchTargets() {
+    if (this.configPath) {
+      return [this.projectRoot, this.configPath];
+    }
+    const externalConfigTargets = this.getExternalConfigWatchTargets();
+    if (externalConfigTargets.length === 0) {
+      return this.projectRoot;
+    }
+    return [this.projectRoot, ...externalConfigTargets];
+  }
+  getExternalConfigWatchTargets() {
+    return [...new Set(
+      this.projectConfigPaths.filter((projectConfigPath) => {
+        const relativeConfigPath = path23.relative(this.projectRoot, projectConfigPath);
+        return this.isOutsideProjectPath(relativeConfigPath);
+      }).map((projectConfigPath) => {
+        if (existsSync13(projectConfigPath)) {
+          return projectConfigPath;
+        }
+        return this.getNearestExistingDirectory(path23.dirname(projectConfigPath));
+      })
+    )];
+  }
+  hasExternalConfigWatchTarget() {
+    return this.getExternalConfigWatchTargets().length > 0;
+  }
+  startExternalConfigWatcher(usePolling = false) {
+    const externalTargets = this.getExternalConfigWatchTargets();
+    if (externalTargets.length === 0) {
+      return;
+    }
+    this.createWatcher(externalTargets, usePolling);
+  }
+  async createNativeWatcher() {
+    const generation = ++this.nativeSetupGeneration;
+    const reconciler = new FileSnapshotReconciler(this.projectRoot, this.config, this.projectConfigPaths);
+    const watcher = new NativeRecursiveWatcher(
+      this.projectRoot,
+      (filePath) => this.scheduleNativeReconciliation(generation, filePath),
+      { onError: (error) => void this.fallbackFromNativeWatcher(generation, error) }
+    );
+    this.nativeReconciler = reconciler;
+    this.nativeWatcher = watcher;
+    this.nativeInitializing = true;
+    try {
+      watcher.start();
+      if (!this.isCurrentNativeSetup(generation)) {
+        await watcher.stop();
+        return;
+      }
+      await reconciler.initialize();
+      if (!this.isCurrentNativeSetup(generation) || this.nativeWatcher !== watcher) {
+        await watcher.stop();
+        return;
+      }
+      this.nativeStarting = false;
+      this.nativeInitializing = false;
+      await this.reconcileNativeWatcherWithPendingInvalidations(generation);
+      this.reportStartupReadySignal();
+    } catch (error) {
+      if (!this.isCurrentNativeSetup(generation)) return;
+      this.nativeInitializing = false;
+      if (this.nativeWatcher) {
+        await this.fallbackFromNativeWatcher(generation, error);
+        return;
+      }
+      this.nativeStarting = false;
+      const externalWatcher = this.watcher;
+      this.watcher = null;
+      this.nativeReconciler = null;
+      await externalWatcher?.close();
+      console.warn("[codebase-index] Native recursive watcher unavailable; using Chokidar fallback.", error);
+      this.setStartupReadySignals(1);
+      this.createWatcher();
+    }
+  }
+  isCurrentNativeSetup(generation) {
+    return this.nativeSetupGeneration === generation && this.onChanges !== null;
+  }
+  scheduleNativeReconciliation(generation, filePath) {
+    if (!this.isCurrentNativeSetup(generation)) return;
+    const requiresFullReconciliation = filePath === path23.join(this.projectRoot, ".gitignore");
+    const invalidatedPath = requiresFullReconciliation ? null : filePath;
+    this.nativeInvalidatedPaths.set(invalidatedPath, invalidatedPath !== null);
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+    }
+    this.nativeReconcileTimer = setTimeout(() => {
+      this.nativeReconcileTimer = null;
+      void this.reconcileNativeWatcherFromQueue(generation);
+    }, 100);
+  }
+  reconcileNativeWatcherFromQueue(generation) {
+    if (!this.isCurrentNativeSetup(generation) || this.nativeInitializing) return;
+    const invalidatedPaths = this.popNativeInvalidations();
+    if (invalidatedPaths.length === 0) return;
+    void this.reconcileNativeWatcher(generation, invalidatedPaths);
+  }
+  async reconcileNativeWatcher(generation, invalidatedPaths) {
+    if (!this.isCurrentNativeSetup(generation) || !this.nativeReconciler) return;
+    try {
+      const reconciler = this.nativeReconciler;
+      const changes = await reconciler.reconcile(invalidatedPaths);
+      if (!this.isCurrentNativeSetup(generation) || this.nativeReconciler !== reconciler) return;
+      this.recordChanges(changes);
+    } catch (error) {
+      await this.fallbackFromNativeWatcher(generation, error);
+    }
+  }
+  async reconcileNativeWatcherWithPendingInvalidations(generation) {
+    const invalidatedPaths = this.popNativeInvalidations();
+    if (invalidatedPaths.length === 0) return;
+    await this.reconcileNativeWatcher(generation, invalidatedPaths);
+  }
+  popNativeInvalidations() {
+    if (this.nativeInvalidatedPaths.size === 0) return [];
+    const invalidations = [...this.nativeInvalidatedPaths].map(([invalidatedPath, forceChange]) => ({
+      path: invalidatedPath,
+      forceChange
+    }));
+    this.nativeInvalidatedPaths.clear();
+    return invalidations;
+  }
+  async fallbackFromNativeWatcher(generation, error) {
+    if (!this.isCurrentNativeSetup(generation)) return;
+    const watcher = this.nativeWatcher;
+    const externalWatcher = this.watcher;
+    this.nativeWatcher = null;
+    this.watcher = null;
+    this.nativeReconciler = null;
+    this.nativeStarting = false;
+    this.nativeInitializing = false;
+    this.nativeSetupGeneration += 1;
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+      this.nativeReconcileTimer = null;
+    }
+    this.nativeInvalidatedPaths.clear();
+    this.setStartupReadySignals(1);
+    console.warn("[codebase-index] Native recursive watcher failed; using Chokidar fallback.", error);
+    await watcher?.stop();
+    await externalWatcher?.close();
+    if (this.onChanges) {
+      this.createWatcher();
+    }
   }
   handleChange(watcher, type, filePath) {
     if (this.watcher !== watcher) {
       return;
     }
     if (this.isProjectConfigPath(filePath)) {
+      this.updateConfigPathState(filePath);
       this.pendingChanges.set(filePath, type);
       this.scheduleFlush();
       return;
@@ -16774,27 +17153,33 @@ var FileWatcher = class {
     )) {
       return;
     }
-    this.pendingChanges.set(filePath, type);
+    this.recordChanges([{ path: filePath, type }]);
+  }
+  recordChanges(changes) {
+    if (changes.length === 0) return;
+    for (const change of changes) {
+      this.pendingChanges.set(change.path, change.type);
+    }
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path21.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path21.normalize(relativePath);
+    const relativePath = path23.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path23.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path21.normalize(relativePath);
+    const normalizedRelativePath = path23.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path21.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path23.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path21.sep}`) || path21.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path23.sep}`) || path23.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
     while (!existsSync13(candidate)) {
-      const parent = path21.dirname(candidate);
+      const parent = path23.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -16802,9 +17187,51 @@ var FileWatcher = class {
   }
   getProjectConfigRelativePaths() {
     return this.projectConfigPaths.map(
-      (configPath) => path21.normalize(path21.relative(this.projectRoot, configPath))
+      (configPath) => path23.normalize(path23.relative(this.projectRoot, configPath))
     );
   }
+  getConfigPathStates() {
+    const states = /* @__PURE__ */ new Map();
+    for (const configPath of this.projectConfigPaths) {
+      const state = this.getConfigPathState(configPath);
+      if (state) states.set(configPath, state);
+    }
+    return states;
+  }
+  getConfigPathState(configPath) {
+    try {
+      const stats = statSync6(configPath);
+      return stats.isFile() ? { mtimeMs: stats.mtimeMs, size: stats.size } : void 0;
+    } catch (error) {
+      void error;
+      return void 0;
+    }
+  }
+  updateConfigPathState(configPath) {
+    const state = this.getConfigPathState(configPath);
+    if (state) {
+      this.configPathStates.set(configPath, state);
+    } else {
+      this.configPathStates.delete(configPath);
+    }
+  }
+  reconcileConfigPathStates() {
+    const nextStates = this.getConfigPathStates();
+    const changes = [];
+    for (const configPath of this.projectConfigPaths) {
+      const previous = this.configPathStates.get(configPath);
+      const next = nextStates.get(configPath);
+      if (!previous && next) {
+        changes.push({ path: configPath, type: "add" });
+      } else if (previous && !next) {
+        changes.push({ path: configPath, type: "unlink" });
+      } else if (previous && next && (previous.size !== next.size || previous.mtimeMs !== next.mtimeMs)) {
+        changes.push({ path: configPath, type: "change" });
+      }
+    }
+    this.configPathStates = nextStates;
+    this.recordChanges(changes);
+  }
   scheduleFlush() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -16818,7 +17245,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path28, type]) => ({ path: path28, type })
+      ([path30, type]) => ({ path: path30, type })
     );
     this.pendingChanges.clear();
     try {
@@ -16832,20 +17259,31 @@ var FileWatcher = class {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
+    if (this.nativeReconcileTimer) {
+      clearTimeout(this.nativeReconcileTimer);
+      this.nativeReconcileTimer = null;
+    }
+    this.nativeInvalidatedPaths.clear();
     const watcher = this.watcher;
+    const nativeWatcher = this.nativeWatcher;
     const pendingClose = this.pendingClose;
     const resolveReady = this.resolveReady;
     this.watcher = null;
+    this.nativeWatcher = null;
+    this.nativeReconciler = null;
+    this.nativeStarting = false;
+    this.nativeInitializing = false;
+    this.nativeSetupGeneration += 1;
     this.pendingClose = null;
     this.resolveReady = null;
     this.readyPromise = null;
     this.pendingChanges.clear();
     this.onChanges = null;
-    await Promise.all([watcher?.close(), pendingClose]);
+    await Promise.all([watcher?.close(), nativeWatcher?.stop(), pendingClose]);
     resolveReady?.();
   }
   isRunning() {
-    return this.watcher !== null;
+    return this.watcher !== null || this.nativeWatcher !== null || this.nativeStarting;
   }
   async waitUntilReady() {
     await (this.readyPromise ?? Promise.resolve());
@@ -16853,7 +17291,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-import * as path22 from "path";
+import * as path24 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -16875,13 +17313,13 @@ var GitHeadWatcher = class {
       this.readyPromise = Promise.resolve();
       return;
     }
-    this.readyPromise = new Promise((resolve15) => {
-      this.resolveReady = resolve15;
+    this.readyPromise = new Promise((resolve17) => {
+      this.resolveReady = resolve17;
     });
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path22.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path24.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -17737,7 +18175,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path28 = await getCallGraphPath(
+    const path30 = await getCallGraphPath(
       projectRoot,
       host,
       from,
@@ -17746,25 +18184,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path28);
-    if (path28.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path30);
+    if (path30.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path28.path.length)
+        details: fittedDetails("path", fitted2, path30.path.length)
       };
     }
-    if (path28.from.status !== "resolved" || path28.to.status !== "resolved") {
+    if (path30.from.status !== "resolved" || path30.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path28.from;
+    const resolvedFrom = path30.from;
     const { callers } = await getCallGraphData(projectRoot, host, {
       name: to,
       direction: "callers",
@@ -17923,7 +18361,7 @@ async function executeCallGraph(projectRoot, host, args) {
   return { text: formatCallGraphResult(await getCallGraphData(projectRoot, host, args)) };
 }
 async function executeCallGraphPath(projectRoot, host, args) {
-  const path28 = await getCallGraphPath(
+  const path30 = await getCallGraphPath(
     projectRoot,
     host,
     args.from,
@@ -17932,7 +18370,7 @@ async function executeCallGraphPath(projectRoot, host, args) {
     args.fromFilePath,
     args.toFilePath
   );
-  return { text: formatCallGraphPathResult(path28) };
+  return { text: formatCallGraphPathResult(path30) };
 }
 async function executeCodeCommunities(projectRoot, host, args) {
   const result = await getCodeCommunities(projectRoot, host, args);
@@ -17942,11 +18380,11 @@ async function executeCodeCommunities(projectRoot, host, args) {
 // src/adapters/opencode/tools.ts
 import { writeFileSync as writeFileSync4 } from "fs";
 import * as os7 from "os";
-import * as path25 from "path";
+import * as path27 from "path";
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path23 from "path";
+import * as path25 from "path";
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -18108,7 +18546,7 @@ function normalizePath3(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path23.isAbsolute(filePath) ? path23.relative(projectRoot, filePath) : filePath;
+  const relativePath = path25.isAbsolute(filePath) ? path25.relative(projectRoot, filePath) : filePath;
   return normalizePath3(relativePath);
 }
 
@@ -18366,7 +18804,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-import * as path24 from "path";
+import * as path26 from "path";
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -18499,8 +18937,8 @@ function compactModules(prefixToNodes) {
 function deriveModules(nodes) {
   const initial = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const relative12 = stripToProjectRelative(node.filePath);
-    const prefix = modulePrefixFromRelativePath(relative12);
+    const relative14 = stripToProjectRelative(node.filePath);
+    const prefix = modulePrefixFromRelativePath(relative14);
     if (!initial.has(prefix)) initial.set(prefix, []);
     initial.get(prefix)?.push(node);
   }
@@ -18626,7 +19064,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path24.dirname(s.filePath),
+    directory: path26.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -18946,7 +19384,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 = path25.join(os7.tmpdir(), `call-graph-${Date.now()}.html`);
+    const outputPath = path27.join(os7.tmpdir(), `call-graph-${Date.now()}.html`);
     writeFileSync4(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
@@ -19053,7 +19491,7 @@ var PI_TOOL_NAMES = [
 
 // src/commands/loader.ts
 import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
-import * as path26 from "path";
+import * as path28 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -19079,7 +19517,7 @@ function loadCommandsFromDirectory(commandsDir) {
   }
   const files = readdirSync3(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path26.join(commandsDir, file);
+    const filePath = path28.join(commandsDir, file);
     let content;
     try {
       content = readFileSync9(filePath, "utf-8");
@@ -19088,7 +19526,7 @@ function loadCommandsFromDirectory(commandsDir) {
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path26.basename(file, ".md");
+    const name = path28.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -19422,23 +19860,41 @@ var RoutingHintController = class {
 
 // src/adapters/opencode.ts
 var activeWatchers = /* @__PURE__ */ new Map();
-function replaceActiveWatcher(projectRoot, nextWatcher) {
-  const existing = activeWatchers.get(projectRoot);
-  if (existing) {
-    existing.stop();
-    activeWatchers.delete(projectRoot);
-  }
-  if (nextWatcher) {
-    activeWatchers.set(projectRoot, nextWatcher);
+var watcherReplacementChains = /* @__PURE__ */ new Map();
+async function replaceActiveWatcher(projectRoot, createNextWatcher) {
+  const chain = (watcherReplacementChains.get(projectRoot) ?? Promise.resolve()).catch(() => void 0).then(async () => {
+    const existing = activeWatchers.get(projectRoot);
+    if (existing) {
+      try {
+        await existing.stop();
+      } catch (error) {
+        console.error("[codebase-index] Failed to stop replaced watcher:", error);
+        throw error;
+      }
+      if (activeWatchers.get(projectRoot) === existing) {
+        activeWatchers.delete(projectRoot);
+      }
+    }
+    if (createNextWatcher) {
+      activeWatchers.set(projectRoot, createNextWatcher());
+    }
+  });
+  watcherReplacementChains.set(projectRoot, chain);
+  try {
+    await chain;
+  } finally {
+    if (watcherReplacementChains.get(projectRoot) === chain) {
+      watcherReplacementChains.delete(projectRoot);
+    }
   }
 }
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path27.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path29.dirname(fileURLToPath2(import.meta.url));
   }
-  const packageRoot = path27.basename(currentDir) === "adapters" ? path27.join(currentDir, "..", "..") : path27.join(currentDir, "..");
-  return path27.join(packageRoot, "commands");
+  const packageRoot = path29.basename(currentDir) === "adapters" ? path29.join(currentDir, "..", "..") : path29.join(currentDir, "..");
+  return path29.join(packageRoot, "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -19479,9 +19935,12 @@ var plugin = async ({ directory, worktree }) => {
       startAutoIndex(projectRoot, "opencode", "startup");
     }
     if (config.indexing.watchFiles && isValidProject) {
-      replaceActiveWatcher(projectRoot, createWatcherWithIndexer(getProjectIndexer, projectRoot, config, "opencode"));
+      await replaceActiveWatcher(
+        projectRoot,
+        () => createWatcherWithIndexer(getProjectIndexer, projectRoot, config, "opencode")
+      );
     } else {
-      replaceActiveWatcher(projectRoot, null);
+      await replaceActiveWatcher(projectRoot, null);
     }
     return {
       tool: {