opencode-codebase-index 0.8.1 → 0.9.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(path13, checkUnignored, mode) {
+      test(path18, 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(path13);
+          const matched = rule[mode].test(path18);
           if (!matched) {
             return;
           }
@@ -517,17 +517,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path13, originalPath, doThrow) => {
-      if (!isString(path13)) {
+    var checkPath = (path18, originalPath, doThrow) => {
+      if (!isString(path18)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path13) {
+      if (!path18) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path13)) {
+      if (checkPath.isNotRelative(path18)) {
         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 = (path13) => REGEX_TEST_INVALID_PATH.test(path13);
+    var isNotRelative = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
     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 path13 = originalPath && checkPath.convert(originalPath);
+        const path18 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path13,
+          path18,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path13, cache, checkUnignored, slices);
+        return this._t(path18, cache, checkUnignored, slices);
       }
-      checkIgnore(path13) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path13)) {
-          return this.test(path13);
+      checkIgnore(path18) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path18)) {
+          return this.test(path18);
         }
-        const slices = path13.split(SLASH).filter(Boolean);
+        const slices = path18.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(path13, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path18, false, MODE_CHECK_IGNORE);
       }
-      _t(path13, cache, checkUnignored, slices) {
-        if (path13 in cache) {
-          return cache[path13];
+      _t(path18, cache, checkUnignored, slices) {
+        if (path18 in cache) {
+          return cache[path18];
         }
         if (!slices) {
-          slices = path13.split(SLASH).filter(Boolean);
+          slices = path18.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path13] = this._rules.test(path13, checkUnignored, MODE_IGNORE);
+          return cache[path18] = this._rules.test(path18, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -610,29 +610,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path13] = parent.ignored ? parent : this._rules.test(path13, checkUnignored, MODE_IGNORE);
+        return cache[path18] = parent.ignored ? parent : this._rules.test(path18, checkUnignored, MODE_IGNORE);
       }
-      ignores(path13) {
-        return this._test(path13, this._ignoreCache, false).ignored;
+      ignores(path18) {
+        return this._test(path18, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path13) => !this.ignores(path13);
+        return (path18) => !this.ignores(path18);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path13) {
-        return this._test(path13, this._testCache, true);
+      test(path18) {
+        return this._test(path18, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path13) => checkPath(path13 && checkPath.convert(path13), path13, RETURN_FALSE);
+    var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, 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 = (path13) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path13) || isNotRelative(path13);
+      checkPath.isNotRelative = (path18) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -649,7 +649,7 @@ var require_ignore = __commonJS({
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as path12 from "path";
+import * as path17 from "path";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -665,7 +665,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{md,mdx}",
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
-  "**/*.zig"
+  "**/*.zig",
+  "**/*.gd"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -764,28 +765,7 @@ var AUTO_DETECT_PROVIDER_ORDER = [
   "google"
 ];
 
-// 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
+// src/config/defaults.ts
 function getDefaultIndexingConfig() {
   return {
     autoIndex: false,
@@ -817,12 +797,6 @@ function getDefaultSearchConfig() {
     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":
@@ -845,8 +819,37 @@ function getDefaultDebugConfig() {
     metrics: true
   };
 }
+
+// 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/validators.ts
 var VALID_SCOPES = ["project", "global"];
 var VALID_LOG_LEVELS = ["error", "warn", "info", "debug"];
+function isValidFusionStrategy(value) {
+  return value === "weighted" || value === "rrf";
+}
+function isValidRerankerProvider(value) {
+  return value === "cohere" || value === "jina" || value === "custom";
+}
 function isValidProvider(value) {
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS).includes(value);
 }
@@ -874,6 +877,8 @@ function getResolvedStringArray(value, keyPath) {
 function isValidLogLevel(value) {
   return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
 }
+
+// src/config/schema.ts
 function parseConfig(raw) {
   const input = raw && typeof raw === "object" ? raw : {};
   const embeddingProviderValue = getResolvedString(input.embeddingProvider, "$root.embeddingProvider");
@@ -928,9 +933,9 @@ function parseConfig(raw) {
   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;
-  let reranker = void 0;
+  let embeddingModel;
+  let customProvider;
+  let reranker;
   if (embeddingProviderValue === "custom") {
     embeddingProvider = "custom";
     const rawCustom = input.customProvider && typeof input.customProvider === "object" ? input.customProvider : null;
@@ -963,7 +968,7 @@ function parseConfig(raw) {
     embeddingProvider = embeddingProviderValue;
     const rawEmbeddingModel = input.embeddingModel;
     if (typeof rawEmbeddingModel === "string") {
-      const embeddingModelValue = substituteEnvString(rawEmbeddingModel, "$root.embeddingModel");
+      const embeddingModelValue = getResolvedString(rawEmbeddingModel, "$root.embeddingModel");
       if (embeddingModelValue) {
         embeddingModel = isValidModel(embeddingModelValue, embeddingProvider) ? embeddingModelValue : DEFAULT_PROVIDER_MODELS[embeddingProvider];
       }
@@ -1025,9 +1030,6 @@ var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
   (provider) => provider in EMBEDDING_MODELS
 );
 
-// src/eval/cli.ts
-import * as path10 from "path";
-
 // src/eval/compare.ts
 function metricDelta(current, baseline) {
   const absolute = current - baseline;
@@ -1069,9 +1071,11 @@ function compareSummaries(current, baseline, againstPath) {
 // src/eval/reports.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
-function assertFiniteNumber(value, path13) {
+
+// src/eval/report-formatters.ts
+function assertFiniteNumber(value, path18) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path13} must be a finite number`);
+    throw new Error(`${path18} must be a finite number`);
   }
   return value;
 }
@@ -1111,9 +1115,23 @@ function signed(value, digits = 4) {
   const formatted = value.toFixed(digits);
   return value > 0 ? `+${formatted}` : formatted;
 }
+
+// src/eval/reports.ts
 function loadSummary(summaryPath, options) {
-  const raw = readFileSync(summaryPath, "utf-8");
-  return validateSummary(JSON.parse(raw), summaryPath, options);
+  try {
+    const raw = readFileSync(summaryPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validateSummary(parsed, summaryPath, options);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const message = error.message;
+      throw new Error(`Failed to parse eval summary JSON at ${summaryPath}: ${message}`);
+    }
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Failed to load eval summary at ${summaryPath}: ${String(error)}`);
+  }
 }
 function createRunDirectory(outputRoot, timestampOverride) {
   const timestamp = (timestampOverride ?? (/* @__PURE__ */ new Date()).toISOString()).replace(/[:.]/g, "-");
@@ -1245,445 +1263,106 @@ function buildPerQueryArtifact(perQuery) {
 }
 
 // src/eval/runner.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdirSync as mkdirSync4 } from "fs";
-import { readFileSync as readFileSync8 } from "fs";
-import { rmSync } from "fs";
-import { writeFileSync as writeFileSync4 } from "fs";
-import * as os5 from "os";
-import * as path9 from "path";
+import { existsSync as existsSync8 } from "fs";
+import * as path12 from "path";
 import { performance as performance3 } from "perf_hooks";
 
-// src/config/merger.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import * as os2 from "os";
-import * as path4 from "path";
+// src/indexer/index.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync2, renameSync, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
+import * as path9 from "path";
+import { performance as performance2 } from "perf_hooks";
 
-// src/config/paths.ts
-import { existsSync as existsSync2 } from "fs";
-import * as os from "os";
-import * as path3 from "path";
+// node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
 
-// src/git/index.ts
-import { existsSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import * as path2 from "path";
-function readPackedRefs(gitDir) {
-  const packedRefsPath = path2.join(gitDir, "packed-refs");
-  if (!existsSync(packedRefsPath)) {
-    return [];
-  }
-  try {
-    return readFileSync2(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 = path2.join(gitDir, "commondir");
-  if (!existsSync(commonDirPath)) {
-    return gitDir;
+// node_modules/p-timeout/index.js
+var TimeoutError = class _TimeoutError extends Error {
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, _TimeoutError);
   }
-  try {
-    const raw = readFileSync2(commonDirPath, "utf-8").trim();
-    if (!raw) {
-      return gitDir;
+};
+var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout },
+    signal
+  } = options;
+  let timer;
+  let abortHandler;
+  const wrappedPromise = new Promise((resolve10, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    const resolved = path2.isAbsolute(raw) ? raw : path2.resolve(gitDir, raw);
-    if (existsSync(resolved)) {
-      return resolved;
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
     }
-  } catch {
-    return gitDir;
-  }
-  return gitDir;
-}
-function resolveWorktreeMainRepoRoot(repoRoot) {
-  const gitDir = resolveGitDir(repoRoot);
-  if (!gitDir) {
-    return null;
-  }
-  const commonGitDir = resolveCommonGitDir(gitDir);
-  if (commonGitDir === gitDir || path2.basename(commonGitDir) !== ".git") {
-    return null;
-  }
-  const mainRepoRoot = path2.dirname(commonGitDir);
-  if (!existsSync(mainRepoRoot)) {
-    return null;
-  }
-  return path2.resolve(mainRepoRoot) === path2.resolve(repoRoot) ? null : mainRepoRoot;
-}
-function resolveGitDir(repoRoot) {
-  const gitPath = path2.join(repoRoot, ".git");
-  if (!existsSync(gitPath)) {
-    return null;
-  }
-  try {
-    const stat = statSync(gitPath);
-    if (stat.isDirectory()) {
-      return gitPath;
+    if (signal) {
+      abortHandler = () => {
+        reject(getAbortedReason(signal));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
     }
-    if (stat.isFile()) {
-      const content = readFileSync2(gitPath, "utf-8").trim();
-      const match = content.match(/^gitdir:\s*(.+)$/);
-      if (match) {
-        const gitdir = match[1];
-        const resolvedPath = path2.isAbsolute(gitdir) ? gitdir : path2.resolve(repoRoot, gitdir);
-        if (existsSync(resolvedPath)) {
-          return resolvedPath;
+    promise.then(resolve10, reject);
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve10(fallback());
+        } catch (error) {
+          reject(error);
         }
+        return;
       }
-    }
-  } catch {
-  }
-  return null;
-}
-function isGitRepo(dir) {
-  return resolveGitDir(dir) !== null;
-}
-function getCurrentBranch(repoRoot) {
-  const gitDir = resolveGitDir(repoRoot);
-  if (!gitDir) {
-    return null;
-  }
-  const headPath = path2.join(gitDir, "HEAD");
-  if (!existsSync(headPath)) {
-    return null;
-  }
-  try {
-    const headContent = readFileSync2(headPath, "utf-8").trim();
-    const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
-    if (match) {
-      return match[1];
-    }
-    if (/^[0-9a-f]{40}$/i.test(headContent)) {
-      return headContent.slice(0, 7);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getBaseBranch(repoRoot) {
-  const gitDir = resolveGitDir(repoRoot);
-  const refStoreDir = gitDir ? resolveCommonGitDir(gitDir) : null;
-  const candidates = ["main", "master", "develop", "trunk"];
-  if (refStoreDir) {
-    for (const candidate of candidates) {
-      const refPath = path2.join(refStoreDir, "refs", "heads", candidate);
-      if (existsSync(refPath)) {
-        return candidate;
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
       }
-      const packedRefs = readPackedRefs(refStoreDir);
-      if (packedRefs.some((line) => line.endsWith(` refs/heads/${candidate}`))) {
-        return candidate;
+      if (message === false) {
+        resolve10();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
       }
+    }, milliseconds);
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
     }
-  }
-  return getCurrentBranch(repoRoot) ?? "main";
-}
-function getBranchOrDefault(repoRoot) {
-  if (!isGitRepo(repoRoot)) {
-    return "default";
-  }
-  return getCurrentBranch(repoRoot) ?? "default";
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
 }
 
-// src/config/paths.ts
-var PROJECT_CONFIG_RELATIVE_PATH = path3.join(".opencode", "codebase-index.json");
-var PROJECT_INDEX_RELATIVE_PATH = path3.join(".opencode", "index");
-function resolveWorktreeFallbackPath(projectRoot, relativePath) {
-  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
-  if (!mainRepoRoot) {
-    return null;
+// node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
   }
-  const fallbackPath = path3.join(mainRepoRoot, relativePath);
-  return existsSync2(fallbackPath) ? fallbackPath : null;
-}
-function hasProjectConfig(projectRoot) {
-  return existsSync2(path3.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
-}
-function getGlobalIndexPath() {
-  return path3.join(os.homedir(), ".opencode", "global-index");
-}
-function resolveProjectConfigPath(projectRoot) {
-  const localConfigPath = path3.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
-  if (existsSync2(localConfigPath)) {
-    return localConfigPath;
-  }
-  return resolveWorktreeFallbackPath(projectRoot, PROJECT_CONFIG_RELATIVE_PATH) ?? localConfigPath;
-}
-function resolveProjectIndexPath(projectRoot, scope) {
-  if (scope === "global") {
-    return getGlobalIndexPath();
-  }
-  const localIndexPath = path3.join(projectRoot, PROJECT_INDEX_RELATIVE_PATH);
-  if (existsSync2(localIndexPath)) {
-    return localIndexPath;
-  }
-  if (hasProjectConfig(projectRoot)) {
-    return localIndexPath;
-  }
-  return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
-}
-
-// src/config/merger.ts
-function loadJsonFile(filePath) {
-  try {
-    if (existsSync3(filePath)) {
-      const content = readFileSync3(filePath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return null;
-}
-function normalizeRelativeConfigPath(candidate) {
-  return candidate.replace(/\\/g, "/");
-}
-function rebasePathEntries(values, fromDir, toDir) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed || path4.isAbsolute(trimmed)) {
-      return trimmed;
-    }
-    return normalizeRelativeConfigPath(path4.normalize(path4.relative(toDir, path4.resolve(fromDir, trimmed))));
-  }).filter(Boolean);
-}
-function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path4.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path4.isAbsolute(relativePath);
-}
-function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return trimmed;
-    }
-    if (path4.isAbsolute(trimmed)) {
-      if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizeRelativeConfigPath(path4.normalize(path4.relative(sourceRoot, trimmed) || "."));
-      }
-      return path4.normalize(trimmed);
-    }
-    const resolvedFromSource = path4.resolve(sourceRoot, trimmed);
-    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizeRelativeConfigPath(path4.normalize(trimmed));
-    }
-    return normalizeRelativeConfigPath(path4.normalize(path4.relative(targetRoot, resolvedFromSource)));
-  }).filter(Boolean);
-}
-function materializeLocalProjectConfig(projectRoot, config) {
-  const localConfigPath = path4.join(projectRoot, ".opencode", "codebase-index.json");
-  mkdirSync2(path4.dirname(localConfigPath), { recursive: true });
-  writeFileSync2(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
-}
-function loadProjectConfigLayer(projectRoot) {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!projectConfig) {
-    return {};
-  }
-  const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path4.dirname(path4.dirname(projectConfigPath));
-  if (Array.isArray(normalizedConfig.knowledgeBases)) {
-    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
-      normalizedConfig.knowledgeBases,
-      projectConfigBaseDir,
-      projectRoot
-    );
-  }
-  return normalizedConfig;
-}
-function loadMergedConfig(projectRoot) {
-  const globalConfigPath = os2.homedir() + "/.config/opencode/codebase-index.json";
-  const globalConfig = loadJsonFile(globalConfigPath);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot);
-  if (!globalConfig && !projectConfig) {
-    return {};
-  }
-  if (!projectConfig && globalConfig) {
-    return globalConfig;
-  }
-  if (!globalConfig && projectConfig) {
-    return normalizedProjectConfig;
-  }
-  const merged = { ...globalConfig };
-  if (projectConfig && "embeddingProvider" in normalizedProjectConfig) {
-    merged.embeddingProvider = normalizedProjectConfig.embeddingProvider;
-  } else if (globalConfig && globalConfig.embeddingProvider) {
-    merged.embeddingProvider = globalConfig.embeddingProvider;
-  }
-  if (projectConfig && "customProvider" in normalizedProjectConfig) {
-    merged.customProvider = normalizedProjectConfig.customProvider;
-  } else if (globalConfig && globalConfig.customProvider) {
-    merged.customProvider = globalConfig.customProvider;
-  }
-  if (projectConfig && "embeddingModel" in normalizedProjectConfig) {
-    merged.embeddingModel = normalizedProjectConfig.embeddingModel;
-  } else if (globalConfig && globalConfig.embeddingModel) {
-    merged.embeddingModel = globalConfig.embeddingModel;
-  }
-  if (projectConfig && "reranker" in normalizedProjectConfig) {
-    merged.reranker = normalizedProjectConfig.reranker;
-  } else if (globalConfig && globalConfig.reranker) {
-    merged.reranker = globalConfig.reranker;
-  }
-  if (projectConfig && "include" in normalizedProjectConfig) {
-    merged.include = normalizedProjectConfig.include;
-  } else if (globalConfig && globalConfig.include) {
-    merged.include = globalConfig.include;
-  }
-  if (projectConfig && "exclude" in normalizedProjectConfig) {
-    merged.exclude = normalizedProjectConfig.exclude;
-  } else if (globalConfig && globalConfig.exclude) {
-    merged.exclude = globalConfig.exclude;
-  }
-  if (projectConfig && "indexing" in normalizedProjectConfig) {
-    merged.indexing = normalizedProjectConfig.indexing;
-  } else if (globalConfig && globalConfig.indexing) {
-    merged.indexing = globalConfig.indexing;
-  }
-  if (projectConfig && "search" in normalizedProjectConfig) {
-    merged.search = normalizedProjectConfig.search;
-  } else if (globalConfig && globalConfig.search) {
-    merged.search = globalConfig.search;
-  }
-  if (projectConfig && "debug" in normalizedProjectConfig) {
-    merged.debug = normalizedProjectConfig.debug;
-  } else if (globalConfig && globalConfig.debug) {
-    merged.debug = globalConfig.debug;
-  }
-  if (projectConfig && "scope" in normalizedProjectConfig) {
-    merged.scope = normalizedProjectConfig.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] = normalizedProjectConfig[key];
-    }
-  }
-  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.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/indexer/index.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3, renameSync, unlinkSync, mkdirSync as mkdirSync3, promises as fsPromises2 } from "fs";
-import * as path8 from "path";
-import { performance as performance2 } from "perf_hooks";
-
-// node_modules/eventemitter3/index.mjs
-var import_index = __toESM(require_eventemitter3(), 1);
-
-// node_modules/p-timeout/index.js
-var TimeoutError = class _TimeoutError extends Error {
-  name = "TimeoutError";
-  constructor(message, options) {
-    super(message, options);
-    Error.captureStackTrace?.(this, _TimeoutError);
-  }
-};
-var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
-function pTimeout(promise, options) {
-  const {
-    milliseconds,
-    fallback,
-    message,
-    customTimers = { setTimeout, clearTimeout },
-    signal
-  } = options;
-  let timer;
-  let abortHandler;
-  const wrappedPromise = new Promise((resolve8, reject) => {
-    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
-      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-    }
-    if (signal?.aborted) {
-      reject(getAbortedReason(signal));
-      return;
-    }
-    if (signal) {
-      abortHandler = () => {
-        reject(getAbortedReason(signal));
-      };
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    promise.then(resolve8, reject);
-    if (milliseconds === Number.POSITIVE_INFINITY) {
-      return;
-    }
-    const timeoutError = new TimeoutError();
-    timer = customTimers.setTimeout.call(void 0, () => {
-      if (fallback) {
-        try {
-          resolve8(fallback());
-        } catch (error) {
-          reject(error);
-        }
-        return;
-      }
-      if (typeof promise.cancel === "function") {
-        promise.cancel();
-      }
-      if (message === false) {
-        resolve8();
-      } else if (message instanceof Error) {
-        reject(message);
-      } else {
-        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
-        reject(timeoutError);
-      }
-    }, milliseconds);
-  });
-  const cancelablePromise = wrappedPromise.finally(() => {
-    cancelablePromise.clear();
-    if (abortHandler && signal) {
-      signal.removeEventListener("abort", abortHandler);
-    }
-  });
-  cancelablePromise.clear = () => {
-    customTimers.clearTimeout.call(void 0, timer);
-    timer = void 0;
-  };
-  return cancelablePromise;
-}
-
-// node_modules/p-queue/dist/lower-bound.js
-function lowerBound(array, value, comparator) {
-  let first = 0;
-  let count = array.length;
-  while (count > 0) {
-    const step = Math.trunc(count / 2);
-    let it = first + step;
-    if (comparator(array[it], value) <= 0) {
-      first = ++it;
-      count -= step + 1;
-    } else {
-      count = step;
-    }
-  }
-  return first;
+  return first;
 }
 
 // node_modules/p-queue/dist/priority-queue.js
@@ -2049,7 +1728,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve10, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -2089,7 +1768,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve8(result);
+          resolve10(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -2277,13 +1956,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve10) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve8();
+        resolve10();
       };
       this.on(event, listener);
     });
@@ -2569,7 +2248,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve10, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2577,7 +2256,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve8();
+        resolve10();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -2638,17 +2317,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import * as path5 from "path";
-import * as os3 from "os";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import * as path2 from "path";
+import * as os from "os";
 function getOpenCodeAuthPath() {
-  return path5.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
+  return path2.join(os.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync4(authPath)) {
-      return JSON.parse(readFileSync4(authPath, "utf-8"));
+    if (existsSync(authPath)) {
+      return JSON.parse(readFileSync2(authPath, "utf-8"));
     }
   } catch {
   }
@@ -2715,7 +2394,8 @@ function getGitHubCopilotCredentials() {
   if (!copilotAuth || copilotAuth.type !== "oauth") {
     return null;
   }
-  const baseUrl = copilotAuth.enterpriseUrl ? `https://copilot-api.${copilotAuth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
+  const auth = copilotAuth;
+  const baseUrl = auth.enterpriseUrl ? `https://copilot-api.${auth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
   return {
     provider: "github-copilot",
     baseUrl,
@@ -2811,42 +2491,12 @@ function createCustomProviderInfo(config) {
   };
 }
 
-// src/embeddings/provider.ts
-var CustomProviderNonRetryableError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CustomProviderNonRetryableError";
-  }
-};
-function createEmbeddingProvider(configuredProviderInfo) {
-  switch (configuredProviderInfo.provider) {
-    case "github-copilot":
-      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "openai":
-      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "google":
-      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "ollama":
-      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "custom":
-      return new CustomEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    default: {
-      const _exhaustive = configuredProviderInfo;
-      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
-    }
-  }
-}
-var GitHubCopilotEmbeddingProvider = class {
+// src/embeddings/provider-types.ts
+var BaseEmbeddingProvider = class {
   constructor(credentials, modelInfo) {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  getToken() {
-    if (!this.credentials.refreshToken) {
-      throw new Error("No OAuth token available for GitHub");
-    }
-    return this.credentials.refreshToken;
-  }
   async embedQuery(query) {
     const result = await this.embedBatch([query]);
     return {
@@ -2861,69 +2511,204 @@ var GitHubCopilotEmbeddingProvider = class {
       tokensUsed: result.totalTokensUsed
     };
   }
-  async embedBatch(texts) {
-    const token = this.getToken();
-    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
-      body: JSON.stringify({
-        model: `openai/${this.modelInfo.model}`,
-        input: texts
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
-    }
-    const data = await response.json();
-    return {
-      embeddings: data.data.map((d) => d.embedding),
-      totalTokensUsed: data.usage.total_tokens
-    };
-  }
   getModelInfo() {
     return this.modelInfo;
   }
 };
-var OpenAIEmbeddingProvider = class {
-  constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+var CustomProviderNonRetryableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomProviderNonRetryableError";
   }
-  async embedQuery(query) {
-    const result = await this.embedBatch([query]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+};
+
+// src/utils/url-validation.ts
+var BLOCKED_METADATA_IPS = [
+  /^169\.254\.169\.254$/,
+  // AWS/Azure/GCP metadata
+  /^169\.254\.170\.2$/,
+  // AWS ECS task metadata
+  /^fd00:ec2::254$/
+  // AWS IMDSv2 IPv6
+];
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "metadata.google.internal",
+  "metadata.google",
+  "metadata.goog",
+  "kubernetes.default.svc"
+]);
+function validateExternalUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    return { valid: false, reason: `Invalid URL: ${sanitizeUrlForError(urlString)}` };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { valid: false, reason: `Blocked protocol: ${parsed.protocol}` };
+  }
+  const hostname = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname)) {
+    return { valid: false, reason: `Blocked: cloud metadata service (${hostname})` };
+  }
+  for (const pattern of BLOCKED_METADATA_IPS) {
+    if (pattern.test(hostname)) {
+      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname})` };
+    }
+  }
+  if (/^169\.254\./.test(hostname)) {
+    return { valid: false, reason: `Blocked: link-local address (${hostname})` };
+  }
+  return { valid: true };
+}
+function sanitizeUrlForError(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    const maxLen = 80;
+    if (url.length > maxLen) {
+      return url.slice(0, maxLen) + "...";
+    }
+    return url;
+  }
+}
+
+// src/embeddings/providers/custom.ts
+var CustomEmbeddingProvider = class extends BaseEmbeddingProvider {
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
+  }
+  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 embedRequest(texts) {
+    if (texts.length === 0) {
+      return {
+        embeddings: [],
+        totalTokensUsed: 0
+      };
+    }
+    const headers = {
+      "Content-Type": "application/json"
     };
+    if (this.credentials.apiKey) {
+      headers.Authorization = `Bearer ${this.credentials.apiKey}`;
+    }
+    const baseUrl = this.credentials.baseUrl ?? "";
+    const fullUrl = `${baseUrl}/embeddings`;
+    const urlCheck = validateExternalUrl(fullUrl);
+    if (!urlCheck.valid) {
+      throw new CustomProviderNonRetryableError(
+        `Custom embedding provider URL blocked (SSRF protection): ${urlCheck.reason}`
+      );
+    }
+    const timeoutMs = this.modelInfo.timeoutMs;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(fullUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          input: texts
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Custom embedding API request timed out after ${timeoutMs}ms for ${sanitizeUrlForError(fullUrl)}`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const errorText = (await response.text()).slice(0, 500);
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+        throw new CustomProviderNonRetryableError(`Custom embedding API error (non-retryable): ${response.status} - ${errorText}`);
+      }
+      throw new Error(`Custom embedding API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data)) {
+      if (data.data.length > 0) {
+        const actualDims = data.data[0].embedding.length;
+        if (actualDims !== this.modelInfo.dimensions) {
+          throw new Error(
+            `Dimension mismatch: customProvider.dimensions is ${this.modelInfo.dimensions}, but the API returned vectors with ${actualDims} dimensions. Update your config to match the model's actual output dimensions.`
+          );
+        }
+      }
+      if (data.data.length !== texts.length) {
+        throw new Error(
+          `Embedding count mismatch: sent ${texts.length} texts but received ${data.data.length} embeddings. The custom embedding server may not support batch input.`
+        );
+      }
+      return {
+        embeddings: data.data.map((d) => d.embedding),
+        totalTokensUsed: data.usage?.total_tokens ?? texts.reduce((sum, t) => sum + Math.ceil(t.length / 4), 0)
+      };
+    }
+    throw new Error("Custom embedding API returned unexpected response format. Expected OpenAI-compatible format with data[].embedding.");
   }
