opencode-codebase-index 0.13.2 → 0.15.0

package/dist/pi-extension.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(path15, checkUnignored, mode) {
+      test(path17, 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(path15);
+          const matched = rule[mode].test(path17);
           if (!matched) {
             return;
           }
@@ -520,17 +520,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path15, originalPath, doThrow) => {
-      if (!isString(path15)) {
+    var checkPath = (path17, originalPath, doThrow) => {
+      if (!isString(path17)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path15) {
+      if (!path17) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path15)) {
+      if (checkPath.isNotRelative(path17)) {
         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 = (path15) => REGEX_TEST_INVALID_PATH.test(path15);
+    var isNotRelative = (path17) => REGEX_TEST_INVALID_PATH.test(path17);
     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 path15 = originalPath && checkPath.convert(originalPath);
+        const path17 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path15,
+          path17,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path15, cache, checkUnignored, slices);
+        return this._t(path17, cache, checkUnignored, slices);
       }
-      checkIgnore(path15) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path15)) {
-          return this.test(path15);
+      checkIgnore(path17) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path17)) {
+          return this.test(path17);
         }
-        const slices = path15.split(SLASH).filter(Boolean);
+        const slices = path17.split(SLASH).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(path15, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path17, false, MODE_CHECK_IGNORE);
       }
