opencode-codebase-index 0.14.0 → 0.16.0

package/dist/index.js

@@ -490,7 +490,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(path23, checkUnignored, mode) {
+      test(path24, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -499,7 +499,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path23);
+          const matched = rule[mode].test(path24);
           if (!matched) {
             return;
           }
@@ -520,17 +520,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path23, originalPath, doThrow) => {
-      if (!isString(path23)) {
+    var checkPath = (path24, originalPath, doThrow) => {
+      if (!isString(path24)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path23) {
+      if (!path24) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path23)) {
+      if (checkPath.isNotRelative(path24)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -539,7 +539,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path23) => REGEX_TEST_INVALID_PATH.test(path23);
+    var isNotRelative = (path24) => REGEX_TEST_INVALID_PATH.test(path24);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -569,19 +569,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path23 = originalPath && checkPath.convert(originalPath);
+        const path24 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path23,
+          path24,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path23, cache, checkUnignored, slices);
+        return this._t(path24, cache, checkUnignored, slices);
       }
-      checkIgnore(path23) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path23)) {
-          return this.test(path23);
+      checkIgnore(path24) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path24)) {
+          return this.test(path24);
         }
-        const slices = path23.split(SLASH2).filter(Boolean);
+        const slices = path24.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -594,18 +594,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path23, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path24, false, MODE_CHECK_IGNORE);
       }