-  async embedDocument(document) {
-    const result = await this.embedBatch([document]);
+  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 {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+      embeddings,
+      totalTokensUsed
     };
   }
+};
+
+// src/embeddings/providers/github-copilot.ts
+var GitHubCopilotEmbeddingProvider = class extends BaseEmbeddingProvider {
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
+  }
+  getToken() {
+    if (!this.credentials.refreshToken) {
+      throw new Error("No OAuth token available for GitHub");
+    }
+    return this.credentials.refreshToken;
+  }
   async embedBatch(texts) {
-    const response = await fetch(`${this.credentials.baseUrl}/embeddings`, {
+    const token = this.getToken();
+    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${this.credentials.apiKey}`,
-        "Content-Type": "application/json"
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
       },
       body: JSON.stringify({
-        model: this.modelInfo.model,
+        model: `openai/${this.modelInfo.model}`,
         input: texts
       })
     });
     if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI embedding API error: ${response.status} - ${error}`);
+      const error = (await response.text()).slice(0, 500);
+      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
     }
     const data = await response.json();
     return {
@@ -2931,16 +2716,14 @@ var OpenAIEmbeddingProvider = class {
       totalTokensUsed: data.usage.total_tokens
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
-var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
+
+// src/embeddings/providers/google.ts
+var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddingProvider {
+  static BATCH_SIZE = 20;
   constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+    super(credentials, modelInfo);
   }
-  static BATCH_SIZE = 20;
   async embedQuery(query) {
     const taskType = this.modelInfo.taskAble ? "CODE_RETRIEVAL_QUERY" : void 0;
     const result = await this.embedWithTaskType([query], taskType);
@@ -2961,12 +2744,6 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
     const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
     return this.embedWithTaskType(texts, taskType);
   }
-  /**
-   * Embeds texts using the Google embedContent API.
-   * Sends multiple texts as parts in batched requests (up to BATCH_SIZE per call).
-   * When taskType is provided (gemini-embedding-001), includes it in the request
-   * for task-specific embedding optimization.
-   */
   async embedWithTaskType(texts, taskType) {
     const batches = [];
     for (let i = 0; i < texts.length; i += _GoogleEmbeddingProvider.BATCH_SIZE) {
@@ -2983,17 +2760,18 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
           outputDimensionality: this.modelInfo.dimensions
         }));
         const response = await fetch(
-          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents?key=${this.credentials.apiKey}`,
+          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents`,
           {
             method: "POST",
             headers: {
-              "Content-Type": "application/json"
+              "Content-Type": "application/json",
+              ...this.credentials.apiKey && { "x-goog-api-key": this.credentials.apiKey }
             },
             body: JSON.stringify({ requests })
           }
         );
         if (!response.ok) {
-          const error = await response.text();
+          const error = (await response.text()).slice(0, 500);
           throw new Error(`Google embedding API error: ${response.status} - ${error}`);
         }
         const data = await response.json();
@@ -3008,29 +2786,13 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
       totalTokensUsed: batchResults.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
-var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
-  constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
-  }
+
+// src/embeddings/providers/ollama.ts
+var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddingProvider {
   static MIN_TRUNCATION_CHARS = 512;
-  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
-    };
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
   }
   estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -3115,7 +2877,7 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
       })
     });
     if (!response.ok) {
-      const error = await response.text();
+      const error = (await response.text()).slice(0, 500);
       throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
     }
     const data = await response.json();
