opencode-codebase-index 0.25.0 → 0.25.1

package/dist/cli.js

@@ -491,7 +491,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(path33, checkUnignored, mode) {
+      test(path34, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -500,7 +500,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path33);
+          const matched = rule[mode].test(path34);
           if (!matched) {
             return;
           }
@@ -521,17 +521,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path33, originalPath, doThrow) => {
-      if (!isString(path33)) {
+    var checkPath = (path34, originalPath, doThrow) => {
+      if (!isString(path34)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path33) {
+      if (!path34) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path33)) {
+      if (checkPath.isNotRelative(path34)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -540,7 +540,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path33) => REGEX_TEST_INVALID_PATH.test(path33);
+    var isNotRelative = (path34) => REGEX_TEST_INVALID_PATH.test(path34);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -570,19 +570,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path33 = originalPath && checkPath.convert(originalPath);
+        const path34 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path33,
+          path34,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path33, cache, checkUnignored, slices);
+        return this._t(path34, cache, checkUnignored, slices);
       }
-      checkIgnore(path33) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path33)) {
-          return this.test(path33);
+      checkIgnore(path34) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path34)) {
+          return this.test(path34);
         }
-        const slices = path33.split(SLASH2).filter(Boolean);
+        const slices = path34.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -595,18 +595,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path33, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path34, false, MODE_CHECK_IGNORE);
       }