-      _t(path23, cache, checkUnignored, slices) {
-        if (path23 in cache) {
-          return cache[path23];
+      _t(path24, cache, checkUnignored, slices) {
+        if (path24 in cache) {
+          return cache[path24];
         }
         if (!slices) {
-          slices = path23.split(SLASH2).filter(Boolean);
+          slices = path24.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path23] = this._rules.test(path23, checkUnignored, MODE_IGNORE);
+          return cache[path24] = this._rules.test(path24, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -613,29 +613,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path23] = parent.ignored ? parent : this._rules.test(path23, checkUnignored, MODE_IGNORE);
+        return cache[path24] = parent.ignored ? parent : this._rules.test(path24, checkUnignored, MODE_IGNORE);
       }
-      ignores(path23) {
-        return this._test(path23, this._ignoreCache, false).ignored;
+      ignores(path24) {
+        return this._test(path24, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path23) => !this.ignores(path23);
+        return (path24) => !this.ignores(path24);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path23) {
-        return this._test(path23, this._testCache, true);
+      test(path24) {
+        return this._test(path24, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path23) => checkPath(path23 && checkPath.convert(path23), path23, RETURN_FALSE);
+    var isPathValid = (path24) => checkPath(path24 && checkPath.convert(path24), path24, 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 = (path23) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path23) || isNotRelative(path23);
+      checkPath.isNotRelative = (path24) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path24) || isNotRelative(path24);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,16 +651,16 @@ var require_ignore = __commonJS({
 });
 
 // src/index.ts
-import * as os5 from "os";
-import * as path22 from "path";
+import * as os6 from "os";
+import * as path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
-  "**/*.{ts,tsx,js,jsx,mjs,cjs}",
+  "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
   "**/*.{py,pyi}",
-  "**/*.{go,rs,java,kt,scala}",
-  "**/*.{c,cpp,cc,h,hpp}",
+  "**/*.{go,rs,java,cs,kt,scala}",
+  "**/*.{c,cpp,cc,cxx,h,hpp,hxx}",
   "**/*.{rb,php,inc,swift}",
   "**/*.{cls,trigger}",
   "**/*.{vue,svelte,astro}",
@@ -1244,6 +1244,9 @@ function getHostProjectIndexRelativePath(host) {
 function hasHostProjectConfig(projectRoot, host) {
   return existsSync3(path3.join(projectRoot, getProjectConfigRelativePath(host)));
 }
+function hasHostGlobalConfig(host) {
+  return existsSync3(getGlobalConfigPath(host));
+}
 function getGlobalIndexPath(host = "opencode") {
   switch (host) {
     case "opencode":
@@ -1283,6 +1286,9 @@ function resolveGlobalIndexPath(host = "opencode") {
     return hostIndexPath;
   }
   if (host !== "opencode") {
+    if (hasHostGlobalConfig(host)) {
+      return hostIndexPath;
+    }
     const legacyIndexPath = getGlobalIndexPath("opencode");
     if (existsSync3(legacyIndexPath)) {
       return legacyIndexPath;
@@ -1581,13 +1587,439 @@ function loadMergedConfig(projectRoot, host = "opencode") {
   return merged;
 }
 
+// src/indexer/index-lock.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync as existsSync5,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync2,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import * as os2 from "os";
+import * as path7 from "path";
+var OWNER_FILE_NAME = "owner.json";
+var RECLAIM_DIRECTORY_NAME = "reclaiming";
+var RECOVERY_MARKER_PREFIX = "indexing.lock.recovery.";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var VALID_OPERATIONS = /* @__PURE__ */ new Set([
+  "initialize",
+  "index",
+  "force-index",
+  "clear",
+  "health-check",
+  "retry-failed-batches",
+  "recovery"
+]);
+var temporaryCounter = 0;
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function retryTransientFilesystemOperation(operation) {
+  let lastError;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      operation();
+      return;
+    } catch (error) {
+      lastError = error;
+      const code = getErrorCode(error);
+      if (code !== "EBUSY" && code !== "EPERM") throw error;
+      if (attempt < 2) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, (attempt + 1) * 10);
+      }
+    }
+  }
+  throw lastError;
+}
+function parseOwner(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  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.operation !== "string" || !VALID_OPERATIONS.has(candidate.operation)) return null;
+  if (typeof candidate.token !== "string" || !UUID_PATTERN.test(candidate.token)) return null;
+  return candidate;
+}
+function parseReclaimOwner(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const candidate = value;
+  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_PATTERN.test(candidate.token)) return null;
+  if (typeof candidate.expectedOwnerToken !== "string" || !UUID_PATTERN.test(candidate.expectedOwnerToken)) return null;
+  return candidate;
+}
+function readJsonDirectory(directoryPath, parser) {
+  try {
+    return parser(JSON.parse(readFileSync4(path7.join(directoryPath, OWNER_FILE_NAME), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function readDirectoryOwner(lockPath) {
+  return readJsonDirectory(lockPath, parseOwner);
+}
+function readReclaimOwner(markerPath) {
+  return readJsonDirectory(markerPath, parseReclaimOwner);
+}
+function readRecoveryOwner(markerPath) {
+  return readDirectoryOwner(markerPath);
+}
+function readLegacyOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(readFileSync4(lockPath, "utf-8"));
+    if (!Number.isInteger(parsed.pid) || Number(parsed.pid) <= 0) return null;
+    if (typeof parsed.startedAt !== "string" || Number.isNaN(Date.parse(parsed.startedAt))) return null;
+    return {
+      pid: Number(parsed.pid),
+      hostname: typeof parsed.hostname === "string" ? parsed.hostname : os2.hostname(),
+      startedAt: parsed.startedAt,
+      operation: typeof parsed.operation === "string" && VALID_OPERATIONS.has(parsed.operation) ? parsed.operation : "index",
+      token: typeof parsed.token === "string" ? parsed.token : "legacy-v0.14.0"
+    };
+  } catch {
+    return null;
+  }
+}
+function getOwnerLiveness(owner) {
+  if (owner.hostname !== os2.hostname()) return "unknown";
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    const code = getErrorCode(error);
+    if (code === "ESRCH") return "dead";
+    if (code === "EPERM") return "alive";
+    return "unknown";
+  }
+}
+function sameOwner(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token;
+}
+function sameReclaimOwner(left, right) {
+  return left.pid === right.pid && left.hostname === right.hostname && left.token === right.token && left.expectedOwnerToken === right.expectedOwnerToken;
+}
+function publishJsonDirectory(finalPath, value) {
+  const candidatePath = `${finalPath}.candidate.${process.pid}.${randomUUID()}`;
+  mkdirSync2(candidatePath, { mode: 448 });
+  try {
+    writeFileSync2(path7.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if (existsSync5(finalPath)) return false;
+    try {
+      renameSync(candidatePath, finalPath);
+      return true;
+    } catch (error) {
+      if (existsSync5(finalPath)) return false;
+      throw error;
+    }
+  } finally {
+    if (existsSync5(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
+  }
+}
+function createOwner(operation) {
+  return {
+    pid: process.pid,
+    hostname: os2.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    operation,
+    token: randomUUID()
+  };
+}
+function recoveryMarkerPath(indexPath, owner) {
+  return path7.join(indexPath, `${RECOVERY_MARKER_PREFIX}${owner.token}`);
+}
+function publishRecoveryMarker(indexPath, owner) {
+  const markerPath = recoveryMarkerPath(indexPath, owner);
+  if (!publishJsonDirectory(markerPath, owner)) {
+    const markerOwner = readRecoveryOwner(markerPath);
+    if (!markerOwner || !sameOwner(markerOwner, owner)) {
+      throw new IndexLockContentionError(markerPath, markerOwner, "unknown-owner");
+    }
+  }
+  return markerPath;
+}
+function getPendingRecoveries(indexPath) {
+  const recoveries = [];
+  const markerNames = readdirSync2(indexPath).filter((name) => {
+    if (!name.startsWith(RECOVERY_MARKER_PREFIX)) return false;
+    return UUID_PATTERN.test(name.slice(RECOVERY_MARKER_PREFIX.length));
+  }).sort();
+  for (const markerName of markerNames) {
+    const markerPath = path7.join(indexPath, markerName);
+    const markerToken = markerName.slice(RECOVERY_MARKER_PREFIX.length);
+    let markerStats;
+    try {
+      markerStats = lstatSync(markerPath);
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") continue;
+      throw error;
+    }
+    if (!markerStats.isDirectory()) {
+      throw new IndexLockContentionError(markerPath, null, "unknown-owner");
+    }
+    const owner = readRecoveryOwner(markerPath);
+    if (!owner || owner.token !== markerToken || getOwnerLiveness(owner) !== "dead") {
+      throw new IndexLockContentionError(markerPath, owner, "unknown-owner");
+    }
+    recoveries.push({ owner, markerPath });
+  }
+  recoveries.sort((left, right) => {
+    const byTimestamp = left.owner.startedAt.localeCompare(right.owner.startedAt);
+    return byTimestamp !== 0 ? byTimestamp : left.markerPath.localeCompare(right.markerPath);
+  });
+  return recoveries;
+}
+function cleanupDeadPublicationCandidates(indexPath) {
+  const candidatePattern = /^indexing\.lock(?:\.recovery\.[0-9a-f-]{36})?\.candidate\.(\d+)\.[0-9a-f-]{36}$/i;
+  for (const entry of readdirSync2(indexPath)) {
+    const match = candidatePattern.exec(entry);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    if (getOwnerLiveness({ pid, hostname: os2.hostname() }) !== "dead") continue;
+    rmSync(path7.join(indexPath, entry), { recursive: true, force: true });
+  }
+}
+function removeDeadReclaimMarker(lockPath, expectedOwner) {
+  const markerPath = path7.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const marker = readReclaimOwner(markerPath);
+  if (!marker || marker.expectedOwnerToken !== expectedOwner.token || getOwnerLiveness(marker) !== "dead") {
+    return false;
+  }
+  const currentOwner = readDirectoryOwner(lockPath);
+  if (!currentOwner || !sameOwner(currentOwner, expectedOwner) || getOwnerLiveness(currentOwner) !== "dead") {
+    return false;
+  }
+  const claimedMarkerPath = `${markerPath}.stale.${marker.pid}.${marker.token}.${randomUUID()}`;
+  try {
+    renameSync(markerPath, claimedMarkerPath);
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedMarker = readReclaimOwner(claimedMarkerPath);
+  const ownerAfterClaim = readDirectoryOwner(lockPath);
+  if (!claimedMarker || !sameReclaimOwner(claimedMarker, marker) || !ownerAfterClaim || !sameOwner(ownerAfterClaim, expectedOwner) || getOwnerLiveness(ownerAfterClaim) !== "dead") {
+    if (!existsSync5(markerPath) && existsSync5(claimedMarkerPath)) {
+      renameSync(claimedMarkerPath, markerPath);
+    }
+    return false;
+  }
+  rmSync(claimedMarkerPath, { recursive: true, force: true });
+  return true;
+}
+function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
+  const reclaimPath = path7.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimOwner = {
+    pid: process.pid,
+    hostname: os2.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token: randomUUID(),
+    expectedOwnerToken: expectedOwner.token
+  };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    if (publishJsonDirectory(reclaimPath, reclaimOwner)) break;
+    if (attempt === 0 && removeDeadReclaimMarker(lockPath, expectedOwner)) continue;
+    return false;
+  }
+  try {
+    const currentReclaimer = readReclaimOwner(reclaimPath);
+    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);
+    if (!ownerBeforeQuarantine || !sameOwner(ownerBeforeQuarantine, expectedOwner) || getOwnerLiveness(ownerBeforeQuarantine) !== "dead" || !reclaimerBeforeQuarantine || !sameReclaimOwner(reclaimerBeforeQuarantine, reclaimOwner)) {
+      return false;
+    }
+    const quarantinePath = `${lockPath}.stale.${expectedOwner.token}.${reclaimOwner.token}`;
+    renameSync(lockPath, quarantinePath);
+    rmSync(quarantinePath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
+}
+var IndexLockContentionError = class extends Error {
+  constructor(lockPath, owner, reason) {
+    const ownerDescription = owner ? `PID ${owner.pid} on ${owner.hostname}, operation ${owner.operation}, since ${owner.startedAt}` : "an unreadable owner";
+    super(`Index mutation already in progress: ${ownerDescription}`);
+    this.lockPath = lockPath;
+    this.owner = owner;
+    this.reason = reason;
+    this.name = "IndexLockContentionError";
+  }
+  lockPath;
+  owner;
+  reason;
+  code = "INDEX_BUSY";
+};
+function isIndexLockContentionError(error) {
+  return error instanceof IndexLockContentionError || typeof error === "object" && error !== null && "code" in error && error.code === "INDEX_BUSY";
+}
+function isTransientIndexLockContention(error) {
+  if (!isIndexLockContentionError(error) || !("reason" in error)) return false;
+  return error.reason === "active" || error.reason === "reclaiming";
+}
+function acquireIndexLock(indexPath, operation) {
+  mkdirSync2(indexPath, { recursive: true });
+  const canonicalIndexPath = realpathSync.native(indexPath);
+  const lockPath = path7.join(canonicalIndexPath, "indexing.lock");
+  cleanupDeadPublicationCandidates(canonicalIndexPath);
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    const owner = createOwner(operation);
+    if (publishJsonDirectory(lockPath, owner)) {
+      const lease = {
+        canonicalIndexPath,
+        lockPath,
+        owner,
+        recoveries: []
+      };
+      try {
+        lease.recoveries = getPendingRecoveries(canonicalIndexPath);
+        return lease;
+      } catch (error) {
+        releaseIndexLock(lease);
+        throw error;
+      }
+    }
+    let stats;
+    try {
+      stats = lstatSync(lockPath);
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") continue;
+      throw error;
+    }
+    if (!stats.isDirectory()) {
+      const legacyOwner = readLegacyOwner(lockPath);
+      throw new IndexLockContentionError(lockPath, legacyOwner, "legacy-lock");
+    }
+    const existingOwner = readDirectoryOwner(lockPath);
+    if (!existingOwner) {
+      throw new IndexLockContentionError(lockPath, null, "unknown-owner");
+    }
+    const liveness = getOwnerLiveness(existingOwner);
+    if (liveness !== "dead") {
+      throw new IndexLockContentionError(lockPath, existingOwner, liveness === "alive" ? "active" : "unknown-owner");
+    }
+    if (!reclaimDeadOwner(canonicalIndexPath, lockPath, existingOwner)) {
+      throw new IndexLockContentionError(lockPath, existingOwner, "reclaiming");
+    }
+  }
+  throw new IndexLockContentionError(lockPath, null, "reclaiming");
+}
+function releaseIndexLock(lease) {
+  const currentOwner = readDirectoryOwner(lease.lockPath);
+  if (!currentOwner || !sameOwner(currentOwner, lease.owner)) return false;
+  const releasePath = `${lease.lockPath}.release.${lease.owner.pid}.${lease.owner.token}`;
+  try {
+    retryTransientFilesystemOperation(() => renameSync(lease.lockPath, releasePath));
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
+  const claimedOwner = readDirectoryOwner(releasePath);
+  if (!claimedOwner || !sameOwner(claimedOwner, lease.owner)) {
+    if (!existsSync5(lease.lockPath) && existsSync5(releasePath)) {
+      renameSync(releasePath, lease.lockPath);
+    }
+    return false;
+  }
+  try {
+    retryTransientFilesystemOperation(() => rmSync(releasePath, { recursive: true, force: true }));
+  } catch (error) {
+    console.error(`[codebase-index] Lease released but tombstone cleanup failed: ${releasePath}`, error);
+  }
+  return true;
+}
+async function withIndexLock(indexPath, operation, callback, options = {}) {
+  const lease = acquireIndexLock(indexPath, operation);
+  let result;
+  let callbackError;
+  let callbackFailed = false;
+  try {
+    result = await callback(lease);
+  } catch (error) {
+    callbackFailed = true;
+    callbackError = error;
+  }
+  if (!callbackFailed && options.completeRecoveries !== false) {
+    try {
+      completeLeaseRecovery(lease);
+    } catch (error) {
+      callbackFailed = true;
+      callbackError = error;
+    }
+  }
+  let releaseError;
+  try {
+    if (!releaseIndexLock(lease)) {
+      releaseError = new Error(`Lost ownership of index mutation lease ${lease.owner.token}`);
+    }
+  } catch (error) {
+    releaseError = error;
+  }
+  if (releaseError !== void 0) {
+    if (callbackFailed) throw new AggregateError([callbackError, releaseError], "Index mutation and lease release both failed");
+    throw releaseError;
+  }
+  if (callbackFailed) throw callbackError;
+  return result;
+}
+function createLeaseTemporaryPath(targetPath, owner, kind = "tmp") {
+  if (kind === "bak") return `${targetPath}.bak.${owner.pid}.${owner.token}`;
+  temporaryCounter += 1;
+  return `${targetPath}.tmp.${owner.pid}.${owner.token}.${temporaryCounter}`;
+}
+function removeLeaseTemporaryPath(temporaryPath) {
+  if (existsSync5(temporaryPath)) rmSync(temporaryPath, { recursive: true, force: true });
+}
+function recoverLeaseArtifacts(indexPath, owner, backupTargets) {
+  for (const targetPath of backupTargets) {
+    const backupPath = createLeaseTemporaryPath(targetPath, owner, "bak");
+    if (!existsSync5(backupPath)) continue;
+    if (existsSync5(targetPath)) rmSync(targetPath, { recursive: true, force: true });
+    renameSync(backupPath, targetPath);
+  }
+  const temporaryOwnerMarker = `.tmp.${owner.pid}.${owner.token}.`;
+  for (const entry of readdirSync2(indexPath)) {
+    if (!entry.includes(temporaryOwnerMarker)) continue;
+    rmSync(path7.join(indexPath, entry), { recursive: true, force: true });
+  }
+}
+function completeLeaseRecovery(lease) {
+  for (const recovery of lease.recoveries) {
+    const markerOwner = readRecoveryOwner(recovery.markerPath);
+    if (!markerOwner || !sameOwner(markerOwner, recovery.owner)) {
+      throw new Error(`Recovery marker ownership changed: ${recovery.markerPath}`);
+    }
+  }
+  for (const recovery of lease.recoveries) {
+    rmSync(recovery.markerPath, { recursive: true, force: true });
+  }
+}
+
 // src/tools/operations.ts
-import { existsSync as existsSync9, realpathSync, statSync as statSync3 } from "fs";
-import * as path15 from "path";
+import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import * as path16 from "path";
 
 // src/indexer/index.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync2, renameSync, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
-import * as path12 from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync3, renameSync as renameSync2, unlinkSync, mkdirSync as mkdirSync3, promises as fsPromises2 } from "fs";
+import * as path13 from "path";
 import { performance as performance2 } from "perf_hooks";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -2637,17 +3069,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import * as path7 from "path";
-import * as os2 from "os";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import * as path8 from "path";
+import * as os3 from "os";
 function getOpenCodeAuthPath() {
-  return path7.join(os2.homedir(), ".local", "share", "opencode", "auth.json");
+  return path8.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync5(authPath)) {
-      return JSON.parse(readFileSync4(authPath, "utf-8"));
+    if (existsSync6(authPath)) {
+      return JSON.parse(readFileSync5(authPath, "utf-8"));
     }
   } catch {
   }
@@ -2869,17 +3301,17 @@ function validateExternalUrl(urlString) {
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
     return { valid: false, reason: `Blocked protocol: ${parsed.protocol}` };
   }
-  const hostname = parsed.hostname.toLowerCase();
-  if (BLOCKED_HOSTNAMES.has(hostname)) {
-    return { valid: false, reason: `Blocked: cloud metadata service (${hostname})` };
+  const hostname2 = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname2)) {
+    return { valid: false, reason: `Blocked: cloud metadata service (${hostname2})` };
   }
   for (const pattern of BLOCKED_METADATA_IPS) {
-    if (pattern.test(hostname)) {
-      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname})` };
+    if (pattern.test(hostname2)) {
+      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname2})` };
     }
   }
-  if (/^169\.254\./.test(hostname)) {
-    return { valid: false, reason: `Blocked: link-local address (${hostname})` };
+  if (/^169\.254\./.test(hostname2)) {
+    return { valid: false, reason: `Blocked: link-local address (${hostname2})` };
   }
   return { valid: true };
 }
@@ -3350,8 +3782,8 @@ var SiliconFlowReranker = class {
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync5, promises as fsPromises } from "fs";
-import * as path8 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, promises as fsPromises } from "fs";
+import * as path9 from "path";
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -3371,7 +3803,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if (existsSync6(path8.join(projectRoot, marker))) {
+    if (existsSync7(path9.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3398,16 +3830,16 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path8.join(projectRoot, ".gitignore");
-  if (existsSync6(gitignorePath)) {
-    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+  const gitignorePath = path9.join(projectRoot, ".gitignore");
+  if (existsSync7(gitignorePath)) {
+    const gitignoreContent = readFileSync6(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
 function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path8.relative(projectRoot, filePath);
-  if (hasFilteredPathSegment(relativePath, path8.sep)) {
+  const relativePath = path9.relative(projectRoot, filePath);
+  if (hasFilteredPathSegment(relativePath, path9.sep)) {
     return false;
   }
   if (ignoreFilter.ignores(relativePath)) {
@@ -3445,8 +3877,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
-    const relativePath = path8.relative(projectRoot, fullPath);
+    const fullPath = path9.join(dir, entry.name);
+    const relativePath = path9.relative(projectRoot, fullPath);
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3495,7 +3927,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path8.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path9.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3535,8 +3967,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path8.normalize(
-        path8.isAbsolute(kbRoot) ? kbRoot : path8.resolve(projectRoot, kbRoot)
+      const resolved = path9.normalize(
+        path9.isAbsolute(kbRoot) ? kbRoot : path9.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3943,13 +4375,13 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path9 from "path";
-import * as os3 from "os";
+import * as path10 from "path";
+import * as os4 from "os";
 import * as module from "module";
 import { fileURLToPath } from "url";
 function getNativeBinding() {
-  const platform2 = os3.platform();
-  const arch2 = os3.arch();
+  const platform2 = os4.platform();
+  const arch2 = os4.arch();
   let bindingName;
   if (platform2 === "darwin" && arch2 === "arm64") {
     bindingName = "codebase-index-native.darwin-arm64.node";
@@ -3967,19 +4399,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path9.dirname(fileURLToPath(import.meta.url));
+    currentDir = path10.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path9.join(currentDir, "index.js");
+    requireTarget = path10.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path9.join("src", "native"));
-  const packageRoot = isDevMode ? path9.resolve(currentDir, "../..") : path9.resolve(currentDir, "..");
-  const nativePath = path9.join(packageRoot, "native", bindingName);
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path10.join("src", "native"));
+  const packageRoot = isDevMode ? path10.resolve(currentDir, "../..") : path10.resolve(currentDir, "..");
+  const nativePath = path10.join(packageRoot, "native", bindingName);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -4021,6 +4453,12 @@ function createMockNativeBinding() {
       constructor() {
         throw error;
       }
+      static openReadOnly() {
+        throw error;
+      }
+      static createEmptyReadOnly() {
+        throw error;
+      }
       close() {
         throw error;
       }
@@ -4124,6 +4562,12 @@ var VectorStore = class {
   load() {
     this.inner.load();
   }
+  loadStrict() {
+    this.inner.loadStrict();
+  }
+  hasFingerprint() {
+    return this.inner.hasFingerprint();
+  }
   count() {
     return this.inner.count();
   }
@@ -4406,12 +4850,24 @@ var InvertedIndex = class {
     return this.inner.documentCount();
   }
 };
-var Database = class {
+var Database = class _Database {
   inner;
   closed = false;
   constructor(dbPath) {
     this.inner = new native.Database(dbPath);
   }
+  static fromNative(inner) {
+    const database = Object.create(_Database.prototype);
+    database.inner = inner;
+    database.closed = false;
+    return database;
+  }
+  static openReadOnly(dbPath) {
+    return _Database.fromNative(native.Database.openReadOnly(dbPath));
+  }
+  static createEmptyReadOnly() {
+    return _Database.fromNative(native.Database.createEmptyReadOnly());
+  }
   throwIfClosed() {
     if (this.closed) {
       throw new Error("Database is closed");
@@ -4688,7 +5144,7 @@ var Database = class {
 };
 
 // src/tools/changed-files.ts
-import * as path10 from "path";
+import * as path11 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -4776,8 +5232,8 @@ function normalizeFiles(rawFiles, projectRoot) {
   for (const raw of rawFiles) {
     const trimmed = raw.trim();
     if (!trimmed) continue;
-    const absolute = path10.resolve(projectRoot, trimmed);
-    const relative11 = path10.relative(projectRoot, absolute);
+    const absolute = path11.resolve(projectRoot, trimmed);
+    const relative11 = path11.relative(projectRoot, absolute);
     const cleaned = relative11.startsWith("./") ? relative11.slice(2) : relative11;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
@@ -4789,7 +5245,7 @@ function normalizeFiles(rawFiles, projectRoot) {
 
 // src/indexer/git-blame.ts
 import { execFile as execFile2 } from "child_process";
-import * as path11 from "path";
+import * as path12 from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 function parseGitBlamePorcelain(output) {
@@ -4827,7 +5283,7 @@ function parseGitBlamePorcelain(output) {
   return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
 }
 async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
-  const relativePath = path11.relative(projectRoot, filePath);
+  const relativePath = path12.relative(projectRoot, filePath);
   try {
     const { stdout } = await execFileAsync2(
       "git",
@@ -4921,6 +5377,7 @@ function isSqliteCorruptionError(error) {
   return message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database schema is corrupt") || message.includes("sqlite_corrupt");
 }
 var STARTUP_WARNING_METADATA_KEY = "index.startupWarning";
+var READER_ARTIFACT_RETRY_INTERVAL_MS = 1e3;
 function metadataFromBlame(blame) {
   if (!blame) {
     return {};
@@ -5118,9 +5575,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path12.resolve(filePath);
-  const normalizedRoot = path12.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path12.sep}`);
+  const normalizedFilePath = path13.resolve(filePath);
+  const normalizedRoot = path13.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path13.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -6186,26 +6643,133 @@ var Indexer = class {
   queryCacheTtlMs = 5 * 60 * 1e3;
   querySimilarityThreshold = 0.85;
   indexCompatibility = null;
-  indexingLockPath = "";
+  activeIndexLease = null;
+  initializationPromise = null;
+  initializationMode = "none";
+  readIssues = [];
+  retiredDatabases = [];
+  readerArtifactFingerprint = null;
+  writerArtifactFingerprint = null;
+  readerArtifactRetryAfter = /* @__PURE__ */ new Map();
   constructor(projectRoot, config, host = "opencode") {
     this.projectRoot = projectRoot;
     this.config = config;
     this.host = host;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path12.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path12.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path12.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
+  isLocalProjectIndexPath() {
+    const localProjectIndexPaths = [path13.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    if (this.host !== "opencode") {
+      localProjectIndexPaths.push(path13.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+    }
+    return localProjectIndexPaths.some((localPath) => {
+      if (!existsSync8(localPath) || !existsSync8(this.indexPath)) {
+        return path13.resolve(this.indexPath) === path13.resolve(localPath);
+      }
+      const indexStats = statSync3(this.indexPath);
+      const localStats = statSync3(localPath);
+      return indexStats.dev === localStats.dev && indexStats.ino === localStats.ino;
+    });
+  }
+  resetLoadedIndexState(retireDatabase = false) {
+    if (this.database) {
+      if (retireDatabase) {
+        this.retiredDatabases.push(this.database);
+      } else {
+        this.database.close();
+      }
+    }
+    this.store = null;
+    this.invertedIndex = null;
+    this.database = null;
+    this.provider = null;
+    this.configuredProviderInfo = null;
+    this.reranker = null;
+    this.indexCompatibility = null;
+    this.initializationMode = "none";
+    this.readIssues = [];
+    this.readerArtifactFingerprint = null;
+    this.writerArtifactFingerprint = null;
+    this.readerArtifactRetryAfter.clear();
+    this.fileHashCache.clear();
+  }
+  refreshLoadedIndexState() {
+    if (!this.store || !this.invertedIndex || !this.configuredProviderInfo) return;
+    this.store.load();
+    this.invertedIndex.load();
+    this.fileHashCache.clear();
+    this.loadFileHashCache();
+    this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+    this.readIssues = [];
+    this.readerArtifactRetryAfter.clear();
+  }
+  async withIndexMutationLease(operation, callback) {
+    const lease = acquireIndexLock(this.indexPath, operation);
+    this.indexPath = lease.canonicalIndexPath;
+    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.activeIndexLease = lease;
+    let result;
+    let callbackError;
+    let callbackFailed = false;
+    try {
+      result = await callback(lease.recoveries.map(({ owner }) => owner));
+    } catch (error) {
+      callbackFailed = true;
+      callbackError = error;
+    }
+    if (!callbackFailed) {
+      try {
+        completeLeaseRecovery(lease);
+        this.writerArtifactFingerprint = this.captureReaderArtifactFingerprint();
+      } catch (error) {
+        callbackFailed = true;
+        callbackError = error;
+      }
+    }
+    let releaseError;
+    try {
+      if (!releaseIndexLock(lease)) {
+        releaseError = new Error(`Lost ownership of index mutation lease ${lease.owner.token}`);
+        this.writerArtifactFingerprint = null;
+        if (this.activeIndexLease?.owner.token === lease.owner.token) {
+          this.activeIndexLease = null;
+        }
+      } else if (this.activeIndexLease?.owner.token === lease.owner.token) {
+        this.activeIndexLease = null;
+      }
+    } catch (error) {
+      releaseError = error;
+      this.writerArtifactFingerprint = null;
+      if (!existsSync8(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+        this.activeIndexLease = null;
+      }
+    }
+    if (releaseError !== void 0) {
+      if (callbackFailed) throw new AggregateError([callbackError, releaseError], "Index mutation and lease release both failed");
+      throw releaseError;
+    }
+    if (callbackFailed) throw callbackError;
+    return result;
+  }
+  requireActiveLease() {
+    if (!this.activeIndexLease) {
+      throw new Error("Index mutation attempted without an active interprocess lease");
+    }
+    return this.activeIndexLease;
+  }
   loadFileHashCache() {
-    if (!existsSync7(this.fileHashCachePath)) {
+    if (!existsSync8(this.fileHashCachePath)) {
       return;
     }
     try {
-      const data = readFileSync6(this.fileHashCachePath, "utf-8");
+      const data = readFileSync7(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -6225,15 +6789,26 @@ var Indexer = class {
     this.atomicWriteSync(this.fileHashCachePath, JSON.stringify(obj));
   }
   atomicWriteSync(targetPath, data) {
-    const tempPath = `${targetPath}.tmp`;
-    mkdirSync2(path12.dirname(targetPath), { recursive: true });
-    writeFileSync2(tempPath, data);
-    renameSync(tempPath, targetPath);
+    const lease = this.requireActiveLease();
+    const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
+    mkdirSync3(path13.dirname(targetPath), { recursive: true });
+    try {
+      writeFileSync3(tempPath, data);
+      renameSync2(tempPath, targetPath);
+    } finally {
+      removeLeaseTemporaryPath(tempPath);
+    }
+  }
+  saveInvertedIndex(invertedIndex) {
+    this.atomicWriteSync(
+      path13.join(this.indexPath, "inverted-index.json"),
+      invertedIndex.serialize()
+    );
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path12.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path13.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path12.resolve(this.projectRoot, kbRoot));
+      roots.add(path13.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6242,29 +6817,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getBranchCatalogKeyFor(branchName) {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -6358,7 +6933,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path12.resolve(this.projectRoot);
+    const projectRootPath = path13.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6381,7 +6956,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -6465,7 +7040,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -6499,7 +7074,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path12.resolve(this.projectRoot);
+    const projectRootPath = path13.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6561,34 +7136,27 @@ var Indexer = class {
     database.gcOrphanEmbeddings();
     database.gcOrphanChunks();
     store.save();
-    invertedIndex.save();
+    this.saveInvertedIndex(invertedIndex);
     return {
       removedChunkIds: removedChunkIdList,
       hasForeignData: allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots))
     };
   }
-  checkForInterruptedIndexing() {
-    return existsSync7(this.indexingLockPath);
-  }
-  acquireIndexingLock() {
-    const lockData = {
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pid: process.pid
-    };
-    writeFileSync2(this.indexingLockPath, JSON.stringify(lockData));
-  }
-  releaseIndexingLock() {
-    if (existsSync7(this.indexingLockPath)) {
-      unlinkSync(this.indexingLockPath);
+  async recoverFromInterruptedIndexingUnlocked(owners) {
+    for (const owner of owners) {
+      this.logger.warn("Detected interrupted indexing session, recovering...", {
+        pid: owner.pid,
+        hostname: owner.hostname,
+        operation: owner.operation,
+        startedAt: owner.startedAt
+      });
     }
-  }
-  async recoverFromInterruptedIndexing() {
-    this.logger.warn("Detected interrupted indexing session, recovering...");
-    if (existsSync7(this.fileHashCachePath)) {
-      unlinkSync(this.fileHashCachePath);
+    if (this.config.scope === "global") {
+      if (existsSync8(this.fileHashCachePath)) {
+        unlinkSync(this.fileHashCachePath);
+      }
+      await this.healthCheckUnlocked();
     }
-    await this.healthCheck();
-    this.releaseIndexingLock();
     this.logger.info("Recovery complete, next index will re-process all files");
   }
   loadFailedBatches(maxChunkTokens) {
@@ -6604,10 +7172,10 @@ var Indexer = class {
     }
   }
   loadSerializedFailedBatches() {
-    if (!existsSync7(this.failedBatchesPath)) {
+    if (!existsSync8(this.failedBatchesPath)) {
       return [];
     }
-    const data = readFileSync6(this.failedBatchesPath, "utf-8");
+    const data = readFileSync7(this.failedBatchesPath, "utf-8");
     const parsed = JSON.parse(data);
     return parsed.map((batch) => {
       const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
@@ -6624,7 +7192,7 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync7(this.failedBatchesPath)) {
+      if (existsSync8(this.failedBatchesPath)) {
         try {
           unlinkSync(this.failedBatchesPath);
         } catch {
@@ -6632,7 +7200,7 @@ var Indexer = class {
       }
       return;
     }
-    writeFileSync2(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    this.atomicWriteSync(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
   collectRetryableFailedChunks(currentFileHashes, unchangedFilePaths, maxChunkTokens) {
     const retryableById = /* @__PURE__ */ new Map();
@@ -6826,6 +7394,222 @@ var Indexer = class {
     return parts.join("\n");
   }
   async initialize() {
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+    if (this.isInitializedFor("reader")) {
+      return;
+    }
+    await this.initializeOnce("reader", [], { skipAutoGc: true });
+  }
+  async initializeOnce(mode, recoveredOwners, options) {
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+      if (this.isInitializedFor(mode)) {
+        return;
+      }
+      return this.initializeOnce(mode, recoveredOwners, options);
+    }
+    if (this.isInitializedFor(mode)) {
+      return;
+    }
+    const initialization = this.initializeUnlocked(mode, recoveredOwners, options).catch((error) => {
+      this.resetLoadedIndexState();
+      throw error;
+    }).finally(() => {
+      if (this.initializationPromise === initialization) {
+        this.initializationPromise = null;
+      }
+    });
+    this.initializationPromise = initialization;
+    await initialization;
+  }
+  isInitializedFor(mode) {
+    const hasState = Boolean(
+      this.store && this.provider && this.invertedIndex && this.configuredProviderInfo && this.database
+    );
+    if (!hasState) {
+      return false;
+    }
+    return mode === "reader" ? this.initializationMode !== "none" : this.initializationMode === "writer";
+  }
+  recordReadIssue(component, message, error) {
+    this.readIssues.push(this.createReadIssue(component, message));
+    this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
+    this.logger.warn(message, error === void 0 ? void 0 : { error: getErrorMessage2(error) });
+  }
+  createReadIssue(component, message) {
+    return {
+      component,
+      message,
+      blocking: component !== "keyword"
+    };
+  }
+  getVectorReadIssueMessage() {
+    if (this.config.scope === "global") {
+      return "Shared vector index could not be read. Restore or repair the complete fingerprinted shared vector artifacts; automatic reset is disabled for global scope.";
+    }
+    if (!this.isLocalProjectIndexPath()) {
+      return "Vector index could not be read from an inherited project index. Restore or fingerprint it from the checkout that owns the index; do not remove or rebuild it from this worktree.";
+    }
+    return "Vector index could not be read. Run index_codebase after the active writer finishes to fingerprint a structurally valid legacy pair, or remove this checkout's local index directory and run index_codebase to rebuild it.";
+  }
+  getKeywordReadIssueMessage() {
+    if (this.config.scope === "global") {
+      return "Shared keyword index could not be read; semantic search remains available. Restore or repair the shared keyword artifact; automatic reset is disabled for global scope.";
+    }
+    if (!this.isLocalProjectIndexPath()) {
+      return "Keyword index could not be read from an inherited project index; semantic search remains available. Restore or repair it from the checkout that owns the index; do not rebuild it from this worktree.";
+    }
+    return "Keyword index could not be read; semantic search remains available. Restore a readable published keyword index, or run index_codebase with force=true after the active writer finishes.";
+  }
+  getDatabaseReadIssueMessage() {
+    if (this.config.scope === "global") {
+      return "Shared index database could not be read. Restore or repair the shared SQLite database; automatic reset is disabled for global scope.";
+    }
+    if (!this.isLocalProjectIndexPath()) {
+      return "Index database could not be read from an inherited project index. Restore or repair it from the checkout that owns the index; do not migrate or rebuild it from this worktree.";
+    }
+    return "Index database could not be read. Run index_codebase after the active writer finishes to repair or migrate it under the writer lease.";
+  }
+  getReaderFileFingerprint(filePath, identityOnly = false) {
+    try {
+      const stats = statSync3(filePath);
+      if (identityOnly) {
+        return `${stats.dev}:${stats.ino}`;
+      }
+      return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`;
+    } catch (error) {
+      return `unavailable:${getErrorMessage2(error)}`;
+    }
+  }
+  captureReaderArtifactFingerprint() {
+    const storePath = path13.join(this.indexPath, "vectors");
+    return {
+      vectors: `${this.getReaderFileFingerprint(storePath)}|${this.getReaderFileFingerprint(`${storePath}.meta.json`)}`,
+      keyword: this.getReaderFileFingerprint(path13.join(this.indexPath, "inverted-index.json")),
+      database: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db")),
+      databaseIdentity: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db"), true)
+    };
+  }
+  refreshReaderArtifacts() {
+    if (this.initializationMode !== "reader" || !this.configuredProviderInfo) {
+      return;
+    }
+    const previousFingerprint = this.readerArtifactFingerprint;
+    const currentFingerprint = this.captureReaderArtifactFingerprint();
+    const issues = new Map(this.readIssues.map((issue) => [issue.component, issue]));
+    const retryDue = (component) => issues.has(component) && Date.now() >= (this.readerArtifactRetryAfter.get(component) ?? 0);
+    const vectorsChanged = !previousFingerprint || currentFingerprint.vectors !== previousFingerprint.vectors;
+    const keywordChanged = !previousFingerprint || currentFingerprint.keyword !== previousFingerprint.keyword;
+    const databaseChanged = !previousFingerprint || currentFingerprint.database !== previousFingerprint.database;
+    const databaseReplaced = !previousFingerprint || currentFingerprint.databaseIdentity !== previousFingerprint.databaseIdentity;
+    if (previousFingerprint && !vectorsChanged && !keywordChanged && !databaseChanged && !Array.from(issues.keys()).some(retryDue)) {
+      return;
+    }
+    const setIssue = (component, message, error) => {
+      if (!issues.has(component)) {
+        this.logger.warn(message, error === void 0 ? void 0 : { error: getErrorMessage2(error) });
+      }
+      issues.set(component, this.createReadIssue(component, message));
+      this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
+    };
+    const storePath = path13.join(this.indexPath, "vectors");
+    const vectorMetadataPath = `${storePath}.meta.json`;
+    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
+    const dbPath = path13.join(this.indexPath, "codebase.db");
+    if (vectorsChanged || retryDue("vectors")) {
+      const vectorStoreExists = existsSync8(storePath);
+      const vectorMetadataExists = existsSync8(vectorMetadataPath);
+      if (vectorStoreExists && vectorMetadataExists) {
+        try {
+          const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
+          store.loadStrict();
+          this.store = store;
+          issues.delete("vectors");
+          this.readerArtifactRetryAfter.delete("vectors");
+        } catch (error) {
+          setIssue("vectors", this.getVectorReadIssueMessage(), error);
+        }
+      } else if (vectorStoreExists !== vectorMetadataExists || issues.has("vectors")) {
+        setIssue("vectors", this.getVectorReadIssueMessage());
+      }
+    }
+    if (keywordChanged || retryDue("keyword") || !existsSync8(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if (existsSync8(invertedIndexPath)) {
+        try {
+          const invertedIndex = new InvertedIndex(invertedIndexPath);
+          invertedIndex.load();
+          this.invertedIndex = invertedIndex;
+          issues.delete("keyword");
+          this.readerArtifactRetryAfter.delete("keyword");
+        } catch (error) {
+          setIssue("keyword", this.getKeywordReadIssueMessage(), error);
+        }
+      } else if ((this.store?.count() ?? 0) > 0 || issues.has("keyword")) {
+        setIssue("keyword", this.getKeywordReadIssueMessage());
+      }
+    }
+    if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
+      if (existsSync8(dbPath)) {
+        try {
+          const database = Database.openReadOnly(dbPath);
+          if (this.database) {
+            this.retiredDatabases.push(this.database);
+          }
+          this.database = database;
+          issues.delete("database");
+          this.readerArtifactRetryAfter.delete("database");
+        } catch (error) {
+          setIssue("database", this.getDatabaseReadIssueMessage(), error);
+        }
+      } else if ((this.store?.count() ?? 0) > 0 || issues.has("database")) {
+        setIssue("database", this.getDatabaseReadIssueMessage());
+      }
+    }
+    if (!issues.has("database")) {
+      try {
+        this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+      } catch (error) {
+        setIssue("database", this.getDatabaseReadIssueMessage(), error);
+      }
+    }
+    this.readIssues = Array.from(issues.values());
+    this.readerArtifactFingerprint = currentFingerprint;
+  }
+  refreshInactiveWriterArtifacts() {
+    if (this.initializationMode !== "writer" || this.activeIndexLease) {
+      return true;
+    }
+    const previousFingerprint = this.writerArtifactFingerprint;
+    const currentFingerprint = this.captureReaderArtifactFingerprint();
+    const retryDue = this.readIssues.some(
+      (issue) => Date.now() >= (this.readerArtifactRetryAfter.get(issue.component) ?? 0)
+    );
+    const artifactsChanged = !previousFingerprint || currentFingerprint.vectors !== previousFingerprint.vectors || currentFingerprint.keyword !== previousFingerprint.keyword || currentFingerprint.database !== previousFingerprint.database || currentFingerprint.databaseIdentity !== previousFingerprint.databaseIdentity;
+    if (!artifactsChanged && !retryDue) {
+      return true;
+    }
+    if (!previousFingerprint || currentFingerprint.databaseIdentity !== previousFingerprint.databaseIdentity) {
+      return false;
+    }
+    this.initializationMode = "reader";
+    this.readerArtifactFingerprint = previousFingerprint;
+    try {
+      this.refreshReaderArtifacts();
+      this.writerArtifactFingerprint = this.readerArtifactFingerprint ?? currentFingerprint;
+    } finally {
+      this.readerArtifactFingerprint = null;
+      this.initializationMode = "writer";
+    }
+    return true;
+  }
+  async initializeUnlocked(mode, recoveredOwners = [], options = {}) {
+    if (mode === "writer") {
+      this.requireActiveLease();
+    }
+    this.readIssues = [];
+    this.readerArtifactRetryAfter.clear();
     if (this.config.embeddingProvider === "custom") {
       if (!this.config.customProvider) {
         throw new Error("embeddingProvider is 'custom' but customProvider config is missing.");
@@ -6857,36 +7641,103 @@ var Indexer = class {
         });
       }
     }
-    await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path12.join(this.indexPath, "vectors");
-    this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
-    if (existsSync7(indexFilePath)) {
-      this.store.load();
-    }
-    const invertedIndexPath = path12.join(this.indexPath, "inverted-index.json");
-    this.invertedIndex = new InvertedIndex(invertedIndexPath);
-    try {
-      this.invertedIndex.load();
-    } catch {
-      if (existsSync7(invertedIndexPath)) {
-        await fsPromises2.unlink(invertedIndexPath);
+    const storePath = path13.join(this.indexPath, "vectors");
+    const vectorMetadataPath = `${storePath}.meta.json`;
+    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
+    const dbPath = path13.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync8(dbPath);
+    const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
+    if (mode === "writer") {
+      await fsPromises2.mkdir(this.indexPath, { recursive: true });
+      if (recoveredOwners.length > 0 && this.config.scope === "project" && !this.isLocalProjectIndexPath()) {
+        throw new Error(
+          "Interrupted indexing recovery is unsafe while using an inherited worktree index. Run index_codebase with force=true to create a local project index boundary."
+        );
+      }
+      for (const recoveredOwner of recoveredOwners) {
+        recoverLeaseArtifacts(this.indexPath, recoveredOwner, [
+          storePath,
+          `${storePath}.meta.json`
+        ]);
+      }
+      if (recoveredOwners.length > 0 && this.config.scope === "project") {
+        await this.resetLocalIndexArtifacts();
+      }
+      this.store = new VectorStore(storePath, dimensions);
+      if (existsSync8(storePath) || existsSync8(vectorMetadataPath)) {
+        this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-    }
-    const dbPath = path12.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync7(dbPath);
-    try {
-      this.database = new Database(dbPath);
-    } catch (error) {
-      if (!await this.tryResetCorruptedIndex("initializing index database", error)) {
-        throw error;
+      try {
+        this.invertedIndex.load();
+      } catch {
+        if (existsSync8(invertedIndexPath)) {
+          await fsPromises2.unlink(invertedIndexPath);
+        }
+        this.invertedIndex = new InvertedIndex(invertedIndexPath);
+      }
+      try {
+        this.database = new Database(dbPath);
+      } catch (error) {
+        if (!await this.tryResetCorruptedIndex("initializing index database", error)) {
+          throw error;
+        }
+        this.store = new VectorStore(storePath, dimensions);
+        this.invertedIndex = new InvertedIndex(invertedIndexPath);
+        this.database = new Database(dbPath);
+        dbIsNew = true;
       }
+    } else {
       this.store = new VectorStore(storePath, dimensions);
+      const vectorStoreExists = existsSync8(storePath);
+      const vectorMetadataExists = existsSync8(vectorMetadataPath);
+      const vectorReadFailureMessage = this.getVectorReadIssueMessage();
+      if (vectorStoreExists !== vectorMetadataExists) {
+        this.recordReadIssue("vectors", vectorReadFailureMessage);
+      } else if (vectorStoreExists) {
+        try {
+          this.store.loadStrict();
+        } catch (error) {
+          this.recordReadIssue("vectors", vectorReadFailureMessage, error);
+          this.store = new VectorStore(storePath, dimensions);
+        }
+      }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      this.database = new Database(dbPath);
-      dbIsNew = true;
+      if (existsSync8(invertedIndexPath)) {
+        try {
+          this.invertedIndex.load();
+        } catch (error) {
+          this.recordReadIssue(
+            "keyword",
+            this.getKeywordReadIssueMessage(),
+            error
+          );
+          this.invertedIndex = new InvertedIndex(invertedIndexPath);
+        }
+      } else if (this.store.count() > 0) {
+        this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
+      }
+      if (existsSync8(dbPath)) {
+        try {
+          this.database = Database.openReadOnly(dbPath);
+        } catch (error) {
+          this.recordReadIssue(
+            "database",
+            this.getDatabaseReadIssueMessage(),
+            error
+          );
+          this.database = Database.createEmptyReadOnly();
+        }
+      } else {
+        this.database = Database.createEmptyReadOnly();
+        if (this.store.count() > 0) {
+          this.recordReadIssue(
+            "database",
+            `Index database is missing for the published vectors. ${this.getDatabaseReadIssueMessage()}`
+          );
+        }
+      }
     }
     if (isGitRepo(this.projectRoot)) {
       this.currentBranch = getBranchOrDefault(this.projectRoot);
@@ -6900,10 +7751,10 @@ var Indexer = class {
       this.baseBranch = "default";
       this.logger.branch("debug", "Not a git repository, using default branch");
     }
-    if (this.checkForInterruptedIndexing()) {
-      await this.recoverFromInterruptedIndexing();
+    if (mode === "writer" && recoveredOwners.length > 0) {
+      await this.recoverFromInterruptedIndexingUnlocked(recoveredOwners);
     }
-    if (dbIsNew && this.store.count() > 0) {
+    if (mode === "writer" && dbIsNew && this.store.count() > 0) {
       this.migrateFromLegacyIndex();
     }
     this.loadFileHashCache();
@@ -6915,9 +7766,11 @@ var Indexer = class {
         configuredProviderInfo: this.configuredProviderInfo
       });
     }
-    if (this.config.indexing.autoGc) {
+    if (mode === "writer" && this.config.indexing.autoGc && !options.skipAutoGc) {
       await this.maybeRunAutoGc();
     }
+    this.initializationMode = mode;
+    this.readerArtifactFingerprint = readerArtifactFingerprint;
   }
   async maybeRunAutoGc() {
     if (!this.database) return;
@@ -6934,7 +7787,7 @@ var Indexer = class {
       }
     }
     if (shouldRunGc) {
-      const result = await this.healthCheck();
+      const result = await this.healthCheckUnlocked();
       if (result.warning) {
         this.database.setMetadata(STARTUP_WARNING_METADATA_KEY, result.warning);
       } else {
@@ -6956,7 +7809,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6971,28 +7824,29 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path12.join(this.indexPath, "vectors");
-    const storeIndexPath = `${storeBasePath}.usearch`;
+    const storeBasePath = path13.join(this.indexPath, "vectors");
+    const storeIndexPath = storeBasePath;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
-    const backupIndexPath = `${storeIndexPath}.bak`;
-    const backupMetadataPath = `${storeMetadataPath}.bak`;
+    const lease = this.requireActiveLease();
+    const backupIndexPath = createLeaseTemporaryPath(storeIndexPath, lease.owner, "bak");
+    const backupMetadataPath = createLeaseTemporaryPath(storeMetadataPath, lease.owner, "bak");
     let backedUpIndex = false;
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync7(backupIndexPath)) {
+    if (existsSync8(backupIndexPath)) {
       unlinkSync(backupIndexPath);
     }
-    if (existsSync7(backupMetadataPath)) {
+    if (existsSync8(backupMetadataPath)) {
       unlinkSync(backupMetadataPath);
     }
     try {
-      if (existsSync7(storeIndexPath)) {
-        renameSync(storeIndexPath, backupIndexPath);
+      if (existsSync8(storeIndexPath)) {
+        renameSync2(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync7(storeMetadataPath)) {
-        renameSync(storeMetadataPath, backupMetadataPath);
+      if (existsSync8(storeMetadataPath)) {
+        renameSync2(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -7012,10 +7866,10 @@ var Indexer = class {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync7(backupIndexPath)) {
+      if (backedUpIndex && existsSync8(backupIndexPath)) {
         unlinkSync(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync8(backupMetadataPath)) {
         unlinkSync(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -7028,17 +7882,17 @@ var Indexer = class {
         store.clear();
       } catch {
       }
-      if (existsSync7(storeIndexPath)) {
+      if (existsSync8(storeIndexPath)) {
         unlinkSync(storeIndexPath);
       }
-      if (existsSync7(storeMetadataPath)) {
+      if (existsSync8(storeMetadataPath)) {
         unlinkSync(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync7(backupIndexPath)) {
-        renameSync(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && existsSync8(backupIndexPath)) {
+        renameSync2(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
-        renameSync(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && existsSync8(backupMetadataPath)) {
+        renameSync2(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -7052,11 +7906,37 @@ var Indexer = class {
     }
     return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
   }
+  async resetLocalIndexArtifacts() {
+    this.store = null;
+    this.invertedIndex = null;
+    this.database?.close();
+    this.database = null;
+    this.indexCompatibility = null;
+    this.initializationMode = "none";
+    this.readIssues = [];
+    this.readerArtifactFingerprint = null;
+    this.writerArtifactFingerprint = null;
+    this.readerArtifactRetryAfter.clear();
+    this.fileHashCache.clear();
+    const resetPaths = [
+      path13.join(this.indexPath, "codebase.db"),
+      path13.join(this.indexPath, "codebase.db-shm"),
+      path13.join(this.indexPath, "codebase.db-wal"),
+      path13.join(this.indexPath, "vectors"),
+      path13.join(this.indexPath, "vectors.usearch"),
+      path13.join(this.indexPath, "vectors.meta.json"),
+      path13.join(this.indexPath, "inverted-index.json"),
+      path13.join(this.indexPath, "file-hashes.json"),
+      path13.join(this.indexPath, "failed-batches.json")
+    ];
+    await Promise.all(resetPaths.map((targetPath) => fsPromises2.rm(targetPath, { recursive: true, force: true })));
+    await fsPromises2.mkdir(this.indexPath, { recursive: true });
+  }
   async tryResetCorruptedIndex(stage, error) {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path12.join(this.indexPath, "codebase.db");
+    const dbPath = path13.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
@@ -7072,30 +7952,7 @@ var Indexer = class {
       dbPath,
       error: errorMessage
     });
-    this.store = null;
-    this.invertedIndex = null;
-    this.database?.close();
-    this.database = null;
-    this.indexCompatibility = null;
-    this.fileHashCache.clear();
-    const resetPaths = [
-      path12.join(this.indexPath, "codebase.db"),
-      path12.join(this.indexPath, "codebase.db-shm"),
-      path12.join(this.indexPath, "codebase.db-wal"),
-      path12.join(this.indexPath, "vectors.usearch"),
-      path12.join(this.indexPath, "inverted-index.json"),
-      path12.join(this.indexPath, "file-hashes.json"),
-      path12.join(this.indexPath, "failed-batches.json"),
-      path12.join(this.indexPath, "indexing.lock"),
-      path12.join(this.indexPath, "vectors")
-    ];
-    await Promise.all(resetPaths.map(async (targetPath) => {
-      try {
-        await fsPromises2.rm(targetPath, { recursive: true, force: true });
-      } catch {
-      }
-    }));
-    await fsPromises2.mkdir(this.indexPath, { recursive: true });
+    await this.resetLocalIndexArtifacts();
     return true;
   }
   migrateFromLegacyIndex() {
@@ -7214,8 +8071,62 @@ var Indexer = class {
     return this.indexCompatibility;
   }
   async ensureInitialized() {
+    let initializedReader = false;
+    while (true) {
+      if (this.initializationPromise) {
+        await this.initializationPromise;
+      }
+      if (!this.isInitializedFor("reader")) {
+        await this.initialize();
+        initializedReader = true;
+        continue;
+      }
+      if (this.initializationMode === "writer" && !this.activeIndexLease && !initializedReader) {
+        if (!this.refreshInactiveWriterArtifacts()) {
+          this.resetLoadedIndexState(true);
+          await this.initialize();
+          initializedReader = true;
+          continue;
+        }
+      }
+      if (this.initializationMode === "reader" && !initializedReader) {
+        this.refreshReaderArtifacts();
+      }
+      const state = this.requireLoadedIndexState();
+      return {
+        ...state,
+        readIssues: [...this.readIssues],
+        compatibility: this.indexCompatibility ?? this.validateIndexCompatibility(state.configuredProviderInfo)
+      };
+    }
+  }
+  async ensureInitializedUnlocked(recoveredOwners = []) {
+    this.requireActiveLease();
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+    if (recoveredOwners.length > 0 || !this.isInitializedFor("writer")) {
+      const retireReaderDatabase = this.initializationMode === "reader";
+      this.resetLoadedIndexState(retireReaderDatabase);
+      await this.initializeOnce("writer", recoveredOwners, { skipAutoGc: true });
+    } else {
+      this.refreshLoadedIndexState();
+    }
+    if (this.config.indexing.autoGc) {
+      await this.maybeRunAutoGc();
+    }
+    return this.requireLoadedIndexState();
+  }
+  requireReadableComponents(readIssues, ...components) {
+    const componentSet = new Set(components);
+    const issues = readIssues.filter((issue) => issue.blocking && componentSet.has(issue.component));
+    if (issues.length > 0) {
+      throw new Error(issues.map((issue) => issue.message).join(" "));
+    }
+  }
+  requireLoadedIndexState() {
     if (!this.store || !this.provider || !this.invertedIndex || !this.configuredProviderInfo || !this.database) {
-      await this.initialize();
+      throw new Error("Index state is not initialized");
     }
     return {
       store: this.store,
@@ -7239,7 +8150,12 @@ var Indexer = class {
     return createCostEstimate(files, configuredProviderInfo);
   }
   async index(onProgress) {
-    const { store, provider, invertedIndex, database, configuredProviderInfo } = await this.ensureInitialized();
+    return this.withIndexMutationLease("index", async (recoveredOwners) => {
+      return this.indexUnlocked(onProgress, recoveredOwners);
+    });
+  }
+  async indexUnlocked(onProgress, recoveredOwners = [], stateReady = false) {
+    const { store, provider, invertedIndex, database, configuredProviderInfo } = stateReady ? this.requireLoadedIndexState() : await this.ensureInitializedUnlocked(recoveredOwners);
     const scopedRoots = this.config.scope === "global" ? this.getScopedRoots() : null;
     const branchCatalogKey = this.getBranchCatalogKey();
     const forceScopedReembed = scopedRoots !== null && database.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
@@ -7249,7 +8165,6 @@ var Indexer = class {
         `${this.indexCompatibility?.reason} Run index_codebase with force=true to rebuild the index.`
       );
     }
-    this.acquireIndexingLock();
     this.logger.recordIndexingStart();
     this.logger.info("Starting indexing", { projectRoot: this.projectRoot });
     const startTime = Date.now();
@@ -7398,7 +8313,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path12.relative(this.projectRoot, parsed.path);
+        const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7598,7 +8513,9 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
-      if (backfilledBlameMetadata) {
+      const vectorPath = path13.join(this.indexPath, "vectors");
+      const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync8(vectorPath) && existsSync8(`${vectorPath}.meta.json`);
+      if (backfilledBlameMetadata || shouldFingerprintLegacyPair) {
         store.save();
       }
       if (scopedRoots) {
@@ -7619,7 +8536,6 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
-      this.releaseIndexingLock();
       return stats;
     }
     if (pendingChunks.length === 0) {
@@ -7628,7 +8544,7 @@ var Indexer = class {
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
       store.save();
-      invertedIndex.save();
+      this.saveInvertedIndex(invertedIndex);
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
         this.clearScopedFailedBatches(scopedRoots);
@@ -7647,7 +8563,6 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
-      this.releaseIndexingLock();
       return stats;
     }
     onProgress?.({
@@ -7878,7 +8793,7 @@ var Indexer = class {
     database.clearBranchSymbols(branchCatalogKey);
     database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
     store.save();
-    invertedIndex.save();
+    this.saveInvertedIndex(invertedIndex);
     if (scopedRoots) {
       this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
     } else {
@@ -7930,7 +8845,6 @@ var Indexer = class {
       chunksProcessed: stats.indexedChunks,
       totalChunks: pendingChunks.length
     });
-    this.releaseIndexingLock();
     return stats;
   }
   async getQueryEmbedding(query, provider) {
@@ -7996,8 +8910,8 @@ var Indexer = class {
     return intersection / union;
   }
   async search(query, limit, options) {
-    const { store, provider, database } = await this.ensureInitialized();
-    const compatibility = this.checkCompatibility();
+    const { store, provider, invertedIndex, database, readIssues, compatibility } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "vectors", "database");
     if (!compatibility.compatible) {
       throw new Error(
         `${compatibility.reason ?? "Index is incompatible with current embedding provider."} A possible solution is to run index_codebase with force=true to rebuild the index.`
@@ -8011,6 +8925,7 @@ var Indexer = class {
     const maxResults = limit ?? this.config.search.maxResults;
     const hybridWeight = options?.hybridWeight ?? this.config.search.hybridWeight;
     const fusionStrategy = this.config.search.fusionStrategy;
+    const effectiveHybridWeight = fusionStrategy === "weighted" && readIssues.some((issue) => issue.component === "keyword") ? 0 : hybridWeight;
     const rrfK = this.config.search.rrfK;
     const rerankTopN = this.config.search.rerankTopN;
     const filterByBranch = options?.filterByBranch ?? true;
@@ -8019,7 +8934,7 @@ var Indexer = class {
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
-      hybridWeight,
+      hybridWeight: effectiveHybridWeight,
       fusionStrategy,
       rrfK,
       rerankTopN,
@@ -8027,13 +8942,22 @@ var Indexer = class {
     });
     const embeddingStartTime = performance2.now();
     const embeddingQuery = stripFilePathHint(query);
-    const embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    let embedding;
+    try {
+      embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    } catch (error) {
+      this.logger.warn("Query embedding failed; falling back to keyword-only search", {
+        query,
+        error: getErrorMessage2(error),
+        action: "Check the embedding provider configuration and retry search after restoring provider health."
+      });
+    }
     const embeddingMs = performance2.now() - embeddingStartTime;
     const vectorStartTime = performance2.now();
-    const semanticResults = store.search(embedding, maxResults * 4);
+    const semanticResults = embedding ? store.search(embedding, maxResults * 4) : [];
     const vectorMs = performance2.now() - vectorStartTime;
     const keywordStartTime = performance2.now();
-    const keywordResults = await this.keywordSearch(query, maxResults * 4);
+    const keywordResults = await this.keywordSearch(query, maxResults * 4, store, invertedIndex);
     const keywordMs = performance2.now() - keywordStartTime;
     let branchChunkIds = null;
     if (filterByBranch && (this.config.scope === "global" || this.currentBranch !== "default")) {
@@ -8065,12 +8989,13 @@ var Indexer = class {
       });
     }
     const fusionStartTime = performance2.now();
+    const rankingHybridWeight = embedding === void 0 && fusionStrategy === "weighted" ? 1 : effectiveHybridWeight;
     const combined = rankHybridResults(query, semanticCandidates, keywordCandidates, {
       fusionStrategy,
       rrfK,
       rerankTopN,
       limit: maxResults,
-      hybridWeight,
+      hybridWeight: rankingHybridWeight,
       prioritizeSourcePaths: sourceIntent
     });
     const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
@@ -8170,8 +9095,7 @@ var Indexer = class {
       })
     );
   }
-  async keywordSearch(query, limit) {
-    const { store, invertedIndex } = await this.ensureInitialized();
+  async keywordSearch(query, limit, store, invertedIndex) {
     const scores = invertedIndex.search(query);
     if (scores.size === 0) {
       return [];
@@ -8189,24 +9113,54 @@ var Indexer = class {
     return results.slice(0, limit);
   }
   async getStatus() {
-    const { store, configuredProviderInfo, database } = await this.ensureInitialized();
+    const { store, configuredProviderInfo, database, readIssues, compatibility } = await this.ensureInitialized();
     const failedBatchesCount = this.getFailedBatchesCount();
+    const vectorCount = store.count();
+    const statusReadIssues = [...readIssues];
+    let startupWarning = "";
+    if (!statusReadIssues.some((issue) => issue.component === "database")) {
+      try {
+        startupWarning = database.getMetadata(STARTUP_WARNING_METADATA_KEY) ?? "";
+      } catch (error) {
+        const message = this.getDatabaseReadIssueMessage();
+        statusReadIssues.push(this.createReadIssue("database", message));
+        if (!this.readIssues.some((issue) => issue.component === "database")) {
+          this.recordReadIssue("database", message, error);
+        }
+      }
+    }
+    const readWarning = statusReadIssues.map((issue) => issue.message).join(" ");
+    const warning = [readWarning, startupWarning].filter((message) => message.length > 0).join(" ");
+    const hasBlockingReadIssue = statusReadIssues.some((issue) => issue.blocking);
     return {
-      indexed: store.count() > 0,
-      vectorCount: store.count(),
+      indexed: vectorCount > 0 && !hasBlockingReadIssue,
+      vectorCount,
       provider: configuredProviderInfo.provider,
       model: configuredProviderInfo.modelInfo.model,
       indexPath: this.indexPath,
       currentBranch: this.currentBranch,
       baseBranch: this.baseBranch,
-      compatibility: this.indexCompatibility,
+      compatibility,
       failedBatchesCount,
       failedBatchesPath: failedBatchesCount > 0 ? this.failedBatchesPath : void 0,
-      warning: database.getMetadata(STARTUP_WARNING_METADATA_KEY) ?? void 0
+      warning: warning || void 0
     };
   }
+  async forceIndex(onProgress) {
+    return this.withIndexMutationLease("force-index", async (recoveredOwners) => {
+      await this.ensureInitializedUnlocked(recoveredOwners);
+      await this.clearIndexUnlocked();
+      return this.indexUnlocked(onProgress, [], true);
+    });
+  }
   async clearIndex() {
-    const { store, invertedIndex, database } = await this.ensureInitialized();
+    await this.withIndexMutationLease("clear", async (recoveredOwners) => {
+      await this.ensureInitializedUnlocked(recoveredOwners);
+      await this.clearIndexUnlocked();
+    });
+  }
+  async clearIndexUnlocked() {
+    const { store, invertedIndex, database } = this.requireLoadedIndexState();
     if (this.config.scope === "global") {
       store.load();
       invertedIndex.load();
@@ -8233,7 +9187,7 @@ var Indexer = class {
         store.clear();
         store.save();
         invertedIndex.clear();
-        invertedIndex.save();
+        this.saveInvertedIndex(invertedIndex);
         this.fileHashCache.clear();
         this.saveFileHashCache();
         database.clearAllIndexedData();
@@ -8257,14 +9211,7 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPaths = [path12.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
-    if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path12.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
-    }
-    const isLocalProjectIndex = localProjectIndexPaths.some(
-      (localPath) => path12.resolve(this.indexPath) === path12.resolve(localPath)
-    );
-    if (!isLocalProjectIndex) {
+    if (!this.isLocalProjectIndexPath()) {
       throw new Error(
         "Project-scoped force rebuild is unsafe while using an inherited worktree index. Create a local project config boundary before clearing the index."
       );
@@ -8272,7 +9219,7 @@ var Indexer = class {
     store.clear();
     store.save();
     invertedIndex.clear();
-    invertedIndex.save();
+    this.saveInvertedIndex(invertedIndex);
     this.fileHashCache.clear();
     this.saveFileHashCache();
     database.clearAllIndexedData();
@@ -8290,7 +9237,13 @@ var Indexer = class {
     this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
   }
   async healthCheck() {
-    const { store, invertedIndex, database } = await this.ensureInitialized();
+    return this.withIndexMutationLease("health-check", async (recoveredOwners) => {
+      await this.ensureInitializedUnlocked(recoveredOwners);
+      return this.healthCheckUnlocked();
+    });
+  }
+  async healthCheckUnlocked() {
+    const { store, invertedIndex, database } = this.requireLoadedIndexState();
     this.logger.gc("info", "Starting health check");
     const allMetadata = store.getAllMetadata();
     const filePathsToChunkKeys = /* @__PURE__ */ new Map();
@@ -8303,7 +9256,7 @@ var Indexer = class {
     const removedChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync7(filePath)) {
+      if (!existsSync8(filePath)) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           removedChunkKeys.push(key);
@@ -8328,7 +9281,7 @@ var Indexer = class {
     const removedCount = removedChunkKeys.length;
     if (removedCount > 0) {
       store.save();
-      invertedIndex.save();
+      this.saveInvertedIndex(invertedIndex);
     }
     let gcOrphanEmbeddings;
     let gcOrphanChunks;
@@ -8343,7 +9296,7 @@ var Indexer = class {
       if (!await this.tryResetCorruptedIndex("running index health check", error)) {
         throw error;
       }
-      await this.ensureInitialized();
+      await this.initializeUnlocked("writer", [], { skipAutoGc: true });
       return {
         removed: 0,
         filePaths: [],
@@ -8352,7 +9305,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8365,7 +9318,13 @@ var Indexer = class {
     return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks, gcOrphanSymbols, gcOrphanCallEdges };
   }
   async retryFailedBatches() {
-    const { store, provider, invertedIndex, database, configuredProviderInfo } = await this.ensureInitialized();
+    return this.withIndexMutationLease("retry-failed-batches", async (recoveredOwners) => {
+      await this.ensureInitializedUnlocked(recoveredOwners);
+      return this.retryFailedBatchesUnlocked();
+    });
+  }
+  async retryFailedBatchesUnlocked() {
+    const { store, provider, invertedIndex, database, configuredProviderInfo } = this.requireLoadedIndexState();
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
     const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
@@ -8529,7 +9488,7 @@ var Indexer = class {
     }
     if (succeeded > 0) {
       store.save();
-      invertedIndex.save();
+      this.saveInvertedIndex(invertedIndex);
     }
     if (roots && succeeded > 0 && persistedStillFailing.length === 0 && this.hasProjectForceReembedPending()) {
       database.deleteMetadata(this.getProjectForceReembedMetadataKey());
@@ -8557,15 +9516,16 @@ var Indexer = class {
     }
   }
   async getDatabaseStats() {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     return database.getStats();
   }
   getLogger() {
     return this.logger;
   }
   async findSimilar(code, limit = this.config.search.maxResults, options) {
-    const { store, provider, database } = await this.ensureInitialized();
-    const compatibility = this.checkCompatibility();
+    const { store, provider, database, readIssues, compatibility } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "vectors", "database");
     if (!compatibility.compatible) {
       throw new Error(
         `${compatibility.reason ?? "Index is incompatible with current embedding provider."} Run index_codebase with force=true to rebuild the index.`
@@ -8679,7 +9639,8 @@ var Indexer = class {
     );
   }
   async getCallers(targetName, callTypeFilter) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const seen = /* @__PURE__ */ new Set();
     const results = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
@@ -8693,7 +9654,8 @@ var Indexer = class {
     return results;
   }
   async getCallees(symbolId, callTypeFilter) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const seen = /* @__PURE__ */ new Set();
     const results = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
@@ -8707,43 +9669,50 @@ var Indexer = class {
     return results;
   }
   async findCallPath(fromName, toName, maxDepth) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path23 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path23.length > 0 && (shortest.length === 0 || path23.length < shortest.length)) {
-        shortest = path23;
+      const path24 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path24.length > 0 && (shortest.length === 0 || path24.length < shortest.length)) {
+        shortest = path24;
       }
     }
     return shortest;
   }
   async getSymbolsForBranch(branch) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
     return database.getSymbolsForBranch(resolvedBranch);
   }
   async getSymbolsForFiles(filePaths, branch) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
     return database.getSymbolsForFiles(filePaths, resolvedBranch);
   }
   async getTransitiveReachability(rootSymbolIds, direction, maxDepth) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const branch = this.getBranchCatalogKey();
     return database.getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth);
   }
   async detectCommunities(branch, symbolIds) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
     return database.detectCommunities(resolvedBranch, symbolIds);
   }
   async computeCentrality(branch) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
     return database.computeCentrality(resolvedBranch);
   }
   async getPrImpact(opts) {
-    const { database } = await this.ensureInitialized();
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
     const execFileAsync3 = promisify3(execFile3);
     const changedFilesResult = await getChangedFiles({
       pr: opts.pr,
@@ -8766,7 +9735,7 @@ var Indexer = class {
         "Run index_codebase first to build the call graph and symbol index for this branch."
       );
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path12.resolve(this.projectRoot, f));
+    const absoluteChangedFiles = changedFiles.map((f) => path13.resolve(this.projectRoot, f));
     const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
@@ -8849,7 +9818,7 @@ var Indexer = class {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path12.resolve(this.projectRoot, f));
+            const otherAbsolute = otherChanged.files.map((f) => path13.resolve(this.projectRoot, f));
             const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
             const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
@@ -8899,7 +9868,8 @@ var Indexer = class {
     };
   }
   async getVisualizationData(options) {
-    const { database, store } = await this.ensureInitialized();
+    const { database, store, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "vectors", "database");
     const seenSymbols = /* @__PURE__ */ new Map();
     const seenEdges = /* @__PURE__ */ new Map();
     for (const branchKey of this.getBranchCatalogKeys()) {
@@ -8912,12 +9882,12 @@ var Indexer = class {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path12.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path13.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path12.resolve(filePath);
+          const absoluteFilePath = path13.resolve(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path12.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path13.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -8939,53 +9909,64 @@ var Indexer = class {
     return { symbols: [...seenSymbols.values()], edges: [...seenEdges.values()] };
   }
   async close() {
-    await this.database?.close();
+    this.database?.close();
+    for (const database of this.retiredDatabases) {
+      database.close();
+    }
+    this.retiredDatabases = [];
     this.database = null;
     this.store = null;
     this.invertedIndex = null;
     this.provider = null;
     this.reranker = null;
+    this.configuredProviderInfo = null;
+    this.indexCompatibility = null;
+    this.initializationMode = "none";
+    this.readIssues = [];
+    this.readerArtifactFingerprint = null;
+    this.writerArtifactFingerprint = null;
+    this.readerArtifactRetryAfter.clear();
   }
 };
 
 // src/tools/knowledge-base-paths.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
-  return path13.normalize(absolutePath);
+  const absolutePath = path14.isAbsolute(trimmed) ? trimmed : path14.resolve(baseDir, trimmed);
+  return path14.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path13.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path13.normalize(trimmed));
+  if (!path14.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path14.normalize(trimmed));
   }
-  const relativePath = path13.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path13.normalize(relativePath || "."));
+  const relativePath = path14.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path14.normalize(relativePath || "."));
   }
-  return path13.normalize(trimmed);
+  return path14.normalize(trimmed);
 }
 function resolveKnowledgeBasePath(value, projectRoot) {
-  return path13.isAbsolute(value) ? value : path13.resolve(projectRoot, value);
+  return path14.isAbsolute(value) ? value : path14.resolve(projectRoot, value);
 }
 function normalizeKnowledgeBasePath2(value, projectRoot) {
-  return path13.normalize(resolveKnowledgeBasePath(value, projectRoot));
+  return path14.normalize(resolveKnowledgeBasePath(value, projectRoot));
 }
 function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path13.normalize(inputPath);
+  const normalizedInput = path14.normalize(inputPath);
   return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput);
 }
 function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path13.normalize(inputPath);
+  const normalizedInput = path14.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path13.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
+    (kb) => path14.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
   );
 }
 
@@ -9085,6 +10066,10 @@ function formatStatus(status) {
       lines.push(`Failed batches: ${status.failedBatchesPath}`);
     }
   }
+  if (status.warning) {
+    lines.push("");
+    lines.push(`INDEX WARNING: ${status.warning}`);
+  }
   if (status.compatibility && !status.compatibility.compatible) {
     lines.push("");
     lines.push(`COMPATIBILITY WARNING: ${status.compatibility.reason}`);
@@ -9190,16 +10175,16 @@ function formatCallGraphCallees(symbolId, callees, relationshipType) {
     return `[${index + 1}] \u2192 ${edge.targetName} (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? ` [resolved: ${edge.toSymbolId}]` : " [unresolved]"}`;
   }).join("\n");
 }
-function formatCallGraphPath(from, to, path23) {
-  if (path23.length === 0) {
+function formatCallGraphPath(from, to, path24) {
+  if (path24.length === 0) {
     return `No path found between "${from}" and "${to}". They may be in disconnected components, or the call graph index needs updating.`;
   }
-  const formatted = path23.map((hop, index) => {
+  const formatted = path24.map((hop, index) => {
     const prefix = index === 0 ? "[start]" : `--${hop.callType}-->`;
     const location = hop.filePath ? ` (${hop.filePath}:${hop.line})` : "";
     return `${prefix} ${hop.symbolName}${location}`;
   });
-  return `Path (${path23.length} hops):
+  return `Path (${path24.length} hops):
 ${formatted.join("\n")}`;
 }
 function formatResultHeader(result, index) {
@@ -9239,8 +10224,8 @@ ${truncateContent(r.content)}
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import * as path14 from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import * as path15 from "path";
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -9267,10 +10252,10 @@ function loadEditableConfig(projectRoot, host = "opencode") {
 }
 function saveConfig(projectRoot, config, host = "opencode") {
   const configPath = getConfigPath(projectRoot, host);
-  const configDir = path14.dirname(configPath);
-  const configBaseDir = path14.dirname(configDir);
-  if (!existsSync8(configDir)) {
-    mkdirSync3(configDir, { recursive: true });
+  const configDir = path15.dirname(configPath);
+  const configBaseDir = path15.dirname(configDir);
+  if (!existsSync9(configDir)) {
+    mkdirSync4(configDir, { recursive: true });
   }
   const serializableConfig = { ...config };
   if (Array.isArray(serializableConfig.knowledgeBases)) {
@@ -9278,13 +10263,31 @@ function saveConfig(projectRoot, config, host = "opencode") {
       (kb) => serializeConfigPathValue(kb, configBaseDir)
     );
   }
-  writeFileSync3(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+  writeFileSync4(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/tools/operations.ts
 var indexerCache = /* @__PURE__ */ new Map();
 var configCache = /* @__PURE__ */ new Map();
 var defaultProjectRoots = /* @__PURE__ */ new Map();
+function getIndexBusyResult(error) {
+  if (!isIndexLockContentionError(error)) return null;
+  const owner = error.owner;
+  const ownerText = owner ? `PID ${owner.pid}, operation ${owner.operation}, since ${owner.startedAt}` : "unreadable owner";
+  if (error.reason === "legacy-lock") {
+    return {
+      kind: "busy",
+      text: `INDEX_BUSY: legacy lock format detected (${ownerText}). Verify the PID and remove this lock manually only if it is stale.`
+    };
+  }
+  if (error.reason === "unknown-owner") {
+    return {
+      kind: "busy",
+      text: `INDEX_BUSY: unreadable or remote lock owner (${ownerText}). Automatic recovery was refused; manual verification is required.`
+    };
+  }
+  return { kind: "busy", text: `INDEX_BUSY: another index operation is already in progress (${ownerText}).` };
+}
 function getProjectRoot(projectRoot, host) {
   if (projectRoot) {
     return projectRoot;
@@ -9329,8 +10332,8 @@ function refreshIndexerForDirectory(projectRoot, host = "opencode", config = par
 }
 function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
   const root = getProjectRoot(projectRoot, host);
-  const localIndexPath = path15.join(root, getHostProjectIndexRelativePath(host));
-  if (existsSync9(localIndexPath)) {
+  const localIndexPath = path16.join(root, getHostProjectIndexRelativePath(host));
+  if (existsSync10(localIndexPath)) {
     return false;
   }
   const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
@@ -9386,35 +10389,46 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
   const key = getIndexerCacheKey(root, host);
-  const cachedConfig = configCache.get(key);
   let indexer = getIndexerForProject(root, host);
-  if (args.estimateOnly) {
-    return { kind: "estimate", estimate: await indexer.estimateCost() };
-  }
-  if (args.force) {
-    if (shouldForceLocalizeProjectIndex(root, host)) {
-      materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
-      refreshIndexerForDirectory(root, host, cachedConfig);
-      indexer = getIndexerForProject(root, host);
-    }
-    await indexer.clearIndex();
-    refreshIndexerForDirectory(root, host, cachedConfig);
-    indexer = getIndexerForProject(root, host);
-  }
-  const stats = await indexer.index((progress) => {
-    if (onProgress) {
-      return onProgress(formatProgressTitle(progress), {
-        phase: progress.phase,
-        filesProcessed: progress.filesProcessed,
-        totalFiles: progress.totalFiles,
-        chunksProcessed: progress.chunksProcessed,
-        totalChunks: progress.totalChunks,
-        percentage: calculatePercentage(progress)
+  const runtimeConfig = configCache.get(key);
+  try {
+    if (args.estimateOnly) {
+      return { kind: "estimate", estimate: await indexer.estimateCost() };
+    }
+    const runIndex = async (target) => {
+      const operation = args.force ? target.forceIndex.bind(target) : target.index.bind(target);
+      return operation((progress) => {
+        if (onProgress) {
+          return onProgress(formatProgressTitle(progress), {
+            phase: progress.phase,
+            filesProcessed: progress.filesProcessed,
+            totalFiles: progress.totalFiles,
+            chunksProcessed: progress.chunksProcessed,
+            totalChunks: progress.totalChunks,
+            percentage: calculatePercentage(progress)
+          });
+        }
+        return Promise.resolve();
       });
+    };
+    let stats;
+    if (args.force && shouldForceLocalizeProjectIndex(root, host)) {
+      const inheritedIndexPath = resolveProjectIndexPath(root, runtimeConfig.scope, host);
+      stats = await withIndexLock(inheritedIndexPath, "force-index", async () => {
+        materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
+        refreshIndexerForDirectory(root, host, runtimeConfig);
+        indexer = getIndexerForProject(root, host);
+        return runIndex(indexer);
+      }, { completeRecoveries: false });
+    } else {
+      stats = await runIndex(indexer);
     }
-    return Promise.resolve();
-  });
-  return { kind: "stats", stats };
+    return { kind: "stats", stats };
+  } catch (error) {
+    const busyResult = getIndexBusyResult(error);
+    if (!busyResult) throw error;
+    return busyResult;
+  }
 }
 async function getIndexStatus(projectRoot, host) {
   const indexer = getIndexerForProject(projectRoot, host);
@@ -9424,6 +10438,15 @@ async function getIndexHealthCheck(projectRoot, host) {
   const indexer = getIndexerForProject(projectRoot, host);
   return indexer.healthCheck();
 }
+async function runIndexHealthCheck(projectRoot, host) {
+  try {
+    return { kind: "health", health: await getIndexHealthCheck(projectRoot, host) };
+  } catch (error) {
+    const busyResult = getIndexBusyResult(error);
+    if (!busyResult) throw error;
+    return busyResult;
+  }
+}
 async function getIndexMetrics(projectRoot, host) {
   const indexer = getIndexerForProject(projectRoot, host);
   const logger = indexer.getLogger();
@@ -9479,15 +10502,15 @@ async function getIndexLogs(projectRoot, host, args) {
 function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath = path15.resolve(
-    path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  const normalizedPath = path16.resolve(
+    path16.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
-  if (!existsSync9(normalizedPath)) {
+  if (!existsSync10(normalizedPath)) {
     return `Error: Directory does not exist: ${normalizedPath}`;
   }
   let realPath;
   try {
-    realPath = realpathSync(normalizedPath);
+    realPath = realpathSync2(normalizedPath);
   } catch {
     return `Error: Cannot resolve path: ${normalizedPath}`;
   }
@@ -9516,13 +10539,13 @@ function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path15.join(homeDir, dotDir);
+    const sensitiveDir = path16.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
     }
   }
   try {
-    const stat4 = statSync3(normalizedPath);
+    const stat4 = statSync4(normalizedPath);
     if (!stat4.isDirectory()) {
       return `Error: Path is not a directory: ${normalizedPath}`;
     }
@@ -9562,7 +10585,7 @@ function listKnowledgeBases(projectRoot, host) {
   for (let i = 0; i < knowledgeBases.length; i++) {
     const kb = knowledgeBases[i];
     const resolvedPath = resolveKnowledgeBasePath(kb, root);
-    const exists = existsSync9(resolvedPath);
+    const exists = existsSync10(resolvedPath);
     result += `[${i + 1}] ${kb}
 `;
     result += `    Resolved: ${resolvedPath}
@@ -9571,7 +10594,7 @@ function listKnowledgeBases(projectRoot, host) {
 `;
     if (exists) {
       try {
-        const stat4 = statSync3(resolvedPath);
+        const stat4 = statSync4(resolvedPath);
         result += `    Type: ${stat4.isDirectory() ? "Directory" : "File"}
 `;
       } catch {
@@ -9579,7 +10602,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync9(path15.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync10(path16.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -9702,7 +10725,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path24) => statMethod(path24, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -9727,8 +10750,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          const { path: path24, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -9768,20 +10791,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path24, depth) {
     let files;
     try {
-      files = await readdir(path23, this._rdOptions);
+      files = await readdir(path24, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path24 };
   }
-  async _formatEntry(dirent, path23) {
+  async _formatEntry(dirent, path24) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path23, basename5));
+      const fullPath = presolve(pjoin(path24, basename5));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -10181,16 +11204,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path24, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
+    listener(path24);
+    emitRaw(rawEvent, evPath, { watchedPath: path24 });
+    if (evPath && path24 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path24, evPath), KEY_LISTENERS, sp.join(path24, evPath));
     }
   };
   try {
-    return fs_watch(path23, {
+    return fs_watch(path24, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -10206,12 +11229,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, fullPath, options, handlers) => {
+var setFsWatchListener = (path24, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path24, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -10222,7 +11245,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path24,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -10237,7 +11260,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path23, "r");
+          const fd = await open(path24, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -10268,7 +11291,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path24, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -10290,7 +11313,7 @@ var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path24, curr));
         }
       })
     };
@@ -10320,13 +11343,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path24, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path23);
-    const basename5 = sp.basename(path23);
+    const directory = sp.dirname(path24);
+    const basename5 = sp.basename(path24);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path23);
+    const absolutePath = sp.resolve(path24);
     const options = {
       persistent: opts.persistent
     };
@@ -10336,12 +11359,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path23, absolutePath, options, {
+      closer = setFsWatchFileListener(path24, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options, {
+      closer = setFsWatchListener(path24, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -10363,7 +11386,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path23, newStats) => {
+    const listener = async (path24, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -10377,11 +11400,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path24);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, closer2);
+              this.fsw._addPathCloser(path24, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -10413,7 +11436,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, path23, item) {
+  async _handleSymlink(entry, directory, path24, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -10423,7 +11446,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path23);
+        linkPath = await fsrealpath(path24);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -10433,12 +11456,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, path23, entry.stats);
+          this.fsw._emit(EV.CHANGE, path24, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path24, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -10468,9 +11491,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sp.join(directory, item);
+      let path24 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -10479,8 +11502,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sp.join(dir, sp.relative(dir, path23));
-        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+        path24 = sp.join(dir, sp.relative(dir, path24));
+        this._addToNodeFs(path24, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve13, reject) => {
@@ -10549,13 +11572,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path24);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -10571,8 +11594,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path23);
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const absPath = sp.resolve(path24);
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -10582,29 +11605,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         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, path23, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path24), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path24, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path23;
+        return path24;
       }
     }
   }
@@ -10647,24 +11670,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path24) {
+  if (typeof path24 !== "string")
     throw new Error("string expected");
-  path23 = sp2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path24 = sp2.normalize(path24);
+  path24 = path24.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path24.startsWith("//"))
     prepend = true;
-  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
+  path24 = path24.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path24 = "/" + path24;
+  return path24;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path24 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path24, stats)) {
       return true;
     }
   }
@@ -10702,19 +11725,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
+var normalizePathToUnix = (path24) => toUnix(sp2.normalize(toUnix(path24)));
+var normalizeIgnored = (cwd = "") => (path24) => {
+  if (typeof path24 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path24) ? path24 : sp2.join(cwd, path24));
   } else {
-    return path23;
+    return path24;
   }
 };
-var getAbsolutePath = (path23, cwd) => {
-  if (sp2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path24, cwd) => {
+  if (sp2.isAbsolute(path24)) {
+    return path24;
   }
-  return sp2.join(cwd, path23);
+  return sp2.join(cwd, path24);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -10779,10 +11802,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path23, follow, fsw) {
+  constructor(path24, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path24;
+    this.path = path24 = path24.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -10922,20 +11945,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd);
+      paths = paths.map((path24) => {
+        const absPath = getAbsolutePath(path24, cwd);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    paths.forEach((path24) => {
+      this._removeIgnoredPath(path24);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path24) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -10957,17 +11980,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path23) => {
-      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path24) => {
+      if (!sp2.isAbsolute(path24) && !this._closers.has(path24)) {
         if (cwd)
-          path23 = sp2.join(cwd, path23);
-        path23 = sp2.resolve(path23);
+          path24 = sp2.join(cwd, path24);
+        path24 = sp2.resolve(path24);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path24);
+      this._addIgnoredPath(path24);
+      if (this._watched.has(path24)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path24,
           recursive: true
         });
       }
@@ -11031,38 +12054,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, path23, stats) {
+  async _emit(event, path24, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sp2.normalize(path23);
+      path24 = sp2.normalize(path24);
     if (opts.cwd)
-      path23 = sp2.relative(opts.cwd, path23);
-    const args = [path23];
+      path24 = sp2.relative(opts.cwd, path24);
+    const args = [path24];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path24))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path24, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path25) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path25);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path24);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -11080,16 +12103,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 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, path23) : path23;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path24) : path24;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -11120,23 +12143,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, path23, timeout) {
+  _throttle(actionType, path24, 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(path23);
+    const actionPath = action.get(path24);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path24);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path24);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -11144,7 +12167,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path24, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -11158,44 +12181,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, threshold, event, awfEmit) {
+  _awaitWriteFinish(path24, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path23;
-    if (this.options.cwd && !sp2.isAbsolute(path23)) {
-      fullPath = sp2.join(this.options.cwd, path23);
+    let fullPath = path24;
+    if (this.options.cwd && !sp2.isAbsolute(path24)) {
+      fullPath = sp2.join(this.options.cwd, path24);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path23)) {
+        if (err || !writes.has(path24)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path23).lastChange = now2;
+          writes.get(path24).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path24);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path24);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path24)) {
+      writes.set(path24, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path24);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -11206,8 +12229,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path24, stats) {
+    if (this.options.atomic && DOT_RE.test(path24))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -11217,17 +12240,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path24, stats);
   }
-  _isntIgnored(path23, stat4) {
-    return !this._isIgnored(path23, stat4);
+  _isntIgnored(path24, stat4) {
+    return !this._isIgnored(path24, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path24) {
+    return new WatchHelper(path24, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -11259,63 +12282,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 100))
+    const path24 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path24);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path24, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path23);
+    const wp = this._getWatchedDir(path24);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path24, 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 = path23;
+    let relPath = path24;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path23);
+      relPath = sp2.relative(this.options.cwd, path24);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path23);
+    this._watched.delete(path24);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path24))
+      this._emit(eventName, path24);
+    this._closePath(path24);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sp2.dirname(path23);
-    this._getWatchedDir(dir).remove(sp2.basename(path23));
+  _closePath(path24) {
+    this._closeFile(path24);
+    const dir = sp2.dirname(path24);
+    this._getWatchedDir(dir).remove(sp2.basename(path24));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path24) {
+    const closers = this._closers.get(path24);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path24);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path24, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path24);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path24, list);
     }
     list.push(closer);
   }
@@ -11345,7 +12368,7 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-import * as path16 from "path";
+import * as path17 from "path";
 var FileWatcher = class {
   watcher = null;
   projectRoot;
@@ -11356,6 +12379,8 @@ var FileWatcher = class {
   debounceTimer = null;
   debounceMs = 1e3;
   onChanges = null;
+  readyPromise = null;
+  resolveReady = null;
   constructor(projectRoot, config, host = "opencode", options = {}) {
     this.projectRoot = projectRoot;
     this.config = config;
@@ -11371,15 +12396,15 @@ var FileWatcher = class {
     const watchTargets = this.configPath ? [this.projectRoot, this.configPath] : this.projectRoot;
     this.watcher = chokidar_default.watch(watchTargets, {
       ignored: (filePath) => {
-        const relativePath = path16.relative(this.projectRoot, filePath);
+        const relativePath = path17.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
         }
-        if (hasFilteredPathSegment(relativePath, path16.sep)) {
+        if (hasFilteredPathSegment(relativePath, path17.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path16.sep)) {
+        if (isRestrictedDirectory(relativePath, path17.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -11394,6 +12419,13 @@ var FileWatcher = class {
         pollInterval: 100
       }
     });
+    this.readyPromise = new Promise((resolve13) => {
+      this.resolveReady = resolve13;
+    });
+    this.watcher.once("ready", () => {
+      this.resolveReady?.();
+      this.resolveReady = null;
+    });
     this.watcher.on("error", (error) => {
       const err = error instanceof Error ? error : null;
       if (err?.code === "EPERM" || err?.code === "EACCES") {
@@ -11425,24 +12457,24 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path16.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path16.normalize(relativePath);
+    const relativePath = path17.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path17.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path16.normalize(relativePath);
+    const normalizedRelativePath = path17.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path16.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path17.sep}`)
     );
   }
   getProjectConfigRelativePaths() {
     if (this.configPath) {
-      return [path16.normalize(path16.relative(this.projectRoot, this.configPath))];
+      return [path17.normalize(path17.relative(this.projectRoot, this.configPath))];
     }
     return [
       resolveProjectConfigPath(this.projectRoot, this.host),
       resolveWritableProjectConfigPath(this.projectRoot, this.host)
-    ].map((configPath) => path16.normalize(path16.relative(this.projectRoot, configPath)));
+    ].map((configPath) => path17.normalize(path17.relative(this.projectRoot, configPath)));
   }
   scheduleFlush() {
     if (this.debounceTimer) {
@@ -11457,7 +12489,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path23, type]) => ({ path: path23, type })
+      ([path24, type]) => ({ path: path24, type })
     );
     this.pendingChanges.clear();
     try {
@@ -11466,25 +12498,32 @@ var FileWatcher = class {
       console.error("Error handling file changes:", error);
     }
   }
-  stop() {
+  async stop() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
     if (this.watcher) {
-      this.watcher.close();
+      const watcher = this.watcher;
       this.watcher = null;
+      await watcher.close();
     }
+    this.resolveReady?.();
+    this.resolveReady = null;
+    this.readyPromise = null;
     this.pendingChanges.clear();
     this.onChanges = null;
   }
   isRunning() {
     return this.watcher !== null;
   }
+  async waitUntilReady() {
+    await (this.readyPromise ?? Promise.resolve());
+  }
 };
 
 // src/watcher/git-head-watcher.ts
-import * as path17 from "path";
+import * as path18 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -11506,7 +12545,7 @@ var GitHeadWatcher = class {
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path17.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path18.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -11543,14 +12582,15 @@ var GitHeadWatcher = class {
   getCurrentBranch() {
     return this.currentBranch;
   }
-  stop() {
+  async stop() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
     if (this.watcher) {
-      this.watcher.close();
+      const watcher = this.watcher;
       this.watcher = null;
+      await watcher.close();
     }
     this.onBranchChange = null;
   }
@@ -11568,6 +12608,8 @@ var BackgroundReindexer = class {
   running = false;
   pending = false;
   stopped = false;
+  retryTimer = null;
+  retryDelayMs = 50;
   request() {
     if (this.stopped) {
       return;
@@ -11578,9 +12620,13 @@ var BackgroundReindexer = class {
   stop() {
     this.stopped = true;
     this.pending = false;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
   }
   drain() {
-    if (this.stopped || this.running || !this.pending) {
+    if (this.stopped || this.running || this.retryTimer || !this.pending) {
       return;
     }
     this.pending = false;
@@ -11588,13 +12634,29 @@ var BackgroundReindexer = class {
     void this.run();
   }
   async run() {
+    let retryAfterContention = false;
     try {
       await this.runIndex();
+      this.retryDelayMs = 50;
     } catch (error) {
-      console.error("[codebase-index] Background reindex failed:", error);
+      if (isTransientIndexLockContention(error)) {
+        this.pending = true;
+        retryAfterContention = true;
+      } else {
+        console.error("[codebase-index] Background reindex failed:", error);
+      }
     } finally {
       this.running = false;
-      this.drain();
+      if (retryAfterContention && !this.stopped) {
+        const delay = this.retryDelayMs;
+        this.retryDelayMs = Math.min(this.retryDelayMs * 2, 500);
+        this.retryTimer = setTimeout(() => {
+          this.retryTimer = null;
+          this.drain();
+        }, delay);
+      } else {
+        this.drain();
+      }
     }
   }
 };
@@ -11628,10 +12690,12 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config, host = "openc
   return {
     fileWatcher,
     gitWatcher,
-    stop() {
+    whenReady() {
+      return fileWatcher.waitUntilReady();
+    },
+    async stop() {
       backgroundReindexer.stop();
-      fileWatcher.stop();
-      gitWatcher?.stop();
+      await Promise.all([fileWatcher.stop(), gitWatcher?.stop()]);
     }
   };
 }
@@ -11737,13 +12801,13 @@ var pr_impact = tool({
 });
 
 // src/tools/index.ts
-import { writeFileSync as writeFileSync4 } from "fs";
-import * as os4 from "os";
-import * as path20 from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+import * as os5 from "os";
+import * as path21 from "path";
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path18 from "path";
+import * as path19 from "path";
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -11905,7 +12969,7 @@ function normalizePath2(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path18.isAbsolute(filePath) ? path18.relative(projectRoot, filePath) : filePath;
+  const relativePath = path19.isAbsolute(filePath) ? path19.relative(projectRoot, filePath) : filePath;
   return normalizePath2(relativePath);
 }
 
@@ -12163,7 +13227,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-import * as path19 from "path";
+import * as path20 from "path";
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -12423,7 +13487,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path19.dirname(s.filePath),
+    directory: path20.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -12504,7 +13568,9 @@ var index_codebase = tool2({
     const result = await runIndexCodebase(context?.worktree, DEFAULT_HOST, args, (title, metadata) => {
       context.metadata({ title, metadata });
     });
-    return result.kind === "estimate" ? formatCostEstimate(result.estimate) : formatIndexStats(result.stats, args.verbose ?? false);
+    if (result.kind === "estimate") return formatCostEstimate(result.estimate);
+    if (result.kind === "busy") return result.text;
+    return formatIndexStats(result.stats, args.verbose ?? false);
   }
 });
 var index_status = tool2({
@@ -12518,7 +13584,9 @@ var index_health_check = tool2({
   description: "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
   args: {},
   async execute(_args, context) {
-    return formatHealthCheck(await getIndexHealthCheck(context?.worktree, DEFAULT_HOST));
+    const result = await runIndexHealthCheck(context?.worktree, DEFAULT_HOST);
+    if (result.kind === "busy") return result.text;
+    return formatHealthCheck(result.health);
   }
 });
 var index_metrics = tool2({
@@ -12638,8 +13706,8 @@ var call_graph_path = tool2({
     maxDepth: z2.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
   },
   async execute(args, context) {
-    const path23 = await getCallGraphPath(context?.worktree, DEFAULT_HOST, args.from, args.to, args.maxDepth);
-    return formatCallGraphPath(args.from, args.to, path23);
+    const path24 = await getCallGraphPath(context?.worktree, DEFAULT_HOST, args.from, args.to, args.maxDepth);
+    return formatCallGraphPath(args.from, args.to, path24);
   }
 });
 var add_knowledge_base = tool2({
@@ -12692,8 +13760,8 @@ var index_visualize = tool2({
       return "No connected symbols found for visualization. Try including orphans with includeOrphans=true, or check that the call graph has resolved edges.";
     }
     const html = generateVisualizationHtml(vizData);
-    const outputPath = path20.join(os4.tmpdir(), `call-graph-${Date.now()}.html`);
-    writeFileSync4(outputPath, html, "utf-8");
+    const outputPath = path21.join(os5.tmpdir(), `call-graph-${Date.now()}.html`);
+    writeFileSync5(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
 `;
@@ -12714,8 +13782,8 @@ var index_visualize = tool2({
 });
 
 // src/commands/loader.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
-import * as path21 from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
+import * as path22 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -12736,21 +13804,21 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!existsSync10(commandsDir)) {
+  if (!existsSync11(commandsDir)) {
     return commands;
   }
-  const files = readdirSync2(commandsDir).filter((f) => f.endsWith(".md"));
+  const files = readdirSync3(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path21.join(commandsDir, file);
+    const filePath = path22.join(commandsDir, file);
     let content;
     try {
-      content = readFileSync7(filePath, "utf-8");
+      content = readFileSync8(filePath, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path21.basename(file, ".md");
+    const name = path22.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -13054,18 +14122,37 @@ var RoutingHintController = class {
 };
 
 // src/utils/auto-index.ts
+var INITIAL_RETRY_DELAY_MS = 50;
+var MAX_RETRY_DELAY_MS = 500;
+var autoIndexStates = /* @__PURE__ */ new WeakMap();
 function getErrorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function startAutoIndex(indexer, projectRoot) {
-  indexer.initialize().then(() => {
-    indexer.index().catch((error) => {
-      console.error(`[codebase-index] Auto-index failed for "${projectRoot}": ${getErrorMessage3(error)}`);
-    });
+function runAutoIndex(indexer, projectRoot, state) {
+  void indexer.index().then(() => {
+    autoIndexStates.delete(indexer);
   }).catch((error) => {
-    console.error(`[codebase-index] Auto-index initialization failed for "${projectRoot}": ${getErrorMessage3(error)}`);
+    if (!isTransientIndexLockContention(error)) {
+      autoIndexStates.delete(indexer);
+      console.error(`[codebase-index] Auto-index failed for "${projectRoot}": ${getErrorMessage3(error)}`);
+      return;
+    }
+    const retryDelayMs = state.retryDelayMs;
+    state.retryDelayMs = Math.min(retryDelayMs * 2, MAX_RETRY_DELAY_MS);
+    const retryTimer = setTimeout(() => {
+      runAutoIndex(indexer, projectRoot, state);
+    }, retryDelayMs);
+    retryTimer.unref?.();
   });
 }
+function startAutoIndex(indexer, projectRoot) {
+  if (autoIndexStates.has(indexer)) return;
+  const state = {
+    retryDelayMs: INITIAL_RETRY_DELAY_MS
+  };
+  autoIndexStates.set(indexer, state);
+  runAutoIndex(indexer, projectRoot, state);
+}
 
 // src/index.ts
 var activeWatchers = /* @__PURE__ */ new Map();
@@ -13082,9 +14169,9 @@ function replaceActiveWatcher(projectRoot, nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path22.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path23.dirname(fileURLToPath2(import.meta.url));
   }
-  return path22.join(currentDir, "..", "commands");
+  return path23.join(currentDir, "..", "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -13104,7 +14191,7 @@ var plugin = async ({ directory, worktree }) => {
     initializeTools2(projectRoot, config);
     const getProjectIndexer = () => getIndexerForProject2(projectRoot);
     const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus(), 200, config.search.routingGraphHandoffHints) : null;
-    const isHomeDir = path22.resolve(projectRoot) === path22.resolve(os5.homedir());
+    const isHomeDir = path23.resolve(projectRoot) === path23.resolve(os6.homedir());
     const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(projectRoot));
     if (isHomeDir) {
       console.warn(