@@ -3134,125 +2896,56 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
       totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
-var CustomEmbeddingProvider = class {
+
+// src/embeddings/providers/openai.ts
+var OpenAIEmbeddingProvider = class extends BaseEmbeddingProvider {
   constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+    super(credentials, modelInfo);
   }
-  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 embedRequest(texts) {
-    if (texts.length === 0) {
-      return {
-        embeddings: [],
-        totalTokensUsed: 0
-      };
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.credentials.apiKey) {
-      headers["Authorization"] = `Bearer ${this.credentials.apiKey}`;
-    }
-    const baseUrl = this.credentials.baseUrl ?? "";
-    const timeoutMs = this.modelInfo.timeoutMs;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response;
-    try {
-      response = await fetch(`${baseUrl}/embeddings`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          model: this.modelInfo.model,
-          input: texts
-        }),
-        signal: controller.signal
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Custom embedding API request timed out after ${timeoutMs}ms for ${baseUrl}/embeddings`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
+  async embedBatch(texts) {
+    const response = await fetch(`${this.credentials.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.credentials.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.modelInfo.model,
+        input: texts
+      })
+    });
     if (!response.ok) {
-      const errorText = await response.text();
-      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-        throw new CustomProviderNonRetryableError(`Custom embedding API error (non-retryable): ${response.status} - ${errorText}`);
-      }
-      throw new Error(`Custom embedding API error: ${response.status} - ${errorText}`);
+      const error = (await response.text()).slice(0, 500);
+      throw new Error(`OpenAI embedding API error: ${response.status} - ${error}`);
     }
     const data = await response.json();
-    if (data.data && Array.isArray(data.data)) {
-      if (data.data.length > 0) {
-        const actualDims = data.data[0].embedding.length;
-        if (actualDims !== this.modelInfo.dimensions) {
-          throw new Error(
-            `Dimension mismatch: customProvider.dimensions is ${this.modelInfo.dimensions}, but the API returned vectors with ${actualDims} dimensions. Update your config to match the model's actual output dimensions.`
-          );
-        }
-      }
-      if (data.data.length !== texts.length) {
-        throw new Error(
-          `Embedding count mismatch: sent ${texts.length} texts but received ${data.data.length} embeddings. The custom embedding server may not support batch input.`
-        );
-      }
-      return {
-        embeddings: data.data.map((d) => d.embedding),
-        // Rough estimate: ~4 chars per token. Used as fallback when the server
-        // doesn't return usage.total_tokens (e.g. llama.cpp, some vLLM configs).
-        totalTokensUsed: data.usage?.total_tokens ?? texts.reduce((sum, t) => sum + Math.ceil(t.length / 4), 0)
-      };
-    }
-    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
+      embeddings: data.data.map((d) => d.embedding),
+      totalTokensUsed: data.usage.total_tokens
     };
   }
