opencode-codebase-index 0.16.0 → 0.17.1

package/dist/cli.js

@@ -1070,6 +1070,11 @@ function metricDelta(current, baseline) {
   };
 }
 function compareSummaries(current, baseline, againstPath) {
+  if (current.datasetName !== baseline.datasetName || current.datasetVersion !== baseline.datasetVersion || current.queryCount !== baseline.queryCount) {
+    throw new Error(
+      `Cannot compare incompatible evaluation datasets: current=${current.datasetName}@${current.datasetVersion} (${current.queryCount} queries), baseline=${baseline.datasetName}@${baseline.datasetVersion} (${baseline.queryCount} queries) at ${againstPath}`
+    );
+  }
   return {
     againstPath,
     deltas: {
@@ -1091,6 +1096,34 @@ function compareSummaries(current, baseline, againstPath) {
       estimatedCostUsd: metricDelta(
         current.metrics.embedding.estimatedCostUsd,
         baseline.metrics.embedding.estimatedCostUsd
+      ),
+      contextResponseTokensAverage: metricDelta(
+        current.metrics.contextEfficiency.responseTokens.average,
+        baseline.metrics.contextEfficiency.responseTokens.average
+      ),
+      contextResponseTokensP95: metricDelta(
+        current.metrics.contextEfficiency.responseTokens.p95,
+        baseline.metrics.contextEfficiency.responseTokens.p95
+      ),
+      contextResponseTokensMax: metricDelta(
+        current.metrics.contextEfficiency.responseTokens.max,
+        baseline.metrics.contextEfficiency.responseTokens.max
+      ),
+      contextDuplicateCandidateRatio: metricDelta(
+        current.metrics.contextEfficiency.duplicateCandidateRatio,
+        baseline.metrics.contextEfficiency.duplicateCandidateRatio
+      ),
+      contextSelectedFileRatio: metricDelta(
+        current.metrics.contextEfficiency.selectedFileRatio,
+        baseline.metrics.contextEfficiency.selectedFileRatio
+      ),
+      contextHitAt5Per1kResponseTokens: metricDelta(
+        current.metrics.contextEfficiency.hitAt5Per1kResponseTokens,
+        baseline.metrics.contextEfficiency.hitAt5Per1kResponseTokens
+      ),
+      contextMrrAt10Per1kResponseTokens: metricDelta(
+        current.metrics.contextEfficiency.mrrAt10Per1kResponseTokens,
+        baseline.metrics.contextEfficiency.mrrAt10Per1kResponseTokens
       )
     }
   };
@@ -1128,6 +1161,25 @@ function validateSummary(summary, summaryPath, options) {
   assertFiniteNumber(summary.metrics.latencyMs.p99, `${summaryPath}.metrics.latencyMs.p99`);
   assertFiniteNumber(summary.metrics.embedding.callCount, `${summaryPath}.metrics.embedding.callCount`);
   assertFiniteNumber(summary.metrics.embedding.estimatedCostUsd, `${summaryPath}.metrics.embedding.estimatedCostUsd`);
+  if (!summary.metrics.contextEfficiency) {
+    summary.metrics.contextEfficiency = {
+      queryCount: 0,
+      responseTokens: { total: 0, average: 0, p95: 0, max: 0 },
+      duplicateCandidateRatio: 0,
+      selectedFileRatio: 0,
+      hitAt5Per1kResponseTokens: 0,
+      mrrAt10Per1kResponseTokens: 0
+    };
+  }
+  assertFiniteNumber(summary.metrics.contextEfficiency.queryCount, `${summaryPath}.metrics.contextEfficiency.queryCount`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.responseTokens.total, `${summaryPath}.metrics.contextEfficiency.responseTokens.total`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.responseTokens.average, `${summaryPath}.metrics.contextEfficiency.responseTokens.average`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.responseTokens.p95, `${summaryPath}.metrics.contextEfficiency.responseTokens.p95`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.responseTokens.max, `${summaryPath}.metrics.contextEfficiency.responseTokens.max`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.duplicateCandidateRatio, `${summaryPath}.metrics.contextEfficiency.duplicateCandidateRatio`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.selectedFileRatio, `${summaryPath}.metrics.contextEfficiency.selectedFileRatio`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.hitAt5Per1kResponseTokens, `${summaryPath}.metrics.contextEfficiency.hitAt5Per1kResponseTokens`);
+  assertFiniteNumber(summary.metrics.contextEfficiency.mrrAt10Per1kResponseTokens, `${summaryPath}.metrics.contextEfficiency.mrrAt10Per1kResponseTokens`);
   return summary;
 }
 function formatPct(value) {
@@ -1202,6 +1254,15 @@ function createSummaryMarkdown(summary, comparison, gate, sweep) {
   lines.push(`| Embedding calls | ${summary.metrics.embedding.callCount} |`);
   lines.push(`| Embedding tokens | ${summary.metrics.tokenEstimate.embeddingTokensUsed} |`);
   lines.push(`| Estimated embedding cost | ${formatUsd(summary.metrics.embedding.estimatedCostUsd)} |`);
+  lines.push(`| Context queries | ${summary.metrics.contextEfficiency.queryCount} |`);
+  lines.push(`| Context response tokens total | ${summary.metrics.contextEfficiency.responseTokens.total} |`);
+  lines.push(`| Context response tokens avg | ${summary.metrics.contextEfficiency.responseTokens.average.toFixed(1)} |`);
+  lines.push(`| Context response tokens p95 | ${summary.metrics.contextEfficiency.responseTokens.p95.toFixed(1)} |`);
+  lines.push(`| Context response tokens max | ${summary.metrics.contextEfficiency.responseTokens.max.toFixed(1)} |`);
+  lines.push(`| Context duplicate candidate ratio | ${formatPct(summary.metrics.contextEfficiency.duplicateCandidateRatio)} |`);
+  lines.push(`| Context selected-file ratio | ${formatPct(summary.metrics.contextEfficiency.selectedFileRatio)} |`);
+  lines.push(`| Context Hit@5 / 1k response tokens | ${summary.metrics.contextEfficiency.hitAt5Per1kResponseTokens.toFixed(4)} |`);
+  lines.push(`| Context MRR@10 / 1k response tokens | ${summary.metrics.contextEfficiency.mrrAt10Per1kResponseTokens.toFixed(4)} |`);
   lines.push("");
   lines.push("## Failure Buckets");
   lines.push("");
@@ -1245,6 +1306,27 @@ function createSummaryMarkdown(summary, comparison, gate, sweep) {
     lines.push(
       `| p95 latency (ms) | ${comparison.deltas.latencyP95Ms.baseline.toFixed(3)} | ${comparison.deltas.latencyP95Ms.current.toFixed(3)} | ${signed(comparison.deltas.latencyP95Ms.absolute, 3)} |`
     );
+    lines.push(
+      `| Context response tokens avg | ${comparison.deltas.contextResponseTokensAverage.baseline.toFixed(1)} | ${comparison.deltas.contextResponseTokensAverage.current.toFixed(1)} | ${signed(comparison.deltas.contextResponseTokensAverage.absolute, 1)} |`
+    );
+    lines.push(
+      `| Context response tokens p95 | ${comparison.deltas.contextResponseTokensP95.baseline.toFixed(1)} | ${comparison.deltas.contextResponseTokensP95.current.toFixed(1)} | ${signed(comparison.deltas.contextResponseTokensP95.absolute, 1)} |`
+    );
+    lines.push(
+      `| Context response tokens max | ${comparison.deltas.contextResponseTokensMax.baseline.toFixed(1)} | ${comparison.deltas.contextResponseTokensMax.current.toFixed(1)} | ${signed(comparison.deltas.contextResponseTokensMax.absolute, 1)} |`
+    );
+    lines.push(
+      `| Context duplicate candidate ratio | ${formatPct(comparison.deltas.contextDuplicateCandidateRatio.baseline)} | ${formatPct(comparison.deltas.contextDuplicateCandidateRatio.current)} | ${signed(comparison.deltas.contextDuplicateCandidateRatio.absolute)} |`
+    );
+    lines.push(
+      `| Context selected-file ratio | ${formatPct(comparison.deltas.contextSelectedFileRatio.baseline)} | ${formatPct(comparison.deltas.contextSelectedFileRatio.current)} | ${signed(comparison.deltas.contextSelectedFileRatio.absolute)} |`
+    );
+    lines.push(
+      `| Context Hit@5 / 1k response tokens | ${comparison.deltas.contextHitAt5Per1kResponseTokens.baseline.toFixed(4)} | ${comparison.deltas.contextHitAt5Per1kResponseTokens.current.toFixed(4)} | ${signed(comparison.deltas.contextHitAt5Per1kResponseTokens.absolute)} |`
+    );
+    lines.push(
+      `| Context MRR@10 / 1k response tokens | ${comparison.deltas.contextMrrAt10Per1kResponseTokens.baseline.toFixed(4)} | ${comparison.deltas.contextMrrAt10Per1kResponseTokens.current.toFixed(4)} | ${signed(comparison.deltas.contextMrrAt10Per1kResponseTokens.absolute)} |`
+    );
     lines.push("");
   }
   if (gate) {
@@ -1291,8 +1373,8 @@ function buildPerQueryArtifact(perQuery) {
 }
 
 // src/eval/runner.ts
-import { existsSync as existsSync9 } from "fs";
-import * as path15 from "path";
+import { existsSync as existsSync12 } from "fs";
+import * as path19 from "path";
 import { performance as performance3 } from "perf_hooks";
 
 // src/indexer/index.ts
@@ -5044,7 +5126,12 @@ function sameReclaimOwner(left, right) {
 }
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${randomUUID()}`;
-  mkdirSync2(candidatePath, { mode: 448 });
+  try {
+    mkdirSync2(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
   try {
     writeFileSync2(path11.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
@@ -5057,8 +5144,12 @@ function publishJsonDirectory(finalPath, value) {
       return true;
     } catch (error) {
       if (existsSync6(finalPath)) return false;
+      if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
   } finally {
     if (existsSync6(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
   }
@@ -6631,6 +6722,27 @@ function mergeTieredResults(symbolLane, hybridLane, limit) {
   }
   return out;
 }
+function selectChunksWithFileCoverage(chunks, limit) {
+  if (limit <= 0 || chunks.length === 0) {
+    return [];
+  }
+  if (chunks.length <= limit) {
+    return chunks;
+  }
+  if (limit === 1) {
+    return [chunks[Math.floor((chunks.length - 1) / 2)]];
+  }
+  const selected = [];
+  for (let index = 0; index < limit; index++) {
+    const sourceIndex = Math.round(index * (chunks.length - 1) / (limit - 1));
+    selected.push(chunks[sourceIndex]);
+  }
+  return selected;
+}
+function selectIndexableChunks(chunks, limit, semanticOnly) {
+  const indexableChunks = semanticOnly ? chunks.filter((chunk) => chunk.chunkType !== "other") : chunks;
+  return selectChunksWithFileCoverage(indexableChunks, limit);
+}
 function matchesSearchFilters(candidate, options, minScore) {
   if (candidate.score < minScore) return false;
   if (options?.fileType) {
@@ -8369,7 +8481,6 @@ var Indexer = class {
         const relativePath = path12.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
-      let fileChunkCount = 0;
       let chunksToProcess = parsed.chunks;
       if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
         const changedFile = changedFiles.find((f) => f.path === parsed.path);
@@ -8378,13 +8489,12 @@ var Indexer = class {
           chunksToProcess = textChunks;
         }
       }
+      chunksToProcess = selectIndexableChunks(
+        chunksToProcess,
+        this.config.indexing.maxChunksPerFile,
+        this.config.indexing.semanticOnly
+      );
       for (const chunk of chunksToProcess) {
-        if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
-          break;
-        }
-        if (this.config.indexing.semanticOnly && chunk.chunkType === "other") {
-          continue;
-        }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
         const existingContentHash = existingChunks.get(id);
@@ -8408,7 +8518,6 @@ var Indexer = class {
           blameSummary: blameMetadata.blameSummary
         });
         if (existingContentHash === contentHash) {
-          fileChunkCount++;
           continue;
         }
         const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
@@ -8433,7 +8542,6 @@ var Indexer = class {
           contentHash,
           metadata
         });
-        fileChunkCount++;
       }
     }
     const retryableFailedChunks = this.collectRetryableFailedChunks(
@@ -9982,1955 +10090,2500 @@ var Indexer = class {
   }
 };
 
-// src/eval/budget.ts
-function evaluateBudgetGate(budget, summary, comparison) {
-  const BASELINE_P95_EPSILON_MS = 1e-3;
-  const violations = [];
-  const { thresholds } = budget;
-  if (thresholds.minHitAt5 !== void 0 && summary.metrics.hitAt5 < thresholds.minHitAt5) {
-    violations.push({
-      metric: "minHitAt5",
-      message: `Hit@5 ${summary.metrics.hitAt5.toFixed(4)} is below minimum ${thresholds.minHitAt5.toFixed(4)}`
-    });
-  }
-  if (thresholds.minMrrAt10 !== void 0 && summary.metrics.mrrAt10 < thresholds.minMrrAt10) {
-    violations.push({
-      metric: "minMrrAt10",
-      message: `MRR@10 ${summary.metrics.mrrAt10.toFixed(4)} is below minimum ${thresholds.minMrrAt10.toFixed(4)}`
-    });
-  }
-  if (thresholds.minRawDistinctTop3Ratio !== void 0 && summary.metrics.rawDistinctTop3Ratio < thresholds.minRawDistinctTop3Ratio) {
-    violations.push({
-      metric: "minRawDistinctTop3Ratio",
-      message: `Raw Distinct Top@3 ${summary.metrics.rawDistinctTop3Ratio.toFixed(4)} is below minimum ${thresholds.minRawDistinctTop3Ratio.toFixed(4)}`
-    });
+// src/tools/operations.ts
+import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import * as path17 from "path";
+
+// src/config/merger.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import * as path14 from "path";
+
+// src/config/rebase.ts
+import * as path13 from "path";
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path13.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath);
+}
+function rebasePathEntries(values, fromDir, toDir) {
+  if (!Array.isArray(values)) {
+    return [];
   }
-  if (comparison) {
-    if (thresholds.hitAt5MaxDrop !== void 0 && comparison.deltas.hitAt5.absolute < -thresholds.hitAt5MaxDrop) {
-      violations.push({
-        metric: "hitAt5MaxDrop",
-        message: `Hit@5 drop ${comparison.deltas.hitAt5.absolute.toFixed(4)} exceeds allowed -${thresholds.hitAt5MaxDrop.toFixed(4)}`
-      });
-    }
-    if (thresholds.mrrAt10MaxDrop !== void 0 && comparison.deltas.mrrAt10.absolute < -thresholds.mrrAt10MaxDrop) {
-      violations.push({
-        metric: "mrrAt10MaxDrop",
-        message: `MRR@10 drop ${comparison.deltas.mrrAt10.absolute.toFixed(4)} exceeds allowed -${thresholds.mrrAt10MaxDrop.toFixed(4)}`
-      });
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed || path13.isAbsolute(trimmed)) {
+      return trimmed;
     }
-    if (thresholds.rawDistinctTop3RatioMaxDrop !== void 0 && comparison.deltas.rawDistinctTop3Ratio.absolute < -thresholds.rawDistinctTop3RatioMaxDrop) {
-      violations.push({
-        metric: "rawDistinctTop3RatioMaxDrop",
-        message: `Raw Distinct Top@3 drop ${comparison.deltas.rawDistinctTop3Ratio.absolute.toFixed(4)} exceeds allowed -${thresholds.rawDistinctTop3RatioMaxDrop.toFixed(4)}`
-      });
+    return normalizePathSeparators(path13.normalize(path13.relative(toDir, path13.resolve(fromDir, trimmed))));
+  }).filter(Boolean);
+}
+function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return trimmed;
     }
-    if (thresholds.p95LatencyMaxMultiplier !== void 0) {
-      const baselineP95 = comparison.deltas.latencyP95Ms.baseline;
-      if (baselineP95 > BASELINE_P95_EPSILON_MS) {
-        const allowed = baselineP95 * thresholds.p95LatencyMaxMultiplier;
-        if (summary.metrics.latencyMs.p95 > allowed) {
-          violations.push({
-            metric: "p95LatencyMaxMultiplier",
-            message: `p95 latency ${summary.metrics.latencyMs.p95.toFixed(3)}ms exceeds allowed ${allowed.toFixed(3)}ms (${thresholds.p95LatencyMaxMultiplier.toFixed(2)}x baseline)`
-          });
-        }
+    if (path13.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizePathSeparators(path13.normalize(path13.relative(sourceRoot, trimmed) || "."));
       }
+      return path13.normalize(trimmed);
     }
-  }
-  if (thresholds.p95LatencyMaxAbsoluteMs !== void 0 && summary.metrics.latencyMs.p95 > thresholds.p95LatencyMaxAbsoluteMs) {
-    violations.push({
-      metric: "p95LatencyMaxAbsoluteMs",
-      message: `p95 latency ${summary.metrics.latencyMs.p95.toFixed(3)}ms exceeds absolute maximum ${thresholds.p95LatencyMaxAbsoluteMs.toFixed(3)}ms`
-    });
-  }
-  return {
-    passed: violations.length === 0,
-    budgetName: budget.name,
-    violations
-  };
+    const resolvedFromSource = path13.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizePathSeparators(path13.normalize(trimmed));
+    }
+    return normalizePathSeparators(path13.normalize(path13.relative(targetRoot, resolvedFromSource)));
+  }).filter(Boolean);
 }
 
-// src/eval/metrics.ts
-function percentile(values, p) {
-  if (values.length === 0) return 0;
-  if (values.length === 1) return values[0];
-  const sorted = [...values].sort((a, b) => a - b);
-  const x = p * (sorted.length - 1);
-  const lowerIndex = Math.floor(x);
-  const upperIndex = Math.ceil(x);
-  if (lowerIndex === upperIndex) {
-    return sorted[lowerIndex];
-  }
-  const fraction = x - lowerIndex;
-  return sorted[lowerIndex] + fraction * (sorted[upperIndex] - sorted[lowerIndex]);
+// src/config/merger.ts
+var PROJECT_OVERRIDE_KEYS = [
+  "embeddingProvider",
+  "customProvider",
+  "embeddingModel",
+  "reranker",
+  "include",
+  "exclude",
+  "indexing",
+  "search",
+  "debug",
+  "scope"
+];
+var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function normalizePath(input) {
-  return normalizePathSeparators(input);
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function uniqueResultsByPath(results) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const result of results) {
-    const normalized = normalizePath(result.filePath);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    unique.push(result);
+function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
+  if (key in normalizedProjectConfig) {
+    merged[key] = normalizedProjectConfig[key];
+    return;
+  }
+  if (key in globalConfig) {
+    merged[key] = globalConfig[key];
   }
-  return unique;
-}
-function distinctTopKRatio(results, k) {
-  const top = results.slice(0, k);
-  if (top.length === 0) return 0;
-  const distinct = new Set(top.map((result) => normalizePath(result.filePath))).size;
-  return distinct / top.length;
 }
-function pathMatchesExpected(actualPath, expectedPath) {
-  const actual = normalizePath(actualPath);
-  const expected = normalizePath(expectedPath);
-  if (actual === expected) return true;
-  return actual.endsWith(`/${expected}`) || expected.endsWith(`/${actual}`);
+function mergeUniqueStringArray(values) {
+  return [...new Set(values.map((value) => String(value).trim()))];
 }
-function getRelevantPaths(query) {
-  const fromExact = query.expected.filePath ? [query.expected.filePath] : [];
-  const fromAcceptable = query.expected.acceptableFiles ?? [];
-  return Array.from(/* @__PURE__ */ new Set([...fromExact, ...fromAcceptable]));
+function normalizeKnowledgeBasePath(value) {
+  let normalized = path14.normalize(String(value).trim());
+  const root = path14.parse(normalized).root;
+  while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
 }
-function isRelevantResult(filePath, relevantPaths) {
-  return relevantPaths.some((expected) => pathMatchesExpected(filePath, expected));
+function mergeKnowledgeBasePaths(values) {
+  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
 }
-function reciprocalRankAtK(results, relevantPaths, k) {
-  const top = uniqueResultsByPath(results).slice(0, k);
-  for (let i = 0; i < top.length; i += 1) {
-    if (isRelevantResult(top[i].filePath, relevantPaths)) {
-      return 1 / (i + 1);
+function validateConfigLayerShape(rawConfig, filePath) {
+  if (!isRecord(rawConfig)) {
+    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+  }
+  if (rawConfig.knowledgeBases !== void 0 && !isStringArray2(rawConfig.knowledgeBases)) {
+    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (rawConfig.additionalInclude !== void 0 && !isStringArray2(rawConfig.additionalInclude)) {
+    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (rawConfig.include !== void 0 && !isStringArray2(rawConfig.include)) {
+    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (rawConfig.exclude !== void 0 && !isStringArray2(rawConfig.exclude)) {
+    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
+  }
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = rawConfig[section];
+    if (value !== void 0 && !isRecord(value)) {
+      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
     }
   }
-  return 0;
+  return rawConfig;
 }
-function ndcgAtK(results, relevantPaths, k) {
-  const top = uniqueResultsByPath(results).slice(0, k);
-  const dcg = top.reduce((sum, result, i) => {
-    const rel = isRelevantResult(result.filePath, relevantPaths) ? 1 : 0;
-    return sum + rel / Math.log2(i + 2);
-  }, 0);
-  const idealLen = Math.min(k, relevantPaths.length);
-  const idcg = Array.from({ length: idealLen }, (_, i) => 1 / Math.log2(i + 2)).reduce(
-    (sum, value) => sum + value,
-    0
-  );
-  return idcg === 0 ? 0 : dcg / idcg;
+function loadJsonFile(filePath) {
+  if (!existsSync8(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync8(filePath, "utf-8");
+    return validateConfigLayerShape(JSON.parse(content), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Config file ")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config file ${filePath}: ${message}`);
+  }
 }
-function isDocsOrTestsPath(filePath) {
-  const lowered = normalizePath(filePath).toLowerCase();
-  return lowered.includes("/docs/") || lowered.includes("/test/") || lowered.includes("/tests/") || lowered.includes("readme") || lowered.includes("/benchmarks/");
+function loadConfigFile(filePath) {
+  return loadJsonFile(filePath);
 }
-function classifyFailureBucket(query, results, k) {
-  const relevantPaths = getRelevantPaths(query);
-  const top = uniqueResultsByPath(results).slice(0, k);
-  const hasRelevantTopK = top.some((result) => isRelevantResult(result.filePath, relevantPaths));
-  if (!hasRelevantTopK) {
-    return "no-relevant-hit-top-k";
+function materializeLocalProjectConfig(projectRoot, config, host = "opencode") {
+  const localConfigPath = resolveWritableProjectConfigPath(projectRoot, host);
+  mkdirSync4(path14.dirname(localConfigPath), { recursive: true });
+  writeFileSync4(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
+  return localConfigPath;
+}
+function loadProjectConfigLayer(projectRoot, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
   }
-  if (query.expected.symbol) {
-    const hasSymbol = top.some(
-      (result) => isRelevantResult(result.filePath, relevantPaths) && result.name === query.expected.symbol
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path14.dirname(path14.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot
     );
-    if (!hasSymbol) return "wrong-symbol";
   }
-  const top1 = top[0];
-  if (top1 && !isRelevantResult(top1.filePath, relevantPaths) && isDocsOrTestsPath(top1.filePath)) {
-    return "docs-tests-outranking-source";
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot, host = "opencode") {
+  const globalConfigPath = resolveGlobalConfigPath(host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
+  let globalConfig = null;
+  let globalConfigError = null;
+  try {
+    globalConfig = loadJsonFile(globalConfigPath);
+  } catch (error) {
+    globalConfigError = error instanceof Error ? error : new Error(String(error));
   }
-  if (top1 && !isRelevantResult(top1.filePath, relevantPaths)) {
-    return "wrong-file";
+  const projectConfig = loadJsonFile(projectConfigPath);
+  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot, host);
+  if (globalConfigError) {
+    if (!projectConfig) {
+      throw globalConfigError;
+    }
+    globalConfig = null;
   }
-  return void 0;
-}
-function buildPerQueryResult(query, results, latencyMs, k) {
-  const relevantPaths = getRelevantPaths(query);
-  const deduped = uniqueResultsByPath(results);
-  const hitAt = (cutoff) => deduped.slice(0, cutoff).some((result) => isRelevantResult(result.filePath, relevantPaths));
-  const perQuery = {
-    id: query.id,
-    query: query.query,
-    queryType: query.queryType,
-    latencyMs,
-    hitAt1: hitAt(1),
-    hitAt3: hitAt(3),
-    hitAt5: hitAt(5),
-    hitAt10: hitAt(10),
-    reciprocalRankAt10: reciprocalRankAtK(deduped, relevantPaths, 10),
-    ndcgAt10: ndcgAtK(deduped, relevantPaths, 10),
-    failureBucket: classifyFailureBucket(query, results, k),
-    rawTop3DistinctRatio: distinctTopKRatio(results, 3),
-    results: deduped
-  };
-  return perQuery;
-}
-function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingTokensUsed, costPer1MTokensUsd) {
-  const count = perQuery.length;
-  const safeDiv = (value) => count === 0 ? 0 : value / count;
-  const sum = {
-    hitAt1: 0,
-    hitAt3: 0,
-    hitAt5: 0,
-    hitAt10: 0,
-    mrrAt10: 0,
-    ndcgAt10: 0,
-    distinctTop3Ratio: 0,
-    rawDistinctTop3Ratio: 0
-  };
-  const failureBuckets = {
-    "wrong-file": 0,
-    "wrong-symbol": 0,
-    "docs-tests-outranking-source": 0,
-    "no-relevant-hit-top-k": 0
-  };
-  const latencies = perQuery.map((item) => item.latencyMs);
-  for (const query of perQuery) {
-    if (query.hitAt1) sum.hitAt1 += 1;
-    if (query.hitAt3) sum.hitAt3 += 1;
-    if (query.hitAt5) sum.hitAt5 += 1;
-    if (query.hitAt10) sum.hitAt10 += 1;
-    sum.mrrAt10 += query.reciprocalRankAt10;
-    sum.ndcgAt10 += query.ndcgAt10;
-    sum.distinctTop3Ratio += distinctTopKRatio(query.results, 3);
-    sum.rawDistinctTop3Ratio += query.rawTop3DistinctRatio;
-    if (query.failureBucket) {
-      failureBuckets[query.failureBucket] += 1;
+  if (!globalConfig && !projectConfig) {
+    return {};
+  }
+  if (!projectConfig && globalConfig) {
+    return globalConfig;
+  }
+  if (!globalConfig && projectConfig) {
+    return normalizedProjectConfig;
+  }
+  if (!globalConfig || !projectConfig) {
+    return globalConfig ?? normalizedProjectConfig;
+  }
+  const merged = { ...globalConfig };
+  for (const key of PROJECT_OVERRIDE_KEYS) {
+    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
+  }
+  if (projectConfig) {
+    for (const key of Object.keys(projectConfig)) {
+      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
+        continue;
+      }
+      merged[key] = normalizedProjectConfig[key];
     }
   }
-  const queryTokens = queries.reduce((acc, q) => acc + estimateTokens(q.query), 0);
-  return {
-    hitAt1: safeDiv(sum.hitAt1),
-    hitAt3: safeDiv(sum.hitAt3),
-    hitAt5: safeDiv(sum.hitAt5),
-    hitAt10: safeDiv(sum.hitAt10),
-    mrrAt10: safeDiv(sum.mrrAt10),
-    ndcgAt10: safeDiv(sum.ndcgAt10),
-    distinctTop3Ratio: safeDiv(sum.distinctTop3Ratio),
-    rawDistinctTop3Ratio: safeDiv(sum.rawDistinctTop3Ratio),
-    latencyMs: {
-      p50: percentile(latencies, 0.5),
-      p95: percentile(latencies, 0.95),
-      p99: percentile(latencies, 0.99)
-    },
-    tokenEstimate: {
-      queryTokens,
-      embeddingTokensUsed
-    },
-    embedding: {
-      callCount: embeddingCallCount,
-      estimatedCostUsd: embeddingTokensUsed / 1e6 * costPer1MTokensUsd,
-      costPer1MTokensUsd
-    },
-    failureBuckets
-  };
+  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
+  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
+  const allKbs = [...globalKbs, ...projectKbs];
+  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
+  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
+  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
+  const allAdditional = [...globalAdditional, ...projectAdditional];
+  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
+  return merged;
 }
 
-// src/eval/runner-config.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import * as os5 from "os";
-import * as path14 from "path";
+// src/tools/knowledge-base-paths.ts
+import * as path15 from "path";
+function resolveConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const absolutePath = path15.isAbsolute(trimmed) ? trimmed : path15.resolve(baseDir, trimmed);
+  return path15.normalize(absolutePath);
+}
 
-// src/config/rebase.ts
-import * as path13 from "path";
-function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path13.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath);
+// src/tools/utils.ts
+import { get_encoding } from "tiktoken";
+var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
+var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
+var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
+var CONTEXT_TOKENIZER = get_encoding("cl100k_base");
+function clampContextPackTokenBudget(tokenBudget) {
+  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
+    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  }
+  return Math.min(
+    MAX_CONTEXT_PACK_TOKEN_BUDGET,
+    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
+  );
 }
-function rebasePathEntries(values, fromDir, toDir) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed || path13.isAbsolute(trimmed)) {
-      return trimmed;
-    }
-    return normalizePathSeparators(path13.normalize(path13.relative(toDir, path13.resolve(fromDir, trimmed))));
-  }).filter(Boolean);
+function countContextTokens(text) {
+  return CONTEXT_TOKENIZER.encode(text).length;
 }
-function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
-  if (!Array.isArray(values)) {
-    return [];
+function fitTextToContextBudget(text, tokenBudget) {
+  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
+  const tokenEstimate = countContextTokens(text);
+  if (tokenEstimate <= normalizedBudget) {
+    return {
+      text,
+      tokenBudget: normalizedBudget,
+      tokenEstimate,
+      truncated: false
+    };
   }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return trimmed;
-    }
-    if (path13.isAbsolute(trimmed)) {
-      if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizePathSeparators(path13.normalize(path13.relative(sourceRoot, trimmed) || "."));
-      }
-      return path13.normalize(trimmed);
-    }
-    const resolvedFromSource = path13.resolve(sourceRoot, trimmed);
-    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizePathSeparators(path13.normalize(trimmed));
-    }
-    return normalizePathSeparators(path13.normalize(path13.relative(targetRoot, resolvedFromSource)));
-  }).filter(Boolean);
+  const suffix = "\n...[truncated to context token budget]";
+  const codePoints = Array.from(text);
+  let low = 0;
+  let high = codePoints.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = `${codePoints.slice(0, middle).join("").trimEnd()}${suffix}`;
+    if (countContextTokens(candidate) <= normalizedBudget) low = middle;
+    else high = middle - 1;
+  }
+  const fitted = `${codePoints.slice(0, low).join("").trimEnd()}${suffix}`;
+  return {
+    text: fitted,
+    tokenBudget: normalizedBudget,
+    tokenEstimate: countContextTokens(fitted),
+    truncated: true
+  };
 }
