opencode-codebase-index 0.13.1 → 0.14.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(path16, 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(path16);
           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 = (path16, originalPath, doThrow) => {
+      if (!isString(path16)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path15) {
+      if (!path16) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path15)) {
+      if (checkPath.isNotRelative(path16)) {
         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 = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
     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 path16 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path15,
+          path16,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path15, cache, checkUnignored, slices);
+        return this._t(path16, cache, checkUnignored, slices);
       }
-      checkIgnore(path15) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path15)) {
-          return this.test(path15);
+      checkIgnore(path16) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path16)) {
+          return this.test(path16);
         }
-        const slices = path15.split(SLASH).filter(Boolean);
+        const slices = path16.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(path16, false, MODE_CHECK_IGNORE);
       }
-      _t(path15, cache, checkUnignored, slices) {
-        if (path15 in cache) {
-          return cache[path15];
+      _t(path16, cache, checkUnignored, slices) {
+        if (path16 in cache) {
+          return cache[path16];
         }
         if (!slices) {
-          slices = path15.split(SLASH).filter(Boolean);
+          slices = path16.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path15] = this._rules.test(path15, checkUnignored, MODE_IGNORE);
+          return cache[path16] = this._rules.test(path16, 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[path16] = parent.ignored ? parent : this._rules.test(path16, checkUnignored, MODE_IGNORE);
       }
-      ignores(path15) {
-        return this._test(path15, this._ignoreCache, false).ignored;
+      ignores(path16) {
+        return this._test(path16, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path15) => !this.ignores(path15);
+        return (path16) => !this.ignores(path16);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path15) {
-        return this._test(path15, this._testCache, true);
+      test(path16) {
+        return this._test(path16, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path15) => checkPath(path15 && checkPath.convert(path15), path15, RETURN_FALSE);
+    var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, 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 = (path16) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,7 +651,7 @@ 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 = [
@@ -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 = {
@@ -1324,7 +1328,7 @@ function formatPrImpact(result) {
 
 // src/tools/operations.ts
 import { existsSync as existsSync9, realpathSync, statSync as statSync3 } from "fs";
-import * as path14 from "path";
+import * as path15 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,8 @@ 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 getGlobalIndexPath(host = "opencode") {
   switch (host) {
@@ -1567,55 +1571,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 +1752,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 +1770,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 +1786,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;
@@ -1826,10 +1830,10 @@ 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 * as path12 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);
@@ -3137,10 +3141,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 +3167,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 +3184,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 +3213,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 +3233,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 +3254,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 +3262,7 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
       },
       body: JSON.stringify({
         model: this.modelInfo.model,
-        prompt: text2,
+        prompt: text3,
         truncate: false
       })
     });
@@ -3269,13 +3273,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 +3420,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 +3441,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 +3463,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 +3518,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 +3537,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 +3559,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);
     }
@@ -4121,8 +4125,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 = [];
@@ -4656,20 +4660,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 +4682,7 @@ async function getChangedFilesForPr(pr, projectRoot2, baseBranch) {
       return {
         files: normalizeFiles(
           data.files.map((f) => f.path),
-          projectRoot2
+          projectRoot3
         ),
         baseBranch: actualBaseBranch,
         source: "gh",
@@ -4695,49 +4699,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 +4750,61 @@ 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.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 +4884,45 @@ 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";
+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 +4966,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 +5081,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 = path12.resolve(filePath);
+  const normalizedRoot = path12.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path12.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5103,11 +5199,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 +5842,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 +5927,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 +6097,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) {
@@ -6037,14 +6150,14 @@ var Indexer = class {
   querySimilarityThreshold = 0.85;
   indexCompatibility = null;
   indexingLockPath = "";
-  constructor(projectRoot2, config, host = "opencode") {
-    this.projectRoot = projectRoot2;
+  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 = path12.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path12.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path12.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
@@ -6076,14 +6189,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    mkdirSync2(path11.dirname(targetPath), { recursive: true });
+    mkdirSync2(path12.dirname(targetPath), { recursive: true });
     writeFileSync2(tempPath, data);
     renameSync(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path11.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path12.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path11.resolve(this.projectRoot, kbRoot));
+      roots.add(path12.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6092,29 +6205,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.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(path12.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(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -6208,7 +6321,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path11.resolve(this.projectRoot);
+    const projectRootPath = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6231,7 +6344,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(path12.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -6315,7 +6428,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(path12.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 +6462,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 = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6709,13 +6822,13 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path11.join(this.indexPath, "vectors");
+    const storePath = path12.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path11.join(this.indexPath, "vectors.usearch");
+    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
     if (existsSync7(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path12.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
@@ -6725,7 +6838,7 @@ var Indexer = class {
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path11.join(this.indexPath, "codebase.db");
+    const dbPath = path12.join(this.indexPath, "codebase.db");
     let dbIsNew = !existsSync7(dbPath);
     try {
       this.database = new Database(dbPath);
@@ -6806,7 +6919,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(path12.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6821,7 +6934,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path11.join(this.indexPath, "vectors");
+    const storeBasePath = path12.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -6906,7 +7019,7 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path11.join(this.indexPath, "codebase.db");
+    const dbPath = path12.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
@@ -6929,15 +7042,15 @@ var Indexer = class {
     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")
+      path12.join(this.indexPath, "codebase.db"),
+      path12.join(this.indexPath, "codebase.db-shm"),
+      path12.join(this.indexPath, "codebase.db-wal"),
+      path12.join(this.indexPath, "vectors.usearch"),
+      path12.join(this.indexPath, "inverted-index.json"),
+      path12.join(this.indexPath, "file-hashes.json"),
+      path12.join(this.indexPath, "failed-batches.json"),
+      path12.join(this.indexPath, "indexing.lock"),
+      path12.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -7174,6 +7287,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 +7296,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 +7304,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 +7316,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 = path12.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7223,6 +7382,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 +7395,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 +7417,8 @@ var Indexer = class {
           chunkType: chunk.chunkType,
           name: chunk.name,
           language: chunk.language,
-          hash: contentHash
+          hash: contentHash,
+          ...blameMetadata
         };
         pendingChunks.push({
           id,
@@ -7392,6 +7561,9 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
+      if (backfilledBlameMetadata) {
+        store.save();
+      }
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
         this.clearScopedFailedBatches(scopedRoots);
@@ -7771,9 +7943,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) {
@@ -7955,7 +8127,8 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
@@ -8047,12 +8220,12 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPaths = [path11.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    const localProjectIndexPaths = [path12.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
     if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path11.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+      localProjectIndexPaths.push(path12.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
     }
     const isLocalProjectIndex = localProjectIndexPaths.some(
-      (localPath) => path11.resolve(this.indexPath) === path11.resolve(localPath)
+      (localPath) => path12.resolve(this.indexPath) === path12.resolve(localPath)
     );
     if (!isLocalProjectIndex) {
       throw new Error(
@@ -8142,7 +8315,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8462,7 +8635,8 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
@@ -8499,9 +8673,9 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     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 path16 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path16.length > 0 && (shortest.length === 0 || path16.length < shortest.length)) {
+        shortest = path16;
       }
     }
     return shortest;
@@ -8533,7 +8707,7 @@ var Indexer = class {
   }
   async getPrImpact(opts) {
     const { database } = await this.ensureInitialized();
-    const execFileAsync2 = promisify2(execFile2);
+    const execFileAsync3 = promisify3(execFile3);
     const changedFilesResult = await getChangedFiles({
       pr: opts.pr,
       branch: opts.branch,
@@ -8555,7 +8729,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) => path12.resolve(this.projectRoot, f));
     const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
@@ -8617,7 +8791,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 +8812,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) => path12.resolve(this.projectRoot, f));
             const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
             const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
@@ -8701,12 +8875,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 ? path12.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path11.resolve(filePath);
+          const absoluteFilePath = path12.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 + path12.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -8738,43 +8912,43 @@ var Indexer = class {
 };
 
 // src/tools/knowledge-base-paths.ts
-import * as path12 from "path";
+import * as path13 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 = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
+  return path13.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path12.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path12.normalize(trimmed));
+  if (!path13.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path13.normalize(trimmed));
   }
-  const relativePath = path12.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path12.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path12.normalize(relativePath || "."));
+  const relativePath = path13.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path13.normalize(relativePath || "."));
   }
-  return path12.normalize(trimmed);
+  return path13.normalize(trimmed);
 }
-function resolveKnowledgeBasePath(value, projectRoot2) {
-  return path12.isAbsolute(value) ? value : path12.resolve(projectRoot2, value);
+function resolveKnowledgeBasePath(value, projectRoot3) {
+  return path13.isAbsolute(value) ? value : path13.resolve(projectRoot3, value);
 }
-function normalizeKnowledgeBasePath2(value, projectRoot2) {
-  return path12.normalize(resolveKnowledgeBasePath(value, projectRoot2));
+function normalizeKnowledgeBasePath2(value, projectRoot3) {
+  return path13.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 = path13.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 = path13.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path12.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot2) === normalizedInput
+    (kb) => path13.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput
   );
 }
 
@@ -8947,16 +9121,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, path16) {
+  if (path16.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 = path16.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 (${path16.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 +9182,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)}
 \`\`\``;
@@ -8977,12 +9192,12 @@ ${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 * as path14 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,19 +9208,19 @@ 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);
+function saveConfig(projectRoot3, config, host = "opencode") {
+  const configPath = getConfigPath(projectRoot3, host);
+  const configDir = path14.dirname(configPath);
+  const configBaseDir = path14.dirname(configDir);
   if (!existsSync8(configDir)) {
     mkdirSync3(configDir, { recursive: true });
   }
@@ -9022,9 +9237,9 @@ function saveConfig(projectRoot2, config, host = "opencode") {
 var indexerCache = /* @__PURE__ */ new Map();
 var configCache = /* @__PURE__ */ new Map();
 var defaultProjectRoots = /* @__PURE__ */ new Map();
-function getProjectRoot(projectRoot2, host) {
-  if (projectRoot2) {
-    return projectRoot2;
+function getProjectRoot(projectRoot3, host) {
+  if (projectRoot3) {
+    return projectRoot3;
   }
   const root = defaultProjectRoots.get(host);
   if (!root) {
@@ -9032,53 +9247,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));
+function shouldForceLocalizeProjectIndex(projectRoot3, host = "opencode") {
+  const root = getProjectRoot(projectRoot3, host);
+  const localIndexPath = path15.join(root, getHostProjectIndexRelativePath(host));
   if (existsSync9(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 +9304,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,12 +9324,12 @@ 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);
@@ -9143,16 +9361,16 @@ async function runIndexCodebase(projectRoot2, host, args, onProgress) {
   });
   return { kind: "stats", stats };
 }
-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 getPrImpact(projectRoot3, host, params) {
+  const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.getPrImpact({
     pr: params.pr,
     branch: params.branch,
@@ -9162,8 +9380,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 +9403,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,17 +9426,17 @@ 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 = path15.resolve(
+    path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
   if (!existsSync9(normalizedPath)) {
     return `Error: Directory does not exist: ${normalizedPath}`;
@@ -9254,7 +9472,7 @@ function addKnowledgeBase(projectRoot2, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path14.join(homeDir, dotDir);
+    const sensitiveDir = path15.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
     }
@@ -9287,8 +9505,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) {
@@ -9317,7 +9535,7 @@ function listKnowledgeBases(projectRoot2, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync9(path14.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync9(path15.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -9326,8 +9544,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 +9568,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 +9579,247 @@ 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);
+      return result.kind === "estimate" ? text2(formatCostEstimate(result.estimate), result.estimate) : 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 getIndexHealthCheck(projectRoot2(ctx), HOST2);
+      return text2(formatHealthCheck(result), result);
     }
   });
   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")]))
+      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 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)
-    }),
-    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));
     }
   });
 }