-  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;
+};
+
+// src/embeddings/provider.ts
+function createEmbeddingProvider(configuredProviderInfo) {
+  switch (configuredProviderInfo.provider) {
+    case "github-copilot":
+      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "openai":
+      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "google":
+      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "ollama":
+      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "custom":
+      return new CustomEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    default: {
+      const _exhaustive = configuredProviderInfo;
+      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
     }
-    return {
-      embeddings,
-      totalTokensUsed
-    };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
-};
+}
 
 // src/rerank/index.ts
 function createReranker(config) {
@@ -3289,7 +2982,10 @@ var SiliconFlowReranker = class {
     if (this.config.apiKey) {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
-    const baseUrl = this.config.baseUrl ?? "https://api.siliconflow.cn/v1";
+    const baseUrl = this.config.baseUrl;
+    if (!baseUrl) {
+      throw new Error("Reranker baseUrl is required. Configure reranker.baseUrl in your codebase-index.json.");
+    }
     const timeoutMs = this.config.timeoutMs ?? 3e4;
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -3332,8 +3028,22 @@ var SiliconFlowReranker = class {
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync5, promises as fsPromises } from "fs";
-import * as path6 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, promises as fsPromises } from "fs";
+import * as path4 from "path";
+
+// src/utils/paths.ts
+import * as path3 from "path";
+function normalizePathSeparators(value) {
+  return value.replace(/\\/g, "/");
+}
+function isHiddenPathSegment(part) {
+  return part.startsWith(".") && part !== "." && part !== "..";
+}
+function isBuildPathSegment(part) {
+  return part.toLowerCase().includes("build");
+}
+
+// src/utils/files.ts
 function createIgnoreFilter(projectRoot) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -3354,9 +3064,9 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path6.join(projectRoot, ".gitignore");
-  if (existsSync5(gitignorePath)) {
-    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+  const gitignorePath = path4.join(projectRoot, ".gitignore");
+  if (existsSync2(gitignorePath)) {
+    const gitignoreContent = readFileSync3(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
@@ -3381,15 +3091,15 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path6.join(dir, entry.name);
-    const relativePath = path6.relative(projectRoot, fullPath);
-    if (entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..") {
+    const fullPath = path4.join(dir, entry.name);
+    const relativePath = path4.relative(projectRoot, fullPath);
+    if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
       }
       continue;
     }
-    if (entry.isDirectory() && entry.name.toLowerCase().includes("build")) {
+    if (entry.isDirectory() && isBuildPathSegment(entry.name)) {
       skipped.push({ path: relativePath, reason: "excluded" });
       continue;
     }
@@ -3431,7 +3141,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path6.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path4.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3471,8 +3181,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path6.normalize(
-        path6.isAbsolute(kbRoot) ? kbRoot : path6.resolve(projectRoot, kbRoot)
+      const resolved = path4.normalize(
+        path4.isAbsolute(kbRoot) ? kbRoot : path4.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3541,20 +3251,21 @@ function createCostEstimate(files, provider) {
 }
 function formatCostEstimate(estimate) {
   const sizeFormatted = formatBytes(estimate.totalSizeBytes);
+  const filesFormatted = `${estimate.filesCount.toLocaleString()} files`;
   const costFormatted = estimate.isFree ? "Free" : `~$${estimate.estimatedCost.toFixed(4)}`;
   return `
 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
 \u2502  \u{1F4CA} Indexing Estimate                                           \u2502
 \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
 \u2502                                                                 \u2502
-\u2502  Files to index:     ${padRight(estimate.filesCount.toLocaleString() + " files", 40)}\u2502
-\u2502  Total size:         ${padRight(sizeFormatted, 40)}\u2502
-\u2502  Estimated chunks:   ${padRight("~" + estimate.estimatedChunks.toLocaleString() + " chunks", 40)}\u2502
-\u2502  Estimated tokens:   ${padRight("~" + estimate.estimatedTokens.toLocaleString() + " tokens", 40)}\u2502
+\u2502  Files to index:     ${filesFormatted.padEnd(40)}\u2502
+\u2502  Total size:         ${sizeFormatted.padEnd(40)}\u2502
+\u2502  Estimated chunks:   ${("~" + estimate.estimatedChunks.toLocaleString() + " chunks").padEnd(40)}\u2502
+\u2502  Estimated tokens:   ${("~" + estimate.estimatedTokens.toLocaleString() + " tokens").padEnd(40)}\u2502
 \u2502                                                                 \u2502
-\u2502  Provider: ${padRight(estimate.provider, 52)}\u2502
-\u2502  Model:    ${padRight(estimate.model, 52)}\u2502
-\u2502  Cost:     ${padRight(costFormatted, 52)}\u2502
+\u2502  Provider: ${estimate.provider.padEnd(52)}\u2502
+\u2502  Model:    ${estimate.model.padEnd(52)}\u2502
+\u2502  Cost:     ${costFormatted.padEnd(52)}\u2502
 \u2502                                                                 \u2502
 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
 `;
@@ -3566,9 +3277,6 @@ function formatBytes(bytes) {
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
 }
-function padRight(str, length) {
-  return str.padEnd(length);
-}
 
 // src/utils/logger.ts
 var LOG_LEVEL_PRIORITY = {
@@ -3635,6 +3343,10 @@ var Logger = class {
       this.logs.shift();
     }
   }
+  withMetrics(fn) {
+    if (!this.config.metrics) return;
+    fn();
+  }
   search(level, message, data) {
     if (this.config.logSearch) {
       this.log(level, "search", message, data);
@@ -3673,89 +3385,107 @@ var Logger = class {
     this.log("debug", "general", message, data);
   }
   recordIndexingStart() {
-    if (!this.config.metrics) return;
-    this.metrics.indexingStartTime = Date.now();
+    this.withMetrics(() => {
+      this.metrics.indexingStartTime = Date.now();
+    });
   }
   recordIndexingEnd() {
-    if (!this.config.metrics) return;
-    this.metrics.indexingEndTime = Date.now();
+    this.withMetrics(() => {
+      this.metrics.indexingEndTime = Date.now();
+    });
   }
   recordFilesScanned(count) {
-    if (!this.config.metrics) return;
-    this.metrics.filesScanned = count;
+    this.withMetrics(() => {
+      this.metrics.filesScanned = count;
+    });
   }
   recordFilesParsed(count) {
-    if (!this.config.metrics) return;
-    this.metrics.filesParsed = count;
+    this.withMetrics(() => {
+      this.metrics.filesParsed = count;
+    });
   }
   recordParseDuration(durationMs) {
-    if (!this.config.metrics) return;
-    this.metrics.parseMs = durationMs;
+    this.withMetrics(() => {
+      this.metrics.parseMs = durationMs;
+    });
   }
   recordChunksProcessed(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksProcessed += count;
+    this.withMetrics(() => {
+      this.metrics.chunksProcessed += count;
+    });
   }
   recordChunksEmbedded(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksEmbedded += count;
+    this.withMetrics(() => {
+      this.metrics.chunksEmbedded += count;
+    });
   }
   recordChunksFromCache(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksFromCache += count;
+    this.withMetrics(() => {
+      this.metrics.chunksFromCache += count;
+    });
   }
   recordChunksRemoved(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksRemoved += count;
+    this.withMetrics(() => {
+      this.metrics.chunksRemoved += count;
+    });
   }
   recordEmbeddingApiCall(tokens) {
-    if (!this.config.metrics) return;
-    this.metrics.embeddingApiCalls++;
-    this.metrics.embeddingTokensUsed += tokens;
+    this.withMetrics(() => {
+      this.metrics.embeddingApiCalls++;
+      this.metrics.embeddingTokensUsed += tokens;
+    });
   }
   recordEmbeddingError() {
-    if (!this.config.metrics) return;
-    this.metrics.embeddingErrors++;
+    this.withMetrics(() => {
+      this.metrics.embeddingErrors++;
+    });
   }
   recordSearch(durationMs, breakdown) {
-    if (!this.config.metrics) return;
-    this.metrics.searchCount++;
-    this.metrics.searchTotalMs += durationMs;
-    this.metrics.searchLastMs = durationMs;
-    this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
-    if (breakdown) {
-      this.metrics.embeddingCallMs = breakdown.embeddingMs;
-      this.metrics.vectorSearchMs = breakdown.vectorMs;
-      this.metrics.keywordSearchMs = breakdown.keywordMs;
-      this.metrics.fusionMs = breakdown.fusionMs;
-    }
+    this.withMetrics(() => {
+      this.metrics.searchCount++;
+      this.metrics.searchTotalMs += durationMs;
+      this.metrics.searchLastMs = durationMs;
+      this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
+      if (breakdown) {
+        this.metrics.embeddingCallMs = breakdown.embeddingMs;
+        this.metrics.vectorSearchMs = breakdown.vectorMs;
+        this.metrics.keywordSearchMs = breakdown.keywordMs;
+        this.metrics.fusionMs = breakdown.fusionMs;
+      }
+    });
   }
   recordCacheHit() {
-    if (!this.config.metrics) return;
-    this.metrics.cacheHits++;
+    this.withMetrics(() => {
+      this.metrics.cacheHits++;
+    });
   }
   recordCacheMiss() {
-    if (!this.config.metrics) return;
-    this.metrics.cacheMisses++;
+    this.withMetrics(() => {
+      this.metrics.cacheMisses++;
+    });
   }
   recordQueryCacheHit() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheHits++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheHits++;
+    });
   }
   recordQueryCacheSimilarHit() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheSimilarHits++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheSimilarHits++;
+    });
   }
   recordQueryCacheMiss() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheMisses++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheMisses++;
+    });
   }
   recordGc(orphans, chunks, embeddings) {
-    if (!this.config.metrics) return;
-    this.metrics.gcRuns++;
-    this.metrics.gcOrphansRemoved += orphans;
-    this.metrics.gcChunksRemoved += chunks;
-    this.metrics.gcEmbeddingsRemoved += embeddings;
+    this.withMetrics(() => {
+      this.metrics.gcRuns++;
+      this.metrics.gcOrphansRemoved += orphans;
+      this.metrics.gcChunksRemoved += chunks;
+      this.metrics.gcEmbeddingsRemoved += embeddings;
+    });
   }
   getMetrics() {
     return { ...this.metrics };
@@ -3862,13 +3592,13 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path7 from "path";
-import * as os4 from "os";
+import * as path5 from "path";
+import * as os2 from "os";
 import * as module from "module";
 import { fileURLToPath } from "url";
 function getNativeBinding() {
-  const platform2 = os4.platform();
-  const arch2 = os4.arch();
+  const platform2 = os2.platform();
+  const arch2 = os2.arch();
   let bindingName;
   if (platform2 === "darwin" && arch2 === "arm64") {
     bindingName = "codebase-index-native.darwin-arm64.node";
@@ -3886,19 +3616,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path7.dirname(fileURLToPath(import.meta.url));
+    currentDir = path5.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path7.join(currentDir, "index.js");
+    requireTarget = path5.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path7.join("src", "native"));
-  const packageRoot = isDevMode ? path7.resolve(currentDir, "../..") : path7.resolve(currentDir, "..");
-  const nativePath = path7.join(packageRoot, "native", bindingName);
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path5.join("src", "native"));
+  const packageRoot = isDevMode ? path5.resolve(currentDir, "../..") : path5.resolve(currentDir, "..");
+  const nativePath = path5.join(packageRoot, "native", bindingName);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -4468,7 +4198,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.getStats();
   }
-  // ── Symbol methods ──────────────────────────────────────────────
   upsertSymbol(symbol) {
     this.throwIfClosed();
     this.inner.upsertSymbol(symbol);
@@ -4498,7 +4227,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
   }
-  // ── Call Edge methods ────────────────────────────────────────────
   upsertCallEdge(edge) {
     this.throwIfClosed();
     this.inner.upsertCallEdge(edge);
@@ -4524,56 +4252,225 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.deleteCallEdgesByFile(filePath);
   }
-  resolveCallEdge(edgeId, toSymbolId) {
-    this.throwIfClosed();
-    this.inner.resolveCallEdge(edgeId, toSymbolId);
+  resolveCallEdge(edgeId, toSymbolId) {
+    this.throwIfClosed();
+    this.inner.resolveCallEdge(edgeId, toSymbolId);
+  }
+  addSymbolsToBranch(branch, symbolIds) {
+    this.throwIfClosed();
+    this.inner.addSymbolsToBranch(branch, symbolIds);
+  }
+  addSymbolsToBranchBatch(branch, symbolIds) {
+    this.throwIfClosed();
+    if (symbolIds.length === 0) return;
+    this.inner.addSymbolsToBranchBatch(branch, symbolIds);
+  }
+  getBranchSymbolIds(branch) {
+    this.throwIfClosed();
+    return this.inner.getBranchSymbolIds(branch);
+  }
+  clearBranchSymbols(branch) {
+    this.throwIfClosed();
+    return this.inner.clearBranchSymbols(branch);
+  }
+  getReferencedSymbolIds(symbolIds) {
+    this.throwIfClosed();
+    if (symbolIds.length === 0) return [];
+    return this.inner.getReferencedSymbolIds(symbolIds);
+  }
+  deleteBranchSymbolsBySymbolIds(symbolIds) {
+    this.throwIfClosed();
+    if (symbolIds.length === 0) return 0;
+    return this.inner.deleteBranchSymbolsBySymbolIds(symbolIds);
+  }
+  deleteBranchSymbolsForBranch(branch, symbolIds) {
+    this.throwIfClosed();
+    if (symbolIds.length === 0) return 0;
+    return this.inner.deleteBranchSymbolsForBranch(branch, symbolIds);
+  }
+  gcOrphanSymbols() {
+    this.throwIfClosed();
+    return this.inner.gcOrphanSymbols();
+  }
+  gcOrphanCallEdges() {
+    this.throwIfClosed();
+    return this.inner.gcOrphanCallEdges();
+  }
+};
+
+// src/git/index.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import * as path7 from "path";
+
+// src/git/refs.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
+import * as path6 from "path";
+function readPackedRefs(gitDir) {
+  const packedRefsPath = path6.join(gitDir, "packed-refs");
+  if (!existsSync3(packedRefsPath)) {
+    return [];
+  }
+  try {
+    return readFileSync4(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 = path6.join(gitDir, "commondir");
+  if (!existsSync3(commonDirPath)) {
+    return gitDir;
+  }
+  try {
+    const raw = readFileSync4(commonDirPath, "utf-8").trim();
+    if (!raw) {
+      return gitDir;
+    }
+    const resolved = path6.isAbsolute(raw) ? raw : path6.resolve(gitDir, raw);
+    if (existsSync3(resolved)) {
+      return resolved;
+    }
+  } catch {
+    return gitDir;
+  }
+  return gitDir;
+}
+
+// src/git/index.ts
+function resolveWorktreeMainRepoRoot(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (!gitDir) {
+    return null;
+  }
+  const commonGitDir = resolveCommonGitDir(gitDir);
+  if (commonGitDir === gitDir || path7.basename(commonGitDir) !== ".git") {
+    return null;
+  }
+  const mainRepoRoot = path7.dirname(commonGitDir);
+  if (!existsSync4(mainRepoRoot)) {
+    return null;
+  }
+  return path7.resolve(mainRepoRoot) === path7.resolve(repoRoot) ? null : mainRepoRoot;
+}
+function resolveGitDir(repoRoot) {
+  const gitPath = path7.join(repoRoot, ".git");
+  if (!existsSync4(gitPath)) {
+    return null;
+  }
+  try {
+    const stat = statSync2(gitPath);
+    if (stat.isDirectory()) {
+      return gitPath;
+    }
+    if (stat.isFile()) {
+      const content = readFileSync5(gitPath, "utf-8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1];
+        const resolvedPath = path7.isAbsolute(gitdir) ? gitdir : path7.resolve(repoRoot, gitdir);
+        if (existsSync4(resolvedPath)) {
+          return resolvedPath;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isGitRepo(dir) {
+  return resolveGitDir(dir) !== null;
+}
+function getCurrentBranch(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (!gitDir) {
+    return null;
   }
-  // ── Branch Symbol methods ────────────────────────────────────────
-  addSymbolsToBranch(branch, symbolIds) {
-    this.throwIfClosed();
-    this.inner.addSymbolsToBranch(branch, symbolIds);
+  const headPath = path7.join(gitDir, "HEAD");
+  if (!existsSync4(headPath)) {
+    return null;
   }
-  addSymbolsToBranchBatch(branch, symbolIds) {
-    this.throwIfClosed();
-    if (symbolIds.length === 0) return;
-    this.inner.addSymbolsToBranchBatch(branch, symbolIds);
+  try {
+    const headContent = readFileSync5(headPath, "utf-8").trim();
+    const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
+    if (match) {
+      return match[1];
+    }
+    if (/^[0-9a-f]{40}$/i.test(headContent)) {
+      return headContent.slice(0, 7);
+    }
+    return null;
+  } catch {
+    return null;
   }
-  getBranchSymbolIds(branch) {
-    this.throwIfClosed();
-    return this.inner.getBranchSymbolIds(branch);
+}
+function getBaseBranch(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  const refStoreDir = gitDir ? resolveCommonGitDir(gitDir) : null;
+  const candidates = ["main", "master", "develop", "trunk"];
+  if (refStoreDir) {
+    for (const candidate of candidates) {
+      const refPath = path7.join(refStoreDir, "refs", "heads", candidate);
+      if (existsSync4(refPath)) {
+        return candidate;
+      }
+      const packedRefs = readPackedRefs(refStoreDir);
+      if (packedRefs.some((line) => line.endsWith(` refs/heads/${candidate}`))) {
+        return candidate;
+      }
+    }
   }
-  clearBranchSymbols(branch) {
-    this.throwIfClosed();
-    return this.inner.clearBranchSymbols(branch);
+  return getCurrentBranch(repoRoot) ?? "main";
+}
+function getBranchOrDefault(repoRoot) {
+  if (!isGitRepo(repoRoot)) {
+    return "default";
   }
-  getReferencedSymbolIds(symbolIds) {
-    this.throwIfClosed();
-    if (symbolIds.length === 0) return [];
-    return this.inner.getReferencedSymbolIds(symbolIds);
+  return getCurrentBranch(repoRoot) ?? "default";
+}
+
+// src/config/paths.ts
+import { existsSync as existsSync5 } from "fs";
+import * as os3 from "os";
+import * as path8 from "path";
+var PROJECT_CONFIG_RELATIVE_PATH = path8.join(".opencode", "codebase-index.json");
+var PROJECT_INDEX_RELATIVE_PATH = path8.join(".opencode", "index");
+function resolveWorktreeFallbackPath(projectRoot, relativePath) {
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (!mainRepoRoot) {
+    return null;
   }
-  deleteBranchSymbolsBySymbolIds(symbolIds) {
-    this.throwIfClosed();
-    if (symbolIds.length === 0) return 0;
-    return this.inner.deleteBranchSymbolsBySymbolIds(symbolIds);
+  const fallbackPath = path8.join(mainRepoRoot, relativePath);
+  return existsSync5(fallbackPath) ? fallbackPath : null;
+}
+function hasProjectConfig(projectRoot) {
+  return existsSync5(path8.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
+}
+function getGlobalIndexPath() {
+  return path8.join(os3.homedir(), ".opencode", "global-index");
+}
+function resolveProjectConfigPath(projectRoot) {
+  const localConfigPath = path8.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+  if (existsSync5(localConfigPath)) {
+    return localConfigPath;
   }
-  deleteBranchSymbolsForBranch(branch, symbolIds) {
-    this.throwIfClosed();
-    if (symbolIds.length === 0) return 0;
-    return this.inner.deleteBranchSymbolsForBranch(branch, symbolIds);
+  return resolveWorktreeFallbackPath(projectRoot, PROJECT_CONFIG_RELATIVE_PATH) ?? localConfigPath;
+}
+function resolveProjectIndexPath(projectRoot, scope) {
+  if (scope === "global") {
+    return getGlobalIndexPath();
   }
-  // ── GC methods for symbols/edges ─────────────────────────────────
-  gcOrphanSymbols() {
-    this.throwIfClosed();
-    return this.inner.gcOrphanSymbols();
+  const localIndexPath = path8.join(projectRoot, PROJECT_INDEX_RELATIVE_PATH);
+  if (existsSync5(localIndexPath)) {
+    return localIndexPath;
   }
-  gcOrphanCallEdges() {
-    this.throwIfClosed();
-    return this.inner.gcOrphanCallEdges();
+  if (hasProjectConfig(projectRoot)) {
+    return localIndexPath;
   }
-};
+  return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
+}
 
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -4600,7 +4497,15 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "trigger_declaration",
   "test_declaration",
   "struct_declaration",
-  "union_declaration"
+  "union_declaration",
+  // GDScript declarations whose names participate in the call graph.
+  // `function_definition` and `class_definition` are already in the set
+  // above (shared with Python/C/Bash and Python, respectively).
+  "constructor_definition",
+  "enum_definition",
+  "signal_statement",
+  "const_statement",
+  "class_name_statement"
 ]);
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
@@ -4802,9 +4707,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path8.resolve(filePath);
-  const normalizedRoot = path8.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path8.sep}`);
+  const normalizedFilePath = path9.resolve(filePath);
+  const normalizedRoot = path9.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path9.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5857,22 +5762,28 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path8.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path8.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path8.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path9.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path9.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path9.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return resolveProjectIndexPath(this.projectRoot, this.config.scope);
   }
   loadFileHashCache() {
+    if (!existsSync6(this.fileHashCachePath)) {
+      return;
+    }
     try {
-      if (existsSync6(this.fileHashCachePath)) {
-        const data = readFileSync6(this.fileHashCachePath, "utf-8");
-        const parsed = JSON.parse(data);
-        this.fileHashCache = new Map(Object.entries(parsed));
-      }
-    } catch {
+      const data = readFileSync6(this.fileHashCachePath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.fileHashCache = new Map(Object.entries(parsed));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("Failed to load file hash cache, resetting cache state", {
+        fileHashCachePath: this.fileHashCachePath,
+        error: message
+      });
       this.fileHashCache = /* @__PURE__ */ new Map();
     }
   }
@@ -5885,14 +5796,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    mkdirSync3(path8.dirname(targetPath), { recursive: true });
-    writeFileSync3(tempPath, data);
+    mkdirSync2(path9.dirname(targetPath), { recursive: true });
+    writeFileSync2(tempPath, data);
     renameSync(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path8.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path9.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path8.resolve(this.projectRoot, kbRoot));
+      roots.add(path9.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -5901,22 +5812,22 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -6010,7 +5921,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectRootPath = path9.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6033,7 +5944,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -6117,7 +6028,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -6151,7 +6062,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectRootPath = path9.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6227,7 +6138,7 @@ var Indexer = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       pid: process.pid
     };
-    writeFileSync3(this.indexingLockPath, JSON.stringify(lockData));
+    writeFileSync2(this.indexingLockPath, JSON.stringify(lockData));
   }
   releaseIndexingLock() {
     if (existsSync6(this.indexingLockPath)) {
@@ -6246,7 +6157,12 @@ var Indexer = class {
   loadFailedBatches(maxChunkTokens) {
     try {
       return this.loadSerializedFailedBatches().map((batch) => normalizeFailedBatch(batch, maxChunkTokens)).filter((batch) => batch !== null);
-    } catch {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("Failed to load failed batch state, skipping persisted retries", {
+        failedBatchesPath: this.failedBatchesPath,
+        error: message
+      });
       return [];
     }
   }
@@ -6279,7 +6195,7 @@ var Indexer = class {
       }
       return;
     }
-    writeFileSync3(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    writeFileSync2(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
   collectRetryableFailedChunks(currentFileHashes, unchangedFilePaths, maxChunkTokens) {
     const retryableById = /* @__PURE__ */ new Map();
@@ -6506,13 +6422,13 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path8.join(this.indexPath, "vectors");
+    const storePath = path9.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path8.join(this.indexPath, "vectors.usearch");
+    const indexFilePath = path9.join(this.indexPath, "vectors.usearch");
     if (existsSync6(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path8.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path9.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
@@ -6522,7 +6438,7 @@ var Indexer = class {
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path8.join(this.indexPath, "codebase.db");
+    const dbPath = path9.join(this.indexPath, "codebase.db");
     let dbIsNew = !existsSync6(dbPath);
     try {
       this.database = new Database(dbPath);
@@ -6603,7 +6519,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path9.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6618,7 +6534,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path8.join(this.indexPath, "vectors");
+    const storeBasePath = path9.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -6703,7 +6619,7 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path8.join(this.indexPath, "codebase.db");
+    const dbPath = path9.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage(error);
     if (this.config.scope === "global") {
@@ -6726,15 +6642,15 @@ var Indexer = class {
     this.indexCompatibility = null;
     this.fileHashCache.clear();
     const resetPaths = [
-      path8.join(this.indexPath, "codebase.db"),
-      path8.join(this.indexPath, "codebase.db-shm"),
-      path8.join(this.indexPath, "codebase.db-wal"),
-      path8.join(this.indexPath, "vectors.usearch"),
-      path8.join(this.indexPath, "inverted-index.json"),
-      path8.join(this.indexPath, "file-hashes.json"),
-      path8.join(this.indexPath, "failed-batches.json"),
-      path8.join(this.indexPath, "indexing.lock"),
-      path8.join(this.indexPath, "vectors")
+      path9.join(this.indexPath, "codebase.db"),
+      path9.join(this.indexPath, "codebase.db-shm"),
+      path9.join(this.indexPath, "codebase.db-wal"),
+      path9.join(this.indexPath, "vectors.usearch"),
+      path9.join(this.indexPath, "inverted-index.json"),
+      path9.join(this.indexPath, "file-hashes.json"),
+      path9.join(this.indexPath, "failed-batches.json"),
+      path9.join(this.indexPath, "indexing.lock"),
+      path9.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -6999,7 +6915,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path8.relative(this.projectRoot, parsed.path);
+        const relativePath = path9.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7282,7 +7198,7 @@ var Indexer = class {
     for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve8) => setTimeout(resolve8, rateLimitBackoffMs));
+          await new Promise((resolve10) => setTimeout(resolve10, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -7843,8 +7759,8 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPath = path8.join(this.projectRoot, ".opencode", "index");
-    if (path8.resolve(this.indexPath) !== path8.resolve(localProjectIndexPath)) {
+    const localProjectIndexPath = path9.join(this.projectRoot, ".opencode", "index");
+    if (path9.resolve(this.indexPath) !== path9.resolve(localProjectIndexPath)) {
       throw new Error(
         "Project-scoped force rebuild is unsafe while using an inherited worktree index. Create a local project config boundary before clearing the index."
       );
@@ -7932,7 +7848,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path9.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8378,7 +8294,7 @@ function percentile(values, p) {
   return sorted[lowerIndex] + fraction * (sorted[upperIndex] - sorted[lowerIndex]);
 }
 function normalizePath(input) {
-  return input.replace(/\\/g, "/");
+  return normalizePathSeparators(input);
 }
 function uniqueResultsByPath(results) {
   const seen = /* @__PURE__ */ new Set();
@@ -8541,53 +8457,257 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
   };
 }
 
+// src/eval/runner-config.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import * as os4 from "os";
+import * as path11 from "path";
+
+// src/config/rebase.ts
+import * as path10 from "path";
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path10.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+}
+function rebasePathEntries(values, fromDir, toDir) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed || path10.isAbsolute(trimmed)) {
+      return trimmed;
+    }
+    return normalizePathSeparators(path10.normalize(path10.relative(toDir, path10.resolve(fromDir, trimmed))));
+  }).filter(Boolean);
+}
+function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    if (path10.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizePathSeparators(path10.normalize(path10.relative(sourceRoot, trimmed) || "."));
+      }
+      return path10.normalize(trimmed);
+    }
+    const resolvedFromSource = path10.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizePathSeparators(path10.normalize(trimmed));
+    }
+    return normalizePathSeparators(path10.normalize(path10.relative(targetRoot, resolvedFromSource)));
+  }).filter(Boolean);
+}
+
+// src/eval/runner-config.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function validateEvalConfigShape(rawConfig, filePath) {
+  if (!isRecord(rawConfig)) {
+    throw new Error(`Eval config at ${filePath} must contain a JSON object at the root.`);
+  }
+  const config = rawConfig;
+  if (config.knowledgeBases !== void 0 && !isStringArray2(config.knowledgeBases)) {
+    throw new Error(`Eval config at ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (config.additionalInclude !== void 0 && !isStringArray2(config.additionalInclude)) {
+    throw new Error(`Eval config at ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (config.include !== void 0 && !isStringArray2(config.include)) {
+    throw new Error(`Eval config at ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (config.exclude !== void 0 && !isStringArray2(config.exclude)) {
+    throw new Error(`Eval config at ${filePath} field 'exclude' must be an array of strings.`);
+  }
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = config[section];
+    if (value !== void 0 && !isRecord(value)) {
+      throw new Error(`Eval config at ${filePath} field '${section}' must be an object.`);
+    }
+  }
+  return config;
+}
+function parseJsonConfigFile(filePath) {
+  try {
+    return validateEvalConfigShape(JSON.parse(readFileSync7(filePath, "utf-8")), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Eval config at ")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse eval config JSON at ${filePath}: ${message}`);
+  }
+}
+function toAbsolute(projectRoot, maybeRelative) {
+  return path11.isAbsolute(maybeRelative) ? maybeRelative : path11.join(projectRoot, maybeRelative);
+}
+function isProjectScopedConfigPath(configPath) {
+  return path11.basename(configPath) === "codebase-index.json" && path11.basename(path11.dirname(configPath)) === ".opencode";
+}
+function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
+  const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
+  const rebaseEntries = (values) => isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
+    values,
+    path11.dirname(path11.dirname(resolvedConfigPath)),
+    projectRoot
+  ) : rebasePathEntries(
+    values,
+    path11.dirname(resolvedConfigPath),
+    projectRoot
+  );
+  if (Array.isArray(config.knowledgeBases)) {
+    config.knowledgeBases = rebaseEntries(config.knowledgeBases);
+  }
+  if (Array.isArray(config.additionalInclude)) {
+    config.additionalInclude = rebaseEntries(config.additionalInclude);
+  }
+  return config;
+}
+function loadRawConfig(projectRoot, configPath) {
+  const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
+  if (fromPath && existsSync7(fromPath)) {
+    return normalizeEvalConfigKnowledgeBases(
+      parseJsonConfigFile(fromPath),
+      projectRoot,
+      fromPath
+    );
+  }
+  const projectConfig = resolveProjectConfigPath(projectRoot);
+  if (existsSync7(projectConfig)) {
+    return normalizeEvalConfigKnowledgeBases(
+      parseJsonConfigFile(projectConfig),
+      projectRoot,
+      projectConfig
+    );
+  }
+  const globalConfig = path11.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
+  if (existsSync7(globalConfig)) {
+    return parseJsonConfigFile(globalConfig);
+  }
+  return {};
+}
+function getIndexRootPath(projectRoot, scope) {
+  return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
+}
+function getLocalProjectIndexRoot(projectRoot) {
+  return path11.join(projectRoot, ".opencode", "index");
+}
+function getLocalProjectConfigPath(projectRoot) {
+  return path11.join(projectRoot, ".opencode", "codebase-index.json");
+}
+function clearIndexRoot(projectRoot, scope) {
+  const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
+  if (existsSync7(indexRoot)) {
+    rmSync(indexRoot, { recursive: true, force: true });
+  }
+}
+function ensureLocalEvalProjectConfig(projectRoot, configPath) {
+  const localConfigPath = getLocalProjectConfigPath(projectRoot);
+  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot);
+  if (!configPath && existsSync7(localConfigPath)) {
+    return localConfigPath;
+  }
+  if (!existsSync7(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
+    return resolvedConfigPath;
+  }
+  const sourceConfig = normalizeEvalConfigKnowledgeBases(
+    parseJsonConfigFile(resolvedConfigPath),
+    projectRoot,
+    resolvedConfigPath
+  );
+  mkdirSync3(path11.dirname(localConfigPath), { recursive: true });
+  writeFileSync3(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
+  return localConfigPath;
+}
+function loadParsedConfig(projectRoot, configPath) {
+  const raw = loadRawConfig(projectRoot, configPath);
+  return parseConfig(raw);
+}
+function resolveSearchConfig(parsedConfig, overrides) {
+  const nextSearch = {
+    ...parsedConfig.search
+  };
+  if (overrides?.fusionStrategy !== void 0) {
+    nextSearch.fusionStrategy = overrides.fusionStrategy;
+  }
+  if (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
+  };
+}
+function getEmbeddingCostPer1MTokens(embeddingProvider) {
+  return embeddingProvider === "custom" || embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(embeddingProvider).costPer1MTokens;
+}
+
 // src/eval/schema.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 function parseJsonFile(filePath) {
-  const content = readFileSync7(filePath, "utf-8");
-  return JSON.parse(content);
+  const content = readFileSync8(filePath, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse JSON from ${filePath}: ${message}`);
+  }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
-function isStringArray2(value) {
+function isStringArray3(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function asPositiveNumber(value, path13) {
+function asPositiveNumber(value, path18) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path13} must be a non-negative number`);
+    throw new Error(`${path18} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path13) {
+function parseQueryType(value, path18) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
     return value;
   }
   throw new Error(
-    `${path13} must be one of: definition, implementation-intent, similarity, keyword-heavy`
+    `${path18} must be one of: definition, implementation-intent, similarity, keyword-heavy`
   );
 }
-function parseExpected(input, path13) {
-  if (!isRecord(input)) {
-    throw new Error(`${path13} must be an object`);
+function parseExpected(input, path18) {
+  if (!isRecord2(input)) {
+    throw new Error(`${path18} 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;
+  const acceptableFiles = isStringArray3(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
   if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path13} must include either expected.filePath or expected.acceptableFiles`);
+    throw new Error(`${path18} must include either expected.filePath or expected.acceptableFiles`);
   }
-  if (acceptableFilesRaw !== void 0 && !isStringArray2(acceptableFilesRaw)) {
-    throw new Error(`${path13}.acceptableFiles must be an array of strings`);
+  if (acceptableFilesRaw !== void 0 && !isStringArray3(acceptableFilesRaw)) {
+    throw new Error(`${path18}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path13}.symbol must be a string when provided`);
+    throw new Error(`${path18}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path13}.branch must be a string when provided`);
+    throw new Error(`${path18}.branch must be a string when provided`);
   }
   return {
     filePath,
@@ -8597,29 +8717,29 @@ function parseExpected(input, path13) {
   };
 }
 function parseQuery(input, index) {
-  const path13 = `queries[${index}]`;
-  if (!isRecord(input)) {
-    throw new Error(`${path13} must be an object`);
+  const path18 = `queries[${index}]`;
+  if (!isRecord2(input)) {
+    throw new Error(`${path18} 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(`${path13}.id must be a non-empty string`);
+    throw new Error(`${path18}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path13}.query must be a non-empty string`);
+    throw new Error(`${path18}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path13}.queryType`),
-    expected: parseExpected(expected, `${path13}.expected`)
+    queryType: parseQueryType(queryType, `${path18}.queryType`),
+    expected: parseExpected(expected, `${path18}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error(`${sourceLabel} must be a JSON object`);
   }
   const version = raw.version;
@@ -8660,8 +8780,11 @@ function loadGoldenDataset(datasetPath) {
   const parsed = parseJsonFile(datasetPath);
   return parseGoldenDataset(parsed, datasetPath);
 }
+function parseThresholdValue(value, fieldName, sourceLabel) {
+  return value === void 0 ? void 0 : asPositiveNumber(value, `${sourceLabel}.thresholds.${fieldName}`);
+}
 function parseBudget(raw, sourceLabel) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error(`${sourceLabel} must be a JSON object`);
   }
   const name = raw.name;
@@ -8674,7 +8797,7 @@ function parseBudget(raw, sourceLabel) {
   if (baselinePath !== void 0 && typeof baselinePath !== "string") {
     throw new Error(`${sourceLabel}.baselinePath must be a string when provided`);
   }
-  if (!isRecord(thresholds)) {
+  if (!isRecord2(thresholds)) {
     throw new Error(`${sourceLabel}.thresholds must be an object`);
   }
   return {
@@ -8682,25 +8805,45 @@ function parseBudget(raw, sourceLabel) {
     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`),
-      rawDistinctTop3RatioMaxDrop: thresholds.rawDistinctTop3RatioMaxDrop === void 0 ? void 0 : asPositiveNumber(
+      hitAt5MaxDrop: parseThresholdValue(
+        thresholds.hitAt5MaxDrop,
+        "hitAt5MaxDrop",
+        sourceLabel
+      ),
+      mrrAt10MaxDrop: parseThresholdValue(
+        thresholds.mrrAt10MaxDrop,
+        "mrrAt10MaxDrop",
+        sourceLabel
+      ),
+      rawDistinctTop3RatioMaxDrop: parseThresholdValue(
         thresholds.rawDistinctTop3RatioMaxDrop,
-        `${sourceLabel}.thresholds.rawDistinctTop3RatioMaxDrop`
+        "rawDistinctTop3RatioMaxDrop",
+        sourceLabel
       ),
-      p95LatencyMaxMultiplier: thresholds.p95LatencyMaxMultiplier === void 0 ? void 0 : asPositiveNumber(
+      p95LatencyMaxMultiplier: parseThresholdValue(
         thresholds.p95LatencyMaxMultiplier,
-        `${sourceLabel}.thresholds.p95LatencyMaxMultiplier`
+        "p95LatencyMaxMultiplier",
+        sourceLabel
       ),
-      p95LatencyMaxAbsoluteMs: thresholds.p95LatencyMaxAbsoluteMs === void 0 ? void 0 : asPositiveNumber(
+      p95LatencyMaxAbsoluteMs: parseThresholdValue(
         thresholds.p95LatencyMaxAbsoluteMs,
-        `${sourceLabel}.thresholds.p95LatencyMaxAbsoluteMs`
+        "p95LatencyMaxAbsoluteMs",
+        sourceLabel
       ),
-      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`),
-      minRawDistinctTop3Ratio: thresholds.minRawDistinctTop3Ratio === void 0 ? void 0 : asPositiveNumber(
+      minHitAt5: parseThresholdValue(
+        thresholds.minHitAt5,
+        "minHitAt5",
+        sourceLabel
+      ),
+      minMrrAt10: parseThresholdValue(
+        thresholds.minMrrAt10,
+        "minMrrAt10",
+        sourceLabel
+      ),
+      minRawDistinctTop3Ratio: parseThresholdValue(
         thresholds.minRawDistinctTop3Ratio,
-        `${sourceLabel}.thresholds.minRawDistinctTop3Ratio`
+        "minRawDistinctTop3Ratio",
+        sourceLabel
       )
     }
   };
@@ -8711,109 +8854,6 @@ function loadBudget(budgetPath) {
 }
 
 // src/eval/runner.ts
-function toAbsolute(projectRoot, maybeRelative) {
-  return path9.isAbsolute(maybeRelative) ? maybeRelative : path9.join(projectRoot, maybeRelative);
-}
-function isProjectScopedConfigPath(configPath) {
-  return path9.basename(configPath) === "codebase-index.json" && path9.basename(path9.dirname(configPath)) === ".opencode";
-}
-function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
-  const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
-  if (!Array.isArray(config.knowledgeBases)) {
-    return config;
-  }
-  config.knowledgeBases = isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
-    config.knowledgeBases,
-    path9.dirname(path9.dirname(resolvedConfigPath)),
-    projectRoot
-  ) : rebasePathEntries(
-    config.knowledgeBases,
-    path9.dirname(resolvedConfigPath),
-    projectRoot
-  );
-  return config;
-}
-function loadRawConfig(projectRoot, configPath) {
-  const fromPath = configPath ? toAbsolute(projectRoot, configPath) : null;
-  if (fromPath && existsSync7(fromPath)) {
-    return normalizeEvalConfigKnowledgeBases(
-      JSON.parse(readFileSync8(fromPath, "utf-8")),
-      projectRoot,
-      fromPath
-    );
-  }
-  const projectConfig = resolveProjectConfigPath(projectRoot);
-  if (existsSync7(projectConfig)) {
-    return normalizeEvalConfigKnowledgeBases(
-      JSON.parse(readFileSync8(projectConfig, "utf-8")),
-      projectRoot,
-      projectConfig
-    );
-  }
-  const globalConfig = path9.join(os5.homedir(), ".config", "opencode", "codebase-index.json");
-  if (existsSync7(globalConfig)) {
-    return JSON.parse(readFileSync8(globalConfig, "utf-8"));
-  }
-  return {};
-}
-function getIndexRootPath(projectRoot, scope) {
-  return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
-}
-function getLocalProjectIndexRoot(projectRoot) {
-  return path9.join(projectRoot, ".opencode", "index");
-}
-function getLocalProjectConfigPath(projectRoot) {
-  return path9.join(projectRoot, ".opencode", "codebase-index.json");
-}
-function clearIndexRoot(projectRoot, scope) {
-  const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
-  if (existsSync7(indexRoot)) {
-    rmSync(indexRoot, { recursive: true, force: true });
-  }
-}
-function ensureLocalEvalProjectConfig(projectRoot, configPath) {
-  const localConfigPath = getLocalProjectConfigPath(projectRoot);
-  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot);
-  if (!configPath && existsSync7(localConfigPath)) {
-    return localConfigPath;
-  }
-  if (!existsSync7(resolvedConfigPath) || resolvedConfigPath === localConfigPath) {
-    return resolvedConfigPath;
-  }
-  const sourceConfig = normalizeEvalConfigKnowledgeBases(
-    JSON.parse(readFileSync8(resolvedConfigPath, "utf-8")),
-    projectRoot,
-    resolvedConfigPath
-  );
-  mkdirSync4(path9.dirname(localConfigPath), { recursive: true });
-  writeFileSync4(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
-  return localConfigPath;
-}
-function loadParsedConfig(projectRoot, configPath) {
-  const raw = loadRawConfig(projectRoot, configPath);
-  return parseConfig(raw);
-}
-function resolveSearchConfig(parsedConfig, overrides) {
-  const nextSearch = {
-    ...parsedConfig.search
-  };
-  if (overrides?.fusionStrategy !== void 0) {
-    nextSearch.fusionStrategy = overrides.fusionStrategy;
-  }
-  if (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;
@@ -8838,7 +8878,7 @@ async function runEvaluation(options) {
       const start = performance3.now();
       const result = await indexer.search(query.query, 10, {
         metadataOnly: true,
-        filterByBranch: query.expected.branch ? true : false
+        filterByBranch: !!query.expected.branch
       });
       const elapsed = performance3.now() - start;
       const materialized = result.map((item) => ({
@@ -8853,7 +8893,7 @@ async function runEvaluation(options) {
     }
     const logger = indexer.getLogger();
     const metricSnapshot = logger.getMetrics();
-    const costPer1MTokensUsd = effectiveConfig.embeddingProvider === "custom" || effectiveConfig.embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(effectiveConfig.embeddingProvider).costPer1MTokens;
+    const costPer1MTokensUsd = getEmbeddingCostPer1MTokens(effectiveConfig.embeddingProvider);
     const summary = {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       projectRoot: options.projectRoot,
@@ -8878,13 +8918,13 @@ async function runEvaluation(options) {
     };
     const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
     const perQueryArtifact = buildPerQueryArtifact(perQuery);
-    writeJson(path9.join(outputDir, "summary.json"), summary);
-    writeJson(path9.join(outputDir, "per-query.json"), perQueryArtifact);
+    writeJson(path12.join(outputDir, "summary.json"), summary);
+    writeJson(path12.join(outputDir, "per-query.json"), perQueryArtifact);
     let comparison;
     if (againstPath) {
       const baseline = loadSummary(againstPath);
       comparison = compareSummaries(summary, baseline, againstPath);
-      writeJson(path9.join(outputDir, "compare.json"), comparison);
+      writeJson(path12.join(outputDir, "compare.json"), comparison);
     }
     let gate;
     if (options.ciMode) {
@@ -8894,10 +8934,10 @@ async function runEvaluation(options) {
       const budget = loadBudget(budgetPath);
       if (!comparison && budget.baselinePath) {
         const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
-        if (existsSync7(resolvedBaseline)) {
+        if (existsSync8(resolvedBaseline)) {
           const baselineSummary = loadSummary(resolvedBaseline);
           comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
-          writeJson(path9.join(outputDir, "compare.json"), comparison);
+          writeJson(path12.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.`
@@ -8907,7 +8947,7 @@ async function runEvaluation(options) {
       gate = evaluateBudgetGate(budget, summary, comparison);
     }
     const markdown = createSummaryMarkdown(summary, comparison, gate);
-    writeText(path9.join(outputDir, "summary.md"), markdown);
+    writeText(path12.join(outputDir, "summary.md"), markdown);
     return { outputDir, summary, perQuery, comparison, gate };
   } finally {
     await indexer.close();
@@ -8965,19 +9005,23 @@ async function runSweep(options, sweep) {
     bestByMrrAt10,
     bestByP95Latency
   };
-  writeJson(path9.join(outputDir, "compare.json"), aggregate);
+  writeJson(path12.join(outputDir, "compare.json"), aggregate);
   const md = createSummaryMarkdown(
     bestByHitAt5?.summary ?? runs[0].summary,
     bestByHitAt5?.comparison,
     void 0,
     aggregate
   );
-  writeText(path9.join(outputDir, "summary.md"), md);
-  writeJson(path9.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  writeText(path12.join(outputDir, "summary.md"), md);
+  writeJson(path12.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
   return { outputDir, aggregate };
 }
 
 // src/eval/cli.ts
+import * as path14 from "path";
+
+// src/eval/cli-parser.ts
+import * as path13 from "path";
 function printUsage() {
   console.log(`
 Usage:
@@ -9049,12 +9093,12 @@ function parseEvalArgs(argv, cwd) {
     const arg = argv[i];
     const next = argv[i + 1];
     if (arg === "--project" && next) {
-      parsed.projectRoot = path10.resolve(cwd, next);
+      parsed.projectRoot = path13.resolve(cwd, next);
       i += 1;
       continue;
     }
     if (arg === "--config" && next) {
-      parsed.configPath = path10.resolve(cwd, next);
+      parsed.configPath = path13.resolve(cwd, next);
       i += 1;
       continue;
     }
@@ -9173,6 +9217,8 @@ function toRunOptions(parsed) {
     }
   };
 }
+
+// src/eval/cli.ts
 async function handleEvalCommand(args, cwd) {
   const subcommand = args[0];
   if (!subcommand || subcommand === "--help" || subcommand === "-h") {
@@ -9210,72 +9256,326 @@ async function handleEvalCommand(args, cwd) {
     }
     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 === "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(path14.resolve(parsed.projectRoot, currentPath), {
+      allowLegacyDiversityMetrics: true
+    });
+    const baselineSummary = loadSummary(path14.resolve(parsed.projectRoot, parsed.againstPath), {
+      allowLegacyDiversityMetrics: true
+    });
+    const comparison = compareSummaries(
+      currentSummary,
+      baselineSummary,
+      path14.resolve(parsed.projectRoot, parsed.againstPath)
+    );
+    const outputDir = createRunDirectory(path14.resolve(parsed.projectRoot, parsed.outputRoot));
+    const summaryMd = createSummaryMarkdown(currentSummary, comparison);
+    writeJson(path14.join(outputDir, "compare.json"), comparison);
+    writeText(path14.join(outputDir, "summary.md"), summaryMd);
+    writeJson(path14.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
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as path16 from "path";
+import { existsSync as existsSync10 } from "fs";
+
+// src/mcp-server/register-prompts.ts
+import { z } from "zod";
+function registerMcpPrompts(server) {
+  server.prompt(
+    "search",
+    "Search codebase by meaning using semantic search",
+    { query: z.string().describe("What to search for in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Search the codebase for: "${args.query}"
+
+Use the codebase_search tool with this query. If you need just locations first, use codebase_peek instead to save tokens.`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "find",
+    "Find code using hybrid approach (semantic + grep)",
+    { query: z.string().describe("What to find in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Find code related to: "${args.query}"
+
+Use a hybrid approach:
+1. First use codebase_peek to find semantic matches by meaning
+2. Then use grep for exact identifier matches
+3. Combine results for comprehensive coverage`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "index",
+    "Index the codebase for semantic search",
+    { options: z.string().optional().describe("Options: 'force' to rebuild, 'estimate' to check costs") },
+    (args) => {
+      const opts = args.options?.toLowerCase() ?? "";
+      let instruction = "Use the index_codebase tool to index the codebase for semantic search.";
+      if (opts.includes("force")) {
+        instruction = "Use the index_codebase tool with force=true to rebuild the entire index from scratch.";
+      } else if (opts.includes("estimate")) {
+        instruction = "Use the index_codebase tool with estimateOnly=true to check the cost estimate before indexing.";
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: instruction }
+        }]
+      };
+    }
+  );
+  server.prompt(
+    "status",
+    "Check if the codebase is indexed and ready",
+    {},
+    () => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: "Use the index_status tool to check if the codebase index is ready and show its current state."
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "definition",
+    "Find where a symbol is defined in the codebase",
+    { query: z.string().describe("Symbol name or description to find the definition of") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Find the definition of: "${args.query}"
+
+Use the implementation_lookup tool to find where this symbol is defined. This prioritizes real implementation files over tests, docs, and examples. If no definition is found, fall back to codebase_search for broader discovery.`
+        }
+      }]
+    })
+  );
+}
+
+// src/mcp-server/register-tools.ts
+import { z as z2 } from "zod";
+
+// src/config/merger.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import * as os5 from "os";
+import * as path15 from "path";
+var PROJECT_OVERRIDE_KEYS = [
+  "embeddingProvider",
+  "customProvider",
+  "embeddingModel",
+  "reranker",
+  "include",
+  "exclude",
+  "indexing",
+  "search",
+  "debug",
+  "scope"
+];
+var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray4(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
+  if (key in normalizedProjectConfig) {
+    merged[key] = normalizedProjectConfig[key];
+    return;
+  }
+  if (key in globalConfig) {
+    merged[key] = globalConfig[key];
   }
-  if (subcommand === "diff") {
-    const { parsed, explicitAgainst } = parseEvalSubcommandOptions(args.slice(1), cwd);
-    if (!explicitAgainst) {
-      throw new Error("eval diff requires --against <baseline summary.json>");
+}
+function mergeUniqueStringArray(values) {
+  return [...new Set(values.map((value) => String(value).trim()))];
+}
+function normalizeKnowledgeBasePath(value) {
+  let normalized = path15.normalize(String(value).trim());
+  const root = path15.parse(normalized).root;
+  while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function mergeKnowledgeBasePaths(values) {
+  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
+}
+function validateConfigLayerShape(rawConfig, filePath) {
+  if (!isRecord3(rawConfig)) {
+    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+  }
+  if (rawConfig.knowledgeBases !== void 0 && !isStringArray4(rawConfig.knowledgeBases)) {
+    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (rawConfig.additionalInclude !== void 0 && !isStringArray4(rawConfig.additionalInclude)) {
+    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (rawConfig.include !== void 0 && !isStringArray4(rawConfig.include)) {
+    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (rawConfig.exclude !== void 0 && !isStringArray4(rawConfig.exclude)) {
+    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
+  }
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = rawConfig[section];
+    if (value !== void 0 && !isRecord3(value)) {
+      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
     }
-    if (!parsed.currentPath) {
-      throw new Error("eval diff requires --current <current summary.json>");
+  }
+  return rawConfig;
+}
+function loadJsonFile(filePath) {
+  if (!existsSync9(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync9(filePath, "utf-8");
+    return validateConfigLayerShape(JSON.parse(content), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Config file ")) {
+      throw error;
     }
-    parsed.againstPath = explicitAgainst;
-    const currentPath = parsed.currentPath;
-    if (!currentPath.endsWith(".json")) {
-      throw new Error("eval diff --current must point to a summary JSON file");
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config file ${filePath}: ${message}`);
+  }
+  return null;
+}
+function materializeLocalProjectConfig(projectRoot, config) {
+  const localConfigPath = path15.join(projectRoot, ".opencode", "codebase-index.json");
+  mkdirSync4(path15.dirname(localConfigPath), { recursive: true });
+  writeFileSync4(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
+  return localConfigPath;
+}
+function loadProjectConfigLayer(projectRoot) {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
+  }
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path15.dirname(path15.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot
+    );
+  }
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot) {
+  const globalConfigPath = os5.homedir() + "/.config/opencode/codebase-index.json";
+  const projectConfigPath = resolveProjectConfigPath(projectRoot);
+  let globalConfig = null;
+  let globalConfigError = null;
+  try {
+    globalConfig = loadJsonFile(globalConfigPath);
+  } catch (error) {
+    globalConfigError = error instanceof Error ? error : new Error(String(error));
+  }
+  const projectConfig = loadJsonFile(projectConfigPath);
+  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot);
+  if (globalConfigError) {
+    if (!projectConfig) {
+      throw globalConfigError;
     }
-    if (!parsed.againstPath.endsWith(".json")) {
-      throw new Error("eval diff --against must point to a summary JSON file");
+    globalConfig = null;
+  }
+  if (!globalConfig && !projectConfig) {
+    return {};
+  }
+  if (!projectConfig && globalConfig) {
+    return globalConfig;
+  }
+  if (!globalConfig && projectConfig) {
+    return normalizedProjectConfig;
+  }
+  if (!globalConfig || !projectConfig) {
+    return globalConfig ?? normalizedProjectConfig;
+  }
+  const merged = { ...globalConfig };
+  for (const key of PROJECT_OVERRIDE_KEYS) {
+    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
+  }
+  if (projectConfig) {
+    for (const key of Object.keys(projectConfig)) {
+      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
+        continue;
+      }
+      merged[key] = normalizedProjectConfig[key];
     }
-    const currentSummary = loadSummary(path10.resolve(parsed.projectRoot, currentPath), {
-      allowLegacyDiversityMetrics: true
-    });
-    const baselineSummary = loadSummary(path10.resolve(parsed.projectRoot, parsed.againstPath), {
-      allowLegacyDiversityMetrics: true
-    });
-    const comparison = compareSummaries(
-      currentSummary,
-      baselineSummary,
-      path10.resolve(parsed.projectRoot, parsed.againstPath)
-    );
-    const outputDir = createRunDirectory(path10.resolve(parsed.projectRoot, parsed.outputRoot));
-    const summaryMd = createSummaryMarkdown(currentSummary, comparison);
-    writeJson(path10.join(outputDir, "compare.json"), comparison);
-    writeText(path10.join(outputDir, "summary.md"), summaryMd);
-    writeJson(path10.join(outputDir, "summary.json"), currentSummary);
-    console.log(`Eval diff complete. Artifacts: ${outputDir}`);
-    return 0;
   }
-  throw new Error(`Unknown eval subcommand: ${subcommand}`);
+  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
+  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
+  const allKbs = [...globalKbs, ...projectKbs];
+  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
+  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
+  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
+  const allAdditional = [...globalAdditional, ...projectAdditional];
+  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
+  return merged;
 }
 
-// src/mcp-server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import * as path11 from "path";
-import { existsSync as existsSync8 } from "fs";
-
 // src/tools/utils.ts
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
@@ -9415,12 +9715,15 @@ function formatHealthCheck(result) {
   }
   return lines.join("\n");
 }
+function formatResultHeader(result, index) {
+  return result.name ? `[${index + 1}] ${result.chunkType} "${result.name}" in ${result.filePath}:${result.startLine}-${result.endLine}` : `[${index + 1}] ${result.chunkType} in ${result.filePath}:${result.startLine}-${result.endLine}`;
+}
 function formatDefinitionLookup(results, query) {
   if (results.length === 0) {
     return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
   }
   const formatted = results.map((r, idx) => {
-    const header = 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}`;
+    const header = formatResultHeader(r, idx);
     return `${header} (score: ${r.score.toFixed(2)})
 \`\`\`
 ${truncateContent(r.content)}
@@ -9429,7 +9732,7 @@ ${truncateContent(r.content)}
   return formatted.join("\n\n");
 }
 
-// src/mcp-server.ts
+// src/mcp-server/shared.ts
 var MAX_CONTENT_LINES2 = 30;
 function truncateContent2(content) {
   const lines = content.split("\n");
@@ -9450,50 +9753,23 @@ var CHUNK_TYPE_ENUM = [
   "module",
   "other"
 ];
-function createMcpServer(projectRoot, config) {
-  const server = new McpServer({
-    name: "opencode-codebase-index",
-    version: "0.5.1"
-  });
-  const runtimeConfig = config;
-  let indexer = new Indexer(projectRoot, runtimeConfig);
-  let initialized = false;
-  function refreshIndexerFromConfig() {
-    indexer = new Indexer(projectRoot, runtimeConfig);
-    initialized = false;
-  }
-  function shouldForceLocalizeProjectIndex() {
-    if (runtimeConfig.scope !== "project") {
-      return false;
-    }
-    const localIndexPath = path11.join(projectRoot, ".opencode", "index");
-    const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
-    if (!mainRepoRoot) {
-      return false;
-    }
-    const inheritedIndexPath = path11.join(mainRepoRoot, ".opencode", "index");
-    return !existsSync8(localIndexPath) && existsSync8(inheritedIndexPath);
-  }
-  async function ensureInitialized() {
-    if (!initialized) {
-      await indexer.initialize();
-      initialized = true;
-    }
-  }
+
+// src/mcp-server/register-tools.ts
+function registerMcpTools(server, runtime) {
   server.tool(
     "codebase_search",
     "Search codebase by MEANING, not keywords. Returns full code content. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead.",
     {
-      query: z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
-      limit: z.number().optional().default(5).describe("Maximum number of results to return"),
-      fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-      directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-      chunkType: z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
-      contextLines: z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
+      query: z2.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
+      limit: z2.number().optional().default(5).describe("Maximum number of results to return"),
+      fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: z2.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
+      contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
     },
     async (args) => {
-      await ensureInitialized();
-      const results = await indexer.search(args.query, args.limit ?? 5, {
+      await runtime.ensureInitialized();
+      const results = await runtime.getIndexer().search(args.query, args.limit ?? 5, {
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -9518,15 +9794,15 @@ ${formatted.join("\n\n")}` }] };
     "codebase_peek",
     "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Saves ~90% tokens vs codebase_search.",
     {
-      query: z.string().describe("Natural language description of what code you're looking for."),
-      limit: z.number().optional().default(10).describe("Maximum number of results to return"),
-      fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-      directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-      chunkType: z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type")
+      query: z2.string().describe("Natural language description of what code you're looking for."),
+      limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
+      fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: z2.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type")
     },
     async (args) => {
-      await ensureInitialized();
-      const results = await indexer.search(args.query, args.limit ?? 10, {
+      await runtime.ensureInitialized();
+      const results = await runtime.getIndexer().search(args.query, args.limit ?? 10, {
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -9551,29 +9827,29 @@ Use Read tool to examine specific files.` }] };
     "index_codebase",
     "Index the codebase for semantic search. Creates vector embeddings of code chunks. Incremental - only re-indexes changed files. Run before first codebase_search.",
     {
-      force: z.boolean().optional().default(false).describe("Force reindex even if already indexed"),
-      estimateOnly: z.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
-      verbose: z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
+      force: z2.boolean().optional().default(false).describe("Force reindex even if already indexed"),
+      estimateOnly: z2.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
+      verbose: z2.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
     },
     async (args) => {
       if (args.estimateOnly) {
-        await ensureInitialized();
-        const estimate = await indexer.estimateCost();
+        await runtime.ensureInitialized();
+        const estimate = await runtime.getIndexer().estimateCost();
         return { content: [{ type: "text", text: formatCostEstimate(estimate) }] };
       }
       if (args.force) {
-        if (shouldForceLocalizeProjectIndex()) {
-          materializeLocalProjectConfig(projectRoot, loadProjectConfigLayer(projectRoot));
-          refreshIndexerFromConfig();
+        if (runtime.shouldForceLocalizeProjectIndex()) {
+          materializeLocalProjectConfig(runtime.projectRoot, loadProjectConfigLayer(runtime.projectRoot));
+          runtime.refreshIndexerFromConfig();
         }
-        await ensureInitialized();
-        await indexer.clearIndex();
-        refreshIndexerFromConfig();
-        await ensureInitialized();
+        await runtime.ensureInitialized();
+        await runtime.getIndexer().clearIndex();
+        runtime.refreshIndexerFromConfig();
+        await runtime.ensureInitialized();
       } else {
-        await ensureInitialized();
+        await runtime.ensureInitialized();
       }
-      const stats = await indexer.index();
+      const stats = await runtime.getIndexer().index();
       return { content: [{ type: "text", text: formatIndexStats(stats, args.verbose ?? false) }] };
     }
   );
@@ -9582,8 +9858,8 @@ Use Read tool to examine specific files.` }] };
     "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
     {},
     async () => {
-      await ensureInitialized();
-      const status = await indexer.getStatus();
+      await runtime.ensureInitialized();
+      const status = await runtime.getIndexer().getStatus();
       return { content: [{ type: "text", text: formatStatus(status) }] };
     }
   );
@@ -9592,8 +9868,8 @@ Use Read tool to examine specific files.` }] };
     "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
     {},
     async () => {
-      await ensureInitialized();
-      const result = await indexer.healthCheck();
+      await runtime.ensureInitialized();
+      const result = await runtime.getIndexer().healthCheck();
       return { content: [{ type: "text", text: formatHealthCheck(result) }] };
     }
   );
@@ -9602,8 +9878,8 @@ Use Read tool to examine specific files.` }] };
     "Get metrics and performance statistics for the codebase index. Requires debug.enabled=true and debug.metrics=true in config.",
     {},
     async () => {
-      await ensureInitialized();
-      const logger = indexer.getLogger();
+      await runtime.ensureInitialized();
+      const logger = runtime.getIndexer().getLogger();
       if (!logger.isEnabled()) {
         return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```' }] };
       }
@@ -9617,13 +9893,13 @@ Use Read tool to examine specific files.` }] };
     "index_logs",
     "Get recent debug logs from the codebase indexer. Requires debug.enabled=true in config.",
     {
-      limit: z.number().optional().default(20).describe("Maximum number of log entries to return"),
-      category: z.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
-      level: z.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
+      limit: z2.number().optional().default(20).describe("Maximum number of log entries to return"),
+      category: z2.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
+      level: z2.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
     },
     async (args) => {
-      await ensureInitialized();
-      const logger = indexer.getLogger();
+      await runtime.ensureInitialized();
+      const logger = runtime.getIndexer().getLogger();
       if (!logger.isEnabled()) {
         return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```' }] };
       }
@@ -9649,16 +9925,16 @@ Use Read tool to examine specific files.` }] };
     "find_similar",
     "Find code similar to a given snippet. Use for duplicate detection, pattern discovery, or refactoring prep.",
     {
-      code: z.string().describe("The code snippet to find similar code for"),
-      limit: z.number().optional().default(10).describe("Maximum number of results to return"),
-      fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-      directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-      chunkType: z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
-      excludeFile: z.string().optional().describe("Exclude results from this file path")
+      code: z2.string().describe("The code snippet to find similar code for"),
+      limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
+      fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: z2.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
+      excludeFile: z2.string().optional().describe("Exclude results from this file path")
     },
     async (args) => {
-      await ensureInitialized();
-      const results = await indexer.findSimilar(args.code, args.limit ?? 10, {
+      await runtime.ensureInitialized();
+      const results = await runtime.getIndexer().findSimilar(args.code, args.limit ?? 10, {
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -9683,14 +9959,14 @@ ${formatted.join("\n\n")}` }] };
     "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: z.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
-      limit: z.number().optional().default(5).describe("Maximum number of results"),
-      fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
-      directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
+      query: z2.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
+      limit: z2.number().optional().default(5).describe("Maximum number of results"),
+      fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
+      directory: z2.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, {
+      await runtime.ensureInitialized();
+      const results = await runtime.getIndexer().search(args.query, args.limit ?? 5, {
         fileType: args.fileType,
         directory: args.directory,
         definitionIntent: true
@@ -9702,12 +9978,13 @@ ${formatted.join("\n\n")}` }] };
     "call_graph",
     "Query the call graph to find callers or callees of a function/method. Use to understand code flow and dependencies.",
     {
-      name: z.string().describe("Function or method name to query"),
-      direction: z.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
-      symbolId: z.string().optional().describe("Symbol ID (required for 'callees' direction)")
+      name: z2.string().describe("Function or method name to query"),
+      direction: z2.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
+      symbolId: z2.string().optional().describe("Symbol ID (required for 'callees' direction)")
     },
     async (args) => {
-      await ensureInitialized();
+      await runtime.ensureInitialized();
+      const indexer = runtime.getIndexer();
       if (args.direction === "callees") {
         if (!args.symbolId) {
           return { content: [{ type: "text", text: "Error: 'symbolId' is required when direction is 'callees'." }] };
@@ -9735,91 +10012,46 @@ ${formatted2.join("\n")}` }] };
 ${formatted.join("\n")}` }] };
     }
   );
-  server.prompt(
-    "search",
-    "Search codebase by meaning using semantic search",
-    { query: z.string().describe("What to search for in the codebase") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Search the codebase for: "${args.query}"
-
-Use the codebase_search tool with this query. If you need just locations first, use codebase_peek instead to save tokens.`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "find",
-    "Find code using hybrid approach (semantic + grep)",
-    { query: z.string().describe("What to find in the codebase") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Find code related to: "${args.query}"
+}
 
-Use a hybrid approach:
-1. First use codebase_peek to find semantic matches by meaning
-2. Then use grep for exact identifier matches
-3. Combine results for comprehensive coverage`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "index",
-    "Index the codebase for semantic search",
-    { options: z.string().optional().describe("Options: 'force' to rebuild, 'estimate' to check costs") },
-    (args) => {
-      const opts = args.options?.toLowerCase() ?? "";
-      let instruction = "Use the index_codebase tool to index the codebase for semantic search.";
-      if (opts.includes("force")) {
-        instruction = "Use the index_codebase tool with force=true to rebuild the entire index from scratch.";
-      } else if (opts.includes("estimate")) {
-        instruction = "Use the index_codebase tool with estimateOnly=true to check the cost estimate before indexing.";
-      }
-      return {
-        messages: [{
-          role: "user",
-          content: { type: "text", text: instruction }
-        }]
-      };
+// src/mcp-server.ts
+function createMcpServer(projectRoot, config) {
+  const server = new McpServer({
+    name: "opencode-codebase-index",
+    version: "0.5.1"
+  });
+  let indexer = new Indexer(projectRoot, config);
+  let initialized = false;
+  function refreshIndexerFromConfig() {
+    indexer = new Indexer(projectRoot, config);
+    initialized = false;
+  }
+  function shouldForceLocalizeProjectIndex() {
+    if (config.scope !== "project") {
+      return false;
     }
-  );
-  server.prompt(
-    "status",
-    "Check if the codebase is indexed and ready",
-    {},
-    () => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: "Use the index_status tool to check if the codebase index is ready and show its current state."
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "definition",
-    "Find where a symbol is defined in the codebase",
-    { query: z.string().describe("Symbol name or description to find the definition of") },
-    (args) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Find the definition of: "${args.query}"
-
-Use the implementation_lookup tool to find where this symbol is defined. This prioritizes real implementation files over tests, docs, and examples. If no definition is found, fall back to codebase_search for broader discovery.`
-        }
-      }]
-    })
-  );
+    const localIndexPath = path16.join(projectRoot, ".opencode", "index");
+    const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+    if (!mainRepoRoot) {
+      return false;
+    }
+    const inheritedIndexPath = path16.join(mainRepoRoot, ".opencode", "index");
+    return !existsSync10(localIndexPath) && existsSync10(inheritedIndexPath);
+  }
+  async function ensureInitialized() {
+    if (!initialized) {
+      await indexer.initialize();
+      initialized = true;
+    }
+  }
+  registerMcpTools(server, {
+    projectRoot,
+    ensureInitialized,
+    getIndexer: () => indexer,
+    refreshIndexerFromConfig,
+    shouldForceLocalizeProjectIndex
+  });
+  registerMcpPrompts(server);
   return server;
 }
 
@@ -9829,9 +10061,9 @@ function parseArgs(argv) {
   let config;
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path12.resolve(argv[++i]);
+      project = path17.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path12.resolve(argv[++i]);
+      config = path17.resolve(argv[++i]);
     }
   }
   return { project, config };