-      _t(path15, cache, checkUnignored, slices) {
-        if (path15 in cache) {
-          return cache[path15];
+      _t(path17, cache, checkUnignored, slices) {
+        if (path17 in cache) {
+          return cache[path17];
         }
         if (!slices) {
-          slices = path15.split(SLASH).filter(Boolean);
+          slices = path17.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path15] = this._rules.test(path15, checkUnignored, MODE_IGNORE);
+          return cache[path17] = this._rules.test(path17, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -613,29 +613,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path15] = parent.ignored ? parent : this._rules.test(path15, checkUnignored, MODE_IGNORE);
+        return cache[path17] = parent.ignored ? parent : this._rules.test(path17, checkUnignored, MODE_IGNORE);
       }
-      ignores(path15) {
-        return this._test(path15, this._ignoreCache, false).ignored;
+      ignores(path17) {
+        return this._test(path17, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path15) => !this.ignores(path15);
+        return (path17) => !this.ignores(path17);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path15) {
-        return this._test(path15, this._testCache, true);
+      test(path17) {
+        return this._test(path17, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path15) => checkPath(path15 && checkPath.convert(path15), path15, RETURN_FALSE);
+    var isPathValid = (path17) => checkPath(path17 && checkPath.convert(path17), path17, 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 = (path15) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path15) || isNotRelative(path15);
+      checkPath.isNotRelative = (path17) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path17) || isNotRelative(path17);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,14 +651,14 @@ var require_ignore = __commonJS({
 });
 
 // src/pi-extension.ts
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 
 // 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}",
@@ -783,7 +783,8 @@ function getDefaultIndexingConfig() {
     requireProjectMarker: true,
     maxDepth: 5,
     maxFilesPerDirectory: 100,
-    fallbackToTextOnMaxChunks: true
+    fallbackToTextOnMaxChunks: true,
+    gitBlame: { enabled: false }
   };
 }
 function getDefaultSearchConfig() {
@@ -907,7 +908,10 @@ function parseConfig(raw) {
     requireProjectMarker: typeof rawIndexing.requireProjectMarker === "boolean" ? rawIndexing.requireProjectMarker : defaultIndexing.requireProjectMarker,
     maxDepth: typeof rawIndexing.maxDepth === "number" ? rawIndexing.maxDepth < -1 ? -1 : rawIndexing.maxDepth : defaultIndexing.maxDepth,
     maxFilesPerDirectory: typeof rawIndexing.maxFilesPerDirectory === "number" ? Math.max(1, rawIndexing.maxFilesPerDirectory) : defaultIndexing.maxFilesPerDirectory,
-    fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks
+    fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks,
+    gitBlame: {
+      enabled: rawIndexing.gitBlame && typeof rawIndexing.gitBlame === "object" && typeof rawIndexing.gitBlame.enabled === "boolean" ? rawIndexing.gitBlame.enabled : defaultIndexing.gitBlame.enabled
+    }
   };
   const rawSearch = input.search && typeof input.search === "object" ? input.search : {};
   const search = {
@@ -1323,8 +1327,8 @@ function formatPrImpact(result) {
 }
 
 // src/tools/operations.ts
-import { existsSync as existsSync9, realpathSync, statSync as statSync3 } from "fs";
-import * as path14 from "path";
+import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import * as path16 from "path";
 
 // src/config/merger.ts
 import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
@@ -1494,21 +1498,21 @@ function getProjectIndexRelativePath(host) {
       return CODEBASE_PROJECT_INDEX_RELATIVE_PATH;
   }
 }
-function resolveWorktreeFallbackPath(projectRoot2, relativePath) {
-  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot2);
+function resolveWorktreeFallbackPath(projectRoot3, relativePath) {
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot3);
   if (!mainRepoRoot) {
     return null;
   }
   const fallbackPath = path4.join(mainRepoRoot, relativePath);
   return existsSync4(fallbackPath) ? fallbackPath : null;
 }
-function resolveWorktreeFallbackProjectIndexPath(projectRoot2, host) {
-  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot2, getProjectIndexRelativePath(host));
+function resolveWorktreeFallbackProjectIndexPath(projectRoot3, host) {
+  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
   if (inheritedHostPath) {
     return inheritedHostPath;
   }
   if (host !== "opencode") {
-    return resolveWorktreeFallbackPath(projectRoot2, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+    return resolveWorktreeFallbackPath(projectRoot3, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
   }
   return null;
 }
@@ -1518,8 +1522,11 @@ function getHostProjectConfigRelativePath(host) {
 function getHostProjectIndexRelativePath(host) {
   return getProjectIndexRelativePath(host);
 }
-function hasHostProjectConfig(projectRoot2, host) {
-  return existsSync4(path4.join(projectRoot2, getProjectConfigRelativePath(host)));
+function hasHostProjectConfig(projectRoot3, host) {
+  return existsSync4(path4.join(projectRoot3, getProjectConfigRelativePath(host)));
+}
+function hasHostGlobalConfig(host) {
+  return existsSync4(getGlobalConfigPath(host));
 }
 function getGlobalIndexPath(host = "opencode") {
   switch (host) {
@@ -1560,6 +1567,9 @@ function resolveGlobalIndexPath(host = "opencode") {
     return hostIndexPath;
   }
   if (host !== "opencode") {
+    if (hasHostGlobalConfig(host)) {
+      return hostIndexPath;
+    }
     const legacyIndexPath = getGlobalIndexPath("opencode");
     if (existsSync4(legacyIndexPath)) {
       return legacyIndexPath;
@@ -1567,55 +1577,55 @@ function resolveGlobalIndexPath(host = "opencode") {
   }
   return hostIndexPath;
 }
-function resolveProjectConfigPath(projectRoot2, host = "opencode") {
-  const hostConfigPath = path4.join(projectRoot2, getProjectConfigRelativePath(host));
+function resolveProjectConfigPath(projectRoot3, host = "opencode") {
+  const hostConfigPath = path4.join(projectRoot3, getProjectConfigRelativePath(host));
   if (existsSync4(hostConfigPath)) {
     return hostConfigPath;
   }
   if (host !== "opencode") {
-    const legacyConfigPath = path4.join(projectRoot2, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+    const legacyConfigPath = path4.join(projectRoot3, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
     if (existsSync4(legacyConfigPath)) {
       return legacyConfigPath;
     }
   }
-  const hostFallback = resolveWorktreeFallbackPath(projectRoot2, getProjectConfigRelativePath(host));
+  const hostFallback = resolveWorktreeFallbackPath(projectRoot3, getProjectConfigRelativePath(host));
   if (hostFallback) {
     return hostFallback;
   }
   if (host !== "opencode") {
-    const legacyFallback = resolveWorktreeFallbackPath(projectRoot2, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+    const legacyFallback = resolveWorktreeFallbackPath(projectRoot3, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
     if (legacyFallback) {
       return legacyFallback;
     }
   }
   return hostConfigPath;
 }
-function resolveWritableProjectConfigPath(projectRoot2, host = "opencode") {
-  return path4.join(projectRoot2, getProjectConfigRelativePath(host));
+function resolveWritableProjectConfigPath(projectRoot3, host = "opencode") {
+  return path4.join(projectRoot3, getProjectConfigRelativePath(host));
 }
-function resolveProjectIndexPath(projectRoot2, scope, host = "opencode") {
+function resolveProjectIndexPath(projectRoot3, scope, host = "opencode") {
   if (scope === "global") {
     return resolveGlobalIndexPath(host);
   }
-  const localIndexPath = path4.join(projectRoot2, getProjectIndexRelativePath(host));
+  const localIndexPath = path4.join(projectRoot3, getProjectIndexRelativePath(host));
   if (existsSync4(localIndexPath)) {
     return localIndexPath;
   }
   if (host !== "opencode") {
-    const legacyIndexPath = path4.join(projectRoot2, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
-    if (existsSync4(legacyIndexPath) && !hasHostProjectConfig(projectRoot2, host)) {
+    const legacyIndexPath = path4.join(projectRoot3, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+    if (existsSync4(legacyIndexPath) && !hasHostProjectConfig(projectRoot3, host)) {
       return legacyIndexPath;
     }
   }
-  if (hasHostProjectConfig(projectRoot2, host)) {
+  if (hasHostProjectConfig(projectRoot3, host)) {
     return localIndexPath;
   }
-  const hostFallback = resolveWorktreeFallbackPath(projectRoot2, getProjectIndexRelativePath(host));
+  const hostFallback = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
   if (hostFallback) {
     return hostFallback;
   }
   if (host !== "opencode") {
-    const legacyFallback = resolveWorktreeFallbackPath(projectRoot2, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+    const legacyFallback = resolveWorktreeFallbackPath(projectRoot3, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
     if (legacyFallback) {
       return legacyFallback;
     }
@@ -1748,14 +1758,14 @@ function loadJsonFile(filePath) {
     throw new Error(`Failed to load config file ${filePath}: ${message}`);
   }
 }
-function materializeLocalProjectConfig(projectRoot2, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot2, host);
+function materializeLocalProjectConfig(projectRoot3, config, host = "opencode") {
+  const localConfigPath = resolveWritableProjectConfigPath(projectRoot3, host);
   mkdirSync(path7.dirname(localConfigPath), { recursive: true });
   writeFileSync(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
   return localConfigPath;
 }
-function loadProjectConfigLayer(projectRoot2, host = "opencode") {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot2, host);
+function loadProjectConfigLayer(projectRoot3, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
   const projectConfig = loadJsonFile(projectConfigPath);
   if (!projectConfig) {
     return {};
@@ -1766,14 +1776,14 @@ function loadProjectConfigLayer(projectRoot2, host = "opencode") {
     normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
       normalizedConfig.knowledgeBases,
       projectConfigBaseDir,
-      projectRoot2
+      projectRoot3
     );
   }
   return normalizedConfig;
 }
-function loadMergedConfig(projectRoot2, host = "opencode") {
+function loadMergedConfig(projectRoot3, host = "opencode") {
   const globalConfigPath = resolveGlobalConfigPath(host);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot2, host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
   let globalConfig = null;
   let globalConfigError = null;
   try {
@@ -1782,7 +1792,7 @@ function loadMergedConfig(projectRoot2, host = "opencode") {
     globalConfigError = error instanceof Error ? error : new Error(String(error));
   }
   const projectConfig = loadJsonFile(projectConfigPath);
-  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot2, host);
+  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot3, host);
   if (globalConfigError) {
     if (!projectConfig) {
       throw globalConfigError;
@@ -1825,11 +1835,11 @@ function loadMergedConfig(projectRoot2, host = "opencode") {
 }
 
 // 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 path11 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 execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -2933,17 +2943,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 };
 }
@@ -3137,10 +3147,10 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
     }
     const batchResults = await Promise.all(
       batches.map(async (batch) => {
-        const requests = batch.map((text2) => ({
+        const requests = batch.map((text3) => ({
           model: `models/${this.modelInfo.model}`,
           content: {
-            parts: [{ text: text2 }]
+            parts: [{ text: text3 }]
           },
           taskType,
           outputDimensionality: this.modelInfo.dimensions
@@ -3163,7 +3173,7 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
         const data = await response.json();
         return {
           embeddings: data.embeddings.map((e) => e.values),
-          tokensUsed: batch.reduce((sum, text2) => sum + Math.ceil(text2.length / 4), 0)
+          tokensUsed: batch.reduce((sum, text3) => sum + Math.ceil(text3.length / 4), 0)
         };
       })
     );
@@ -3180,28 +3190,28 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
   constructor(credentials, modelInfo) {
     super(credentials, modelInfo);
   }
-  estimateTokens(text2) {
-    return Math.ceil(text2.length / 4);
+  estimateTokens(text3) {
+    return Math.ceil(text3.length / 4);
   }
-  truncateToCharLimit(text2, maxChars) {
-    if (text2.length <= maxChars) {
-      return text2;
+  truncateToCharLimit(text3, maxChars) {
+    if (text3.length <= maxChars) {
+      return text3;
     }
-    return `${text2.slice(0, Math.max(0, maxChars - 17))}
+    return `${text3.slice(0, Math.max(0, maxChars - 17))}
 ... [truncated]`;
   }
   isContextLengthError(error) {
     const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return message.includes("context length") && (message.includes("exceed") || message.includes("exceeded") || message.includes("too long")) || message.includes("input length exceeds the context length") || message.includes("context length exceeded");
   }
-  buildTruncationCandidates(text2) {
+  buildTruncationCandidates(text3) {
     const baseMaxChars = Math.max(1, this.modelInfo.maxTokens * 4);
     const candidateLimits = /* @__PURE__ */ new Set();
-    const baselineLimit = text2.length > baseMaxChars ? baseMaxChars : Math.max(
+    const baselineLimit = text3.length > baseMaxChars ? baseMaxChars : Math.max(
       _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS,
-      Math.floor(text2.length * 0.9)
+      Math.floor(text3.length * 0.9)
     );
-    if (baselineLimit < text2.length) {
+    if (baselineLimit < text3.length) {
       candidateLimits.add(baselineLimit);
     }
     for (const factor of [0.75, 0.6, 0.45, 0.35, 0.25]) {
@@ -3209,19 +3219,19 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
         _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS,
         Math.floor(baselineLimit * factor)
       );
-      if (scaledLimit < text2.length) {
+      if (scaledLimit < text3.length) {
         candidateLimits.add(scaledLimit);
       }
     }
-    candidateLimits.add(Math.min(text2.length - 1, _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS));
+    candidateLimits.add(Math.min(text3.length - 1, _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS));
     const candidates = [];
     const seen = /* @__PURE__ */ new Set();
     for (const limit of [...candidateLimits].sort((a, b) => b - a)) {
-      if (limit <= 0 || limit >= text2.length) {
+      if (limit <= 0 || limit >= text3.length) {
         continue;
       }
-      const truncated = this.truncateToCharLimit(text2, limit);
-      if (truncated === text2 || seen.has(truncated)) {
+      const truncated = this.truncateToCharLimit(text3, limit);
+      if (truncated === text3 || seen.has(truncated)) {
         continue;
       }
       seen.add(truncated);
@@ -3229,15 +3239,15 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     }
     return candidates;
   }
-  async embedSingleWithFallback(text2) {
+  async embedSingleWithFallback(text3) {
     try {
-      return await this.embedSingle(text2);
+      return await this.embedSingle(text3);
     } catch (error) {
       if (!this.isContextLengthError(error)) {
         throw error;
       }
       let lastError = error;
-      for (const truncated of this.buildTruncationCandidates(text2)) {
+      for (const truncated of this.buildTruncationCandidates(text3)) {
         try {
           return await this.embedSingle(truncated);
         } catch (retryError) {
@@ -3250,7 +3260,7 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
       throw lastError;
     }
   }
-  async embedSingle(text2) {
+  async embedSingle(text3) {
     const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
       method: "POST",
       headers: {
@@ -3258,7 +3268,7 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
       },
       body: JSON.stringify({
         model: this.modelInfo.model,
-        prompt: text2,
+        prompt: text3,
         truncate: false
       })
     });
@@ -3269,13 +3279,13 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     const data = await response.json();
     return {
       embedding: data.embedding,
-      tokensUsed: this.estimateTokens(text2)
+      tokensUsed: this.estimateTokens(text3)
     };
   }
   async embedBatch(texts) {
     const results = [];
-    for (const text2 of texts) {
-      results.push(await this.embedSingleWithFallback(text2));
+    for (const text3 of texts) {
+      results.push(await this.embedSingleWithFallback(text3));
     }
     return {
       embeddings: results.map((r) => r.embedding),
@@ -3416,7 +3426,7 @@ var SiliconFlowReranker = class {
 var import_ignore = __toESM(require_ignore(), 1);
 import { existsSync as existsSync6, readFileSync as readFileSync5, promises as fsPromises } from "fs";
 import * as path8 from "path";
-function createIgnoreFilter(projectRoot2) {
+function createIgnoreFilter(projectRoot3) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
     "node_modules",
@@ -3437,7 +3447,7 @@ function createIgnoreFilter(projectRoot2) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path8.join(projectRoot2, ".gitignore");
+  const gitignorePath = path8.join(projectRoot3, ".gitignore");
   if (existsSync6(gitignorePath)) {
     const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
@@ -3459,13 +3469,13 @@ function matchGlob(filePath, pattern) {
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filePath);
 }
-async function* walkDirectory(dir, projectRoot2, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped, options, currentDepth = 0) {
+async function* walkDirectory(dir, projectRoot3, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped, options, currentDepth = 0) {
   const entries = await fsPromises.readdir(dir, { withFileTypes: true });
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
     const fullPath = path8.join(dir, entry.name);
-    const relativePath = path8.relative(projectRoot2, fullPath);
+    const relativePath = path8.relative(projectRoot3, fullPath);
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3514,14 +3524,14 @@ async function* walkDirectory(dir, projectRoot2, includePatterns, excludePattern
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path8.relative(projectRoot2, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path8.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
     for (const sub of subdirs) {
       yield* walkDirectory(
         sub.fullPath,
-        projectRoot2,
+        projectRoot3,
         includePatterns,
         excludePatterns,
         ignoreFilter,
@@ -3533,14 +3543,14 @@ async function* walkDirectory(dir, projectRoot2, includePatterns, excludePattern
     }
   }
 }
-async function collectFiles(projectRoot2, includePatterns, excludePatterns, maxFileSize, additionalRoots, walkOptions) {
+async function collectFiles(projectRoot3, includePatterns, excludePatterns, maxFileSize, additionalRoots, walkOptions) {
   const opts = walkOptions ?? { maxDepth: 5, maxFilesPerDirectory: 100 };
-  const ignoreFilter = createIgnoreFilter(projectRoot2);
+  const ignoreFilter = createIgnoreFilter(projectRoot3);
   const files = [];
   const skipped = [];
   for await (const file of walkDirectory(
-    projectRoot2,
-    projectRoot2,
+    projectRoot3,
+    projectRoot3,
     includePatterns,
     excludePatterns,
     ignoreFilter,
@@ -3555,7 +3565,7 @@ async function collectFiles(projectRoot2, includePatterns, excludePatterns, maxF
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
       const resolved = path8.normalize(
-        path8.isAbsolute(kbRoot) ? kbRoot : path8.resolve(projectRoot2, kbRoot)
+        path8.isAbsolute(kbRoot) ? kbRoot : path8.resolve(projectRoot3, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3980,6 +3990,12 @@ function createMockNativeBinding() {
       constructor() {
         throw error;
       }
+      static openReadOnly() {
+        throw error;
+      }
+      static createEmptyReadOnly() {
+        throw error;
+      }
       close() {
         throw error;
       }
@@ -4083,6 +4099,12 @@ var VectorStore = class {
   load() {
     this.inner.load();
   }
+  loadStrict() {
+    this.inner.loadStrict();
+  }
+  hasFingerprint() {
+    return this.inner.hasFingerprint();
+  }
   count() {
     return this.inner.count();
   }
@@ -4121,8 +4143,8 @@ var VectorStore = class {
 var CHARS_PER_TOKEN = 4;
 var MAX_BATCH_TOKENS = 7500;
 var MAX_SINGLE_CHUNK_TOKENS = 2e3;
-function estimateTokens(text2) {
-  return Math.ceil(text2.length / CHARS_PER_TOKEN);
+function estimateTokens(text3) {
+  return Math.ceil(text3.length / CHARS_PER_TOKEN);
 }
 function getEmbeddingHeaderParts(chunk, filePath) {
   const parts = [];
@@ -4365,12 +4387,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");
@@ -4656,20 +4690,20 @@ function getErrorMessage(error) {
   return String(error);
 }
 async function getChangedFiles(opts) {
-  const { pr, branch, projectRoot: projectRoot2, baseBranch = "main" } = opts;
+  const { pr, branch, projectRoot: projectRoot3, baseBranch = "main" } = opts;
   if (pr !== void 0) {
-    return getChangedFilesForPr(pr, projectRoot2, baseBranch);
+    return getChangedFilesForPr(pr, projectRoot3, baseBranch);
   }
-  return getChangedFilesForBranch(branch, projectRoot2, baseBranch);
+  return getChangedFilesForBranch(branch, projectRoot3, baseBranch);
 }
-async function getChangedFilesForPr(pr, projectRoot2, baseBranch) {
+async function getChangedFilesForPr(pr, projectRoot3, baseBranch) {
   let headRefName;
   let actualBaseBranch = baseBranch;
   try {
     const { stdout } = await execFileAsync(
       "gh",
       ["pr", "view", String(pr), "--json", "headRefName,baseRefName,files"],
-      { cwd: projectRoot2, timeout: 3e4 }
+      { cwd: projectRoot3, timeout: 3e4 }
     );
     const data = JSON.parse(stdout);
     headRefName = data.headRefName;
@@ -4678,7 +4712,7 @@ async function getChangedFilesForPr(pr, projectRoot2, baseBranch) {
       return {
         files: normalizeFiles(
           data.files.map((f) => f.path),
-          projectRoot2
+          projectRoot3
         ),
         baseBranch: actualBaseBranch,
         source: "gh",
@@ -4695,49 +4729,49 @@ async function getChangedFilesForPr(pr, projectRoot2, baseBranch) {
       `PR #${pr} returned no usable branch or file information.`
     );
   }
-  const result = await getChangedFilesForBranch(headRefName, projectRoot2, actualBaseBranch);
+  const result = await getChangedFilesForBranch(headRefName, projectRoot3, actualBaseBranch);
   return { ...result, headRefName };
 }
-async function getChangedFilesForBranch(branch, projectRoot2, baseBranch) {
-  const targetBranch = branch || await getCurrentBranch2(projectRoot2);
-  const mergeBase = await getMergeBase(projectRoot2, baseBranch, targetBranch);
+async function getChangedFilesForBranch(branch, projectRoot3, baseBranch) {
+  const targetBranch = branch || await getCurrentBranch2(projectRoot3);
+  const mergeBase = await getMergeBase(projectRoot3, baseBranch, targetBranch);
   const { stdout } = await execFileAsync(
     "git",
     ["diff", "--name-only", `${mergeBase}...${targetBranch}`],
-    { cwd: projectRoot2, timeout: 3e4 }
+    { cwd: projectRoot3, timeout: 3e4 }
   );
   return {
-    files: normalizeFiles(stdout.split("\n"), projectRoot2),
+    files: normalizeFiles(stdout.split("\n"), projectRoot3),
     baseBranch,
     source: "git",
     headRefName: targetBranch
   };
 }
-async function getCurrentBranch2(projectRoot2) {
+async function getCurrentBranch2(projectRoot3) {
   const { stdout } = await execFileAsync(
     "git",
     ["branch", "--show-current"],
-    { cwd: projectRoot2, timeout: 3e4 }
+    { cwd: projectRoot3, timeout: 3e4 }
   );
   return stdout.trim() || "HEAD";
 }
-async function getMergeBase(projectRoot2, baseBranch, branch) {
+async function getMergeBase(projectRoot3, baseBranch, branch) {
   const { stdout } = await execFileAsync(
     "git",
     ["merge-base", baseBranch, branch],
-    { cwd: projectRoot2, timeout: 3e4 }
+    { cwd: projectRoot3, timeout: 3e4 }
   );
   return stdout.trim();
 }
-function normalizeFiles(rawFiles, projectRoot2) {
+function normalizeFiles(rawFiles, projectRoot3) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const raw of rawFiles) {
     const trimmed = raw.trim();
     if (!trimmed) continue;
-    const absolute = path10.resolve(projectRoot2, trimmed);
-    const relative6 = path10.relative(projectRoot2, absolute);
-    const cleaned = relative6.startsWith("./") ? relative6.slice(2) : relative6;
+    const absolute = path10.resolve(projectRoot3, trimmed);
+    const relative7 = path10.relative(projectRoot3, absolute);
+    const cleaned = relative7.startsWith("./") ? relative7.slice(2) : relative7;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -4746,8 +4780,483 @@ function normalizeFiles(rawFiles, projectRoot2) {
   return result;
 }
 
+// src/indexer/git-blame.ts
+import { execFile as execFile2 } from "child_process";
+import * as path11 from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function parseGitBlamePorcelain(output) {
+  const commits = /* @__PURE__ */ new Map();
+  let current;
+  for (const line of output.split("\n")) {
+    if (/^[0-9a-f]{40} /.test(line)) {
+      const sha = line.slice(0, 40);
+      current = commits.get(sha) ?? {
+        sha,
+        author: "",
+        authorEmail: "",
+        committedAt: 0,
+        summary: "",
+        lines: 0
+      };
+      commits.set(sha, current);
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("author ")) {
+      current.author = line.slice("author ".length);
+    } else if (line.startsWith("author-mail ")) {
+      current.authorEmail = line.slice("author-mail ".length).replace(/^<|>$/g, "");
+    } else if (line.startsWith("author-time ")) {
+      current.committedAt = Number.parseInt(line.slice("author-time ".length), 10);
+    } else if (line.startsWith("summary ")) {
+      current.summary = line.slice("summary ".length);
+    } else if (line.startsWith("	")) {
+      current.lines += 1;
+    }
+  }
+  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(projectRoot3, filePath, startLine, endLine) {
+  const relativePath = path11.relative(projectRoot3, filePath);
+  try {
+    const { stdout } = await execFileAsync2(
+      "git",
+      ["blame", "--line-porcelain", "-L", `${startLine},${endLine}`, "--", relativePath],
+      { cwd: projectRoot3, timeout: 3e4 }
+    );
+    return parseGitBlamePorcelain(stdout);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/indexer/index-lock.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync as existsSync7,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync2,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import * as os4 from "os";
+import * as path12 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(readFileSync6(path12.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(readFileSync6(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 : os4.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 !== os4.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(path12.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
+      encoding: "utf-8",
+      flag: "wx",
+      mode: 384
+    });
+    if (existsSync7(finalPath)) return false;
+    try {
+      renameSync(candidatePath, finalPath);
+      return true;
+    } catch (error) {
+      if (existsSync7(finalPath)) return false;
+      throw error;
+    }
+  } finally {
+    if (existsSync7(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
+  }
+}
+function createOwner(operation) {
+  return {
+    pid: process.pid,
+    hostname: os4.hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    operation,
+    token: randomUUID()
+  };
+}
+function recoveryMarkerPath(indexPath, owner) {
+  return path12.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 = path12.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: os4.hostname() }) !== "dead") continue;
+    rmSync(path12.join(indexPath, entry), { recursive: true, force: true });
+  }
+}
+function removeDeadReclaimMarker(lockPath, expectedOwner) {
+  const markerPath = path12.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 (!existsSync7(markerPath) && existsSync7(claimedMarkerPath)) {
+      renameSync(claimedMarkerPath, markerPath);
+    }
+    return false;
+  }
+  rmSync(claimedMarkerPath, { recursive: true, force: true });
+  return true;
+}
+function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
+  const reclaimPath = path12.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimOwner = {
+    pid: process.pid,
+    hostname: os4.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 acquireIndexLock(indexPath, operation) {
+  mkdirSync2(indexPath, { recursive: true });
+  const canonicalIndexPath = realpathSync.native(indexPath);
+  const lockPath = path12.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 (!existsSync7(lease.lockPath) && existsSync7(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 (existsSync7(temporaryPath)) rmSync(temporaryPath, { recursive: true, force: true });
+}
+function recoverLeaseArtifacts(indexPath, owner, backupTargets) {
+  for (const targetPath of backupTargets) {
+    const backupPath = createLeaseTemporaryPath(targetPath, owner, "bak");
+    if (!existsSync7(backupPath)) continue;
+    if (existsSync7(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(path12.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/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab", "bash"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -4827,6 +5336,46 @@ 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 {};
+  }
+  return {
+    blameSha: blame.sha,
+    blameAuthor: blame.author,
+    blameAuthorEmail: blame.authorEmail,
+    blameCommittedAt: blame.committedAt,
+    blameSummary: blame.summary
+  };
+}
+function blameFromChunkData(chunk) {
+  if (!chunk?.blameSha || !chunk.blameAuthor || !chunk.blameAuthorEmail || chunk.blameCommittedAt === void 0 || !chunk.blameSummary) {
+    return void 0;
+  }
+  return {
+    sha: chunk.blameSha,
+    author: chunk.blameAuthor,
+    authorEmail: chunk.blameAuthorEmail,
+    committedAt: chunk.blameCommittedAt,
+    summary: chunk.blameSummary
+  };
+}
+function blameFromMetadata(metadata) {
+  if (!metadata.blameSha || !metadata.blameAuthor || !metadata.blameAuthorEmail || metadata.blameCommittedAt === void 0 || !metadata.blameSummary) {
+    return void 0;
+  }
+  return {
+    sha: metadata.blameSha,
+    author: metadata.blameAuthor,
+    authorEmail: metadata.blameAuthorEmail,
+    committedAt: metadata.blameCommittedAt,
+    summary: metadata.blameSummary
+  };
+}
+function hasBlameMetadata(metadata) {
+  return blameFromMetadata(metadata) !== void 0;
+}
 var INDEX_METADATA_VERSION = "1";
 var EMBEDDING_STRATEGY_VERSION = "2";
 var RANKING_TOKEN_CACHE_LIMIT = 4096;
@@ -4870,9 +5419,9 @@ function normalizePendingChunk(rawChunk, maxChunkTokens) {
       };
       const filePath = typeof metadata.filePath === "string" ? metadata.filePath : "unknown";
       texts.push(
-        ...createEmbeddingTexts(rebuiltChunk, filePath, maxChunkTokens).map((text2) => ({
-          text: text2,
-          tokenCount: estimateTokens(text2)
+        ...createEmbeddingTexts(rebuiltChunk, filePath, maxChunkTokens).map((text3) => ({
+          text: text3,
+          tokenCount: estimateTokens(text3)
         }))
       );
     } else {
@@ -4985,9 +5534,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path11.resolve(filePath);
-  const normalizedRoot = path11.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path11.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();
@@ -5103,11 +5652,11 @@ function setBoundedCache(cache, key, value) {
   }
   cache.set(key, value);
 }
-function tokenizeTextForRanking(text2) {
-  if (!text2) {
+function tokenizeTextForRanking(text3) {
+  if (!text3) {
     return /* @__PURE__ */ new Set();
   }
-  const lowered = text2.toLowerCase();
+  const lowered = text3.toLowerCase();
   const cache = rankingQueryTokenCache.get(lowered) ?? rankingTextTokenCache.get(lowered);
   if (cache) {
     return cache;
@@ -5746,7 +6295,8 @@ function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCa
             chunkType,
             name: chunk.name ?? void 0,
             language: chunk.language,
-            hash: chunk.contentHash
+            hash: chunk.contentHash,
+            ...metadataFromBlame(blameFromChunkData(chunk))
           };
           const baselineScore = existing?.score ?? 0.5;
           candidateUnion.set(chunk.chunkId, {
@@ -5830,7 +6380,8 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallb
           chunkType,
           name: chunk.name ?? void 0,
           language: chunk.language,
-          hash: chunk.contentHash
+          hash: chunk.contentHash,
+          ...metadataFromBlame(blameFromChunkData(chunk))
         }
       });
     }
@@ -5999,6 +6550,21 @@ function matchesSearchFilters(candidate, options, minScore) {
   if (options?.chunkType && candidate.metadata.chunkType !== options.chunkType) {
     return false;
   }
+  if (options?.blameAuthor) {
+    const author = options.blameAuthor.toLowerCase();
+    const candidateAuthor = candidate.metadata.blameAuthor?.toLowerCase();
+    const candidateEmail = candidate.metadata.blameAuthorEmail?.toLowerCase();
+    if (candidateAuthor !== author && candidateEmail !== author) return false;
+  }
+  if (options?.blameSha && !candidate.metadata.blameSha?.toLowerCase().startsWith(options.blameSha.toLowerCase())) {
+    return false;
+  }
+  if (options?.blameSince) {
+    const sinceMs = Date.parse(options.blameSince);
+    if (Number.isNaN(sinceMs)) return false;
+    const committedAt = candidate.metadata.blameCommittedAt;
+    if (committedAt === void 0 || committedAt < Math.floor(sinceMs / 1e3)) return false;
+  }
   return true;
 }
 function unionCandidates(semanticCandidates, keywordCandidates) {
@@ -6036,26 +6602,133 @@ var Indexer = class {
   queryCacheTtlMs = 5 * 60 * 1e3;
   querySimilarityThreshold = 0.85;
   indexCompatibility = null;
-  indexingLockPath = "";
-  constructor(projectRoot2, config, host = "opencode") {
-    this.projectRoot = projectRoot2;
+  activeIndexLease = null;
+  initializationPromise = null;
+  initializationMode = "none";
+  readIssues = [];
+  retiredDatabases = [];
+  readerArtifactFingerprint = null;
+  writerArtifactFingerprint = null;
+  readerArtifactRetryAfter = /* @__PURE__ */ new Map();
+  constructor(projectRoot3, config, host = "opencode") {
+    this.projectRoot = projectRoot3;
     this.config = config;
     this.host = host;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path11.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) {
@@ -6075,15 +6748,26 @@ var Indexer = class {
     this.atomicWriteSync(this.fileHashCachePath, JSON.stringify(obj));
   }
   atomicWriteSync(targetPath, data) {
-    const tempPath = `${targetPath}.tmp`;
-    mkdirSync2(path11.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([path11.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path13.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path11.resolve(this.projectRoot, kbRoot));
+      roots.add(path13.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6092,29 +6776,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path11.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(path11.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(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -6208,7 +6892,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path11.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)
@@ -6231,7 +6915,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path11.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);
@@ -6315,7 +6999,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path11.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(
@@ -6349,7 +7033,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path11.resolve(this.projectRoot);
+    const projectRootPath = path13.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6411,34 +7095,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) {
@@ -6454,10 +7131,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 : [];
@@ -6474,7 +7151,7 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync7(this.failedBatchesPath)) {
+      if (existsSync8(this.failedBatchesPath)) {
         try {
           unlinkSync(this.failedBatchesPath);
         } catch {
@@ -6482,7 +7159,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();
@@ -6676,67 +7353,350 @@ var Indexer = class {
     return parts.join("\n");
   }
   async initialize() {
-    if (this.config.embeddingProvider === "custom") {
-      if (!this.config.customProvider) {
-        throw new Error("embeddingProvider is 'custom' but customProvider config is missing.");
-      }
-      this.configuredProviderInfo = createCustomProviderInfo(this.config.customProvider);
-    } else if (this.config.embeddingProvider === "auto") {
-      this.configuredProviderInfo = await tryDetectProvider();
-    } else {
-      this.configuredProviderInfo = await detectEmbeddingProvider(this.config.embeddingProvider, this.config.embeddingModel);
+    if (this.initializationPromise) {
+      await this.initializationPromise;
     }
-    if (!this.configuredProviderInfo) {
-      throw new Error(
-        "No embedding provider available. Configure GitHub Copilot, OpenAI, Google, Ollama, or a custom OpenAI-compatible endpoint."
-      );
+    if (this.isInitializedFor("reader")) {
+      return;
     }
-    this.logger.info("Initializing indexer", {
-      provider: this.configuredProviderInfo.provider,
-      model: this.configuredProviderInfo.modelInfo.model,
-      scope: this.config.scope,
-      rerankerEnabled: this.config.reranker?.enabled ?? false
-    });
-    this.provider = createEmbeddingProvider(this.configuredProviderInfo);
-    if (this.config.reranker?.enabled) {
-      this.reranker = createReranker(this.config.reranker);
-      if (this.reranker.isAvailable()) {
-        this.logger.info("Reranker initialized", {
-          model: this.config.reranker.model,
-          baseUrl: this.config.reranker.baseUrl
-        });
+    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);
     }
-    await fsPromises2.mkdir(this.indexPath, { recursive: true });
-    const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path11.join(this.indexPath, "vectors");
-    this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path11.join(this.indexPath, "vectors.usearch");
-    if (existsSync7(indexFilePath)) {
-      this.store.load();
-    }
-    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
-    this.invertedIndex = new InvertedIndex(invertedIndexPath);
-    try {
-      this.invertedIndex.load();
-    } catch {
-      if (existsSync7(invertedIndexPath)) {
-        await fsPromises2.unlink(invertedIndexPath);
+    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.invertedIndex = new InvertedIndex(invertedIndexPath);
+    });
+    this.initializationPromise = initialization;
+    await initialization;
+  }
+  isInitializedFor(mode) {
+    const hasState = Boolean(
+      this.store && this.provider && this.invertedIndex && this.configuredProviderInfo && this.database
+    );
+    if (!hasState) {
+      return false;
     }
-    const dbPath = path11.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync7(dbPath);
+    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 {
-      this.database = new Database(dbPath);
+      const stats = statSync3(filePath);
+      if (identityOnly) {
+        return `${stats.dev}:${stats.ino}`;
+      }
+      return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`;
     } catch (error) {
-      if (!await this.tryResetCorruptedIndex("initializing index database", error)) {
-        throw 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.");
+      }
+      this.configuredProviderInfo = createCustomProviderInfo(this.config.customProvider);
+    } else if (this.config.embeddingProvider === "auto") {
+      this.configuredProviderInfo = await tryDetectProvider();
+    } else {
+      this.configuredProviderInfo = await detectEmbeddingProvider(this.config.embeddingProvider, this.config.embeddingModel);
+    }
+    if (!this.configuredProviderInfo) {
+      throw new Error(
+        "No embedding provider available. Configure GitHub Copilot, OpenAI, Google, Ollama, or a custom OpenAI-compatible endpoint."
+      );
+    }
+    this.logger.info("Initializing indexer", {
+      provider: this.configuredProviderInfo.provider,
+      model: this.configuredProviderInfo.modelInfo.model,
+      scope: this.config.scope,
+      rerankerEnabled: this.config.reranker?.enabled ?? false
+    });
+    this.provider = createEmbeddingProvider(this.configuredProviderInfo);
+    if (this.config.reranker?.enabled) {
+      this.reranker = createReranker(this.config.reranker);
+      if (this.reranker.isAvailable()) {
+        this.logger.info("Reranker initialized", {
+          model: this.config.reranker.model,
+          baseUrl: this.config.reranker.baseUrl
+        });
+      }
+    }
+    const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
+    const storePath = 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);
+      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);
@@ -6750,10 +7710,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();
@@ -6765,9 +7725,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;
@@ -6784,7 +7746,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 {
@@ -6806,7 +7768,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6821,28 +7783,29 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path11.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();
@@ -6862,10 +7825,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", {
@@ -6878,17 +7841,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();
@@ -6902,11 +7865,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 = path11.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") {
@@ -6922,30 +7911,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 = [
-      path11.join(this.indexPath, "codebase.db"),
-      path11.join(this.indexPath, "codebase.db-shm"),
-      path11.join(this.indexPath, "codebase.db-wal"),
-      path11.join(this.indexPath, "vectors.usearch"),
-      path11.join(this.indexPath, "inverted-index.json"),
-      path11.join(this.indexPath, "file-hashes.json"),
-      path11.join(this.indexPath, "failed-batches.json"),
-      path11.join(this.indexPath, "indexing.lock"),
-      path11.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() {
@@ -7064,8 +8030,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,
@@ -7089,7 +8109,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";
@@ -7099,7 +8124,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();
@@ -7174,6 +8198,7 @@ var Indexer = class {
     this.logger.debug("Parsed changed files", { parsedCount: parsedFiles.length, parseMs: parseMs.toFixed(2) });
     const existingChunks = /* @__PURE__ */ new Map();
     const existingChunksByFile = /* @__PURE__ */ new Map();
+    const existingMetadataById = /* @__PURE__ */ new Map();
     for (const { key, metadata } of store.getAllMetadata()) {
       if (scopedRoots && !this.isFileInCurrentScope(metadata.filePath, scopedRoots)) {
         continue;
@@ -7182,6 +8207,7 @@ var Indexer = class {
         continue;
       }
       existingChunks.set(key, metadata.hash);
+      existingMetadataById.set(key, metadata);
       const fileChunks = existingChunksByFile.get(metadata.filePath) || /* @__PURE__ */ new Set();
       fileChunks.add(key);
       existingChunksByFile.set(metadata.filePath, fileChunks);
@@ -7189,6 +8215,8 @@ var Indexer = class {
     const currentChunkIds = /* @__PURE__ */ new Set();
     const currentFilePaths = /* @__PURE__ */ new Set();
     const pendingChunks = [];
+    const gitBlameEnabled = this.config.indexing.gitBlame.enabled && isGitRepo(this.projectRoot);
+    let backfilledBlameMetadata = false;
     for (const filePath of unchangedFilePaths) {
       currentFilePaths.add(filePath);
       const fileChunks = existingChunksByFile.get(filePath);
@@ -7199,10 +8227,52 @@ var Indexer = class {
       }
     }
     const chunkDataBatch = [];
+    if (gitBlameEnabled) {
+      const backfillItems = [];
+      for (const chunkId of currentChunkIds) {
+        const metadata = existingMetadataById.get(chunkId);
+        if (!metadata || hasBlameMetadata(metadata)) {
+          continue;
+        }
+        const chunk = database.getChunk(chunkId);
+        if (!chunk) {
+          continue;
+        }
+        const blame = await getChunkGitBlame(this.projectRoot, chunk.filePath, chunk.startLine, chunk.endLine);
+        const blameMetadata = metadataFromBlame(blame);
+        if (!blameMetadata.blameSha) {
+          continue;
+        }
+        chunkDataBatch.push({
+          ...chunk,
+          blameSha: blameMetadata.blameSha,
+          blameAuthor: blameMetadata.blameAuthor,
+          blameAuthorEmail: blameMetadata.blameAuthorEmail,
+          blameCommittedAt: blameMetadata.blameCommittedAt,
+          blameSummary: blameMetadata.blameSummary
+        });
+        const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+        if (!embeddingBuffer) {
+          continue;
+        }
+        backfillItems.push({
+          id: chunkId,
+          vector: Array.from(bufferToFloat32Array(embeddingBuffer)),
+          metadata: {
+            ...metadata,
+            ...blameMetadata
+          }
+        });
+      }
+      if (backfillItems.length > 0) {
+        store.addBatch(backfillItems);
+        backfilledBlameMetadata = true;
+      }
+    }
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path11.relative(this.projectRoot, parsed.path);
+        const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7223,6 +8293,10 @@ var Indexer = class {
         }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
+        const existingContentHash = existingChunks.get(id);
+        const existingChunk = gitBlameEnabled ? database.getChunk(id) : null;
+        const blame = gitBlameEnabled && existingContentHash !== contentHash ? await getChunkGitBlame(this.projectRoot, parsed.path, chunk.startLine, chunk.endLine) : blameFromChunkData(existingChunk);
+        const blameMetadata = metadataFromBlame(blame);
         currentChunkIds.add(id);
         chunkDataBatch.push({
           chunkId: id,
@@ -7232,15 +8306,20 @@ var Indexer = class {
           endLine: chunk.endLine,
           nodeType: chunk.chunkType,
           name: chunk.name,
-          language: chunk.language
+          language: chunk.language,
+          blameSha: blameMetadata.blameSha,
+          blameAuthor: blameMetadata.blameAuthor,
+          blameAuthorEmail: blameMetadata.blameAuthorEmail,
+          blameCommittedAt: blameMetadata.blameCommittedAt,
+          blameSummary: blameMetadata.blameSummary
         });
-        if (existingChunks.get(id) === contentHash) {
+        if (existingContentHash === contentHash) {
           fileChunkCount++;
           continue;
         }
-        const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text2) => ({
-          text: text2,
-          tokenCount: estimateTokens(text2)
+        const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text3) => ({
+          text: text3,
+          tokenCount: estimateTokens(text3)
         }));
         const metadata = {
           filePath: parsed.path,
@@ -7249,7 +8328,8 @@ var Indexer = class {
           chunkType: chunk.chunkType,
           name: chunk.name,
           language: chunk.language,
-          hash: contentHash
+          hash: contentHash,
+          ...blameMetadata
         };
         pendingChunks.push({
           id,
@@ -7392,6 +8472,11 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
+      const vectorPath = path13.join(this.indexPath, "vectors");
+      const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync8(vectorPath) && existsSync8(`${vectorPath}.meta.json`);
+      if (backfilledBlameMetadata || shouldFingerprintLegacyPair) {
+        store.save();
+      }
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
         this.clearScopedFailedBatches(scopedRoots);
@@ -7410,7 +8495,6 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
-      this.releaseIndexingLock();
       return stats;
     }
     if (pendingChunks.length === 0) {
@@ -7419,7 +8503,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);
@@ -7438,7 +8522,6 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
-      this.releaseIndexingLock();
       return stats;
     }
     onProgress?.({
@@ -7669,7 +8752,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 {
@@ -7721,7 +8804,6 @@ var Indexer = class {
       chunksProcessed: stats.indexedChunks,
       totalChunks: pendingChunks.length
     });
-    this.releaseIndexingLock();
     return stats;
   }
   async getQueryEmbedding(query, provider) {
@@ -7771,9 +8853,9 @@ var Indexer = class {
     }
     return bestMatch;
   }
-  tokenize(text2) {
+  tokenize(text3) {
     return new Set(
-      text2.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 1)
+      text3.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 1)
     );
   }
   jaccardSimilarity(a, b) {
@@ -7787,8 +8869,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.`
@@ -7802,6 +8884,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;
@@ -7810,7 +8893,7 @@ var Indexer = class {
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
-      hybridWeight,
+      hybridWeight: effectiveHybridWeight,
       fusionStrategy,
       rrfK,
       rerankTopN,
@@ -7824,7 +8907,7 @@ var Indexer = class {
     const semanticResults = 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")) {
@@ -7861,7 +8944,7 @@ var Indexer = class {
       rrfK,
       rerankTopN,
       limit: maxResults,
-      hybridWeight,
+      hybridWeight: effectiveHybridWeight,
       prioritizeSourcePaths: sourceIntent
     });
     const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
@@ -7955,13 +9038,13 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
   }
-  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 [];
@@ -7979,24 +9062,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();
@@ -8023,7 +9136,7 @@ var Indexer = class {
         store.clear();
         store.save();
         invertedIndex.clear();
-        invertedIndex.save();
+        this.saveInvertedIndex(invertedIndex);
         this.fileHashCache.clear();
         this.saveFileHashCache();
         database.clearAllIndexedData();
@@ -8047,14 +9160,7 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPaths = [path11.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
-    if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path11.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
-    }
-    const isLocalProjectIndex = localProjectIndexPaths.some(
-      (localPath) => path11.resolve(this.indexPath) === path11.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."
       );
@@ -8062,7 +9168,7 @@ var Indexer = class {
     store.clear();
     store.save();
     invertedIndex.clear();
-    invertedIndex.save();
+    this.saveInvertedIndex(invertedIndex);
     this.fileHashCache.clear();
     this.saveFileHashCache();
     database.clearAllIndexedData();
@@ -8080,7 +9186,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();
@@ -8093,7 +9205,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);
@@ -8118,7 +9230,7 @@ var Indexer = class {
     const removedCount = removedChunkKeys.length;
     if (removedCount > 0) {
       store.save();
-      invertedIndex.save();
+      this.saveInvertedIndex(invertedIndex);
     }
     let gcOrphanEmbeddings;
     let gcOrphanChunks;
@@ -8133,7 +9245,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: [],
@@ -8142,7 +9254,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8155,7 +9267,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;
@@ -8319,7 +9437,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());
@@ -8347,15 +9465,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.`
@@ -8462,13 +9581,15 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
   }
   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()) {
@@ -8482,7 +9603,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()) {
@@ -8496,44 +9618,51 @@ 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 path15 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path15.length > 0 && (shortest.length === 0 || path15.length < shortest.length)) {
-        shortest = path15;
+      const path17 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path17.length > 0 && (shortest.length === 0 || path17.length < shortest.length)) {
+        shortest = path17;
       }
     }
     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 execFileAsync2 = promisify2(execFile2);
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
+    const execFileAsync3 = promisify3(execFile3);
     const changedFilesResult = await getChangedFiles({
       pr: opts.pr,
       branch: opts.branch,
@@ -8555,7 +9684,7 @@ var Indexer = class {
         "Run index_codebase first to build the call graph and symbol index for this branch."
       );
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path11.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";
@@ -8617,7 +9746,7 @@ var Indexer = class {
     if (opts.checkConflicts) {
       conflictingPRs = [];
       try {
-        const { stdout } = await execFileAsync2(
+        const { stdout } = await execFileAsync3(
           "gh",
           ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "10000"],
           { cwd: this.projectRoot, timeout: 3e4 }
@@ -8638,7 +9767,7 @@ var Indexer = class {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path11.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();
@@ -8688,7 +9817,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()) {
@@ -8701,12 +9831,12 @@ var Indexer = class {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path11.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 = path11.resolve(filePath);
+          const absoluteFilePath = path13.resolve(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path11.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path13.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -8728,53 +9858,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 path12 from "path";
+import * as path14 from "path";
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path12.isAbsolute(trimmed) ? trimmed : path12.resolve(baseDir, trimmed);
-  return path12.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 (!path12.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path12.normalize(trimmed));
+  if (!path14.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path14.normalize(trimmed));
   }
-  const relativePath = path12.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path12.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path12.normalize(relativePath || "."));
+  const relativePath = path14.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path14.normalize(relativePath || "."));
   }
-  return path12.normalize(trimmed);
+  return path14.normalize(trimmed);
 }
-function resolveKnowledgeBasePath(value, projectRoot2) {
-  return path12.isAbsolute(value) ? value : path12.resolve(projectRoot2, value);
+function resolveKnowledgeBasePath(value, projectRoot3) {
+  return path14.isAbsolute(value) ? value : path14.resolve(projectRoot3, value);
 }
-function normalizeKnowledgeBasePath2(value, projectRoot2) {
-  return path12.normalize(resolveKnowledgeBasePath(value, projectRoot2));
+function normalizeKnowledgeBasePath2(value, projectRoot3) {
+  return path14.normalize(resolveKnowledgeBasePath(value, projectRoot3));
 }
-function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot2) {
-  const normalizedInput = path12.normalize(inputPath);
-  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot2) === normalizedInput);
+function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot3) {
+  const normalizedInput = path14.normalize(inputPath);
+  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput);
 }
-function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot2) {
-  const normalizedInput = path12.normalize(inputPath);
+function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot3) {
+  const normalizedInput = path14.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path12.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot2) === normalizedInput
+    (kb) => path14.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput
   );
 }
 
@@ -8874,6 +10015,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}`);
@@ -8947,16 +10092,57 @@ function formatHealthCheck(result) {
   }
   return lines.join("\n");
 }
+function formatCallGraphCallers(name, callers, relationshipType) {
+  if (callers.length === 0) {
+    return `No callers found for "${name}"${relationshipType ? ` with type ${relationshipType}` : ""}. It may not be called by any tracked function, or the index needs updating.`;
+  }
+  const formatted = callers.map((edge, index) => {
+    const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
+    return `[${index + 1}] \u2190 from ${edge.fromSymbolName ?? "<unknown>"} in ${edge.fromSymbolFilePath ?? "<unknown file>"} [${edge.fromSymbolId}] (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? " [resolved]" : " [unresolved]"}`;
+  });
+  return `"${name}" is called by ${callers.length} function(s):
+
+${formatted.join("\n")}`;
+}
+function formatCallGraphCallees(symbolId, callees, relationshipType) {
+  if (callees.length === 0) {
+    return `No callees found for symbol ${symbolId}${relationshipType ? ` with type ${relationshipType}` : ""}. The function may not call any other tracked functions.`;
+  }
+  return callees.map((edge, index) => {
+    const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
+    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, path17) {
+  if (path17.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 = path17.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 (${path17.length} hops):
+${formatted.join("\n")}`;
+}
 function formatResultHeader(result, index) {
   return result.name ? `[${index + 1}] ${result.chunkType} "${result.name}" in ${result.filePath}:${result.startLine}-${result.endLine}` : `[${index + 1}] ${result.chunkType} in ${result.filePath}:${result.startLine}-${result.endLine}`;
 }
+function formatBlame(result) {
+  if (!result.blame) {
+    return "";
+  }
+  const date = new Date(result.blame.committedAt * 1e3).toISOString().slice(0, 10);
+  return `
+    ${result.blame.sha.slice(0, 7)} | ${result.blame.author} | ${date} | ${result.blame.summary}`;
+}
 function formatDefinitionLookup(results, query) {
   if (results.length === 0) {
     return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
   }
   const formatted = results.map((r, idx) => {
     const header = formatResultHeader(r, idx);
-    return `${header} (score: ${r.score.toFixed(2)})
+    return `${header} (score: ${r.score.toFixed(2)})${formatBlame(r)}
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
@@ -8967,7 +10153,7 @@ function formatSearchResults(results, scoreFormat = "similarity") {
   const formatted = results.map((r, idx) => {
     const header = formatResultHeader(r, idx);
     const scoreLabel = scoreFormat === "similarity" ? `(similarity: ${(r.score * 100).toFixed(1)}%)` : `(score: ${r.score.toFixed(2)})`;
-    return `${header} ${scoreLabel}
+    return `${header} ${scoreLabel}${formatBlame(r)}
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
@@ -8976,13 +10162,13 @@ ${truncateContent(r.content)}
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import * as path13 from "path";
-function normalizeKnowledgeBasePaths(config, projectRoot2) {
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import * as path15 from "path";
+function normalizeKnowledgeBasePaths(config, projectRoot3) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
     normalized.knowledgeBases = normalized.knowledgeBases.map(
-      (kb) => resolveConfigPathValue(kb, projectRoot2)
+      (kb) => resolveConfigPathValue(kb, projectRoot3)
     );
   }
   return normalized;
@@ -8993,21 +10179,21 @@ function toConfigRecord(rawConfig) {
   }
   return { ...rawConfig };
 }
-function getConfigPath(projectRoot2, host = "opencode") {
-  return resolveWritableProjectConfigPath(projectRoot2, host);
+function getConfigPath(projectRoot3, host = "opencode") {
+  return resolveWritableProjectConfigPath(projectRoot3, host);
 }
-function loadRuntimeConfig(projectRoot2, host = "opencode") {
-  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot2, host)), projectRoot2);
+function loadRuntimeConfig(projectRoot3, host = "opencode") {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot3, host)), projectRoot3);
 }
-function loadEditableConfig(projectRoot2, host = "opencode") {
-  return normalizeKnowledgeBasePaths(toConfigRecord(loadProjectConfigLayer(projectRoot2, host)), projectRoot2);
+function loadEditableConfig(projectRoot3, host = "opencode") {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadProjectConfigLayer(projectRoot3, host)), projectRoot3);
 }
-function saveConfig(projectRoot2, config, host = "opencode") {
-  const configPath = getConfigPath(projectRoot2, host);
-  const configDir = path13.dirname(configPath);
-  const configBaseDir = path13.dirname(configDir);
-  if (!existsSync8(configDir)) {
-    mkdirSync3(configDir, { recursive: true });
+function saveConfig(projectRoot3, config, host = "opencode") {
+  const configPath = getConfigPath(projectRoot3, host);
+  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)) {
@@ -9015,16 +10201,34 @@ function saveConfig(projectRoot2, 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 getProjectRoot(projectRoot2, host) {
-  if (projectRoot2) {
-    return projectRoot2;
+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(projectRoot3, host) {
+  if (projectRoot3) {
+    return projectRoot3;
   }
   const root = defaultProjectRoots.get(host);
   if (!root) {
@@ -9032,53 +10236,56 @@ function getProjectRoot(projectRoot2, host) {
   }
   return root;
 }
-function getIndexerCacheKey(projectRoot2, host) {
-  return `${host}::${projectRoot2}`;
+function getIndexerCacheKey(projectRoot3, host) {
+  return `${host}::${projectRoot3}`;
 }
-function getOrCreateIndexer(projectRoot2, host) {
-  const key = getIndexerCacheKey(projectRoot2, host);
+function getOrCreateIndexer(projectRoot3, host) {
+  const key = getIndexerCacheKey(projectRoot3, host);
   const cached = indexerCache.get(key);
   if (cached) {
     return cached;
   }
-  const config = parseConfig(loadRuntimeConfig(projectRoot2, host));
-  const indexer = new Indexer(projectRoot2, config, host);
+  const config = parseConfig(loadRuntimeConfig(projectRoot3, host));
+  const indexer = new Indexer(projectRoot3, config, host);
   indexerCache.set(key, indexer);
   configCache.set(key, config);
   return indexer;
 }
-function getIndexerForProject(projectRoot2, host = "opencode") {
-  const root = getProjectRoot(projectRoot2, host);
+function getIndexerForProject(projectRoot3, host = "opencode") {
+  const root = getProjectRoot(projectRoot3, host);
   return getOrCreateIndexer(root, host);
 }
-function refreshIndexerForDirectory(projectRoot2, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot2, host))) {
-  const key = getIndexerCacheKey(projectRoot2, host);
-  const indexer = new Indexer(projectRoot2, config, host);
+function refreshIndexerForDirectory(projectRoot3, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot3, host))) {
+  const key = getIndexerCacheKey(projectRoot3, host);
+  const indexer = new Indexer(projectRoot3, config, host);
   indexerCache.set(key, indexer);
   configCache.set(key, config);
 }
-function shouldForceLocalizeProjectIndex(projectRoot2, host = "opencode") {
-  const root = getProjectRoot(projectRoot2, host);
-  const localIndexPath = path14.join(root, getHostProjectIndexRelativePath(host));
-  if (existsSync9(localIndexPath)) {
+function shouldForceLocalizeProjectIndex(projectRoot3, host = "opencode") {
+  const root = getProjectRoot(projectRoot3, host);
+  const localIndexPath = path16.join(root, getHostProjectIndexRelativePath(host));
+  if (existsSync10(localIndexPath)) {
     return false;
   }
   const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
   return inheritedIndexPath !== null;
 }
-async function searchCodebase(projectRoot2, host, query, options = {}) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function searchCodebase(projectRoot3, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.search(query, options.limit, {
     fileType: options.fileType,
     directory: options.directory,
     chunkType: options.chunkType,
     contextLines: options.contextLines,
     metadataOnly: options.metadataOnly,
-    definitionIntent: options.definitionIntent
+    definitionIntent: options.definitionIntent,
+    blameAuthor: options.blameAuthor,
+    blameSha: options.blameSha,
+    blameSince: options.blameSince
   });
 }
-async function findSimilarCode(projectRoot2, host, code, options = {}) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function findSimilarCode(projectRoot3, host, code, options = {}) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.findSimilar(code, options.limit, {
     fileType: options.fileType,
     directory: options.directory,
@@ -9086,16 +10293,16 @@ async function findSimilarCode(projectRoot2, host, code, options = {}) {
     excludeFile: options.excludeFile
   });
 }
-async function implementationLookup(projectRoot2, host, query, options = {}) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function implementationLookup(projectRoot3, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.search(query, options.limit, {
     fileType: options.fileType,
     directory: options.directory,
     definitionIntent: true
   });
 }
-async function getCallGraphData(projectRoot2, host, params) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getCallGraphData(projectRoot3, host, params) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   if (params.direction === "callees") {
     if (!params.symbolId) {
       return { direction: "callees", callees: [], callers: [] };
@@ -9106,53 +10313,73 @@ async function getCallGraphData(projectRoot2, host, params) {
   const callers = await indexer.getCallers(params.name, params.relationshipType);
   return { direction: "callers", callers, callees: [] };
 }
-async function getCallGraphPath(projectRoot2, host, from, to, maxDepth) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getCallGraphPath(projectRoot3, host, from, to, maxDepth) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.findCallPath(from, to, maxDepth);
 }
-async function runIndexCodebase(projectRoot2, host, args, onProgress) {
-  const root = getProjectRoot(projectRoot2, host);
+async function runIndexCodebase(projectRoot3, host, args, onProgress) {
+  const root = getProjectRoot(projectRoot3, 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(projectRoot2, host) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getIndexStatus(projectRoot3, host) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.getStatus();
 }
-async function getIndexHealthCheck(projectRoot2, host) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getIndexHealthCheck(projectRoot3, host) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.healthCheck();
 }
-async function getPrImpact(projectRoot2, host, params) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function runIndexHealthCheck(projectRoot3, host) {
+  try {
+    return { kind: "health", health: await getIndexHealthCheck(projectRoot3, host) };
+  } catch (error) {
+    const busyResult = getIndexBusyResult(error);
+    if (!busyResult) throw error;
+    return busyResult;
+  }
+}
+async function getPrImpact(projectRoot3, host, params) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.getPrImpact({
     pr: params.pr,
     branch: params.branch,
@@ -9162,8 +10389,8 @@ async function getPrImpact(projectRoot2, host, params) {
     direction: params.direction
   });
 }
-async function getIndexMetrics(projectRoot2, host) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getIndexMetrics(projectRoot3, host) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   const logger = indexer.getLogger();
   if (!logger.isEnabled()) {
     return {
@@ -9185,8 +10412,8 @@ async function getIndexMetrics(projectRoot2, host) {
     text: logger.formatMetrics()
   };
 }
-async function getIndexLogs(projectRoot2, host, args) {
-  const indexer = getIndexerForProject(projectRoot2, host);
+async function getIndexLogs(projectRoot3, host, args) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   const logger = indexer.getLogger();
   if (!logger.isEnabled()) {
     return {
@@ -9208,24 +10435,24 @@ async function getIndexLogs(projectRoot2, host, args) {
       text: "No logs recorded yet. Logs are captured during indexing and search operations."
     };
   }
-  const text2 = logs.map((entry) => {
+  const text3 = logs.map((entry) => {
     const dataStr = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
     return `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.category}] ${entry.message}${dataStr}`;
   }).join("\n");
-  return { kind: "entries", text: text2 };
+  return { kind: "entries", text: text3 };
 }
-function addKnowledgeBase(projectRoot2, host, knowledgeBasePath) {
-  const root = getProjectRoot(projectRoot2, host);
+function addKnowledgeBase(projectRoot3, host, knowledgeBasePath) {
+  const root = getProjectRoot(projectRoot3, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath = path14.resolve(
-    path14.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}`;
   }
@@ -9254,13 +10481,13 @@ function addKnowledgeBase(projectRoot2, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path14.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 stat = statSync3(normalizedPath);
+    const stat = statSync4(normalizedPath);
     if (!stat.isDirectory()) {
       return `Error: Path is not a directory: ${normalizedPath}`;
     }
@@ -9287,8 +10514,8 @@ function addKnowledgeBase(projectRoot2, host, knowledgeBasePath) {
 Run /index to rebuild the index with the new knowledge base.`;
   return result;
 }
-function listKnowledgeBases(projectRoot2, host) {
-  const root = getProjectRoot(projectRoot2, host);
+function listKnowledgeBases(projectRoot3, host) {
+  const root = getProjectRoot(projectRoot3, host);
   const config = loadRuntimeConfig(root, host);
   const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
   if (knowledgeBases.length === 0) {
@@ -9300,7 +10527,7 @@ function listKnowledgeBases(projectRoot2, 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}
@@ -9309,7 +10536,7 @@ function listKnowledgeBases(projectRoot2, host) {
 `;
     if (exists) {
       try {
-        const stat = statSync3(resolvedPath);
+        const stat = statSync4(resolvedPath);
         result += `    Type: ${stat.isDirectory() ? "Directory" : "File"}
 `;
       } catch {
@@ -9317,7 +10544,7 @@ function listKnowledgeBases(projectRoot2, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync9(path14.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync10(path16.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -9326,8 +10553,8 @@ Config sources: 1 file(s).`;
 Config file: ${getConfigPath(root, host)}`;
   return result;
 }
-function removeKnowledgeBase(projectRoot2, host, knowledgeBasePath) {
-  const root = getProjectRoot(projectRoot2, host);
+function removeKnowledgeBase(projectRoot3, host, knowledgeBasePath) {
+  const root = getProjectRoot(projectRoot3, host);
   const config = loadEditableConfig(root, host);
   const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
   const index = findKnowledgeBasePathIndex(knowledgeBases, knowledgeBasePath, root);
@@ -9350,17 +10577,9 @@ Run /index to rebuild the index without the removed knowledge base.`;
   return result;
 }
 
-// src/pi-extension.ts
+// src/pi-call-graph.ts
+import { Type } from "typebox";
 var HOST = "pi";
-var ChunkType = Type.Union([
-  Type.Literal("function"),
-  Type.Literal("class"),
-  Type.Literal("method"),
-  Type.Literal("interface"),
-  Type.Literal("type"),
-  Type.Literal("module"),
-  Type.Literal("block")
-]);
 var RelationshipType = Type.Union([
   Type.Literal("Call"),
   Type.Literal("MethodCall"),
@@ -9369,214 +10588,250 @@ var RelationshipType = Type.Union([
   Type.Literal("Inherits"),
   Type.Literal("Implements")
 ]);
-function text(text2, details) {
-  return { content: [{ type: "text", text: text2 }], details };
+function text(text3, details) {
+  return { content: [{ type: "text", text: text3 }], details };
 }
 function projectRoot(ctx) {
   return ctx?.cwd ?? process.cwd();
 }
+function registerPiCallGraphTools(pi) {
+  pi.registerTool({
+    name: "call_graph",
+    label: "Call Graph",
+    description: "Find callers or callees of a function/method in the indexed call graph.",
+    parameters: Type.Object({
+      name: Type.String(),
+      direction: Type.Optional(Type.Union([Type.Literal("callers"), Type.Literal("callees")])),
+      symbolId: Type.Optional(Type.String()),
+      relationshipType: Type.Optional(RelationshipType)
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await getCallGraphData(projectRoot(ctx), HOST, params);
+      if (result.direction === "callees") {
+        return text(
+          params.symbolId ? formatCallGraphCallees(params.symbolId, result.callees, params.relationshipType) : "Error: 'symbolId' is required when direction is 'callees'.",
+          result
+        );
+      }
+      return text(formatCallGraphCallers(params.name, result.callers, params.relationshipType), result);
+    }
+  });
+  pi.registerTool({
+    name: "call_graph_path",
+    label: "Call Graph Path",
+    description: "Find a call path between two functions/methods.",
+    parameters: Type.Object({
+      from: Type.String(),
+      to: Type.String(),
+      maxDepth: Type.Optional(Type.Number({ default: 10 }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await getCallGraphPath(projectRoot(ctx), HOST, params.from, params.to, params.maxDepth);
+      return text(formatCallGraphPath(params.from, params.to, result), result);
+    }
+  });
+}
+
+// src/pi-extension.ts
+var HOST2 = "pi";
+var ChunkType = Type2.Union([
+  Type2.Literal("function"),
+  Type2.Literal("class"),
+  Type2.Literal("method"),
+  Type2.Literal("interface"),
+  Type2.Literal("type"),
+  Type2.Literal("module"),
+  Type2.Literal("block")
+]);
+function text2(text3, details) {
+  return { content: [{ type: "text", text: text3 }], details };
+}
+function projectRoot2(ctx) {
+  return ctx?.cwd ?? process.cwd();
+}
 function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "codebase_search",
     label: "Codebase Search",
     description: "Semantic search over the indexed codebase. Describe behavior, not syntax.",
-    parameters: Type.Object({
-      query: Type.String({ description: "Natural language description of what code you're looking for" }),
-      limit: Type.Optional(Type.Number({ description: "Maximum results (default: 10)" })),
-      fileType: Type.Optional(Type.String({ description: "Filter by extension, e.g. ts, py, rs" })),
-      directory: Type.Optional(Type.String({ description: "Filter by directory path" })),
-      chunkType: Type.Optional(ChunkType),
-      contextLines: Type.Optional(Type.Number({ description: "Extra lines around each match" }))
+    parameters: Type2.Object({
+      query: Type2.String({ description: "Natural language description of what code you're looking for" }),
+      limit: Type2.Optional(Type2.Number({ description: "Maximum results (default: 10)" })),
+      fileType: Type2.Optional(Type2.String({ description: "Filter by extension, e.g. ts, py, rs" })),
+      directory: Type2.Optional(Type2.String({ description: "Filter by directory path" })),
+      chunkType: Type2.Optional(ChunkType),
+      contextLines: Type2.Optional(Type2.Number({ description: "Extra lines around each match" })),
+      blameAuthor: Type2.Optional(Type2.String({ description: "Filter by git blame author name or email" })),
+      blameSha: Type2.Optional(Type2.String({ description: "Filter by git blame commit SHA or prefix" })),
+      blameSince: Type2.Optional(Type2.String({ description: "Filter to chunks last changed on or after this date" }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const results = await searchCodebase(projectRoot(ctx), HOST, params.query, params);
-      return text(formatSearchResults(results), results);
+      const results = await searchCodebase(projectRoot2(ctx), HOST2, params.query, params);
+      return text2(formatSearchResults(results), results);
     }
   });
   pi.registerTool({
     name: "codebase_peek",
     label: "Codebase Peek",
     description: "Semantic search returning only metadata (file, lines, symbol) to save tokens.",
-    parameters: Type.Object({
-      query: Type.String(),
-      limit: Type.Optional(Type.Number()),
-      fileType: Type.Optional(Type.String()),
-      directory: Type.Optional(Type.String()),
-      chunkType: Type.Optional(ChunkType)
+    parameters: Type2.Object({
+      query: Type2.String(),
+      limit: Type2.Optional(Type2.Number()),
+      fileType: Type2.Optional(Type2.String()),
+      directory: Type2.Optional(Type2.String()),
+      chunkType: Type2.Optional(ChunkType),
+      blameAuthor: Type2.Optional(Type2.String()),
+      blameSha: Type2.Optional(Type2.String()),
+      blameSince: Type2.Optional(Type2.String())
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const results = await searchCodebase(projectRoot(ctx), HOST, params.query, { ...params, metadataOnly: true });
-      return text(formatSearchResults(results), results);
+      const results = await searchCodebase(projectRoot2(ctx), HOST2, params.query, { ...params, metadataOnly: true });
+      return text2(formatSearchResults(results), results);
     }
   });
   pi.registerTool({
     name: "find_similar",
     label: "Find Similar Code",
     description: "Find code similar to a snippet for duplicate detection and pattern discovery.",
-    parameters: Type.Object({
-      code: Type.String({ description: "Code snippet to compare" }),
-      limit: Type.Optional(Type.Number()),
-      fileType: Type.Optional(Type.String()),
-      directory: Type.Optional(Type.String()),
-      chunkType: Type.Optional(ChunkType),
-      excludeFile: Type.Optional(Type.String())
+    parameters: Type2.Object({
+      code: Type2.String({ description: "Code snippet to compare" }),
+      limit: Type2.Optional(Type2.Number()),
+      fileType: Type2.Optional(Type2.String()),
+      directory: Type2.Optional(Type2.String()),
+      chunkType: Type2.Optional(ChunkType),
+      excludeFile: Type2.Optional(Type2.String())
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const results = await findSimilarCode(projectRoot(ctx), HOST, params.code, params);
-      return text(formatSearchResults(results, "similarity"), results);
+      const results = await findSimilarCode(projectRoot2(ctx), HOST2, params.code, params);
+      return text2(formatSearchResults(results, "similarity"), results);
     }
   });
   pi.registerTool({
     name: "implementation_lookup",
     label: "Implementation Lookup",
     description: "Find likely symbol definitions or implementations by name or natural language.",
-    parameters: Type.Object({
-      query: Type.String(),
-      limit: Type.Optional(Type.Number()),
-      fileType: Type.Optional(Type.String()),
-      directory: Type.Optional(Type.String())
+    parameters: Type2.Object({
+      query: Type2.String(),
+      limit: Type2.Optional(Type2.Number()),
+      fileType: Type2.Optional(Type2.String()),
+      directory: Type2.Optional(Type2.String())
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const results = await implementationLookup(projectRoot(ctx), HOST, params.query, params);
-      return text(formatDefinitionLookup(results, params.query), results);
+      const results = await implementationLookup(projectRoot2(ctx), HOST2, params.query, params);
+      return text2(formatDefinitionLookup(results, params.query), results);
     }
   });
   pi.registerTool({
     name: "index_codebase",
     label: "Index Codebase",
     description: "Build or refresh the semantic codebase index.",
-    parameters: Type.Object({
-      force: Type.Optional(Type.Boolean({ default: false })),
-      estimateOnly: Type.Optional(Type.Boolean({ default: false })),
-      verbose: Type.Optional(Type.Boolean({ default: false }))
+    parameters: Type2.Object({
+      force: Type2.Optional(Type2.Boolean({ default: false })),
+      estimateOnly: Type2.Optional(Type2.Boolean({ default: false })),
+      verbose: Type2.Optional(Type2.Boolean({ default: false }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await runIndexCodebase(projectRoot(ctx), HOST, params);
-      return result.kind === "estimate" ? text(formatCostEstimate(result.estimate), result.estimate) : text(formatIndexStats(result.stats, params.verbose ?? false), result.stats);
+      const result = await runIndexCodebase(projectRoot2(ctx), HOST2, params);
+      if (result.kind === "estimate") return text2(formatCostEstimate(result.estimate), result.estimate);
+      if (result.kind === "busy") return text2(result.text, { code: "INDEX_BUSY" });
+      return text2(formatIndexStats(result.stats, params.verbose ?? false), result.stats);
     }
   });
   pi.registerTool({
     name: "index_status",
     label: "Index Status",
     description: "Check index health and current status.",
-    parameters: Type.Object({}),
+    parameters: Type2.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      const status = await getIndexStatus(projectRoot(ctx), HOST);
-      return text(formatStatus(status), status);
+      const status = await getIndexStatus(projectRoot2(ctx), HOST2);
+      return text2(formatStatus(status), status);
     }
   });
   pi.registerTool({
     name: "index_health_check",
     label: "Index Health Check",
     description: "Garbage collect orphaned embeddings/chunks and report health.",
-    parameters: Type.Object({}),
+    parameters: Type2.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      const result = await getIndexHealthCheck(projectRoot(ctx), HOST);
-      return text(formatHealthCheck(result), result);
+      const result = await runIndexHealthCheck(projectRoot2(ctx), HOST2);
+      if (result.kind === "busy") return text2(result.text, { code: "INDEX_BUSY" });
+      return text2(formatHealthCheck(result.health), result.health);
     }
   });
   pi.registerTool({
     name: "index_metrics",
     label: "Index Metrics",
     description: "Return collected performance metrics when debug metrics are enabled.",
-    parameters: Type.Object({}),
+    parameters: Type2.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      const result = await getIndexMetrics(projectRoot(ctx), HOST);
-      return text(result.text, result);
+      const result = await getIndexMetrics(projectRoot2(ctx), HOST2);
+      return text2(result.text, result);
     }
   });
   pi.registerTool({
     name: "index_logs",
     label: "Index Logs",
     description: "Return recent debug logs when debug logging is enabled.",
-    parameters: Type.Object({
-      limit: Type.Optional(Type.Number()),
-      category: Type.Optional(Type.Union([
-        Type.Literal("search"),
-        Type.Literal("embedding"),
-        Type.Literal("cache"),
-        Type.Literal("gc"),
-        Type.Literal("branch"),
-        Type.Literal("general")
+    parameters: Type2.Object({
+      limit: Type2.Optional(Type2.Number()),
+      category: Type2.Optional(Type2.Union([
+        Type2.Literal("search"),
+        Type2.Literal("embedding"),
+        Type2.Literal("cache"),
+        Type2.Literal("gc"),
+        Type2.Literal("branch"),
+        Type2.Literal("general")
       ])),
-      level: Type.Optional(Type.Union([Type.Literal("error"), Type.Literal("warn"), Type.Literal("info"), Type.Literal("debug")]))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await getIndexLogs(projectRoot(ctx), HOST, params);
-      return text(result.text, result);
-    }
-  });
-  pi.registerTool({
-    name: "call_graph",
-    label: "Call Graph",
-    description: "Find callers or callees of a function/method in the indexed call graph.",
-    parameters: Type.Object({
-      name: Type.String(),
-      direction: Type.Optional(Type.Union([Type.Literal("callers"), Type.Literal("callees")])),
-      symbolId: Type.Optional(Type.String()),
-      relationshipType: Type.Optional(RelationshipType)
+      level: Type2.Optional(Type2.Union([Type2.Literal("error"), Type2.Literal("warn"), Type2.Literal("info"), Type2.Literal("debug")]))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await getCallGraphData(projectRoot(ctx), HOST, params);
-      return text(JSON.stringify(result, null, 2), result);
-    }
-  });
-  pi.registerTool({
-    name: "call_graph_path",
-    label: "Call Graph Path",
-    description: "Find a call path between two functions/methods.",
-    parameters: Type.Object({
-      from: Type.String(),
-      to: Type.String(),
-      maxDepth: Type.Optional(Type.Number({ default: 10 }))
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await getCallGraphPath(projectRoot(ctx), HOST, params.from, params.to, params.maxDepth);
-      return text(JSON.stringify(result, null, 2), result);
+      const result = await getIndexLogs(projectRoot2(ctx), HOST2, params);
+      return text2(result.text, result);
     }
   });
+  registerPiCallGraphTools(pi);
   pi.registerTool({
     name: "pr_impact",
     label: "PR Impact",
     description: "Analyze PR or branch impact through changed symbols and call graph neighborhoods.",
-    parameters: Type.Object({
-      pr: Type.Optional(Type.Number()),
-      branch: Type.Optional(Type.String()),
-      maxDepth: Type.Optional(Type.Number({ default: 5 })),
-      hubThreshold: Type.Optional(Type.Number({ default: 10 })),
-      checkConflicts: Type.Optional(Type.Boolean({ default: false })),
-      direction: Type.Optional(Type.Union([Type.Literal("callers"), Type.Literal("callees"), Type.Literal("both")]))
+    parameters: Type2.Object({
+      pr: Type2.Optional(Type2.Number()),
+      branch: Type2.Optional(Type2.String()),
+      maxDepth: Type2.Optional(Type2.Number({ default: 5 })),
+      hubThreshold: Type2.Optional(Type2.Number({ default: 10 })),
+      checkConflicts: Type2.Optional(Type2.Boolean({ default: false })),
+      direction: Type2.Optional(Type2.Union([Type2.Literal("callers"), Type2.Literal("callees"), Type2.Literal("both")]))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await getPrImpact(projectRoot(ctx), HOST, params);
-      return text(formatPrImpact(result), result);
+      const result = await getPrImpact(projectRoot2(ctx), HOST2, params);
+      return text2(formatPrImpact(result), result);
     }
   });
   pi.registerTool({
     name: "knowledge_base_list",
     label: "List Knowledge Bases",
     description: "List configured knowledge-base paths included in the index.",
-    parameters: Type.Object({}),
+    parameters: Type2.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      return text(listKnowledgeBases(projectRoot(ctx), HOST));
+      return text2(listKnowledgeBases(projectRoot2(ctx), HOST2));
     }
   });
   pi.registerTool({
     name: "knowledge_base_add",
     label: "Add Knowledge Base",
     description: "Add a knowledge-base path to the codebase index config.",
-    parameters: Type.Object({ path: Type.String({ description: "File or directory path to add" }) }),
+    parameters: Type2.Object({ path: Type2.String({ description: "File or directory path to add" }) }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      return text(addKnowledgeBase(projectRoot(ctx), HOST, params.path));
+      return text2(addKnowledgeBase(projectRoot2(ctx), HOST2, params.path));
     }
   });
   pi.registerTool({
     name: "knowledge_base_remove",
     label: "Remove Knowledge Base",
     description: "Remove a knowledge-base path from the codebase index config.",
-    parameters: Type.Object({ path: Type.String({ description: "File or directory path to remove" }) }),
+    parameters: Type2.Object({ path: Type2.String({ description: "File or directory path to remove" }) }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      return text(removeKnowledgeBase(projectRoot(ctx), HOST, params.path));
+      return text2(removeKnowledgeBase(projectRoot2(ctx), HOST2, params.path));
     }
   });
 }