-      _t(path33, cache, checkUnignored, slices) {
-        if (path33 in cache) {
-          return cache[path33];
+      _t(path34, cache, checkUnignored, slices) {
+        if (path34 in cache) {
+          return cache[path34];
         }
         if (!slices) {
-          slices = path33.split(SLASH2).filter(Boolean);
+          slices = path34.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path33] = this._rules.test(path33, checkUnignored, MODE_IGNORE);
+          return cache[path34] = this._rules.test(path34, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -614,29 +614,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path33] = parent.ignored ? parent : this._rules.test(path33, checkUnignored, MODE_IGNORE);
+        return cache[path34] = parent.ignored ? parent : this._rules.test(path34, checkUnignored, MODE_IGNORE);
       }
-      ignores(path33) {
-        return this._test(path33, this._ignoreCache, false).ignored;
+      ignores(path34) {
+        return this._test(path34, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path33) => !this.ignores(path33);
+        return (path34) => !this.ignores(path34);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path33) {
-        return this._test(path33, this._testCache, true);
+      test(path34) {
+        return this._test(path34, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path33) => checkPath(path33 && checkPath.convert(path33), path33, RETURN_FALSE);
+    var isPathValid = (path34) => checkPath(path34 && checkPath.convert(path34), path34, 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 = (path33) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path33) || isNotRelative(path33);
+      checkPath.isNotRelative = (path34) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path34) || isNotRelative(path34);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -653,9 +653,9 @@ var require_ignore = __commonJS({
 
 // src/adapters/mcp/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { realpathSync as realpathSync6, writeFileSync as writeFileSync6 } from "fs";
-import * as os8 from "os";
-import * as path32 from "path";
+import { realpathSync as realpathSync7, writeFileSync as writeFileSync7 } from "fs";
+import * as os9 from "os";
+import * as path33 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -1183,9 +1183,9 @@ import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 
 // src/eval/report-formatters.ts
-function assertFiniteNumber(value, path33) {
+function assertFiniteNumber(value, path34) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path33} must be a finite number`);
+    throw new Error(`${path34} must be a finite number`);
   }
   return value;
 }
@@ -1424,8 +1424,8 @@ function buildPerQueryArtifact(perQuery) {
 
 // src/eval/runner.ts
 import * as crypto2 from "crypto";
-import { existsSync as existsSync14 } from "fs";
-import * as path23 from "path";
+import { existsSync as existsSync15 } from "fs";
+import * as path24 from "path";
 import { performance as performance3 } from "perf_hooks";
 
 // src/indexer/index.ts
@@ -1457,7 +1457,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve20, reject) => {
+  const wrappedPromise = new Promise((resolve21, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -1471,7 +1471,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve20, reject);
+    promise.then(resolve21, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1479,7 +1479,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve20(fallback());
+          resolve21(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1489,7 +1489,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve20();
+        resolve21();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1891,7 +1891,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve21, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -1931,7 +1931,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve20(result);
+          resolve21(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -2119,13 +2119,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve20) => {
+    return new Promise((resolve21) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve20();
+        resolve21();
       };
       this.on(event, listener);
     });
@@ -2411,7 +2411,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve20, reject) => {
+    await new Promise((resolve21, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2419,7 +2419,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve20();
+        resolve21();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -2781,17 +2781,17 @@ function validateExternalUrl(urlString) {
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
     return { valid: false, reason: `Blocked protocol: ${parsed.protocol}` };
   }
-  const hostname2 = parsed.hostname.toLowerCase();
-  if (BLOCKED_HOSTNAMES.has(hostname2)) {
-    return { valid: false, reason: `Blocked: cloud metadata service (${hostname2})` };
+  const hostname3 = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname3)) {
+    return { valid: false, reason: `Blocked: cloud metadata service (${hostname3})` };
   }
   for (const pattern of BLOCKED_METADATA_IPS) {
-    if (pattern.test(hostname2)) {
-      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname2})` };
+    if (pattern.test(hostname3)) {
+      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname3})` };
     }
   }
-  if (/^169\.254\./.test(hostname2)) {
-    return { valid: false, reason: `Blocked: link-local address (${hostname2})` };
+  if (/^169\.254\./.test(hostname3)) {
+    return { valid: false, reason: `Blocked: link-local address (${hostname3})` };
   }
   return { valid: true };
 }
@@ -3377,26 +3377,46 @@ function createIgnoreFilter(projectRoot) {
   }
   return ig;
 }
-function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path4.relative(projectRoot, filePath);
-  if (hasFilteredPathSegment(relativePath, path4.sep)) {
-    return false;
-  }
-  if (ignoreFilter.ignores(relativePath)) {
-    return false;
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path4.sep).join("/");
+}
+function matchesAnyGlob(filePath, patterns) {
+  const normalized = toPosixRelativePath(filePath);
+  return patterns.some((pattern) => matchGlob(normalized, pattern));
+}
+function isExcludedByPatterns(relativePath, excludePatterns) {
+  return matchesAnyGlob(relativePath, excludePatterns);
+}
+function isExcludedDirectory(relativePath, excludePatterns) {
+  const normalized = toPosixRelativePath(relativePath);
+  if (matchesAnyGlob(normalized, excludePatterns)) {
+    return true;
   }
   for (const pattern of excludePatterns) {
-    if (matchGlob(relativePath, pattern)) {
-      return false;
+    const posixPattern = toPosixRelativePath(pattern).replace(/\/+$/, "");
+    if (!posixPattern.endsWith("/**")) {
+      continue;
     }
-  }
-  for (const pattern of includePatterns) {
-    if (matchGlob(relativePath, pattern)) {
+    const directoryPattern = posixPattern.slice(0, -3);
+    if (directoryPattern && matchesAnyGlob(normalized, [directoryPattern])) {
       return true;
     }
   }
   return false;
 }
+function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
+  const relativePath = toPosixRelativePath(path4.relative(projectRoot, filePath));
+  if (hasFilteredPathSegment(relativePath, "/")) {
+    return false;
+  }
+  if (ignoreFilter.ignores(relativePath)) {
+    return false;
+  }
+  if (isExcludedByPatterns(relativePath, excludePatterns)) {
+    return false;
+  }
+  return matchesAnyGlob(relativePath, includePatterns);
+}
 function matchGlob(filePath, pattern) {
   if (pattern.startsWith("**/")) {
     const withoutPrefix = pattern.slice(3);
@@ -3418,7 +3438,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const subdirs = [];
   for (const entry of entries) {
     const fullPath = path4.join(dir, entry.name);
-    const relativePath = path4.relative(projectRoot, fullPath);
+    const relativePath = toPosixRelativePath(path4.relative(projectRoot, fullPath));
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3436,6 +3456,10 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
       continue;
     }
     if (entry.isDirectory()) {
+      if (isExcludedDirectory(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
+      }
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
       const stat5 = await fsPromises.stat(fullPath);
@@ -3443,20 +3467,11 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
-      for (const pattern of excludePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          skipped.push({ path: relativePath, reason: "excluded" });
-          continue;
-        }
-      }
-      let matched = false;
-      for (const pattern of includePatterns) {
-        if (matchGlob(relativePath, pattern)) {
-          matched = true;
-          break;
-        }
+      if (isExcludedByPatterns(relativePath, excludePatterns)) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+        continue;
       }
-      if (matched) {
+      if (matchesAnyGlob(relativePath, includePatterns)) {
         filesInDir.push({ path: fullPath, size: stat5.size });
       }
     }
@@ -3467,7 +3482,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path4.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: toPosixRelativePath(path4.relative(projectRoot, filesInDir[i].path)), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -7087,8 +7102,8 @@ function pathSegmentsForAffinityMatch(filePath) {
   if (segments.length === 0) {
     return [];
   }
-  const basename8 = segments[segments.length - 1] ?? "";
-  const basenameWithoutExt = basename8.replace(/\.[^/.]+$/u, "");
+  const basename9 = segments[segments.length - 1] ?? "";
+  const basenameWithoutExt = basename9.replace(/\.[^/.]+$/u, "");
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
   return Array.from(/* @__PURE__ */ new Set([
     ...normalizedSegments,
@@ -7511,7 +7526,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path13.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath2 = path13.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os5.hostname(),
@@ -7520,19 +7535,19 @@ function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
     expectedOwnerToken: expectedOwner.token
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
-    if (publishJsonDirectory(reclaimPath, reclaimOwner)) break;
+    if (publishJsonDirectory(reclaimPath2, reclaimOwner)) break;
     if (attempt === 0 && removeDeadReclaimMarker(lockPath, expectedOwner)) continue;
     return false;
   }
   try {
-    const currentReclaimer = readReclaimOwner(reclaimPath);
+    const currentReclaimer = readReclaimOwner(reclaimPath2);
     const currentOwner = readDirectoryOwner(lockPath);
     if (!currentReclaimer || !sameReclaimOwner(currentReclaimer, reclaimOwner) || !currentOwner || !sameOwner(currentOwner, expectedOwner) || getOwnerLiveness(currentOwner) !== "dead") {
       return false;
     }
     publishRecoveryMarker(indexPath, expectedOwner);
     const ownerBeforeQuarantine = readDirectoryOwner(lockPath);
-    const reclaimerBeforeQuarantine = readReclaimOwner(reclaimPath);
+    const reclaimerBeforeQuarantine = readReclaimOwner(reclaimPath2);
     if (!ownerBeforeQuarantine || !sameOwner(ownerBeforeQuarantine, expectedOwner) || getOwnerLiveness(ownerBeforeQuarantine) !== "dead" || !reclaimerBeforeQuarantine || !sameReclaimOwner(reclaimerBeforeQuarantine, reclaimOwner)) {
       return false;
     }
@@ -8748,6 +8763,17 @@ var Indexer = class _Indexer {
     }
     return path15.relative(this.projectRoot, canonicalFilePath).split(path15.sep).join("/");
   }
+  isStoredPathExcluded(storedPath) {
+    let matchPath = storedPath.split(path15.sep).join("/");
+    if (path15.isAbsolute(storedPath)) {
+      const relativePath = path15.relative(this.projectRoot, storedPath).split(path15.sep).join("/");
+      if (relativePath.startsWith("..") || path15.isAbsolute(relativePath)) {
+        return false;
+      }
+      matchPath = relativePath;
+    }
+    return isExcludedByPatterns(matchPath, this.config.exclude);
+  }
   resolveStoredFilePath(filePath, rootPath = this.projectRoot) {
     if (path15.isAbsolute(filePath)) {
       return filePath;
@@ -9772,7 +9798,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((resolve20) => setTimeout(resolve20, options.rateLimitState.backoffMs));
+          await new Promise((resolve21) => setTimeout(resolve21, options.rateLimitState.backoffMs));
         }
         try {
           const embeddingResult = await pRetry(
@@ -11149,7 +11175,7 @@ var Indexer = class _Indexer {
         }
       }
     }
-    const shouldRetryFailedPath = (filePath) => filePath !== null && currentFileHashes.has(filePath) && unchangedFilePaths.has(filePath);
+    const shouldRetryFailedPath = (filePath) => filePath !== null && !this.isStoredPathExcluded(filePath) && currentFileHashes.has(filePath) && unchangedFilePaths.has(filePath);
     const failedProcessing = this.prepareFailedBatchProcessing(scopedRoots, shouldRetryFailedPath);
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
@@ -12477,7 +12503,8 @@ var Indexer = class _Indexer {
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
     const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
-    const failedProcessing = this.prepareFailedBatchProcessing(roots, () => true);
+    const shouldProcessFailedPath = (filePath) => filePath === null || !this.isStoredPathExcluded(filePath);
+    const failedProcessing = this.prepareFailedBatchProcessing(roots, shouldProcessFailedPath);
     if (failedProcessing.latestById.size === 0) {
       this.finalizeFailedBatchWriteState(failedProcessing.state);
       return { succeeded: 0, failed: 0, remaining: 0 };
@@ -12490,7 +12517,7 @@ var Indexer = class _Indexer {
       const retryableChunks = this.iterateLatestFailedChunks(
         failedProcessing.latestById,
         roots,
-        () => true,
+        shouldProcessFailedPath,
         maxChunkTokens
       );
       for (const retryBatch of iterateOrderedFileBatches(
@@ -12760,9 +12787,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path33 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path33.length > 0 && (shortest.length === 0 || path33.length < shortest.length)) {
-        shortest = path33;
+      const path34 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path34.length > 0 && (shortest.length === 0 || path34.length < shortest.length)) {
+        shortest = path34;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -12810,13 +12837,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path33 = [];
+      const path34 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path33.push({
+        path34.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -12826,9 +12853,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path33.reverse();
-      if (path33.length > 0 && (shortest.length === 0 || path33.length < shortest.length)) {
-        shortest = path33;
+      path34.reverse();
+      if (path34.length > 0 && (shortest.length === 0 || path34.length < shortest.length)) {
+        shortest = path34;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13211,8 +13238,8 @@ var CODE_COMMUNITIES_DEFAULT_COUPLING_LIMIT = 20;
 var CODE_COMMUNITIES_MAX_COUPLING_LIMIT = 100;
 
 // src/tools/operations.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5, statSync as statSync5 } from "fs";
-import * as path21 from "path";
+import { existsSync as existsSync13, realpathSync as realpathSync6, statSync as statSync5 } from "fs";
+import * as path22 from "path";
 
 // src/tools/knowledge-base-paths.ts
 import * as path16 from "path";
@@ -13507,8 +13534,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path33 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path33}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path34 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path34}:${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));
@@ -14150,9 +14177,907 @@ function formatEffectivenessMetrics(snapshot) {
 }
 
 // src/utils/auto-index.ts
-import { existsSync as existsSync9, realpathSync as realpathSync4 } from "fs";
+import { existsSync as existsSync10, realpathSync as realpathSync5 } from "fs";
+import * as os7 from "os";
+import * as path18 from "path";
+
+// src/utils/background-worker.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import {
+  existsSync as existsSync9,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync9,
+  realpathSync as realpathSync4,
+  renameSync as renameSync4,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
 import * as os6 from "os";
 import * as path17 from "path";
+var OWNER_FILE_NAME2 = "owner.json";
+var HEARTBEAT_FILE_PREFIX = "heartbeat.";
+var RECLAIM_DIRECTORY_NAME2 = "reclaim";
+var REFRESH_REQUEST_FILE_NAME = "refresh-request.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_LEASE_MS = 3e4;
+var RETRY_DELAY_MS = 5e3;
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var BackgroundWorkerStopError = class extends Error {
+  constructor(watcherError, autoIndexError) {
+    super("Failed to stop background worker");
+    this.watcherError = watcherError;
+    this.autoIndexError = autoIndexError;
+    this.name = "BackgroundWorkerStopError";
+  }
+  watcherError;
+  autoIndexError;
+};
+var workers = /* @__PURE__ */ new Map();
+var workerKeysByProject = /* @__PURE__ */ new Map();
+var workerReplacementBarriers = /* @__PURE__ */ new Map();
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function canonicalizePath(targetPath) {
+  const resolved = path17.resolve(targetPath);
+  if (existsSync9(resolved)) {
+    try {
+      return realpathSync4.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  const parent = path17.dirname(resolved);
+  if (parent === resolved) return resolved;
+  return path17.join(canonicalizePath(parent), path17.basename(resolved));
+}
+function projectLookupKey(projectRoot, host) {
+  return `${host}::${canonicalizePath(projectRoot)}`;
+}
+function getBackgroundWorkerProjectKey(projectRoot, host) {
+  return projectLookupKey(projectRoot, host);
+}
+function resolveIdentity(projectRoot, config, host) {
+  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalIndexPath = canonicalizePath(resolveProjectIndexPath(projectRoot, config.scope, host));
+  return {
+    canonicalIndexPath,
+    canonicalProjectRoot,
+    key: `${canonicalIndexPath}::${canonicalProjectRoot}`
+  };
+}
+function controllerKey(identity, host) {
+  return `${identity.key}::${host}`;
+}
+function leaseDirectoryName(identity) {
+  const hash = createHash2("sha256").update(identity.key).digest("hex").slice(0, 32);
+  return `background-worker.${hash}.lease`;
+}
+function leasePathFor(identity) {
+  return path17.join(identity.canonicalIndexPath, leaseDirectoryName(identity));
+}
+function parseOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  if (typeof candidate.projectRoot !== "string" || candidate.projectRoot.length === 0) return null;
+  if (typeof candidate.indexPath !== "string" || candidate.indexPath.length === 0) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  return candidate;
+}
+function parseHeartbeat(value, expectedToken) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1 || candidate.token !== expectedToken) return null;
+  if (typeof candidate.heartbeatAt !== "string" || Number.isNaN(Date.parse(candidate.heartbeatAt))) return null;
+  return candidate;
+}
+function parseReclaimOwner2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (!Number.isInteger(candidate.pid) || (candidate.pid ?? 0) <= 0) return null;
+  if (typeof candidate.hostname !== "string" || candidate.hostname.length === 0) return null;
+  if (typeof candidate.startedAt !== "string" || Number.isNaN(Date.parse(candidate.startedAt))) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN2.test(candidate.token)) return null;
+  if (candidate.expectedOwnerToken !== null && (typeof candidate.expectedOwnerToken !== "string" || !UUID_PATTERN2.test(candidate.expectedOwnerToken))) return null;
+  return candidate;
+}
+function heartbeatPath(leasePath, token) {
+  return path17.join(leasePath, `${HEARTBEAT_FILE_PREFIX}${token}.json`);
+}
+function reclaimPath(leasePath) {
+  return path17.join(leasePath, RECLAIM_DIRECTORY_NAME2);
+}
+function refreshRequestPath(leasePath) {
+  return path17.join(leasePath, REFRESH_REQUEST_FILE_NAME);
+}
+function readLeaseOwner(leasePath) {
+  try {
+    return parseOwner2(JSON.parse(readFileSync9(path17.join(leasePath, OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function readOwner(leasePath) {
+  const owner = readLeaseOwner(leasePath);
+  if (!owner) return null;
+  try {
+    const heartbeat = parseHeartbeat(
+      JSON.parse(readFileSync9(heartbeatPath(leasePath, owner.token), "utf-8")),
+      owner.token
+    );
+    return heartbeat ? { ...owner, heartbeatAt: heartbeat.heartbeatAt } : owner;
+  } catch {
+    return owner;
+  }
+}
+function readReclaimOwner2(leasePath) {
+  try {
+    return parseReclaimOwner2(JSON.parse(readFileSync9(path17.join(reclaimPath(leasePath), OWNER_FILE_NAME2), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function ownerLiveness(owner) {
+  if (owner.hostname !== os6.hostname()) return "unknown";
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    const code = getErrorCode2(error);
+    if (code === "ESRCH") return "dead";
+    if (code === "EPERM") return "alive";
+    return "unknown";
+  }
+}
+function isHeartbeatExpired(owner) {
+  return Date.now() - Date.parse(owner.heartbeatAt) >= STALE_LEASE_MS;
+}
+function sameOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token;
+}
+function writeHeartbeat(leasePath, owner) {
+  const targetPath = heartbeatPath(leasePath, owner.token);
+  const temporaryPath = `${targetPath}.tmp.${process.pid}.${owner.token}.${randomUUID2()}`;
+  const heartbeat = {
+    version: 1,
+    token: owner.token,
+    heartbeatAt: owner.heartbeatAt
+  };
+  try {
+    writeFileSync4(temporaryPath, JSON.stringify(heartbeat), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync4(temporaryPath, targetPath);
+    const currentOwner = readLeaseOwner(leasePath);
+    return currentOwner !== null && sameOwner2(currentOwner, owner);
+  } finally {
+    if (existsSync9(temporaryPath)) rmSync3(temporaryPath, { force: true });
+  }
+}
+function requestRefreshFromLeader(leasePath, allowDisabledAutoIndex) {
+  const requestPath = refreshRequestPath(leasePath);
+  const temporaryPath = `${requestPath}.tmp.${process.pid}.${randomUUID2()}`;
+  try {
+    const request = {
+      allowDisabledAutoIndex,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    writeFileSync4(temporaryPath, JSON.stringify(request), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    renameSync4(temporaryPath, requestPath);
+  } catch (error) {
+    if (getErrorCode2(error) !== "ENOENT") {
+      console.error("[codebase-index] Failed to request background index refresh from the project worker:", error);
+    }
+  } finally {
+    if (existsSync9(temporaryPath)) rmSync3(temporaryPath, { force: true });
+  }
+}
+function consumeRefreshRequest(leasePath) {
+  const requestPath = refreshRequestPath(leasePath);
+  const claimedPath = `${requestPath}.handling.${process.pid}.${randomUUID2()}`;
+  try {
+    renameSync4(requestPath, claimedPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    const value = JSON.parse(readFileSync9(claimedPath, "utf-8"));
+    return {
+      allowDisabledAutoIndex: value.version === 1 && value.allowDisabledAutoIndex === true,
+      requestedAt: typeof value.requestedAt === "string" ? value.requestedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+  } catch {
+    return { allowDisabledAutoIndex: false, requestedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  } finally {
+    rmSync3(claimedPath, { force: true });
+  }
+}
+function publishLease(leasePath, owner) {
+  const candidatePath = `${leasePath}.candidate.${process.pid}.${owner.token}`;
+  try {
+    mkdirSync5(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    writeFileSync4(path17.join(candidatePath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if (existsSync9(leasePath)) return false;
+    try {
+      renameSync4(candidatePath, leasePath);
+      return true;
+    } catch (error) {
+      if (existsSync9(leasePath) || getErrorCode2(error) === "ENOENT") return false;
+      throw error;
+    }
+  } finally {
+    if (existsSync9(candidatePath)) rmSync3(candidatePath, { recursive: true, force: true });
+  }
+}
+function sameReclaimOwner2(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token && left.expectedOwnerToken === right.expectedOwnerToken;
+}
+function reclaimerLiveness(owner) {
+  return ownerLiveness(owner);
+}
+function isReclaimMarkerExpired(leasePath, owner) {
+  const startedAt = owner ? Date.parse(owner.startedAt) : (() => {
+    try {
+      return lstatSync2(reclaimPath(leasePath)).mtimeMs;
+    } catch {
+      return Date.now();
+    }
+  })();
+  return Date.now() - startedAt >= STALE_LEASE_MS;
+}
+function hasActiveReclaimMarker(leasePath, owner) {
+  const marker = readReclaimOwner2(leasePath);
+  return marker !== null && marker.expectedOwnerToken === owner.token && (marker.hostname !== os6.hostname() || ownerLiveness(owner) !== "alive");
+}
+function publishReclaimMarker(leasePath, expectedOwner) {
+  const markerPath = reclaimPath(leasePath);
+  const owner = {
+    version: 1,
+    pid: process.pid,
+    hostname: os6.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token: randomUUID2(),
+    expectedOwnerToken: expectedOwner?.token ?? null
+  };
+  try {
+    mkdirSync5(markerPath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode2(error) === "EEXIST" || getErrorCode2(error) === "ENOENT") return null;
+    throw error;
+  }
+  try {
+    writeFileSync4(path17.join(markerPath, OWNER_FILE_NAME2), JSON.stringify(owner), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    return owner;
+  } catch (error) {
+    rmSync3(markerPath, { recursive: true, force: true });
+    throw error;
+  }
+}
+function removeExpiredReclaimMarker(leasePath, expectedOwner) {
+  const marker = readReclaimOwner2(leasePath);
+  const markerPath = reclaimPath(leasePath);
+  if (!existsSync9(markerPath)) return false;
+  if (marker && marker.expectedOwnerToken !== (expectedOwner?.token ?? null)) return false;
+  if (marker && (reclaimerLiveness(marker) === "alive" || !isReclaimMarkerExpired(leasePath, marker))) return false;
+  if (!marker && !isReclaimMarkerExpired(leasePath, null)) return false;
+  const staleMarkerPath = `${markerPath}.stale.${marker?.pid ?? process.pid}.${marker?.token ?? randomUUID2()}.${randomUUID2()}`;
+  try {
+    renameSync4(markerPath, staleMarkerPath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    let claimedMarker = null;
+    try {
+      claimedMarker = parseReclaimOwner2(
+        JSON.parse(readFileSync9(path17.join(staleMarkerPath, OWNER_FILE_NAME2), "utf-8"))
+      );
+    } catch {
+      claimedMarker = null;
+    }
+    const markerMatches = marker ? claimedMarker !== null && sameReclaimOwner2(claimedMarker, marker) : claimedMarker === null;
+    if (!markerMatches || !canReclaimLease(leasePath, expectedOwner)) {
+      if (!existsSync9(markerPath) && existsSync9(staleMarkerPath)) renameSync4(staleMarkerPath, markerPath);
+      return false;
+    }
+    rmSync3(staleMarkerPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+function canReclaimLease(leasePath, expectedOwner) {
+  if (!existsSync9(leasePath)) return false;
+  if (!expectedOwner) return false;
+  const currentOwner = readOwner(leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, expectedOwner)) return false;
+  if (currentOwner.hostname === os6.hostname()) {
+    return ownerLiveness(currentOwner) === "dead";
+  }
+  return isHeartbeatExpired(currentOwner);
+}
+function reclaimLease(leasePath, expectedOwner) {
+  let marker = null;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    marker = publishReclaimMarker(leasePath, expectedOwner);
+    if (marker) break;
+    if (attempt === 0 && removeExpiredReclaimMarker(leasePath, expectedOwner)) continue;
+    return false;
+  }
+  if (!marker) return false;
+  const markerPath = reclaimPath(leasePath);
+  try {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (!currentMarker || !sameReclaimOwner2(currentMarker, marker) || !canReclaimLease(leasePath, expectedOwner)) {
+      return false;
+    }
+    const stalePath = `${leasePath}.stale.${process.pid}.${marker.token}`;
+    renameSync4(leasePath, stalePath);
+    const quarantinedOwner = readOwner(stalePath);
+    const quarantinedMarker = readReclaimOwner2(stalePath);
+    if (!quarantinedMarker || !sameReclaimOwner2(quarantinedMarker, marker) || expectedOwner !== null && (!quarantinedOwner || !sameOwner2(quarantinedOwner, expectedOwner))) {
+      if (!existsSync9(leasePath) && existsSync9(stalePath)) renameSync4(stalePath, leasePath);
+      return false;
+    }
+    rmSync3(stalePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  } finally {
+    const currentMarker = readReclaimOwner2(leasePath);
+    if (currentMarker && sameReclaimOwner2(currentMarker, marker)) {
+      rmSync3(markerPath, { recursive: true, force: true });
+    }
+  }
+}
+function acquireLease(identity) {
+  mkdirSync5(identity.canonicalIndexPath, { recursive: true, mode: 448 });
+  const canonicalIndexPath = realpathSync4.native(identity.canonicalIndexPath);
+  const leasePath = path17.join(canonicalIndexPath, leaseDirectoryName({ ...identity, canonicalIndexPath }));
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const owner = {
+      version: 1,
+      pid: process.pid,
+      hostname: os6.hostname(),
+      startedAt: timestamp,
+      heartbeatAt: timestamp,
+      projectRoot: identity.canonicalProjectRoot,
+      indexPath: canonicalIndexPath,
+      token: randomUUID2()
+    };
+    if (publishLease(leasePath, owner)) {
+      return { leasePath, owner };
+    }
+    const existingOwner = readOwner(leasePath);
+    if (existingOwner) {
+      if (canReclaimLease(leasePath, existingOwner) && reclaimLease(leasePath, existingOwner)) continue;
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function releaseLease(lease) {
+  const currentOwner = readOwner(lease.leasePath);
+  if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) return false;
+  const releasePath = `${lease.leasePath}.release.${lease.owner.pid}.${lease.owner.token}`;
+  try {
+    renameSync4(lease.leasePath, releasePath);
+  } catch (error) {
+    if (getErrorCode2(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readOwner(releasePath);
+  if (!claimedOwner || !sameOwner2(claimedOwner, lease.owner)) {
+    if (!existsSync9(lease.leasePath) && existsSync9(releasePath)) {
+      renameSync4(releasePath, lease.leasePath);
+    }
+    return false;
+  }
+  rmSync3(releasePath, { recursive: true, force: true });
+  return true;
+}
+var BackgroundWorkerController = class {
+  constructor(projectRoot, host, config, hooks, identity) {
+    this.projectRoot = projectRoot;
+    this.host = host;
+    this.config = config;
+    this.hooks = hooks;
+    this.identity = identity;
+  }
+  projectRoot;
+  host;
+  config;
+  hooks;
+  identity;
+  lease = null;
+  watcher = null;
+  leaderReady = Promise.resolve();
+  heartbeatTimer = null;
+  retryTimer = null;
+  teardownRetryTimer = null;
+  transition = Promise.resolve();
+  stopPromise = null;
+  stopped = false;
+  stopping = false;
+  losingLeadership = false;
+  restartAfterStop = false;
+  leaderWorkStopped = false;
+  startingLeaderWork = false;
+  stopAutoIndexOnTeardown = true;
+  autoIndexStarted = false;
+  reportedError = null;
+  update(config, hooks, options) {
+    const autoIndexWasEnabled = this.config.indexing.autoIndex;
+    const shouldReplaceWatcher = this.watcher !== null && hooks.watcherFactory !== void 0 && (hooks.watcherFactory === null || hooks.replaceWatcher === true);
+    this.config = config;
+    this.hooks = {
+      ...this.hooks,
+      ...hooks,
+      watcherFactory: hooks.watcherFactory === void 0 ? this.hooks.watcherFactory : hooks.watcherFactory,
+      watcherFactoryForConfig: hooks.watcherFactoryForConfig === void 0 ? this.hooks.watcherFactoryForConfig : hooks.watcherFactoryForConfig
+    };
+    if (autoIndexWasEnabled && !config.indexing.autoIndex || options.restartAutoIndex === true && config.indexing.autoIndex && !this.startingLeaderWork) {
+      this.autoIndexStarted = false;
+    }
+    if (!this.canRun()) {
+      void this.stop().catch((error) => {
+        console.error("[codebase-index] Failed to stop background worker after disabling automatic work:", error);
+      });
+      return;
+    }
+    if (shouldReplaceWatcher) {
+      void this.enqueue(async () => {
+        const watcher = this.watcher;
+        if (watcher) {
+          await watcher.stop();
+          if (this.watcher === watcher) this.watcher = null;
+        }
+        if (this.lease && !this.stopped) this.startLeaderWork();
+      }).catch((error) => {
+        console.error("[codebase-index] Failed to replace background file watcher:", error);
+      });
+    }
+    this.start();
+  }
+  startAfter(activation) {
+    this.transition = activation.catch(() => void 0);
+    this.start();
+  }
+  start() {
+    if (!this.canRun() || this.losingLeadership) return;
+    if (this.stopping) {
+      this.restartAfterStop = true;
+      return;
+    }
+    this.stopped = false;
+    void this.enqueue(async () => {
+      if (this.stopped || this.stopping || this.losingLeadership || !this.canRun()) return;
+      if (!this.lease) {
+        try {
+          this.lease = acquireLease(this.identity);
+          this.reportedError = null;
+        } catch (error) {
+          this.reportAcquireError(error);
+          this.scheduleRetry();
+          return;
+        }
+      }
+      if (!this.lease) {
+        this.scheduleRetry();
+        return;
+      }
+      this.startHeartbeat();
+      this.startLeaderWork();
+    });
+  }
+  waitForStart() {
+    return this.transition.catch(() => void 0).then(() => this.leaderReady);
+  }
+  requestRefresh(allowDisabledAutoIndex = false) {
+    this.start();
+    if (!this.isLeader()) {
+      requestRefreshFromLeader(leasePathFor(this.identity), allowDisabledAutoIndex);
+      return;
+    }
+    void this.enqueue(async () => {
+      if (this.stopped || !this.lease) return;
+      this.hooks.startAutoIndex("retrieval", allowDisabledAutoIndex);
+    });
+  }
+  isLeader() {
+    return this.lease !== null && !this.stopping && !this.losingLeadership;
+  }
+  isStopping() {
+    return this.stopping;
+  }
+  getHooksForConfig(config) {
+    const watcherFactoryForConfig = this.hooks.watcherFactoryForConfig;
+    if (!watcherFactoryForConfig) return this.hooks;
+    return {
+      ...this.hooks,
+      watcherFactory: watcherFactoryForConfig(config),
+      replaceWatcher: true
+    };
+  }
+  attachWatcher(watcherFactory, watcherFactoryForConfig) {
+    if (this.hooks.watcherFactory !== void 0) return;
+    this.hooks = {
+      ...this.hooks,
+      watcherFactory,
+      watcherFactoryForConfig: watcherFactoryForConfig ?? this.hooks.watcherFactoryForConfig
+    };
+    this.start();
+  }
+  async stop(stopAutoIndex = true) {
+    if (this.stopPromise) return this.stopPromise;
+    this.stopped = true;
+    this.stopping = true;
+    this.stopAutoIndexOnTeardown &&= stopAutoIndex;
+    this.clearRetryTimer();
+    const attempt = this.enqueue(async () => {
+      try {
+        const lease = this.lease;
+        if (this.leaderWorkStopped) {
+          if (lease) {
+            this.releaseStoppedLease(lease);
+          } else {
+            this.finishStoppedLease();
+          }
+          return;
+        }
+        const hadLeaderWork = lease !== null || this.watcher !== null || this.autoIndexStarted;
+        const stopped = await this.stopLeaderWork(hadLeaderWork && this.stopAutoIndexOnTeardown);
+        if (!lease) {
+          this.finishStoppedLease();
+          return;
+        }
+        if (!stopped.completed) {
+          this.releaseLeaseWhenAutoIndexStops(lease, stopped.completion);
+          return;
+        }
+        this.leaderWorkStopped = true;
+        this.releaseStoppedLease(lease);
+      } catch (error) {
+        this.scheduleTeardownRetry();
+        throw error;
+      }
+    });
+    const completion = attempt.finally(() => {
+      if (this.stopPromise === completion) this.stopPromise = null;
+    });
+    this.stopPromise = completion;
+    return completion;
+  }
+  canRun() {
+    return this.config.indexing.autoIndex || this.hooks.watcherFactory != null;
+  }
+  enqueue(operation) {
+    const next = this.transition.catch(() => void 0).then(operation);
+    this.transition = next;
+    return next;
+  }
+  startLeaderWork() {
+    if (this.stopped || this.stopping || this.losingLeadership) return;
+    this.startingLeaderWork = true;
+    try {
+      if (this.config.indexing.autoIndex && !this.autoIndexStarted) {
+        this.autoIndexStarted = true;
+        this.hooks.startAutoIndex("startup");
+      }
+      if (!this.watcher && this.hooks.watcherFactory) {
+        try {
+          const watcher = this.hooks.watcherFactory();
+          this.watcher = watcher;
+          this.leaderReady = watcher.whenReady?.().catch((error) => {
+            console.error("[codebase-index] Failed while waiting for background file watcher startup:", error);
+          }) ?? Promise.resolve();
+        } catch (error) {
+          console.error("[codebase-index] Failed to start background file watcher:", error);
+          this.leaderReady = Promise.resolve();
+        }
+      }
+    } finally {
+      this.startingLeaderWork = false;
+    }
+  }
+  async stopLeaderWork(stopAutoIndex) {
+    const watcher = this.watcher;
+    let watcherError;
+    if (watcher) {
+      try {
+        await watcher.stop();
+        if (this.watcher === watcher) this.watcher = null;
+      } catch (error) {
+        watcherError = error;
+      }
+    }
+    let autoIndexError;
+    let autoIndexStop = {
+      completed: true,
+      completion: Promise.resolve()
+    };
+    if (stopAutoIndex) {
+      try {
+        autoIndexStop = await this.hooks.stopAutoIndex();
+        this.autoIndexStarted = false;
+      } catch (error) {
+        autoIndexError = error;
+      }
+    }
+    if (watcherError !== void 0 || autoIndexError !== void 0) {
+      throw new BackgroundWorkerStopError(watcherError, autoIndexError);
+    }
+    return autoIndexStop;
+  }
+  releaseLeaseWhenAutoIndexStops(lease, completion) {
+    void completion.then(
+      () => {
+        void this.enqueue(async () => {
+          if (this.lease !== lease || !this.stopping) return;
+          this.leaderWorkStopped = true;
+          this.releaseStoppedLease(lease);
+        }).catch((error) => {
+          console.error("[codebase-index] Failed to release background worker lease after automatic indexing stopped:", error);
+          this.scheduleTeardownRetry();
+        });
+      },
+      (error) => {
+        console.error("[codebase-index] Failed while waiting for automatic indexing to stop:", error);
+        this.scheduleTeardownRetry();
+      }
+    );
+  }
+  releaseStoppedLease(lease) {
+    if (this.lease !== lease) {
+      this.finishStoppedLease();
+      return;
+    }
+    releaseLease(lease);
+    this.lease = null;
+    this.finishStoppedLease();
+  }
+  finishStoppedLease() {
+    this.leaderWorkStopped = false;
+    this.stopAutoIndexOnTeardown = true;
+    this.stopping = false;
+    this.clearTimers();
+    this.restartAfterTeardown();
+    if (!this.stopped || this.stopping) return;
+    const projectKey = projectLookupKey(this.projectRoot, this.host);
+    const key = controllerKey(this.identity, this.host);
+    if (workers.get(key) === this) workers.delete(key);
+    if (workerKeysByProject.get(projectKey) === key) workerKeysByProject.delete(projectKey);
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    const heartbeat = () => {
+      void this.heartbeat();
+    };
+    this.heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimer.unref?.();
+  }
+  async heartbeat() {
+    const lease = this.lease;
+    if (!lease || this.losingLeadership || this.stopped && !this.stopping) return;
+    if (hasActiveReclaimMarker(lease.leasePath, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    const currentOwner = readOwner(lease.leasePath);
+    if (!currentOwner || !sameOwner2(currentOwner, lease.owner)) {
+      await this.loseLeadership();
+      return;
+    }
+    try {
+      const nextOwner = { ...lease.owner, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+      if (!writeHeartbeat(lease.leasePath, nextOwner)) {
+        await this.loseLeadership();
+        return;
+      }
+      lease.owner = nextOwner;
+      const refreshRequest = !this.stopping ? consumeRefreshRequest(lease.leasePath) : null;
+      if (refreshRequest) {
+        this.hooks.startAutoIndex("retrieval", refreshRequest.allowDisabledAutoIndex);
+      }
+    } catch (error) {
+      const ownerAfterError = readOwner(lease.leasePath);
+      if (hasActiveReclaimMarker(lease.leasePath, lease.owner) || !ownerAfterError || !sameOwner2(ownerAfterError, lease.owner)) {
+        await this.loseLeadership();
+        return;
+      }
+      console.error("[codebase-index] Failed to renew background worker lease:", error);
+    }
+  }
+  async loseLeadership() {
+    if (this.losingLeadership) return;
+    this.losingLeadership = true;
+    this.clearHeartbeat();
+    await this.enqueue(async () => this.stopAfterLeadershipLoss());
+  }
+  async stopAfterLeadershipLoss() {
+    const lease = this.lease;
+    if (!lease) {
+      this.losingLeadership = false;
+      return;
+    }
+    try {
+      const stopped = await this.stopLeaderWork(true);
+      this.lease = null;
+      this.losingLeadership = false;
+      if (stopped.completed) {
+        this.scheduleRetry();
+      } else {
+        void stopped.completion.then(() => this.scheduleRetry());
+      }
+    } catch (error) {
+      console.error("[codebase-index] Failed to stop background work after losing its lease:", error);
+      this.scheduleLostLeadershipTeardownRetry();
+    }
+  }
+  scheduleRetry() {
+    if (this.stopped || !this.canRun() || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.start();
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  scheduleTeardownRetry() {
+    if (!this.stopping || this.teardownRetryTimer) return;
+    this.teardownRetryTimer = setTimeout(() => {
+      this.teardownRetryTimer = null;
+      void this.stop(this.stopAutoIndexOnTeardown).catch((error) => {
+        console.error("[codebase-index] Failed to retry background worker teardown:", error);
+      });
+    }, RETRY_DELAY_MS);
+    this.teardownRetryTimer.unref?.();
+  }
+  restartAfterTeardown() {
+    if (!this.restartAfterStop || !this.canRun() || this.losingLeadership) return;
+    this.restartAfterStop = false;
+    this.stopped = false;
+    this.start();
+  }
+  scheduleLostLeadershipTeardownRetry() {
+    if (this.stopped || !this.losingLeadership || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.enqueue(async () => this.stopAfterLeadershipLoss());
+    }, RETRY_DELAY_MS);
+    this.retryTimer.unref?.();
+  }
+  clearHeartbeat() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    this.clearRetryTimer();
+    if (this.teardownRetryTimer) {
+      clearTimeout(this.teardownRetryTimer);
+      this.teardownRetryTimer = null;
+    }
+  }
+  clearRetryTimer() {
+    if (!this.retryTimer) return;
+    clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  reportAcquireError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.reportedError === message) return;
+    this.reportedError = message;
+    console.error("[codebase-index] Failed to acquire background worker lease:", error);
+  }
+};
+function configureBackgroundWorker(projectRoot, host, config, hooks, options = {}) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const identity = resolveIdentity(projectRoot, config, host);
+  const key = controllerKey(identity, host);
+  const previousKey = workerKeysByProject.get(projectKey);
+  if (previousKey && previousKey !== key) {
+    const previous = workers.get(previousKey);
+    const previousBarrier = workerReplacementBarriers.get(projectKey) ?? Promise.resolve();
+    const stopPrevious = previous?.stop(options.stopPreviousAutoIndex ?? true) ?? Promise.resolve();
+    const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
+    workerReplacementBarriers.set(projectKey, activation);
+    workers.delete(previousKey);
+    const worker2 = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    worker2.startAfter(activation);
+    workers.set(key, worker2);
+    workerKeysByProject.set(projectKey, key);
+    return;
+  }
+  let worker = workers.get(key);
+  if (!worker) {
+    worker = new BackgroundWorkerController(projectRoot, host, config, hooks, identity);
+    workers.set(key, worker);
+  } else {
+    worker.update(config, hooks, options);
+  }
+  workerKeysByProject.set(projectKey, key);
+  worker.start();
+}
+function attachBackgroundWorkerWatcher(projectRoot, host, watcherFactory, watcherFactoryForConfig) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  workers.get(key ?? "")?.attachWatcher(watcherFactory, watcherFactoryForConfig);
+}
+function updateBackgroundWorkerConfig(projectRoot, host, config) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  configureBackgroundWorker(projectRoot, host, config, worker.getHooksForConfig(config), {
+    stopPreviousAutoIndex: false,
+    restartAutoIndex: true
+  });
+}
+function requestBackgroundWorker(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  workers.get(key ?? "")?.start();
+}
+function waitForBackgroundWorkerStart(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return workers.get(key ?? "")?.waitForStart() ?? Promise.resolve();
+}
+function requestBackgroundWorkerRefresh(projectRoot, host, allowDisabledAutoIndex = false) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  workers.get(key ?? "")?.requestRefresh(allowDisabledAutoIndex);
+}
+function isBackgroundWorkerManaged(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.has(key);
+}
+function isBackgroundWorkerLeader(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.get(key)?.isLeader() === true;
+}
+function isBackgroundWorkerStopping(projectRoot, host) {
+  const key = workerKeysByProject.get(projectLookupKey(projectRoot, host));
+  return key !== void 0 && workers.get(key)?.isStopping() === true;
+}
+async function stopBackgroundWorker(projectRoot, host) {
+  const projectKey = projectLookupKey(projectRoot, host);
+  const key = workerKeysByProject.get(projectKey);
+  const worker = key ? workers.get(key) : void 0;
+  if (!worker) return;
+  await worker.stop();
+}
 
 // src/utils/power-source.ts
 import * as childProcess from "child_process";
@@ -14162,7 +15087,7 @@ function getErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runCommand(file, args, options) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     childProcess.execFile(
       file,
       args,
@@ -14172,7 +15097,7 @@ function runCommand(file, args, options) {
           reject(error);
           return;
         }
-        resolve20(stdout);
+        resolve21(stdout);
       }
     );
   });
@@ -14264,29 +15189,29 @@ var AutoIndexCancelledError = class extends Error {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function canonicalizePath(targetPath) {
-  const resolved = path17.resolve(targetPath);
-  if (existsSync9(resolved)) {
+function canonicalizePath2(targetPath) {
+  const resolved = path18.resolve(targetPath);
+  if (existsSync10(resolved)) {
     try {
-      return realpathSync4.native(resolved);
+      return realpathSync5.native(resolved);
     } catch {
       return resolved;
     }
   }
-  const parent = path17.dirname(resolved);
+  const parent = path18.dirname(resolved);
   if (parent === resolved) return resolved;
-  return path17.join(canonicalizePath(parent), path17.basename(resolved));
+  return path18.join(canonicalizePath2(parent), path18.basename(resolved));
 }
 function isHomeDirectory(projectRoot) {
-  return canonicalizePath(projectRoot) === canonicalizePath(os6.homedir());
+  return canonicalizePath2(projectRoot) === canonicalizePath2(os7.homedir());
 }
-function projectLookupKey(projectRoot, host) {
-  return `${host}::${canonicalizePath(projectRoot)}`;
+function projectLookupKey2(projectRoot, host) {
+  return `${host}::${canonicalizePath2(projectRoot)}`;
 }
 function coordinatorKey(projectRoot, config, host) {
-  const canonicalProjectRoot = canonicalizePath(projectRoot);
+  const canonicalProjectRoot = canonicalizePath2(projectRoot);
   const indexPath = resolveProjectIndexPath(projectRoot, config.scope, host);
-  return `${canonicalizePath(indexPath)}::${canonicalProjectRoot}`;
+  return `${canonicalizePath2(indexPath)}::${canonicalProjectRoot}`;
 }
 function getProjectSafety(projectRoot, config) {
   if (isHomeDirectory(projectRoot)) {
@@ -14317,10 +15242,10 @@ function safeFailureMessage(error) {
 }
 function cancellableDelay(delayMs, signal) {
   if (signal.aborted) return Promise.reject(new AutoIndexCancelledError());
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve20();
+      resolve21();
     }, delayMs);
     timer.unref?.();
     const onAbort = () => {
@@ -14332,18 +15257,44 @@ function cancellableDelay(delayMs, signal) {
 }
 function withTimeout(promise, timeoutMs) {
   if (timeoutMs <= 0) return Promise.resolve(void 0);
-  return new Promise((resolve20) => {
-    const timer = setTimeout(() => resolve20(void 0), timeoutMs);
+  return new Promise((resolve21) => {
+    const timer = setTimeout(() => resolve21(void 0), timeoutMs);
     timer.unref?.();
     void promise.then((value) => {
       clearTimeout(timer);
-      resolve20(value);
+      resolve21(value);
     }, () => {
       clearTimeout(timer);
-      resolve20(void 0);
+      resolve21(void 0);
     });
   });
 }
+function settlesWithin(promise, timeoutMs) {
+  if (timeoutMs <= 0) return Promise.resolve(false);
+  return new Promise((resolve21) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve21(false);
+    }, timeoutMs);
+    timer.unref?.();
+    void promise.then(
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve21(true);
+      },
+      () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve21(true);
+      }
+    );
+  });
+}
 function requestPriority(request) {
   if (request.force) return 4;
   if (request.source === "manual") return 3;
@@ -14354,6 +15305,7 @@ function mergeRequests(current, next) {
   if (!current) return next;
   const preferred = requestPriority(next) > requestPriority(current) ? next : current;
   return {
+    allowDisabledAutoIndex: current.allowDisabledAutoIndex || next.allowDisabledAutoIndex,
     checkFreshness: current.checkFreshness && next.checkFreshness,
     force: current.force || next.force,
     onProgress: next.onProgress ?? current.onProgress,
@@ -14415,11 +15367,11 @@ var AutoIndexCoordinator = class {
       progress: this.status.progress ? { ...this.status.progress } : void 0
     };
   }
-  start(source) {
+  start(source, allowDisabledAutoIndex = false) {
     this.refreshSafety();
-    if (!this.registration.config.indexing.autoIndex || !this.registration.safeToRun) return null;
+    if (!this.registration.config.indexing.autoIndex && !allowDisabledAutoIndex || !this.registration.safeToRun) return null;
     if (this.status.state === "failed") return this.inFlight;
-    return this.request({ checkFreshness: true, force: false, source });
+    return this.request({ allowDisabledAutoIndex, checkFreshness: true, force: false, source });
   }
   request(request) {
     if (this.stopped) {
@@ -14494,13 +15446,15 @@ var AutoIndexCoordinator = class {
       retryAttempt: void 0
     });
     const inFlight = this.inFlight;
-    if (inFlight) {
-      if (waitForCompletion) {
-        await inFlight;
-      } else {
-        await withTimeout(inFlight, SHUTDOWN_WAIT_MS);
-      }
+    const completion = inFlight ? inFlight.then(() => void 0, () => void 0) : Promise.resolve();
+    if (!inFlight) {
+      return { completed: true, completion };
     }
+    if (waitForCompletion) {
+      await completion;
+      return { completed: true, completion };
+    }
+    return { completed: await settlesWithin(completion, SHUTDOWN_WAIT_MS), completion };
   }
   startRequest(request) {
     if (this.stopped || !this.canRun(request)) {
@@ -14689,7 +15643,7 @@ var AutoIndexCoordinator = class {
     if (request.source === "manual" || request.source === "watcher") {
       return true;
     }
-    return this.registration.safeToRun && this.registration.config.indexing.autoIndex;
+    return this.registration.safeToRun && (this.registration.config.indexing.autoIndex || request.allowDisabledAutoIndex === true);
   }
   shouldDeferForBattery(request) {
     return this.registration.backgroundIndexingPolicy !== null && (request.source === "startup" || request.source === "watcher");
@@ -14722,17 +15676,17 @@ var AutoIndexCoordinator = class {
     }
   }
   waitForBatteryRetry(delayMs) {
-    return new Promise((resolve20) => {
+    return new Promise((resolve21) => {
       const timer = setTimeout(() => {
         if (this.batteryRetryTimer === timer) {
           this.batteryRetryTimer = null;
           this.resolveBatteryRetry = null;
         }
-        resolve20();
+        resolve21();
       }, delayMs);
       timer.unref?.();
       this.batteryRetryTimer = timer;
-      this.resolveBatteryRetry = resolve20;
+      this.resolveBatteryRetry = resolve21;
     });
   }
   cancelBatteryRetry() {
@@ -14740,9 +15694,9 @@ var AutoIndexCoordinator = class {
       clearTimeout(this.batteryRetryTimer);
       this.batteryRetryTimer = null;
     }
-    const resolve20 = this.resolveBatteryRetry;
+    const resolve21 = this.resolveBatteryRetry;
     this.resolveBatteryRetry = null;
-    resolve20?.();
+    resolve21?.();
   }
   finishBatteryCheck(batteryCheck) {
     if (this.batteryCheck !== batteryCheck) return;
@@ -14755,12 +15709,25 @@ var AutoIndexCoordinator = class {
   }
 };
 function getCoordinator(projectRoot, host) {
-  const key = coordinatorKeysByProject.get(projectLookupKey(projectRoot, host));
+  const key = coordinatorKeysByProject.get(projectLookupKey2(projectRoot, host));
   return key ? coordinators.get(key) ?? null : null;
 }
-function configureAutoIndex(projectRoot, host, config, getIndexer) {
-  const projectKey = projectLookupKey(projectRoot, host);
+function synchronizeBackgroundWorker(projectRoot, host, config, safeToRun) {
+  if (safeToRun) {
+    updateBackgroundWorkerConfig(projectRoot, host, config);
+    return;
+  }
+  void stopBackgroundWorker(projectRoot, host).catch((error) => {
+    console.error("[codebase-index] Failed to stop background worker after project safety changed:", error);
+  });
+}
+function configureAutoIndex(projectRoot, host, config, getIndexer, options = {}) {
+  const projectKey = projectLookupKey2(projectRoot, host);
   const safety = getProjectSafety(projectRoot, config);
+  const synchronizeWorker = options.synchronizeBackgroundWorker ?? true;
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host)) {
+    return;
+  }
   const registration = {
     backgroundIndexingPolicy: createBackgroundIndexingPolicy(
       config.indexing.pauseBackgroundIndexingOnBattery
@@ -14778,6 +15745,9 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     const stopPrevious = previousCoordinator?.stop(true) ?? Promise.resolve();
     const activation = Promise.all([previousBarrier, stopPrevious]).then(() => void 0);
     coordinatorReplacementBarriers.set(projectKey, activation);
+    if (synchronizeWorker) {
+      synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+    }
     coordinators.delete(previousKey);
     const coordinator2 = new AutoIndexCoordinator(registration);
     coordinator2.activateAfter(activation);
@@ -14793,11 +15763,17 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
     coordinator.update(registration);
   }
   coordinatorKeysByProject.set(projectKey, key);
+  if (synchronizeWorker) {
+    synchronizeBackgroundWorker(projectRoot, host, config, safety.safeToRun);
+  }
 }
-function startAutoIndex(projectRoot, host, source = "startup") {
-  return getCoordinator(projectRoot, host)?.start(source) ?? null;
+function startAutoIndexForBackgroundWorker(projectRoot, host, source = "startup", allowDisabledAutoIndex = false) {
+  return getCoordinator(projectRoot, host)?.start(source, allowDisabledAutoIndex) ?? null;
 }
 function requestBackgroundIndex(projectRoot, host) {
+  if (isBackgroundWorkerManaged(projectRoot, host) && !isBackgroundWorkerLeader(projectRoot, host)) {
+    return null;
+  }
   return getCoordinator(projectRoot, host)?.request({
     checkFreshness: false,
     force: false,
@@ -14837,15 +15813,23 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     };
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) {
+      return { ready: true };
+    }
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
-  const job = coordinator.start("retrieval") ?? coordinator.currentJob();
+  const job = startRetrievalRefresh(projectRoot, host, coordinator);
   if (job) {
     await withTimeout(job, coordinator.getWaitMs());
+  } else if (isBackgroundWorkerManaged(projectRoot, host)) {
+    await waitForPublishedSnapshot(coordinator, coordinator.getWaitMs());
   }
   try {
-    if (await hasReadableCurrentIndex(coordinator)) return { ready: true };
+    const readiness = await getSearchReadiness(coordinator);
+    if (readiness.searchable) return { ready: true };
+    if (readiness.blocked) return unavailableSnapshotResult(readiness.reason);
   } catch {
   }
   const status = coordinator.snapshot();
@@ -14866,31 +15850,62 @@ async function waitForAutoIndexForRetrieval(projectRoot, host) {
     text: `Automatic indexing is ${status.state}. Retry shortly or call index_status for progress. You can also run index_codebase explicitly.`
   };
 }
-async function stopAutoIndex(projectRoot, host) {
-  await getCoordinator(projectRoot, host)?.stop();
+async function stopAutoIndexForBackgroundWorker(projectRoot, host, waitForCompletion = false) {
+  const coordinator = getCoordinator(projectRoot, host);
+  if (!coordinator) {
+    return { completed: true, completion: Promise.resolve() };
+  }
+  return coordinator.stop(waitForCompletion);
 }
-async function hasReadableCurrentIndex(coordinator) {
+async function getSearchReadiness(coordinator) {
   const indexer = coordinator.getIndexer();
   if (indexer.getIndexFreshness) {
     const freshness = await indexer.getIndexFreshness();
-    return freshness.readable && freshness.current;
+    const searchable = freshness.readable && freshness.current && freshness.reason === "current";
+    return {
+      blocked: freshness.reason === "unreadable" || freshness.reason === "incompatible" || freshness.reason === "failed-batches" || freshness.reason === "migration-required",
+      reason: freshness.reason,
+      searchable
+    };
+  }
+  const indexed = (await indexer.getStatus()).indexed;
+  return { blocked: false, searchable: indexed };
+}
+function unavailableSnapshotResult(reason) {
+  const detail = reason === "incompatible" ? "The existing index is incompatible with the configured embedding provider." : reason === "migration-required" ? "The existing index requires a storage migration." : reason === "failed-batches" ? "The existing index has failed embedding batches." : "The existing index is unreadable.";
+  return {
+    ready: false,
+    text: `${detail} Run index_codebase before retrying retrieval.`
+  };
+}
+function startRetrievalRefresh(projectRoot, host, coordinator) {
+  if (isBackgroundWorkerManaged(projectRoot, host)) {
+    requestBackgroundWorkerRefresh(projectRoot, host, true);
+    return isBackgroundWorkerLeader(projectRoot, host) ? coordinator.currentJob() : null;
+  }
+  return coordinator.start("retrieval") ?? coordinator.currentJob();
+}
+async function waitForPublishedSnapshot(coordinator, waitMs) {
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    if ((await getSearchReadiness(coordinator)).searchable) return;
+    await new Promise((resolve21) => setTimeout(resolve21, Math.min(250, deadline - Date.now())));
   }
-  return (await indexer.getStatus()).indexed;
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import * as path20 from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import * as path21 from "path";
 
 // src/config/merger.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import * as path19 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import * as path20 from "path";
 
 // src/config/rebase.ts
-import * as path18 from "path";
+import * as path19 from "path";
 function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path18.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path18.isAbsolute(relativePath);
+  const relativePath = path19.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path19.isAbsolute(relativePath);
 }
 function rebasePathEntries(values, fromDir, toDir) {
   if (!Array.isArray(values)) {
@@ -14898,10 +15913,10 @@ function rebasePathEntries(values, fromDir, toDir) {
   }
   return values.filter((value) => typeof value === "string").map((value) => {
     const trimmed = value.trim();
-    if (!trimmed || path18.isAbsolute(trimmed)) {
+    if (!trimmed || path19.isAbsolute(trimmed)) {
       return trimmed;
     }
-    return normalizePathSeparators(path18.normalize(path18.relative(toDir, path18.resolve(fromDir, trimmed))));
+    return normalizePathSeparators(path19.normalize(path19.relative(toDir, path19.resolve(fromDir, trimmed))));
   }).filter(Boolean);
 }
 function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
@@ -14913,17 +15928,17 @@ function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
     if (!trimmed) {
       return trimmed;
     }
-    if (path18.isAbsolute(trimmed)) {
+    if (path19.isAbsolute(trimmed)) {
       if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizePathSeparators(path18.normalize(path18.relative(sourceRoot, trimmed) || "."));
+        return normalizePathSeparators(path19.normalize(path19.relative(sourceRoot, trimmed) || "."));
       }
-      return path18.normalize(trimmed);
+      return path19.normalize(trimmed);
     }
-    const resolvedFromSource = path18.resolve(sourceRoot, trimmed);
+    const resolvedFromSource = path19.resolve(sourceRoot, trimmed);
     if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizePathSeparators(path18.normalize(trimmed));
+      return normalizePathSeparators(path19.normalize(trimmed));
     }
-    return normalizePathSeparators(path18.normalize(path18.relative(targetRoot, resolvedFromSource)));
+    return normalizePathSeparators(path19.normalize(path19.relative(targetRoot, resolvedFromSource)));
   }).filter(Boolean);
 }
 
@@ -14961,8 +15976,8 @@ function mergeUniqueStringArray(values) {
   return [...new Set(values.map((value) => String(value).trim()))];
 }
 function normalizeKnowledgeBasePath2(value) {
-  let normalized = path19.normalize(String(value).trim());
-  const root = path19.parse(normalized).root;
+  let normalized = path20.normalize(String(value).trim());
+  const root = path20.parse(normalized).root;
   while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
     normalized = normalized.slice(0, -1);
   }
@@ -14996,11 +16011,11 @@ function validateConfigLayerShape(rawConfig, filePath) {
   return rawConfig;
 }
 function loadJsonFile(filePath) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync11(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     return validateConfigLayerShape(JSON.parse(content), filePath);
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("Config file ")) {
@@ -15020,7 +16035,7 @@ function loadProjectConfigLayer(projectRoot, host) {
     return {};
   }
   const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path19.dirname(path19.dirname(projectConfigPath));
+  const projectConfigBaseDir = path20.dirname(path20.dirname(projectConfigPath));
   if (Array.isArray(normalizedConfig.knowledgeBases)) {
     normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
       normalizedConfig.knowledgeBases,
@@ -15110,10 +16125,10 @@ function loadEditableConfig(projectRoot, host) {
 }
 function saveConfig(projectRoot, config, host) {
   const configPath = getConfigPath(projectRoot, host);
-  const configDir = path20.dirname(configPath);
-  const configBaseDir = path20.dirname(configDir);
-  if (!existsSync11(configDir)) {
-    mkdirSync5(configDir, { recursive: true });
+  const configDir = path21.dirname(configPath);
+  const configBaseDir = path21.dirname(configDir);
+  if (!existsSync12(configDir)) {
+    mkdirSync6(configDir, { recursive: true });
   }
   const serializableConfig = { ...config };
   if (Array.isArray(serializableConfig.knowledgeBases)) {
@@ -15121,7 +16136,7 @@ function saveConfig(projectRoot, config, host) {
       (kb) => serializeConfigPathValue(kb, configBaseDir)
     );
   }
-  writeFileSync4(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+  writeFileSync5(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/tools/operation-runtime.ts
@@ -15200,15 +16215,24 @@ function getOrCreateIndexer(projectRoot, host) {
   }
   const indexer = new Indexer(projectRoot, config, host);
   indexerCache.set(key, indexer);
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: true,
+    synchronizeBackgroundWorker: false
+  });
   return indexer;
 }
-function initializeTools(projectRoot, config, host) {
+function initializeTools(projectRoot, config, host, options = {}) {
   defaultProjectRoots.set(host, projectRoot);
   const key = getIndexerCacheKey(projectRoot, host);
+  if (options.preserveManagedWorker === true && isBackgroundWorkerManaged(projectRoot, host) && indexerCache.has(key)) {
+    return;
+  }
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    preserveManagedWorker: options.preserveManagedWorker,
+    synchronizeBackgroundWorker: false
+  });
 }
 function getIndexerForProject(projectRoot, host) {
   const root = getProjectRoot(projectRoot, host);
@@ -15222,7 +16246,9 @@ function refreshIndexerForDirectory(projectRoot, host, config = parseConfig(load
   const key = getIndexerCacheKey(projectRoot, host);
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
-  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
+  configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host), {
+    synchronizeBackgroundWorker: true
+  });
   return config;
 }
 var AutoIndexRetrievalUnavailableError = class extends Error {
@@ -15249,7 +16275,7 @@ function trimOrUndefined(value) {
   return normalized || void 0;
 }
 function normalizeCallGraphPath(value) {
-  let normalized = path21.posix.normalize(value.trim().replaceAll("\\", "/"));
+  let normalized = path22.posix.normalize(value.trim().replaceAll("\\", "/"));
   if (normalized.startsWith("./")) {
     normalized = normalized.slice(2);
   }
@@ -15442,12 +16468,12 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth, fromFileP
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path33 = await indexer.findCallPathBySymbolIds(
+  const path34 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path33 };
+  return { from: fromResolution, to: toResolution, path: path34 };
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
@@ -15645,15 +16671,15 @@ async function getIndexLogs(projectRoot, host, args) {
 function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath3 = path21.resolve(
-    path21.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  const normalizedPath3 = path22.resolve(
+    path22.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
-  if (!existsSync12(normalizedPath3)) {
+  if (!existsSync13(normalizedPath3)) {
     return `Error: Directory does not exist: ${normalizedPath3}`;
   }
   let realPath;
   try {
-    realPath = realpathSync5(normalizedPath3);
+    realPath = realpathSync6(normalizedPath3);
   } catch {
     return `Error: Cannot resolve path: ${normalizedPath3}`;
   }
@@ -15682,7 +16708,7 @@ function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path21.join(homeDir, dotDir);
+    const sensitiveDir = path22.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath3}`;
     }
@@ -15728,7 +16754,7 @@ function listKnowledgeBases(projectRoot, host) {
   for (let i = 0; i < knowledgeBases.length; i++) {
     const kb = knowledgeBases[i];
     const resolvedPath = resolveKnowledgeBasePath(kb, root);
-    const exists = existsSync12(resolvedPath);
+    const exists = existsSync13(resolvedPath);
     result += `[${i + 1}] ${kb}
 `;
     result += `    Resolved: ${resolvedPath}
@@ -15745,7 +16771,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync12(path21.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync13(path22.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -16218,7 +17244,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path33 = await getCallGraphPath(
+    const path34 = await getCallGraphPath(
       projectRoot,
       host,
       from,
@@ -16227,25 +17253,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path33);
-    if (path33.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path34);
+    if (path34.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path33.path.length)
+        details: fittedDetails("path", fitted2, path34.path.length)
       };
     }
-    if (path33.from.status !== "resolved" || path33.to.status !== "resolved") {
+    if (path34.from.status !== "resolved" || path34.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path33.from;
+    const resolvedFrom = path34.from;
     const { callers } = await getCallGraphData(projectRoot, host, {
       name: to,
       direction: "callers",
@@ -16723,9 +17749,9 @@ function getRelevantEvidence(query) {
     });
   }
   if (query.expected.acceptableFiles) {
-    for (const path33 of query.expected.acceptableFiles) {
+    for (const path34 of query.expected.acceptableFiles) {
       legacyEvidence.push({
-        path: path33,
+        path: path34,
         ...query.expected.symbol !== void 0 ? { symbol: query.expected.symbol } : {},
         relevance: 1
       });
@@ -17047,9 +18073,9 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
 }
 
 // src/eval/runner-config.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import * as os7 from "os";
-import * as path22 from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import * as os8 from "os";
+import * as path23 from "path";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -17083,7 +18109,7 @@ function validateEvalConfigShape(rawConfig, filePath) {
 }
 function parseJsonConfigFile(filePath) {
   try {
-    return validateEvalConfigShape(JSON.parse(readFileSync10(filePath, "utf-8")), filePath);
+    return validateEvalConfigShape(JSON.parse(readFileSync11(filePath, "utf-8")), filePath);
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("Eval config at ")) {
       throw error;
@@ -17093,20 +18119,20 @@ function parseJsonConfigFile(filePath) {
   }
 }
 function toAbsolute(projectRoot, maybeRelative) {
-  return path22.isAbsolute(maybeRelative) ? maybeRelative : path22.join(projectRoot, maybeRelative);
+  return path23.isAbsolute(maybeRelative) ? maybeRelative : path23.join(projectRoot, maybeRelative);
 }
 function isProjectScopedConfigPath(configPath) {
-  return path22.basename(configPath) === "codebase-index.json" && path22.basename(path22.dirname(configPath)) === ".opencode";
+  return path23.basename(configPath) === "codebase-index.json" && path23.basename(path23.dirname(configPath)) === ".opencode";
 }
 function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
   const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
   const rebaseEntries = (values) => isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
     values,
-    path22.dirname(path22.dirname(resolvedConfigPath)),
+    path23.dirname(path23.dirname(resolvedConfigPath)),
     projectRoot
   ) : rebasePathEntries(
     values,
-    path22.dirname(resolvedConfigPath),
+    path23.dirname(resolvedConfigPath),
     projectRoot
   );
   if (Array.isArray(config.knowledgeBases)) {
@@ -17119,7 +18145,7 @@ function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfi
 }
 function loadRawConfig(projectRoot, configPath) {
   const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
-  if (fromPath && existsSync13(fromPath)) {
+  if (fromPath && existsSync14(fromPath)) {
     return normalizeEvalConfigKnowledgeBases(
       parseJsonConfigFile(fromPath),
       projectRoot,
@@ -17127,15 +18153,15 @@ function loadRawConfig(projectRoot, configPath) {
     );
   }
   const projectConfig = resolveProjectConfigPath(projectRoot, "opencode");
-  if (existsSync13(projectConfig)) {
+  if (existsSync14(projectConfig)) {
     return normalizeEvalConfigKnowledgeBases(
       parseJsonConfigFile(projectConfig),
       projectRoot,
       projectConfig
     );
   }
-  const globalConfig = path22.join(os7.homedir(), ".config", "opencode", "codebase-index.json");
-  if (existsSync13(globalConfig)) {
+  const globalConfig = path23.join(os8.homedir(), ".config", "opencode", "codebase-index.json");
+  if (existsSync14(globalConfig)) {
     return parseJsonConfigFile(globalConfig);
   }
   return {};
@@ -17144,24 +18170,24 @@ function getIndexRootPath(projectRoot, scope) {
   return scope === "global" ? getGlobalIndexPath("opencode") : resolveProjectIndexPath(projectRoot, scope, "opencode");
 }
 function getLocalProjectIndexRoot(projectRoot) {
-  return path22.join(projectRoot, ".opencode", "index");
+  return path23.join(projectRoot, ".opencode", "index");
 }
 function getLocalProjectConfigPath(projectRoot) {
-  return path22.join(projectRoot, ".opencode", "codebase-index.json");
+  return path23.join(projectRoot, ".opencode", "codebase-index.json");
 }
 function clearIndexRoot(projectRoot, scope) {
   const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
-  if (existsSync13(indexRoot)) {
-    rmSync3(indexRoot, { recursive: true, force: true });
+  if (existsSync14(indexRoot)) {
+    rmSync4(indexRoot, { recursive: true, force: true });
   }
 }
 function ensureLocalEvalProjectConfig(projectRoot, configPath) {
   const localConfigPath = getLocalProjectConfigPath(projectRoot);
   const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot, "opencode");
-  if (!configPath && existsSync13(localConfigPath)) {
+  if (!configPath && existsSync14(localConfigPath)) {
     return localConfigPath;
   }
-  if (!existsSync13(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
+  if (!existsSync14(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
     return resolvedConfigPath;
   }
   const sourceConfig = normalizeEvalConfigKnowledgeBases(
@@ -17169,8 +18195,8 @@ function ensureLocalEvalProjectConfig(projectRoot, configPath) {
     projectRoot,
     resolvedConfigPath
   );
-  mkdirSync6(path22.dirname(localConfigPath), { recursive: true });
-  writeFileSync5(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
+  mkdirSync7(path23.dirname(localConfigPath), { recursive: true });
+  writeFileSync6(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
   return localConfigPath;
 }
 function loadParsedConfig(projectRoot, configPath) {
@@ -17203,9 +18229,9 @@ function getEmbeddingCostPer1MTokens(embeddingProvider) {
 }
 
 // src/eval/schema.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 function parseJsonFile(filePath) {
-  const content = readFileSync11(filePath, "utf-8");
+  const content = readFileSync12(filePath, "utf-8");
   try {
     return JSON.parse(content);
   } catch (error) {
@@ -17222,68 +18248,68 @@ function isStringArray4(value) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function asPositiveNumber(value, path33) {
+function asPositiveNumber(value, path34) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path33} must be a non-negative number`);
+    throw new Error(`${path34} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path33) {
+function parseQueryType(value, path34) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy" || value === "conceptual") {
     return value;
   }
   throw new Error(
-    `${path33} must be one of: definition, implementation-intent, similarity, keyword-heavy, conceptual`
+    `${path34} must be one of: definition, implementation-intent, similarity, keyword-heavy, conceptual`
   );
 }
-function parseExpectedRoute(value, path33) {
+function parseExpectedRoute(value, path34) {
   if (value === void 0) return void 0;
   if (value === "search" || value === "definition") return value;
-  throw new Error(`${path33} must be one of: search, definition`);
+  throw new Error(`${path34} must be one of: search, definition`);
 }
-function parseExpectedOutcome(value, path33) {
+function parseExpectedOutcome(value, path34) {
   if (value === void 0) return void 0;
   if (value === "results" || value === "no-results") {
     return value;
   }
-  throw new Error(`${path33} must be one of: results, no-results`);
+  throw new Error(`${path34} must be one of: results, no-results`);
 }
-function parseRecoveryExpectation(value, path33) {
+function parseRecoveryExpectation(value, path34) {
   if (value === void 0) return void 0;
   if (value === "none" || value === "filter-relaxed") {
     return value;
   }
-  throw new Error(`${path33} must be one of: none, filter-relaxed`);
+  throw new Error(`${path34} must be one of: none, filter-relaxed`);
 }
-function parseQueryDifficulty(value, path33) {
+function parseQueryDifficulty(value, path34) {
   if (value === void 0) return void 0;
   if (value === "easy" || value === "medium" || value === "hard") {
     return value;
   }
-  throw new Error(`${path33} must be one of: easy, medium, hard`);
+  throw new Error(`${path34} must be one of: easy, medium, hard`);
 }
-function parseQueryTags(value, path33) {
+function parseQueryTags(value, path34) {
   if (value === void 0) return void 0;
   if (!isStringArray4(value) || value.some((tag) => tag.trim().length === 0)) {
-    throw new Error(`${path33} must be an array of non-empty strings`);
+    throw new Error(`${path34} must be an array of non-empty strings`);
   }
   if (value.length > 16) {
-    throw new Error(`${path33} must contain at most 16 tags`);
+    throw new Error(`${path34} must contain at most 16 tags`);
   }
   return value;
 }
-function parseQueryArgs(value, path33) {
+function parseQueryArgs(value, path34) {
   if (value === void 0) return void 0;
   if (!isRecord3(value)) {
-    throw new Error(`${path33} must be an object`);
-  }
-  const symbol = parseStringOrUndefined(value.symbol, `${path33}.symbol`);
-  const filePath = parseStringOrUndefined(value.filePath, `${path33}.filePath`);
-  const fileType = parseStringOrUndefined(value.fileType, `${path33}.fileType`);
-  const directory = parseStringOrUndefined(value.directory, `${path33}.directory`);
-  const callerLimit = parsePositiveIntegerOrUndefined(value.callerLimit, `${path33}.callerLimit`);
-  const calleeLimit = parsePositiveIntegerOrUndefined(value.calleeLimit, `${path33}.calleeLimit`);
-  const tokenBudget = parsePositiveIntegerOrUndefined(value.tokenBudget, `${path33}.tokenBudget`);
+    throw new Error(`${path34} must be an object`);
+  }
+  const symbol = parseStringOrUndefined(value.symbol, `${path34}.symbol`);
+  const filePath = parseStringOrUndefined(value.filePath, `${path34}.filePath`);
+  const fileType = parseStringOrUndefined(value.fileType, `${path34}.fileType`);
+  const directory = parseStringOrUndefined(value.directory, `${path34}.directory`);
+  const callerLimit = parsePositiveIntegerOrUndefined(value.callerLimit, `${path34}.callerLimit`);
+  const calleeLimit = parsePositiveIntegerOrUndefined(value.calleeLimit, `${path34}.calleeLimit`);
+  const tokenBudget = parsePositiveIntegerOrUndefined(value.tokenBudget, `${path34}.tokenBudget`);
   return {
     ...symbol !== void 0 ? { symbol } : {},
     ...filePath !== void 0 ? { filePath } : {},
@@ -17294,50 +18320,50 @@ function parseQueryArgs(value, path33) {
     ...tokenBudget !== void 0 ? { tokenBudget } : {}
   };
 }
-function parsePositiveIntegerOrUndefined(value, path33) {
+function parsePositiveIntegerOrUndefined(value, path34) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    throw new Error(`${path33} must be a positive integer`);
+    throw new Error(`${path34} must be a positive integer`);
   }
   return value;
 }
 var SEMVER_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function parseSemanticVersion(value, path33) {
+function parseSemanticVersion(value, path34) {
   if (!isNonEmptyString(value)) {
-    throw new Error(`${path33} must be a non-empty string`);
+    throw new Error(`${path34} must be a non-empty string`);
   }
   if (!SEMVER_VERSION_PATTERN.test(value)) {
-    throw new Error(`${path33} must be a valid semantic version (MAJOR.MINOR.PATCH)`);
+    throw new Error(`${path34} must be a valid semantic version (MAJOR.MINOR.PATCH)`);
   }
   return value;
 }
-function parseRetrievalMode(value, path33) {
+function parseRetrievalMode(value, path34) {
   if (value === void 0 || value === "search") return "search";
   if (value === "context" || value === "edit-context") return value;
-  throw new Error(`${path33} must be one of: search, context, edit-context`);
+  throw new Error(`${path34} must be one of: search, context, edit-context`);
 }
-function parseStringOrUndefined(value, path33) {
+function parseStringOrUndefined(value, path34) {
   if (value === void 0 || value === null) return void 0;
   if (!isNonEmptyString(value)) {
-    throw new Error(`${path33} must be a non-empty string`);
+    throw new Error(`${path34} must be a non-empty string`);
   }
   return value;
 }
-function parseGradedEvidence(value, path33) {
+function parseGradedEvidence(value, path34) {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
-    throw new Error(`${path33} must be an array`);
+    throw new Error(`${path34} must be an array`);
   }
   return value.map((entry, index) => {
     if (!isRecord3(entry)) {
-      throw new Error(`${path33}[${index}] must be an object`);
+      throw new Error(`${path34}[${index}] must be an object`);
     }
-    const evidencePath = parseStringOrUndefined(entry.path, `${path33}[${index}].path`);
+    const evidencePath = parseStringOrUndefined(entry.path, `${path34}[${index}].path`);
     if (evidencePath === void 0) {
-      throw new Error(`${path33}[${index}].path is required`);
+      throw new Error(`${path34}[${index}].path is required`);
     }
-    const symbol = parseStringOrUndefined(entry.symbol, `${path33}[${index}].symbol`);
-    const relevance = parseEvidenceRelevance(entry.relevance, `${path33}[${index}].relevance`);
+    const symbol = parseStringOrUndefined(entry.symbol, `${path34}[${index}].symbol`);
+    const relevance = parseEvidenceRelevance(entry.relevance, `${path34}[${index}].relevance`);
     return {
       path: evidencePath,
       ...symbol !== void 0 ? { symbol } : {},
@@ -17345,27 +18371,27 @@ function parseGradedEvidence(value, path33) {
     };
   });
 }
-function parseEvidenceRelevance(value, path33) {
+function parseEvidenceRelevance(value, path34) {
   if (value === void 0) {
-    throw new Error(`${path33} is required`);
+    throw new Error(`${path34} is required`);
   }
   if (value !== 1 && value !== 2 && value !== 3) {
-    throw new Error(`${path33} must be 1, 2, or 3`);
+    throw new Error(`${path34} must be 1, 2, or 3`);
   }
   return value;
 }
-function parseExpectedGraphNeighbor(value, path33) {
+function parseExpectedGraphNeighbor(value, path34) {
   if (value === void 0) return void 0;
   if (!isRecord3(value)) {
-    throw new Error(`${path33} must be an object`);
+    throw new Error(`${path34} must be an object`);
   }
   if (value.direction !== "caller" && value.direction !== "callee") {
-    throw new Error(`${path33}.direction must be one of: caller, callee`);
+    throw new Error(`${path34}.direction must be one of: caller, callee`);
   }
-  const filePath = parseStringOrUndefined(value.filePath, `${path33}.filePath`);
-  const symbol = parseStringOrUndefined(value.symbol, `${path33}.symbol`);
+  const filePath = parseStringOrUndefined(value.filePath, `${path34}.filePath`);
+  const symbol = parseStringOrUndefined(value.symbol, `${path34}.symbol`);
   if (filePath === void 0 && symbol === void 0) {
-    throw new Error(`${path33} must include filePath or symbol`);
+    throw new Error(`${path34} must include filePath or symbol`);
   }
   return {
     direction: value.direction,
@@ -17373,9 +18399,9 @@ function parseExpectedGraphNeighbor(value, path33) {
     ...symbol !== void 0 ? { symbol } : {}
   };
 }
-function parseExpected(input, path33) {
+function parseExpected(input, path34) {
   if (!isRecord3(input)) {
-    throw new Error(`${path33} must be an object`);
+    throw new Error(`${path34} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -17386,29 +18412,29 @@ function parseExpected(input, path33) {
   const recoveryExpectationRaw = input.recoveryExpectation;
   const gradedEvidenceRaw = input.gradedEvidence;
   const graphNeighborRaw = input.graphNeighbor;
-  const filePath = parseStringOrUndefined(filePathRaw, `${path33}.filePath`);
+  const filePath = parseStringOrUndefined(filePathRaw, `${path34}.filePath`);
   const acceptableFiles = isStringArray4(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
-  const gradedEvidence = parseGradedEvidence(gradedEvidenceRaw, `${path33}.gradedEvidence`);
-  const graphNeighbor = parseExpectedGraphNeighbor(graphNeighborRaw, `${path33}.graphNeighbor`);
-  const expectedOutcome = parseExpectedOutcome(expectedOutcomeRaw, `${path33}.expectedOutcome`);
+  const gradedEvidence = parseGradedEvidence(gradedEvidenceRaw, `${path34}.gradedEvidence`);
+  const graphNeighbor = parseExpectedGraphNeighbor(graphNeighborRaw, `${path34}.graphNeighbor`);
+  const expectedOutcome = parseExpectedOutcome(expectedOutcomeRaw, `${path34}.expectedOutcome`);
   if (expectedOutcome !== "no-results" && !filePath && (!acceptableFiles || acceptableFiles.length === 0) && gradedEvidence.length === 0) {
     throw new Error(
-      `${path33} must include expected.filePath, expected.acceptableFiles, or expected.gradedEvidence`
+      `${path34} must include expected.filePath, expected.acceptableFiles, or expected.gradedEvidence`
     );
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray4(acceptableFilesRaw)) {
-    throw new Error(`${path33}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path34}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path33}.symbol must be a string when provided`);
+    throw new Error(`${path34}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path33}.branch must be a string when provided`);
+    throw new Error(`${path34}.branch must be a string when provided`);
   }
-  const expectedRoute = parseExpectedRoute(expectedRouteRaw, `${path33}.expectedRoute`);
+  const expectedRoute = parseExpectedRoute(expectedRouteRaw, `${path34}.expectedRoute`);
   const recoveryExpectation = parseRecoveryExpectation(
     recoveryExpectationRaw,
-    `${path33}.recoveryExpectation`
+    `${path34}.recoveryExpectation`
   );
   return {
     filePath,
@@ -17422,13 +18448,13 @@ function parseExpected(input, path33) {
     ...graphNeighbor !== void 0 ? { graphNeighbor } : {}
   };
 }
-function parseQueryLanguage(value, path33) {
-  return parseStringOrUndefined(value, path33);
+function parseQueryLanguage(value, path34) {
+  return parseStringOrUndefined(value, path34);
 }
 function parseQuery(input, index) {
-  const path33 = `queries[${index}]`;
+  const path34 = `queries[${index}]`;
   if (!isRecord3(input)) {
-    throw new Error(`${path33} must be an object`);
+    throw new Error(`${path34} must be an object`);
   }
   const id = input.id;
   const query = input.query;
@@ -17440,21 +18466,21 @@ function parseQuery(input, index) {
   const tags = input.tags;
   const args = input.args;
   if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error(`${path33}.id must be a non-empty string`);
+    throw new Error(`${path34}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path33}.query must be a non-empty string`);
+    throw new Error(`${path34}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path33}.queryType`),
-    retrievalMode: parseRetrievalMode(retrievalMode, `${path33}.retrievalMode`),
-    language: parseQueryLanguage(language, `${path33}.language`),
-    difficulty: parseQueryDifficulty(difficulty, `${path33}.difficulty`),
-    args: parseQueryArgs(args, `${path33}.args`),
-    tags: parseQueryTags(tags, `${path33}.tags`),
-    expected: parseExpected(expected, `${path33}.expected`)
+    queryType: parseQueryType(queryType, `${path34}.queryType`),
+    retrievalMode: parseRetrievalMode(retrievalMode, `${path34}.retrievalMode`),
+    language: parseQueryLanguage(language, `${path34}.language`),
+    difficulty: parseQueryDifficulty(difficulty, `${path34}.difficulty`),
+    args: parseQueryArgs(args, `${path34}.args`),
+    tags: parseQueryTags(tags, `${path34}.tags`),
+    expected: parseExpected(expected, `${path34}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -17870,13 +18896,13 @@ async function runEvaluation(options) {
     };
     const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
     const perQueryArtifact = buildPerQueryArtifact(perQuery);
-    writeJson(path23.join(outputDir, "summary.json"), summary);
-    writeJson(path23.join(outputDir, "per-query.json"), perQueryArtifact);
+    writeJson(path24.join(outputDir, "summary.json"), summary);
+    writeJson(path24.join(outputDir, "per-query.json"), perQueryArtifact);
     let comparison;
     if (againstPath) {
       const baseline = loadSummary(againstPath);
       comparison = compareSummaries(summary, baseline, againstPath);
-      writeJson(path23.join(outputDir, "compare.json"), comparison);
+      writeJson(path24.join(outputDir, "compare.json"), comparison);
     }
     let gate;
     if (options.ciMode) {
@@ -17886,10 +18912,10 @@ async function runEvaluation(options) {
       const budget = loadBudget(budgetPath);
       if (!comparison && budget.baselinePath) {
         const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
-        if (existsSync14(resolvedBaseline)) {
+        if (existsSync15(resolvedBaseline)) {
           const baselineSummary = loadSummary(resolvedBaseline);
           comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
-          writeJson(path23.join(outputDir, "compare.json"), comparison);
+          writeJson(path24.join(outputDir, "compare.json"), comparison);
         } else if (budget.failOnMissingBaseline) {
           throw new Error(
             `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
@@ -17899,7 +18925,7 @@ async function runEvaluation(options) {
       gate = evaluateBudgetGate(budget, summary, comparison);
     }
     const markdown = createSummaryMarkdown(summary, comparison, gate);
-    writeText(path23.join(outputDir, "summary.md"), markdown);
+    writeText(path24.join(outputDir, "summary.md"), markdown);
     return { outputDir, summary, perQuery, comparison, gate };
   } finally {
     await indexer.close();
@@ -17957,23 +18983,23 @@ async function runSweep(options, sweep) {
     bestByMrrAt10,
     bestByP95Latency
   };
-  writeJson(path23.join(outputDir, "compare.json"), aggregate);
+  writeJson(path24.join(outputDir, "compare.json"), aggregate);
   const md = createSummaryMarkdown(
     bestByHitAt5?.summary ?? runs[0].summary,
     bestByHitAt5?.comparison,
     void 0,
     aggregate
   );
-  writeText(path23.join(outputDir, "summary.md"), md);
-  writeJson(path23.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  writeText(path24.join(outputDir, "summary.md"), md);
+  writeJson(path24.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
   return { outputDir, aggregate };
 }
 
 // src/eval/cli.ts
-import * as path25 from "path";
+import * as path26 from "path";
 
 // src/eval/cli-parser.ts
-import * as path24 from "path";
+import * as path25 from "path";
 function printUsage() {
   console.log(`
 Usage:
@@ -18045,12 +19071,12 @@ function parseEvalArgs(argv, cwd) {
     const arg = argv[i];
     const next = argv[i + 1];
     if (arg === "--project" && next) {
-      parsed.projectRoot = path24.resolve(cwd, next);
+      parsed.projectRoot = path25.resolve(cwd, next);
       i += 1;
       continue;
     }
     if (arg === "--config" && next) {
-      parsed.configPath = path24.resolve(cwd, next);
+      parsed.configPath = path25.resolve(cwd, next);
       i += 1;
       continue;
     }
@@ -18246,22 +19272,22 @@ async function handleEvalCommand(args, cwd) {
     if (!parsed.againstPath.endsWith(".json")) {
       throw new Error("eval diff --against must point to a summary JSON file");
     }
-    const currentSummary = loadSummary(path25.resolve(parsed.projectRoot, currentPath), {
+    const currentSummary = loadSummary(path26.resolve(parsed.projectRoot, currentPath), {
       allowLegacyDiversityMetrics: true
     });
-    const baselineSummary = loadSummary(path25.resolve(parsed.projectRoot, parsed.againstPath), {
+    const baselineSummary = loadSummary(path26.resolve(parsed.projectRoot, parsed.againstPath), {
       allowLegacyDiversityMetrics: true
     });
     const comparison = compareSummaries(
       currentSummary,
       baselineSummary,
-      path25.resolve(parsed.projectRoot, parsed.againstPath)
+      path26.resolve(parsed.projectRoot, parsed.againstPath)
     );
-    const outputDir = createRunDirectory(path25.resolve(parsed.projectRoot, parsed.outputRoot));
+    const outputDir = createRunDirectory(path26.resolve(parsed.projectRoot, parsed.outputRoot));
     const summaryMd = createSummaryMarkdown(currentSummary, comparison);
-    writeJson(path25.join(outputDir, "compare.json"), comparison);
-    writeText(path25.join(outputDir, "summary.md"), summaryMd);
-    writeJson(path25.join(outputDir, "summary.json"), currentSummary);
+    writeJson(path26.join(outputDir, "compare.json"), comparison);
+    writeText(path26.join(outputDir, "summary.md"), summaryMd);
+    writeJson(path26.join(outputDir, "summary.json"), currentSummary);
     console.log(`Eval diff complete. Artifacts: ${outputDir}`);
     return 0;
   }
@@ -18272,9 +19298,9 @@ async function handleEvalCommand(args, cwd) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/package-metadata.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 function getPackageVersion() {
-  const raw = JSON.parse(readFileSync12(new URL("../package.json", import.meta.url), "utf-8"));
+  const raw = JSON.parse(readFileSync13(new URL("../package.json", import.meta.url), "utf-8"));
   if (raw && typeof raw === "object" && "version" in raw && typeof raw.version === "string") {
     return raw.version;
   }
@@ -18422,7 +19448,7 @@ async function executeCallGraph(projectRoot, host, args) {
   return { text: formatCallGraphResult(await getCallGraphData(projectRoot, host, args)) };
 }
 async function executeCallGraphPath(projectRoot, host, args) {
-  const path33 = await getCallGraphPath(
+  const path34 = await getCallGraphPath(
     projectRoot,
     host,
     args.from,
@@ -18431,7 +19457,7 @@ async function executeCallGraphPath(projectRoot, host, args) {
     args.fromFilePath,
     args.toFilePath
   );
-  return { text: formatCallGraphPathResult(path33) };
+  return { text: formatCallGraphPathResult(path34) };
 }
 async function executeCodeCommunities(projectRoot, host, args) {
   const result = await getCodeCommunities(projectRoot, host, args);
@@ -18926,10 +19952,65 @@ ${formatSearchResults(results)}` }] };
 }
 
 // src/adapters/mcp/server.ts
+var mcpWorkerReferences = /* @__PURE__ */ new Map();
+var mcpWorkerTeardowns = /* @__PURE__ */ new Map();
+function retainMcpBackgroundWorker(projectRoot, host) {
+  const key = getBackgroundWorkerProjectKey(projectRoot, host);
+  mcpWorkerReferences.set(key, (mcpWorkerReferences.get(key) ?? 0) + 1);
+}
+async function releaseMcpBackgroundWorker(projectRoot, host) {
+  const key = getBackgroundWorkerProjectKey(projectRoot, host);
+  const references = mcpWorkerReferences.get(key) ?? 0;
+  if (references > 1) {
+    mcpWorkerReferences.set(key, references - 1);
+    return;
+  }
+  mcpWorkerReferences.delete(key);
+  const teardown = stopBackgroundWorker(projectRoot, host);
+  mcpWorkerTeardowns.set(key, teardown);
+  try {
+    await teardown;
+  } finally {
+    if (mcpWorkerTeardowns.get(key) === teardown) {
+      mcpWorkerTeardowns.delete(key);
+    }
+  }
+}
 function getServerInstructions(host) {
   const hostText = `host ${host}`;
   return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns a token-budgeted location pack and routes to definitions or call-graph helpers when symbol intent is present. For code changes with a known or suspected symbol target, optionally call codebase_edit_context as a compact pre-edit step for bounded source plus direct callers and callees before broad file reads. Keep the default tokenBudget for normal discovery, then use implementation_lookup, codebase_search, or a targeted file read only for selected locations that need source content. Use codebase_peek for direct conceptual location lookup. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
 }
+function configureMcpBackgroundWorker(projectRoot, config, host, watcherFactory, watcherFactoryForConfig) {
+  if (!getProjectSafety(projectRoot, config).safeToRun) {
+    return { managesWorker: false };
+  }
+  if (isBackgroundWorkerManaged(projectRoot, host)) {
+    const key = getBackgroundWorkerProjectKey(projectRoot, host);
+    if ((mcpWorkerReferences.get(key) ?? 0) === 0 && !mcpWorkerTeardowns.has(key)) {
+      return { managesWorker: false };
+    }
+    if (watcherFactory !== void 0) {
+      attachBackgroundWorkerWatcher(projectRoot, host, watcherFactory, watcherFactoryForConfig);
+    }
+    if (mcpWorkerTeardowns.has(key) || isBackgroundWorkerStopping(projectRoot, host)) {
+      requestBackgroundWorker(projectRoot, host);
+    }
+    return { managesWorker: true };
+  }
+  configureBackgroundWorker(projectRoot, host, config, {
+    startAutoIndex: (source, allowDisabledAutoIndex) => {
+      startAutoIndexForBackgroundWorker(projectRoot, host, source, allowDisabledAutoIndex);
+    },
+    stopAutoIndex: () => stopAutoIndexForBackgroundWorker(projectRoot, host),
+    watcherFactory,
+    watcherFactoryForConfig
+  });
+  return { managesWorker: true };
+}
+function attachMcpBackgroundWatcher(projectRoot, config, host, watcherFactory, watcherFactoryForConfig) {
+  configureMcpBackgroundWorker(projectRoot, config, host, watcherFactory, watcherFactoryForConfig);
+  return waitForBackgroundWorkerStart(projectRoot, host);
+}
 function createMcpServer(projectRoot, config, host) {
   const server = new McpServer({
     name: MCP_SERVER_CURRENT_NAME,
@@ -18937,11 +20018,14 @@ function createMcpServer(projectRoot, config, host) {
   }, {
     instructions: getServerInstructions(host)
   });
-  initializeTools(projectRoot, config, host);
-  startAutoIndex(projectRoot, host, "startup");
+  initializeTools(projectRoot, config, host, { preserveManagedWorker: true });
+  const backgroundWorker = configureMcpBackgroundWorker(projectRoot, config, host);
+  if (backgroundWorker.managesWorker) {
+    retainMcpBackgroundWorker(projectRoot, host);
+  }
   let stopCoordinationPromise = null;
   const stopCoordination = () => {
-    stopCoordinationPromise ??= stopAutoIndex(projectRoot, host);
+    stopCoordinationPromise ??= backgroundWorker.managesWorker ? releaseMcpBackgroundWorker(projectRoot, host) : Promise.resolve();
     return stopCoordinationPromise;
   };
   const closeProtocol = server.server.close.bind(server.server);
@@ -18957,7 +20041,9 @@ function createMcpServer(projectRoot, config, host) {
   const onServerClose = server.server.onclose;
   server.server.onclose = () => {
     onServerClose?.();
-    void stopCoordination();
+    void stopCoordination().catch((error) => {
+      console.error("[codebase-index] Failed to stop MCP background worker after transport close:", error);
+    });
   };
   registerMcpTools(server, {
     projectRoot,
@@ -18968,7 +20054,7 @@ function createMcpServer(projectRoot, config, host) {
 }
 
 // src/watcher/file-watcher.ts
-import { existsSync as existsSync15, statSync as statSync6 } from "fs";
+import { existsSync as existsSync16, statSync as statSync6 } from "fs";
 
 // node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter2 } from "events";
@@ -19060,7 +20146,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path33) => statMethod(path33, { bigint: true });
+      this._stat = (path34) => statMethod(path34, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -19085,8 +20171,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path33, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path33));
+          const { path: path34, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path34));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -19126,21 +20212,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path33, depth) {
+  async _exploreDir(path34, depth) {
     let files;
     try {
-      files = await readdir(path33, this._rdOptions);
+      files = await readdir(path34, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path33 };
+    return { files, depth, path: path34 };
   }
-  async _formatEntry(dirent, path33) {
+  async _formatEntry(dirent, path34) {
     let entry;
-    const basename8 = this._isDirent ? dirent.name : dirent;
+    const basename9 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path33, basename8));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename8 };
+      const fullPath = presolve(pjoin(path34, basename9));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -19539,16 +20625,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path33, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path34, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path33);
-    emitRaw(rawEvent, evPath, { watchedPath: path33 });
-    if (evPath && path33 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path33, evPath), KEY_LISTENERS, sp.join(path33, evPath));
+    listener(path34);
+    emitRaw(rawEvent, evPath, { watchedPath: path34 });
+    if (evPath && path34 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path34, evPath), KEY_LISTENERS, sp.join(path34, evPath));
     }
   };
   try {
-    return fs_watch(path33, {
+    return fs_watch(path34, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -19564,12 +20650,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path33, fullPath, options, handlers) => {
+var setFsWatchListener = (path34, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path33, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path34, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -19580,7 +20666,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path33,
+      path34,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -19595,7 +20681,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path33, "r");
+          const fd = await open(path34, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -19626,7 +20712,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path33, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path34, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -19648,7 +20734,7 @@ var setFsWatchFileListener = (path33, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path33, curr));
+          foreach(cont.listeners, (listener2) => listener2(path34, curr));
         }
       })
     };
@@ -19678,13 +20764,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path33, listener) {
+  _watchWithNodeFs(path34, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path33);
-    const basename8 = sp.basename(path33);
+    const directory = sp.dirname(path34);
+    const basename9 = sp.basename(path34);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
-    const absolutePath = sp.resolve(path33);
+    parent.add(basename9);
+    const absolutePath = sp.resolve(path34);
     const options = {
       persistent: opts.persistent
     };
@@ -19693,13 +20779,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path33, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path34, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path33, absolutePath, options, {
+      closer = setFsWatchListener(path34, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -19715,13 +20801,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname15 = sp.dirname(file);
-    const basename8 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname15);
+    const dirname16 = sp.dirname(file);
+    const basename9 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname16);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename9))
       return;
-    const listener = async (path33, newStats) => {
+    const listener = async (path34, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -19735,18 +20821,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path33);
+            this.fsw._closeFile(path34);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path33, closer2);
+              this.fsw._addPathCloser(path34, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname15, basename8);
+          this.fsw._remove(dirname16, basename9);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename9)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -19771,7 +20857,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, path33, item) {
+  async _handleSymlink(entry, directory, path34, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -19781,7 +20867,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path33);
+        linkPath = await fsrealpath(path34);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -19791,12 +20877,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, path33, entry.stats);
+          this.fsw._emit(EV.CHANGE, path34, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path33, entry.stats);
+        this.fsw._emit(EV.ADD, path34, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -19826,9 +20912,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path33 = sp.join(directory, item);
+      let path34 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path33, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path34, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -19837,11 +20923,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path33 = sp.join(dir, sp.relative(dir, path33));
-        this._addToNodeFs(path33, initialAdd, wh, depth + 1);
+        path34 = sp.join(dir, sp.relative(dir, path34));
+        this._addToNodeFs(path34, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve21, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -19850,7 +20936,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve20(void 0);
+        resolve21(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -19907,13 +20993,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path33, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path34, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path33) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path34) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path33);
+    const wh = this.fsw._getWatchHelpers(path34);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -19929,8 +21015,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path33);
-        const targetPath = follow ? await fsrealpath(path33) : path33;
+        const absPath = sp.resolve(path34);
+        const targetPath = follow ? await fsrealpath(path34) : path34;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -19940,29 +21026,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path33) : path33;
+        const targetPath = follow ? await fsrealpath(path34) : path34;
         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, path33, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path34, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path33), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path34), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path33, closer);