-
-// src/eval/runner-config.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizedLineRange(result) {
+  return result.startLine <= result.endLine ? { start: result.startLine, end: result.endLine } : { start: result.endLine, end: result.startLine };
 }
-function isStringArray2(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
+function rankContextCandidates(results) {
+  return results.map((result, originalIndex) => ({ result, originalIndex })).sort((left, right) => right.result.score - left.result.score || left.originalIndex - right.originalIndex);
 }
-function validateEvalConfigShape(rawConfig, filePath) {
-  if (!isRecord(rawConfig)) {
-    throw new Error(`Eval config at ${filePath} must contain a JSON object at the root.`);
-  }
-  const config = rawConfig;
-  if (config.knowledgeBases !== void 0 && !isStringArray2(config.knowledgeBases)) {
-    throw new Error(`Eval config at ${filePath} field 'knowledgeBases' must be an array of strings.`);
-  }
-  if (config.additionalInclude !== void 0 && !isStringArray2(config.additionalInclude)) {
-    throw new Error(`Eval config at ${filePath} field 'additionalInclude' must be an array of strings.`);
-  }
-  if (config.include !== void 0 && !isStringArray2(config.include)) {
-    throw new Error(`Eval config at ${filePath} field 'include' must be an array of strings.`);
-  }
-  if (config.exclude !== void 0 && !isStringArray2(config.exclude)) {
-    throw new Error(`Eval config at ${filePath} field 'exclude' must be an array of strings.`);
-  }
-  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
-    const value = config[section];
-    if (value !== void 0 && !isRecord(value)) {
-      throw new Error(`Eval config at ${filePath} field '${section}' must be an object.`);
+function deduplicateContextCandidates(candidates) {
+  const acceptedByFile = /* @__PURE__ */ new Map();
+  const deduplicated = [];
+  for (const { result } of candidates) {
+    const range = normalizedLineRange(result);
+    const accepted = acceptedByFile.get(result.filePath) ?? [];
+    if (accepted.some((item) => item.start <= range.end && range.start <= item.end)) {
+      continue;
     }
+    accepted.push(range);
+    acceptedByFile.set(result.filePath, accepted);
+    deduplicated.push(result);
   }
-  return config;
+  return deduplicated;
 }
-function parseJsonConfigFile(filePath) {
-  try {
-    return validateEvalConfigShape(JSON.parse(readFileSync8(filePath, "utf-8")), filePath);
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Eval config at ")) {
-      throw error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse eval config JSON at ${filePath}: ${message}`);
+function diversifyContextCandidates(results) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const bucket = byFile.get(result.filePath) ?? [];
+    bucket.push(result);
+    byFile.set(result.filePath, bucket);
+  }
+  const files = [...byFile.keys()];
+  const diversified = [];
+  for (let depth = 0; diversified.length < results.length; depth += 1) {
+    for (const file of files) {
+      const result = byFile.get(file)?.[depth];
+      if (result) diversified.push(result);
+    }
+  }
+  return diversified;
+}
+function compactEvidenceValue(value, maxChars) {
+  const characters = [...value];
+  if (characters.length <= maxChars) return value;
+  return `\u2026${characters.slice(-(maxChars - 1)).join("")}`;
+}
+function formatContextEvidence(result, index) {
+  const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
+  const path27 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path27}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+}
+function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount) {
+  const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
+  const notes = [];
+  if (duplicateCount > 0) notes.push(`${duplicateCount} overlapping duplicate${duplicateCount === 1 ? "" : "s"} removed`);
+  if (limitOmittedCount > 0) notes.push(`${limitOmittedCount} additional result${limitOmittedCount === 1 ? "" : "s"} excluded by result limit`);
+  if (budgetOmittedCount > 0) notes.push(`${budgetOmittedCount} additional result${budgetOmittedCount === 1 ? "" : "s"} omitted by token budget`);
+  const footer = notes.length > 0 ? `Selected ${selected.length} of ${candidateCount} candidates; ${notes.join("; ")}.` : `Selected ${selected.length} of ${candidateCount} candidates.`;
+  return `${heading}
+
+${lines.join("\n")}
+
+${footer}`;
+}
+function buildContextPack(results, options = {}) {
+  const requestedTokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  const tokenBudget = clampContextPackTokenBudget(options.tokenBudget);
+  const heading = compactEvidenceValue(options.heading?.trim() || "Codebase evidence", 160);
+  const maxResults = Math.max(0, Math.floor(options.maxResults ?? results.length));
+  const candidateCount = results.length;
+  const deduplicated = deduplicateContextCandidates(rankContextCandidates(results));
+  const diversified = diversifyContextCandidates(deduplicated);
+  const duplicateCount = candidateCount - deduplicated.length;
+  const selectable = diversified.slice(0, maxResults);
+  const limitOmittedCount = deduplicated.length - selectable.length;
+  let selected = [];
+  let text = formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, selectable.length);
+  for (let count = 1; count <= selectable.length; count += 1) {
+    const candidateSelection = selectable.slice(0, count);
+    const budgetOmittedCount2 = selectable.length - candidateSelection.length;
+    const candidateText = formatContextPack(
+      heading,
+      candidateSelection,
+      candidateCount,
+      duplicateCount,
+      limitOmittedCount,
+      budgetOmittedCount2
+    );
+    if (countContextTokens(candidateText) > tokenBudget) break;
+    selected = candidateSelection;
+    text = candidateText;
   }
+  const fitted = fitTextToContextBudget(text, tokenBudget);
+  const budgetOmittedCount = selectable.length - selected.length;
+  const omittedCount = candidateCount - selected.length;
+  return {
+    requestedTokenBudget,
+    tokenBudget,
+    text: fitted.text,
+    tokenEstimate: fitted.tokenEstimate,
+    results: selected,
+    candidateCount,
+    deduplicatedCount: deduplicated.length,
+    selectedCount: selected.length,
+    omittedCount,
+    duplicateCount,
+    limitOmittedCount,
+    budgetOmittedCount
+  };
 }
-function toAbsolute(projectRoot, maybeRelative) {
-  return path14.isAbsolute(maybeRelative) ? maybeRelative : path14.join(projectRoot, maybeRelative);
-}
-function isProjectScopedConfigPath(configPath) {
-  return path14.basename(configPath) === "codebase-index.json" && path14.basename(path14.dirname(configPath)) === ".opencode";
+var MAX_CONTENT_LINES = 30;
+function truncateContent(content) {
+  const lines = content.split("\n");
+  if (lines.length <= MAX_CONTENT_LINES) return content;
+  return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
+// ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
 }
-function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
-  const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
-  const rebaseEntries = (values) => isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
-    values,
-    path14.dirname(path14.dirname(resolvedConfigPath)),
-    projectRoot
-  ) : rebasePathEntries(
-    values,
-    path14.dirname(resolvedConfigPath),
-    projectRoot
-  );
-  if (Array.isArray(config.knowledgeBases)) {
-    config.knowledgeBases = rebaseEntries(config.knowledgeBases);
+function formatIndexStats(stats, verbose = false) {
+  if (stats.resetCorruptedIndex) {
+    return stats.warning ?? "Detected a corrupted local index and reset it during indexing. Run index_codebase again to rebuild search data.";
   }
-  if (Array.isArray(config.additionalInclude)) {
-    config.additionalInclude = rebaseEntries(config.additionalInclude);
+  const lines = [];
+  if (stats.failedChunks > 0) {
+    lines.push(`INDEXING WARNING: ${stats.failedChunks} chunks failed to embed.`);
+    if (stats.failedBatchesPath) {
+      lines.push(`Inspect failed batches at: ${stats.failedBatchesPath}`);
+    }
+    lines.push("");
   }
-  return config;
+  if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
+    lines.push(`${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
+  } else if (stats.indexedChunks === 0) {
+    lines.push(`${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
+  } else {
+    let main2 = `${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
+    if (stats.existingChunks > 0) {
+      main2 += ` ${stats.existingChunks} unchanged chunks skipped.`;
+    }
+    lines.push(main2);
+    if (stats.removedChunks > 0) {
+      lines.push(`Removed ${stats.removedChunks} stale chunks.`);
+    }
+    if (stats.failedChunks > 0) {
+      lines.push(`Failed: ${stats.failedChunks} chunks.`);
+    }
+    lines.push(`Tokens: ${stats.tokensUsed.toLocaleString()}, Duration: ${(stats.durationMs / 1e3).toFixed(1)}s`);
+  }
+  if (verbose) {
+    if (stats.skippedFiles.length > 0) {
+      const tooLarge = stats.skippedFiles.filter((f) => f.reason === "too_large");
+      const excluded = stats.skippedFiles.filter((f) => f.reason === "excluded");
+      const gitignored = stats.skippedFiles.filter((f) => f.reason === "gitignore");
+      lines.push("");
+      lines.push(`Skipped files: ${stats.skippedFiles.length}`);
+      if (tooLarge.length > 0) {
+        lines.push(`  Too large (${tooLarge.length}): ${tooLarge.slice(0, 5).map((f) => f.path).join(", ")}${tooLarge.length > 5 ? "..." : ""}`);
+      }
+      if (excluded.length > 0) {
+        lines.push(`  Excluded (${excluded.length}): ${excluded.slice(0, 5).map((f) => f.path).join(", ")}${excluded.length > 5 ? "..." : ""}`);
+      }
+      if (gitignored.length > 0) {
+        lines.push(`  Gitignored (${gitignored.length}): ${gitignored.slice(0, 5).map((f) => f.path).join(", ")}${gitignored.length > 5 ? "..." : ""}`);
+      }
+    }
+    if (stats.parseFailures.length > 0) {
+      lines.push("");
+      lines.push(`Files with no extractable chunks (${stats.parseFailures.length}): ${stats.parseFailures.slice(0, 10).join(", ")}${stats.parseFailures.length > 10 ? "..." : ""}`);
+    }
+  }
+  return lines.join("\n");
 }
-function loadRawConfig(projectRoot, configPath) {
-  const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
-  if (fromPath && existsSync8(fromPath)) {
-    return normalizeEvalConfigKnowledgeBases(
-      parseJsonConfigFile(fromPath),
-      projectRoot,
-      fromPath
-    );
+function formatStatus(status) {
+  if (!status.indexed) {
+    if (status.warning) {
+      return status.warning;
+    }
+    if (status.failedBatchesCount > 0) {
+      const lines2 = [
+        "Codebase is not indexed. The last indexing run left failed embedding batches.",
+        "Fix the provider/model configuration, then rerun index_codebase normally to retry the saved failed batches. Use force=true only for a full rebuild or compatibility reset."
+      ];
+      if (status.failedBatchesPath) {
+        lines2.push(`Failed batches: ${status.failedBatchesPath}`);
+      }
+      return lines2.join("\n");
+    }
+    return "Codebase is not indexed. Run index_codebase to create an index.";
   }
-  const projectConfig = resolveProjectConfigPath(projectRoot);
-  if (existsSync8(projectConfig)) {
-    return normalizeEvalConfigKnowledgeBases(
-      parseJsonConfigFile(projectConfig),
-      projectRoot,
-      projectConfig
-    );
+  const lines = [
+    `Indexed chunks: ${status.vectorCount.toLocaleString()}`,
+    `Provider: ${status.provider}`,
+    `Model: ${status.model}`,
+    `Location: ${status.indexPath}`
+  ];
+  if (status.currentBranch !== "default") {
+    lines.push(`Current branch: ${status.currentBranch}`);
+    lines.push(`Base branch: ${status.baseBranch}`);
   }
-  const globalConfig = path14.join(os5.homedir(), ".config", "opencode", "codebase-index.json");
-  if (existsSync8(globalConfig)) {
-    return parseJsonConfigFile(globalConfig);
+  if (status.failedBatchesCount > 0) {
+    lines.push("");
+    lines.push(`INDEXING WARNING: ${status.failedBatchesCount} failed embedding batch${status.failedBatchesCount === 1 ? " remains" : "es remain"}.`);
+    if (status.failedBatchesPath) {
+      lines.push(`Failed batches: ${status.failedBatchesPath}`);
+    }
   }
-  return {};
-}
-function getIndexRootPath(projectRoot, scope) {
-  return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
-}
-function getLocalProjectIndexRoot(projectRoot) {
-  return path14.join(projectRoot, ".opencode", "index");
-}
-function getLocalProjectConfigPath(projectRoot) {
-  return path14.join(projectRoot, ".opencode", "codebase-index.json");
+  if (status.warning) {
+    lines.push("");
+    lines.push(`INDEX WARNING: ${status.warning}`);
+  }
+  if (status.compatibility && !status.compatibility.compatible) {
+    lines.push("");
+    lines.push(`COMPATIBILITY WARNING: ${status.compatibility.reason}`);
+    if (status.compatibility.storedMetadata) {
+      const stored = status.compatibility.storedMetadata;
+      lines.push(`Index was built with: ${stored.embeddingProvider}/${stored.embeddingModel} (${stored.embeddingDimensions}D)`);
+      lines.push(`Current config:       ${status.provider}/${status.model}`);
+    }
+  } else if (!status.compatibility) {
+    lines.push(`Compatibility: No compatibility information found. Maybe the index is not initialized yet, try running index_codebase.`);
+  } else {
+    lines.push(`Compatibility: Index is compatible with the current provider and model.`);
+  }
+  return lines.join("\n");
 }
-function clearIndexRoot(projectRoot, scope) {
-  const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
-  if (existsSync8(indexRoot)) {
-    rmSync2(indexRoot, { recursive: true, force: true });
+function formatProgressTitle(progress) {
+  switch (progress.phase) {
+    case "scanning":
+      return "Scanning files...";
+    case "parsing":
+      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
+    case "embedding":
+      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
+    case "storing":
+      return "Storing index...";
+    case "complete":
+      return "Indexing complete";
+    default:
+      return "Indexing...";
   }
 }
-function ensureLocalEvalProjectConfig(projectRoot, configPath) {
-  const localConfigPath = getLocalProjectConfigPath(projectRoot);
-  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot);
-  if (!configPath && existsSync8(localConfigPath)) {
-    return localConfigPath;
+function calculatePercentage(progress) {
+  if (progress.phase === "scanning") return 0;
+  if (progress.phase === "complete") return 100;
+  if (progress.phase === "parsing") {
+    if (progress.totalFiles === 0) return 5;
+    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
   }
-  if (!existsSync8(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
-    return resolvedConfigPath;
+  if (progress.phase === "embedding") {
+    if (progress.totalChunks === 0) return 20;
+    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
   }
-  const sourceConfig = normalizeEvalConfigKnowledgeBases(
-    parseJsonConfigFile(resolvedConfigPath),
-    projectRoot,
-    resolvedConfigPath
-  );
-  mkdirSync4(path14.dirname(localConfigPath), { recursive: true });
-  writeFileSync4(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
-  return localConfigPath;
+  if (progress.phase === "storing") return 95;
+  return 0;
 }
-function loadParsedConfig(projectRoot, configPath) {
-  const raw = loadRawConfig(projectRoot, configPath);
-  return parseConfig(raw);
+function formatCodebasePeek(results) {
+  if (results.length === 0) {
+    return "No matching code found. Try a different query or run index_codebase first.";
+  }
+  const formatted = results.map((r, idx) => {
+    const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
+    const name = r.name ? `"${r.name}"` : "(anonymous)";
+    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})${formatBlame(r)}`;
+  });
+  return formatted.join("\n");
 }
-function resolveSearchConfig(parsedConfig, overrides) {
-  const nextSearch = {
-    ...parsedConfig.search
-  };
-  if (overrides?.fusionStrategy !== void 0) {
-    nextSearch.fusionStrategy = overrides.fusionStrategy;
+function formatHealthCheck(result) {
+  if (result.resetCorruptedIndex) {
+    return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
   }
-  if (overrides?.hybridWeight !== void 0) {
-    nextSearch.hybridWeight = overrides.hybridWeight;
+  if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0 && result.gcOrphanSymbols === 0 && result.gcOrphanCallEdges === 0) {
+    return "Index is healthy. No stale entries found.";
   }
-  if (overrides?.rrfK !== void 0) {
-    nextSearch.rrfK = overrides.rrfK;
+  const lines = [];
+  if (result.removed > 0) {
+    lines.push(`Removed stale entries: ${result.removed}`);
   }
-  if (overrides?.rerankTopN !== void 0) {
-    nextSearch.rerankTopN = overrides.rerankTopN;
+  if (result.gcOrphanEmbeddings > 0) {
+    lines.push(`Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
   }
-  return {
-    ...parsedConfig,
-    search: nextSearch
-  };
-}
-function getEmbeddingCostPer1MTokens(embeddingProvider) {
-  return embeddingProvider === "custom" || embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(embeddingProvider).costPer1MTokens;
-}
-
-// src/eval/schema.ts
-import { readFileSync as readFileSync9 } from "fs";
-function parseJsonFile(filePath) {
-  const content = readFileSync9(filePath, "utf-8");
-  try {
-    return JSON.parse(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse JSON from ${filePath}: ${message}`);
+  if (result.gcOrphanChunks > 0) {
+    lines.push(`Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
   }
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
-function isStringArray3(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function asPositiveNumber(value, path27) {
-  if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path27} must be a non-negative number`);
-  }
-  return value;
-}
-function parseQueryType(value, path27) {
-  if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
-    return value;
-  }
-  throw new Error(
-    `${path27} must be one of: definition, implementation-intent, similarity, keyword-heavy`
-  );
-}
-function parseExpected(input, path27) {
-  if (!isRecord2(input)) {
-    throw new Error(`${path27} must be an object`);
+  if (result.gcOrphanSymbols > 0) {
+    lines.push(`Garbage collected orphan symbols: ${result.gcOrphanSymbols}`);
   }
-  const filePathRaw = input.filePath;
-  const acceptableFilesRaw = input.acceptableFiles;
-  const symbolRaw = input.symbol;
-  const branchRaw = input.branch;
-  const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
-  const acceptableFiles = isStringArray3(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
-  if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path27} must include either expected.filePath or expected.acceptableFiles`);
+  if (result.gcOrphanCallEdges > 0) {
+    lines.push(`Garbage collected orphan call edges: ${result.gcOrphanCallEdges}`);
   }
-  if (acceptableFilesRaw !== void 0 && !isStringArray3(acceptableFilesRaw)) {
-    throw new Error(`${path27}.acceptableFiles must be an array of strings`);
+  if (result.filePaths.length > 0) {
+    lines.push(`Cleaned paths: ${result.filePaths.join(", ")}`);
   }
-  if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path27}.symbol must be a string when provided`);
+  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.`;
   }
-  if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path27}.branch must be a string when provided`);
+  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 {
-    filePath,
-    acceptableFiles,
-    symbol: typeof symbolRaw === "string" ? symbolRaw : void 0,
-    branch: typeof branchRaw === "string" ? branchRaw : void 0
-  };
+  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 parseQuery(input, index) {
-  const path27 = `queries[${index}]`;
-  if (!isRecord2(input)) {
-    throw new Error(`${path27} must be an object`);
+function formatCallGraphPath(from, to, path27) {
+  if (path27.length === 0) {
+    return `No path found between "${from}" and "${to}". They may be in disconnected components, or the call graph index needs updating.`;
   }
-  const id = input.id;
-  const query = input.query;
-  const queryType = input.queryType;
-  const expected = input.expected;
-  if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error(`${path27}.id must be a non-empty string`);
+  const formatted = path27.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 (${path27.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 "";
   }
-  if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path27}.query must be a non-empty string`);
+  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.`;
   }
-  return {
-    id,
-    query,
-    queryType: parseQueryType(queryType, `${path27}.queryType`),
-    expected: parseExpected(expected, `${path27}.expected`)
-  };
+  const formatted = results.map((r, idx) => {
+    const header = formatResultHeader(r, idx);
+    return `${header} (score: ${r.score.toFixed(2)})${formatBlame(r)}
+\`\`\`
+${truncateContent(r.content)}
+\`\`\``;
+  });
+  return formatted.join("\n\n");
 }
-function parseGoldenDataset(raw, sourceLabel) {
-  if (!isRecord2(raw)) {
-    throw new Error(`${sourceLabel} must be a JSON object`);
+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}${formatBlame(r)}
+\`\`\`
+${truncateContent(r.content)}
+\`\`\``;
+  });
+  return formatted.join("\n\n");
+}
+
+// src/tools/config-state.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import * as path16 from "path";
+function normalizeKnowledgeBasePaths(config, projectRoot) {
+  const normalized = { ...config };
+  if (Array.isArray(normalized.knowledgeBases)) {
+    normalized.knowledgeBases = normalized.knowledgeBases.map(
+      (kb) => resolveConfigPathValue(kb, projectRoot)
+    );
   }
-  const version = raw.version;
-  const name = raw.name;
-  const description = raw.description;
-  const queriesRaw = raw.queries;
-  if (typeof version !== "string" || version.trim().length === 0) {
-    throw new Error(`${sourceLabel}.version must be a non-empty string`);
+  return normalized;
+}
+function toConfigRecord(rawConfig) {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
   }
-  if (typeof name !== "string" || name.trim().length === 0) {
-    throw new Error(`${sourceLabel}.name must be a non-empty string`);
+  return { ...rawConfig };
+}
+function loadRuntimeConfig(projectRoot, host = "opencode") {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot, host)), projectRoot);
+}
+
+// src/tools/operations.ts
+var indexerCache = /* @__PURE__ */ new Map();
+var configCache = /* @__PURE__ */ new Map();
+var defaultProjectRoots = /* @__PURE__ */ new Map();
+function getIndexBusyResult(error) {
+  if (!isIndexLockContentionError(error)) return null;
+  const owner = error.owner;
+  const ownerText = owner ? `PID ${owner.pid}, operation ${owner.operation}, since ${owner.startedAt}` : "unreadable owner";
+  if (error.reason === "legacy-lock") {
+    return {
+      kind: "busy",
+      text: `INDEX_BUSY: legacy lock format detected (${ownerText}). Verify the PID and remove this lock manually only if it is stale.`
+    };
   }
-  if (description !== void 0 && typeof description !== "string") {
-    throw new Error(`${sourceLabel}.description must be a string when provided`);
+  if (error.reason === "unknown-owner") {
+    return {
+      kind: "busy",
+      text: `INDEX_BUSY: unreadable or remote lock owner (${ownerText}). Automatic recovery was refused; manual verification is required.`
+    };
   }
-  if (!Array.isArray(queriesRaw)) {
-    throw new Error(`${sourceLabel}.queries must be an array`);
+  return { kind: "busy", text: `INDEX_BUSY: another index operation is already in progress (${ownerText}).` };
+}
+function getProjectRoot(projectRoot, host) {
+  if (projectRoot) {
+    return projectRoot;
   }
-  if (queriesRaw.length === 0) {
-    throw new Error(`${sourceLabel}.queries must contain at least one query`);
+  const root = defaultProjectRoots.get(host);
+  if (!root) {
+    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
   }
-  const queries = queriesRaw.map((query, idx) => parseQuery(query, idx));
-  const idSet = /* @__PURE__ */ new Set();
-  for (const query of queries) {
-    if (idSet.has(query.id)) {
-      throw new Error(`${sourceLabel}.queries has duplicate id: ${query.id}`);
-    }
-    idSet.add(query.id);
+  return root;
+}
+function getIndexerCacheKey(projectRoot, host) {
+  return `${host}::${projectRoot}`;
+}
+function getOrCreateIndexer(projectRoot, host) {
+  const key = getIndexerCacheKey(projectRoot, host);
+  const cached = indexerCache.get(key);
+  if (cached) {
+    return cached;
   }
-  return {
-    version,
-    name,
-    description: typeof description === "string" ? description : void 0,
-    queries
-  };
+  const config = parseConfig(loadRuntimeConfig(projectRoot, host));
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
+  return indexer;
 }
-function loadGoldenDataset(datasetPath) {
-  const parsed = parseJsonFile(datasetPath);
-  return parseGoldenDataset(parsed, datasetPath);
+function initializeTools(projectRoot, config, host = "opencode") {
+  defaultProjectRoots.set(host, projectRoot);
+  const key = getIndexerCacheKey(projectRoot, host);
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
 }
-function parseThresholdValue(value, fieldName, sourceLabel) {
-  return value === void 0 ? void 0 : asPositiveNumber(value, `${sourceLabel}.thresholds.${fieldName}`);
+function getIndexerForProject(projectRoot, host = "opencode") {
+  const root = getProjectRoot(projectRoot, host);
+  return getOrCreateIndexer(root, host);
 }
-function parseBudget(raw, sourceLabel) {
-  if (!isRecord2(raw)) {
-    throw new Error(`${sourceLabel} must be a JSON object`);
-  }
-  const name = raw.name;
-  const baselinePath = raw.baselinePath;
-  const failOnMissingBaseline = raw.failOnMissingBaseline;
-  const thresholds = raw.thresholds;
-  if (typeof name !== "string" || name.trim().length === 0) {
-    throw new Error(`${sourceLabel}.name must be a non-empty string`);
-  }
-  if (baselinePath !== void 0 && typeof baselinePath !== "string") {
-    throw new Error(`${sourceLabel}.baselinePath must be a string when provided`);
-  }
-  if (!isRecord2(thresholds)) {
-    throw new Error(`${sourceLabel}.thresholds must be an object`);
+function refreshIndexerForDirectory(projectRoot, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot, host))) {
+  const key = getIndexerCacheKey(projectRoot, host);
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
+}
+function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
+  const root = getProjectRoot(projectRoot, host);
+  const localIndexPath = path17.join(root, getHostProjectIndexRelativePath(host));
+  if (existsSync10(localIndexPath)) {
+    return false;
   }
-  return {
-    name,
-    baselinePath: typeof baselinePath === "string" ? baselinePath : void 0,
-    failOnMissingBaseline: typeof failOnMissingBaseline === "boolean" ? failOnMissingBaseline : true,
-    thresholds: {
-      hitAt5MaxDrop: parseThresholdValue(
-        thresholds.hitAt5MaxDrop,
-        "hitAt5MaxDrop",
-        sourceLabel
-      ),
-      mrrAt10MaxDrop: parseThresholdValue(
-        thresholds.mrrAt10MaxDrop,
-        "mrrAt10MaxDrop",
-        sourceLabel
-      ),
-      rawDistinctTop3RatioMaxDrop: parseThresholdValue(
-        thresholds.rawDistinctTop3RatioMaxDrop,
-        "rawDistinctTop3RatioMaxDrop",
-        sourceLabel
-      ),
-      p95LatencyMaxMultiplier: parseThresholdValue(
-        thresholds.p95LatencyMaxMultiplier,
-        "p95LatencyMaxMultiplier",
-        sourceLabel
-      ),
-      p95LatencyMaxAbsoluteMs: parseThresholdValue(
-        thresholds.p95LatencyMaxAbsoluteMs,
-        "p95LatencyMaxAbsoluteMs",
-        sourceLabel
-      ),
-      minHitAt5: parseThresholdValue(
-        thresholds.minHitAt5,
-        "minHitAt5",
-        sourceLabel
-      ),
-      minMrrAt10: parseThresholdValue(
-        thresholds.minMrrAt10,
-        "minMrrAt10",
-        sourceLabel
-      ),
-      minRawDistinctTop3Ratio: parseThresholdValue(
-        thresholds.minRawDistinctTop3Ratio,
-        "minRawDistinctTop3Ratio",
-        sourceLabel
-      )
-    }
-  };
+  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
+  return inheritedIndexPath !== null;
 }
-function loadBudget(budgetPath) {
-  const parsed = parseJsonFile(budgetPath);
-  return parseBudget(parsed, budgetPath);
+async function searchCodebase(projectRoot, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, 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,
+    blameAuthor: options.blameAuthor,
+    blameSha: options.blameSha,
+    blameSince: options.blameSince
+  });
 }
-
-// src/eval/runner.ts
-async function runEvaluation(options) {
-  const datasetPath = toAbsolute(options.projectRoot, options.datasetPath);
-  const againstPath = options.againstPath ? toAbsolute(options.projectRoot, options.againstPath) : void 0;
-  const budgetPath = options.budgetPath ? toAbsolute(options.projectRoot, options.budgetPath) : void 0;
-  const dataset = loadGoldenDataset(datasetPath);
-  const resolvedEvalConfigPath = options.reindex ? ensureLocalEvalProjectConfig(options.projectRoot, options.configPath) : options.configPath;
-  const parsedConfig = loadParsedConfig(options.projectRoot, resolvedEvalConfigPath);
-  const effectiveConfig = resolveSearchConfig(parsedConfig, options.searchOverrides);
-  if (options.reindex) {
-    clearIndexRoot(options.projectRoot, effectiveConfig.scope);
-  }
-  const indexer = new Indexer(options.projectRoot, effectiveConfig);
-  try {
-    await indexer.index();
-    const perQuery = [];
-    for (const query of dataset.queries) {
-      if (query.expected.branch && query.expected.branch !== indexer.getCurrentBranch()) {
-        throw new Error(
-          `Query '${query.id}' expects branch '${query.expected.branch}', but current branch is '${indexer.getCurrentBranch()}'. Switch branch before running this dataset.`
-        );
-      }
-      const start = performance3.now();
-      const result = await indexer.search(query.query, 10, {
-        metadataOnly: true,
-        filterByBranch: !!query.expected.branch
-      });
-      const elapsed = performance3.now() - start;
-      const materialized = result.map((item) => ({
-        filePath: item.filePath,
-        startLine: item.startLine,
-        endLine: item.endLine,
-        score: item.score,
-        chunkType: item.chunkType,
-        name: item.name
-      }));
-      perQuery.push(buildPerQueryResult(query, materialized, elapsed, 10));
-    }
-    const logger = indexer.getLogger();
-    const metricSnapshot = logger.getMetrics();
-    const costPer1MTokensUsd = getEmbeddingCostPer1MTokens(effectiveConfig.embeddingProvider);
-    const summary = {
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectRoot: options.projectRoot,
-      datasetPath,
-      datasetName: dataset.name,
-      datasetVersion: dataset.version,
-      queryCount: dataset.queries.length,
-      topK: 10,
-      searchConfig: {
-        fusionStrategy: effectiveConfig.search.fusionStrategy,
-        hybridWeight: effectiveConfig.search.hybridWeight,
-        rrfK: effectiveConfig.search.rrfK,
-        rerankTopN: effectiveConfig.search.rerankTopN
-      },
-      metrics: computeEvalMetrics(
-        dataset.queries,
-        perQuery,
-        metricSnapshot.embeddingApiCalls,
-        metricSnapshot.embeddingTokensUsed,
-        costPer1MTokensUsd
-      )
-    };
-    const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
-    const perQueryArtifact = buildPerQueryArtifact(perQuery);
-    writeJson(path15.join(outputDir, "summary.json"), summary);
-    writeJson(path15.join(outputDir, "per-query.json"), perQueryArtifact);
-    let comparison;
-    if (againstPath) {
-      const baseline = loadSummary(againstPath);
-      comparison = compareSummaries(summary, baseline, againstPath);
-      writeJson(path15.join(outputDir, "compare.json"), comparison);
-    }
-    let gate;
-    if (options.ciMode) {
-      if (!budgetPath) {
-        throw new Error("CI mode requires --budget path");
-      }
-      const budget = loadBudget(budgetPath);
-      if (!comparison && budget.baselinePath) {
-        const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
-        if (existsSync9(resolvedBaseline)) {
-          const baselineSummary = loadSummary(resolvedBaseline);
-          comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
-          writeJson(path15.join(outputDir, "compare.json"), comparison);
-        } else if (budget.failOnMissingBaseline) {
-          throw new Error(
-            `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
-          );
-        }
-      }
-      gate = evaluateBudgetGate(budget, summary, comparison);
+async function findSimilarCode(projectRoot, host, code, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.findSimilar(code, options.limit, {
+    fileType: options.fileType,
+    directory: options.directory,
+    chunkType: options.chunkType,
+    excludeFile: options.excludeFile
+  });
+}
+async function implementationLookup(projectRoot, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.search(query, options.limit, {
+    fileType: options.fileType,
+    directory: options.directory,
+    definitionIntent: true
+  });
+}
+async function getCallGraphData(projectRoot, host, params) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  if (params.direction === "callees") {
+    if (!params.symbolId) {
+      return { direction: "callees", callees: [], callers: [] };
     }
-    const markdown = createSummaryMarkdown(summary, comparison, gate);
-    writeText(path15.join(outputDir, "summary.md"), markdown);
-    return { outputDir, summary, perQuery, comparison, gate };
-  } finally {
-    await indexer.close();
+    const callees = await indexer.getCallees(params.symbolId, params.relationshipType);
+    return { direction: "callees", callees, callers: [] };
   }
+  const callers = await indexer.getCallers(params.name, params.relationshipType);
+  return { direction: "callers", callers, callees: [] };
 }
-async function runSweep(options, sweep) {
-  const fusionValues = sweep.fusionStrategy && sweep.fusionStrategy.length > 0 ? [...sweep.fusionStrategy] : [void 0];
-  const weightValues = sweep.hybridWeight && sweep.hybridWeight.length > 0 ? [...sweep.hybridWeight] : [void 0];
-  const rrfValues = sweep.rrfK && sweep.rrfK.length > 0 ? [...sweep.rrfK] : [void 0];
-  const rerankValues = sweep.rerankTopN && sweep.rerankTopN.length > 0 ? [...sweep.rerankTopN] : [void 0];
-  const runs = [];
-  for (const fusion of fusionValues) {
-    for (const hybridWeight of weightValues) {
-      for (const rrfK of rrfValues) {
-        for (const rerankTopN of rerankValues) {
-          const run = await runEvaluation({
-            ...options,
-            searchOverrides: {
-              ...fusion !== void 0 ? { fusionStrategy: fusion } : {},
-              ...hybridWeight !== void 0 ? { hybridWeight } : {},
-              ...rrfK !== void 0 ? { rrfK } : {},
-              ...rerankTopN !== void 0 ? { rerankTopN } : {}
-            }
-          });
-          runs.push({
-            searchConfig: run.summary.searchConfig,
-            summary: run.summary,
-            comparison: run.comparison,
-            gate: run.gate
+async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.findCallPath(from, to, maxDepth);
+}
+async function runIndexCodebase(projectRoot, host, args, onProgress) {
+  const root = getProjectRoot(projectRoot, host);
+  const key = getIndexerCacheKey(root, host);
+  let indexer = getIndexerForProject(root, host);
+  const runtimeConfig = configCache.get(key);
+  try {
+    if (args.estimateOnly) {
+      return { kind: "estimate", estimate: await indexer.estimateCost() };
+    }
+    const runIndex = async (target) => {
+      const operation = args.force ? target.forceIndex.bind(target) : target.index.bind(target);
+      return operation((progress) => {
+        if (onProgress) {
+          return onProgress(formatProgressTitle(progress), {
+            phase: progress.phase,
+            filesProcessed: progress.filesProcessed,
+            totalFiles: progress.totalFiles,
+            chunksProcessed: progress.chunksProcessed,
+            totalChunks: progress.totalChunks,
+            percentage: calculatePercentage(progress)
           });
         }
-      }
+        return Promise.resolve();
+      });
+    };
+    let stats;
+    if (args.force && shouldForceLocalizeProjectIndex(root, host)) {
+      const inheritedIndexPath = resolveProjectIndexPath(root, runtimeConfig.scope, host);
+      stats = await withIndexLock(inheritedIndexPath, "force-index", async () => {
+        materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
+        refreshIndexerForDirectory(root, host, runtimeConfig);
+        indexer = getIndexerForProject(root, host);
+        return runIndex(indexer);
+      }, { completeRecoveries: false });
+    } else {
+      stats = await runIndex(indexer);
     }
+    return { kind: "stats", stats };
+  } catch (error) {
+    const busyResult = getIndexBusyResult(error);
+    if (!busyResult) throw error;
+    return busyResult;
   }
-  const bestByHitAt5 = [...runs].sort(
-    (a, b) => b.summary.metrics.hitAt5 - a.summary.metrics.hitAt5
-  )[0];
-  const bestByMrrAt10 = [...runs].sort(
-    (a, b) => b.summary.metrics.mrrAt10 - a.summary.metrics.mrrAt10
-  )[0];
-  const bestByP95Latency = [...runs].sort(
-    (a, b) => a.summary.metrics.latencyMs.p95 - b.summary.metrics.latencyMs.p95
-  )[0];
-  const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
-  const failedGateRuns = runs.filter((run) => run.gate && !run.gate.passed).length;
-  const gatePassed = failedGateRuns === 0;
-  const aggregate = {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    againstPath: options.againstPath,
-    runCount: runs.length,
-    runs,
-    gatePassed,
-    failedGateRuns,
-    bestByHitAt5,
-    bestByMrrAt10,
-    bestByP95Latency
-  };
-  writeJson(path15.join(outputDir, "compare.json"), aggregate);
-  const md = createSummaryMarkdown(
-    bestByHitAt5?.summary ?? runs[0].summary,
-    bestByHitAt5?.comparison,
-    void 0,
-    aggregate
-  );
-  writeText(path15.join(outputDir, "summary.md"), md);
-  writeJson(path15.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
-  return { outputDir, aggregate };
 }
-
-// src/eval/cli.ts
-import * as path17 from "path";
-
-// src/eval/cli-parser.ts
-import * as path16 from "path";
-function printUsage() {
-  console.log(`
-Usage:
-  opencode-codebase-index-mcp eval run [options]
-  opencode-codebase-index-mcp eval compare --against <summary.json> [options]
-  opencode-codebase-index-mcp eval diff --current <summary.json> --against <summary.json> [options]
-
-Options:
-  --project <path>                 Project root (default: cwd)
-  --config <path>                  Config JSON path
-  --dataset <path>                 Golden dataset path (default: benchmarks/golden/small.json)
-  --current <path>                 Current summary.json path (required for eval diff)
-  --output <path>                  Output root dir (default: benchmarks/results)
-  --against <path>                 Baseline summary.json to compare against
-  --budget <path>                  Budget file for CI mode (default: benchmarks/budgets/default.json)
-  --ci                             Enable CI gate mode
-  --reindex                        Force reindex before eval
-
-Search overrides:
-  --fusionStrategy <rrf|weighted>
-  --hybridWeight <0-1>
-  --rrfK <number>
-  --rerankTopN <number>
-
-Sweep options (comma-separated values):
-  --sweepFusionStrategy <rrf,weighted>
-  --sweepHybridWeight <0.3,0.5,0.7>
-  --sweepRrfK <30,60,90>
-  --sweepRerankTopN <10,20,40>
-`);
-}
-function parseNumber(value, flag) {
-  const parsed = Number(value);
-  if (Number.isNaN(parsed)) {
-    throw new Error(`${flag} must be a number`);
-  }
-  return parsed;
+async function getIndexStatus(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.getStatus();
 }
-function parseCsvNumbers(value, flag) {
-  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0).map((item) => parseNumber(item, flag));
+async function getIndexHealthCheck(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.healthCheck();
 }
-function parseCsvFusion(value) {
-  const values = value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
-  const parsed = [];
-  for (const candidate of values) {
-    if (candidate !== "rrf" && candidate !== "weighted") {
-      throw new Error("--sweepFusionStrategy accepts only rrf,weighted");
-    }
-    parsed.push(candidate);
+async function runIndexHealthCheck(projectRoot, host) {
+  try {
+    return { kind: "health", health: await getIndexHealthCheck(projectRoot, host) };
+  } catch (error) {
+    const busyResult = getIndexBusyResult(error);
+    if (!busyResult) throw error;
+    return busyResult;
   }
-  return parsed;
 }
-function hasSweepOptions(sweep) {
-  return Boolean(
-    sweep.fusionStrategy && sweep.fusionStrategy.length > 0 || sweep.hybridWeight && sweep.hybridWeight.length > 0 || sweep.rrfK && sweep.rrfK.length > 0 || sweep.rerankTopN && sweep.rerankTopN.length > 0
-  );
-}
-function parseEvalArgs(argv, cwd) {
-  const parsed = {
-    projectRoot: cwd,
-    datasetPath: "benchmarks/golden/small.json",
-    outputRoot: "benchmarks/results",
-    budgetPath: "benchmarks/budgets/default.json",
-    ciMode: false,
-    reindex: false,
-    sweep: {}
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    const next = argv[i + 1];
-    if (arg === "--project" && next) {
-      parsed.projectRoot = path16.resolve(cwd, next);
-      i += 1;
-      continue;
-    }
-    if (arg === "--config" && next) {
-      parsed.configPath = path16.resolve(cwd, next);
-      i += 1;
-      continue;
-    }
-    if (arg === "--dataset" && next) {
-      parsed.datasetPath = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--current" && next) {
-      parsed.currentPath = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--output" && next) {
-      parsed.outputRoot = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--against" && next) {
-      parsed.againstPath = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--budget" && next) {
-      parsed.budgetPath = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--ci") {
-      parsed.ciMode = true;
-      continue;
-    }
-    if (arg === "--reindex") {
-      parsed.reindex = true;
-      continue;
-    }
-    if (arg === "--fusionStrategy" && next) {
-      if (next !== "rrf" && next !== "weighted") {
-        throw new Error("--fusionStrategy must be rrf or weighted");
-      }
-      parsed.fusionStrategy = next;
-      i += 1;
-      continue;
-    }
-    if (arg === "--hybridWeight" && next) {
-      parsed.hybridWeight = parseNumber(next, "--hybridWeight");
-      i += 1;
-      continue;
-    }
-    if (arg === "--rrfK" && next) {
-      parsed.rrfK = parseNumber(next, "--rrfK");
-      i += 1;
-      continue;
-    }
-    if (arg === "--rerankTopN" && next) {
-      parsed.rerankTopN = parseNumber(next, "--rerankTopN");
-      i += 1;
-      continue;
-    }
-    if (arg === "--sweepFusionStrategy" && next) {
-      parsed.sweep.fusionStrategy = parseCsvFusion(next);
-      i += 1;
-      continue;
-    }
-    if (arg === "--sweepHybridWeight" && next) {
-      parsed.sweep.hybridWeight = parseCsvNumbers(next, "--sweepHybridWeight");
-      i += 1;
-      continue;
-    }
-    if (arg === "--sweepRrfK" && next) {
-      parsed.sweep.rrfK = parseCsvNumbers(next, "--sweepRrfK");
-      i += 1;
-      continue;
-    }
-    if (arg === "--sweepRerankTopN" && next) {
-      parsed.sweep.rerankTopN = parseCsvNumbers(next, "--sweepRerankTopN");
-      i += 1;
-      continue;
-    }
-  }
-  return parsed;
+async function getPrImpact(projectRoot, host, params) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.getPrImpact({
+    pr: params.pr,
+    branch: params.branch,
+    maxDepth: params.maxDepth,
+    hubThreshold: params.hubThreshold,
+    checkConflicts: params.checkConflicts,
+    direction: params.direction
+  });
 }
-function parseEvalSubcommandOptions(argv, cwd) {
-  let explicitAgainst;
-  const filtered = [];
-  for (let i = 0; i < argv.length; i += 1) {
-    const current = argv[i];
-    const next = argv[i + 1];
-    if (current === "--against" && next) {
-      explicitAgainst = next;
-      i += 1;
-      continue;
-    }
-    filtered.push(current);
+async function getIndexMetrics(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  const logger = indexer.getLogger();
+  if (!logger.isEnabled()) {
+    return {
+      enabled: false,
+      metricsEnabled: false,
+      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
+    };
+  }
+  if (!logger.isMetricsEnabled()) {
+    return {
+      enabled: true,
+      metricsEnabled: false,
+      text: 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
+    };
   }
   return {
-    parsed: parseEvalArgs(filtered, cwd),
-    explicitAgainst
+    enabled: true,
+    metricsEnabled: true,
+    text: logger.formatMetrics()
   };
 }
-function toRunOptions(parsed) {
-  return {
-    projectRoot: parsed.projectRoot,
-    configPath: parsed.configPath,
-    datasetPath: parsed.datasetPath,
-    outputRoot: parsed.outputRoot,
-    againstPath: parsed.againstPath,
-    budgetPath: parsed.budgetPath,
-    ciMode: parsed.ciMode,
-    reindex: parsed.reindex,
-    searchOverrides: {
-      ...parsed.fusionStrategy !== void 0 ? { fusionStrategy: parsed.fusionStrategy } : {},
-      ...parsed.hybridWeight !== void 0 ? { hybridWeight: parsed.hybridWeight } : {},
-      ...parsed.rrfK !== void 0 ? { rrfK: parsed.rrfK } : {},
-      ...parsed.rerankTopN !== void 0 ? { rerankTopN: parsed.rerankTopN } : {}
-    }
-  };
+async function getIndexLogs(projectRoot, host, args) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  const logger = indexer.getLogger();
+  if (!logger.isEnabled()) {
+    return {
+      kind: "disabled",
+      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```'
+    };
+  }
+  let logs;
+  if (args.category) {
+    logs = logger.getLogsByCategory(args.category, args.limit);
+  } else if (args.level) {
+    logs = logger.getLogsByLevel(args.level, args.limit);
+  } else {
+    logs = logger.getLogs(args.limit);
+  }
+  if (logs.length === 0) {
+    return {
+      kind: "entries",
+      text: "No logs recorded yet. Logs are captured during indexing and search operations."
+    };
+  }
+  const text = 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 };
 }
 
-// src/eval/cli.ts
-async function handleEvalCommand(args, cwd) {
-  const subcommand = args[0];
-  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
-    printUsage();
-    return 0;
+// src/tools/symbol-inference.ts
+var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
+var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
+var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
+var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
+var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
+var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "for",
+  "find",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "that",
+  "the",
+  "definition",
+  "show",
+  "to",
+  "where",
+  "which",
+  "what",
+  "you",
+  "your",
+  "with"
+]);
+function stripCallSuffix(token) {
+  return token.replace(/\(\s*\)$/, "");
+}
+function isLikelySymbolName(token) {
+  if (!SYMBOL_LIKE_RE.test(token)) {
+    return false;
   }
-  if (subcommand === "run") {
-    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
-    if (explicitAgainst) {
-      parsed.againstPath = explicitAgainst;
-    }
-    const runOptions = toRunOptions(parsed);
-    if (hasSweepOptions(parsed.sweep)) {
-      const sweep = await runSweep(runOptions, parsed.sweep);
-      console.log(`Eval sweep complete. Artifacts: ${sweep.outputDir}`);
-      console.log(`Sweep runs: ${sweep.aggregate.runCount}`);
-      if (parsed.ciMode && sweep.aggregate.gatePassed === false) {
-        console.error(
-          `[CI-GATE] Sweep failed: ${sweep.aggregate.failedGateRuns ?? 0} run(s) violated budget/baseline gates`
-        );
-        return 1;
-      }
-      return 0;
-    }
-    const result = await runEvaluation(runOptions);
-    console.log(`Eval run complete. Artifacts: ${result.outputDir}`);
-    console.log(
-      `Hit@5=${(result.summary.metrics.hitAt5 * 100).toFixed(2)}% MRR@10=${result.summary.metrics.mrrAt10.toFixed(4)} p95=${result.summary.metrics.latencyMs.p95.toFixed(3)}ms`
-    );
-    if (result.gate && !result.gate.passed) {
-      for (const violation of result.gate.violations) {
-        console.error(`[CI-GATE] ${violation.metric}: ${violation.message}`);
-      }
-      return 1;
-    }
-    return 0;
+  if (STOP_WORDS.has(token.toLowerCase())) {
+    return false;
   }
-  if (subcommand === "compare") {
-    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
-    if (!explicitAgainst) {
-      throw new Error("eval compare requires --against <baseline summary.json>");
-    }
-    parsed.againstPath = explicitAgainst;
-    const runOptions = toRunOptions(parsed);
-    if (hasSweepOptions(parsed.sweep)) {
-      const sweep = await runSweep(runOptions, parsed.sweep);
-      console.log(`Eval compare sweep complete. Artifacts: ${sweep.outputDir}`);
-      if (parsed.ciMode && sweep.aggregate.gatePassed === false) {
-        console.error(
-          `[CI-GATE] Sweep failed: ${sweep.aggregate.failedGateRuns ?? 0} run(s) violated budget/baseline gates`
-        );
-        return 1;
-      }
-      return 0;
+  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
+}
+function extractQuotedIdentifiers(query) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
     }
-    const result = await runEvaluation(runOptions);
-    console.log(`Eval compare complete. Artifacts: ${result.outputDir}`);
-    return 0;
   }
-  if (subcommand === "diff") {
-    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
-    if (!explicitAgainst) {
-      throw new Error("eval diff requires --against <baseline summary.json>");
-    }
-    if (!parsed.currentPath) {
-      throw new Error("eval diff requires --current <current summary.json>");
+  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
     }
-    parsed.againstPath = explicitAgainst;
-    const currentPath = parsed.currentPath;
-    if (!currentPath.endsWith(".json")) {
-      throw new Error("eval diff --current must point to a summary JSON file");
+  }
+  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
     }
-    if (!parsed.againstPath.endsWith(".json")) {
-      throw new Error("eval diff --against must point to a summary JSON file");
+  }
+  return [...identifiers];
+}
+function extractBareIdentifiers(query) {
+  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
+    const candidate = stripCallSuffix(match[0]);
+    if (isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
     }
-    const currentSummary = loadSummary(path17.resolve(parsed.projectRoot, currentPath), {
-      allowLegacyDiversityMetrics: true
-    });
-    const baselineSummary = loadSummary(path17.resolve(parsed.projectRoot, parsed.againstPath), {
-      allowLegacyDiversityMetrics: true
-    });
-    const comparison = compareSummaries(
-      currentSummary,
-      baselineSummary,
-      path17.resolve(parsed.projectRoot, parsed.againstPath)
-    );
-    const outputDir = createRunDirectory(path17.resolve(parsed.projectRoot, parsed.outputRoot));
-    const summaryMd = createSummaryMarkdown(currentSummary, comparison);
-    writeJson(path17.join(outputDir, "compare.json"), comparison);
-    writeText(path17.join(outputDir, "summary.md"), summaryMd);
-    writeJson(path17.join(outputDir, "summary.json"), currentSummary);
-    console.log(`Eval diff complete. Artifacts: ${outputDir}`);
-    return 0;
   }
-  throw new Error(`Unknown eval subcommand: ${subcommand}`);
+  return [...identifiers];
+}
+function isSingleMeaningfulToken(query, symbol) {
+  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
+  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
+}
+function inferExactSymbolFromQuery(query) {
+  const quoted = extractQuotedIdentifiers(query);
+  if (quoted.length === 1) {
+    return quoted[0];
+  }
+  if (quoted.length > 1) {
+    return void 0;
+  }
+  const candidates = extractBareIdentifiers(query);
+  if (candidates.length !== 1) {
+    return void 0;
+  }
+  const candidate = candidates[0];
+  if (DEFINITION_INTENT_RE.test(query)) {
+    return candidate;
+  }
+  if (isSingleMeaningfulToken(query, candidate)) {
+    return candidate;
+  }
+  return void 0;
 }
 
-// src/mcp-server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { readFileSync as readFileSync11 } from "fs";
-
-// src/mcp-server/register-prompts.ts
-import { z } from "zod";
-function registerMcpPrompts(server) {
-  server.prompt(
-    "search",
-    "Search codebase by meaning using semantic search",
-    { query: z.string().describe("What to search for in the codebase") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Search the codebase for: "${args.query}"
-
-Use the codebase_search tool with this query. If you need just locations first, use codebase_peek instead to save tokens.`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "find",
-    "Find code using hybrid approach (semantic + grep)",
-    { query: z.string().describe("What to find in the codebase") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Find code related to: "${args.query}"
-
-Use a hybrid approach:
-1. First use codebase_peek to find semantic matches by meaning
-2. Then use grep for exact identifier matches
-3. Combine results for comprehensive coverage`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "index",
-    "Index the codebase for semantic search",
-    { options: z.string().optional().describe("Options: 'force' to rebuild, 'estimate' to check costs") },
-    (args) => {
-      const opts = args.options?.toLowerCase() ?? "";
-      let instruction = "Use the index_codebase tool to index the codebase for semantic search.";
-      if (opts.includes("force")) {
-        instruction = "Use the index_codebase tool with force=true to rebuild the entire index from scratch.";
-      } else if (opts.includes("estimate")) {
-        instruction = "Use the index_codebase tool with estimateOnly=true to check the cost estimate before indexing.";
-      }
+// src/tools/context.ts
+var MIN_CONTEXT_RESULT_LIMIT = 1;
+var MAX_CONTEXT_RESULT_LIMIT = 100;
+var MIN_CONTEXT_PATH_DEPTH = 1;
+var MAX_CONTEXT_PATH_DEPTH = 100;
+function locations(results) {
+  return results.map((result) => ({
+    filePath: result.filePath,
+    startLine: result.startLine,
+    endLine: result.endLine,
+    score: result.score,
+    chunkType: result.chunkType,
+    name: result.name
+  }));
+}
+function packedResult(route, routedQuery, pack) {
+  return {
+    text: pack.text,
+    details: {
+      route,
+      routedQuery,
+      tokenBudget: pack.tokenBudget,
+      tokenEstimate: pack.tokenEstimate,
+      candidateCount: pack.candidateCount,
+      deduplicatedCount: pack.deduplicatedCount,
+      selectedCount: pack.selectedCount,
+      omittedCount: pack.omittedCount,
+      duplicateCount: pack.duplicateCount,
+      limitOmittedCount: pack.limitOmittedCount,
+      budgetOmittedCount: pack.budgetOmittedCount,
+      results: locations(pack.results)
+    }
+  };
+}
+async function resolveSearchContext(input, operations) {
+  const explicitSymbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  const lookupSymbol = explicitSymbol ?? inferExactSymbolFromQuery(input.query);
+  if (lookupSymbol) {
+    const definitions = await operations.lookup(lookupSymbol, MAX_CONTEXT_RESULT_LIMIT);
+    if (definitions.length > 0) {
+      return packedResult("definition", lookupSymbol, buildContextPack(definitions, {
+        tokenBudget,
+        maxResults: limit,
+        heading: `Definition evidence for ${JSON.stringify(lookupSymbol)}`
+      }));
+    }
+    if (explicitSymbol) {
+      const fitted = fitTextToContextBudget(
+        formatDefinitionLookup(definitions, lookupSymbol),
+        tokenBudget
+      );
+      return { text: fitted.text };
+    }
+  }
+  const results = await operations.search(input.query, MAX_CONTEXT_RESULT_LIMIT);
+  if (results.length === 0) {
+    const fitted = fitTextToContextBudget(
+      "No matching code found. Try a different query or run index_codebase first.",
+      tokenBudget
+    );
+    return { text: fitted.text };
+  }
+  return packedResult("conceptual", input.query, buildContextPack(results, {
+    tokenBudget,
+    maxResults: limit,
+    heading: `Codebase evidence for ${JSON.stringify(input.query)}`
+  }));
+}
+function fittedDetails(route, fitted) {
+  return {
+    route,
+    tokenBudget: fitted.tokenBudget,
+    tokenEstimate: fitted.tokenEstimate,
+    truncated: fitted.truncated
+  };
+}
+async function resolveCodebaseContext(projectRoot, host, input) {
+  const from = input.from ?? void 0;
+  const to = input.to ?? void 0;
+  const symbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const maxDepth = input.maxDepth ?? 10;
+  const fileType = input.fileType ?? void 0;
+  const directory = input.directory ?? void 0;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  if (from && to) {
+    const path27 = await getCallGraphPath(projectRoot, host, from, to, maxDepth);
+    if (path27.length > 0) {
+      const fitted2 = fitTextToContextBudget(
+        formatCallGraphPath(from, to, path27),
+        tokenBudget
+      );
       return {
-        messages: [{
-          role: "user",
-          content: { type: "text", text: instruction }
-        }]
+        text: fitted2.text,
+        details: fittedDetails("path", fitted2)
       };
     }
-  );
-  server.prompt(
-    "status",
-    "Check if the codebase is indexed and ready",
-    {},
-    () => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: "Use the index_status tool to check if the codebase index is ready and show its current state."
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "definition",
-    "Find where a symbol is defined in the codebase",
-    { query: z.string().describe("Symbol name or description to find the definition of") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Find the definition of: "${args.query}"
-
-Use the implementation_lookup tool to find where this symbol is defined. This prioritizes real implementation files over tests, docs, and examples. If no definition is found, fall back to codebase_search for broader discovery.`
-        }
-      }]
+    const { callers } = await getCallGraphData(projectRoot, host, {
+      name: to,
+      direction: "callers"
+    });
+    const directEdge = callers.find((edge) => edge.fromSymbolName === from);
+    if (directEdge) {
+      const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
+      const fitted2 = fitTextToContextBudget(
+        `Direct path: ${from} --${directEdge.callType}--> ${to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("direct-edge", fitted2)
+      };
+    }
+    const fitted = fitTextToContextBudget(
+      formatCallGraphPath(from, to, path27),
+      tokenBudget
+    );
+    return {
+      text: fitted.text,
+      details: fittedDetails("path", fitted)
+    };
+  }
+  return resolveSearchContext({ query: input.query, symbol, limit, tokenBudget }, {
+    lookup: (lookupSymbol, retrievalLimit) => implementationLookup(projectRoot, host, lookupSymbol, {
+      limit: retrievalLimit,
+      fileType,
+      directory
+    }),
+    search: (query, retrievalLimit) => searchCodebase(projectRoot, host, query, {
+      limit: retrievalLimit,
+      fileType,
+      directory,
+      metadataOnly: true
     })
-  );
+  });
 }
 
-// src/mcp-server/register-tools.ts
-import { z as z2 } from "zod";
-
-// src/tools/utils.ts
-var MAX_CONTENT_LINES = 30;
-function truncateContent(content) {
-  const lines = content.split("\n");
-  if (lines.length <= MAX_CONTENT_LINES) return content;
-  return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
-// ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
-}
-function formatIndexStats(stats, verbose = false) {
-  if (stats.resetCorruptedIndex) {
-    return stats.warning ?? "Detected a corrupted local index and reset it during indexing. Run index_codebase again to rebuild search data.";
+// src/eval/budget.ts
+function evaluateBudgetGate(budget, summary, comparison) {
+  const BASELINE_P95_EPSILON_MS = 1e-3;
+  const violations = [];
+  const { thresholds } = budget;
+  if (thresholds.minHitAt5 !== void 0 && summary.metrics.hitAt5 < thresholds.minHitAt5) {
+    violations.push({
+      metric: "minHitAt5",
+      message: `Hit@5 ${summary.metrics.hitAt5.toFixed(4)} is below minimum ${thresholds.minHitAt5.toFixed(4)}`
+    });
   }
-  const lines = [];
-  if (stats.failedChunks > 0) {
-    lines.push(`INDEXING WARNING: ${stats.failedChunks} chunks failed to embed.`);
-    if (stats.failedBatchesPath) {
-      lines.push(`Inspect failed batches at: ${stats.failedBatchesPath}`);
-    }
-    lines.push("");
+  if (thresholds.minMrrAt10 !== void 0 && summary.metrics.mrrAt10 < thresholds.minMrrAt10) {
+    violations.push({
+      metric: "minMrrAt10",
+      message: `MRR@10 ${summary.metrics.mrrAt10.toFixed(4)} is below minimum ${thresholds.minMrrAt10.toFixed(4)}`
+    });
   }
-  if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
-    lines.push(`${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
-  } else if (stats.indexedChunks === 0) {
-    lines.push(`${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
-  } else {
-    let main2 = `${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
-    if (stats.existingChunks > 0) {
-      main2 += ` ${stats.existingChunks} unchanged chunks skipped.`;
+  if (thresholds.minRawDistinctTop3Ratio !== void 0 && summary.metrics.rawDistinctTop3Ratio < thresholds.minRawDistinctTop3Ratio) {
+    violations.push({
+      metric: "minRawDistinctTop3Ratio",
+      message: `Raw Distinct Top@3 ${summary.metrics.rawDistinctTop3Ratio.toFixed(4)} is below minimum ${thresholds.minRawDistinctTop3Ratio.toFixed(4)}`
+    });
+  }
+  if (comparison) {
+    if (thresholds.hitAt5MaxDrop !== void 0 && comparison.deltas.hitAt5.absolute < -thresholds.hitAt5MaxDrop) {
+      violations.push({
+        metric: "hitAt5MaxDrop",
+        message: `Hit@5 drop ${comparison.deltas.hitAt5.absolute.toFixed(4)} exceeds allowed -${thresholds.hitAt5MaxDrop.toFixed(4)}`
+      });
     }
-    lines.push(main2);
-    if (stats.removedChunks > 0) {
-      lines.push(`Removed ${stats.removedChunks} stale chunks.`);
+    if (thresholds.mrrAt10MaxDrop !== void 0 && comparison.deltas.mrrAt10.absolute < -thresholds.mrrAt10MaxDrop) {
+      violations.push({
+        metric: "mrrAt10MaxDrop",
+        message: `MRR@10 drop ${comparison.deltas.mrrAt10.absolute.toFixed(4)} exceeds allowed -${thresholds.mrrAt10MaxDrop.toFixed(4)}`
+      });
     }
-    if (stats.failedChunks > 0) {
-      lines.push(`Failed: ${stats.failedChunks} chunks.`);
+    if (thresholds.rawDistinctTop3RatioMaxDrop !== void 0 && comparison.deltas.rawDistinctTop3Ratio.absolute < -thresholds.rawDistinctTop3RatioMaxDrop) {
+      violations.push({
+        metric: "rawDistinctTop3RatioMaxDrop",
+        message: `Raw Distinct Top@3 drop ${comparison.deltas.rawDistinctTop3Ratio.absolute.toFixed(4)} exceeds allowed -${thresholds.rawDistinctTop3RatioMaxDrop.toFixed(4)}`
+      });
     }
-    lines.push(`Tokens: ${stats.tokensUsed.toLocaleString()}, Duration: ${(stats.durationMs / 1e3).toFixed(1)}s`);
-  }
-  if (verbose) {
-    if (stats.skippedFiles.length > 0) {
-      const tooLarge = stats.skippedFiles.filter((f) => f.reason === "too_large");
-      const excluded = stats.skippedFiles.filter((f) => f.reason === "excluded");
-      const gitignored = stats.skippedFiles.filter((f) => f.reason === "gitignore");
-      lines.push("");
-      lines.push(`Skipped files: ${stats.skippedFiles.length}`);
-      if (tooLarge.length > 0) {
-        lines.push(`  Too large (${tooLarge.length}): ${tooLarge.slice(0, 5).map((f) => f.path).join(", ")}${tooLarge.length > 5 ? "..." : ""}`);
-      }
-      if (excluded.length > 0) {
-        lines.push(`  Excluded (${excluded.length}): ${excluded.slice(0, 5).map((f) => f.path).join(", ")}${excluded.length > 5 ? "..." : ""}`);
-      }
-      if (gitignored.length > 0) {
-        lines.push(`  Gitignored (${gitignored.length}): ${gitignored.slice(0, 5).map((f) => f.path).join(", ")}${gitignored.length > 5 ? "..." : ""}`);
+    if (thresholds.p95LatencyMaxMultiplier !== void 0) {
+      const baselineP95 = comparison.deltas.latencyP95Ms.baseline;
+      if (baselineP95 > BASELINE_P95_EPSILON_MS) {
+        const allowed = baselineP95 * thresholds.p95LatencyMaxMultiplier;
+        if (summary.metrics.latencyMs.p95 > allowed) {
+          violations.push({
+            metric: "p95LatencyMaxMultiplier",
+            message: `p95 latency ${summary.metrics.latencyMs.p95.toFixed(3)}ms exceeds allowed ${allowed.toFixed(3)}ms (${thresholds.p95LatencyMaxMultiplier.toFixed(2)}x baseline)`
+          });
+        }
       }
     }
-    if (stats.parseFailures.length > 0) {
-      lines.push("");
-      lines.push(`Files with no extractable chunks (${stats.parseFailures.length}): ${stats.parseFailures.slice(0, 10).join(", ")}${stats.parseFailures.length > 10 ? "..." : ""}`);
+  }
+  if (thresholds.p95LatencyMaxAbsoluteMs !== void 0 && summary.metrics.latencyMs.p95 > thresholds.p95LatencyMaxAbsoluteMs) {
+    violations.push({
+      metric: "p95LatencyMaxAbsoluteMs",
+      message: `p95 latency ${summary.metrics.latencyMs.p95.toFixed(3)}ms exceeds absolute maximum ${thresholds.p95LatencyMaxAbsoluteMs.toFixed(3)}ms`
+    });
+  }
+  const context = summary.metrics.contextEfficiency;
+  if (context.queryCount > 0) {
+    if (thresholds.maxContextResponseTokensAverage !== void 0 && context.responseTokens.average > thresholds.maxContextResponseTokensAverage) {
+      violations.push({
+        metric: "maxContextResponseTokensAverage",
+        message: `Context response average ${context.responseTokens.average.toFixed(1)} tokens exceeds maximum ${thresholds.maxContextResponseTokensAverage.toFixed(1)}`
+      });
+    }
+    if (thresholds.maxContextResponseTokensP95 !== void 0 && context.responseTokens.p95 > thresholds.maxContextResponseTokensP95) {
+      violations.push({
+        metric: "maxContextResponseTokensP95",
+        message: `Context response p95 ${context.responseTokens.p95.toFixed(1)} tokens exceeds maximum ${thresholds.maxContextResponseTokensP95.toFixed(1)}`
+      });
+    }
+    if (thresholds.maxContextResponseTokensMax !== void 0 && context.responseTokens.max > thresholds.maxContextResponseTokensMax) {
+      violations.push({
+        metric: "maxContextResponseTokensMax",
+        message: `Context response maximum ${context.responseTokens.max.toFixed(1)} tokens exceeds maximum ${thresholds.maxContextResponseTokensMax.toFixed(1)}`
+      });
+    }
+    if (thresholds.maxContextDuplicateCandidateRatio !== void 0 && context.duplicateCandidateRatio > thresholds.maxContextDuplicateCandidateRatio) {
+      violations.push({
+        metric: "maxContextDuplicateCandidateRatio",
+        message: `Context duplicate candidate ratio ${context.duplicateCandidateRatio.toFixed(4)} exceeds maximum ${thresholds.maxContextDuplicateCandidateRatio.toFixed(4)}`
+      });
+    }
+    if (thresholds.minContextSelectedFileRatio !== void 0 && context.selectedFileRatio < thresholds.minContextSelectedFileRatio) {
+      violations.push({
+        metric: "minContextSelectedFileRatio",
+        message: `Context selected-file ratio ${context.selectedFileRatio.toFixed(4)} is below minimum ${thresholds.minContextSelectedFileRatio.toFixed(4)}`
+      });
+    }
+    if (thresholds.minContextHitAt5Per1kResponseTokens !== void 0 && context.hitAt5Per1kResponseTokens < thresholds.minContextHitAt5Per1kResponseTokens) {
+      violations.push({
+        metric: "minContextHitAt5Per1kResponseTokens",
+        message: `Context Hit@5 per 1k response tokens ${context.hitAt5Per1kResponseTokens.toFixed(4)} is below minimum ${thresholds.minContextHitAt5Per1kResponseTokens.toFixed(4)}`
+      });
+    }
+    if (thresholds.minContextMrrAt10Per1kResponseTokens !== void 0 && context.mrrAt10Per1kResponseTokens < thresholds.minContextMrrAt10Per1kResponseTokens) {
+      violations.push({
+        metric: "minContextMrrAt10Per1kResponseTokens",
+        message: `Context MRR@10 per 1k response tokens ${context.mrrAt10Per1kResponseTokens.toFixed(4)} is below minimum ${thresholds.minContextMrrAt10Per1kResponseTokens.toFixed(4)}`
+      });
     }
   }
-  return lines.join("\n");
+  return {
+    passed: violations.length === 0,
+    budgetName: budget.name,
+    violations
+  };
 }
-function formatStatus(status) {
-  if (!status.indexed) {
-    if (status.warning) {
-      return status.warning;
-    }
-    if (status.failedBatchesCount > 0) {
-      const lines2 = [
-        "Codebase is not indexed. The last indexing run left failed embedding batches.",
-        "Fix the provider/model configuration, then rerun index_codebase normally to retry the saved failed batches. Use force=true only for a full rebuild or compatibility reset."
-      ];
-      if (status.failedBatchesPath) {
-        lines2.push(`Failed batches: ${status.failedBatchesPath}`);
-      }
-      return lines2.join("\n");
+
+// src/eval/metrics.ts
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  if (values.length === 1) return values[0];
+  const sorted = [...values].sort((a, b) => a - b);
+  const x = p * (sorted.length - 1);
+  const lowerIndex = Math.floor(x);
+  const upperIndex = Math.ceil(x);
+  if (lowerIndex === upperIndex) {
+    return sorted[lowerIndex];
+  }
+  const fraction = x - lowerIndex;
+  return sorted[lowerIndex] + fraction * (sorted[upperIndex] - sorted[lowerIndex]);
+}
+function normalizePath(input) {
+  return normalizePathSeparators(input);
+}
+function uniqueResultsByPath(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const result of results) {
+    const normalized = normalizePath(result.filePath);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    unique.push(result);
+  }
+  return unique;
+}
+function distinctTopKRatio(results, k) {
+  const top = results.slice(0, k);
+  if (top.length === 0) return 0;
+  const distinct = new Set(top.map((result) => normalizePath(result.filePath))).size;
+  return distinct / top.length;
+}
+function pathMatchesExpected(actualPath, expectedPath) {
+  const actual = normalizePath(actualPath);
+  const expected = normalizePath(expectedPath);
+  if (actual === expected) return true;
+  return actual.endsWith(`/${expected}`) || expected.endsWith(`/${actual}`);
+}
+function getRelevantPaths(query) {
+  const fromExact = query.expected.filePath ? [query.expected.filePath] : [];
+  const fromAcceptable = query.expected.acceptableFiles ?? [];
+  return Array.from(/* @__PURE__ */ new Set([...fromExact, ...fromAcceptable]));
+}
+function isRelevantResult(filePath, relevantPaths) {
+  return relevantPaths.some((expected) => pathMatchesExpected(filePath, expected));
+}
+function reciprocalRankAtK(results, relevantPaths, k) {
+  const top = uniqueResultsByPath(results).slice(0, k);
+  for (let i = 0; i < top.length; i += 1) {
+    if (isRelevantResult(top[i].filePath, relevantPaths)) {
+      return 1 / (i + 1);
     }
-    return "Codebase is not indexed. Run index_codebase to create an index.";
   }
-  const lines = [
-    `Indexed chunks: ${status.vectorCount.toLocaleString()}`,
-    `Provider: ${status.provider}`,
-    `Model: ${status.model}`,
-    `Location: ${status.indexPath}`
-  ];
-  if (status.currentBranch !== "default") {
-    lines.push(`Current branch: ${status.currentBranch}`);
-    lines.push(`Base branch: ${status.baseBranch}`);
+  return 0;
+}
+function ndcgAtK(results, relevantPaths, k) {
+  const top = uniqueResultsByPath(results).slice(0, k);
+  const dcg = top.reduce((sum, result, i) => {
+    const rel = isRelevantResult(result.filePath, relevantPaths) ? 1 : 0;
+    return sum + rel / Math.log2(i + 2);
+  }, 0);
+  const idealLen = Math.min(k, relevantPaths.length);
+  const idcg = Array.from({ length: idealLen }, (_, i) => 1 / Math.log2(i + 2)).reduce(
+    (sum, value) => sum + value,
+    0
+  );
+  return idcg === 0 ? 0 : dcg / idcg;
+}
+function isDocsOrTestsPath(filePath) {
+  const lowered = normalizePath(filePath).toLowerCase();
+  return lowered.includes("/docs/") || lowered.includes("/test/") || lowered.includes("/tests/") || lowered.includes("readme") || lowered.includes("/benchmarks/");
+}
+function classifyFailureBucket(query, results, k) {
+  const relevantPaths = getRelevantPaths(query);
+  const top = uniqueResultsByPath(results).slice(0, k);
+  const hasRelevantTopK = top.some((result) => isRelevantResult(result.filePath, relevantPaths));
+  if (!hasRelevantTopK) {
+    return "no-relevant-hit-top-k";
   }
-  if (status.failedBatchesCount > 0) {
-    lines.push("");
-    lines.push(`INDEXING WARNING: ${status.failedBatchesCount} failed embedding batch${status.failedBatchesCount === 1 ? " remains" : "es remain"}.`);
-    if (status.failedBatchesPath) {
-      lines.push(`Failed batches: ${status.failedBatchesPath}`);
-    }
+  if (query.expected.symbol) {
+    const hasSymbol = top.some(
+      (result) => isRelevantResult(result.filePath, relevantPaths) && result.name === query.expected.symbol
+    );
+    if (!hasSymbol) return "wrong-symbol";
   }
-  if (status.warning) {
-    lines.push("");
-    lines.push(`INDEX WARNING: ${status.warning}`);
+  const top1 = top[0];
+  if (top1 && !isRelevantResult(top1.filePath, relevantPaths) && isDocsOrTestsPath(top1.filePath)) {
+    return "docs-tests-outranking-source";
   }
-  if (status.compatibility && !status.compatibility.compatible) {
-    lines.push("");
-    lines.push(`COMPATIBILITY WARNING: ${status.compatibility.reason}`);
-    if (status.compatibility.storedMetadata) {
-      const stored = status.compatibility.storedMetadata;
-      lines.push(`Index was built with: ${stored.embeddingProvider}/${stored.embeddingModel} (${stored.embeddingDimensions}D)`);
-      lines.push(`Current config:       ${status.provider}/${status.model}`);
-    }
-  } else if (!status.compatibility) {
-    lines.push(`Compatibility: No compatibility information found. Maybe the index is not initialized yet, try running index_codebase.`);
-  } else {
-    lines.push(`Compatibility: Index is compatible with the current provider and model.`);
+  if (top1 && !isRelevantResult(top1.filePath, relevantPaths)) {
+    return "wrong-file";
   }
-  return lines.join("\n");
+  return void 0;
 }
-function formatProgressTitle(progress) {
-  switch (progress.phase) {
-    case "scanning":
-      return "Scanning files...";
-    case "parsing":
-      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
-    case "embedding":
-      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
-    case "storing":
-      return "Storing index...";
-    case "complete":
-      return "Indexing complete";
-    default:
-      return "Indexing...";
-  }
+function buildPerQueryResult(query, results, latencyMs, k, route = {
+  resolvedRoute: "search",
+  routedQuery: query.query
+}, context) {
+  const relevantPaths = getRelevantPaths(query);
+  const deduped = uniqueResultsByPath(results);
+  const hitAt = (cutoff) => deduped.slice(0, cutoff).some((result) => isRelevantResult(result.filePath, relevantPaths));
+  const perQuery = {
+    id: query.id,
+    query: query.query,
+    queryType: query.queryType,
+    retrievalMode: query.retrievalMode ?? "search",
+    resolvedRoute: route.resolvedRoute,
+    routedQuery: route.routedQuery,
+    latencyMs,
+    hitAt1: hitAt(1),
+    hitAt3: hitAt(3),
+    hitAt5: hitAt(5),
+    hitAt10: hitAt(10),
+    reciprocalRankAt10: reciprocalRankAtK(deduped, relevantPaths, 10),
+    ndcgAt10: ndcgAtK(deduped, relevantPaths, 10),
+    failureBucket: classifyFailureBucket(query, results, k),
+    rawTop3DistinctRatio: distinctTopKRatio(results, 3),
+    tokenBudget: context?.tokenBudget,
+    responseTokens: context?.responseTokens ?? 0,
+    candidateCount: context?.candidateCount ?? results.length,
+    deduplicatedCount: context?.deduplicatedCount ?? results.length,
+    selectedCount: results.length,
+    omittedCount: context?.omittedCount ?? 0,
+    duplicateCandidateRatio: context && context.candidateCount > 0 ? (context.candidateCount - context.deduplicatedCount) / context.candidateCount : 0,
+    selectedFileRatio: results.length === 0 ? 0 : new Set(results.map((result) => normalizePath(result.filePath))).size / results.length,
+    results: deduped
+  };
+  return perQuery;
 }
-function calculatePercentage(progress) {
-  if (progress.phase === "scanning") return 0;
-  if (progress.phase === "complete") return 100;
-  if (progress.phase === "parsing") {
-    if (progress.totalFiles === 0) return 5;
-    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
-  }
-  if (progress.phase === "embedding") {
-    if (progress.totalChunks === 0) return 20;
-    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
+function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingTokensUsed, costPer1MTokensUsd) {
+  const count = perQuery.length;
+  const safeDiv = (value) => count === 0 ? 0 : value / count;
+  const sum = {
+    hitAt1: 0,
+    hitAt3: 0,
+    hitAt5: 0,
+    hitAt10: 0,
+    mrrAt10: 0,
+    ndcgAt10: 0,
+    distinctTop3Ratio: 0,
+    rawDistinctTop3Ratio: 0
+  };
+  const failureBuckets = {
+    "wrong-file": 0,
+    "wrong-symbol": 0,
+    "docs-tests-outranking-source": 0,
+    "no-relevant-hit-top-k": 0
+  };
+  const latencies = perQuery.map((item) => item.latencyMs);
+  const contextQueries = perQuery.filter((item) => item.retrievalMode === "context");
+  const contextResponseTokens = contextQueries.map((item) => item.responseTokens);
+  const totalContextResponseTokens = contextResponseTokens.reduce((sum2, value) => sum2 + value, 0);
+  const contextTokenUnits = totalContextResponseTokens / 1e3;
+  for (const query of perQuery) {
+    if (query.hitAt1) sum.hitAt1 += 1;
+    if (query.hitAt3) sum.hitAt3 += 1;
+    if (query.hitAt5) sum.hitAt5 += 1;
+    if (query.hitAt10) sum.hitAt10 += 1;
+    sum.mrrAt10 += query.reciprocalRankAt10;
+    sum.ndcgAt10 += query.ndcgAt10;
+    sum.distinctTop3Ratio += distinctTopKRatio(query.results, 3);
+    sum.rawDistinctTop3Ratio += query.rawTop3DistinctRatio;
+    if (query.failureBucket) {
+      failureBuckets[query.failureBucket] += 1;
+    }
   }
-  if (progress.phase === "storing") return 95;
-  return 0;
+  const queryTokens = queries.reduce((acc, q) => acc + estimateTokens(q.query), 0);
+  return {
+    hitAt1: safeDiv(sum.hitAt1),
+    hitAt3: safeDiv(sum.hitAt3),
+    hitAt5: safeDiv(sum.hitAt5),
+    hitAt10: safeDiv(sum.hitAt10),
+    mrrAt10: safeDiv(sum.mrrAt10),
+    ndcgAt10: safeDiv(sum.ndcgAt10),
+    distinctTop3Ratio: safeDiv(sum.distinctTop3Ratio),
+    rawDistinctTop3Ratio: safeDiv(sum.rawDistinctTop3Ratio),
+    latencyMs: {
+      p50: percentile(latencies, 0.5),
+      p95: percentile(latencies, 0.95),
+      p99: percentile(latencies, 0.99)
+    },
+    tokenEstimate: {
+      queryTokens,
+      embeddingTokensUsed
+    },
+    embedding: {
+      callCount: embeddingCallCount,
+      estimatedCostUsd: embeddingTokensUsed / 1e6 * costPer1MTokensUsd,
+      costPer1MTokensUsd
+    },
+    contextEfficiency: {
+      queryCount: contextQueries.length,
+      responseTokens: {
+        total: totalContextResponseTokens,
+        average: contextQueries.length === 0 ? 0 : totalContextResponseTokens / contextQueries.length,
+        p95: percentile(contextResponseTokens, 0.95),
+        max: contextResponseTokens.length === 0 ? 0 : Math.max(...contextResponseTokens)
+      },
+      duplicateCandidateRatio: contextQueries.length === 0 ? 0 : contextQueries.reduce((sum2, item) => sum2 + item.duplicateCandidateRatio, 0) / contextQueries.length,
+      selectedFileRatio: contextQueries.length === 0 ? 0 : contextQueries.reduce((sum2, item) => sum2 + item.selectedFileRatio, 0) / contextQueries.length,
+      hitAt5Per1kResponseTokens: contextTokenUnits === 0 ? 0 : contextQueries.filter((item) => item.hitAt5).length / contextTokenUnits,
+      mrrAt10Per1kResponseTokens: contextTokenUnits === 0 ? 0 : contextQueries.reduce((sum2, item) => sum2 + item.reciprocalRankAt10, 0) / contextTokenUnits
+    },
+    failureBuckets
+  };
 }
-function formatCodebasePeek(results) {
-  if (results.length === 0) {
-    return "No matching code found. Try a different query or run index_codebase first.";
-  }
-  const formatted = results.map((r, idx) => {
-    const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
-    const name = r.name ? `"${r.name}"` : "(anonymous)";
-    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})${formatBlame(r)}`;
-  });
-  return formatted.join("\n");
+
+// src/eval/runner-config.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import * as os5 from "os";
+import * as path18 from "path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function formatHealthCheck(result) {
-  if (result.resetCorruptedIndex) {
-    return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
+function isStringArray3(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function validateEvalConfigShape(rawConfig, filePath) {
+  if (!isRecord2(rawConfig)) {
+    throw new Error(`Eval config at ${filePath} must contain a JSON object at the root.`);
   }
-  if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0 && result.gcOrphanSymbols === 0 && result.gcOrphanCallEdges === 0) {
-    return "Index is healthy. No stale entries found.";
+  const config = rawConfig;
+  if (config.knowledgeBases !== void 0 && !isStringArray3(config.knowledgeBases)) {
+    throw new Error(`Eval config at ${filePath} field 'knowledgeBases' must be an array of strings.`);
   }
-  const lines = [];
-  if (result.removed > 0) {
-    lines.push(`Removed stale entries: ${result.removed}`);
+  if (config.additionalInclude !== void 0 && !isStringArray3(config.additionalInclude)) {
+    throw new Error(`Eval config at ${filePath} field 'additionalInclude' must be an array of strings.`);
   }
-  if (result.gcOrphanEmbeddings > 0) {
-    lines.push(`Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
+  if (config.include !== void 0 && !isStringArray3(config.include)) {
+    throw new Error(`Eval config at ${filePath} field 'include' must be an array of strings.`);
   }
-  if (result.gcOrphanChunks > 0) {
-    lines.push(`Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
+  if (config.exclude !== void 0 && !isStringArray3(config.exclude)) {
+    throw new Error(`Eval config at ${filePath} field 'exclude' must be an array of strings.`);
   }
-  if (result.gcOrphanSymbols > 0) {
-    lines.push(`Garbage collected orphan symbols: ${result.gcOrphanSymbols}`);
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = config[section];
+    if (value !== void 0 && !isRecord2(value)) {
+      throw new Error(`Eval config at ${filePath} field '${section}' must be an object.`);
+    }
   }
-  if (result.gcOrphanCallEdges > 0) {
-    lines.push(`Garbage collected orphan call edges: ${result.gcOrphanCallEdges}`);
+  return config;
+}
+function parseJsonConfigFile(filePath) {
+  try {
+    return validateEvalConfigShape(JSON.parse(readFileSync9(filePath, "utf-8")), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Eval config at ")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse eval config JSON at ${filePath}: ${message}`);
   }
-  if (result.filePaths.length > 0) {
-    lines.push(`Cleaned paths: ${result.filePaths.join(", ")}`);
+}
+function toAbsolute(projectRoot, maybeRelative) {
+  return path18.isAbsolute(maybeRelative) ? maybeRelative : path18.join(projectRoot, maybeRelative);
+}
+function isProjectScopedConfigPath(configPath) {
+  return path18.basename(configPath) === "codebase-index.json" && path18.basename(path18.dirname(configPath)) === ".opencode";
+}
+function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
+  const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
+  const rebaseEntries = (values) => isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
+    values,
+    path18.dirname(path18.dirname(resolvedConfigPath)),
+    projectRoot
+  ) : rebasePathEntries(
+    values,
+    path18.dirname(resolvedConfigPath),
+    projectRoot
+  );
+  if (Array.isArray(config.knowledgeBases)) {
+    config.knowledgeBases = rebaseEntries(config.knowledgeBases);
+  }
+  if (Array.isArray(config.additionalInclude)) {
+    config.additionalInclude = rebaseEntries(config.additionalInclude);
   }
-  return lines.join("\n");
+  return config;
 }
-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.`;
+function loadRawConfig(projectRoot, configPath) {
+  const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
+  if (fromPath && existsSync11(fromPath)) {
+    return normalizeEvalConfigKnowledgeBases(
+      parseJsonConfigFile(fromPath),
+      projectRoot,
+      fromPath
+    );
   }
-  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.`;
+  const projectConfig = resolveProjectConfigPath(projectRoot);
+  if (existsSync11(projectConfig)) {
+    return normalizeEvalConfigKnowledgeBases(
+      parseJsonConfigFile(projectConfig),
+      projectRoot,
+      projectConfig
+    );
   }
-  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, path27) {
-  if (path27.length === 0) {
-    return `No path found between "${from}" and "${to}". They may be in disconnected components, or the call graph index needs updating.`;
+  const globalConfig = path18.join(os5.homedir(), ".config", "opencode", "codebase-index.json");
+  if (existsSync11(globalConfig)) {
+    return parseJsonConfigFile(globalConfig);
   }
-  const formatted = path27.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 (${path27.length} hops):
-${formatted.join("\n")}`;
+  return {};
 }
-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 getIndexRootPath(projectRoot, scope) {
+  return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
 }
-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 getLocalProjectIndexRoot(projectRoot) {
+  return path18.join(projectRoot, ".opencode", "index");
 }
-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)})${formatBlame(r)}
-\`\`\`
-${truncateContent(r.content)}
-\`\`\``;
-  });
-  return formatted.join("\n\n");
+function getLocalProjectConfigPath(projectRoot) {
+  return path18.join(projectRoot, ".opencode", "codebase-index.json");
 }
-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}${formatBlame(r)}
-\`\`\`
-${truncateContent(r.content)}
-\`\`\``;
-  });
-  return formatted.join("\n\n");
+function clearIndexRoot(projectRoot, scope) {
+  const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
+  if (existsSync11(indexRoot)) {
+    rmSync2(indexRoot, { recursive: true, force: true });
+  }
 }
-
-// src/tools/format-pr-impact.ts
-function formatPrImpact(result) {
-  const lines = [];
-  lines.push(`\u2192 Files changed: ${result.changedFiles.length}`);
-  for (const file of result.changedFiles) {
-    lines.push(`  - ${file}`);
+function ensureLocalEvalProjectConfig(projectRoot, configPath) {
+  const localConfigPath = getLocalProjectConfigPath(projectRoot);
+  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot);
+  if (!configPath && existsSync11(localConfigPath)) {
+    return localConfigPath;
   }
-  const directCount = result.directSymbols.length;
-  const transitiveCount = result.transitiveCallers.length;
-  const directionLabel = result.direction === "callees" ? "callees" : result.direction === "both" ? "reachable (callers + callees)" : "callers";
-  lines.push(
-    `\u2192 Symbols affected: ${result.totalAffected} (${directCount} direct, ${transitiveCount} transitive ${directionLabel})`
-  );
-  if (directCount > 0) {
-    lines.push(
-      `  Direct: ${result.directSymbols.map((s) => `${s.name} (${s.kind})`).join(", ")}`
-    );
+  if (!existsSync11(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
+    return resolvedConfigPath;
   }
-  if (transitiveCount > 0) {
-    lines.push(
-      `  Transitive ${directionLabel}: ${result.transitiveCallers.map((s) => s.name).join(", ")}`
-    );
+  const sourceConfig = normalizeEvalConfigKnowledgeBases(
+    parseJsonConfigFile(resolvedConfigPath),
+    projectRoot,
+    resolvedConfigPath
+  );
+  mkdirSync6(path18.dirname(localConfigPath), { recursive: true });
+  writeFileSync6(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
+  return localConfigPath;
+}
+function loadParsedConfig(projectRoot, configPath) {
+  const raw = loadRawConfig(projectRoot, configPath);
+  return parseConfig(raw);
+}
+function resolveSearchConfig(parsedConfig, overrides) {
+  const nextSearch = {
+    ...parsedConfig.search
+  };
+  if (overrides?.fusionStrategy !== void 0) {
+    nextSearch.fusionStrategy = overrides.fusionStrategy;
   }
-  if (result.communities.length > 0) {
-    lines.push(
-      `\u2192 Communities touched: ${result.communities.map((c) => c.label).join(", ")}`
-    );
-    for (const community of result.communities) {
-      lines.push(
-        `  - ${community.label}: ${community.symbolCount} symbols`
-      );
-    }
-  } else {
-    lines.push("\u2192 Communities touched: none");
+  if (overrides?.hybridWeight !== void 0) {
+    nextSearch.hybridWeight = overrides.hybridWeight;
   }
-  lines.push(`\u2192 Risk: ${result.riskLevel} \u2014 ${result.riskReason}`);
-  if (result.hubNodes.length > 0) {
-    lines.push("  Hub nodes in change scope:");
-    for (const hub of result.hubNodes) {
-      lines.push(`    - ${hub.name} (${hub.callerCount} callers) at ${hub.filePath}`);
-    }
+  if (overrides?.rrfK !== void 0) {
+    nextSearch.rrfK = overrides.rrfK;
   }
-  if (result.conflictingPRs && result.conflictingPRs.length > 0) {
-    const conflictList = result.conflictingPRs.map(
-      (c) => `PR #${c.pr} (also touches ${c.overlappingCommunities.join(", ")} community)`
-    );
-    lines.push(`\u2192 Potential conflicts with: ${conflictList.join(", ")}`);
+  if (overrides?.rerankTopN !== void 0) {
+    nextSearch.rerankTopN = overrides.rerankTopN;
   }
-  return lines.join("\n");
+  return {
+    ...parsedConfig,
+    search: nextSearch
+  };
+}
+function getEmbeddingCostPer1MTokens(embeddingProvider) {
+  return embeddingProvider === "custom" || embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(embeddingProvider).costPer1MTokens;
 }
 
-// src/tools/operations.ts
-import { existsSync as existsSync12, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
-import * as path21 from "path";
-
-// src/config/merger.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import * as path18 from "path";
-var PROJECT_OVERRIDE_KEYS = [
-  "embeddingProvider",
-  "customProvider",
-  "embeddingModel",
-  "reranker",
-  "include",
-  "exclude",
-  "indexing",
-  "search",
-  "debug",
-  "scope"
-];
-var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+// src/eval/schema.ts
+import { readFileSync as readFileSync10 } from "fs";
+function parseJsonFile(filePath) {
+  const content = readFileSync10(filePath, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse JSON from ${filePath}: ${message}`);
+  }
+}
 function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null;
 }
 function isStringArray4(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
-  if (key in normalizedProjectConfig) {
-    merged[key] = normalizedProjectConfig[key];
-    return;
+function asPositiveNumber(value, path27) {
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+    throw new Error(`${path27} must be a non-negative number`);
   }
-  if (key in globalConfig) {
-    merged[key] = globalConfig[key];
+  return value;
+}
+function parseQueryType(value, path27) {
+  if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy" || value === "conceptual") {
+    return value;
   }
+  throw new Error(
+    `${path27} must be one of: definition, implementation-intent, similarity, keyword-heavy, conceptual`
+  );
 }
-function mergeUniqueStringArray(values) {
-  return [...new Set(values.map((value) => String(value).trim()))];
+function parseRetrievalMode(value, path27) {
+  if (value === void 0 || value === "search") return "search";
+  if (value === "context") return value;
+  throw new Error(`${path27} must be one of: search, context`);
 }
-function normalizeKnowledgeBasePath(value) {
-  let normalized = path18.normalize(String(value).trim());
-  const root = path18.parse(normalized).root;
-  while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
-    normalized = normalized.slice(0, -1);
+function parseExpected(input, path27) {
+  if (!isRecord3(input)) {
+    throw new Error(`${path27} must be an object`);
   }
-  return normalized;
-}
-function mergeKnowledgeBasePaths(values) {
-  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
+  const filePathRaw = input.filePath;
+  const acceptableFilesRaw = input.acceptableFiles;
+  const symbolRaw = input.symbol;
+  const branchRaw = input.branch;
+  const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
+  const acceptableFiles = isStringArray4(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
+  if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
+    throw new Error(`${path27} must include either expected.filePath or expected.acceptableFiles`);
+  }
+  if (acceptableFilesRaw !== void 0 && !isStringArray4(acceptableFilesRaw)) {
+    throw new Error(`${path27}.acceptableFiles must be an array of strings`);
+  }
+  if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
+    throw new Error(`${path27}.symbol must be a string when provided`);
+  }
+  if (branchRaw !== void 0 && typeof branchRaw !== "string") {
+    throw new Error(`${path27}.branch must be a string when provided`);
+  }
+  return {
+    filePath,
+    acceptableFiles,
+    symbol: typeof symbolRaw === "string" ? symbolRaw : void 0,
+    branch: typeof branchRaw === "string" ? branchRaw : void 0
+  };
 }
-function validateConfigLayerShape(rawConfig, filePath) {
-  if (!isRecord3(rawConfig)) {
-    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+function parseQuery(input, index) {
+  const path27 = `queries[${index}]`;
+  if (!isRecord3(input)) {
+    throw new Error(`${path27} must be an object`);
+  }
+  const id = input.id;
+  const query = input.query;
+  const queryType = input.queryType;
+  const retrievalMode = input.retrievalMode;
+  const expected = input.expected;
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new Error(`${path27}.id must be a non-empty string`);
+  }
+  if (typeof query !== "string" || query.trim().length === 0) {
+    throw new Error(`${path27}.query must be a non-empty string`);
   }
-  if (rawConfig.knowledgeBases !== void 0 && !isStringArray4(rawConfig.knowledgeBases)) {
-    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  return {
+    id,
+    query,
+    queryType: parseQueryType(queryType, `${path27}.queryType`),
+    retrievalMode: parseRetrievalMode(retrievalMode, `${path27}.retrievalMode`),
+    expected: parseExpected(expected, `${path27}.expected`)
+  };
+}
+function parseGoldenDataset(raw, sourceLabel) {
+  if (!isRecord3(raw)) {
+    throw new Error(`${sourceLabel} must be a JSON object`);
   }
-  if (rawConfig.additionalInclude !== void 0 && !isStringArray4(rawConfig.additionalInclude)) {
-    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  const version = raw.version;
+  const name = raw.name;
+  const description = raw.description;
+  const queriesRaw = raw.queries;
+  if (typeof version !== "string" || version.trim().length === 0) {
+    throw new Error(`${sourceLabel}.version must be a non-empty string`);
   }
-  if (rawConfig.include !== void 0 && !isStringArray4(rawConfig.include)) {
-    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error(`${sourceLabel}.name must be a non-empty string`);
   }
-  if (rawConfig.exclude !== void 0 && !isStringArray4(rawConfig.exclude)) {
-    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
+  if (description !== void 0 && typeof description !== "string") {
+    throw new Error(`${sourceLabel}.description must be a string when provided`);
   }
-  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
-    const value = rawConfig[section];
-    if (value !== void 0 && !isRecord3(value)) {
-      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
-    }
+  if (!Array.isArray(queriesRaw)) {
+    throw new Error(`${sourceLabel}.queries must be an array`);
   }
-  return rawConfig;
-}
-function loadJsonFile(filePath) {
-  if (!existsSync10(filePath)) {
-    return null;
+  if (queriesRaw.length === 0) {
+    throw new Error(`${sourceLabel}.queries must contain at least one query`);
   }
-  try {
-    const content = readFileSync10(filePath, "utf-8");
-    return validateConfigLayerShape(JSON.parse(content), filePath);
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Config file ")) {
-      throw error;
+  const queries = queriesRaw.map((query, idx) => parseQuery(query, idx));
+  const idSet = /* @__PURE__ */ new Set();
+  for (const query of queries) {
+    if (idSet.has(query.id)) {
+      throw new Error(`${sourceLabel}.queries has duplicate id: ${query.id}`);
     }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to load config file ${filePath}: ${message}`);
+    idSet.add(query.id);
   }
+  return {
+    version,
+    name,
+    description: typeof description === "string" ? description : void 0,
+    queries
+  };
 }
-function loadConfigFile(filePath) {
-  return loadJsonFile(filePath);
-}
-function materializeLocalProjectConfig(projectRoot, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot, host);
-  mkdirSync5(path18.dirname(localConfigPath), { recursive: true });
-  writeFileSync5(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
+function loadGoldenDataset(datasetPath) {
+  const parsed = parseJsonFile(datasetPath);
+  return parseGoldenDataset(parsed, datasetPath);
 }
-function loadProjectConfigLayer(projectRoot, host = "opencode") {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!projectConfig) {
-    return {};
-  }
-  const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path18.dirname(path18.dirname(projectConfigPath));
-  if (Array.isArray(normalizedConfig.knowledgeBases)) {
-    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
-      normalizedConfig.knowledgeBases,
-      projectConfigBaseDir,
-      projectRoot
-    );
-  }
-  return normalizedConfig;
+function parseThresholdValue(value, fieldName, sourceLabel) {
+  return value === void 0 ? void 0 : asPositiveNumber(value, `${sourceLabel}.thresholds.${fieldName}`);
 }
-function loadMergedConfig(projectRoot, host = "opencode") {
-  const globalConfigPath = resolveGlobalConfigPath(host);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
-  let globalConfig = null;
-  let globalConfigError = null;
-  try {
-    globalConfig = loadJsonFile(globalConfigPath);
-  } catch (error) {
-    globalConfigError = error instanceof Error ? error : new Error(String(error));
-  }
-  const projectConfig = loadJsonFile(projectConfigPath);
-  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot, host);
-  if (globalConfigError) {
-    if (!projectConfig) {
-      throw globalConfigError;
-    }
-    globalConfig = null;
-  }
-  if (!globalConfig && !projectConfig) {
-    return {};
+function parseBudget(raw, sourceLabel) {
+  if (!isRecord3(raw)) {
+    throw new Error(`${sourceLabel} must be a JSON object`);
   }
-  if (!projectConfig && globalConfig) {
-    return globalConfig;
+  const name = raw.name;
+  const baselinePath = raw.baselinePath;
+  const failOnMissingBaseline = raw.failOnMissingBaseline;
+  const thresholds = raw.thresholds;
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error(`${sourceLabel}.name must be a non-empty string`);
   }
-  if (!globalConfig && projectConfig) {
-    return normalizedProjectConfig;
+  if (baselinePath !== void 0 && typeof baselinePath !== "string") {
+    throw new Error(`${sourceLabel}.baselinePath must be a string when provided`);
   }
-  if (!globalConfig || !projectConfig) {
-    return globalConfig ?? normalizedProjectConfig;
+  if (!isRecord3(thresholds)) {
+    throw new Error(`${sourceLabel}.thresholds must be an object`);
   }
-  const merged = { ...globalConfig };
-  for (const key of PROJECT_OVERRIDE_KEYS) {
-    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
+  return {
+    name,
+    baselinePath: typeof baselinePath === "string" ? baselinePath : void 0,
+    failOnMissingBaseline: typeof failOnMissingBaseline === "boolean" ? failOnMissingBaseline : true,
+    thresholds: {
+      hitAt5MaxDrop: parseThresholdValue(
+        thresholds.hitAt5MaxDrop,
+        "hitAt5MaxDrop",
+        sourceLabel
+      ),
+      mrrAt10MaxDrop: parseThresholdValue(
+        thresholds.mrrAt10MaxDrop,
+        "mrrAt10MaxDrop",
+        sourceLabel
+      ),
+      rawDistinctTop3RatioMaxDrop: parseThresholdValue(
+        thresholds.rawDistinctTop3RatioMaxDrop,
+        "rawDistinctTop3RatioMaxDrop",
+        sourceLabel
+      ),
+      p95LatencyMaxMultiplier: parseThresholdValue(
+        thresholds.p95LatencyMaxMultiplier,
+        "p95LatencyMaxMultiplier",
+        sourceLabel
+      ),
+      p95LatencyMaxAbsoluteMs: parseThresholdValue(
+        thresholds.p95LatencyMaxAbsoluteMs,
+        "p95LatencyMaxAbsoluteMs",
+        sourceLabel
+      ),
+      minHitAt5: parseThresholdValue(
+        thresholds.minHitAt5,
+        "minHitAt5",
+        sourceLabel
+      ),
+      minMrrAt10: parseThresholdValue(
+        thresholds.minMrrAt10,
+        "minMrrAt10",
+        sourceLabel
+      ),
+      minRawDistinctTop3Ratio: parseThresholdValue(
+        thresholds.minRawDistinctTop3Ratio,
+        "minRawDistinctTop3Ratio",
+        sourceLabel
+      ),
+      maxContextResponseTokensAverage: parseThresholdValue(
+        thresholds.maxContextResponseTokensAverage,
+        "maxContextResponseTokensAverage",
+        sourceLabel
+      ),
+      maxContextResponseTokensP95: parseThresholdValue(
+        thresholds.maxContextResponseTokensP95,
+        "maxContextResponseTokensP95",
+        sourceLabel
+      ),
+      maxContextResponseTokensMax: parseThresholdValue(
+        thresholds.maxContextResponseTokensMax,
+        "maxContextResponseTokensMax",
+        sourceLabel
+      ),
+      maxContextDuplicateCandidateRatio: parseThresholdValue(
+        thresholds.maxContextDuplicateCandidateRatio,
+        "maxContextDuplicateCandidateRatio",
+        sourceLabel
+      ),
+      minContextSelectedFileRatio: parseThresholdValue(
+        thresholds.minContextSelectedFileRatio,
+        "minContextSelectedFileRatio",
+        sourceLabel
+      ),
+      minContextHitAt5Per1kResponseTokens: parseThresholdValue(
+        thresholds.minContextHitAt5Per1kResponseTokens,
+        "minContextHitAt5Per1kResponseTokens",
+        sourceLabel
+      ),
+      minContextMrrAt10Per1kResponseTokens: parseThresholdValue(
+        thresholds.minContextMrrAt10Per1kResponseTokens,
+        "minContextMrrAt10Per1kResponseTokens",
+        sourceLabel
+      )
+    }
+  };
+}
+function loadBudget(budgetPath) {
+  const parsed = parseJsonFile(budgetPath);
+  return parseBudget(parsed, budgetPath);
+}
+
+// src/eval/runner.ts
+async function runEvaluation(options) {
+  const datasetPath = toAbsolute(options.projectRoot, options.datasetPath);
+  const againstPath = options.againstPath ? toAbsolute(options.projectRoot, options.againstPath) : void 0;
+  const budgetPath = options.budgetPath ? toAbsolute(options.projectRoot, options.budgetPath) : void 0;
+  const dataset = loadGoldenDataset(datasetPath);
+  const resolvedEvalConfigPath = options.reindex ? ensureLocalEvalProjectConfig(options.projectRoot, options.configPath) : options.configPath;
+  const parsedConfig = loadParsedConfig(options.projectRoot, resolvedEvalConfigPath);
+  const effectiveConfig = resolveSearchConfig(parsedConfig, options.searchOverrides);
+  if (options.reindex) {
+    clearIndexRoot(options.projectRoot, effectiveConfig.scope);
   }
-  if (projectConfig) {
-    for (const key of Object.keys(projectConfig)) {
-      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
-        continue;
+  const indexer = new Indexer(options.projectRoot, effectiveConfig);
+  try {
+    await indexer.index();
+    const perQuery = [];
+    for (const query of dataset.queries) {
+      if (query.expected.branch && query.expected.branch !== indexer.getCurrentBranch()) {
+        throw new Error(
+          `Query '${query.id}' expects branch '${query.expected.branch}', but current branch is '${indexer.getCurrentBranch()}'. Switch branch before running this dataset.`
+        );
+      }
+      const start = performance3.now();
+      const contextResult = query.retrievalMode === "context" ? await resolveSearchContext({
+        query: query.query,
+        limit: 10,
+        tokenBudget: DEFAULT_CONTEXT_PACK_TOKEN_BUDGET
+      }, {
+        lookup: (symbol, limit) => indexer.search(symbol, limit, {
+          metadataOnly: true,
+          filterByBranch: !!query.expected.branch,
+          definitionIntent: true
+        }),
+        search: (searchQuery, limit) => indexer.search(searchQuery, limit, {
+          metadataOnly: true,
+          filterByBranch: !!query.expected.branch,
+          definitionIntent: false
+        })
+      }) : void 0;
+      const result = contextResult?.details?.results ?? await indexer.search(query.query, 10, {
+        metadataOnly: true,
+        filterByBranch: !!query.expected.branch
+      });
+      const elapsed = performance3.now() - start;
+      const resolvedRoute = contextResult?.details?.route === "definition" ? "definition" : "search";
+      const routedQuery = contextResult?.details?.routedQuery ?? query.query;
+      const materialized = result.map((item) => ({
+        filePath: item.filePath,
+        startLine: item.startLine,
+        endLine: item.endLine,
+        score: item.score,
+        chunkType: item.chunkType,
+        name: item.name
+      }));
+      perQuery.push(buildPerQueryResult(query, materialized, elapsed, 10, {
+        resolvedRoute,
+        routedQuery
+      }, contextResult?.details ? {
+        tokenBudget: contextResult.details.tokenBudget,
+        responseTokens: contextResult.details.tokenEstimate,
+        candidateCount: contextResult.details.candidateCount ?? 0,
+        deduplicatedCount: contextResult.details.deduplicatedCount ?? 0,
+        omittedCount: contextResult.details.omittedCount ?? 0
+      } : void 0));
+    }
+    const logger = indexer.getLogger();
+    const metricSnapshot = logger.getMetrics();
+    const costPer1MTokensUsd = getEmbeddingCostPer1MTokens(effectiveConfig.embeddingProvider);
+    const summary = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot: options.projectRoot,
+      datasetPath,
+      datasetName: dataset.name,
+      datasetVersion: dataset.version,
+      queryCount: dataset.queries.length,
+      topK: 10,
+      searchConfig: {
+        fusionStrategy: effectiveConfig.search.fusionStrategy,
+        hybridWeight: effectiveConfig.search.hybridWeight,
+        rrfK: effectiveConfig.search.rrfK,
+        rerankTopN: effectiveConfig.search.rerankTopN
+      },
+      metrics: computeEvalMetrics(
+        dataset.queries,
+        perQuery,
+        metricSnapshot.embeddingApiCalls,
+        metricSnapshot.embeddingTokensUsed,
+        costPer1MTokensUsd
+      )
+    };
+    const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
+    const perQueryArtifact = buildPerQueryArtifact(perQuery);
+    writeJson(path19.join(outputDir, "summary.json"), summary);
+    writeJson(path19.join(outputDir, "per-query.json"), perQueryArtifact);
+    let comparison;
+    if (againstPath) {
+      const baseline = loadSummary(againstPath);
+      comparison = compareSummaries(summary, baseline, againstPath);
+      writeJson(path19.join(outputDir, "compare.json"), comparison);
+    }
+    let gate;
+    if (options.ciMode) {
+      if (!budgetPath) {
+        throw new Error("CI mode requires --budget path");
       }
-      merged[key] = normalizedProjectConfig[key];
+      const budget = loadBudget(budgetPath);
+      if (!comparison && budget.baselinePath) {
+        const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
+        if (existsSync12(resolvedBaseline)) {
+          const baselineSummary = loadSummary(resolvedBaseline);
+          comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
+          writeJson(path19.join(outputDir, "compare.json"), comparison);
+        } else if (budget.failOnMissingBaseline) {
+          throw new Error(
+            `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
+          );
+        }
+      }
+      gate = evaluateBudgetGate(budget, summary, comparison);
     }
+    const markdown = createSummaryMarkdown(summary, comparison, gate);
+    writeText(path19.join(outputDir, "summary.md"), markdown);
+    return { outputDir, summary, perQuery, comparison, gate };
+  } finally {
+    await indexer.close();
   }
-  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
-  const allKbs = [...globalKbs, ...projectKbs];
-  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
-  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
-  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
-  const allAdditional = [...globalAdditional, ...projectAdditional];
-  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
-  return merged;
 }
-
-// src/tools/knowledge-base-paths.ts
-import * as path19 from "path";
-function resolveConfigPathValue(value, baseDir) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return trimmed;
+async function runSweep(options, sweep) {
+  const fusionValues = sweep.fusionStrategy && sweep.fusionStrategy.length > 0 ? [...sweep.fusionStrategy] : [void 0];
+  const weightValues = sweep.hybridWeight && sweep.hybridWeight.length > 0 ? [...sweep.hybridWeight] : [void 0];
+  const rrfValues = sweep.rrfK && sweep.rrfK.length > 0 ? [...sweep.rrfK] : [void 0];
+  const rerankValues = sweep.rerankTopN && sweep.rerankTopN.length > 0 ? [...sweep.rerankTopN] : [void 0];
+  const runs = [];
+  for (const fusion of fusionValues) {
+    for (const hybridWeight of weightValues) {
+      for (const rrfK of rrfValues) {
+        for (const rerankTopN of rerankValues) {
+          const run = await runEvaluation({
+            ...options,
+            searchOverrides: {
+              ...fusion !== void 0 ? { fusionStrategy: fusion } : {},
+              ...hybridWeight !== void 0 ? { hybridWeight } : {},
+              ...rrfK !== void 0 ? { rrfK } : {},
+              ...rerankTopN !== void 0 ? { rerankTopN } : {}
+            }
+          });
+          runs.push({
+            searchConfig: run.summary.searchConfig,
+            summary: run.summary,
+            comparison: run.comparison,
+            gate: run.gate
+          });
+        }
+      }
+    }
   }
-  const absolutePath = path19.isAbsolute(trimmed) ? trimmed : path19.resolve(baseDir, trimmed);
-  return path19.normalize(absolutePath);
+  const bestByHitAt5 = [...runs].sort(
+    (a, b) => b.summary.metrics.hitAt5 - a.summary.metrics.hitAt5
+  )[0];
+  const bestByMrrAt10 = [...runs].sort(
+    (a, b) => b.summary.metrics.mrrAt10 - a.summary.metrics.mrrAt10
+  )[0];
+  const bestByP95Latency = [...runs].sort(
+    (a, b) => a.summary.metrics.latencyMs.p95 - b.summary.metrics.latencyMs.p95
+  )[0];
+  const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
+  const failedGateRuns = runs.filter((run) => run.gate && !run.gate.passed).length;
+  const gatePassed = failedGateRuns === 0;
+  const aggregate = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    againstPath: options.againstPath,
+    runCount: runs.length,
+    runs,
+    gatePassed,
+    failedGateRuns,
+    bestByHitAt5,
+    bestByMrrAt10,
+    bestByP95Latency
+  };
+  writeJson(path19.join(outputDir, "compare.json"), aggregate);
+  const md = createSummaryMarkdown(
+    bestByHitAt5?.summary ?? runs[0].summary,
+    bestByHitAt5?.comparison,
+    void 0,
+    aggregate
+  );
+  writeText(path19.join(outputDir, "summary.md"), md);
+  writeJson(path19.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  return { outputDir, aggregate };
 }
 
-// src/tools/config-state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+// src/eval/cli.ts
+import * as path21 from "path";
+
+// src/eval/cli-parser.ts
 import * as path20 from "path";
-function normalizeKnowledgeBasePaths(config, projectRoot) {
-  const normalized = { ...config };
-  if (Array.isArray(normalized.knowledgeBases)) {
-    normalized.knowledgeBases = normalized.knowledgeBases.map(
-      (kb) => resolveConfigPathValue(kb, projectRoot)
-    );
-  }
-  return normalized;
+function printUsage() {
+  console.log(`
+Usage:
+  opencode-codebase-index-mcp eval run [options]
+  opencode-codebase-index-mcp eval compare --against <summary.json> [options]
+  opencode-codebase-index-mcp eval diff --current <summary.json> --against <summary.json> [options]
+
+Options:
+  --project <path>                 Project root (default: cwd)
+  --config <path>                  Config JSON path
+  --dataset <path>                 Golden dataset path (default: benchmarks/golden/small.json)
+  --current <path>                 Current summary.json path (required for eval diff)
+  --output <path>                  Output root dir (default: benchmarks/results)
+  --against <path>                 Baseline summary.json to compare against
+  --budget <path>                  Budget file for CI mode (default: benchmarks/budgets/default.json)
+  --ci                             Enable CI gate mode
+  --reindex                        Force reindex before eval
+
+Search overrides:
+  --fusionStrategy <rrf|weighted>
+  --hybridWeight <0-1>
+  --rrfK <number>
+  --rerankTopN <number>
+
+Sweep options (comma-separated values):
+  --sweepFusionStrategy <rrf,weighted>
+  --sweepHybridWeight <0.3,0.5,0.7>
+  --sweepRrfK <30,60,90>
+  --sweepRerankTopN <10,20,40>
+`);
 }
-function toConfigRecord(rawConfig) {
-  if (!rawConfig || typeof rawConfig !== "object") {
-    return {};
+function parseNumber(value, flag) {
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`${flag} must be a number`);
   }
-  return { ...rawConfig };
+  return parsed;
 }
-function loadRuntimeConfig(projectRoot, host = "opencode") {
-  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot, host)), projectRoot);
+function parseCsvNumbers(value, flag) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0).map((item) => parseNumber(item, flag));
 }
-
-// src/tools/operations.ts
-var indexerCache = /* @__PURE__ */ new Map();
-var configCache = /* @__PURE__ */ new Map();
-var defaultProjectRoots = /* @__PURE__ */ new Map();
-function getIndexBusyResult(error) {
-  if (!isIndexLockContentionError(error)) return null;
-  const owner = error.owner;
-  const ownerText = owner ? `PID ${owner.pid}, operation ${owner.operation}, since ${owner.startedAt}` : "unreadable owner";
-  if (error.reason === "legacy-lock") {
-    return {
-      kind: "busy",
-      text: `INDEX_BUSY: legacy lock format detected (${ownerText}). Verify the PID and remove this lock manually only if it is stale.`
-    };
+function parseCsvFusion(value) {
+  const values = value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  const parsed = [];
+  for (const candidate of values) {
+    if (candidate !== "rrf" && candidate !== "weighted") {
+      throw new Error("--sweepFusionStrategy accepts only rrf,weighted");
+    }
+    parsed.push(candidate);
   }
-  if (error.reason === "unknown-owner") {
-    return {
-      kind: "busy",
-      text: `INDEX_BUSY: unreadable or remote lock owner (${ownerText}). Automatic recovery was refused; manual verification is required.`
-    };
+  return parsed;
+}
+function hasSweepOptions(sweep) {
+  return Boolean(
+    sweep.fusionStrategy && sweep.fusionStrategy.length > 0 || sweep.hybridWeight && sweep.hybridWeight.length > 0 || sweep.rrfK && sweep.rrfK.length > 0 || sweep.rerankTopN && sweep.rerankTopN.length > 0
+  );
+}
+function parseEvalArgs(argv, cwd) {
+  const parsed = {
+    projectRoot: cwd,
+    datasetPath: "benchmarks/golden/small.json",
+    outputRoot: "benchmarks/results",
+    budgetPath: "benchmarks/budgets/default.json",
+    ciMode: false,
+    reindex: false,
+    sweep: {}
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if (arg === "--project" && next) {
+      parsed.projectRoot = path20.resolve(cwd, next);
+      i += 1;
+      continue;
+    }
+    if (arg === "--config" && next) {
+      parsed.configPath = path20.resolve(cwd, next);
+      i += 1;
+      continue;
+    }
+    if (arg === "--dataset" && next) {
+      parsed.datasetPath = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--current" && next) {
+      parsed.currentPath = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--output" && next) {
+      parsed.outputRoot = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--against" && next) {
+      parsed.againstPath = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--budget" && next) {
+      parsed.budgetPath = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--ci") {
+      parsed.ciMode = true;
+      continue;
+    }
+    if (arg === "--reindex") {
+      parsed.reindex = true;
+      continue;
+    }
+    if (arg === "--fusionStrategy" && next) {
+      if (next !== "rrf" && next !== "weighted") {
+        throw new Error("--fusionStrategy must be rrf or weighted");
+      }
+      parsed.fusionStrategy = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--hybridWeight" && next) {
+      parsed.hybridWeight = parseNumber(next, "--hybridWeight");
+      i += 1;
+      continue;
+    }
+    if (arg === "--rrfK" && next) {
+      parsed.rrfK = parseNumber(next, "--rrfK");
+      i += 1;
+      continue;
+    }
+    if (arg === "--rerankTopN" && next) {
+      parsed.rerankTopN = parseNumber(next, "--rerankTopN");
+      i += 1;
+      continue;
+    }
+    if (arg === "--sweepFusionStrategy" && next) {
+      parsed.sweep.fusionStrategy = parseCsvFusion(next);
+      i += 1;
+      continue;
+    }
+    if (arg === "--sweepHybridWeight" && next) {
+      parsed.sweep.hybridWeight = parseCsvNumbers(next, "--sweepHybridWeight");
+      i += 1;
+      continue;
+    }
+    if (arg === "--sweepRrfK" && next) {
+      parsed.sweep.rrfK = parseCsvNumbers(next, "--sweepRrfK");
+      i += 1;
+      continue;
+    }
+    if (arg === "--sweepRerankTopN" && next) {
+      parsed.sweep.rerankTopN = parseCsvNumbers(next, "--sweepRerankTopN");
+      i += 1;
+      continue;
+    }
   }
-  return { kind: "busy", text: `INDEX_BUSY: another index operation is already in progress (${ownerText}).` };
+  return parsed;
 }
-function getProjectRoot(projectRoot, host) {
-  if (projectRoot) {
-    return projectRoot;
-  }
-  const root = defaultProjectRoots.get(host);
-  if (!root) {
-    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
+function parseEvalSubcommandOptions(argv, cwd) {
+  let explicitAgainst;
+  const filtered = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const current = argv[i];
+    const next = argv[i + 1];
+    if (current === "--against" && next) {
+      explicitAgainst = next;
+      i += 1;
+      continue;
+    }
+    filtered.push(current);
   }
-  return root;
+  return {
+    parsed: parseEvalArgs(filtered, cwd),
+    explicitAgainst
+  };
 }
-function getIndexerCacheKey(projectRoot, host) {
-  return `${host}::${projectRoot}`;
+function toRunOptions(parsed) {
+  return {
+    projectRoot: parsed.projectRoot,
+    configPath: parsed.configPath,
+    datasetPath: parsed.datasetPath,
+    outputRoot: parsed.outputRoot,
+    againstPath: parsed.againstPath,
+    budgetPath: parsed.budgetPath,
+    ciMode: parsed.ciMode,
+    reindex: parsed.reindex,
+    searchOverrides: {
+      ...parsed.fusionStrategy !== void 0 ? { fusionStrategy: parsed.fusionStrategy } : {},
+      ...parsed.hybridWeight !== void 0 ? { hybridWeight: parsed.hybridWeight } : {},
+      ...parsed.rrfK !== void 0 ? { rrfK: parsed.rrfK } : {},
+      ...parsed.rerankTopN !== void 0 ? { rerankTopN: parsed.rerankTopN } : {}
+    }
+  };
 }
-function getOrCreateIndexer(projectRoot, host) {
-  const key = getIndexerCacheKey(projectRoot, host);
-  const cached = indexerCache.get(key);
-  if (cached) {
-    return cached;
+
+// src/eval/cli.ts
+async function handleEvalCommand(args, cwd) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    return 0;
   }
-  const config = parseConfig(loadRuntimeConfig(projectRoot, host));
-  const indexer = new Indexer(projectRoot, config, host);
-  indexerCache.set(key, indexer);
-  configCache.set(key, config);
-  return indexer;
-}
-function initializeTools(projectRoot, config, host = "opencode") {
-  defaultProjectRoots.set(host, projectRoot);
-  const key = getIndexerCacheKey(projectRoot, host);
-  const indexer = new Indexer(projectRoot, config, host);
-  indexerCache.set(key, indexer);
-  configCache.set(key, config);
-}
-function getIndexerForProject(projectRoot, host = "opencode") {
-  const root = getProjectRoot(projectRoot, host);
-  return getOrCreateIndexer(root, host);
-}
-function refreshIndexerForDirectory(projectRoot, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot, host))) {
-  const key = getIndexerCacheKey(projectRoot, host);
-  const indexer = new Indexer(projectRoot, config, host);
-  indexerCache.set(key, indexer);
-  configCache.set(key, config);
-}
-function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
-  const root = getProjectRoot(projectRoot, host);
-  const localIndexPath = path21.join(root, getHostProjectIndexRelativePath(host));
-  if (existsSync12(localIndexPath)) {
-    return false;
+  if (subcommand === "run") {
+    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
+    if (explicitAgainst) {
+      parsed.againstPath = explicitAgainst;
+    }
+    const runOptions = toRunOptions(parsed);
+    if (hasSweepOptions(parsed.sweep)) {
+      const sweep = await runSweep(runOptions, parsed.sweep);
+      console.log(`Eval sweep complete. Artifacts: ${sweep.outputDir}`);
+      console.log(`Sweep runs: ${sweep.aggregate.runCount}`);
+      if (parsed.ciMode && sweep.aggregate.gatePassed === false) {
+        console.error(
+          `[CI-GATE] Sweep failed: ${sweep.aggregate.failedGateRuns ?? 0} run(s) violated budget/baseline gates`
+        );
+        return 1;
+      }
+      return 0;
+    }
+    const result = await runEvaluation(runOptions);
+    console.log(`Eval run complete. Artifacts: ${result.outputDir}`);
+    console.log(
+      `Hit@5=${(result.summary.metrics.hitAt5 * 100).toFixed(2)}% MRR@10=${result.summary.metrics.mrrAt10.toFixed(4)} p95=${result.summary.metrics.latencyMs.p95.toFixed(3)}ms`
+    );
+    if (result.gate && !result.gate.passed) {
+      for (const violation of result.gate.violations) {
+        console.error(`[CI-GATE] ${violation.metric}: ${violation.message}`);
+      }
+      return 1;
+    }
+    return 0;
   }
-  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
-  return inheritedIndexPath !== null;
-}
-async function searchCodebase(projectRoot, host, query, options = {}) {
-  const indexer = getIndexerForProject(projectRoot, 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,
-    blameAuthor: options.blameAuthor,
-    blameSha: options.blameSha,
-    blameSince: options.blameSince
-  });
-}
-async function findSimilarCode(projectRoot, host, code, options = {}) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.findSimilar(code, options.limit, {
-    fileType: options.fileType,
-    directory: options.directory,
-    chunkType: options.chunkType,
-    excludeFile: options.excludeFile
-  });
-}
-async function implementationLookup(projectRoot, host, query, options = {}) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.search(query, options.limit, {
-    fileType: options.fileType,
-    directory: options.directory,
-    definitionIntent: true
-  });
-}
-async function getCallGraphData(projectRoot, host, params) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  if (params.direction === "callees") {
-    if (!params.symbolId) {
-      return { direction: "callees", callees: [], callers: [] };
+  if (subcommand === "compare") {
+    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
+    if (!explicitAgainst) {
+      throw new Error("eval compare requires --against <baseline summary.json>");
     }
-    const callees = await indexer.getCallees(params.symbolId, params.relationshipType);
-    return { direction: "callees", callees, callers: [] };
+    parsed.againstPath = explicitAgainst;
+    const runOptions = toRunOptions(parsed);
+    if (hasSweepOptions(parsed.sweep)) {
+      const sweep = await runSweep(runOptions, parsed.sweep);
+      console.log(`Eval compare sweep complete. Artifacts: ${sweep.outputDir}`);
+      if (parsed.ciMode && sweep.aggregate.gatePassed === false) {
+        console.error(
+          `[CI-GATE] Sweep failed: ${sweep.aggregate.failedGateRuns ?? 0} run(s) violated budget/baseline gates`
+        );
+        return 1;
+      }
+      return 0;
+    }
+    const result = await runEvaluation(runOptions);
+    console.log(`Eval compare complete. Artifacts: ${result.outputDir}`);
+    return 0;
   }
-  const callers = await indexer.getCallers(params.name, params.relationshipType);
-  return { direction: "callers", callers, callees: [] };
-}
-async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.findCallPath(from, to, maxDepth);
-}
-async function runIndexCodebase(projectRoot, host, args, onProgress) {
-  const root = getProjectRoot(projectRoot, host);
-  const key = getIndexerCacheKey(root, host);
-  let indexer = getIndexerForProject(root, host);
-  const runtimeConfig = configCache.get(key);
-  try {
-    if (args.estimateOnly) {
-      return { kind: "estimate", estimate: await indexer.estimateCost() };
+  if (subcommand === "diff") {
+    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
+    if (!explicitAgainst) {
+      throw new Error("eval diff requires --against <baseline summary.json>");
     }
-    const runIndex = async (target) => {
-      const operation = args.force ? target.forceIndex.bind(target) : target.index.bind(target);
-      return operation((progress) => {
-        if (onProgress) {
-          return onProgress(formatProgressTitle(progress), {
-            phase: progress.phase,
-            filesProcessed: progress.filesProcessed,
-            totalFiles: progress.totalFiles,
-            chunksProcessed: progress.chunksProcessed,
-            totalChunks: progress.totalChunks,
-            percentage: calculatePercentage(progress)
-          });
-        }
-        return Promise.resolve();
-      });
-    };
-    let stats;
-    if (args.force && shouldForceLocalizeProjectIndex(root, host)) {
-      const inheritedIndexPath = resolveProjectIndexPath(root, runtimeConfig.scope, host);
-      stats = await withIndexLock(inheritedIndexPath, "force-index", async () => {
-        materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
-        refreshIndexerForDirectory(root, host, runtimeConfig);
-        indexer = getIndexerForProject(root, host);
-        return runIndex(indexer);
-      }, { completeRecoveries: false });
-    } else {
-      stats = await runIndex(indexer);
+    if (!parsed.currentPath) {
+      throw new Error("eval diff requires --current <current summary.json>");
+    }
+    parsed.againstPath = explicitAgainst;
+    const currentPath = parsed.currentPath;
+    if (!currentPath.endsWith(".json")) {
+      throw new Error("eval diff --current must point to a summary JSON file");
     }
-    return { kind: "stats", stats };
-  } catch (error) {
-    const busyResult = getIndexBusyResult(error);
-    if (!busyResult) throw error;
-    return busyResult;
-  }
-}
-async function getIndexStatus(projectRoot, host) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.getStatus();
-}
-async function getIndexHealthCheck(projectRoot, host) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.healthCheck();
-}
-async function runIndexHealthCheck(projectRoot, host) {
-  try {
-    return { kind: "health", health: await getIndexHealthCheck(projectRoot, host) };
-  } catch (error) {
-    const busyResult = getIndexBusyResult(error);
-    if (!busyResult) throw error;
-    return busyResult;
+    if (!parsed.againstPath.endsWith(".json")) {
+      throw new Error("eval diff --against must point to a summary JSON file");
+    }
+    const currentSummary = loadSummary(path21.resolve(parsed.projectRoot, currentPath), {
+      allowLegacyDiversityMetrics: true
+    });
+    const baselineSummary = loadSummary(path21.resolve(parsed.projectRoot, parsed.againstPath), {
+      allowLegacyDiversityMetrics: true
+    });
+    const comparison = compareSummaries(
+      currentSummary,
+      baselineSummary,
+      path21.resolve(parsed.projectRoot, parsed.againstPath)
+    );
+    const outputDir = createRunDirectory(path21.resolve(parsed.projectRoot, parsed.outputRoot));
+    const summaryMd = createSummaryMarkdown(currentSummary, comparison);
+    writeJson(path21.join(outputDir, "compare.json"), comparison);
+    writeText(path21.join(outputDir, "summary.md"), summaryMd);
+    writeJson(path21.join(outputDir, "summary.json"), currentSummary);
+    console.log(`Eval diff complete. Artifacts: ${outputDir}`);
+    return 0;
   }
+  throw new Error(`Unknown eval subcommand: ${subcommand}`);
 }
-async function getPrImpact(projectRoot, host, params) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  return indexer.getPrImpact({
-    pr: params.pr,
-    branch: params.branch,
-    maxDepth: params.maxDepth,
-    hubThreshold: params.hubThreshold,
-    checkConflicts: params.checkConflicts,
-    direction: params.direction
-  });
+
+// src/mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { readFileSync as readFileSync11 } from "fs";
+
+// src/mcp-server/register-prompts.ts
+import { z } from "zod";
+function registerMcpPrompts(server) {
+  server.prompt(
+    "search",
+    "Search codebase by meaning using semantic search",
+    { query: z.string().describe("What to search for in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Search the codebase for: "${args.query}"
+
+Use the codebase_search tool with this query. If you need just locations first, use codebase_peek instead to save tokens.`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "find",
+    "Find code using hybrid approach (semantic + grep)",
+    { query: z.string().describe("What to find in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Find code related to: "${args.query}"
+
+Use a hybrid approach:
+1. First use codebase_peek to find semantic matches by meaning
+2. Then use grep for exact identifier matches
+3. Combine results for comprehensive coverage`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "index",
+    "Index the codebase for semantic search",
+    { options: z.string().optional().describe("Options: 'force' to rebuild, 'estimate' to check costs") },
+    (args) => {
+      const opts = args.options?.toLowerCase() ?? "";
+      let instruction = "Use the index_codebase tool to index the codebase for semantic search.";
+      if (opts.includes("force")) {
+        instruction = "Use the index_codebase tool with force=true to rebuild the entire index from scratch.";
+      } else if (opts.includes("estimate")) {
+        instruction = "Use the index_codebase tool with estimateOnly=true to check the cost estimate before indexing.";
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: instruction }
+        }]
+      };
+    }
+  );
+  server.prompt(
+    "status",
+    "Check if the codebase is indexed and ready",
+    {},
+    () => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: "Use the index_status tool to check if the codebase index is ready and show its current state."
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "definition",
+    "Find where a symbol is defined in the codebase",
+    { query: z.string().describe("Symbol name or description to find the definition of") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Find the definition of: "${args.query}"
+
+Use the implementation_lookup tool to find where this symbol is defined. This prioritizes real implementation files over tests, docs, and examples. If no definition is found, fall back to codebase_search for broader discovery.`
+        }
+      }]
+    })
+  );
 }
-async function getIndexMetrics(projectRoot, host) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  const logger = indexer.getLogger();
-  if (!logger.isEnabled()) {
-    return {
-      enabled: false,
-      metricsEnabled: false,
-      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
-    };
+
+// src/mcp-server/register-tools.ts
+import { z as z2 } from "zod";
+
+// src/tools/format-pr-impact.ts
+function formatPrImpact(result) {
+  const lines = [];
+  lines.push(`\u2192 Files changed: ${result.changedFiles.length}`);
+  for (const file of result.changedFiles) {
+    lines.push(`  - ${file}`);
   }
-  if (!logger.isMetricsEnabled()) {
-    return {
-      enabled: true,
-      metricsEnabled: false,
-      text: 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
-    };
+  const directCount = result.directSymbols.length;
+  const transitiveCount = result.transitiveCallers.length;
+  const directionLabel = result.direction === "callees" ? "callees" : result.direction === "both" ? "reachable (callers + callees)" : "callers";
+  lines.push(
+    `\u2192 Symbols affected: ${result.totalAffected} (${directCount} direct, ${transitiveCount} transitive ${directionLabel})`
+  );
+  if (directCount > 0) {
+    lines.push(
+      `  Direct: ${result.directSymbols.map((s) => `${s.name} (${s.kind})`).join(", ")}`
+    );
   }
-  return {
-    enabled: true,
-    metricsEnabled: true,
-    text: logger.formatMetrics()
-  };
-}
-async function getIndexLogs(projectRoot, host, args) {
-  const indexer = getIndexerForProject(projectRoot, host);
-  const logger = indexer.getLogger();
-  if (!logger.isEnabled()) {
-    return {
-      kind: "disabled",
-      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```'
-    };
+  if (transitiveCount > 0) {
+    lines.push(
+      `  Transitive ${directionLabel}: ${result.transitiveCallers.map((s) => s.name).join(", ")}`
+    );
   }
-  let logs;
-  if (args.category) {
-    logs = logger.getLogsByCategory(args.category, args.limit);
-  } else if (args.level) {
-    logs = logger.getLogsByLevel(args.level, args.limit);
+  if (result.communities.length > 0) {
+    lines.push(
+      `\u2192 Communities touched: ${result.communities.map((c) => c.label).join(", ")}`
+    );
+    for (const community of result.communities) {
+      lines.push(
+        `  - ${community.label}: ${community.symbolCount} symbols`
+      );
+    }
   } else {
-    logs = logger.getLogs(args.limit);
+    lines.push("\u2192 Communities touched: none");
   }
-  if (logs.length === 0) {
-    return {
-      kind: "entries",
-      text: "No logs recorded yet. Logs are captured during indexing and search operations."
-    };
+  lines.push(`\u2192 Risk: ${result.riskLevel} \u2014 ${result.riskReason}`);
+  if (result.hubNodes.length > 0) {
+    lines.push("  Hub nodes in change scope:");
+    for (const hub of result.hubNodes) {
+      lines.push(`    - ${hub.name} (${hub.callerCount} callers) at ${hub.filePath}`);
+    }
   }
-  const text = 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 };
+  if (result.conflictingPRs && result.conflictingPRs.length > 0) {
+    const conflictList = result.conflictingPRs.map(
+      (c) => `PR #${c.pr} (also touches ${c.overlappingCommunities.join(", ")} community)`
+    );
+    lines.push(`\u2192 Potential conflicts with: ${conflictList.join(", ")}`);
+  }
+  return lines.join("\n");
 }
 
 // src/mcp-server/shared.ts
@@ -11955,66 +12608,27 @@ function allowNullAsUndefined(schema) {
 function registerMcpTools(server, runtime) {
   server.tool(
     "codebase_context",
-    "PREFERRED FIRST TOOL for any question about this repository. Use before built-in code search, grep, shell search, or broad file reads. Provide from+to for a dependency path, symbol for a definition, or only query for low-token conceptual discovery. Use call_graph directly for callers or callees.",
+    "PREFERRED FIRST TOOL for any question about this repository. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Use before built-in code search, grep, shell search, or broad file reads. Provide from+to for a dependency path, symbol for a definition, or only query for low-token conceptual discovery. Use call_graph directly for callers or callees.",
     {
       query: z2.string().describe("The codebase question or behavior to locate. Always provide the user's repository question here."),
       from: allowNullAsUndefined(z2.string().optional()).describe("Source symbol. For dependency-path questions, extract the first endpoint and provide it here."),
       to: allowNullAsUndefined(z2.string().optional()).describe("Target symbol. For dependency-path questions, extract the second endpoint and provide it here."),
       symbol: allowNullAsUndefined(z2.string().optional()).describe("Exact symbol for an authoritative definition lookup. Omit when from and to are supplied."),
-      limit: allowNullAsUndefined(z2.number().optional().default(10)).describe("Maximum number of search or definition results"),
-      maxDepth: allowNullAsUndefined(z2.number().optional().default(10)).describe("Maximum call-graph traversal depth for from/to path lookup"),
+      limit: allowNullAsUndefined(
+        z2.number().int().min(MIN_CONTEXT_RESULT_LIMIT).max(MAX_CONTEXT_RESULT_LIMIT).optional().default(10)
+      ).describe(`Maximum number of search or definition results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})`),
+      maxDepth: allowNullAsUndefined(
+        z2.number().int().min(MIN_CONTEXT_PATH_DEPTH).max(MAX_CONTEXT_PATH_DEPTH).optional().default(10)
+      ).describe(`Maximum call-graph traversal depth for from/to path lookup (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})`),
       fileType: allowNullAsUndefined(z2.string().optional()).describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-      directory: allowNullAsUndefined(z2.string().optional()).describe("Filter by directory path (e.g., 'src/utils', 'lib')")
+      directory: allowNullAsUndefined(z2.string().optional()).describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      tokenBudget: allowNullAsUndefined(
+        z2.number().int().min(MIN_CONTEXT_PACK_TOKEN_BUDGET).max(MAX_CONTEXT_PACK_TOKEN_BUDGET).optional().default(DEFAULT_CONTEXT_PACK_TOKEN_BUDGET)
+      ).describe(`Maximum response tokens for this context pack (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`)
     },
     async (args) => {
-      if (args.from && args.to) {
-        const path27 = await getCallGraphPath(runtime.projectRoot, runtime.host, args.from, args.to, args.maxDepth);
-        if (path27.length > 0) {
-          return { content: [{ type: "text", text: formatCallGraphPath(args.from, args.to, path27) }] };
-        }
-        const { callers } = await getCallGraphData(runtime.projectRoot, runtime.host, {
-          name: args.to,
-          direction: "callers"
-        });
-        const directEdge = callers.find((edge) => edge.fromSymbolName === args.from);
-        if (directEdge) {
-          const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
-          return {
-            content: [{
-              type: "text",
-              text: `Direct path: ${args.from} --${directEdge.callType}--> ${args.to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`
-            }]
-          };
-        }
-        return { content: [{ type: "text", text: formatCallGraphPath(args.from, args.to, path27) }] };
-      }
-      if (args.symbol) {
-        const results2 = await implementationLookup(runtime.projectRoot, runtime.host, args.symbol, {
-          limit: args.limit ?? 10,
-          fileType: args.fileType,
-          directory: args.directory
-        });
-        return { content: [{ type: "text", text: formatDefinitionLookup(results2, args.symbol) }] };
-      }
-      const results = await searchCodebase(runtime.projectRoot, runtime.host, args.query, {
-        limit: args.limit ?? 10,
-        fileType: args.fileType,
-        directory: args.directory,
-        metadataOnly: true
-      });
-      if (results.length === 0) {
-        return { content: [{ type: "text", text: "No matching code found. Try a different query or run index_codebase first." }] };
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `Found ${results.length} locations for "${args.query}":
-
-${formatCodebasePeek(results)}
-
-Use implementation_lookup for an authoritative definition, or call call_graph/call_graph_path once you have a symbol.`
-        }]
-      };
+      const result = await resolveCodebaseContext(runtime.projectRoot, runtime.host, args);
+      return { content: [{ type: "text", text: result.text }] };
     }
   );
   server.tool(
@@ -12268,7 +12882,7 @@ ${formatSearchResults(results)}` }] };
 // src/mcp-server.ts
 function getServerInstructions(host) {
   const hostText = `host ${host}`;
-  return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns low-token locations first and routes to definitions or call-graph helpers when symbol intent is present. Use codebase_peek for direct conceptual location lookup, implementation_lookup for known-symbol definition questions, and codebase_search only when full semantic code content is needed. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
+  return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns a token-budgeted location pack and routes to definitions or call-graph helpers when symbol intent is present. Keep the default tokenBudget for normal discovery, then use implementation_lookup, codebase_search, or a targeted file read only for selected locations that need source content. Use codebase_peek for direct conceptual location lookup. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
 }
 function getPackageVersion() {
   const raw = JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf-8"));