opencode-codebase-index 0.5.2 → 0.6.0

package/dist/cli.cjs

@@ -29,7 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS({
-  "node_modules/eventemitter3/index.js"(exports2, module2) {
+  "node_modules/eventemitter3/index.js"(exports2, module3) {
     "use strict";
     var has = Object.prototype.hasOwnProperty;
     var prefix = "~";
@@ -183,15 +183,15 @@ var require_eventemitter3 = __commonJS({
     EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
     EventEmitter2.prefixed = prefix;
     EventEmitter2.EventEmitter = EventEmitter2;
-    if ("undefined" !== typeof module2) {
-      module2.exports = EventEmitter2;
+    if ("undefined" !== typeof module3) {
+      module3.exports = EventEmitter2;
     }
   }
 });
 
 // node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "node_modules/ignore/index.js"(exports2, module2) {
+  "node_modules/ignore/index.js"(exports2, module3) {
     "use strict";
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
@@ -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(path7, checkUnignored, mode) {
+      test(path10, 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(path7);
+          const matched = rule[mode].test(path10);
           if (!matched) {
             return;
           }
@@ -517,17 +517,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path7, originalPath, doThrow) => {
-      if (!isString(path7)) {
+    var checkPath = (path10, originalPath, doThrow) => {
+      if (!isString(path10)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path7) {
+      if (!path10) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path7)) {
+      if (checkPath.isNotRelative(path10)) {
         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 = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
     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 path7 = originalPath && checkPath.convert(originalPath);
+        const path10 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path7,
+          path10,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path7, cache, checkUnignored, slices);
+        return this._t(path10, cache, checkUnignored, slices);
       }
-      checkIgnore(path7) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
-          return this.test(path7);
+      checkIgnore(path10) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path10)) {
+          return this.test(path10);
         }
-        const slices = path7.split(SLASH).filter(Boolean);
+        const slices = path10.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(path7, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path10, false, MODE_CHECK_IGNORE);
       }
-      _t(path7, cache, checkUnignored, slices) {
-        if (path7 in cache) {
-          return cache[path7];
+      _t(path10, cache, checkUnignored, slices) {
+        if (path10 in cache) {
+          return cache[path10];
         }
         if (!slices) {
-          slices = path7.split(SLASH).filter(Boolean);
+          slices = path10.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+          return cache[path10] = this._rules.test(path10, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -610,29 +610,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        return cache[path10] = parent.ignored ? parent : this._rules.test(path10, checkUnignored, MODE_IGNORE);
       }
-      ignores(path7) {
-        return this._test(path7, this._ignoreCache, false).ignored;
+      ignores(path10) {
+        return this._test(path10, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path7) => !this.ignores(path7);
+        return (path10) => !this.ignores(path10);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path7) {
-        return this._test(path7, this._testCache, true);
+      test(path10) {
+        return this._test(path10, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, 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 = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+      checkPath.isNotRelative = (path10) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -640,18 +640,18 @@ var require_ignore = __commonJS({
     ) {
       setupWindows();
     }
-    module2.exports = factory;
+    module3.exports = factory;
     factory.default = factory;
-    module2.exports.isPathValid = isPathValid;
-    define(module2.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+    module3.exports.isPathValid = isPathValid;
+    define(module3.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
   }
 });
 
 // src/cli.ts
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_fs5 = require("fs");
-var path6 = __toESM(require("path"), 1);
-var os3 = __toESM(require("os"), 1);
+var import_fs10 = require("fs");
+var path9 = __toESM(require("path"), 1);
+var os4 = __toESM(require("os"), 1);
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -659,7 +659,7 @@ var DEFAULT_INCLUDE = [
   "**/*.{py,pyi}",
   "**/*.{go,rs,java,kt,scala}",
   "**/*.{c,cpp,cc,h,hpp}",
-  "**/*.{rb,php,swift}",
+  "**/*.{rb,php,inc,swift}",
   "**/*.{vue,svelte,astro}",
   "**/*.{sql,graphql,proto}",
   "**/*.{yaml,yml,toml}",
@@ -909,13 +909,197 @@ function getDefaultModelForProvider(provider) {
 }
 var availableProviders = Object.keys(EMBEDDING_MODELS);
 
-// src/mcp-server.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod = require("zod");
+// src/eval/cli.ts
+var path8 = __toESM(require("path"), 1);
+
+// src/eval/compare.ts
+function metricDelta(current, baseline) {
+  const absolute = current - baseline;
+  const relativePct = baseline === 0 ? current === 0 ? 0 : 100 : absolute / baseline * 100;
+  return {
+    current,
+    baseline,
+    absolute,
+    relativePct
+  };
+}
+function compareSummaries(current, baseline, againstPath) {
+  return {
+    againstPath,
+    deltas: {
+      hitAt1: metricDelta(current.metrics.hitAt1, baseline.metrics.hitAt1),
+      hitAt3: metricDelta(current.metrics.hitAt3, baseline.metrics.hitAt3),
+      hitAt5: metricDelta(current.metrics.hitAt5, baseline.metrics.hitAt5),
+      hitAt10: metricDelta(current.metrics.hitAt10, baseline.metrics.hitAt10),
+      mrrAt10: metricDelta(current.metrics.mrrAt10, baseline.metrics.mrrAt10),
+      ndcgAt10: metricDelta(current.metrics.ndcgAt10, baseline.metrics.ndcgAt10),
+      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),
+      embeddingCallCount: metricDelta(
+        current.metrics.embedding.callCount,
+        baseline.metrics.embedding.callCount
+      ),
+      estimatedCostUsd: metricDelta(
+        current.metrics.embedding.estimatedCostUsd,
+        baseline.metrics.embedding.estimatedCostUsd
+      )
+    }
+  };
+}
+
+// src/eval/reports.ts
+var import_fs = require("fs");
+var path = __toESM(require("path"), 1);
+function formatPct(value) {
+  return `${(value * 100).toFixed(2)}%`;
+}
+function formatMs(value) {
+  return `${value.toFixed(3)}ms`;
+}
+function formatUsd(value) {
+  return `$${value.toFixed(6)}`;
+}
+function signed(value, digits = 4) {
+  const formatted = value.toFixed(digits);
+  return value > 0 ? `+${formatted}` : formatted;
+}
+function loadSummary(summaryPath) {
+  const raw = (0, import_fs.readFileSync)(summaryPath, "utf-8");
+  return JSON.parse(raw);
+}
+function createRunDirectory(outputRoot, timestampOverride) {
+  const timestamp = (timestampOverride ?? (/* @__PURE__ */ new Date()).toISOString()).replace(/[:.]/g, "-");
+  const dir = path.join(outputRoot, timestamp);
+  (0, import_fs.mkdirSync)(dir, { recursive: true });
+  return dir;
+}
+function writeJson(filePath, value) {
+  (0, import_fs.writeFileSync)(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+function writeText(filePath, value) {
+  (0, import_fs.writeFileSync)(filePath, value, "utf-8");
+}
+function createSummaryMarkdown(summary, comparison, gate, sweep) {
+  const lines = [];
+  lines.push("# Evaluation Summary");
+  lines.push("");
+  lines.push(`- Generated: ${summary.generatedAt}`);
+  lines.push(`- Dataset: ${summary.datasetName} (v${summary.datasetVersion})`);
+  lines.push(`- Query count: ${summary.queryCount}`);
+  lines.push(
+    `- Search config: fusion=${summary.searchConfig.fusionStrategy}, hybridWeight=${summary.searchConfig.hybridWeight}, rrfK=${summary.searchConfig.rrfK}, rerankTopN=${summary.searchConfig.rerankTopN}`
+  );
+  lines.push("");
+  lines.push("## Metrics");
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|---|---:|");
+  lines.push(`| Hit@1 | ${formatPct(summary.metrics.hitAt1)} |`);
+  lines.push(`| Hit@3 | ${formatPct(summary.metrics.hitAt3)} |`);
+  lines.push(`| Hit@5 | ${formatPct(summary.metrics.hitAt5)} |`);
+  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(`| 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)} |`);
+  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("");
+  lines.push("## Failure Buckets");
+  lines.push("");
+  lines.push("| Bucket | Count |");
+  lines.push("|---|---:|");
+  lines.push(
+    `| wrong-file | ${summary.metrics.failureBuckets["wrong-file"]} |`
+  );
+  lines.push(
+    `| wrong-symbol | ${summary.metrics.failureBuckets["wrong-symbol"]} |`
+  );
+  lines.push(
+    `| docs/tests outranking source | ${summary.metrics.failureBuckets["docs-tests-outranking-source"]} |`
+  );
+  lines.push(
+    `| no relevant hit in top-k | ${summary.metrics.failureBuckets["no-relevant-hit-top-k"]} |`
+  );
+  lines.push("");
+  if (comparison) {
+    lines.push("## Comparison vs Baseline");
+    lines.push("");
+    lines.push(`- Against: ${comparison.againstPath}`);
+    lines.push("");
+    lines.push("| Metric | Baseline | Current | Delta |");
+    lines.push("|---|---:|---:|---:|");
+    lines.push(
+      `| Hit@5 | ${formatPct(comparison.deltas.hitAt5.baseline)} | ${formatPct(comparison.deltas.hitAt5.current)} | ${signed(comparison.deltas.hitAt5.absolute)} |`
+    );
+    lines.push(
+      `| MRR@10 | ${comparison.deltas.mrrAt10.baseline.toFixed(4)} | ${comparison.deltas.mrrAt10.current.toFixed(4)} | ${signed(comparison.deltas.mrrAt10.absolute)} |`
+    );
+    lines.push(
+      `| nDCG@10 | ${comparison.deltas.ndcgAt10.baseline.toFixed(4)} | ${comparison.deltas.ndcgAt10.current.toFixed(4)} | ${signed(comparison.deltas.ndcgAt10.absolute)} |`
+    );
+    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("");
+  }
+  if (gate) {
+    lines.push("## CI Gate");
+    lines.push("");
+    lines.push(`- Result: ${gate.passed ? "PASS \u2705" : "FAIL \u274C"}`);
+    if (gate.violations.length > 0) {
+      lines.push("- Violations:");
+      for (const violation of gate.violations) {
+        lines.push(`  - ${violation.metric}: ${violation.message}`);
+      }
+    }
+    lines.push("");
+  }
+  if (sweep) {
+    lines.push("## Parameter Sweep");
+    lines.push("");
+    lines.push(`- Run count: ${sweep.runCount}`);
+    if (sweep.bestByHitAt5) {
+      lines.push(
+        `- Best Hit@5: ${formatPct(sweep.bestByHitAt5.summary.metrics.hitAt5)} with fusion=${sweep.bestByHitAt5.searchConfig.fusionStrategy}, hybridWeight=${sweep.bestByHitAt5.searchConfig.hybridWeight}, rrfK=${sweep.bestByHitAt5.searchConfig.rrfK}, rerankTopN=${sweep.bestByHitAt5.searchConfig.rerankTopN}`
+      );
+    }
+    if (sweep.bestByMrrAt10) {
+      lines.push(
+        `- Best MRR@10: ${sweep.bestByMrrAt10.summary.metrics.mrrAt10.toFixed(4)} with fusion=${sweep.bestByMrrAt10.searchConfig.fusionStrategy}, hybridWeight=${sweep.bestByMrrAt10.searchConfig.hybridWeight}, rrfK=${sweep.bestByMrrAt10.searchConfig.rrfK}, rerankTopN=${sweep.bestByMrrAt10.searchConfig.rerankTopN}`
+      );
+    }
+    if (sweep.bestByP95Latency) {
+      lines.push(
+        `- Best p95 latency: ${formatMs(sweep.bestByP95Latency.summary.metrics.latencyMs.p95)} with fusion=${sweep.bestByP95Latency.searchConfig.fusionStrategy}, hybridWeight=${sweep.bestByP95Latency.searchConfig.hybridWeight}, rrfK=${sweep.bestByP95Latency.searchConfig.rrfK}, rerankTopN=${sweep.bestByP95Latency.searchConfig.rerankTopN}`
+      );
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function buildPerQueryArtifact(perQuery) {
+  return {
+    queryCount: perQuery.length,
+    queries: [...perQuery].sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+
+// src/eval/runner.ts
+var import_fs7 = require("fs");
+var import_fs8 = require("fs");
+var import_fs9 = require("fs");
+var os3 = __toESM(require("os"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_perf_hooks2 = require("perf_hooks");
 
 // src/indexer/index.ts
-var import_fs4 = require("fs");
-var path5 = __toESM(require("path"), 1);
+var import_fs5 = require("fs");
+var path6 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
 
 // node_modules/eventemitter3/index.mjs
@@ -940,7 +1124,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve4, reject) => {
+  const wrappedPromise = new Promise((resolve5, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -954,7 +1138,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve4, reject);
+    promise.then(resolve5, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -962,7 +1146,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve4(fallback());
+          resolve5(fallback());
         } catch (error) {
           reject(error);
         }
@@ -972,7 +1156,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve4();
+        resolve5();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1362,7 +1546,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
@@ -1400,7 +1584,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve4(result);
+          resolve5(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1557,13 +1741,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve4();
+        resolve5();
       };
       this.on(event, listener);
     });
@@ -1848,7 +2032,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -1856,7 +2040,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve4();
+        resolve5();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -1917,17 +2101,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-var import_fs = require("fs");
-var path = __toESM(require("path"), 1);
+var import_fs2 = require("fs");
+var path2 = __toESM(require("path"), 1);
 var os = __toESM(require("os"), 1);
 function getOpenCodeAuthPath() {
-  return path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
+  return path2.join(os.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if ((0, import_fs.existsSync)(authPath)) {
-      return JSON.parse((0, import_fs.readFileSync)(authPath, "utf-8"));
+    if ((0, import_fs2.existsSync)(authPath)) {
+      return JSON.parse((0, import_fs2.readFileSync)(authPath, "utf-8"));
     }
   } catch {
   }
@@ -2429,8 +2613,8 @@ var CustomEmbeddingProvider = class {
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-var import_fs2 = require("fs");
-var path2 = __toESM(require("path"), 1);
+var import_fs3 = require("fs");
+var path3 = __toESM(require("path"), 1);
 function createIgnoreFilter(projectRoot) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -2447,9 +2631,9 @@ function createIgnoreFilter(projectRoot) {
     ".opencode"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path2.join(projectRoot, ".gitignore");
-  if ((0, import_fs2.existsSync)(gitignorePath)) {
-    const gitignoreContent = (0, import_fs2.readFileSync)(gitignorePath, "utf-8");
+  const gitignorePath = path3.join(projectRoot, ".gitignore");
+  if ((0, import_fs3.existsSync)(gitignorePath)) {
+    const gitignoreContent = (0, import_fs3.readFileSync)(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
@@ -2463,10 +2647,10 @@ function matchGlob(filePath, pattern) {
   return regex.test(filePath);
 }
 async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped) {
-  const entries = await import_fs2.promises.readdir(dir, { withFileTypes: true });
+  const entries = await import_fs3.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    const relativePath = path2.relative(projectRoot, fullPath);
+    const fullPath = path3.join(dir, entry.name);
+    const relativePath = path3.relative(projectRoot, fullPath);
     if (ignoreFilter.ignores(relativePath)) {
       if (entry.isFile()) {
         skipped.push({ path: relativePath, reason: "gitignore" });
@@ -2484,7 +2668,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         skipped
       );
     } else if (entry.isFile()) {
-      const stat = await import_fs2.promises.stat(fullPath);
+      const stat = await import_fs3.promises.stat(fullPath);
       if (stat.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
@@ -2527,6 +2711,9 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
 }
 
 // src/utils/cost.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
 function estimateChunksFromFiles(files) {
   let totalChunks = 0;
   for (const file of files) {
@@ -2881,8 +3068,9 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 var os2 = __toESM(require("os"), 1);
+var module2 = __toESM(require("module"), 1);
 var import_url = require("url");
 var import_meta = {};
 function getNativeBinding() {
@@ -2903,17 +3091,22 @@ function getNativeBinding() {
     throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
   }
   let currentDir;
+  let requireTarget;
   if (typeof import_meta !== "undefined" && import_meta.url) {
-    currentDir = path3.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    currentDir = path4.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    requireTarget = import_meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
+    requireTarget = __filename;
   } else {
     currentDir = process.cwd();
+    requireTarget = path4.join(currentDir, "index.js");
   }
   const isDevMode = currentDir.includes("/src/native");
-  const packageRoot = isDevMode ? path3.resolve(currentDir, "../..") : path3.resolve(currentDir, "..");
-  const nativePath = path3.join(packageRoot, "native", bindingName);
-  return require(nativePath);
+  const packageRoot = isDevMode ? path4.resolve(currentDir, "../..") : path4.resolve(currentDir, "..");
+  const nativePath = path4.join(packageRoot, "native", bindingName);
+  const require2 = module2.createRequire(requireTarget);
+  return require2(nativePath);
 }
 var native = getNativeBinding();
 function parseFiles(files) {
@@ -3031,7 +3224,7 @@ var VectorStore = class {
 var CHARS_PER_TOKEN = 4;
 var MAX_BATCH_TOKENS = 7500;
 var MAX_SINGLE_CHUNK_TOKENS = 2e3;
-function estimateTokens(text) {
+function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
 function createEmbeddingText(chunk, filePath) {
@@ -3096,7 +3289,7 @@ function createDynamicBatches(chunks) {
   let currentBatch = [];
   let currentTokens = 0;
   for (const chunk of chunks) {
-    const chunkTokens = estimateTokens(chunk.text);
+    const chunkTokens = estimateTokens2(chunk.text);
     if (currentBatch.length > 0 && currentTokens + chunkTokens > MAX_BATCH_TOKENS) {
       batches.push(currentBatch);
       currentBatch = [];
@@ -3393,26 +3586,55 @@ var Database = class {
 };
 
 // src/git/index.ts
-var import_fs3 = require("fs");
-var path4 = __toESM(require("path"), 1);
-var import_child_process = require("child_process");
+var import_fs4 = require("fs");
+var path5 = __toESM(require("path"), 1);
+function readPackedRefs(gitDir) {
+  const packedRefsPath = path5.join(gitDir, "packed-refs");
+  if (!(0, import_fs4.existsSync)(packedRefsPath)) {
+    return [];
+  }
+  try {
+    return (0, import_fs4.readFileSync)(packedRefsPath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("^"));
+  } catch {
+    return [];
+  }
+}
+function resolveCommonGitDir(gitDir) {
+  const commonDirPath = path5.join(gitDir, "commondir");
+  if (!(0, import_fs4.existsSync)(commonDirPath)) {
+    return gitDir;
+  }
+  try {
+    const raw = (0, import_fs4.readFileSync)(commonDirPath, "utf-8").trim();
+    if (!raw) {
+      return gitDir;
+    }
+    const resolved = path5.isAbsolute(raw) ? raw : path5.resolve(gitDir, raw);
+    if ((0, import_fs4.existsSync)(resolved)) {
+      return resolved;
+    }
+  } catch {
+    return gitDir;
+  }
+  return gitDir;
+}
 function resolveGitDir(repoRoot) {
-  const gitPath = path4.join(repoRoot, ".git");
-  if (!(0, import_fs3.existsSync)(gitPath)) {
+  const gitPath = path5.join(repoRoot, ".git");
+  if (!(0, import_fs4.existsSync)(gitPath)) {
     return null;
   }
   try {
-    const stat = (0, import_fs3.statSync)(gitPath);
+    const stat = (0, import_fs4.statSync)(gitPath);
     if (stat.isDirectory()) {
       return gitPath;
     }
     if (stat.isFile()) {
-      const content = (0, import_fs3.readFileSync)(gitPath, "utf-8").trim();
+      const content = (0, import_fs4.readFileSync)(gitPath, "utf-8").trim();
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
         const gitdir = match[1];
-        const resolvedPath = path4.isAbsolute(gitdir) ? gitdir : path4.resolve(repoRoot, gitdir);
-        if ((0, import_fs3.existsSync)(resolvedPath)) {
+        const resolvedPath = path5.isAbsolute(gitdir) ? gitdir : path5.resolve(repoRoot, gitdir);
+        if ((0, import_fs4.existsSync)(resolvedPath)) {
           return resolvedPath;
         }
       }
@@ -3429,12 +3651,12 @@ function getCurrentBranch(repoRoot) {
   if (!gitDir) {
     return null;
   }
-  const headPath = path4.join(gitDir, "HEAD");
-  if (!(0, import_fs3.existsSync)(headPath)) {
+  const headPath = path5.join(gitDir, "HEAD");
+  if (!(0, import_fs4.existsSync)(headPath)) {
     return null;
   }
   try {
-    const headContent = (0, import_fs3.readFileSync)(headPath, "utf-8").trim();
+    const headContent = (0, import_fs4.readFileSync)(headPath, "utf-8").trim();
     const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
     if (match) {
       return match[1];
@@ -3449,37 +3671,20 @@ function getCurrentBranch(repoRoot) {
 }
 function getBaseBranch(repoRoot) {
   const gitDir = resolveGitDir(repoRoot);
+  const refStoreDir = gitDir ? resolveCommonGitDir(gitDir) : null;
   const candidates = ["main", "master", "develop", "trunk"];
-  if (gitDir) {
+  if (refStoreDir) {
     for (const candidate of candidates) {
-      const refPath = path4.join(gitDir, "refs", "heads", candidate);
-      if ((0, import_fs3.existsSync)(refPath)) {
+      const refPath = path5.join(refStoreDir, "refs", "heads", candidate);
+      if ((0, import_fs4.existsSync)(refPath)) {
         return candidate;
       }
-      const packedRefsPath = path4.join(gitDir, "packed-refs");
-      if ((0, import_fs3.existsSync)(packedRefsPath)) {
-        try {
-          const content = (0, import_fs3.readFileSync)(packedRefsPath, "utf-8");
-          if (content.includes(`refs/heads/${candidate}`)) {
-            return candidate;
-          }
-        } catch {
-        }
+      const packedRefs = readPackedRefs(refStoreDir);
+      if (packedRefs.some((line) => line.endsWith(` refs/heads/${candidate}`))) {
+        return candidate;
       }
     }
   }
-  try {
-    const result = (0, import_child_process.execSync)("git remote show origin", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const match = result.match(/HEAD branch: (.+)/);
-    if (match) {
-      return match[1].trim();
-    }
-  } catch {
-  }
   return getCurrentBranch(repoRoot) ?? "main";
 }
 function getBranchOrDefault(repoRoot) {
@@ -3490,7 +3695,7 @@ function getBranchOrDefault(repoRoot) {
 }
 
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
@@ -3511,7 +3716,8 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "struct_item",
   "enum_item",
   "trait_item",
-  "mod_item"
+  "mod_item",
+  "trait_declaration"
 ]);
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
@@ -3893,8 +4099,8 @@ function stripFilePathHint(query) {
   const stripped = query.replace(FILE_PATH_HINT_SUFFIX_REGEX, "").trim();
   return stripped.length > 0 ? stripped : query;
 }
-function buildDeterministicIdentifierPass(query, candidates, limit) {
-  if (classifyQueryIntentRaw(query) !== "source") {
+function buildDeterministicIdentifierPass(query, candidates, limit, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
+  if (!prioritizeSourcePaths) {
     return [];
   }
   const primary = extractPrimaryIdentifierQueryHint(query);
@@ -4110,9 +4316,8 @@ function rankHybridResults(query, semanticResults, keywordResults, options) {
   const fused = options.fusionStrategy === "rrf" ? fuseResultsRrf(semanticResults, keywordResults, options.rrfK, overfetchLimit) : fuseResultsWeighted(semanticResults, keywordResults, options.hybridWeight, overfetchLimit);
   const rerankPoolLimit = Math.max(overfetchLimit, options.rerankTopN * 3, options.limit * 6);
   const rerankPool = fused.slice(0, rerankPoolLimit);
-  const intent = classifyQueryIntentRaw(query);
   return rerankResults(query, rerankPool, options.rerankTopN, {
-    prioritizeSourcePaths: intent === "source"
+    prioritizeSourcePaths: options.prioritizeSourcePaths ?? classifyQueryIntentRaw(query) === "source"
   });
 }
 function rankSemanticOnlyResults(query, semanticResults, options) {
@@ -4122,11 +4327,11 @@ function rankSemanticOnlyResults(query, semanticResults, options) {
     prioritizeSourcePaths: options.prioritizeSourcePaths ?? false
   });
 }
-function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCandidates, database, branchChunkIds) {
+function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCandidates, database, branchChunkIds, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
   if (combined.length === 0) {
     return combined;
   }
-  if (classifyQueryIntentRaw(query) !== "source") {
+  if (!prioritizeSourcePaths) {
     return combined;
   }
   const identifierHints = extractIdentifierHints(query);
@@ -4216,8 +4421,8 @@ function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCa
   const remainder = combined.filter((candidate) => !promotedIds.has(candidate.id));
   return [...promoted, ...remainder];
 }
-function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallbackCandidates) {
-  if (classifyQueryIntentRaw(query) !== "source") {
+function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallbackCandidates, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
+  if (!prioritizeSourcePaths) {
     return [];
   }
   const identifierHints = extractIdentifierHints(query);
@@ -4362,8 +4567,8 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallb
   const withFallback = Array.from(symbolCandidates.values()).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
   return withFallback.slice(0, Math.max(limit * 2, limit));
 }
-function buildIdentifierDefinitionLane(query, candidates, limit) {
-  if (classifyQueryIntentRaw(query) !== "source") {
+function buildIdentifierDefinitionLane(query, candidates, limit, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
+  if (!prioritizeSourcePaths) {
     return [];
   }
   const primaryHint = extractPrimaryIdentifierQueryHint(query);
@@ -4448,22 +4653,22 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path5.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path5.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path5.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path6.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path6.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path6.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     if (this.config.scope === "global") {
       const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-      return path5.join(homeDir, ".opencode", "global-index");
+      return path6.join(homeDir, ".opencode", "global-index");
     }
-    return path5.join(this.projectRoot, ".opencode", "index");
+    return path6.join(this.projectRoot, ".opencode", "index");
   }
   loadFileHashCache() {
     try {
-      if ((0, import_fs4.existsSync)(this.fileHashCachePath)) {
-        const data = (0, import_fs4.readFileSync)(this.fileHashCachePath, "utf-8");
+      if ((0, import_fs5.existsSync)(this.fileHashCachePath)) {
+        const data = (0, import_fs5.readFileSync)(this.fileHashCachePath, "utf-8");
         const parsed = JSON.parse(data);
         this.fileHashCache = new Map(Object.entries(parsed));
       }
@@ -4480,28 +4685,28 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    (0, import_fs4.writeFileSync)(tempPath, data);
-    (0, import_fs4.renameSync)(tempPath, targetPath);
+    (0, import_fs5.writeFileSync)(tempPath, data);
+    (0, import_fs5.renameSync)(tempPath, targetPath);
   }
   checkForInterruptedIndexing() {
-    return (0, import_fs4.existsSync)(this.indexingLockPath);
+    return (0, import_fs5.existsSync)(this.indexingLockPath);
   }
   acquireIndexingLock() {
     const lockData = {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       pid: process.pid
     };
-    (0, import_fs4.writeFileSync)(this.indexingLockPath, JSON.stringify(lockData));
+    (0, import_fs5.writeFileSync)(this.indexingLockPath, JSON.stringify(lockData));
   }
   releaseIndexingLock() {
-    if ((0, import_fs4.existsSync)(this.indexingLockPath)) {
-      (0, import_fs4.unlinkSync)(this.indexingLockPath);
+    if ((0, import_fs5.existsSync)(this.indexingLockPath)) {
+      (0, import_fs5.unlinkSync)(this.indexingLockPath);
     }
   }
   async recoverFromInterruptedIndexing() {
     this.logger.warn("Detected interrupted indexing session, recovering...");
-    if ((0, import_fs4.existsSync)(this.fileHashCachePath)) {
-      (0, import_fs4.unlinkSync)(this.fileHashCachePath);
+    if ((0, import_fs5.existsSync)(this.fileHashCachePath)) {
+      (0, import_fs5.unlinkSync)(this.fileHashCachePath);
     }
     await this.healthCheck();
     this.releaseIndexingLock();
@@ -4509,8 +4714,8 @@ var Indexer = class {
   }
   loadFailedBatches() {
     try {
-      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
-        const data = (0, import_fs4.readFileSync)(this.failedBatchesPath, "utf-8");
+      if ((0, import_fs5.existsSync)(this.failedBatchesPath)) {
+        const data = (0, import_fs5.readFileSync)(this.failedBatchesPath, "utf-8");
         return JSON.parse(data);
       }
     } catch {
@@ -4520,13 +4725,13 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
-        import_fs4.promises.unlink(this.failedBatchesPath).catch(() => {
+      if ((0, import_fs5.existsSync)(this.failedBatchesPath)) {
+        import_fs5.promises.unlink(this.failedBatchesPath).catch(() => {
         });
       }
       return;
     }
-    (0, import_fs4.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    (0, import_fs5.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
   addFailedBatch(batch, error) {
     const existing = this.loadFailedBatches();
@@ -4583,26 +4788,26 @@ var Indexer = class {
       scope: this.config.scope
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
-    await import_fs4.promises.mkdir(this.indexPath, { recursive: true });
+    await import_fs5.promises.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path5.join(this.indexPath, "vectors");
+    const storePath = path6.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path5.join(this.indexPath, "vectors.usearch");
-    if ((0, import_fs4.existsSync)(indexFilePath)) {
+    const indexFilePath = path6.join(this.indexPath, "vectors.usearch");
+    if ((0, import_fs5.existsSync)(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path5.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path6.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
     } catch {
-      if ((0, import_fs4.existsSync)(invertedIndexPath)) {
-        await import_fs4.promises.unlink(invertedIndexPath);
+      if ((0, import_fs5.existsSync)(invertedIndexPath)) {
+        await import_fs5.promises.unlink(invertedIndexPath);
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path5.join(this.indexPath, "codebase.db");
-    const dbIsNew = !(0, import_fs4.existsSync)(dbPath);
+    const dbPath = path6.join(this.indexPath, "codebase.db");
+    const dbIsNew = !(0, import_fs5.existsSync)(dbPath);
     this.database = new Database(dbPath);
     if (this.checkForInterruptedIndexing()) {
       await this.recoverFromInterruptedIndexing();
@@ -4834,7 +5039,7 @@ var Indexer = class {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
-        const content = await import_fs4.promises.readFile(f.path, "utf-8");
+        const content = await import_fs5.promises.readFile(f.path, "utf-8");
         changedFiles.push({ path: f.path, content, hash: currentHash });
         this.logger.recordCacheMiss();
       }
@@ -4880,7 +5085,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path5.relative(this.projectRoot, parsed.path);
+        const relativePath = path6.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -5091,7 +5296,7 @@ var Indexer = class {
     for (const batch of dynamicBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve4) => setTimeout(resolve4, rateLimitBackoffMs));
+          await new Promise((resolve5) => setTimeout(resolve5, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -5295,6 +5500,7 @@ var Indexer = class {
     const rrfK = this.config.search.rrfK;
     const rerankTopN = this.config.search.rerankTopN;
     const filterByBranch = options?.filterByBranch ?? true;
+    const sourceIntent = options?.definitionIntent === true || classifyQueryIntentRaw(query) === "source";
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
@@ -5346,7 +5552,8 @@ var Indexer = class {
       rrfK,
       rerankTopN,
       limit: maxResults,
-      hybridWeight
+      hybridWeight,
+      prioritizeSourcePaths: sourceIntent
     });
     const fusionMs = import_perf_hooks.performance.now() - fusionStartTime;
     const rescued = promoteIdentifierMatches(
@@ -5355,30 +5562,33 @@ var Indexer = class {
       semanticCandidates,
       keywordCandidates,
       database,
-      branchChunkIds
+      branchChunkIds,
+      sourceIntent
     );
     const union = unionCandidates(semanticCandidates, keywordCandidates);
     const deterministicIdentifierLane = buildDeterministicIdentifierPass(
       query,
       union,
-      maxResults
+      maxResults,
+      sourceIntent
     );
     const identifierLane = buildIdentifierDefinitionLane(
       query,
       union,
-      maxResults
+      maxResults,
+      sourceIntent
     );
     const symbolLane = buildSymbolDefinitionLane(
       query,
       database,
       branchChunkIds,
       maxResults,
-      union
+      union,
+      sourceIntent
     );
     const prePrimaryLane = mergeTieredResults(deterministicIdentifierLane, identifierLane, maxResults * 4);
     const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
     const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
-    const sourceIntent = classifyQueryIntentRaw(query) === "source";
     const hasCodeHints = extractCodeTermHints(query).length > 0 || extractIdentifierHints(query).length > 0;
     const baseFiltered = tiered.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
@@ -5424,7 +5634,7 @@ var Indexer = class {
         let contextEndLine = r.metadata.endLine;
         if (!metadataOnly && this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs4.promises.readFile(
+            const fileContent = await import_fs5.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -5511,7 +5721,7 @@ var Indexer = class {
     const removedFilePaths = [];
     let removedCount = 0;
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!(0, import_fs4.existsSync)(filePath)) {
+      if (!(0, import_fs5.existsSync)(filePath)) {
         for (const key of chunkKeys) {
           store.remove(key);
           invertedIndex.removeChunk(key);
@@ -5703,7 +5913,7 @@ var Indexer = class {
         let content = "";
         if (this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs4.promises.readFile(
+            const fileContent = await import_fs5.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -5735,7 +5945,896 @@ 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 (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)}`
+      });
+    }
+    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 (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
+  };
+}
+
+// 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 input.replace(/\\/g, "/");
+}
+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 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 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 (query.expected.symbol) {
+    const hasSymbol = top.some(
+      (result) => isRelevantResult(result.filePath, relevantPaths) && result.name === query.expected.symbol
+    );
+    if (!hasSymbol) return "wrong-symbol";
+  }
+  const top1 = top[0];
+  if (top1 && !isRelevantResult(top1.filePath, relevantPaths) && isDocsOrTestsPath(top1.filePath)) {
+    return "docs-tests-outranking-source";
+  }
+  if (top1 && !isRelevantResult(top1.filePath, relevantPaths)) {
+    return "wrong-file";
+  }
+  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),
+    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
+  };
+  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;
+    if (query.failureBucket) {
+      failureBuckets[query.failureBucket] += 1;
+    }
+  }
+  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),
+    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
+  };
+}
+
+// src/eval/schema.ts
+var import_fs6 = require("fs");
+function parseJsonFile(filePath) {
+  const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function asPositiveNumber(value, path10) {
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+    throw new Error(`${path10} must be a non-negative number`);
+  }
+  return value;
+}
+function parseQueryType(value, path10) {
+  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`
+  );
+}
+function parseExpected(input, path10) {
+  if (!isRecord(input)) {
+    throw new Error(`${path10} must be an object`);
+  }
+  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 = isStringArray2(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
+  if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
+    throw new Error(`${path10} 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`);
+  }
+  if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
+    throw new Error(`${path10}.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`);
+  }
+  return {
+    filePath,
+    acceptableFiles,
+    symbol: typeof symbolRaw === "string" ? symbolRaw : void 0,
+    branch: typeof branchRaw === "string" ? branchRaw : void 0
+  };
+}
+function parseQuery(input, index) {
+  const path10 = `queries[${index}]`;
+  if (!isRecord(input)) {
+    throw new Error(`${path10} 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`);
+  }
+  if (typeof query !== "string" || query.trim().length === 0) {
+    throw new Error(`${path10}.query must be a non-empty string`);
+  }
+  return {
+    id,
+    query,
+    queryType: parseQueryType(queryType, `${path10}.queryType`),
+    expected: parseExpected(expected, `${path10}.expected`)
+  };
+}
+function parseGoldenDataset(raw, sourceLabel) {
+  if (!isRecord(raw)) {
+    throw new Error(`${sourceLabel} must be a JSON object`);
+  }
+  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 (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error(`${sourceLabel}.name must be a non-empty string`);
+  }
+  if (description !== void 0 && typeof description !== "string") {
+    throw new Error(`${sourceLabel}.description must be a string when provided`);
+  }
+  if (!Array.isArray(queriesRaw)) {
+    throw new Error(`${sourceLabel}.queries must be an array`);
+  }
+  if (queriesRaw.length === 0) {
+    throw new Error(`${sourceLabel}.queries must contain at least one query`);
+  }
+  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 {
+    version,
+    name,
+    description: typeof description === "string" ? description : void 0,
+    queries
+  };
+}
+function loadGoldenDataset(datasetPath) {
+  const parsed = parseJsonFile(datasetPath);
+  return parseGoldenDataset(parsed, datasetPath);
+}
+function parseBudget(raw, sourceLabel) {
+  if (!isRecord(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 (!isRecord(thresholds)) {
+    throw new Error(`${sourceLabel}.thresholds must be an object`);
+  }
+  return {
+    name,
+    baselinePath: typeof baselinePath === "string" ? baselinePath : void 0,
+    failOnMissingBaseline: typeof failOnMissingBaseline === "boolean" ? failOnMissingBaseline : true,
+    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`),
+      p95LatencyMaxMultiplier: thresholds.p95LatencyMaxMultiplier === void 0 ? void 0 : asPositiveNumber(
+        thresholds.p95LatencyMaxMultiplier,
+        `${sourceLabel}.thresholds.p95LatencyMaxMultiplier`
+      ),
+      p95LatencyMaxAbsoluteMs: thresholds.p95LatencyMaxAbsoluteMs === void 0 ? void 0 : asPositiveNumber(
+        thresholds.p95LatencyMaxAbsoluteMs,
+        `${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`)
+    }
+  };
+}
+function loadBudget(budgetPath) {
+  const parsed = parseJsonFile(budgetPath);
+  return parseBudget(parsed, budgetPath);
+}
+
+// src/eval/runner.ts
+function toAbsolute(projectRoot, maybeRelative) {
+  return path7.isAbsolute(maybeRelative) ? maybeRelative : path7.join(projectRoot, maybeRelative);
+}
+function loadRawConfig(projectRoot, configPath) {
+  const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
+  if (fromPath && (0, import_fs7.existsSync)(fromPath)) {
+    return JSON.parse((0, import_fs8.readFileSync)(fromPath, "utf-8"));
+  }
+  const projectConfig = path7.join(projectRoot, ".opencode", "codebase-index.json");
+  if ((0, import_fs7.existsSync)(projectConfig)) {
+    return JSON.parse((0, import_fs8.readFileSync)(projectConfig, "utf-8"));
+  }
+  const globalConfig = path7.join(os3.homedir(), ".config", "opencode", "codebase-index.json");
+  if ((0, import_fs7.existsSync)(globalConfig)) {
+    return JSON.parse((0, import_fs8.readFileSync)(globalConfig, "utf-8"));
+  }
+  return {};
+}
+function getIndexRootPath(projectRoot, scope) {
+  if (scope === "global") {
+    return path7.join(os3.homedir(), ".opencode", "global-index");
+  }
+  return path7.join(projectRoot, ".opencode", "index");
+}
+function clearIndexRoot(projectRoot, scope) {
+  const indexRoot = getIndexRootPath(projectRoot, scope);
+  if ((0, import_fs7.existsSync)(indexRoot)) {
+    (0, import_fs9.rmSync)(indexRoot, { recursive: true, force: true });
+  }
+}
+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 (overrides?.hybridWeight !== void 0) {
+    nextSearch.hybridWeight = overrides.hybridWeight;
+  }
+  if (overrides?.rrfK !== void 0) {
+    nextSearch.rrfK = overrides.rrfK;
+  }
+  if (overrides?.rerankTopN !== void 0) {
+    nextSearch.rerankTopN = overrides.rerankTopN;
+  }
+  return {
+    ...parsedConfig,
+    search: nextSearch
+  };
+}
+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 parsedConfig = loadParsedConfig(options.projectRoot, options.configPath);
+  const effectiveConfig = resolveSearchConfig(parsedConfig, options.searchOverrides);
+  if (options.reindex) {
+    clearIndexRoot(options.projectRoot, effectiveConfig.scope);
+  }
+  const indexer = new Indexer(options.projectRoot, effectiveConfig);
+  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 = import_perf_hooks2.performance.now();
+    const result = await indexer.search(query.query, 10, {
+      metadataOnly: true,
+      filterByBranch: query.expected.branch ? true : false
+    });
+    const elapsed = import_perf_hooks2.performance.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 = effectiveConfig.embeddingProvider === "custom" || effectiveConfig.embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(effectiveConfig.embeddingProvider).costPer1MTokens;
+  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(path7.join(outputDir, "summary.json"), summary);
+  writeJson(path7.join(outputDir, "per-query.json"), perQueryArtifact);
+  let comparison;
+  if (againstPath) {
+    const baseline = loadSummary(againstPath);
+    comparison = compareSummaries(summary, baseline, againstPath);
+    writeJson(path7.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 ((0, import_fs7.existsSync)(resolvedBaseline)) {
+        const baselineSummary = loadSummary(resolvedBaseline);
+        comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
+        writeJson(path7.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(path7.join(outputDir, "summary.md"), markdown);
+  return { outputDir, summary, perQuery, comparison, gate };
+}
+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 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(path7.join(outputDir, "compare.json"), aggregate);
+  const md = createSummaryMarkdown(
+    bestByHitAt5?.summary ?? runs[0].summary,
+    bestByHitAt5?.comparison,
+    void 0,
+    aggregate
+  );
+  writeText(path7.join(outputDir, "summary.md"), md);
+  writeJson(path7.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  return { outputDir, aggregate };
+}
+
+// src/eval/cli.ts
+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;
+}
+function parseCsvNumbers(value, flag) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0).map((item) => parseNumber(item, flag));
+}
+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);
+  }
+  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 = path8.resolve(cwd, next);
+      i += 1;
+      continue;
+    }
+    if (arg === "--config" && next) {
+      parsed.configPath = path8.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;
+}
+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 {
+    parsed: parseEvalArgs(filtered, cwd),
+    explicitAgainst
+  };
+}
+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 handleEvalCommand(args, cwd) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    return 0;
+  }
+  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 (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;
+    }
+    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>");
+    }
+    parsed.againstPath = explicitAgainst;
+    const currentPath = parsed.currentPath;
+    if (!currentPath.endsWith(".json")) {
+      throw new Error("eval diff --current must point to a summary JSON file");
+    }
+    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 comparison = compareSummaries(
+      currentSummary,
+      baselineSummary,
+      path8.resolve(parsed.projectRoot, parsed.againstPath)
+    );
+    const outputDir = createRunDirectory(path8.resolve(parsed.projectRoot, parsed.outputRoot));
+    const summaryMd = createSummaryMarkdown(currentSummary, comparison);
+    writeJson(path8.join(outputDir, "compare.json"), comparison);
+    writeText(path8.join(outputDir, "summary.md"), summaryMd);
+    writeJson(path8.join(outputDir, "summary.json"), currentSummary);
+    console.log(`Eval diff complete. Artifacts: ${outputDir}`);
+    return 0;
+  }
+  throw new Error(`Unknown eval subcommand: ${subcommand}`);
+}
+
 // src/mcp-server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod = require("zod");
+
+// src/tools/utils.ts
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
   const lines = content.split("\n");
@@ -5743,6 +6842,31 @@ function truncateContent(content) {
   return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
 // ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
 }
+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 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)})
+\`\`\`
+${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")}`;
+}
+
+// src/mcp-server.ts
+var MAX_CONTENT_LINES2 = 30;
+function truncateContent2(content) {
+  const lines = content.split("\n");
+  if (lines.length <= MAX_CONTENT_LINES2) return content;
+  return lines.slice(0, MAX_CONTENT_LINES2).join("\n") + `
+// ... (${lines.length - MAX_CONTENT_LINES2} more lines)`;
+}
 function formatIndexStats(stats, verbose = false) {
   const lines = [];
   if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
@@ -5856,7 +6980,7 @@ function createMcpServer(projectRoot, config) {
         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)}
+${truncateContent2(r.content)}
 \`\`\``;
       });
       return { content: [{ type: "text", text: `Found ${results.length} results for "${args.query}":
@@ -6034,7 +7158,7 @@ Use Read tool to examine specific files.` }] };
         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} (similarity: ${(r.score * 100).toFixed(1)}%)
 \`\`\`
-${truncateContent(r.content)}
+${truncateContent2(r.content)}
 \`\`\``;
       });
       return { content: [{ type: "text", text: `Found ${results.length} similar code blocks:
@@ -6042,6 +7166,25 @@ ${truncateContent(r.content)}
 ${formatted.join("\n\n")}` }] };
     }
   );
+  server.tool(
+    "implementation_lookup",
+    "Jump to symbol definition. Find WHERE something is defined. Returns the authoritative source location(s). Prefers real implementation files over tests, docs, examples, and fixtures.",
+    {
+      query: import_zod.z.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
+      limit: import_zod.z.number().optional().default(5).describe("Maximum number of results"),
+      fileType: import_zod.z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
+      directory: import_zod.z.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
+    },
+    async (args) => {
+      await ensureInitialized();
+      const results = await indexer.search(args.query, args.limit ?? 5, {
+        fileType: args.fileType,
+        directory: args.directory,
+        definitionIntent: true
+      });
+      return { content: [{ type: "text", text: formatDefinitionLookup(results, args.query) }] };
+    }
+  );
   server.tool(
     "call_graph",
     "Query the call graph to find callers or callees of a function/method. Use to understand code flow and dependencies.",
@@ -6148,14 +7291,30 @@ Use a hybrid approach:
       }]
     })
   );
+  server.prompt(
+    "definition",
+    "Find where a symbol is defined in the codebase",
+    { query: import_zod.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.`
+        }
+      }]
+    })
+  );
   return server;
 }
 
 // src/cli.ts
 function loadJsonFile(filePath) {
   try {
-    if ((0, import_fs5.existsSync)(filePath)) {
-      const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    if ((0, import_fs10.existsSync)(filePath)) {
+      const content = (0, import_fs10.readFileSync)(filePath, "utf-8");
       return JSON.parse(content);
     }
   } catch {
@@ -6167,9 +7326,9 @@ function loadPluginConfig(projectRoot, configPath) {
     const config = loadJsonFile(configPath);
     if (config) return config;
   }
-  const projectConfig = loadJsonFile(path6.join(projectRoot, ".opencode", "codebase-index.json"));
+  const projectConfig = loadJsonFile(path9.join(projectRoot, ".opencode", "codebase-index.json"));
   if (projectConfig) return projectConfig;
-  const globalConfig = loadJsonFile(path6.join(os3.homedir(), ".config", "opencode", "codebase-index.json"));
+  const globalConfig = loadJsonFile(path9.join(os4.homedir(), ".config", "opencode", "codebase-index.json"));
   if (globalConfig) return globalConfig;
   return {};
 }
@@ -6178,14 +7337,18 @@ function parseArgs(argv) {
   let config;
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path6.resolve(argv[++i]);
+      project = path9.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path6.resolve(argv[++i]);
+      config = path9.resolve(argv[++i]);
     }
   }
   return { project, config };
 }
 async function main() {
+  if (process.argv[2] === "eval") {
+    const exitCode = await handleEvalCommand(process.argv.slice(3), process.cwd());
+    process.exit(exitCode);
+  }
   const args = parseArgs(process.argv);
   const rawConfig = loadPluginConfig(args.project, args.config);
   const config = parseConfig(rawConfig);