+        this.fsw._addPathCloser(path34, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path33;
+        return path34;
       }
     }
   }
@@ -20005,24 +21091,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath3(path33) {
-  if (typeof path33 !== "string")
+function normalizePath3(path34) {
+  if (typeof path34 !== "string")
     throw new Error("string expected");
-  path33 = sp2.normalize(path33);
-  path33 = path33.replace(/\\/g, "/");
+  path34 = sp2.normalize(path34);
+  path34 = path34.replace(/\\/g, "/");
   let prepend = false;
-  if (path33.startsWith("//"))
+  if (path34.startsWith("//"))
     prepend = true;
-  path33 = path33.replace(DOUBLE_SLASH_RE, "/");
+  path34 = path34.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path33 = "/" + path33;
-  return path33;
+    path34 = "/" + path34;
+  return path34;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path33 = normalizePath3(testString);
+  const path34 = normalizePath3(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path33, stats)) {
+    if (pattern(path34, stats)) {
       return true;
     }
   }
@@ -20060,19 +21146,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path33) => toUnix(sp2.normalize(toUnix(path33)));
-var normalizeIgnored = (cwd = "") => (path33) => {
-  if (typeof path33 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path33) ? path33 : sp2.join(cwd, path33));
+var normalizePathToUnix = (path34) => toUnix(sp2.normalize(toUnix(path34)));
+var normalizeIgnored = (cwd = "") => (path34) => {
+  if (typeof path34 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path34) ? path34 : sp2.join(cwd, path34));
   } else {
-    return path33;
+    return path34;
   }
 };
