opencode-codebase-index 0.6.0 → 0.7.0

package/dist/cli.js

@@ -487,7 +487,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path10, checkUnignored, mode) {
+      test(path11, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -496,7 +496,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path10);
+          const matched = rule[mode].test(path11);
           if (!matched) {
             return;
           }
@@ -517,17 +517,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path10, originalPath, doThrow) => {
-      if (!isString(path10)) {
+    var checkPath = (path11, originalPath, doThrow) => {
+      if (!isString(path11)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path10) {
+      if (!path11) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path10)) {
+      if (checkPath.isNotRelative(path11)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -536,7 +536,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+    var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -566,19 +566,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path10 = originalPath && checkPath.convert(originalPath);
+        const path11 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path10,
+          path11,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path10, cache, checkUnignored, slices);
+        return this._t(path11, cache, checkUnignored, slices);
       }
-      checkIgnore(path10) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path10)) {
-          return this.test(path10);
+      checkIgnore(path11) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path11)) {
+          return this.test(path11);
         }
-        const slices = path10.split(SLASH).filter(Boolean);
+        const slices = path11.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -591,18 +591,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path10, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path11, false, MODE_CHECK_IGNORE);
       }
-      _t(path10, cache, checkUnignored, slices) {
-        if (path10 in cache) {
-          return cache[path10];
+      _t(path11, cache, checkUnignored, slices) {
+        if (path11 in cache) {
+          return cache[path11];
         }
         if (!slices) {
-          slices = path10.split(SLASH).filter(Boolean);
+          slices = path11.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path10] = this._rules.test(path10, checkUnignored, MODE_IGNORE);
+          return cache[path11] = this._rules.test(path11, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -610,29 +610,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path10] = parent.ignored ? parent : this._rules.test(path10, checkUnignored, MODE_IGNORE);
+        return cache[path11] = parent.ignored ? parent : this._rules.test(path11, checkUnignored, MODE_IGNORE);
       }
-      ignores(path10) {
-        return this._test(path10, this._ignoreCache, false).ignored;
+      ignores(path11) {
+        return this._test(path11, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path10) => !this.ignores(path10);
+        return (path11) => !this.ignores(path11);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path10) {
-        return this._test(path10, this._testCache, true);
+      test(path11) {
+        return this._test(path11, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path10) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+      checkPath.isNotRelative = (path11) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -649,9 +649,7 @@ var require_ignore = __commonJS({
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
-import * as path9 from "path";
-import * as os4 from "os";
+import * as path10 from "path";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -664,13 +662,15 @@ var DEFAULT_INCLUDE = [
   "**/*.{sql,graphql,proto}",
   "**/*.{yaml,yml,toml}",
   "**/*.{md,mdx}",
-  "**/*.{sh,bash,zsh}"
+  "**/*.{sh,bash,zsh}",
+  "**/*.{txt,html,htm}"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
   "**/.git/**",
   "**/dist/**",
   "**/build/**",
+  "**/*build*/**",
   "**/*.min.js",
   "**/*.bundle.js",
   "**/vendor/**",
@@ -679,7 +679,9 @@ var DEFAULT_EXCLUDE = [
   "**/coverage/**",
   "**/.next/**",
   "**/.nuxt/**",
-  "**/.opencode/**"
+  "**/.opencode/**",
+  "**/.*",
+  "**/.*/**"
 ];
 var EMBEDDING_MODELS = {
   "google": {
@@ -754,6 +756,27 @@ var DEFAULT_PROVIDER_MODELS = {
   "ollama": "nomic-embed-text"
 };
 
+// src/config/env-substitution.ts
+var ENV_REFERENCE_PATTERN = /^\{env:([A-Z_][A-Z0-9_]*)\}$/;
+var ENV_REFERENCE_LIKE_PATTERN = /\{env:[^}]+\}/;
+function substituteEnvString(value, keyPath) {
+  const match = value.match(ENV_REFERENCE_PATTERN);
+  if (!match) {
+    if (ENV_REFERENCE_LIKE_PATTERN.test(value)) {
+      throw new Error(
+        `Invalid environment variable reference at '${keyPath}'. Expected the entire string to match '{env:VAR_NAME}' with VAR_NAME matching [A-Z_][A-Z0-9_]*.`
+      );
+    }
+    return value;
+  }
+  const variableName = match[1];
+  const envValue = process.env[variableName];
+  if (envValue === void 0) {
+    throw new Error(`Missing environment variable '${variableName}' referenced by config at '${keyPath}'.`);
+  }
+  return envValue;
+}
+
 // src/config/schema.ts
 function getDefaultIndexingConfig() {
   return {
@@ -767,7 +790,10 @@ function getDefaultIndexingConfig() {
     autoGc: true,
     gcIntervalDays: 7,
     gcOrphanThreshold: 100,
-    requireProjectMarker: true
+    requireProjectMarker: true,
+    maxDepth: 5,
+    maxFilesPerDirectory: 100,
+    fallbackToTextOnMaxChunks: true
   };
 }
 function getDefaultSearchConfig() {
@@ -779,12 +805,26 @@ function getDefaultSearchConfig() {
     fusionStrategy: "rrf",
     rrfK: 60,
     rerankTopN: 20,
-    contextLines: 0
+    contextLines: 0,
+    routingHints: true
   };
 }
 function isValidFusionStrategy(value) {
   return value === "weighted" || value === "rrf";
 }
+function isValidRerankerProvider(value) {
+  return value === "cohere" || value === "jina" || value === "custom";
+}
+function getDefaultRerankerBaseUrl(provider) {
+  switch (provider) {
+    case "cohere":
+      return "https://api.cohere.ai/v1";
+    case "jina":
+      return "https://api.jina.ai/v1";
+    case "custom":
+      return "";
+  }
+}
 function getDefaultDebugConfig() {
   return {
     enabled: false,
@@ -811,11 +851,27 @@ function isValidScope(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function getResolvedString(value, keyPath) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  return substituteEnvString(value, keyPath);
+}
+function getResolvedStringArray(value, keyPath) {
+  if (!isStringArray(value)) {
+    return void 0;
+  }
+  return value.map((item, index) => substituteEnvString(item, `${keyPath}[${index}]`));
+}
 function isValidLogLevel(value) {
   return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
 }
 function parseConfig(raw) {
   const input = raw && typeof raw === "object" ? raw : {};
+  const embeddingProviderValue = getResolvedString(input.embeddingProvider, "$root.embeddingProvider");
+  const scopeValue = getResolvedString(input.scope, "$root.scope");
+  const includeValue = getResolvedStringArray(input.include, "$root.include");
+  const excludeValue = getResolvedStringArray(input.exclude, "$root.exclude");
   const defaultIndexing = getDefaultIndexingConfig();
   const defaultSearch = getDefaultSearchConfig();
   const defaultDebug = getDefaultDebugConfig();
@@ -831,7 +887,10 @@ function parseConfig(raw) {
     autoGc: typeof rawIndexing.autoGc === "boolean" ? rawIndexing.autoGc : defaultIndexing.autoGc,
     gcIntervalDays: typeof rawIndexing.gcIntervalDays === "number" ? Math.max(1, rawIndexing.gcIntervalDays) : defaultIndexing.gcIntervalDays,
     gcOrphanThreshold: typeof rawIndexing.gcOrphanThreshold === "number" ? Math.max(0, rawIndexing.gcOrphanThreshold) : defaultIndexing.gcOrphanThreshold,
-    requireProjectMarker: typeof rawIndexing.requireProjectMarker === "boolean" ? rawIndexing.requireProjectMarker : defaultIndexing.requireProjectMarker
+    requireProjectMarker: typeof rawIndexing.requireProjectMarker === "boolean" ? rawIndexing.requireProjectMarker : defaultIndexing.requireProjectMarker,
+    maxDepth: typeof rawIndexing.maxDepth === "number" ? rawIndexing.maxDepth < -1 ? -1 : rawIndexing.maxDepth : defaultIndexing.maxDepth,
+    maxFilesPerDirectory: typeof rawIndexing.maxFilesPerDirectory === "number" ? Math.max(1, rawIndexing.maxFilesPerDirectory) : defaultIndexing.maxFilesPerDirectory,
+    fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks
   };
   const rawSearch = input.search && typeof input.search === "object" ? input.search : {};
   const search = {
@@ -842,7 +901,8 @@ function parseConfig(raw) {
     fusionStrategy: isValidFusionStrategy(rawSearch.fusionStrategy) ? rawSearch.fusionStrategy : defaultSearch.fusionStrategy,
     rrfK: typeof rawSearch.rrfK === "number" ? Math.max(1, Math.floor(rawSearch.rrfK)) : defaultSearch.rrfK,
     rerankTopN: typeof rawSearch.rerankTopN === "number" ? Math.min(200, Math.max(0, Math.floor(rawSearch.rerankTopN))) : defaultSearch.rerankTopN,
-    contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines
+    contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines,
+    routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
   const debug = {
@@ -855,22 +915,31 @@ function parseConfig(raw) {
     logBranch: typeof rawDebug.logBranch === "boolean" ? rawDebug.logBranch : defaultDebug.logBranch,
     metrics: typeof rawDebug.metrics === "boolean" ? rawDebug.metrics : defaultDebug.metrics
   };
+  const rawKnowledgeBases = input.knowledgeBases;
+  const knowledgeBases = isStringArray(rawKnowledgeBases) ? rawKnowledgeBases.filter((p) => typeof p === "string" && p.trim().length > 0).map((p) => p.trim()) : [];
+  const rawAdditionalInclude = input.additionalInclude;
+  const additionalInclude = isStringArray(rawAdditionalInclude) ? rawAdditionalInclude.filter((p) => typeof p === "string" && p.trim().length > 0).map((p) => p.trim()) : [];
   let embeddingProvider;
   let embeddingModel = void 0;
   let customProvider = void 0;
-  if (input.embeddingProvider === "custom") {
+  let reranker = void 0;
+  if (embeddingProviderValue === "custom") {
     embeddingProvider = "custom";
     const rawCustom = input.customProvider && typeof input.customProvider === "object" ? input.customProvider : null;
-    if (rawCustom && typeof rawCustom.baseUrl === "string" && rawCustom.baseUrl.trim().length > 0 && typeof rawCustom.model === "string" && rawCustom.model.trim().length > 0 && typeof rawCustom.dimensions === "number" && Number.isInteger(rawCustom.dimensions) && rawCustom.dimensions > 0) {
+    const baseUrlValue = getResolvedString(rawCustom?.baseUrl, "$root.customProvider.baseUrl");
+    const modelValue = getResolvedString(rawCustom?.model, "$root.customProvider.model");
+    const apiKeyValue = getResolvedString(rawCustom?.apiKey, "$root.customProvider.apiKey");
+    if (rawCustom && typeof baseUrlValue === "string" && baseUrlValue.trim().length > 0 && typeof modelValue === "string" && modelValue.trim().length > 0 && typeof rawCustom.dimensions === "number" && Number.isInteger(rawCustom.dimensions) && rawCustom.dimensions > 0) {
       customProvider = {
-        baseUrl: rawCustom.baseUrl.trim().replace(/\/+$/, ""),
-        model: rawCustom.model,
+        baseUrl: baseUrlValue.trim().replace(/\/+$/, ""),
+        model: modelValue,
         dimensions: rawCustom.dimensions,
-        apiKey: typeof rawCustom.apiKey === "string" ? rawCustom.apiKey : void 0,
+        apiKey: apiKeyValue,
         maxTokens: typeof rawCustom.maxTokens === "number" ? rawCustom.maxTokens : void 0,
         timeoutMs: typeof rawCustom.timeoutMs === "number" ? Math.max(1e3, rawCustom.timeoutMs) : void 0,
         concurrency: typeof rawCustom.concurrency === "number" ? Math.max(1, Math.floor(rawCustom.concurrency)) : void 0,
-        requestIntervalMs: typeof rawCustom.requestIntervalMs === "number" ? Math.max(0, Math.floor(rawCustom.requestIntervalMs)) : void 0
+        requestIntervalMs: typeof rawCustom.requestIntervalMs === "number" ? Math.max(0, Math.floor(rawCustom.requestIntervalMs)) : void 0,
+        maxBatchSize: typeof rawCustom.maxBatchSize === "number" ? Math.max(1, Math.floor(rawCustom.maxBatchSize)) : typeof rawCustom.max_batch_size === "number" ? Math.max(1, Math.floor(rawCustom.max_batch_size)) : void 0
       };
       if (!/\/v\d+\/?$/.test(customProvider.baseUrl)) {
         console.warn(
@@ -882,24 +951,60 @@ function parseConfig(raw) {
         "embeddingProvider is 'custom' but customProvider config is missing or invalid. Required fields: baseUrl (string), model (string), dimensions (positive integer)."
       );
     }
-  } else if (isValidProvider(input.embeddingProvider)) {
-    embeddingProvider = input.embeddingProvider;
-    if (input.embeddingModel) {
-      embeddingModel = isValidModel(input.embeddingModel, embeddingProvider) ? input.embeddingModel : DEFAULT_PROVIDER_MODELS[embeddingProvider];
+  } else if (isValidProvider(embeddingProviderValue)) {
+    embeddingProvider = embeddingProviderValue;
+    const rawEmbeddingModel = input.embeddingModel;
+    if (typeof rawEmbeddingModel === "string") {
+      const embeddingModelValue = substituteEnvString(rawEmbeddingModel, "$root.embeddingModel");
+      if (embeddingModelValue) {
+        embeddingModel = isValidModel(embeddingModelValue, embeddingProvider) ? embeddingModelValue : DEFAULT_PROVIDER_MODELS[embeddingProvider];
+      }
+    } else if (rawEmbeddingModel) {
+      embeddingModel = DEFAULT_PROVIDER_MODELS[embeddingProvider];
     }
   } else {
     embeddingProvider = "auto";
   }
+  const rawReranker = input.reranker && typeof input.reranker === "object" ? input.reranker : {};
+  const rerankerEnabled = typeof rawReranker.enabled === "boolean" ? rawReranker.enabled : false;
+  if (rerankerEnabled) {
+    const provider = isValidRerankerProvider(rawReranker.provider) ? rawReranker.provider : "custom";
+    const model = getResolvedString(rawReranker.model, "$root.reranker.model");
+    if (!model || model.trim().length === 0) {
+      throw new Error("reranker is enabled but reranker.model is missing or invalid.");
+    }
+    const configuredBaseUrl = getResolvedString(rawReranker.baseUrl, "$root.reranker.baseUrl");
+    const baseUrl = configuredBaseUrl?.trim() || getDefaultRerankerBaseUrl(provider);
+    if (baseUrl.length === 0) {
+      throw new Error("reranker is enabled but reranker.baseUrl is missing or invalid for provider 'custom'.");
+    }
+    const apiKey = getResolvedString(rawReranker.apiKey, "$root.reranker.apiKey");
+    if ((provider === "cohere" || provider === "jina") && (!apiKey || apiKey.trim().length === 0)) {
+      throw new Error(`reranker provider '${provider}' requires reranker.apiKey when enabled.`);
+    }
+    reranker = {
+      enabled: true,
+      provider,
+      model: model.trim(),
+      baseUrl: baseUrl.replace(/\/+$/, ""),
+      apiKey: apiKey?.trim() || void 0,
+      topN: typeof rawReranker.topN === "number" ? Math.min(50, Math.max(1, Math.floor(rawReranker.topN))) : 15,
+      timeoutMs: typeof rawReranker.timeoutMs === "number" ? Math.max(1e3, Math.floor(rawReranker.timeoutMs)) : 1e4
+    };
+  }
   return {
     embeddingProvider,
     embeddingModel,
     customProvider,
-    scope: isValidScope(input.scope) ? input.scope : "project",
-    include: isStringArray(input.include) ? input.include : DEFAULT_INCLUDE,
-    exclude: isStringArray(input.exclude) ? input.exclude : DEFAULT_EXCLUDE,
+    scope: isValidScope(scopeValue) ? scopeValue : "project",
+    include: includeValue ?? DEFAULT_INCLUDE,
+    exclude: excludeValue ?? DEFAULT_EXCLUDE,
+    additionalInclude,
     indexing,
     search,
-    debug
+    debug,
+    reranker,
+    knowledgeBases
   };
 }
 function getDefaultModelForProvider(provider) {
@@ -933,6 +1038,8 @@ function compareSummaries(current, baseline, againstPath) {
       hitAt10: metricDelta(current.metrics.hitAt10, baseline.metrics.hitAt10),
       mrrAt10: metricDelta(current.metrics.mrrAt10, baseline.metrics.mrrAt10),
       ndcgAt10: metricDelta(current.metrics.ndcgAt10, baseline.metrics.ndcgAt10),
+      distinctTop3Ratio: metricDelta(current.metrics.distinctTop3Ratio, baseline.metrics.distinctTop3Ratio),
+      rawDistinctTop3Ratio: metricDelta(current.metrics.rawDistinctTop3Ratio, baseline.metrics.rawDistinctTop3Ratio),
       latencyP50Ms: metricDelta(current.metrics.latencyMs.p50, baseline.metrics.latencyMs.p50),
       latencyP95Ms: metricDelta(current.metrics.latencyMs.p95, baseline.metrics.latencyMs.p95),
       latencyP99Ms: metricDelta(current.metrics.latencyMs.p99, baseline.metrics.latencyMs.p99),
@@ -951,6 +1058,35 @@ function compareSummaries(current, baseline, againstPath) {
 // src/eval/reports.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
+function assertFiniteNumber(value, path11) {
+  if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
+    throw new Error(`${path11} must be a finite number`);
+  }
+  return value;
+}
+function validateSummary(summary, summaryPath, options) {
+  assertFiniteNumber(summary.metrics.hitAt1, `${summaryPath}.metrics.hitAt1`);
+  assertFiniteNumber(summary.metrics.hitAt3, `${summaryPath}.metrics.hitAt3`);
+  assertFiniteNumber(summary.metrics.hitAt5, `${summaryPath}.metrics.hitAt5`);
+  assertFiniteNumber(summary.metrics.hitAt10, `${summaryPath}.metrics.hitAt10`);
+  assertFiniteNumber(summary.metrics.mrrAt10, `${summaryPath}.metrics.mrrAt10`);
+  assertFiniteNumber(summary.metrics.ndcgAt10, `${summaryPath}.metrics.ndcgAt10`);
+  const metrics = summary.metrics;
+  if (metrics.distinctTop3Ratio === void 0 && options?.allowLegacyDiversityMetrics) {
+    metrics.distinctTop3Ratio = 0;
+  }
+  if (metrics.rawDistinctTop3Ratio === void 0 && options?.allowLegacyDiversityMetrics) {
+    metrics.rawDistinctTop3Ratio = 0;
+  }
+  assertFiniteNumber(metrics.distinctTop3Ratio, `${summaryPath}.metrics.distinctTop3Ratio`);
+  assertFiniteNumber(metrics.rawDistinctTop3Ratio, `${summaryPath}.metrics.rawDistinctTop3Ratio`);
+  assertFiniteNumber(summary.metrics.latencyMs.p50, `${summaryPath}.metrics.latencyMs.p50`);
+  assertFiniteNumber(summary.metrics.latencyMs.p95, `${summaryPath}.metrics.latencyMs.p95`);
+  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`);
+  return summary;
+}
 function formatPct(value) {
   return `${(value * 100).toFixed(2)}%`;
 }
@@ -964,9 +1100,9 @@ function signed(value, digits = 4) {
   const formatted = value.toFixed(digits);
   return value > 0 ? `+${formatted}` : formatted;
 }
-function loadSummary(summaryPath) {
+function loadSummary(summaryPath, options) {
   const raw = readFileSync(summaryPath, "utf-8");
-  return JSON.parse(raw);
+  return validateSummary(JSON.parse(raw), summaryPath, options);
 }
 function createRunDirectory(outputRoot, timestampOverride) {
   const timestamp = (timestampOverride ?? (/* @__PURE__ */ new Date()).toISOString()).replace(/[:.]/g, "-");
@@ -1001,6 +1137,8 @@ function createSummaryMarkdown(summary, comparison, gate, sweep) {
   lines.push(`| Hit@10 | ${formatPct(summary.metrics.hitAt10)} |`);
   lines.push(`| MRR@10 | ${summary.metrics.mrrAt10.toFixed(4)} |`);
   lines.push(`| nDCG@10 | ${summary.metrics.ndcgAt10.toFixed(4)} |`);
+  lines.push(`| Distinct Top@3 | ${formatPct(summary.metrics.distinctTop3Ratio)} |`);
+  lines.push(`| Raw Distinct Top@3 | ${formatPct(summary.metrics.rawDistinctTop3Ratio)} |`);
   lines.push(`| Latency p50 | ${formatMs(summary.metrics.latencyMs.p50)} |`);
   lines.push(`| Latency p95 | ${formatMs(summary.metrics.latencyMs.p95)} |`);
   lines.push(`| Latency p99 | ${formatMs(summary.metrics.latencyMs.p99)} |`);
@@ -1041,6 +1179,12 @@ function createSummaryMarkdown(summary, comparison, gate, sweep) {
     lines.push(
       `| nDCG@10 | ${comparison.deltas.ndcgAt10.baseline.toFixed(4)} | ${comparison.deltas.ndcgAt10.current.toFixed(4)} | ${signed(comparison.deltas.ndcgAt10.absolute)} |`
     );
+    lines.push(
+      `| Distinct Top@3 | ${formatPct(comparison.deltas.distinctTop3Ratio.baseline)} | ${formatPct(comparison.deltas.distinctTop3Ratio.current)} | ${signed(comparison.deltas.distinctTop3Ratio.absolute)} |`
+    );
+    lines.push(
+      `| Raw Distinct Top@3 | ${formatPct(comparison.deltas.rawDistinctTop3Ratio.baseline)} | ${formatPct(comparison.deltas.rawDistinctTop3Ratio.current)} | ${signed(comparison.deltas.rawDistinctTop3Ratio.absolute)} |`
+    );
     lines.push(
       `| p95 latency (ms) | ${comparison.deltas.latencyP95Ms.baseline.toFixed(3)} | ${comparison.deltas.latencyP95Ms.current.toFixed(3)} | ${signed(comparison.deltas.latencyP95Ms.absolute, 3)} |`
     );
@@ -1124,7 +1268,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve5, reject) => {
+  const wrappedPromise = new Promise((resolve6, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -1138,7 +1282,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve5, reject);
+    promise.then(resolve6, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1146,7 +1290,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve5(fallback());
+          resolve6(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1156,7 +1300,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve5();
+        resolve6();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1220,6 +1364,17 @@ var PriorityQueue = class {
     const [item] = this.#queue.splice(index, 1);
     this.enqueue(item.run, { priority, id });
   }
+  remove(idOrRun) {
+    const index = this.#queue.findIndex((element) => {
+      if (typeof idOrRun === "string") {
+        return element.id === idOrRun;
+      }
+      return element.run === idOrRun;
+    });
+    if (index !== -1) {
+      this.#queue.splice(index, 1);
+    }
+  }
   dequeue() {
     const item = this.#queue.shift();
     return item?.run;
@@ -1259,6 +1414,7 @@ var PQueue = class extends import_index.default {
   #idAssigner = 1n;
   // Track currently running tasks for debugging
   #runningTasks = /* @__PURE__ */ new Map();
+  #queueAbortListenerCleanupFunctions = /* @__PURE__ */ new Set();
   /**
       Get or set the default timeout for all tasks. Can be changed at runtime.
   
@@ -1546,9 +1702,11 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
-      this.#queue.enqueue(async () => {
+      let cleanupQueueAbortHandler = () => void 0;
+      const run = async () => {
+        cleanupQueueAbortHandler();
         this.#pending++;
         this.#runningTasks.set(taskSymbol, {
           id: options.id,
@@ -1584,7 +1742,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve5(result);
+          resolve6(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1598,7 +1756,35 @@ var PQueue = class extends import_index.default {
             this.#next();
           });
         }
-      }, options);
+      };
+      this.#queue.enqueue(run, options);
+      const removeQueuedTask = () => {
+        if (this.#queue instanceof PriorityQueue) {
+          this.#queue.remove(run);
+          return;
+        }
+        this.#queue.remove?.(options.id);
+      };
+      if (options.signal) {
+        const { signal } = options;
+        const queueAbortHandler = () => {
+          cleanupQueueAbortHandler();
+          removeQueuedTask();
+          reject(signal.reason);
+          this.#tryToStartAnother();
+          this.emit("next");
+        };
+        cleanupQueueAbortHandler = () => {
+          signal.removeEventListener("abort", queueAbortHandler);
+          this.#queueAbortListenerCleanupFunctions.delete(cleanupQueueAbortHandler);
+        };
+        if (signal.aborted) {
+          queueAbortHandler();
+          return;
+        }
+        signal.addEventListener("abort", queueAbortHandler, { once: true });
+        this.#queueAbortListenerCleanupFunctions.add(cleanupQueueAbortHandler);
+      }
       this.emit("add");
       this.#tryToStartAnother();
     });
@@ -1627,6 +1813,9 @@ var PQueue = class extends import_index.default {
   Clear the queue.
   */
   clear() {
+    for (const cleanupQueueAbortHandler of this.#queueAbortListenerCleanupFunctions) {
+      cleanupQueueAbortHandler();
+    }
     this.#queue = new this.#queueClass();
     this.#clearIntervalTimer();
     this.#updateRateLimitState();
@@ -1741,13 +1930,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve5();
+        resolve6();
       };
       this.on(event, listener);
     });
@@ -1906,8 +2095,6 @@ var isError = (value) => objectToString.call(value) === "[object Error]";
 var errorMessages = /* @__PURE__ */ new Set([
   "network error",
   // Chrome
-  "Failed to fetch",
-  // Chrome
   "NetworkError when attempting to fetch resource.",
   // Firefox
   "The Internet connection appears to be offline.",
@@ -1935,6 +2122,9 @@ function isNetworkError(error) {
   if (message.startsWith("error sending request for url")) {
     return true;
   }
+  if (message === "Failed to fetch" || message.startsWith("Failed to fetch (") && message.endsWith(")")) {
+    return true;
+  }
   return errorMessages.has(message);
 }
 
@@ -2032,7 +2222,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2040,7 +2230,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve5();
+        resolve6();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -2268,7 +2458,8 @@ function createCustomProviderInfo(config) {
       dimensions: config.dimensions,
       maxTokens: config.maxTokens ?? 8192,
       costPer1MTokens: 0,
-      timeoutMs: config.timeoutMs ?? 3e4
+      timeoutMs: config.timeoutMs ?? 3e4,
+      maxBatchSize: config.maxBatchSize
     }
   };
 }
@@ -2531,21 +2722,24 @@ var CustomEmbeddingProvider = class {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  async embedQuery(query) {
-    const result = await this.embedBatch([query]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
-    };
-  }
-  async embedDocument(document) {
-    const result = await this.embedBatch([document]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
-    };
+  splitIntoRequestBatches(texts) {
+    const maxBatchSize = this.modelInfo.maxBatchSize;
+    if (!maxBatchSize || texts.length <= maxBatchSize) {
+      return [texts];
+    }
+    const batches = [];
+    for (let i = 0; i < texts.length; i += maxBatchSize) {
+      batches.push(texts.slice(i, i + maxBatchSize));
+    }
+    return batches;
   }
-  async embedBatch(texts) {
+  async embedRequest(texts) {
+    if (texts.length === 0) {
+      return {
+        embeddings: [],
+        totalTokensUsed: 0
+      };
+    }
     const headers = {
       "Content-Type": "application/json"
     };
@@ -2606,11 +2800,115 @@ var CustomEmbeddingProvider = class {
     }
     throw new Error("Custom embedding API returned unexpected response format. Expected OpenAI-compatible format with data[].embedding.");
   }
+  async embedQuery(query) {
+    const result = await this.embedBatch([query]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedDocument(document) {
+    const result = await this.embedBatch([document]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedBatch(texts) {
+    const requestBatches = this.splitIntoRequestBatches(texts);
+    const embeddings = [];
+    let totalTokensUsed = 0;
+    for (const batch of requestBatches) {
+      const result = await this.embedRequest(batch);
+      embeddings.push(...result.embeddings);
+      totalTokensUsed += result.totalTokensUsed;
+    }
+    return {
+      embeddings,
+      totalTokensUsed
+    };
+  }
   getModelInfo() {
     return this.modelInfo;
   }
 };
 
+// src/rerank/index.ts
+function createReranker(config) {
+  if (!config.enabled) {
+    return new NoOpReranker();
+  }
+  return new SiliconFlowReranker(config);
+}
+var NoOpReranker = class {
+  isAvailable() {
+    return false;
+  }
+  async rerank(_query, documents, _topN) {
+    return {
+      results: documents.map((_, index) => ({ index, relevanceScore: 0 }))
+    };
+  }
+};
+var SiliconFlowReranker = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  isAvailable() {
+    return this.config.enabled && !!this.config.baseUrl && !!this.config.model;
+  }
+  async rerank(query, documents, topN) {
+    if (documents.length === 0) {
+      return { results: [] };
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const baseUrl = this.config.baseUrl ?? "https://api.siliconflow.cn/v1";
+    const timeoutMs = this.config.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}/rerank`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: this.config.model,
+          query,
+          documents,
+          top_n: topN ?? this.config.topN ?? 20,
+          return_documents: false
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Rerank API error: ${response.status} - ${errorText}`);
+      }
+      const data = await response.json();
+      return {
+        results: data.results.map((r) => ({
+          index: r.index,
+          relevanceScore: r.relevance_score,
+          document: r.document?.text
+        })),
+        tokensUsed: data.meta?.tokens?.input_tokens
+      };
+    } catch (error) {
+      clearTimeout(timeout);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Rerank API request timed out after ${timeoutMs}ms`);
+      }
+      throw error;
+    }
+  }
+};
+
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
 import { existsSync as existsSync2, readFileSync as readFileSync3, promises as fsPromises } from "fs";
@@ -2628,7 +2926,11 @@ function createIgnoreFilter(projectRoot) {
     "__pycache__",
     "target",
     "vendor",
-    ".opencode"
+    ".opencode",
+    ".*",
+    "**/.*",
+    "**/.*/**",
+    "**/*build*/**"
   ];
   ig.add(defaultIgnores);
   const gitignorePath = path3.join(projectRoot, ".gitignore");
@@ -2639,18 +2941,37 @@ function createIgnoreFilter(projectRoot) {
   return ig;
 }
 function matchGlob(filePath, pattern) {
-  let regexPattern = pattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<DOUBLESTAR>>>/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, p1) => `(${p1.split(",").join("|")})`);
+  if (pattern.startsWith("**/")) {
+    const withoutPrefix = pattern.slice(3);
+    if (withoutPrefix && matchGlob(filePath, withoutPrefix)) {
+      return true;
+    }
+  }
+  const escapedPattern = pattern.replace(/[.+^$()|[\]\\]/g, "\\$&");
+  let regexPattern = escapedPattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<DOUBLESTAR>>>/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, p1) => `(${p1.split(",").join("|")})`);
   if (regexPattern.startsWith(".*/")) {
     regexPattern = `(.*\\/)?${regexPattern.slice(3)}`;
   }
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filePath);
 }
-async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped) {
+async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped, options, currentDepth = 0) {
   const entries = await fsPromises.readdir(dir, { withFileTypes: true });
+  const filesInDir = [];
+  const subdirs = [];
   for (const entry of entries) {
     const fullPath = path3.join(dir, entry.name);
     const relativePath = path3.relative(projectRoot, fullPath);
+    if (entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..") {
+      if (entry.isDirectory()) {
+        skipped.push({ path: relativePath, reason: "excluded" });
+      }
+      continue;
+    }
+    if (entry.isDirectory() && entry.name.toLowerCase().includes("build")) {
+      skipped.push({ path: relativePath, reason: "excluded" });
+      continue;
+    }
     if (ignoreFilter.ignores(relativePath)) {
       if (entry.isFile()) {
         skipped.push({ path: relativePath, reason: "gitignore" });
@@ -2658,15 +2979,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
       continue;
     }
     if (entry.isDirectory()) {
-      yield* walkDirectory(
-        fullPath,
-        projectRoot,
-        includePatterns,
-        excludePatterns,
-        ignoreFilter,
-        maxFileSize,
-        skipped
-      );
+      subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
       const stat = await fsPromises.stat(fullPath);
       if (stat.size > maxFileSize) {
@@ -2687,12 +3000,37 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         }
       }
       if (matched) {
-        yield { path: fullPath, size: stat.size };
+        filesInDir.push({ path: fullPath, size: stat.size });
       }
     }
   }
+  filesInDir.sort((a, b) => a.size - b.size);
+  const limitedFiles = filesInDir.slice(0, options.maxFilesPerDirectory);
+  for (const f of limitedFiles) {
+    yield f;
+  }
+  for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
+    skipped.push({ path: path3.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+  }
+  const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
+  if (canRecurse) {
+    for (const sub of subdirs) {
+      yield* walkDirectory(
+        sub.fullPath,
+        projectRoot,
+        includePatterns,
+        excludePatterns,
+        ignoreFilter,
+        maxFileSize,
+        skipped,
+        options,
+        currentDepth + 1
+      );
+    }
+  }
 }
-async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFileSize) {
+async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFileSize, additionalRoots, walkOptions) {
+  const opts = walkOptions ?? { maxDepth: 5, maxFilesPerDirectory: 100 };
   const ignoreFilter = createIgnoreFilter(projectRoot);
   const files = [];
   const skipped = [];
@@ -2703,10 +3041,46 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
     excludePatterns,
     ignoreFilter,
     maxFileSize,
-    skipped
+    skipped,
+    opts,
+    0
   )) {
     files.push(file);
   }
+  if (additionalRoots && additionalRoots.length > 0) {
+    const normalizedRoots = /* @__PURE__ */ new Set();
+    for (const kbRoot of additionalRoots) {
+      const resolved = path3.normalize(
+        path3.isAbsolute(kbRoot) ? kbRoot : path3.resolve(projectRoot, kbRoot)
+      );
+      normalizedRoots.add(resolved);
+    }
+    for (const resolvedKbRoot of normalizedRoots) {
+      try {
+        const stat = await fsPromises.stat(resolvedKbRoot);
+        if (!stat.isDirectory()) {
+          skipped.push({ path: resolvedKbRoot, reason: "excluded" });
+          continue;
+        }
+        const kbIgnoreFilter = createIgnoreFilter(resolvedKbRoot);
+        for await (const file of walkDirectory(
+          resolvedKbRoot,
+          resolvedKbRoot,
+          includePatterns,
+          excludePatterns,
+          kbIgnoreFilter,
+          maxFileSize,
+          skipped,
+          opts,
+          0
+        )) {
+          files.push(file);
+        }
+      } catch {
+        skipped.push({ path: resolvedKbRoot, reason: "excluded" });
+      }
+    }
+  }
   return { files, skipped };
 }
 
@@ -2995,7 +3369,6 @@ var Logger = class {
   formatMetrics() {
     const m = this.metrics;
     const lines = [];
-    lines.push("=== Metrics ===");
     if (m.indexingStartTime && m.indexingEndTime) {
       const duration = m.indexingEndTime - m.indexingStartTime;
       lines.push(`Indexing duration: ${(duration / 1e3).toFixed(2)}s`);
@@ -3107,7 +3480,52 @@ function getNativeBinding() {
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
-var native = getNativeBinding();
+function createMockNativeBinding() {
+  const error = new Error("Native module not available. Please rebuild with 'npm run build:native'.");
+  return {
+    parseFile: () => {
+      throw error;
+    },
+    parseFiles: () => {
+      throw error;
+    },
+    hashContent: () => {
+      throw error;
+    },
+    hashFile: () => {
+      throw error;
+    },
+    extractCalls: () => {
+      throw error;
+    },
+    VectorStore: class {
+      constructor() {
+        throw error;
+      }
+    },
+    InvertedIndex: class {
+      constructor() {
+        throw error;
+      }
+    },
+    Database: class {
+      constructor() {
+        throw error;
+      }
+    }
+  };
+}
+var native;
+try {
+  native = getNativeBinding();
+} catch (e) {
+  console.error("[codebase-index] Failed to load native module:", e);
+  native = createMockNativeBinding();
+}
+function parseFileAsText(filePath, content) {
+  const result = native.parseFileAsText(filePath, content);
+  return result.map(mapChunk);
+}
 function parseFiles(files) {
   const result = native.parseFiles(files);
   return result.map((f) => ({
@@ -3933,6 +4351,32 @@ function isLikelyImplementationPath(filePath) {
   }
   return true;
 }
+function isDocumentationPath(filePath) {
+  const lowered = filePath.toLowerCase();
+  const ext = lowered.split(".").pop() ?? "";
+  return lowered.includes("readme") || ["md", "mdx", "rst", "adoc", "txt"].includes(ext);
+}
+function classifyExternalRerankBand(candidate, preferSourcePaths, docIntent) {
+  const isDocOrTest = isTestOrDocPath(candidate.metadata.filePath);
+  const isDocumentation = isDocumentationPath(candidate.metadata.filePath);
+  const isImplementation = isLikelyImplementationPath(candidate.metadata.filePath) && isImplementationChunkType(candidate.metadata.chunkType);
+  if (preferSourcePaths) {
+    if (isImplementation) return "implementation";
+    if (isDocumentation) return "documentation";
+    if (isDocOrTest) return "test";
+    return "other";
+  }
+  if (docIntent) {
+    if (isDocumentation) return "documentation";
+    if (isImplementation) return "implementation";
+    if (isDocOrTest) return "test";
+    return "other";
+  }
+  if (isImplementation) return "implementation";
+  if (isDocumentation) return "documentation";
+  if (isDocOrTest) return "test";
+  return "other";
+}
 function classifyQueryIntent(tokens) {
   const sourceIntentHits = tokens.filter((t) => SOURCE_INTENT_HINTS.has(t)).length;
   const docTestIntentHits = tokens.filter((t) => DOC_TEST_INTENT_HINTS.has(t)).length;
@@ -4307,8 +4751,74 @@ function rerankResults(query, candidates, rerankTopN, options) {
       return 0;
     });
   }
+  const shouldDiversify = !(preferSourcePaths && identifierHints.length > 0);
+  const diversifiedHead = diversifyEntriesByFileAndSymbol(head, (entry) => entry.candidate, shouldDiversify);
   const tail = candidates.slice(topN);
-  return [...head.map((entry) => entry.candidate), ...tail];
+  return [...diversifiedHead.map((entry) => entry.candidate), ...tail];
+}
+function diversifyEntriesByFileAndSymbol(entries, getCandidate, enabled) {
+  if (!enabled || entries.length <= 2) {
+    return entries;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  const groupOrder = [];
+  for (const entry of entries) {
+    const candidate = getCandidate(entry);
+    const filePath = candidate.metadata.filePath;
+    if (!groups.has(filePath)) {
+      groups.set(filePath, []);
+      groupOrder.push(filePath);
+    }
+    groups.get(filePath)?.push(entry);
+  }
+  const diversifiedGroups = groupOrder.map((filePath) => {
+    const group = groups.get(filePath) ?? [];
+    return diversifyGroupBySymbol(group, getCandidate);
+  });
+  const result = [];
+  let added = true;
+  let round = 0;
+  while (added) {
+    added = false;
+    for (const group of diversifiedGroups) {
+      const entry = group[round];
+      if (entry !== void 0) {
+        result.push(entry);
+        added = true;
+      }
+    }
+    round += 1;
+  }
+  return result;
+}
+function diversifyCandidatesByFile(candidates, enabled) {
+  return diversifyEntriesByFileAndSymbol(candidates, (candidate) => candidate, enabled);
+}
+function diversifyGroupBySymbol(entries, getCandidate) {
+  if (entries.length <= 2) {
+    return entries;
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const primary = [];
+  const remainder = [];
+  for (const entry of entries) {
+    const key = buildDiversityKey(getCandidate(entry).metadata);
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      primary.push(entry);
+    } else {
+      remainder.push(entry);
+    }
+  }
+  return [...primary, ...remainder];
+}
+function buildDiversityKey(metadata) {
+  const normalizedPath = metadata.filePath.toLowerCase();
+  const normalizedName = (metadata.name ?? "").trim().toLowerCase();
+  if (normalizedName.length > 0) {
+    return `${normalizedPath}#${normalizedName}`;
+  }
+  return normalizedPath;
 }
 function rankHybridResults(query, semanticResults, keywordResults, options) {
   const overfetchLimit = Math.max(options.limit * 4, options.limit);
@@ -4636,6 +5146,7 @@ var Indexer = class {
   database = null;
   provider = null;
   configuredProviderInfo = null;
+  reranker = null;
   fileHashCache = /* @__PURE__ */ new Map();
   fileHashCachePath = "";
   failedBatchesPath = "";
@@ -4765,6 +5276,152 @@ var Indexer = class {
         return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
     }
   }
+  async rerankCandidatesWithApi(query, candidates, options) {
+    const reranker = this.config.reranker;
+    if (!reranker || !reranker.enabled || candidates.length <= 1) {
+      return candidates;
+    }
+    const queryTokens = Array.from(tokenizeTextForRanking(query));
+    const preferSourcePaths = classifyQueryIntentRaw(query) === "source";
+    const docIntent = classifyDocIntent(queryTokens) === "docs";
+    if (options?.definitionIntent === true) {
+      return candidates;
+    }
+    if (options?.hasIdentifierHints === true && preferSourcePaths && !docIntent) {
+      return candidates;
+    }
+    const topN = Math.min(reranker.topN, candidates.length);
+    const head = candidates.slice(0, topN);
+    const tail = candidates.slice(topN);
+    const grouped = /* @__PURE__ */ new Map([
+      ["implementation", []],
+      ["documentation", []],
+      ["test", []],
+      ["other", []]
+    ]);
+    for (const candidate of head) {
+      const band = classifyExternalRerankBand(candidate, preferSourcePaths, docIntent);
+      grouped.get(band)?.push(candidate);
+    }
+    const orderedBands = preferSourcePaths ? ["implementation", "other", "documentation", "test"] : docIntent ? ["documentation", "implementation", "other", "test"] : ["implementation", "other", "documentation", "test"];
+    try {
+      const rerankedHead = [];
+      for (const band of orderedBands) {
+        const bandCandidates = grouped.get(band) ?? [];
+        if (bandCandidates.length <= 1) {
+          rerankedHead.push(...bandCandidates);
+          continue;
+        }
+        const documents = await Promise.all(
+          bandCandidates.map(async (candidate) => ({
+            id: candidate.id,
+            text: await this.createRerankerDocumentText(candidate)
+          }))
+        );
+        const rankedIds = await this.callExternalReranker(query, documents, reranker);
+        if (rankedIds.length === 0) {
+          rerankedHead.push(...bandCandidates);
+          continue;
+        }
+        const order = new Map(rankedIds.map((id, index) => [id, index]));
+        const bandReranked = [...bandCandidates].sort((a, b) => {
+          const aRank = order.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+          const bRank = order.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+          if (aRank !== bRank) {
+            return aRank - bRank;
+          }
+          if (b.score !== a.score) {
+            return b.score - a.score;
+          }
+          return a.id.localeCompare(b.id);
+        });
+        const shouldDiversifyBand = !options?.hasIdentifierHints;
+        rerankedHead.push(...diversifyCandidatesByFile(bandReranked, shouldDiversifyBand));
+      }
+      this.logger.search("debug", "Applied external reranker", {
+        provider: reranker.provider,
+        model: reranker.model,
+        candidateCount: head.length,
+        bands: orderedBands
+      });
+      return [...rerankedHead, ...tail];
+    } catch (error) {
+      this.logger.search("warn", "External reranker failed; using deterministic order", {
+        provider: reranker.provider,
+        model: reranker.model,
+        error: getErrorMessage(error)
+      });
+      return candidates;
+    }
+  }
+  async callExternalReranker(query, documents, reranker) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (reranker.apiKey) {
+      headers.Authorization = `Bearer ${reranker.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), reranker.timeoutMs);
+    try {
+      const response = await fetch(`${reranker.baseUrl}/rerank`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: reranker.model,
+          query,
+          documents: documents.map((document) => document.text),
+          top_n: documents.length,
+          return_documents: false
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Reranker API error: ${response.status} - ${await response.text()}`);
+      }
+      const body = await response.json();
+      if (!Array.isArray(body.results)) {
+        throw new Error("Reranker API returned unexpected response format.");
+      }
+      return body.results.map((result) => {
+        const index = typeof result.index === "number" ? result.index : -1;
+        return documents[index]?.id;
+      }).filter((id) => typeof id === "string");
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Reranker request timed out after ${reranker.timeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async createRerankerDocumentText(candidate) {
+    const parts = [
+      `path: ${candidate.metadata.filePath}`,
+      `chunk_type: ${candidate.metadata.chunkType}`,
+      `language: ${candidate.metadata.language}`,
+      `lines: ${candidate.metadata.startLine}-${candidate.metadata.endLine}`
+    ];
+    if (candidate.metadata.name) {
+      parts.push(`name: ${candidate.metadata.name}`);
+    }
+    const intent = isLikelyImplementationPath(candidate.metadata.filePath) ? "implementation" : "doc_or_test";
+    parts.push(`intent_hint: ${intent}`);
+    try {
+      const fileContent = await fsPromises2.readFile(candidate.metadata.filePath, "utf-8");
+      const lines = fileContent.split("\n");
+      const snippetStartLine = Math.max(1, candidate.metadata.startLine - 2);
+      const snippetEndLine = Math.min(lines.length, candidate.metadata.endLine + 2);
+      const snippet = lines.slice(snippetStartLine - 1, snippetEndLine).join("\n").trim();
+      parts.push("snippet:");
+      parts.push(snippet.length > 0 ? snippet : "[empty]");
+    } catch {
+      parts.push("snippet:");
+      parts.push("[unavailable]");
+    }
+    return parts.join("\n");
+  }
   async initialize() {
     if (this.config.embeddingProvider === "custom") {
       if (!this.config.customProvider) {
@@ -4784,9 +5441,19 @@ var Indexer = class {
     this.logger.info("Initializing indexer", {
       provider: this.configuredProviderInfo.provider,
       model: this.configuredProviderInfo.modelInfo.model,
-      scope: this.config.scope
+      scope: this.config.scope,
+      rerankerEnabled: this.config.reranker?.enabled ?? false
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
+    if (this.config.reranker?.enabled) {
+      this.reranker = createReranker(this.config.reranker);
+      if (this.reranker.isAvailable()) {
+        this.logger.info("Reranker initialized", {
+          model: this.config.reranker.model,
+          baseUrl: this.config.reranker.baseUrl
+        });
+      }
+    }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
     const storePath = path6.join(this.indexPath, "vectors");
@@ -4976,11 +5643,14 @@ var Indexer = class {
   }
   async estimateCost() {
     const { configuredProviderInfo } = await this.ensureInitialized();
+    const includePatterns = [...this.config.include, ...this.config.additionalInclude];
     const { files } = await collectFiles(
       this.projectRoot,
-      this.config.include,
+      includePatterns,
       this.config.exclude,
-      this.config.indexing.maxFileSize
+      this.config.indexing.maxFileSize,
+      this.config.knowledgeBases,
+      { maxDepth: this.config.indexing.maxDepth, maxFilesPerDirectory: this.config.indexing.maxFilesPerDirectory }
     );
     return createCostEstimate(files, configuredProviderInfo);
   }
@@ -5015,11 +5685,14 @@ var Indexer = class {
       totalChunks: 0
     });
     this.loadFileHashCache();
+    const includePatterns = [...this.config.include, ...this.config.additionalInclude];
     const { files, skipped } = await collectFiles(
       this.projectRoot,
-      this.config.include,
+      includePatterns,
       this.config.exclude,
-      this.config.indexing.maxFileSize
+      this.config.indexing.maxFileSize,
+      this.config.knowledgeBases,
+      { maxDepth: this.config.indexing.maxDepth, maxFilesPerDirectory: this.config.indexing.maxFilesPerDirectory }
     );
     stats.totalFiles = files.length;
     stats.skippedFiles = skipped;
@@ -5088,7 +5761,15 @@ var Indexer = class {
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
-      for (const chunk of parsed.chunks) {
+      let chunksToProcess = parsed.chunks;
+      if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
+        const changedFile = changedFiles.find((f) => f.path === parsed.path);
+        if (changedFile) {
+          const textChunks = parseFileAsText(parsed.path, changedFile.content);
+          chunksToProcess = textChunks;
+        }
+      }
+      for (const chunk of chunksToProcess) {
         if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
           break;
         }
@@ -5295,7 +5976,7 @@ var Indexer = class {
     for (const batch of dynamicBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve5) => setTimeout(resolve5, rateLimitBackoffMs));
+          await new Promise((resolve6) => setTimeout(resolve6, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -5500,6 +6181,7 @@ var Indexer = class {
     const rerankTopN = this.config.search.rerankTopN;
     const filterByBranch = options?.filterByBranch ?? true;
     const sourceIntent = options?.definitionIntent === true || classifyQueryIntentRaw(query) === "source";
+    const identifierHints = extractIdentifierHints(query);
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
@@ -5554,10 +6236,14 @@ var Indexer = class {
       hybridWeight,
       prioritizeSourcePaths: sourceIntent
     });
+    const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
+      definitionIntent: options?.definitionIntent === true,
+      hasIdentifierHints: identifierHints.length > 0
+    });
     const fusionMs = performance2.now() - fusionStartTime;
     const rescued = promoteIdentifierMatches(
       query,
-      combined,
+      rerankedCombined,
       semanticCandidates,
       keywordCandidates,
       database,
@@ -5588,7 +6274,7 @@ var Indexer = class {
     const prePrimaryLane = mergeTieredResults(deterministicIdentifierLane, identifierLane, maxResults * 4);
     const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
     const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
-    const hasCodeHints = extractCodeTermHints(query).length > 0 || extractIdentifierHints(query).length > 0;
+    const hasCodeHints = extractCodeTermHints(query).length > 0 || identifierHints.length > 0;
     const baseFiltered = tiered.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
       if (options?.fileType) {
@@ -5608,6 +6294,7 @@ var Indexer = class {
       (r) => isLikelyImplementationPath(r.metadata.filePath) && isImplementationChunkType(r.metadata.chunkType)
     );
     const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : baseFiltered).slice(0, maxResults);
+    const finalResults = filtered;
     const totalSearchMs = performance2.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
       embeddingMs,
@@ -5617,7 +6304,7 @@ var Indexer = class {
     });
     this.logger.search("info", "Search complete", {
       query,
-      results: filtered.length,
+      results: finalResults.length,
       totalMs: Math.round(totalSearchMs * 100) / 100,
       embeddingMs: Math.round(embeddingMs * 100) / 100,
       vectorMs: Math.round(vectorMs * 100) / 100,
@@ -5627,7 +6314,7 @@ var Indexer = class {
     });
     const metadataOnly = options?.metadataOnly ?? false;
     return Promise.all(
-      filtered.map(async (r) => {
+      finalResults.map(async (r) => {
         let content = "";
         let contextStartLine = r.metadata.startLine;
         let contextEndLine = r.metadata.endLine;
@@ -5961,6 +6648,12 @@ function evaluateBudgetGate(budget, summary, comparison) {
       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)}`
+    });
+  }
   if (comparison) {
     if (thresholds.hitAt5MaxDrop !== void 0 && comparison.deltas.hitAt5.absolute < -thresholds.hitAt5MaxDrop) {
       violations.push({
@@ -5974,6 +6667,12 @@ function evaluateBudgetGate(budget, summary, comparison) {
         message: `MRR@10 drop ${comparison.deltas.mrrAt10.absolute.toFixed(4)} exceeds allowed -${thresholds.mrrAt10MaxDrop.toFixed(4)}`
       });
     }
+    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)}`
+      });
+    }
     if (thresholds.p95LatencyMaxMultiplier !== void 0) {
       const baselineP95 = comparison.deltas.latencyP95Ms.baseline;
       if (baselineP95 > BASELINE_P95_EPSILON_MS) {
@@ -6028,6 +6727,12 @@ function uniqueResultsByPath(results) {
   }
   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);
@@ -6106,6 +6811,7 @@ function buildPerQueryResult(query, results, latencyMs, k) {
     reciprocalRankAt10: reciprocalRankAtK(deduped, relevantPaths, 10),
     ndcgAt10: ndcgAtK(deduped, relevantPaths, 10),
     failureBucket: classifyFailureBucket(query, results, k),
+    rawTop3DistinctRatio: distinctTopKRatio(results, 3),
     results: deduped
   };
   return perQuery;
@@ -6119,7 +6825,9 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
     hitAt5: 0,
     hitAt10: 0,
     mrrAt10: 0,
-    ndcgAt10: 0
+    ndcgAt10: 0,
+    distinctTop3Ratio: 0,
+    rawDistinctTop3Ratio: 0
   };
   const failureBuckets = {
     "wrong-file": 0,
@@ -6135,6 +6843,8 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
     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;
     }
@@ -6147,6 +6857,8 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
     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),
@@ -6177,23 +6889,23 @@ function isRecord(value) {
 function isStringArray2(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function asPositiveNumber(value, path10) {
+function asPositiveNumber(value, path11) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path10} must be a non-negative number`);
+    throw new Error(`${path11} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path10) {
+function parseQueryType(value, path11) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
     return value;
   }
   throw new Error(
-    `${path10} must be one of: definition, implementation-intent, similarity, keyword-heavy`
+    `${path11} must be one of: definition, implementation-intent, similarity, keyword-heavy`
   );
 }
-function parseExpected(input, path10) {
+function parseExpected(input, path11) {
   if (!isRecord(input)) {
-    throw new Error(`${path10} must be an object`);
+    throw new Error(`${path11} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -6202,16 +6914,16 @@ function parseExpected(input, path10) {
   const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
   const acceptableFiles = isStringArray2(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
   if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path10} must include either expected.filePath or expected.acceptableFiles`);
+    throw new Error(`${path11} must include either expected.filePath or expected.acceptableFiles`);
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray2(acceptableFilesRaw)) {
-    throw new Error(`${path10}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path11}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path10}.symbol must be a string when provided`);
+    throw new Error(`${path11}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path10}.branch must be a string when provided`);
+    throw new Error(`${path11}.branch must be a string when provided`);
   }
   return {
     filePath,
@@ -6221,25 +6933,25 @@ function parseExpected(input, path10) {
   };
 }
 function parseQuery(input, index) {
-  const path10 = `queries[${index}]`;
+  const path11 = `queries[${index}]`;
   if (!isRecord(input)) {
-    throw new Error(`${path10} must be an object`);
+    throw new Error(`${path11} must be an object`);
   }
   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(`${path10}.id must be a non-empty string`);
+    throw new Error(`${path11}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path10}.query must be a non-empty string`);
+    throw new Error(`${path11}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path10}.queryType`),
-    expected: parseExpected(expected, `${path10}.expected`)
+    queryType: parseQueryType(queryType, `${path11}.queryType`),
+    expected: parseExpected(expected, `${path11}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -6308,6 +7020,10 @@ function parseBudget(raw, sourceLabel) {
     thresholds: {
       hitAt5MaxDrop: thresholds.hitAt5MaxDrop === void 0 ? void 0 : asPositiveNumber(thresholds.hitAt5MaxDrop, `${sourceLabel}.thresholds.hitAt5MaxDrop`),
       mrrAt10MaxDrop: thresholds.mrrAt10MaxDrop === void 0 ? void 0 : asPositiveNumber(thresholds.mrrAt10MaxDrop, `${sourceLabel}.thresholds.mrrAt10MaxDrop`),
+      rawDistinctTop3RatioMaxDrop: thresholds.rawDistinctTop3RatioMaxDrop === void 0 ? void 0 : asPositiveNumber(
+        thresholds.rawDistinctTop3RatioMaxDrop,
+        `${sourceLabel}.thresholds.rawDistinctTop3RatioMaxDrop`
+      ),
       p95LatencyMaxMultiplier: thresholds.p95LatencyMaxMultiplier === void 0 ? void 0 : asPositiveNumber(
         thresholds.p95LatencyMaxMultiplier,
         `${sourceLabel}.thresholds.p95LatencyMaxMultiplier`
@@ -6317,7 +7033,11 @@ function parseBudget(raw, sourceLabel) {
         `${sourceLabel}.thresholds.p95LatencyMaxAbsoluteMs`
       ),
       minHitAt5: thresholds.minHitAt5 === void 0 ? void 0 : asPositiveNumber(thresholds.minHitAt5, `${sourceLabel}.thresholds.minHitAt5`),
-      minMrrAt10: thresholds.minMrrAt10 === void 0 ? void 0 : asPositiveNumber(thresholds.minMrrAt10, `${sourceLabel}.thresholds.minMrrAt10`)
+      minMrrAt10: thresholds.minMrrAt10 === void 0 ? void 0 : asPositiveNumber(thresholds.minMrrAt10, `${sourceLabel}.thresholds.minMrrAt10`),
+      minRawDistinctTop3Ratio: thresholds.minRawDistinctTop3Ratio === void 0 ? void 0 : asPositiveNumber(
+        thresholds.minRawDistinctTop3Ratio,
+        `${sourceLabel}.thresholds.minRawDistinctTop3Ratio`
+      )
     }
   };
 }
@@ -6811,8 +7531,12 @@ async function handleEvalCommand(args, cwd) {
     if (!parsed.againstPath.endsWith(".json")) {
       throw new Error("eval diff --against must point to a summary JSON file");
     }
-    const currentSummary = loadSummary(path8.resolve(parsed.projectRoot, currentPath));
-    const baselineSummary = loadSummary(path8.resolve(parsed.projectRoot, parsed.againstPath));
+    const currentSummary = loadSummary(path8.resolve(parsed.projectRoot, currentPath), {
+      allowLegacyDiversityMetrics: true
+    });
+    const baselineSummary = loadSummary(path8.resolve(parsed.projectRoot, parsed.againstPath), {
+      allowLegacyDiversityMetrics: true
+    });
     const comparison = compareSummaries(
       currentSummary,
       baselineSummary,
@@ -6846,16 +7570,13 @@ function formatDefinitionLookup(results, query) {
     return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
   }
   const formatted = results.map((r, idx) => {
-    const header2 = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
-    return `${header2} (score: ${r.score.toFixed(2)})
+    const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
+    return `${header} (score: ${r.score.toFixed(2)})
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
   });
-  const header = results.length === 1 ? `Definition found for "${query}":` : `Found ${results.length} definition candidates for "${query}":`;
-  return `${header}
-
-${formatted.join("\n\n")}`;
+  return formatted.join("\n\n");
 }
 
 // src/mcp-server.ts
@@ -7309,7 +8030,10 @@ Use the implementation_lookup tool to find where this symbol is defined. This pr
   return server;
 }
 
-// src/cli.ts
+// src/config/merger.ts
+import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
+import * as path9 from "path";
+import * as os4 from "os";
 function loadJsonFile(filePath) {
   try {
     if (existsSync6(filePath)) {
@@ -7320,25 +8044,101 @@ function loadJsonFile(filePath) {
   }
   return null;
 }
-function loadPluginConfig(projectRoot, configPath) {
-  if (configPath) {
-    const config = loadJsonFile(configPath);
-    if (config) return config;
+function loadMergedConfig(projectRoot) {
+  const globalConfigPath = path9.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
+  const globalConfig = loadJsonFile(globalConfigPath);
+  const projectConfigPath = path9.join(projectRoot, ".opencode", "codebase-index.json");
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!globalConfig && !projectConfig) {
+    return {};
+  }
+  if (!projectConfig && globalConfig) {
+    return globalConfig;
+  }
+  if (!globalConfig && projectConfig) {
+    return projectConfig;
+  }
+  const merged = { ...globalConfig };
+  if (projectConfig && "embeddingProvider" in projectConfig) {
+    merged.embeddingProvider = projectConfig.embeddingProvider;
+  } else if (globalConfig && globalConfig.embeddingProvider) {
+    merged.embeddingProvider = globalConfig.embeddingProvider;
+  }
+  if (projectConfig && "customProvider" in projectConfig) {
+    merged.customProvider = projectConfig.customProvider;
+  } else if (globalConfig && globalConfig.customProvider) {
+    merged.customProvider = globalConfig.customProvider;
+  }
+  if (projectConfig && "embeddingModel" in projectConfig) {
+    merged.embeddingModel = projectConfig.embeddingModel;
+  } else if (globalConfig && globalConfig.embeddingModel) {
+    merged.embeddingModel = globalConfig.embeddingModel;
+  }
+  if (projectConfig && "reranker" in projectConfig) {
+    merged.reranker = projectConfig.reranker;
+  } else if (globalConfig && globalConfig.reranker) {
+    merged.reranker = globalConfig.reranker;
+  }
+  if (projectConfig && "include" in projectConfig) {
+    merged.include = projectConfig.include;
+  } else if (globalConfig && globalConfig.include) {
+    merged.include = globalConfig.include;
+  }
+  if (projectConfig && "exclude" in projectConfig) {
+    merged.exclude = projectConfig.exclude;
+  } else if (globalConfig && globalConfig.exclude) {
+    merged.exclude = globalConfig.exclude;
+  }
+  if (projectConfig && "indexing" in projectConfig) {
+    merged.indexing = projectConfig.indexing;
+  } else if (globalConfig && globalConfig.indexing) {
+    merged.indexing = globalConfig.indexing;
+  }
+  if (projectConfig && "search" in projectConfig) {
+    merged.search = projectConfig.search;
+  } else if (globalConfig && globalConfig.search) {
+    merged.search = globalConfig.search;
+  }
+  if (projectConfig && "debug" in projectConfig) {
+    merged.debug = projectConfig.debug;
+  } else if (globalConfig && globalConfig.debug) {
+    merged.debug = globalConfig.debug;
+  }
+  if (projectConfig && "scope" in projectConfig) {
+    merged.scope = projectConfig.scope;
+  } else if (globalConfig && "scope" in globalConfig) {
+    merged.scope = globalConfig.scope;
+  }
+  if (projectConfig) {
+    for (const key of Object.keys(projectConfig)) {
+      if (key === "embeddingProvider" || key === "customProvider" || key === "embeddingModel" || key === "reranker" || key === "include" || key === "exclude" || key === "indexing" || key === "search" || key === "debug" || key === "scope" || key === "knowledgeBases" || key === "additionalInclude") {
+        continue;
+      }
+      merged[key] = projectConfig[key];
+    }
   }
-  const projectConfig = loadJsonFile(path9.join(projectRoot, ".opencode", "codebase-index.json"));
-  if (projectConfig) return projectConfig;
-  const globalConfig = loadJsonFile(path9.join(os4.homedir(), ".config", "opencode", "codebase-index.json"));
-  if (globalConfig) return globalConfig;
-  return {};
+  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
+  const projectKbs = projectConfig && Array.isArray(projectConfig.knowledgeBases) ? projectConfig.knowledgeBases : [];
+  const allKbs = [...globalKbs, ...projectKbs];
+  const uniqueKbs = [...new Set(allKbs.map((p) => String(p).trim()))];
+  merged.knowledgeBases = uniqueKbs;
+  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
+  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
+  const allAdditional = [...globalAdditional, ...projectAdditional];
+  const uniqueAdditional = [...new Set(allAdditional.map((p) => String(p).trim()))];
+  merged.additionalInclude = uniqueAdditional;
+  return merged;
 }
+
+// src/cli.ts
 function parseArgs(argv) {
   let project = process.cwd();
   let config;
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path9.resolve(argv[++i]);
+      project = path10.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path9.resolve(argv[++i]);
+      config = path10.resolve(argv[++i]);
     }
   }
   return { project, config };
@@ -7349,7 +8149,7 @@ async function main() {
     process.exit(exitCode);
   }
   const args = parseArgs(process.argv);
-  const rawConfig = loadPluginConfig(args.project, args.config);
+  const rawConfig = loadMergedConfig(args.project);
   const config = parseConfig(rawConfig);
   const server = createMcpServer(args.project, config);
   const transport = new StdioServerTransport();