-var getAbsolutePath = (path33, cwd) => {
-  if (sp2.isAbsolute(path33)) {
-    return path33;
+var getAbsolutePath = (path34, cwd) => {
+  if (sp2.isAbsolute(path34)) {
+    return path34;
   }
-  return sp2.join(cwd, path33);
+  return sp2.join(cwd, path34);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -20137,10 +21223,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path33, follow, fsw) {
+  constructor(path34, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path33;
-    this.path = path33 = path33.replace(REPLACER_RE, "");
+    const watchPath = path34;
+    this.path = path34 = path34.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -20280,20 +21366,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path33) => {
-        const absPath = getAbsolutePath(path33, cwd);
+      paths = paths.map((path34) => {
+        const absPath = getAbsolutePath(path34, cwd);
         return absPath;
       });
     }
-    paths.forEach((path33) => {
-      this._removeIgnoredPath(path33);
+    paths.forEach((path34) => {
+      this._removeIgnoredPath(path34);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path33) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path33, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path34) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path34, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -20315,17 +21401,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path33) => {
-      if (!sp2.isAbsolute(path33) && !this._closers.has(path33)) {
+    paths.forEach((path34) => {
+      if (!sp2.isAbsolute(path34) && !this._closers.has(path34)) {
         if (cwd)
-          path33 = sp2.join(cwd, path33);
-        path33 = sp2.resolve(path33);
+          path34 = sp2.join(cwd, path34);
+        path34 = sp2.resolve(path34);
       }
-      this._closePath(path33);
-      this._addIgnoredPath(path33);
-      if (this._watched.has(path33)) {
+      this._closePath(path34);
+      this._addIgnoredPath(path34);
+      if (this._watched.has(path34)) {
         this._addIgnoredPath({
-          path: path33,
+          path: path34,
           recursive: true
         });
       }
@@ -20389,38 +21475,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, path33, stats) {
+  async _emit(event, path34, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path33 = sp2.normalize(path33);
+      path34 = sp2.normalize(path34);
     if (opts.cwd)
-      path33 = sp2.relative(opts.cwd, path33);
-    const args = [path33];
+      path34 = sp2.relative(opts.cwd, path34);
+    const args = [path34];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path33))) {
+    if (awf && (pw = this._pendingWrites.get(path34))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path33, [event, ...args]);
+        this._pendingUnlinks.set(path34, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path34) => {
+          this._pendingUnlinks.forEach((entry, path35) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path34);
+            this._pendingUnlinks.delete(path35);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path33)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path34)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path33);
+        this._pendingUnlinks.delete(path34);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -20438,16 +21524,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path33, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path34, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path33, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path34, 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, path33) : path33;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path34) : path34;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -20478,23 +21564,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, path33, timeout) {
+  _throttle(actionType, path34, 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(path33);
+    const actionPath = action.get(path34);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path33);
+      const item = action.get(path34);
       const count = item ? item.count : 0;
-      action.delete(path33);
+      action.delete(path34);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -20502,7 +21588,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path33, thr);
+    action.set(path34, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -20516,44 +21602,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path33, threshold, event, awfEmit) {
+  _awaitWriteFinish(path34, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path33;
-    if (this.options.cwd && !sp2.isAbsolute(path33)) {
-      fullPath = sp2.join(this.options.cwd, path33);
+    let fullPath = path34;
+    if (this.options.cwd && !sp2.isAbsolute(path34)) {
+      fullPath = sp2.join(this.options.cwd, path34);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path33)) {
+        if (err || !writes.has(path34)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path33).lastChange = now3;
+          writes.get(path34).lastChange = now3;
         }
-        const pw = writes.get(path33);
+        const pw = writes.get(path34);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path33);
+          writes.delete(path34);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path33)) {
-      writes.set(path33, {
+    if (!writes.has(path34)) {
+      writes.set(path34, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path33);
+          writes.delete(path34);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -20564,8 +21650,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path33, stats) {
-    if (this.options.atomic && DOT_RE.test(path33))
+  _isIgnored(path34, stats) {
+    if (this.options.atomic && DOT_RE.test(path34))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -20575,17 +21661,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path33, stats);
+    return this._userIgnored(path34, stats);
   }
-  _isntIgnored(path33, stat5) {
-    return !this._isIgnored(path33, stat5);
+  _isntIgnored(path34, stat5) {
+    return !this._isIgnored(path34, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path33) {
-    return new WatchHelper(path33, this.options.followSymlinks, this);
+  _getWatchHelpers(path34) {
+    return new WatchHelper(path34, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -20617,63 +21703,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path33 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path33);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path33) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path33, 100))
+    const path34 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path34);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path34) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path34, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path33);
+    const wp = this._getWatchedDir(path34);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path33, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path34, 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 = path33;
+    let relPath = path34;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path33);
+      relPath = sp2.relative(this.options.cwd, path34);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path33);
+    this._watched.delete(path34);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path33))
-      this._emit(eventName, path33);
-    this._closePath(path33);
+    if (wasTracked && !this._isIgnored(path34))
+      this._emit(eventName, path34);
+    this._closePath(path34);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path33) {
-    this._closeFile(path33);
-    const dir = sp2.dirname(path33);
-    this._getWatchedDir(dir).remove(sp2.basename(path33));
+  _closePath(path34) {
+    this._closeFile(path34);
+    const dir = sp2.dirname(path34);
+    this._getWatchedDir(dir).remove(sp2.basename(path34));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path33) {
-    const closers = this._closers.get(path33);
+  _closeFile(path34) {
+    const closers = this._closers.get(path34);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path33);
+    this._closers.delete(path34);
   }
-  _addPathCloser(path33, closer) {
+  _addPathCloser(path34, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path33);
+    let list = this._closers.get(path34);
     if (!list) {
       list = [];
-      this._closers.set(path33, list);
+      this._closers.set(path34, list);
     }
     list.push(closer);
   }
@@ -20703,11 +21789,11 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-import * as path28 from "path";
+import * as path29 from "path";
 
 // src/watcher/native-recursive-watcher.ts
 import { watch as watch2 } from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 var NativeRecursiveWatcher = class {
   constructor(root, onChange, options = {}) {
     this.root = root;
@@ -20755,9 +21841,9 @@ var NativeRecursiveWatcher = class {
   toAbsolutePath(filename) {
     if (filename == null) return null;
     const normalizedFilename = typeof filename === "string" ? filename : filename.toString();
-    const absolutePath = path26.resolve(this.root, normalizedFilename);
-    const relativePath = path26.relative(this.root, absolutePath);
-    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path26.sep}`) || path26.isAbsolute(relativePath);
+    const absolutePath = path27.resolve(this.root, normalizedFilename);
+    const relativePath = path27.relative(this.root, absolutePath);
+    const outsideRoot = relativePath === ".." || relativePath.startsWith(`..${path27.sep}`) || path27.isAbsolute(relativePath);
     return outsideRoot ? null : absolutePath;
   }
   defaultWatchFactory = (root, listener, options) => watch2(root, options, listener);
@@ -20765,16 +21851,16 @@ var NativeRecursiveWatcher = class {
 
 // src/watcher/snapshot.ts
 import * as fsPromises4 from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
-  const normalizedProjectRoot = path27.resolve(projectRoot);
+  const normalizedProjectRoot = path28.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 normalizedPath3 = path27.resolve(filePath);
+    const normalizedPath3 = path28.resolve(filePath);
     if (!shouldIncludeFile(normalizedPath3, normalizedProjectRoot, includePatterns, config.exclude, ignoreFilter)) return;
     const stat5 = await readStatIfFile(normalizedPath3, unreadablePrefixes);
     if (stat5) snapshot.set(normalizedPath3, { size: stat5.size, mtimeMs: stat5.mtimeMs });
@@ -20786,16 +21872,16 @@ async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
     } catch (error) {
       if (isMissingFsError(error)) return;
       if (isPermissionFsError(error)) {
-        unreadablePrefixes.add(path27.resolve(directoryPath));
+        unreadablePrefixes.add(path28.resolve(directoryPath));
         return;
       }
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path27.join(directoryPath, entry.name);
-      const relativePath = path27.relative(normalizedProjectRoot, fullPath);
+      const fullPath = path28.join(directoryPath, entry.name);
+      const relativePath = path28.relative(normalizedProjectRoot, fullPath);
       if (entry.isDirectory()) {
-        if (hasFilteredPathSegment(relativePath, path27.sep) || isRestrictedDirectory(relativePath, path27.sep)) continue;
+        if (hasFilteredPathSegment(relativePath, path28.sep) || isRestrictedDirectory(relativePath, path28.sep)) continue;
         if (ignoreFilter.ignores(relativePath)) continue;
         if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -20808,19 +21894,19 @@ async function buildFileSnapshotScan(projectRoot, config, configPaths = []) {
   return { entries: snapshot, unreadablePrefixes };
 }
 async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, targetPath) {
-  const normalizedProjectRoot = path27.resolve(projectRoot);
-  const normalizedTargetPath = path27.resolve(targetPath);
+  const normalizedProjectRoot = path28.resolve(projectRoot);
+  const normalizedTargetPath = path28.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) => path27.resolve(configPath)));
+  const explicitConfigPaths = new Set(configPaths.map((configPath) => path28.resolve(configPath)));
   const snapshot = /* @__PURE__ */ new Map();
   const unreadablePrefixes = /* @__PURE__ */ new Set();
   const includeFile = async (filePath) => {
-    const normalizedPath3 = path27.resolve(filePath);
+    const normalizedPath3 = path28.resolve(filePath);
     if (!explicitConfigPaths.has(normalizedPath3) && !shouldIncludeFile(
       normalizedPath3,
       normalizedProjectRoot,
@@ -20838,16 +21924,16 @@ async function buildFileSnapshotForPathScan(projectRoot, config, configPaths, ta
     } catch (error) {
       if (isMissingFsError(error)) return;
       if (isPermissionFsError(error)) {
-        unreadablePrefixes.add(path27.resolve(directoryPath));
+        unreadablePrefixes.add(path28.resolve(directoryPath));
         return;
       }
       throw error;
     }
     for (const entry of entries) {
-      const fullPath = path27.join(directoryPath, entry.name);
-      const relativePath = path27.relative(normalizedProjectRoot, fullPath);
+      const fullPath = path28.join(directoryPath, entry.name);
+      const relativePath = path28.relative(normalizedProjectRoot, fullPath);
       if (entry.isDirectory()) {
-        if (hasFilteredPathSegment(relativePath, path27.sep) || isRestrictedDirectory(relativePath, path27.sep)) continue;
+        if (hasFilteredPathSegment(relativePath, path28.sep) || isRestrictedDirectory(relativePath, path28.sep)) continue;
         if (ignoreFilter.ignores(relativePath)) continue;
         if (maxDepth === -1 || depth < maxDepth) await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -20871,7 +21957,7 @@ function completeFileSnapshot(previous, scan) {
   return completed;
 }
 async function includeExplicitConfigPaths(snapshot, unreadablePrefixes, configPaths) {
-  for (const configPath of [...new Set(configPaths.map((value) => path27.resolve(value)))]) {
+  for (const configPath of [...new Set(configPaths.map((value) => path28.resolve(value)))]) {
     if (snapshot.has(configPath)) continue;
     const stat5 = await readStatIfFile(configPath, unreadablePrefixes);
     if (stat5) snapshot.set(configPath, { size: stat5.size, mtimeMs: stat5.mtimeMs });
@@ -20881,12 +21967,12 @@ async function includeExplicitConfigPathsInPath(snapshot, unreadablePrefixes, co
   await includeExplicitConfigPaths(
     snapshot,
     unreadablePrefixes,
-    configPaths.filter((configPath) => isWithinPath(targetPath, path27.resolve(configPath)))
+    configPaths.filter((configPath) => isWithinPath(targetPath, path28.resolve(configPath)))
   );
 }
 function isWithinPath(parentPath, childPath) {
-  const relativePath = path27.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith(`..${path27.sep}`) && relativePath !== ".." && !path27.isAbsolute(relativePath);
+  const relativePath = path28.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path28.sep}`) && relativePath !== ".." && !path28.isAbsolute(relativePath);
 }
 async function readStatIfFile(filePath, unreadablePrefixes) {
   try {
@@ -20895,7 +21981,7 @@ async function readStatIfFile(filePath, unreadablePrefixes) {
   } catch (error) {
     if (isMissingFsError(error)) return null;
     if (isPermissionFsError(error)) {
-      unreadablePrefixes.add(path27.resolve(filePath));
+      unreadablePrefixes.add(path28.resolve(filePath));
       return null;
     }
     throw error;
@@ -21032,8 +22118,8 @@ var FileWatcher = class {
     this.createWatcher();
   }
   resetReady() {
-    this.readyPromise = new Promise((resolve20) => {
-      this.resolveReady = resolve20;
+    this.readyPromise = new Promise((resolve21) => {
+      this.resolveReady = resolve21;
     });
     this.startupReadySignals = 1;
   }
@@ -21064,7 +22150,7 @@ var FileWatcher = class {
     const resolvedWatchTargets = watchTargets ?? this.getFullChokidarWatchTargets();
     const watcherOptions = {
       ignored: (filePath) => {
-        const relativePath = path28.relative(this.projectRoot, filePath);
+        const relativePath = path29.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
@@ -21072,10 +22158,10 @@ var FileWatcher = class {
         if (this.isOutsideProjectPath(relativePath)) {
           return true;
         }
-        if (hasFilteredPathSegment(relativePath, path28.sep)) {
+        if (hasFilteredPathSegment(relativePath, path29.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path28.sep)) {
+        if (isRestrictedDirectory(relativePath, path29.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -21166,13 +22252,13 @@ var FileWatcher = class {
   getExternalConfigWatchTargets() {
     return [...new Set(
       this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path28.relative(this.projectRoot, projectConfigPath);
+        const relativeConfigPath = path29.relative(this.projectRoot, projectConfigPath);
         return this.isOutsideProjectPath(relativeConfigPath);
       }).map((projectConfigPath) => {
-        if (existsSync15(projectConfigPath)) {
+        if (existsSync16(projectConfigPath)) {
           return projectConfigPath;
         }
-        return this.getNearestExistingDirectory(path28.dirname(projectConfigPath));
+        return this.getNearestExistingDirectory(path29.dirname(projectConfigPath));
       })
     )];
   }
@@ -21234,7 +22320,7 @@ var FileWatcher = class {
   }
   scheduleNativeReconciliation(generation, filePath) {
     if (!this.isCurrentNativeSetup(generation)) return;
-    const requiresFullReconciliation = filePath === path28.join(this.projectRoot, ".gitignore");
+    const requiresFullReconciliation = filePath === path29.join(this.projectRoot, ".gitignore");
     const invalidatedPath = requiresFullReconciliation ? null : filePath;
     this.nativeInvalidatedPaths.set(invalidatedPath, invalidatedPath !== null);
     if (this.nativeReconcileTimer) {
@@ -21329,23 +22415,23 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path28.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path28.normalize(relativePath);
+    const relativePath = path29.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path29.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path28.normalize(relativePath);
+    const normalizedRelativePath = path29.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path28.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path29.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path28.sep}`) || path28.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path29.sep}`) || path29.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
-    while (!existsSync15(candidate)) {
-      const parent = path28.dirname(candidate);
+    while (!existsSync16(candidate)) {
+      const parent = path29.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -21353,7 +22439,7 @@ var FileWatcher = class {
   }
   getProjectConfigRelativePaths() {
     return this.projectConfigPaths.map(
-      (configPath) => path28.normalize(path28.relative(this.projectRoot, configPath))
+      (configPath) => path29.normalize(path29.relative(this.projectRoot, configPath))
     );
   }
   getConfigPathStates() {
@@ -21411,7 +22497,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path33, type]) => ({ path: path33, type })
+      ([path34, type]) => ({ path: path34, type })
     );
     this.pendingChanges.clear();
     try {
@@ -21457,7 +22543,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-import * as path29 from "path";
+import * as path30 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -21479,13 +22565,13 @@ var GitHeadWatcher = class {
       this.readyPromise = Promise.resolve();
       return;
     }
-    this.readyPromise = new Promise((resolve20) => {
-      this.resolveReady = resolve20;
+    this.readyPromise = new Promise((resolve21) => {
+      this.resolveReady = resolve21;
     });
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path29.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path30.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -21553,7 +22639,9 @@ var GitHeadWatcher = class {
 function createWatcherWithIndexer(getIndexer, projectRoot, config, host, options = {}) {
   const fileWatcher = new FileWatcher(projectRoot, config, host, options);
   const configPaths = getConfigPaths(projectRoot, host, options);
-  configureAutoIndex(projectRoot, host, parseConfig(config), getIndexer);
+  configureAutoIndex(projectRoot, host, parseConfig(config), getIndexer, {
+    synchronizeBackgroundWorker: false
+  });
   let stopped = false;
   const requestReindex = () => {
     if (stopped) return;
@@ -21573,7 +22661,9 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config, host, options
         const parsedConfig = options.configPath ? parseConfig(loadConfigFile(options.configPath)) : void 0;
         const refreshedConfig = refreshIndexerForDirectory(projectRoot, host, parsedConfig);
         if (refreshedConfig) {
-          configureAutoIndex(projectRoot, host, refreshedConfig, getIndexer);
+          configureAutoIndex(projectRoot, host, refreshedConfig, getIndexer, {
+            synchronizeBackgroundWorker: false
+          });
         }
       }
       requestReindex();
@@ -21621,7 +22711,7 @@ function getConfigPaths(projectRoot, host, options) {
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path30 from "path";
+import * as path31 from "path";
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -21783,7 +22873,7 @@ function normalizePath4(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path30.isAbsolute(filePath) ? path30.relative(projectRoot, filePath) : filePath;
+  const relativePath = path31.isAbsolute(filePath) ? path31.relative(projectRoot, filePath) : filePath;
   return normalizePath4(relativePath);
 }
 
@@ -22041,7 +23131,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-import * as path31 from "path";
+import * as path32 from "path";
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -22301,7 +23391,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path31.dirname(s.filePath),
+    directory: path32.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -22329,9 +23419,9 @@ function parseArgs(argv) {
   let host = "opencode";
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path32.resolve(argv[++i]);
+      project = path33.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path32.resolve(argv[++i]);
+      config = path33.resolve(argv[++i]);
     } else if (argv[i] === "--host" && argv[i + 1]) {
       host = parseHostMode(argv[++i]);
     } else if (argv[i] === "--host") {
@@ -22359,7 +23449,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--project=")) {
         i += 1;
       }
-      project = path32.resolve(cwd, value);
+      project = path33.resolve(cwd, value);
       continue;
     }
     if (arg === "--config" || arg.startsWith("--config=")) {
@@ -22370,7 +23460,7 @@ function parseIndexArgs(argv, cwd) {
       if (!arg.startsWith("--config=")) {
         i += 1;
       }
-      config = path32.resolve(cwd, value);
+      config = path33.resolve(cwd, value);
       continue;
     }
     if (arg === "--host" || arg.startsWith("--host=")) {
@@ -22430,7 +23520,7 @@ Progress and diagnostics are written to stderr. Final index output is written to
   );
 }
 function isCliEntrypoint(moduleUrl, argvPath) {
-  return argvPath !== void 0 && realpathSync6(fileURLToPath2(moduleUrl)) === realpathSync6(argvPath);
+  return argvPath !== void 0 && realpathSync7(fileURLToPath2(moduleUrl)) === realpathSync7(argvPath);
 }
 function parseVisualizeArgs(argv, cwd) {
   let project = cwd;
@@ -22440,7 +23530,7 @@ function parseVisualizeArgs(argv, cwd) {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--project" && argv[i + 1]) {
-      project = path32.resolve(argv[++i]);
+      project = path33.resolve(argv[++i]);
     } else if (arg === "--max" && argv[i + 1]) {
       maxNodes = Number(argv[++i]);
     } else if (arg.startsWith("--max=") || arg.startsWith("max=")) {
@@ -22477,8 +23567,8 @@ async function handleVisualizeCommand(argv, cwd) {
       console.error("No connected symbols found. Retry with: npm run visualize -- orphans");
       return 1;
     }
-    const outputPath = path32.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
-    writeFileSync6(outputPath, generateVisualizationHtml(vizData), "utf-8");
+    const outputPath = path33.join(os9.tmpdir(), `call-graph-${Date.now()}.html`);
+    writeFileSync7(outputPath, generateVisualizationHtml(vizData), "utf-8");
     console.log(`Temporal call graph visualization generated: ${outputPath}`);
     console.log(`Nodes: ${vizData.nodes.length} | Edges: ${vizData.edges.length}`);
     console.log(`Recent change lenses: ${vizData.changes?.length ?? 0}`);
@@ -22509,7 +23599,6 @@ async function runMcpCli(argv) {
   const config = parseConfig(rawConfig);
   const server = createMcpServer(args.project, config, args.host);
   const transport = new StdioServerTransport();
-  let watcher = null;
   let shutdownPromise;
   const onServerClose = server.server.onclose;
   const shutdown = () => {
@@ -22523,16 +23612,19 @@ async function runMcpCli(argv) {
     shutdownPromise = (async () => {
       let exitCode = 0;
       try {
-        await watcher?.stop();
-      } catch (error) {
-        exitCode = 1;
-        console.error("Failed to stop MCP file watcher cleanly:", error);
-      }
-      try {
-        await stopAutoIndex(args.project, args.host);
+        await stopBackgroundWorker(args.project, args.host);
       } catch (error) {
         exitCode = 1;
-        console.error("Failed to stop automatic indexing cleanly:", error);
+        if (error instanceof BackgroundWorkerStopError) {
+          if (error.watcherError !== void 0) {
+            console.error("Failed to stop MCP file watcher cleanly:", error.watcherError);
+          }
+          if (error.autoIndexError !== void 0) {
+            console.error("Failed to stop automatic indexing cleanly:", error.autoIndexError);
+          }
+        } else {
+          console.error("Failed to stop automatic indexing cleanly:", error);
+        }
       }
       try {
         await server.close();
@@ -22561,19 +23653,25 @@ async function runMcpCli(argv) {
     process.once("SIGHUP", requestShutdown);
     process.once("SIGTERM", requestShutdown);
   }
-  await server.connect(transport);
-  if (shutdownPromise) return;
   const isHomeDir = isHomeDirectory(args.project);
   const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(args.project));
-  if (config.indexing.watchFiles && isValidProject) {
-    watcher = createWatcherWithIndexer(
-      () => getIndexerForProject(args.project, args.host),
-      args.project,
-      config,
-      args.host,
-      args.config ? { configPath: args.config } : {}
-    );
-  }
+  const watcherFactoryForConfig = (refreshedConfig) => refreshedConfig.indexing.watchFiles && !isHomeDirectory(args.project) && (!refreshedConfig.indexing.requireProjectMarker || hasProjectMarker(args.project)) ? () => createWatcherWithIndexer(
+    () => getIndexerForProject(args.project, args.host),
+    args.project,
+    refreshedConfig,
+    args.host,
+    args.config ? { configPath: args.config } : {}
+  ) : null;
+  await server.connect(transport);
+  if (shutdownPromise) return;
+  await attachMcpBackgroundWatcher(
+    args.project,
+    config,
+    args.host,
+    config.indexing.watchFiles && isValidProject ? watcherFactoryForConfig(config) : null,
+    watcherFactoryForConfig
+  );
+  if (shutdownPromise) return;
 }
 function printIndexProgress(onProgress, title, metadata) {
   const details = Object.entries(metadata).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${isSensitiveKey(key) ? "[REDACTED]" : String(value)}`).join(" ");