opencode-codebase-index 0.7.0 → 0.8.1

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(path11, checkUnignored, mode) {
+      test(path13, 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(path11);
+          const matched = rule[mode].test(path13);
           if (!matched) {
             return;
           }
@@ -517,17 +517,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path11, originalPath, doThrow) => {
-      if (!isString(path11)) {
+    var checkPath = (path13, originalPath, doThrow) => {
+      if (!isString(path13)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path11) {
+      if (!path13) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path11)) {
+      if (checkPath.isNotRelative(path13)) {
         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 = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
+    var isNotRelative = (path13) => REGEX_TEST_INVALID_PATH.test(path13);
     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 path11 = originalPath && checkPath.convert(originalPath);
+        const path13 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path11,
+          path13,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path11, cache, checkUnignored, slices);
+        return this._t(path13, cache, checkUnignored, slices);
       }
-      checkIgnore(path11) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path11)) {
-          return this.test(path11);
+      checkIgnore(path13) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path13)) {
+          return this.test(path13);
         }
-        const slices = path11.split(SLASH).filter(Boolean);
+        const slices = path13.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(path11, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path13, false, MODE_CHECK_IGNORE);
       }
-      _t(path11, cache, checkUnignored, slices) {
-        if (path11 in cache) {
-          return cache[path11];
+      _t(path13, cache, checkUnignored, slices) {
+        if (path13 in cache) {
+          return cache[path13];
         }
         if (!slices) {
-          slices = path11.split(SLASH).filter(Boolean);
+          slices = path13.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path11] = this._rules.test(path11, checkUnignored, MODE_IGNORE);
+          return cache[path13] = this._rules.test(path13, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -610,29 +610,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path11] = parent.ignored ? parent : this._rules.test(path11, checkUnignored, MODE_IGNORE);
+        return cache[path13] = parent.ignored ? parent : this._rules.test(path13, checkUnignored, MODE_IGNORE);
       }
-      ignores(path11) {
-        return this._test(path11, this._ignoreCache, false).ignored;
+      ignores(path13) {
+        return this._test(path13, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path11) => !this.ignores(path11);
+        return (path13) => !this.ignores(path13);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path11) {
-        return this._test(path11, this._testCache, true);
+      test(path13) {
+        return this._test(path13, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
+    var isPathValid = (path13) => checkPath(path13 && checkPath.convert(path13), path13, 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 = (path11) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
+      checkPath.isNotRelative = (path13) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path13) || isNotRelative(path13);
     };
     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 path10 from "path";
+import * as path12 from "path";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -658,12 +658,14 @@ var DEFAULT_INCLUDE = [
   "**/*.{go,rs,java,kt,scala}",
   "**/*.{c,cpp,cc,h,hpp}",
   "**/*.{rb,php,inc,swift}",
+  "**/*.{cls,trigger}",
   "**/*.{vue,svelte,astro}",
   "**/*.{sql,graphql,proto}",
   "**/*.{yaml,yml,toml}",
   "**/*.{md,mdx}",
   "**/*.{sh,bash,zsh}",
-  "**/*.{txt,html,htm}"
+  "**/*.{txt,html,htm}",
+  "**/*.zig"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -728,7 +730,7 @@ var EMBEDDING_MODELS = {
       provider: "ollama",
       model: "nomic-embed-text",
       dimensions: 768,
-      maxTokens: 8192,
+      maxTokens: 2048,
       costPer1MTokens: 0
     },
     "mxbai-embed-large": {
@@ -752,9 +754,15 @@ var EMBEDDING_MODELS = {
 var DEFAULT_PROVIDER_MODELS = {
   "github-copilot": "text-embedding-3-small",
   "openai": "text-embedding-3-small",
-  "google": "text-embedding-005",
+  "google": "gemini-embedding-001",
   "ollama": "nomic-embed-text"
 };
+var AUTO_DETECT_PROVIDER_ORDER = [
+  "ollama",
+  "github-copilot",
+  "openai",
+  "google"
+];
 
 // src/config/env-substitution.ts
 var ENV_REFERENCE_PATTERN = /^\{env:([A-Z_][A-Z0-9_]*)\}$/;
@@ -1013,9 +1021,12 @@ function getDefaultModelForProvider(provider) {
   return models[providerDefault];
 }
 var availableProviders = Object.keys(EMBEDDING_MODELS);
+var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
+  (provider) => provider in EMBEDDING_MODELS
+);
 
 // src/eval/cli.ts
-import * as path8 from "path";
+import * as path10 from "path";
 
 // src/eval/compare.ts
 function metricDelta(current, baseline) {
@@ -1058,9 +1069,9 @@ function compareSummaries(current, baseline, againstPath) {
 // src/eval/reports.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
-function assertFiniteNumber(value, path11) {
+function assertFiniteNumber(value, path13) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path11} must be a finite number`);
+    throw new Error(`${path13} must be a finite number`);
   }
   return value;
 }
@@ -1234,16 +1245,352 @@ function buildPerQueryArtifact(perQuery) {
 }
 
 // src/eval/runner.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync7 } from "fs";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { rmSync } from "fs";
-import * as os3 from "os";
-import * as path7 from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import * as os5 from "os";
+import * as path9 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/config/paths.ts
+import { existsSync as existsSync2 } from "fs";
+import * as os from "os";
+import * as path3 from "path";
+
+// 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;
+  }
+  try {
+    const raw = readFileSync2(commonDirPath, "utf-8").trim();
+    if (!raw) {
+      return gitDir;
+    }
+    const resolved = path2.isAbsolute(raw) ? raw : path2.resolve(gitDir, raw);
+    if (existsSync(resolved)) {
+      return resolved;
+    }
+  } 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 (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;
+        }
+      }
+    }
+  } 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;
+      }
+      const packedRefs = readPackedRefs(refStoreDir);
+      if (packedRefs.some((line) => line.endsWith(` refs/heads/${candidate}`))) {
+        return candidate;
+      }
+    }
+  }
+  return getCurrentBranch(repoRoot) ?? "main";
+}
+function getBranchOrDefault(repoRoot) {
+  if (!isGitRepo(repoRoot)) {
+    return "default";
+  }
+  return getCurrentBranch(repoRoot) ?? "default";
+}
+
+// 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;
+  }
+  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 existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2, renameSync, unlinkSync, promises as fsPromises2 } from "fs";
-import * as path6 from "path";
+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
@@ -1268,7 +1615,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve6, reject) => {
+  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}\``);
     }
@@ -1282,7 +1629,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve6, reject);
+    promise.then(resolve8, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1290,7 +1637,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve6(fallback());
+          resolve8(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1300,7 +1647,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve6();
+        resolve8();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1702,7 +2049,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -1742,7 +2089,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve6(result);
+          resolve8(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1930,13 +2277,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve8) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve6();
+        resolve8();
       };
       this.on(event, listener);
     });
@@ -2222,7 +2569,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve8, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2230,7 +2577,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve6();
+        resolve8();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -2291,17 +2638,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import * as path2 from "path";
-import * as os from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
 function getOpenCodeAuthPath() {
-  return path2.join(os.homedir(), ".local", "share", "opencode", "auth.json");
+  return path5.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync(authPath)) {
-      return JSON.parse(readFileSync2(authPath, "utf-8"));
+    if (existsSync4(authPath)) {
+      return JSON.parse(readFileSync4(authPath, "utf-8"));
     }
   } catch {
   }
@@ -2334,7 +2681,7 @@ async function detectEmbeddingProvider(preferredProvider, model) {
   );
 }
 async function tryDetectProvider() {
-  for (const provider of availableProviders) {
+  for (const provider of autoDetectProviders) {
     const credentials = await getProviderCredentials(provider);
     if (credentials) {
       return {
@@ -2345,7 +2692,7 @@ async function tryDetectProvider() {
     }
   }
   throw new Error(
-    `No embedding-capable provider found. Please authenticate with OpenCode using one of: ${availableProviders.join(", ")}.`
+    `No embedding-capable provider found. Please authenticate with OpenCode using one of: ${autoDetectProviders.join(", ")}.`
   );
 }
 async function getProviderCredentials(provider) {
@@ -2665,11 +3012,12 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
     return this.modelInfo;
   }
 };
-var OllamaEmbeddingProvider = class {
+var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
   constructor(credentials, modelInfo) {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
+  static MIN_TRUNCATION_CHARS = 512;
   async embedQuery(query) {
     const result = await this.embedBatch([query]);
     return {
@@ -2684,52 +3032,125 @@ var OllamaEmbeddingProvider = class {
       tokensUsed: result.totalTokensUsed
     };
   }
-  async embedBatch(texts) {
-    const results = await Promise.all(
-      texts.map(async (text) => {
-        const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            model: this.modelInfo.model,
-            prompt: text
-          })
-        });
-        if (!response.ok) {
-          const error = await response.text();
-          throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        return {
-          embedding: data.embedding,
-          tokensUsed: Math.ceil(text.length / 4)
-        };
-      })
-    );
-    return {
-      embeddings: results.map((r) => r.embedding),
-      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
-    };
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
   }
-  getModelInfo() {
-    return this.modelInfo;
+  truncateToCharLimit(text, maxChars) {
+    if (text.length <= maxChars) {
+      return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 17))}
+... [truncated]`;
   }
-};
-var CustomEmbeddingProvider = class {
-  constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+  isContextLengthError(error) {
+    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    return message.includes("context length") && (message.includes("exceed") || message.includes("exceeded") || message.includes("too long")) || message.includes("input length exceeds the context length") || message.includes("context length exceeded");
   }
-  splitIntoRequestBatches(texts) {
-    const maxBatchSize = this.modelInfo.maxBatchSize;
-    if (!maxBatchSize || texts.length <= maxBatchSize) {
-      return [texts];
+  buildTruncationCandidates(text) {
+    const baseMaxChars = Math.max(1, this.modelInfo.maxTokens * 4);
+    const candidateLimits = /* @__PURE__ */ new Set();
+    const baselineLimit = text.length > baseMaxChars ? baseMaxChars : Math.max(
+      _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS,
+      Math.floor(text.length * 0.9)
+    );
+    if (baselineLimit < text.length) {
+      candidateLimits.add(baselineLimit);
     }
-    const batches = [];
-    for (let i = 0; i < texts.length; i += maxBatchSize) {
-      batches.push(texts.slice(i, i + maxBatchSize));
+    for (const factor of [0.75, 0.6, 0.45, 0.35, 0.25]) {
+      const scaledLimit = Math.max(
+        _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS,
+        Math.floor(baselineLimit * factor)
+      );
+      if (scaledLimit < text.length) {
+        candidateLimits.add(scaledLimit);
+      }
+    }
+    candidateLimits.add(Math.min(text.length - 1, _OllamaEmbeddingProvider.MIN_TRUNCATION_CHARS));
+    const candidates = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const limit of [...candidateLimits].sort((a, b) => b - a)) {
+      if (limit <= 0 || limit >= text.length) {
+        continue;
+      }
+      const truncated = this.truncateToCharLimit(text, limit);
+      if (truncated === text || seen.has(truncated)) {
+        continue;
+      }
+      seen.add(truncated);
+      candidates.push(truncated);
+    }
+    return candidates;
+  }
+  async embedSingleWithFallback(text) {
+    try {
+      return await this.embedSingle(text);
+    } catch (error) {
+      if (!this.isContextLengthError(error)) {
+        throw error;
+      }
+      let lastError = error;
+      for (const truncated of this.buildTruncationCandidates(text)) {
+        try {
+          return await this.embedSingle(truncated);
+        } catch (retryError) {
+          if (!this.isContextLengthError(retryError)) {
+            throw retryError;
+          }
+          lastError = retryError;
+        }
+      }
+      throw lastError;
+    }
+  }
+  async embedSingle(text) {
+    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.modelInfo.model,
+        prompt: text,
+        truncate: false
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      embedding: data.embedding,
+      tokensUsed: this.estimateTokens(text)
+    };
+  }
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embedSingleWithFallback(text));
+    }
+    return {
+      embeddings: results.map((r) => r.embedding),
+      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
+    };
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
+var CustomEmbeddingProvider = class {
+  constructor(credentials, modelInfo) {
+    this.credentials = credentials;
+    this.modelInfo = 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;
   }
@@ -2911,8 +3332,8 @@ var SiliconFlowReranker = class {
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync2, readFileSync as readFileSync3, promises as fsPromises } from "fs";
-import * as path3 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, promises as fsPromises } from "fs";
+import * as path6 from "path";
 function createIgnoreFilter(projectRoot) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -2933,9 +3354,9 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path3.join(projectRoot, ".gitignore");
-  if (existsSync2(gitignorePath)) {
-    const gitignoreContent = readFileSync3(gitignorePath, "utf-8");
+  const gitignorePath = path6.join(projectRoot, ".gitignore");
+  if (existsSync5(gitignorePath)) {
+    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
@@ -2960,8 +3381,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path3.join(dir, entry.name);
-    const relativePath = path3.relative(projectRoot, fullPath);
+    const fullPath = path6.join(dir, entry.name);
+    const relativePath = path6.relative(projectRoot, fullPath);
     if (entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..") {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3010,7 +3431,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path3.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path6.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3050,8 +3471,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 = path3.normalize(
-        path3.isAbsolute(kbRoot) ? kbRoot : path3.resolve(projectRoot, kbRoot)
+      const resolved = path6.normalize(
+        path6.isAbsolute(kbRoot) ? kbRoot : path6.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3441,13 +3862,13 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path4 from "path";
-import * as os2 from "os";
+import * as path7 from "path";
+import * as os4 from "os";
 import * as module from "module";
 import { fileURLToPath } from "url";
 function getNativeBinding() {
-  const platform2 = os2.platform();
-  const arch2 = os2.arch();
+  const platform2 = os4.platform();
+  const arch2 = os4.arch();
   let bindingName;
   if (platform2 === "darwin" && arch2 === "arm64") {
     bindingName = "codebase-index-native.darwin-arm64.node";
@@ -3465,18 +3886,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path4.dirname(fileURLToPath(import.meta.url));
+    currentDir = path7.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path4.join(currentDir, "index.js");
+    requireTarget = path7.join(currentDir, "index.js");
   }
-  const isDevMode = currentDir.includes("/src/native");
-  const packageRoot = isDevMode ? path4.resolve(currentDir, "../..") : path4.resolve(currentDir, "..");
-  const nativePath = path4.join(packageRoot, "native", bindingName);
+  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 require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -3507,11 +3929,20 @@ function createMockNativeBinding() {
       constructor() {
         throw error;
       }
+      serialize() {
+        throw error;
+      }
+      deserialize() {
+        throw error;
+      }
     },
     Database: class {
       constructor() {
         throw error;
       }
+      close() {
+        throw error;
+      }
     }
   };
 }
@@ -3644,7 +4075,7 @@ var MAX_SINGLE_CHUNK_TOKENS = 2e3;
 function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
-function createEmbeddingText(chunk, filePath) {
+function getEmbeddingHeaderParts(chunk, filePath) {
   const parts = [];
   const fileName = filePath.split("/").pop() || filePath;
   const dirPath = filePath.split("/").slice(-3, -1).join("/");
@@ -3691,23 +4122,52 @@ function createEmbeddingText(chunk, filePath) {
   if (semanticHints.length > 0) {
     parts.push(`Purpose: ${semanticHints.join(", ")}`);
   }
-  parts.push("");
-  let content = chunk.content;
-  const headerLength = parts.join("\n").length;
-  const maxContentChars = MAX_SINGLE_CHUNK_TOKENS * CHARS_PER_TOKEN - headerLength;
-  if (content.length > maxContentChars) {
-    content = content.slice(0, maxContentChars) + "\n... [truncated]";
+  return parts;
+}
+function buildEmbeddingText(headerParts, content, partIndex, partCount) {
+  const parts = [...headerParts];
+  if (partCount && partCount > 1 && partIndex) {
+    parts.push(`Part ${partIndex}/${partCount}`);
   }
+  parts.push("");
   parts.push(content);
   return parts.join("\n");
 }
-function createDynamicBatches(chunks) {
+function splitOversizedContent(content, maxContentChars) {
+  if (content.length <= maxContentChars) {
+    return [content];
+  }
+  const overlapChars = Math.max(CHARS_PER_TOKEN * 32, Math.min(Math.floor(maxContentChars * 0.15), CHARS_PER_TOKEN * 128));
+  const stepChars = Math.max(1, maxContentChars - overlapChars);
+  const segments = [];
+  for (let start = 0; start < content.length; start += stepChars) {
+    const end = Math.min(content.length, start + maxContentChars);
+    segments.push(content.slice(start, end));
+    if (end >= content.length) {
+      break;
+    }
+  }
+  return segments;
+}
+function createEmbeddingTexts(chunk, filePath, maxChunkTokens = MAX_SINGLE_CHUNK_TOKENS) {
+  const headerParts = getEmbeddingHeaderParts(chunk, filePath);
+  const headerLength = buildEmbeddingText(headerParts, "", 1, 9).length;
+  const maxContentChars = Math.max(1, maxChunkTokens * CHARS_PER_TOKEN - headerLength);
+  const segments = splitOversizedContent(chunk.content, maxContentChars);
+  if (segments.length === 1) {
+    return [buildEmbeddingText(headerParts, segments[0])];
+  }
+  return segments.map((segment, index) => buildEmbeddingText(headerParts, segment, index + 1, segments.length));
+}
+function createDynamicBatches(chunks, options = {}) {
   const batches = [];
   let currentBatch = [];
   let currentTokens = 0;
+  const maxBatchTokens = Math.max(1, options.maxBatchTokens ?? MAX_BATCH_TOKENS);
+  const maxBatchItems = Math.max(1, options.maxBatchItems ?? Number.MAX_SAFE_INTEGER);
   for (const chunk of chunks) {
-    const chunkTokens = estimateTokens2(chunk.text);
-    if (currentBatch.length > 0 && currentTokens + chunkTokens > MAX_BATCH_TOKENS) {
+    const chunkTokens = chunk.tokenCount ?? estimateTokens2(chunk.text);
+    if (currentBatch.length > 0 && (currentTokens + chunkTokens > maxBatchTokens || currentBatch.length >= maxBatchItems)) {
       batches.push(currentBatch);
       currentBatch = [];
       currentTokens = 0;
@@ -3826,6 +4286,12 @@ var InvertedIndex = class {
   save() {
     this.inner.save();
   }
+  serialize() {
+    return this.inner.serialize();
+  }
+  deserialize(json) {
+    this.inner.deserialize(json);
+  }
   addChunk(chunkId, content) {
     this.inner.addChunk(chunkId, content);
   }
@@ -3852,267 +4318,263 @@ var InvertedIndex = class {
 };
 var Database = class {
   inner;
+  closed = false;
   constructor(dbPath) {
     this.inner = new native.Database(dbPath);
   }
+  throwIfClosed() {
+    if (this.closed) {
+      throw new Error("Database is closed");
+    }
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    if (typeof this.inner.close === "function") {
+      this.inner.close();
+    }
+    this.closed = true;
+  }
   embeddingExists(contentHash) {
+    this.throwIfClosed();
     return this.inner.embeddingExists(contentHash);
   }
   getEmbedding(contentHash) {
+    this.throwIfClosed();
     return this.inner.getEmbedding(contentHash) ?? null;
   }
   upsertEmbedding(contentHash, embedding, chunkText, model) {
+    this.throwIfClosed();
     this.inner.upsertEmbedding(contentHash, embedding, chunkText, model);
   }
   upsertEmbeddingsBatch(items) {
+    this.throwIfClosed();
     if (items.length === 0) return;
     this.inner.upsertEmbeddingsBatch(items);
   }
   getMissingEmbeddings(contentHashes) {
+    this.throwIfClosed();
     return this.inner.getMissingEmbeddings(contentHashes);
   }
   upsertChunk(chunk) {
+    this.throwIfClosed();
     this.inner.upsertChunk(chunk);
   }
   upsertChunksBatch(chunks) {
+    this.throwIfClosed();
     if (chunks.length === 0) return;
     this.inner.upsertChunksBatch(chunks);
   }
   getChunk(chunkId) {
+    this.throwIfClosed();
     return this.inner.getChunk(chunkId) ?? null;
   }
   getChunksByFile(filePath) {
+    this.throwIfClosed();
     return this.inner.getChunksByFile(filePath);
   }
   getChunksByName(name) {
+    this.throwIfClosed();
     return this.inner.getChunksByName(name);
   }
   getChunksByNameCi(name) {
+    this.throwIfClosed();
     return this.inner.getChunksByNameCi(name);
   }
   deleteChunksByFile(filePath) {
+    this.throwIfClosed();
     return this.inner.deleteChunksByFile(filePath);
   }
+  deleteChunksByIds(chunkIds) {
+    this.throwIfClosed();
+    if (chunkIds.length === 0) return 0;
+    return this.inner.deleteChunksByIds(chunkIds);
+  }
   addChunksToBranch(branch, chunkIds) {
+    this.throwIfClosed();
     this.inner.addChunksToBranch(branch, chunkIds);
   }
   addChunksToBranchBatch(branch, chunkIds) {
+    this.throwIfClosed();
     if (chunkIds.length === 0) return;
     this.inner.addChunksToBranchBatch(branch, chunkIds);
   }
   clearBranch(branch) {
+    this.throwIfClosed();
     return this.inner.clearBranch(branch);
   }
+  deleteBranchChunksByChunkIds(chunkIds) {
+    this.throwIfClosed();
+    if (chunkIds.length === 0) return 0;
+    return this.inner.deleteBranchChunksByChunkIds(chunkIds);
+  }
+  deleteBranchChunksForBranch(branch, chunkIds) {
+    this.throwIfClosed();
+    if (chunkIds.length === 0) return 0;
+    return this.inner.deleteBranchChunksForBranch(branch, chunkIds);
+  }
   getBranchChunkIds(branch) {
+    this.throwIfClosed();
     return this.inner.getBranchChunkIds(branch);
   }
   getBranchDelta(branch, baseBranch) {
+    this.throwIfClosed();
     return this.inner.getBranchDelta(branch, baseBranch);
   }
+  getReferencedChunkIds(chunkIds) {
+    this.throwIfClosed();
+    if (chunkIds.length === 0) return [];
+    return this.inner.getReferencedChunkIds(chunkIds);
+  }
   chunkExistsOnBranch(branch, chunkId) {
+    this.throwIfClosed();
     return this.inner.chunkExistsOnBranch(branch, chunkId);
   }
   getAllBranches() {
+    this.throwIfClosed();
     return this.inner.getAllBranches();
   }
   getMetadata(key) {
+    this.throwIfClosed();
     return this.inner.getMetadata(key) ?? null;
   }
   setMetadata(key, value) {
+    this.throwIfClosed();
     this.inner.setMetadata(key, value);
   }
   deleteMetadata(key) {
+    this.throwIfClosed();
     return this.inner.deleteMetadata(key);
   }
+  clearAllIndexedData() {
+    this.throwIfClosed();
+    this.inner.clearAllIndexedData();
+  }
+  clearCallEdgeTargetsForSymbols(symbolIds) {
+    this.throwIfClosed();
+    if (symbolIds.length === 0) return 0;
+    return this.inner.clearCallEdgeTargetsForSymbols(symbolIds);
+  }
   gcOrphanEmbeddings() {
+    this.throwIfClosed();
     return this.inner.gcOrphanEmbeddings();
   }
   gcOrphanChunks() {
+    this.throwIfClosed();
     return this.inner.gcOrphanChunks();
   }
   getStats() {
+    this.throwIfClosed();
     return this.inner.getStats();
   }
   // ── Symbol methods ──────────────────────────────────────────────
   upsertSymbol(symbol) {
+    this.throwIfClosed();
     this.inner.upsertSymbol(symbol);
   }
   upsertSymbolsBatch(symbols) {
+    this.throwIfClosed();
     if (symbols.length === 0) return;
     this.inner.upsertSymbolsBatch(symbols);
   }
   getSymbolsByFile(filePath) {
+    this.throwIfClosed();
     return this.inner.getSymbolsByFile(filePath);
   }
   getSymbolByName(name, filePath) {
+    this.throwIfClosed();
     return this.inner.getSymbolByName(name, filePath) ?? null;
   }
   getSymbolsByName(name) {
+    this.throwIfClosed();
     return this.inner.getSymbolsByName(name);
   }
   getSymbolsByNameCi(name) {
+    this.throwIfClosed();
     return this.inner.getSymbolsByNameCi(name);
   }
   deleteSymbolsByFile(filePath) {
+    this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
   }
   // ── Call Edge methods ────────────────────────────────────────────
   upsertCallEdge(edge) {
+    this.throwIfClosed();
     this.inner.upsertCallEdge(edge);
   }
   upsertCallEdgesBatch(edges) {
+    this.throwIfClosed();
     if (edges.length === 0) return;
     this.inner.upsertCallEdgesBatch(edges);
   }
   getCallers(targetName, branch) {
+    this.throwIfClosed();
     return this.inner.getCallers(targetName, branch);
   }
   getCallersWithContext(targetName, branch) {
+    this.throwIfClosed();
     return this.inner.getCallersWithContext(targetName, branch);
   }
   getCallees(symbolId, branch) {
+    this.throwIfClosed();
     return this.inner.getCallees(symbolId, branch);
   }
   deleteCallEdgesByFile(filePath) {
+    this.throwIfClosed();
     return this.inner.deleteCallEdgesByFile(filePath);
   }
   resolveCallEdge(edgeId, toSymbolId) {
+    this.throwIfClosed();
     this.inner.resolveCallEdge(edgeId, toSymbolId);
   }
   // ── Branch Symbol methods ────────────────────────────────────────
   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);
+  }
   // ── GC methods for symbols/edges ─────────────────────────────────
   gcOrphanSymbols() {
+    this.throwIfClosed();
     return this.inner.gcOrphanSymbols();
   }
   gcOrphanCallEdges() {
+    this.throwIfClosed();
     return this.inner.gcOrphanCallEdges();
   }
 };
 
-// src/git/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
-import * as path5 from "path";
-function readPackedRefs(gitDir) {
-  const packedRefsPath = path5.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 = path5.join(gitDir, "commondir");
-  if (!existsSync3(commonDirPath)) {
-    return gitDir;
-  }
-  try {
-    const raw = readFileSync4(commonDirPath, "utf-8").trim();
-    if (!raw) {
-      return gitDir;
-    }
-    const resolved = path5.isAbsolute(raw) ? raw : path5.resolve(gitDir, raw);
-    if (existsSync3(resolved)) {
-      return resolved;
-    }
-  } catch {
-    return gitDir;
-  }
-  return gitDir;
-}
-function resolveGitDir(repoRoot) {
-  const gitPath = path5.join(repoRoot, ".git");
-  if (!existsSync3(gitPath)) {
-    return null;
-  }
-  try {
-    const stat = statSync(gitPath);
-    if (stat.isDirectory()) {
-      return gitPath;
-    }
-    if (stat.isFile()) {
-      const content = readFileSync4(gitPath, "utf-8").trim();
-      const match = content.match(/^gitdir:\s*(.+)$/);
-      if (match) {
-        const gitdir = match[1];
-        const resolvedPath = path5.isAbsolute(gitdir) ? gitdir : path5.resolve(repoRoot, gitdir);
-        if (existsSync3(resolvedPath)) {
-          return resolvedPath;
-        }
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function isGitRepo(dir) {
-  return resolveGitDir(dir) !== null;
-}
-function getCurrentBranch(repoRoot) {
-  const gitDir = resolveGitDir(repoRoot);
-  if (!gitDir) {
-    return null;
-  }
-  const headPath = path5.join(gitDir, "HEAD");
-  if (!existsSync3(headPath)) {
-    return null;
-  }
-  try {
-    const headContent = readFileSync4(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 = path5.join(refStoreDir, "refs", "heads", candidate);
-      if (existsSync3(refPath)) {
-        return candidate;
-      }
-      const packedRefs = readPackedRefs(refStoreDir);
-      if (packedRefs.some((line) => line.endsWith(` refs/heads/${candidate}`))) {
-        return candidate;
-      }
-    }
-  }
-  return getCurrentBranch(repoRoot) ?? "main";
-}
-function getBranchOrDefault(repoRoot) {
-  if (!isGitRepo(repoRoot)) {
-    return "default";
-  }
-  return getCurrentBranch(repoRoot) ?? "default";
-}
-
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig"]);
+var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
@@ -4134,7 +4596,11 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "enum_item",
   "trait_item",
   "mod_item",
-  "trait_declaration"
+  "trait_declaration",
+  "trigger_declaration",
+  "test_declaration",
+  "struct_declaration",
+  "union_declaration"
 ]);
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
@@ -4159,12 +4625,192 @@ function isRateLimitError(error) {
   const message = getErrorMessage(error);
   return message.includes("429") || message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("too many requests");
 }
+function getSafeEmbeddingChunkTokenLimit(provider) {
+  const providerMaxTokens = provider.modelInfo.maxTokens;
+  const maxChunkTokens = Math.max(256, Math.floor(providerMaxTokens * 0.75));
+  return Math.min(2e3, maxChunkTokens);
+}
+function getDynamicBatchOptions(provider) {
+  if (provider.provider === "ollama") {
+    return {
+      maxBatchTokens: provider.modelInfo.maxTokens,
+      maxBatchItems: 1
+    };
+  }
+  return {};
+}
+function isSqliteCorruptionError(error) {
+  const message = getErrorMessage(error).toLowerCase();
+  return message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database schema is corrupt") || message.includes("sqlite_corrupt");
+}
+var STARTUP_WARNING_METADATA_KEY = "index.startupWarning";
 var INDEX_METADATA_VERSION = "1";
+var EMBEDDING_STRATEGY_VERSION = "2";
 var RANKING_TOKEN_CACHE_LIMIT = 4096;
+var RANK_HYBRID_CACHE_LIMIT = 256;
+function createPendingChunkStorageText(texts) {
+  const primaryText = texts[0]?.text ?? "";
+  if (texts.length <= 1) {
+    return primaryText;
+  }
+  return `${primaryText}
+
+... [split into ${texts.length} parts for embedding]`;
+}
+function normalizePendingChunk(rawChunk, maxChunkTokens) {
+  if (!rawChunk || typeof rawChunk !== "object") {
+    return null;
+  }
+  const chunk = rawChunk;
+  if (typeof chunk.id !== "string" || typeof chunk.contentHash !== "string" || !chunk.metadata || typeof chunk.metadata !== "object") {
+    return null;
+  }
+  const texts = Array.isArray(chunk.texts) ? chunk.texts.map((entry) => {
+    if (!entry || typeof entry.text !== "string") {
+      return null;
+    }
+    return {
+      text: entry.text,
+      tokenCount: typeof entry.tokenCount === "number" && Number.isFinite(entry.tokenCount) ? entry.tokenCount : estimateTokens2(entry.text)
+    };
+  }).filter((entry) => entry !== null) : [];
+  if (texts.length === 0 && typeof chunk.text === "string") {
+    if (typeof chunk.content === "string" && chunk.content.length > 0 && chunk.metadata && typeof chunk.metadata === "object") {
+      const metadata = chunk.metadata;
+      const rebuiltChunk = {
+        content: chunk.content,
+        startLine: typeof metadata.startLine === "number" ? metadata.startLine : 1,
+        endLine: typeof metadata.endLine === "number" ? metadata.endLine : 1,
+        chunkType: typeof metadata.chunkType === "string" ? metadata.chunkType : "other",
+        name: typeof metadata.name === "string" ? metadata.name : void 0,
+        language: typeof metadata.language === "string" ? metadata.language : "text"
+      };
+      const filePath = typeof metadata.filePath === "string" ? metadata.filePath : "unknown";
+      texts.push(
+        ...createEmbeddingTexts(rebuiltChunk, filePath, maxChunkTokens).map((text) => ({
+          text,
+          tokenCount: estimateTokens2(text)
+        }))
+      );
+    } else {
+      texts.push({
+        text: chunk.text,
+        tokenCount: estimateTokens2(chunk.text)
+      });
+    }
+  }
+  if (texts.length === 0) {
+    return null;
+  }
+  return {
+    id: chunk.id,
+    texts,
+    storageText: typeof chunk.storageText === "string" ? chunk.storageText : createPendingChunkStorageText(texts),
+    content: typeof chunk.content === "string" ? chunk.content : "",
+    contentHash: chunk.contentHash,
+    metadata: chunk.metadata
+  };
+}
+function getPendingChunkFilePath(rawChunk) {
+  if (!rawChunk || typeof rawChunk !== "object") {
+    return null;
+  }
+  const chunk = rawChunk;
+  if (!chunk.metadata || typeof chunk.metadata !== "object") {
+    return null;
+  }
+  const metadata = chunk.metadata;
+  return typeof metadata.filePath === "string" ? metadata.filePath : null;
+}
+function normalizeFailedBatch(batch, maxChunkTokens) {
+  const chunks = batch.chunks.map((chunk) => normalizePendingChunk(chunk, maxChunkTokens)).filter((chunk) => chunk !== null);
+  if (chunks.length === 0) {
+    return null;
+  }
+  return {
+    chunks,
+    error: batch.error,
+    attemptCount: batch.attemptCount,
+    lastAttempt: batch.lastAttempt
+  };
+}
+function createPendingEmbeddingRequests(chunks) {
+  return chunks.flatMap(
+    (chunk) => chunk.texts.map((textPart, partIndex) => ({
+      chunk,
+      partIndex,
+      text: textPart.text,
+      tokenCount: textPart.tokenCount
+    }))
+  );
+}
+function createPendingEmbeddingRequestBatches(chunks, options = {}) {
+  return createDynamicBatches(createPendingEmbeddingRequests(chunks), options);
+}
+function getUniquePendingChunksFromRequests(requests) {
+  const uniqueChunks = /* @__PURE__ */ new Map();
+  for (const request of requests) {
+    uniqueChunks.set(request.chunk.id, request.chunk);
+  }
+  return Array.from(uniqueChunks.values());
+}
+function coalesceFailedBatches(batches) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const batch of batches) {
+    const key = `${batch.attemptCount}:${batch.lastAttempt}:${batch.error}`;
+    const existing = grouped.get(key);
+    if (!existing) {
+      grouped.set(key, {
+        ...batch,
+        chunks: [...batch.chunks]
+      });
+      continue;
+    }
+    existing.chunks.push(...batch.chunks);
+  }
+  return Array.from(grouped.values());
+}
+function poolEmbeddingVectors(vectors, weights) {
+  const firstVector = vectors[0];
+  if (!firstVector) {
+    return [];
+  }
+  const pooled = new Array(firstVector.length).fill(0);
+  let totalWeight = 0;
+  for (let index = 0; index < vectors.length; index++) {
+    const vector = vectors[index];
+    const weight = Math.max(1, weights[index] ?? 1);
+    totalWeight += weight;
+    for (let dimension = 0; dimension < vector.length; dimension++) {
+      pooled[dimension] += vector[dimension] * weight;
+    }
+  }
+  if (totalWeight === 0) {
+    return firstVector;
+  }
+  return pooled.map((value) => value / totalWeight);
+}
+function hasAllEmbeddingParts(parts, expectedPartCount) {
+  if (parts.length !== expectedPartCount) {
+    return false;
+  }
+  for (let index = 0; index < expectedPartCount; index++) {
+    if (parts[index] === void 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPathWithinRoot(filePath, rootPath) {
+  const normalizedFilePath = path8.resolve(filePath);
+  const normalizedRoot = path8.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path8.sep}`);
+}
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
 var rankingPathTokenCache = /* @__PURE__ */ new Map();
 var rankingTextTokenCache = /* @__PURE__ */ new Map();
+var rankHybridResultsCache = /* @__PURE__ */ new WeakMap();
 var STOPWORDS = /* @__PURE__ */ new Set([
   "the",
   "and",
@@ -4380,7 +5026,16 @@ function classifyExternalRerankBand(candidate, preferSourcePaths, docIntent) {
 function classifyQueryIntent(tokens) {
   const sourceIntentHits = tokens.filter((t) => SOURCE_INTENT_HINTS.has(t)).length;
   const docTestIntentHits = tokens.filter((t) => DOC_TEST_INTENT_HINTS.has(t)).length;
-  return sourceIntentHits >= docTestIntentHits ? "source" : "doc_test";
+  if (sourceIntentHits === 0 && docTestIntentHits === 0) {
+    return "neutral";
+  }
+  if (sourceIntentHits > docTestIntentHits) {
+    return "source";
+  }
+  if (docTestIntentHits > sourceIntentHits) {
+    return "doc_test";
+  }
+  return "neutral";
 }
 function classifyQueryIntentRaw(query) {
   const lowerQuery = query.toLowerCase();
@@ -4402,7 +5057,7 @@ function classifyQueryIntentRaw(query) {
   if (docTestRawHits > sourceRawHits) {
     return "doc_test";
   }
-  if (sourceRawHits > docTestRawHits) {
+  if (sourceRawHits > docTestRawHits && sourceRawHits > 0) {
     return "source";
   }
   const hasWhereIsPattern = /\bwhere\s+is\b/.test(lowerQuery);
@@ -4669,9 +5324,8 @@ function rerankResults(query, candidates, rerankTopN, options) {
     return candidates;
   }
   const queryTokenList = Array.from(queryTokens);
-  const intent = classifyQueryIntentRaw(query);
   const docIntent = classifyDocIntent(queryTokenList);
-  const preferSourcePaths = options?.prioritizeSourcePaths ?? intent === "source";
+  const preferSourcePaths = options?.prioritizeSourcePaths ?? classifyQueryIntentRaw(query) === "source";
   const identifierHints = extractIdentifierHints(query);
   const head = candidates.slice(0, topN).map((candidate, idx) => {
     const pathTokens = splitPathTokens(candidate.metadata.filePath);
@@ -4821,13 +5475,38 @@ function buildDiversityKey(metadata) {
   return normalizedPath;
 }
 function rankHybridResults(query, semanticResults, keywordResults, options) {
+  const prioritizeSourcePaths = options.prioritizeSourcePaths ?? classifyQueryIntentRaw(query) === "source";
+  const cacheKey = `${query}
${options.fusionStrategy}|${options.rrfK}|${options.hybridWeight}|${options.rerankTopN}|${options.limit}|${prioritizeSourcePaths ? 1 : 0}`;
+  let byKeyword = rankHybridResultsCache.get(semanticResults);
+  if (!byKeyword) {
+    byKeyword = /* @__PURE__ */ new WeakMap();
+    rankHybridResultsCache.set(semanticResults, byKeyword);
+  }
+  let bucket = byKeyword.get(keywordResults);
+  if (!bucket) {
+    bucket = /* @__PURE__ */ new Map();
+    byKeyword.set(keywordResults, bucket);
+  } else {
+    const cached = bucket.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+  }
   const overfetchLimit = Math.max(options.limit * 4, options.limit);
   const fused = options.fusionStrategy === "rrf" ? fuseResultsRrf(semanticResults, keywordResults, options.rrfK, overfetchLimit) : fuseResultsWeighted(semanticResults, keywordResults, options.hybridWeight, overfetchLimit);
   const rerankPoolLimit = Math.max(overfetchLimit, options.rerankTopN * 3, options.limit * 6);
   const rerankPool = fused.slice(0, rerankPoolLimit);
-  return rerankResults(query, rerankPool, options.rerankTopN, {
-    prioritizeSourcePaths: options.prioritizeSourcePaths ?? classifyQueryIntentRaw(query) === "source"
+  const ranked = rerankResults(query, rerankPool, options.rerankTopN, {
+    prioritizeSourcePaths
   });
+  if (bucket.size >= RANK_HYBRID_CACHE_LIMIT) {
+    const oldest = bucket.keys().next().value;
+    if (oldest !== void 0) {
+      bucket.delete(oldest);
+    }
+  }
+  bucket.set(cacheKey, ranked);
+  return ranked;
 }
 function rankSemanticOnlyResults(query, semanticResults, options) {
   const overfetchLimit = Math.max(options.limit * 4, options.limit);
@@ -5124,6 +5803,21 @@ function mergeTieredResults(symbolLane, hybridLane, limit) {
   }
   return out;
 }
+function matchesSearchFilters(candidate, options, minScore) {
+  if (candidate.score < minScore) return false;
+  if (options?.fileType) {
+    const ext = candidate.metadata.filePath.split(".").pop()?.toLowerCase();
+    if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
+  }
+  if (options?.directory) {
+    const normalizedDir = options.directory.replace(/^\/|\/$/g, "");
+    if (!candidate.metadata.filePath.includes(`/${normalizedDir}/`) && !candidate.metadata.filePath.includes(`${normalizedDir}/`)) return false;
+  }
+  if (options?.chunkType && candidate.metadata.chunkType !== options.chunkType) {
+    return false;
+  }
+  return true;
+}
 function unionCandidates(semanticCandidates, keywordCandidates) {
   const byId = /* @__PURE__ */ new Map();
   for (const candidate of semanticCandidates) {
@@ -5163,22 +5857,18 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path6.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path6.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path6.join(this.indexPath, "indexing.lock");
+    this.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.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
-    if (this.config.scope === "global") {
-      const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-      return path6.join(homeDir, ".opencode", "global-index");
-    }
-    return path6.join(this.projectRoot, ".opencode", "index");
+    return resolveProjectIndexPath(this.projectRoot, this.config.scope);
   }
   loadFileHashCache() {
     try {
-      if (existsSync4(this.fileHashCachePath)) {
-        const data = readFileSync5(this.fileHashCachePath, "utf-8");
+      if (existsSync6(this.fileHashCachePath)) {
+        const data = readFileSync6(this.fileHashCachePath, "utf-8");
         const parsed = JSON.parse(data);
         this.fileHashCache = new Map(Object.entries(parsed));
       }
@@ -5195,63 +5885,423 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    writeFileSync2(tempPath, data);
+    mkdirSync3(path8.dirname(targetPath), { recursive: true });
+    writeFileSync3(tempPath, data);
     renameSync(tempPath, targetPath);
   }
+  getScopedRoots() {
+    const roots = /* @__PURE__ */ new Set([path8.resolve(this.projectRoot)]);
+    for (const kbRoot of this.config.knowledgeBases) {
+      roots.add(path8.resolve(this.projectRoot, kbRoot));
+    }
+    return Array.from(roots);
+  }
+  getBranchCatalogKey() {
+    const branchName = this.currentBranch || "default";
+    if (this.config.scope !== "global") {
+      return branchName;
+    }
+    const projectHash = hashContent(path8.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);
+    return `index.globalBranchMigration.${projectHash}`;
+  }
+  getProjectEmbeddingStrategyMetadataKey() {
+    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    return `index.embeddingStrategyVersion.${projectHash}`;
+  }
+  getProjectForceReembedMetadataKey() {
+    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    return `index.forceReembed.${projectHash}`;
+  }
+  hasProjectForceReembedPending() {
+    return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
+  }
+  hasScopedIndexedData() {
+    if (!this.store || this.config.scope !== "global") {
+      return false;
+    }
+    if (this.hasProjectForceReembedPending()) {
+      return false;
+    }
+    const roots = this.getScopedRoots();
+    if (Array.from(this.fileHashCache.keys()).some((filePath) => this.isFileInCurrentScope(filePath, roots))) {
+      return true;
+    }
+    if (this.loadSerializedFailedBatches().some(
+      (batch) => batch.chunks.some((chunk) => {
+        const filePath = getPendingChunkFilePath(chunk);
+        return filePath !== null && this.isFileInCurrentScope(filePath, roots);
+      })
+    )) {
+      return true;
+    }
+    if (!this.database) {
+      return false;
+    }
+    if (this.getBranchCatalogKeys().some((branchKey) => {
+      const branchChunkIds = this.database.getBranchChunkIds(branchKey);
+      if (branchChunkIds.length > 0) {
+        return true;
+      }
+      return this.database.getBranchSymbolIds(branchKey).length > 0;
+    })) {
+      return true;
+    }
+    const hasAnyBranchRows = this.database.getAllBranches().some((branchKey) => {
+      const branchChunkIds = this.database.getBranchChunkIds(branchKey);
+      if (branchChunkIds.length > 0) {
+        return true;
+      }
+      return this.database.getBranchSymbolIds(branchKey).length > 0;
+    });
+    if (hasAnyBranchRows) {
+      return false;
+    }
+    return this.store.getAllMetadata().some(({ metadata }) => this.isFileInCurrentScope(metadata.filePath, roots));
+  }
+  loadStoredEmbeddingStrategyVersion() {
+    if (!this.database) {
+      return null;
+    }
+    if (this.hasProjectForceReembedPending()) {
+      return null;
+    }
+    if (this.config.scope !== "global") {
+      return this.database.getMetadata("index.embeddingStrategyVersion") ?? "1";
+    }
+    const projectVersion = this.database.getMetadata(this.getProjectEmbeddingStrategyMetadataKey());
+    if (projectVersion) {
+      return projectVersion;
+    }
+    const legacySharedVersion = this.database.getMetadata("index.embeddingStrategyVersion");
+    if (legacySharedVersion && this.hasScopedIndexedData()) {
+      return legacySharedVersion;
+    }
+    return null;
+  }
+  getBranchCatalogKeys() {
+    const primary = this.getBranchCatalogKey();
+    if (this.config.scope !== "global") {
+      return [primary];
+    }
+    if (this.database?.getMetadata(this.getLegacyMigrationMetadataKey()) === "done") {
+      return [primary];
+    }
+    const legacy = this.getLegacyBranchCatalogKey();
+    return primary === legacy ? [primary] : [primary, legacy];
+  }
+  getBranchCatalogCleanupKeys() {
+    const primary = this.getBranchCatalogKey();
+    if (this.config.scope !== "global") {
+      return [primary];
+    }
+    const legacy = this.getLegacyBranchCatalogKey();
+    return primary === legacy ? [primary] : [primary, legacy];
+  }
+  getProjectLocalScopedOwnershipIds(roots) {
+    const chunkIds = /* @__PURE__ */ new Set();
+    const symbolIds = /* @__PURE__ */ new Set();
+    if (!this.database) {
+      return { chunkIds, symbolIds };
+    }
+    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectLocalFilePaths = /* @__PURE__ */ new Set([
+      ...Array.from(this.fileHashCache.keys()).filter(
+        (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
+      ),
+      ...(this.store?.getAllMetadata() ?? []).map(({ metadata }) => metadata.filePath).filter(
+        (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
+      )
+    ]);
+    for (const filePath of projectLocalFilePaths) {
+      for (const chunk of this.database.getChunksByFile(filePath)) {
+        chunkIds.add(chunk.chunkId);
+      }
+      for (const symbol of this.database.getSymbolsByFile(filePath)) {
+        symbolIds.add(symbol.id);
+      }
+    }
+    return { chunkIds, symbolIds };
+  }
+  getProjectScopedBranchCatalogCleanupKeys(projectChunkIds, projectSymbolIds) {
+    if (this.config.scope !== "global") {
+      return this.getBranchCatalogCleanupKeys();
+    }
+    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const keys = /* @__PURE__ */ new Set();
+    const projectChunkIdSet = new Set(projectChunkIds);
+    const projectSymbolIdSet = new Set(projectSymbolIds);
+    for (const branchKey of this.database?.getAllBranches() ?? []) {
+      if (branchKey.startsWith(`${projectHash}:`)) {
+        keys.add(branchKey);
+        continue;
+      }
+      if (branchKey.includes(":")) {
+        continue;
+      }
+      const referencesProjectChunks = this.database?.getBranchChunkIds(branchKey).some((chunkId) => projectChunkIdSet.has(chunkId)) ?? false;
+      const referencesProjectSymbols = this.database?.getBranchSymbolIds(branchKey).some((symbolId) => projectSymbolIdSet.has(symbolId)) ?? false;
+      if (referencesProjectChunks || referencesProjectSymbols) {
+        keys.add(branchKey);
+      }
+    }
+    for (const branchKey of this.getBranchCatalogCleanupKeys()) {
+      keys.add(branchKey);
+    }
+    return Array.from(keys);
+  }
+  isFileInCurrentScope(filePath, roots) {
+    return roots.some((root) => isPathWithinRoot(filePath, root));
+  }
+  clearScopedFileHashCache(roots) {
+    for (const filePath of Array.from(this.fileHashCache.keys())) {
+      if (this.isFileInCurrentScope(filePath, roots)) {
+        this.fileHashCache.delete(filePath);
+      }
+    }
+    this.saveFileHashCache();
+  }
+  replaceScopedFileHashCache(currentFileHashes, roots) {
+    for (const filePath of Array.from(this.fileHashCache.keys())) {
+      if (this.isFileInCurrentScope(filePath, roots)) {
+        this.fileHashCache.delete(filePath);
+      }
+    }
+    for (const [filePath, hash] of currentFileHashes) {
+      this.fileHashCache.set(filePath, hash);
+    }
+    this.saveFileHashCache();
+  }
+  partitionFailedBatches(roots, maxChunkTokens) {
+    const scoped = [];
+    const retained = [];
+    for (const batch of this.loadSerializedFailedBatches()) {
+      const scopedChunks = batch.chunks.filter((chunk) => {
+        const filePath = getPendingChunkFilePath(chunk);
+        return filePath !== null && this.isFileInCurrentScope(filePath, roots);
+      });
+      const retainedChunks = batch.chunks.filter((chunk) => {
+        const filePath = getPendingChunkFilePath(chunk);
+        return filePath === null || !this.isFileInCurrentScope(filePath, roots);
+      });
+      if (scopedChunks.length > 0) {
+        const normalizedBatch = normalizeFailedBatch({ ...batch, chunks: scopedChunks }, maxChunkTokens);
+        if (normalizedBatch) {
+          scoped.push(normalizedBatch);
+        }
+      }
+      if (retainedChunks.length > 0) {
+        retained.push({ ...batch, chunks: retainedChunks });
+      }
+    }
+    return { scoped, retained };
+  }
+  clearScopedFailedBatches(roots) {
+    const { retained: retainedBatches } = this.partitionFailedBatches(roots);
+    this.saveFailedBatches(retainedBatches);
+  }
+  hasForeignScopedFileHashData(roots) {
+    return Array.from(this.fileHashCache.keys()).some((filePath) => !this.isFileInCurrentScope(filePath, roots));
+  }
+  hasForeignScopedFailedBatches(roots) {
+    const { retained } = this.partitionFailedBatches(roots);
+    return retained.length > 0;
+  }
+  hasForeignScopedBranchData() {
+    if (!this.database || this.config.scope !== "global") {
+      return false;
+    }
+    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const roots = this.getScopedRoots();
+    const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
+    return this.database.getAllBranches().some(
+      (branchKey) => {
+        const branchChunkIds = this.database.getBranchChunkIds(branchKey);
+        const branchSymbolIds = this.database.getBranchSymbolIds(branchKey);
+        const hasBranchData = branchChunkIds.length > 0 || branchSymbolIds.length > 0;
+        if (!hasBranchData) {
+          return false;
+        }
+        if (branchKey.startsWith(`${projectHash}:`)) {
+          return false;
+        }
+        if (!branchKey.includes(":")) {
+          const referencesCurrentProjectChunks = branchChunkIds.some((chunkId) => projectLocalChunkIds.has(chunkId));
+          const referencesCurrentProjectSymbols = branchSymbolIds.some((symbolId) => projectLocalSymbolIds.has(symbolId));
+          return !(referencesCurrentProjectChunks || referencesCurrentProjectSymbols);
+        }
+        return true;
+      }
+    );
+  }
+  saveScopedFailedBatches(batches, roots) {
+    const { retained } = this.partitionFailedBatches(roots);
+    this.saveFailedBatches([...retained, ...batches]);
+  }
+  clearSharedIndexProjectData(store, invertedIndex, database, roots) {
+    const allMetadata = store.getAllMetadata();
+    const scopedEntries = allMetadata.filter(({ metadata }) => this.isFileInCurrentScope(metadata.filePath, roots));
+    const filePaths = /* @__PURE__ */ new Set([
+      ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
+      ...scopedEntries.map(({ metadata }) => metadata.filePath)
+    ]);
+    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectLocalFilePaths = new Set(
+      Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
+    );
+    const removedChunkIds = new Set(scopedEntries.map(({ key }) => key));
+    for (const filePath of filePaths) {
+      for (const chunk of database.getChunksByFile(filePath)) {
+        removedChunkIds.add(chunk.chunkId);
+      }
+    }
+    const removedChunkIdList = Array.from(removedChunkIds);
+    const projectLocalChunkIds = new Set(
+      scopedEntries.filter(({ metadata }) => isPathWithinRoot(metadata.filePath, projectRootPath)).map(({ key }) => key)
+    );
+    for (const filePath of projectLocalFilePaths) {
+      for (const chunk of database.getChunksByFile(filePath)) {
+        projectLocalChunkIds.add(chunk.chunkId);
+      }
+    }
+    const symbolIds = [];
+    const projectLocalSymbolIds = /* @__PURE__ */ new Set();
+    for (const filePath of filePaths) {
+      for (const symbol of database.getSymbolsByFile(filePath)) {
+        symbolIds.push(symbol.id);
+        if (projectLocalFilePaths.has(filePath)) {
+          projectLocalSymbolIds.add(symbol.id);
+        }
+      }
+    }
+    for (const branchKey of this.getProjectScopedBranchCatalogCleanupKeys(Array.from(projectLocalChunkIds), Array.from(projectLocalSymbolIds))) {
+      database.deleteBranchChunksForBranch(branchKey, removedChunkIdList);
+    }
+    const sharedChunkIds = new Set(database.getReferencedChunkIds(removedChunkIdList));
+    const removableChunkIds = removedChunkIdList.filter((chunkId) => !sharedChunkIds.has(chunkId));
+    if (removableChunkIds.length > 0) {
+      this.rebuildVectorStoreExcludingChunkIds(store, database, removableChunkIds);
+      for (const chunkId of removableChunkIds) {
+        invertedIndex.removeChunk(chunkId);
+      }
+    }
+    for (const branchKey of this.getProjectScopedBranchCatalogCleanupKeys(Array.from(projectLocalChunkIds), Array.from(projectLocalSymbolIds))) {
+      database.deleteBranchSymbolsForBranch(branchKey, symbolIds);
+    }
+    const sharedSymbolIds = new Set(database.getReferencedSymbolIds(symbolIds));
+    const removableSymbolIds = symbolIds.filter((symbolId) => !sharedSymbolIds.has(symbolId));
+    database.clearCallEdgeTargetsForSymbols(removableSymbolIds);
+    for (const filePath of filePaths) {
+      const fileChunkIds = database.getChunksByFile(filePath).map((chunk) => chunk.chunkId);
+      const fileSymbols = database.getSymbolsByFile(filePath);
+      if (fileChunkIds.every((chunkId) => !sharedChunkIds.has(chunkId))) {
+        database.deleteChunksByFile(filePath);
+      }
+      if (fileSymbols.every((symbol) => !sharedSymbolIds.has(symbol.id))) {
+        database.deleteCallEdgesByFile(filePath);
+        database.deleteSymbolsByFile(filePath);
+      }
+    }
+    database.gcOrphanCallEdges();
+    database.gcOrphanSymbols();
+    database.gcOrphanEmbeddings();
+    database.gcOrphanChunks();
+    store.save();
+    invertedIndex.save();
+    return {
+      removedChunkIds: removedChunkIdList,
+      hasForeignData: allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots))
+    };
+  }
   checkForInterruptedIndexing() {
-    return existsSync4(this.indexingLockPath);
+    return existsSync6(this.indexingLockPath);
   }
   acquireIndexingLock() {
     const lockData = {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       pid: process.pid
     };
-    writeFileSync2(this.indexingLockPath, JSON.stringify(lockData));
+    writeFileSync3(this.indexingLockPath, JSON.stringify(lockData));
   }
   releaseIndexingLock() {
-    if (existsSync4(this.indexingLockPath)) {
+    if (existsSync6(this.indexingLockPath)) {
       unlinkSync(this.indexingLockPath);
     }
   }
   async recoverFromInterruptedIndexing() {
     this.logger.warn("Detected interrupted indexing session, recovering...");
-    if (existsSync4(this.fileHashCachePath)) {
+    if (existsSync6(this.fileHashCachePath)) {
       unlinkSync(this.fileHashCachePath);
     }
     await this.healthCheck();
     this.releaseIndexingLock();
     this.logger.info("Recovery complete, next index will re-process all files");
   }
-  loadFailedBatches() {
+  loadFailedBatches(maxChunkTokens) {
     try {
-      if (existsSync4(this.failedBatchesPath)) {
-        const data = readFileSync5(this.failedBatchesPath, "utf-8");
-        return JSON.parse(data);
-      }
+      return this.loadSerializedFailedBatches().map((batch) => normalizeFailedBatch(batch, maxChunkTokens)).filter((batch) => batch !== null);
     } catch {
       return [];
     }
-    return [];
+  }
+  loadSerializedFailedBatches() {
+    if (!existsSync6(this.failedBatchesPath)) {
+      return [];
+    }
+    const data = readFileSync6(this.failedBatchesPath, "utf-8");
+    const parsed = JSON.parse(data);
+    return parsed.map((batch) => {
+      const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
+      if (chunks.length === 0) {
+        return null;
+      }
+      return {
+        chunks,
+        error: typeof batch.error === "string" ? batch.error : "Unknown embedding error",
+        attemptCount: typeof batch.attemptCount === "number" ? batch.attemptCount : 1,
+        lastAttempt: typeof batch.lastAttempt === "string" ? batch.lastAttempt : (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }).filter((batch) => batch !== null);
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync4(this.failedBatchesPath)) {
-        fsPromises2.unlink(this.failedBatchesPath).catch(() => {
-        });
+      if (existsSync6(this.failedBatchesPath)) {
+        try {
+          unlinkSync(this.failedBatchesPath);
+        } catch {
+        }
       }
       return;
     }
-    writeFileSync2(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    writeFileSync3(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
-  addFailedBatch(batch, error) {
-    const existing = this.loadFailedBatches();
-    existing.push({
-      chunks: batch,
-      error,
-      attemptCount: 1,
-      lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    this.saveFailedBatches(existing);
+  collectRetryableFailedChunks(currentFileHashes, unchangedFilePaths, maxChunkTokens) {
+    const retryableById = /* @__PURE__ */ new Map();
+    for (const batch of this.loadFailedBatches(maxChunkTokens)) {
+      for (const chunk of batch.chunks) {
+        const filePath = chunk.metadata.filePath;
+        if (!currentFileHashes.has(filePath)) {
+          continue;
+        }
+        if (!unchangedFilePaths.has(filePath)) {
+          continue;
+        }
+        const existing = retryableById.get(chunk.id);
+        if (!existing || batch.attemptCount > existing.attemptCount) {
+          retryableById.set(chunk.id, {
+            chunk,
+            attemptCount: batch.attemptCount
+          });
+        }
+      }
+    }
+    return Array.from(retryableById.values());
   }
   getProviderRateLimits(provider) {
     switch (provider) {
@@ -5456,31 +6506,54 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path6.join(this.indexPath, "vectors");
+    const storePath = path8.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path6.join(this.indexPath, "vectors.usearch");
-    if (existsSync4(indexFilePath)) {
+    const indexFilePath = path8.join(this.indexPath, "vectors.usearch");
+    if (existsSync6(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path6.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path8.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
     } catch {
-      if (existsSync4(invertedIndexPath)) {
+      if (existsSync6(invertedIndexPath)) {
         await fsPromises2.unlink(invertedIndexPath);
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path6.join(this.indexPath, "codebase.db");
-    const dbIsNew = !existsSync4(dbPath);
-    this.database = new Database(dbPath);
+    const dbPath = path8.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync6(dbPath);
+    try {
+      this.database = new Database(dbPath);
+    } catch (error) {
+      if (!await this.tryResetCorruptedIndex("initializing index database", error)) {
+        throw error;
+      }
+      this.store = new VectorStore(storePath, dimensions);
+      this.invertedIndex = new InvertedIndex(invertedIndexPath);
+      this.database = new Database(dbPath);
+      dbIsNew = true;
+    }
+    if (isGitRepo(this.projectRoot)) {
+      this.currentBranch = getBranchOrDefault(this.projectRoot);
+      this.baseBranch = getBaseBranch(this.projectRoot);
+      this.logger.branch("info", "Detected git repository", {
+        currentBranch: this.currentBranch,
+        baseBranch: this.baseBranch
+      });
+    } else {
+      this.currentBranch = "default";
+      this.baseBranch = "default";
+      this.logger.branch("debug", "Not a git repository, using default branch");
+    }
     if (this.checkForInterruptedIndexing()) {
       await this.recoverFromInterruptedIndexing();
     }
     if (dbIsNew && this.store.count() > 0) {
       this.migrateFromLegacyIndex();
     }
+    this.loadFileHashCache();
     this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
     if (!this.indexCompatibility.compatible) {
       this.logger.warn("Index compatibility issue detected", {
@@ -5489,18 +6562,6 @@ var Indexer = class {
         configuredProviderInfo: this.configuredProviderInfo
       });
     }
-    if (isGitRepo(this.projectRoot)) {
-      this.currentBranch = getBranchOrDefault(this.projectRoot);
-      this.baseBranch = getBaseBranch(this.projectRoot);
-      this.logger.branch("info", "Detected git repository", {
-        currentBranch: this.currentBranch,
-        baseBranch: this.baseBranch
-      });
-    } else {
-      this.currentBranch = "default";
-      this.baseBranch = "default";
-      this.logger.branch("debug", "Not a git repository, using default branch");
-    }
     if (this.config.indexing.autoGc) {
       await this.maybeRunAutoGc();
     }
@@ -5520,20 +6581,169 @@ var Indexer = class {
       }
     }
     if (shouldRunGc) {
-      await this.healthCheck();
+      const result = await this.healthCheck();
+      if (result.warning) {
+        this.database.setMetadata(STARTUP_WARNING_METADATA_KEY, result.warning);
+      } else {
+        this.database.deleteMetadata(STARTUP_WARNING_METADATA_KEY);
+      }
       this.database.setMetadata("lastGcTimestamp", now.toString());
     }
   }
   async maybeRunOrphanGc() {
-    if (!this.database) return;
+    if (!this.database) return null;
     const stats = this.database.getStats();
-    if (!stats) return;
+    if (!stats) return null;
     const orphanCount = stats.embeddingCount - stats.chunkCount;
     if (orphanCount > this.config.indexing.gcOrphanThreshold) {
-      this.database.gcOrphanEmbeddings();
-      this.database.gcOrphanChunks();
+      try {
+        this.database.gcOrphanEmbeddings();
+        this.database.gcOrphanChunks();
+      } catch (error) {
+        if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
+          return {
+            resetCorruptedIndex: true,
+            warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+          };
+        }
+        throw error;
+      }
       this.database.setMetadata("lastGcTimestamp", Date.now().toString());
     }
+    return null;
+  }
+  rebuildVectorStoreExcludingChunkIds(store, database, excludedChunkIds) {
+    const excludedSet = new Set(excludedChunkIds);
+    if (excludedSet.size === 0) {
+      return;
+    }
+    const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
+    const storeBasePath = path8.join(this.indexPath, "vectors");
+    const storeIndexPath = `${storeBasePath}.usearch`;
+    const storeMetadataPath = `${storeBasePath}.meta.json`;
+    const backupIndexPath = `${storeIndexPath}.bak`;
+    const backupMetadataPath = `${storeMetadataPath}.bak`;
+    let backedUpIndex = false;
+    let backedUpMetadata = false;
+    let rebuiltCount = 0;
+    let skippedCount = 0;
+    if (existsSync6(backupIndexPath)) {
+      unlinkSync(backupIndexPath);
+    }
+    if (existsSync6(backupMetadataPath)) {
+      unlinkSync(backupMetadataPath);
+    }
+    try {
+      if (existsSync6(storeIndexPath)) {
+        renameSync(storeIndexPath, backupIndexPath);
+        backedUpIndex = true;
+      }
+      if (existsSync6(storeMetadataPath)) {
+        renameSync(storeMetadataPath, backupMetadataPath);
+        backedUpMetadata = true;
+      }
+      store.clear();
+      for (const { key, metadata } of retainedEntries) {
+        const chunk = database.getChunk(key);
+        if (!chunk) {
+          skippedCount += 1;
+          continue;
+        }
+        const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+        if (!embeddingBuffer) {
+          skippedCount += 1;
+          continue;
+        }
+        const vector = bufferToFloat32Array(embeddingBuffer);
+        store.add(key, Array.from(vector), metadata);
+        rebuiltCount += 1;
+      }
+      store.save();
+      if (backedUpIndex && existsSync6(backupIndexPath)) {
+        unlinkSync(backupIndexPath);
+      }
+      if (backedUpMetadata && existsSync6(backupMetadataPath)) {
+        unlinkSync(backupMetadataPath);
+      }
+      this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
+        excludedChunks: excludedSet.size,
+        rebuiltChunks: rebuiltCount,
+        skippedChunks: skippedCount
+      });
+    } catch (error) {
+      try {
+        store.clear();
+      } catch {
+      }
+      if (existsSync6(storeIndexPath)) {
+        unlinkSync(storeIndexPath);
+      }
+      if (existsSync6(storeMetadataPath)) {
+        unlinkSync(storeMetadataPath);
+      }
+      if (backedUpIndex && existsSync6(backupIndexPath)) {
+        renameSync(backupIndexPath, storeIndexPath);
+      }
+      if (backedUpMetadata && existsSync6(backupMetadataPath)) {
+        renameSync(backupMetadataPath, storeMetadataPath);
+      }
+      if (backedUpIndex || backedUpMetadata) {
+        store.load();
+      }
+      throw error;
+    }
+  }
+  getCorruptedIndexWarning(dbPath) {
+    if (this.config.scope === "global") {
+      return `Detected a corrupted shared global SQLite index at ${dbPath}. Automatic repair is disabled for global scope because it may delete other projects' index data. Remove or repair the shared index manually, then rerun index_codebase with force=true.`;
+    }
+    return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
+  }
+  async tryResetCorruptedIndex(stage, error) {
+    if (!isSqliteCorruptionError(error)) {
+      return false;
+    }
+    const dbPath = path8.join(this.indexPath, "codebase.db");
+    const warning = this.getCorruptedIndexWarning(dbPath);
+    const errorMessage = getErrorMessage(error);
+    if (this.config.scope === "global") {
+      this.logger.error("Detected corrupted shared global index database", {
+        stage,
+        dbPath,
+        error: errorMessage
+      });
+      throw new Error(`${warning} Original SQLite error: ${errorMessage}`);
+    }
+    this.logger.warn("Detected corrupted local index database, resetting local index", {
+      stage,
+      dbPath,
+      error: errorMessage
+    });
+    this.store = null;
+    this.invertedIndex = null;
+    this.database?.close();
+    this.database = null;
+    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")
+    ];
+    await Promise.all(resetPaths.map(async (targetPath) => {
+      try {
+        await fsPromises2.rm(targetPath, { recursive: true, force: true });
+      } catch {
+      }
+    }));
+    await fsPromises2.mkdir(this.indexPath, { recursive: true });
+    return true;
   }
   migrateFromLegacyIndex() {
     if (!this.store || !this.database) return;
@@ -5557,7 +6767,7 @@ var Indexer = class {
     if (chunkDataBatch.length > 0) {
       this.database.upsertChunksBatch(chunkDataBatch);
     }
-    this.database.addChunksToBranchBatch(this.currentBranch || "default", chunkIds);
+    this.database.addChunksToBranchBatch(this.getBranchCatalogKey(), chunkIds);
   }
   loadIndexMetadata() {
     if (!this.database) return null;
@@ -5568,6 +6778,7 @@ var Indexer = class {
       embeddingProvider: this.database.getMetadata("index.embeddingProvider") ?? "",
       embeddingModel: this.database.getMetadata("index.embeddingModel") ?? "",
       embeddingDimensions: parseInt(this.database.getMetadata("index.embeddingDimensions") ?? "0", 10),
+      embeddingStrategyVersion: this.loadStoredEmbeddingStrategyVersion() ?? EMBEDDING_STRATEGY_VERSION,
       createdAt: this.database.getMetadata("index.createdAt") ?? "",
       updatedAt: this.database.getMetadata("index.updatedAt") ?? ""
     };
@@ -5576,10 +6787,22 @@ var Indexer = class {
     if (!this.database) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existingCreatedAt = this.database.getMetadata("index.createdAt");
+    const completeProjectEmbeddingStrategyReset = !this.hasProjectForceReembedPending();
     this.database.setMetadata("index.version", INDEX_METADATA_VERSION);
     this.database.setMetadata("index.embeddingProvider", provider.provider);
     this.database.setMetadata("index.embeddingModel", provider.modelInfo.model);
     this.database.setMetadata("index.embeddingDimensions", provider.modelInfo.dimensions.toString());
+    if (this.config.scope === "global") {
+      if (completeProjectEmbeddingStrategyReset) {
+        this.database.setMetadata(this.getProjectEmbeddingStrategyMetadataKey(), EMBEDDING_STRATEGY_VERSION);
+      }
+      this.database.setMetadata(this.getLegacyMigrationMetadataKey(), "done");
+      if (completeProjectEmbeddingStrategyReset) {
+        this.database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+      }
+    } else {
+      this.database.setMetadata("index.embeddingStrategyVersion", EMBEDDING_STRATEGY_VERSION);
+    }
     this.database.setMetadata("index.updatedAt", now);
     if (!existingCreatedAt) {
       this.database.setMetadata("index.createdAt", now);
@@ -5609,6 +6832,14 @@ var Indexer = class {
         storedMetadata
       };
     }
+    if (storedMetadata.embeddingStrategyVersion !== EMBEDDING_STRATEGY_VERSION) {
+      return {
+        compatible: false,
+        code: "EMBEDDING_STRATEGY_MISMATCH" /* EMBEDDING_STRATEGY_MISMATCH */,
+        reason: `Embedding strategy mismatch: index was built with embedding strategy v${storedMetadata.embeddingStrategyVersion}, but the current code requires v${EMBEDDING_STRATEGY_VERSION}. Run index_codebase with force=true to rebuild cached embeddings.`,
+        storedMetadata
+      };
+    }
     if (storedMetadata.embeddingProvider !== currentProvider) {
       this.logger.warn("Provider changed", {
         storedProvider: storedMetadata.embeddingProvider,
@@ -5656,6 +6887,10 @@ var Indexer = class {
   }
   async index(onProgress) {
     const { store, provider, invertedIndex, database, configuredProviderInfo } = await this.ensureInitialized();
+    const scopedRoots = this.config.scope === "global" ? this.getScopedRoots() : null;
+    const branchCatalogKey = this.getBranchCatalogKey();
+    const forceScopedReembed = scopedRoots !== null && database.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
+    const failedForcedChunkIds = /* @__PURE__ */ new Set();
     if (!this.indexCompatibility?.compatible) {
       throw new Error(
         `${this.indexCompatibility?.reason} Run index_codebase with force=true to rebuild the index.`
@@ -5677,6 +6912,7 @@ var Indexer = class {
       skippedFiles: [],
       parseFailures: []
     };
+    const failedBatchesForCurrentRun = [];
     onProgress?.({
       phase: "scanning",
       filesProcessed: 0,
@@ -5736,6 +6972,12 @@ var Indexer = class {
     const existingChunks = /* @__PURE__ */ new Map();
     const existingChunksByFile = /* @__PURE__ */ new Map();
     for (const { key, metadata } of store.getAllMetadata()) {
+      if (scopedRoots && !this.isFileInCurrentScope(metadata.filePath, scopedRoots)) {
+        continue;
+      }
+      if (forceScopedReembed && scopedRoots && this.isFileInCurrentScope(metadata.filePath, scopedRoots)) {
+        continue;
+      }
       existingChunks.set(key, metadata.hash);
       const fileChunks = existingChunksByFile.get(metadata.filePath) || /* @__PURE__ */ new Set();
       fileChunks.add(key);
@@ -5757,7 +6999,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path6.relative(this.projectRoot, parsed.path);
+        const relativePath = path8.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -5793,7 +7035,10 @@ var Indexer = class {
           fileChunkCount++;
           continue;
         }
-        const text = createEmbeddingText(chunk, parsed.path);
+        const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
+          text,
+          tokenCount: estimateTokens2(text)
+        }));
         const metadata = {
           filePath: parsed.path,
           startLine: chunk.startLine,
@@ -5803,10 +7048,38 @@ var Indexer = class {
           language: chunk.language,
           hash: contentHash
         };
-        pendingChunks.push({ id, text, content: chunk.content, contentHash, metadata });
+        pendingChunks.push({
+          id,
+          texts,
+          storageText: createPendingChunkStorageText(texts),
+          content: chunk.content,
+          contentHash,
+          metadata
+        });
         fileChunkCount++;
       }
     }
+    const retryableFailedChunks = this.collectRetryableFailedChunks(
+      currentFileHashes,
+      unchangedFilePaths,
+      getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)
+    );
+    const retryableFailedAttemptCounts = /* @__PURE__ */ new Map();
+    const retryableChunksWithExistingData = /* @__PURE__ */ new Set();
+    if (retryableFailedChunks.length > 0) {
+      const pendingChunkIds = new Set(pendingChunks.map((chunk) => chunk.id));
+      for (const { chunk, attemptCount } of retryableFailedChunks) {
+        retryableFailedAttemptCounts.set(chunk.id, attemptCount);
+        if (existingChunks.has(chunk.id)) {
+          retryableChunksWithExistingData.add(chunk.id);
+        }
+        if (!pendingChunkIds.has(chunk.id)) {
+          pendingChunks.push(chunk);
+          pendingChunkIds.add(chunk.id);
+          currentChunkIds.add(chunk.id);
+        }
+      }
+    }
     if (chunkDataBatch.length > 0) {
       database.upsertChunksBatch(chunkDataBatch);
     }
@@ -5835,17 +7108,20 @@ var Indexer = class {
         fileSymbols.push(symbol);
         allSymbolIds.add(symbolId);
       }
+      const fileLanguage = parsed.chunks[0]?.language;
+      const isCaseInsensitiveLanguage = !!fileLanguage && CASE_INSENSITIVE_LANGUAGES.has(fileLanguage);
+      const normalizeSymbolKey = (name) => isCaseInsensitiveLanguage ? name.toLowerCase() : name;
       const symbolsByName = /* @__PURE__ */ new Map();
       for (const symbol of fileSymbols) {
-        const existing = symbolsByName.get(symbol.name) ?? [];
+        const key = normalizeSymbolKey(symbol.name);
+        const existing = symbolsByName.get(key) ?? [];
         existing.push(symbol);
-        symbolsByName.set(symbol.name, existing);
+        symbolsByName.set(key, existing);
       }
       if (fileSymbols.length > 0) {
         database.upsertSymbolsBatch(fileSymbols);
         symbolsByFile.set(parsed.path, fileSymbols);
       }
-      const fileLanguage = parsed.chunks[0]?.language;
       if (!fileLanguage || !CALL_GRAPH_LANGUAGES.has(fileLanguage)) continue;
       const callSites = extractCalls(changedFile.content, fileLanguage);
       if (callSites.length === 0) continue;
@@ -5870,7 +7146,7 @@ var Indexer = class {
       if (edges.length > 0) {
         database.upsertCallEdgesBatch(edges);
         for (const edge of edges) {
-          const candidates = symbolsByName.get(edge.targetName);
+          const candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
           if (candidates && candidates.length === 1) {
             database.resolveCallEdge(edge.id, candidates[0].id);
           }
@@ -5883,14 +7159,20 @@ var Indexer = class {
         allSymbolIds.add(sym.id);
       }
     }
-    let removedCount = 0;
+    const removedChunkIds = [];
     for (const [chunkId] of existingChunks) {
       if (!currentChunkIds.has(chunkId)) {
-        store.remove(chunkId);
+        removedChunkIds.push(chunkId);
+      }
+    }
+    if (removedChunkIds.length > 0) {
+      this.rebuildVectorStoreExcludingChunkIds(store, database, removedChunkIds);
+      for (const chunkId of removedChunkIds) {
         invertedIndex.removeChunk(chunkId);
-        removedCount++;
       }
+      database.deleteChunksByIds(removedChunkIds);
     }
+    const removedCount = removedChunkIds.length;
     stats.totalChunks = pendingChunks.length;
     stats.existingChunks = currentChunkIds.size - pendingChunks.length;
     stats.removedChunks = removedCount;
@@ -5902,12 +7184,20 @@ var Indexer = class {
       removed: removedCount
     });
     if (pendingChunks.length === 0 && removedCount === 0) {
-      database.clearBranch(this.currentBranch);
-      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
-      database.clearBranchSymbols(this.currentBranch);
-      database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
-      this.fileHashCache = currentFileHashes;
-      this.saveFileHashCache();
+      database.clearBranch(branchCatalogKey);
+      database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
+      database.clearBranchSymbols(branchCatalogKey);
+      database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
+      if (scopedRoots) {
+        this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        this.clearScopedFailedBatches(scopedRoots);
+      } else {
+        this.fileHashCache = currentFileHashes;
+        this.saveFileHashCache();
+        this.saveFailedBatches([]);
+      }
+      this.saveIndexMetadata(configuredProviderInfo);
+      this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
       onProgress?.({
         phase: "complete",
@@ -5920,14 +7210,22 @@ var Indexer = class {
       return stats;
     }
     if (pendingChunks.length === 0) {
-      database.clearBranch(this.currentBranch);
-      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
-      database.clearBranchSymbols(this.currentBranch);
-      database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
+      database.clearBranch(branchCatalogKey);
+      database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
+      database.clearBranchSymbols(branchCatalogKey);
+      database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
       store.save();
       invertedIndex.save();
-      this.fileHashCache = currentFileHashes;
-      this.saveFileHashCache();
+      if (scopedRoots) {
+        this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        this.clearScopedFailedBatches(scopedRoots);
+      } else {
+        this.fileHashCache = currentFileHashes;
+        this.saveFileHashCache();
+        this.saveFailedBatches([]);
+      }
+      this.saveIndexMetadata(configuredProviderInfo);
+      this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
       onProgress?.({
         phase: "complete",
@@ -5948,8 +7246,9 @@ var Indexer = class {
     });
     const allContentHashes = pendingChunks.map((c) => c.contentHash);
     const missingHashes = new Set(database.getMissingEmbeddings(allContentHashes));
-    const chunksNeedingEmbedding = pendingChunks.filter((c) => missingHashes.has(c.contentHash));
-    const chunksWithExistingEmbedding = pendingChunks.filter((c) => !missingHashes.has(c.contentHash));
+    const forcedReembedChunkIds = forceScopedReembed ? new Set(pendingChunks.map((chunk) => chunk.id)) : /* @__PURE__ */ new Set();
+    const chunksNeedingEmbedding = pendingChunks.filter((c) => forcedReembedChunkIds.has(c.id) || missingHashes.has(c.contentHash));
+    const chunksWithExistingEmbedding = pendingChunks.filter((c) => !forcedReembedChunkIds.has(c.id) && !missingHashes.has(c.contentHash));
     this.logger.cache("info", "Embedding cache lookup", {
       needsEmbedding: chunksNeedingEmbedding.length,
       fromCache: chunksWithExistingEmbedding.length
@@ -5971,17 +7270,24 @@ var Indexer = class {
       interval: providerRateLimits.intervalMs,
       intervalCap: providerRateLimits.concurrency
     });
-    const dynamicBatches = createDynamicBatches(chunksNeedingEmbedding);
+    const pendingChunksById = new Map(chunksNeedingEmbedding.map((chunk) => [chunk.id, chunk]));
+    const embeddingPartsByChunk = /* @__PURE__ */ new Map();
+    const completedChunkIds = /* @__PURE__ */ new Set();
+    const failedChunkIds = /* @__PURE__ */ new Set();
+    const requestBatches = createPendingEmbeddingRequestBatches(
+      chunksNeedingEmbedding,
+      getDynamicBatchOptions(configuredProviderInfo)
+    );
     let rateLimitBackoffMs = 0;
-    for (const batch of dynamicBatches) {
+    for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve6) => setTimeout(resolve6, rateLimitBackoffMs));
+          await new Promise((resolve8) => setTimeout(resolve8, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
             async () => {
-              const texts = batch.map((c) => c.text);
+              const texts = requestBatch.map((request) => request.text);
               return provider.embedBatch(texts);
             },
             {
@@ -6011,29 +7317,82 @@ var Indexer = class {
           if (rateLimitBackoffMs > 0) {
             rateLimitBackoffMs = Math.max(0, rateLimitBackoffMs - 2e3);
           }
-          const items = batch.map((chunk, idx) => ({
-            id: chunk.id,
-            vector: result.embeddings[idx],
-            metadata: chunk.metadata
-          }));
-          store.addBatch(items);
-          const embeddingBatchItems = batch.map((chunk, i) => ({
-            contentHash: chunk.contentHash,
-            embedding: float32ArrayToBuffer(result.embeddings[i]),
-            chunkText: chunk.text,
-            model: configuredProviderInfo.modelInfo.model
-          }));
-          database.upsertEmbeddingsBatch(embeddingBatchItems);
-          for (const chunk of batch) {
-            invertedIndex.removeChunk(chunk.id);
-            invertedIndex.addChunk(chunk.id, chunk.content);
+          const touchedChunkIds = /* @__PURE__ */ new Set();
+          requestBatch.forEach((request, idx) => {
+            if (failedChunkIds.has(request.chunk.id) || completedChunkIds.has(request.chunk.id)) {
+              return;
+            }
+            const vector = result.embeddings[idx];
+            if (!vector) {
+              throw new Error(`Embedding API returned too few vectors for chunk ${request.chunk.id}`);
+            }
+            const parts = embeddingPartsByChunk.get(request.chunk.id) ?? [];
+            parts[request.partIndex] = {
+              vector,
+              tokenCount: request.tokenCount
+            };
+            embeddingPartsByChunk.set(request.chunk.id, parts);
+            touchedChunkIds.add(request.chunk.id);
+          });
+          const pooledResults = [];
+          for (const chunkId of touchedChunkIds) {
+            if (failedChunkIds.has(chunkId) || completedChunkIds.has(chunkId)) {
+              continue;
+            }
+            const chunk = pendingChunksById.get(chunkId);
+            if (!chunk) {
+              continue;
+            }
+            const parts = embeddingPartsByChunk.get(chunk.id) ?? [];
+            if (!hasAllEmbeddingParts(parts, chunk.texts.length)) {
+              continue;
+            }
+            const orderedParts = parts;
+            pooledResults.push({
+              chunk,
+              vector: poolEmbeddingVectors(
+                orderedParts.map((part) => part.vector),
+                orderedParts.map((part) => part.tokenCount)
+              )
+            });
+          }
+          if (pooledResults.length > 0) {
+            const items = pooledResults.map(({ chunk, vector }) => ({
+              id: chunk.id,
+              vector,
+              metadata: chunk.metadata
+            }));
+            store.addBatch(items);
+            const embeddingBatchItems = pooledResults.map(({ chunk, vector }) => ({
+              contentHash: chunk.contentHash,
+              embedding: float32ArrayToBuffer(vector),
+              chunkText: chunk.storageText,
+              model: configuredProviderInfo.modelInfo.model
+            }));
+            try {
+              database.upsertEmbeddingsBatch(embeddingBatchItems);
+            } catch (dbError) {
+              this.rebuildVectorStoreExcludingChunkIds(
+                store,
+                database,
+                pooledResults.map(({ chunk }) => chunk.id)
+              );
+              throw dbError;
+            }
+            for (const { chunk } of pooledResults) {
+              invertedIndex.removeChunk(chunk.id);
+              invertedIndex.addChunk(chunk.id, chunk.content);
+              completedChunkIds.add(chunk.id);
+              embeddingPartsByChunk.delete(chunk.id);
+            }
+            stats.indexedChunks += pooledResults.length;
+            this.logger.recordChunksEmbedded(pooledResults.length);
           }
-          stats.indexedChunks += batch.length;
           stats.tokensUsed += result.totalTokensUsed;
-          this.logger.recordChunksEmbedded(batch.length);
           this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
           this.logger.embedding("debug", `Embedded batch`, {
-            batchSize: batch.length,
+            batchSize: pooledResults.length,
+            requestCount: requestBatch.length,
             tokens: result.totalTokensUsed
           });
           onProgress?.({
@@ -6044,17 +7403,49 @@ var Indexer = class {
             totalChunks: pendingChunks.length
           });
         } catch (error) {
-          stats.failedChunks += batch.length;
-          this.addFailedBatch(batch, getErrorMessage(error));
+          const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id));
+          const failureMessage = getErrorMessage(error);
+          const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+          for (const chunk of failedChunks) {
+            if (!failedChunkIds.has(chunk.id)) {
+              failedChunkIds.add(chunk.id);
+              stats.failedChunks += 1;
+            }
+            if (forceScopedReembed) {
+              failedForcedChunkIds.add(chunk.id);
+            }
+            embeddingPartsByChunk.delete(chunk.id);
+            const existingFailedBatchIndex = failedBatchesForCurrentRun.findIndex(
+              (failedBatch2) => failedBatch2.chunks[0]?.id === chunk.id
+            );
+            const existingFailedBatch = existingFailedBatchIndex === -1 ? void 0 : failedBatchesForCurrentRun[existingFailedBatchIndex];
+            const failedBatch = {
+              chunks: [chunk],
+              error: failureMessage,
+              attemptCount: (existingFailedBatch?.attemptCount ?? retryableFailedAttemptCounts.get(chunk.id) ?? 0) + 1,
+              lastAttempt: failureTimestamp
+            };
+            if (existingFailedBatchIndex === -1) {
+              failedBatchesForCurrentRun.push(failedBatch);
+            } else {
+              failedBatchesForCurrentRun[existingFailedBatchIndex] = failedBatch;
+            }
+          }
           this.logger.recordEmbeddingError();
           this.logger.embedding("error", `Failed to embed batch after retries`, {
-            batchSize: batch.length,
-            error: getErrorMessage(error)
+            batchSize: failedChunks.length,
+            requestCount: requestBatch.length,
+            error: failureMessage
           });
         }
       });
     }
     await queue.onIdle();
+    if (scopedRoots) {
+      this.saveScopedFailedBatches(coalesceFailedBatches(failedBatchesForCurrentRun), scopedRoots);
+    } else {
+      this.saveFailedBatches(coalesceFailedBatches(failedBatchesForCurrentRun));
+    }
     onProgress?.({
       phase: "storing",
       filesProcessed: files.length,
@@ -6062,18 +7453,48 @@ var Indexer = class {
       chunksProcessed: stats.indexedChunks,
       totalChunks: pendingChunks.length
     });
-    database.clearBranch(this.currentBranch);
-    database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
-    database.clearBranchSymbols(this.currentBranch);
-    database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
+    const branchChunkIds = Array.from(currentChunkIds).filter(
+      (chunkId) => {
+        const isNewlyFailed = failedChunkIds.has(chunkId) && !retryableChunksWithExistingData.has(chunkId);
+        const isForcedFailed = forceScopedReembed && failedForcedChunkIds.has(chunkId);
+        return !isNewlyFailed && !isForcedFailed;
+      }
+    );
+    database.clearBranch(branchCatalogKey);
+    database.addChunksToBranchBatch(branchCatalogKey, branchChunkIds);
+    database.clearBranchSymbols(branchCatalogKey);
+    database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
     store.save();
     invertedIndex.save();
-    this.fileHashCache = currentFileHashes;
-    this.saveFileHashCache();
+    if (scopedRoots) {
+      this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+    } else {
+      this.fileHashCache = currentFileHashes;
+      this.saveFileHashCache();
+    }
     if (this.config.indexing.autoGc && stats.removedChunks > 0) {
-      await this.maybeRunOrphanGc();
+      const gcReset = await this.maybeRunOrphanGc();
+      if (gcReset) {
+        stats.durationMs = Date.now() - startTime;
+        stats.warning = gcReset.warning;
+        stats.resetCorruptedIndex = true;
+        this.logger.recordIndexingEnd();
+        this.logger.warn("Indexing ended after resetting corrupted local index during automatic GC", {
+          files: stats.totalFiles,
+          indexed: stats.indexedChunks,
+          existing: stats.existingChunks,
+          removed: stats.removedChunks,
+          failed: stats.failedChunks,
+          tokens: stats.tokensUsed,
+          durationMs: stats.durationMs
+        });
+        return stats;
+      }
     }
     stats.durationMs = Date.now() - startTime;
+    if (forceScopedReembed && failedForcedChunkIds.size === 0) {
+      database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+    }
     this.saveIndexMetadata(configuredProviderInfo);
     this.indexCompatibility = { compatible: true };
     this.logger.recordIndexingEnd();
@@ -6202,27 +7623,30 @@ var Indexer = class {
     const keywordResults = await this.keywordSearch(query, maxResults * 4);
     const keywordMs = performance2.now() - keywordStartTime;
     let branchChunkIds = null;
-    if (filterByBranch && this.currentBranch !== "default") {
-      branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
+    if (filterByBranch && (this.config.scope === "global" || this.currentBranch !== "default")) {
+      branchChunkIds = new Set(
+        this.getBranchCatalogKeys().flatMap((branchKey) => database.getBranchChunkIds(branchKey))
+      );
     }
     const prefilterStartTime = performance2.now();
-    const shouldPrefilterByBranch = branchChunkIds !== null && branchChunkIds.size > 0;
+    const shouldPrefilterByBranch = branchChunkIds !== null && (this.config.scope === "global" || branchChunkIds.size > 0);
+    const allowBranchPrefilterFallback = this.config.scope !== "global";
     const prefilteredSemantic = shouldPrefilterByBranch && branchChunkIds ? semanticResults.filter((r) => branchChunkIds.has(r.id)) : semanticResults;
     const prefilteredKeyword = shouldPrefilterByBranch && branchChunkIds ? keywordResults.filter((r) => branchChunkIds.has(r.id)) : keywordResults;
-    const semanticCandidates = shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
-    const keywordCandidates = shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0 ? keywordResults : prefilteredKeyword;
+    const semanticCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
+    const keywordCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0 ? keywordResults : prefilteredKeyword;
     const prefilterMs = performance2.now() - prefilterStartTime;
-    if (branchChunkIds && branchChunkIds.size === 0) {
+    if (this.config.scope !== "global" && branchChunkIds && branchChunkIds.size === 0) {
       this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
         branch: this.currentBranch
       });
     }
-    if (shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
+    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
       this.logger.search("warn", "Branch prefilter produced no semantic overlap, using unfiltered semantic candidates", {
         branch: this.currentBranch
       });
     }
-    if (shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0) {
+    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0) {
       this.logger.search("warn", "Branch prefilter produced no keyword overlap, using unfiltered keyword candidates", {
         branch: this.currentBranch
       });
@@ -6275,26 +7699,13 @@ var Indexer = class {
     const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
     const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
     const hasCodeHints = extractCodeTermHints(query).length > 0 || identifierHints.length > 0;
-    const baseFiltered = tiered.filter((r) => {
-      if (r.score < this.config.search.minScore) return false;
-      if (options?.fileType) {
-        const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
-        if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
-      }
-      if (options?.directory) {
-        const normalizedDir = options.directory.replace(/^\/|\/$/g, "");
-        if (!r.metadata.filePath.includes(`/${normalizedDir}/`) && !r.metadata.filePath.includes(`${normalizedDir}/`)) return false;
-      }
-      if (options?.chunkType) {
-        if (r.metadata.chunkType !== options.chunkType) return false;
-      }
-      return true;
-    });
+    const baseFiltered = tiered.filter((r) => matchesSearchFilters(r, options, this.config.search.minScore));
     const implementationOnly = baseFiltered.filter(
       (r) => isLikelyImplementationPath(r.metadata.filePath) && isImplementationChunkType(r.metadata.chunkType)
     );
     const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : baseFiltered).slice(0, maxResults);
-    const finalResults = filtered;
+    const identifierFallback = !options?.definitionIntent && filtered.length === 0 && identifierHints.length > 0 ? buildSymbolDefinitionLane(query, database, branchChunkIds, maxResults, union, true).filter((r) => matchesSearchFilters(r, options, this.config.search.minScore)).slice(0, maxResults) : [];
+    const finalResults = filtered.length > 0 ? filtered : identifierFallback;
     const totalSearchMs = performance2.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
       embeddingMs,
@@ -6364,7 +7775,8 @@ var Indexer = class {
     return results.slice(0, limit);
   }
   async getStatus() {
-    const { store, configuredProviderInfo } = await this.ensureInitialized();
+    const { store, configuredProviderInfo, database } = await this.ensureInitialized();
+    const failedBatchesCount = this.getFailedBatchesCount();
     return {
       indexed: store.count() > 0,
       vectorCount: store.count(),
@@ -6373,23 +7785,86 @@ var Indexer = class {
       indexPath: this.indexPath,
       currentBranch: this.currentBranch,
       baseBranch: this.baseBranch,
-      compatibility: this.indexCompatibility
+      compatibility: this.indexCompatibility,
+      failedBatchesCount,
+      failedBatchesPath: failedBatchesCount > 0 ? this.failedBatchesPath : void 0,
+      warning: database.getMetadata(STARTUP_WARNING_METADATA_KEY) ?? void 0
     };
   }
   async clearIndex() {
     const { store, invertedIndex, database } = await this.ensureInitialized();
+    if (this.config.scope === "global") {
+      store.load();
+      invertedIndex.load();
+      this.loadFileHashCache();
+      const roots = this.getScopedRoots();
+      const compatibility = this.checkCompatibility();
+      const allMetadata = store.getAllMetadata();
+      const hasForeignData = allMetadata.some(({ metadata }) => !this.isFileInCurrentScope(metadata.filePath, roots)) || this.hasForeignScopedBranchData() || this.hasForeignScopedFileHashData(roots) || this.hasForeignScopedFailedBatches(roots);
+      if (!compatibility.compatible && hasForeignData) {
+        if (compatibility.code === "EMBEDDING_STRATEGY_MISMATCH" /* EMBEDDING_STRATEGY_MISMATCH */) {
+          this.clearSharedIndexProjectData(store, invertedIndex, database, roots);
+          this.clearScopedFileHashCache(roots);
+          this.clearScopedFailedBatches(roots);
+          database.setMetadata(this.getProjectForceReembedMetadataKey(), "true");
+          database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey());
+          this.indexCompatibility = { compatible: true };
+          return;
+        }
+        throw new Error(
+          `Global index compatibility reset is unsafe because the shared index contains files from other projects. The current global index cannot be force-rebuilt for ${this.projectRoot} without deleting other repositories' indexed data. Use scope="project" for isolated rebuilds, or manually delete the shared global index if you intend to rebuild all projects.`
+        );
+      }
+      if (!hasForeignData) {
+        store.clear();
+        store.save();
+        invertedIndex.clear();
+        invertedIndex.save();
+        this.fileHashCache.clear();
+        this.saveFileHashCache();
+        database.clearAllIndexedData();
+        this.saveFailedBatches([]);
+        database.deleteMetadata("index.version");
+        database.deleteMetadata("index.embeddingProvider");
+        database.deleteMetadata("index.embeddingModel");
+        database.deleteMetadata("index.embeddingDimensions");
+        database.deleteMetadata("index.embeddingStrategyVersion");
+        database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey());
+        database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+        database.deleteMetadata(this.getLegacyMigrationMetadataKey());
+        database.deleteMetadata("index.createdAt");
+        database.deleteMetadata("index.updatedAt");
+        this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+        return;
+      }
+      this.clearSharedIndexProjectData(store, invertedIndex, database, roots);
+      this.clearScopedFileHashCache(roots);
+      this.clearScopedFailedBatches(roots);
+      this.indexCompatibility = compatibility;
+      return;
+    }
+    const localProjectIndexPath = path8.join(this.projectRoot, ".opencode", "index");
+    if (path8.resolve(this.indexPath) !== path8.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."
+      );
+    }
     store.clear();
     store.save();
     invertedIndex.clear();
     invertedIndex.save();
     this.fileHashCache.clear();
     this.saveFileHashCache();
-    database.clearBranch(this.currentBranch);
-    database.clearBranchSymbols(this.currentBranch);
+    database.clearAllIndexedData();
+    this.saveFailedBatches([]);
     database.deleteMetadata("index.version");
     database.deleteMetadata("index.embeddingProvider");
     database.deleteMetadata("index.embeddingModel");
     database.deleteMetadata("index.embeddingDimensions");
+    database.deleteMetadata("index.embeddingStrategyVersion");
+    database.deleteMetadata(this.getProjectEmbeddingStrategyMetadataKey());
+    database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+    database.deleteMetadata(this.getLegacyMigrationMetadataKey());
     database.deleteMetadata("index.createdAt");
     database.deleteMetadata("index.updatedAt");
     this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
@@ -6405,28 +7880,61 @@ var Indexer = class {
       filePathsToChunkKeys.set(metadata.filePath, existing);
     }
     const removedFilePaths = [];
-    let removedCount = 0;
+    const removedChunkKeys = [];
+    const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync4(filePath)) {
+      if (!existsSync6(filePath)) {
+        chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
-          store.remove(key);
-          invertedIndex.removeChunk(key);
-          removedCount++;
+          removedChunkKeys.push(key);
         }
-        database.deleteChunksByFile(filePath);
-        database.deleteCallEdgesByFile(filePath);
-        database.deleteSymbolsByFile(filePath);
         removedFilePaths.push(filePath);
       }
     }
+    if (removedChunkKeys.length > 0) {
+      this.rebuildVectorStoreExcludingChunkIds(store, database, removedChunkKeys);
+      for (const key of removedChunkKeys) {
+        invertedIndex.removeChunk(key);
+      }
+    }
+    for (const filePath of removedFilePaths) {
+      const fileChunkKeys = chunkKeysByRemovedFile.get(filePath) ?? [];
+      if (fileChunkKeys.length > 0) {
+        database.deleteChunksByIds(fileChunkKeys);
+      }
+      database.deleteCallEdgesByFile(filePath);
+      database.deleteSymbolsByFile(filePath);
+    }
+    const removedCount = removedChunkKeys.length;
     if (removedCount > 0) {
       store.save();
       invertedIndex.save();
     }
-    const gcOrphanEmbeddings = database.gcOrphanEmbeddings();
-    const gcOrphanChunks = database.gcOrphanChunks();
-    const gcOrphanSymbols = database.gcOrphanSymbols();
-    const gcOrphanCallEdges = database.gcOrphanCallEdges();
+    let gcOrphanEmbeddings;
+    let gcOrphanChunks;
+    let gcOrphanSymbols;
+    let gcOrphanCallEdges;
+    try {
+      gcOrphanEmbeddings = database.gcOrphanEmbeddings();
+      gcOrphanChunks = database.gcOrphanChunks();
+      gcOrphanSymbols = database.gcOrphanSymbols();
+      gcOrphanCallEdges = database.gcOrphanCallEdges();
+    } catch (error) {
+      if (!await this.tryResetCorruptedIndex("running index health check", error)) {
+        throw error;
+      }
+      await this.ensureInitialized();
+      return {
+        removed: 0,
+        filePaths: [],
+        gcOrphanEmbeddings: 0,
+        gcOrphanChunks: 0,
+        gcOrphanSymbols: 0,
+        gcOrphanCallEdges: 0,
+        resetCorruptedIndex: true,
+        warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+      };
+    }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
     this.logger.gc("info", "Health check complete", {
       removedStale: removedCount,
@@ -6437,8 +7945,12 @@ var Indexer = class {
     return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks, gcOrphanSymbols, gcOrphanCallEdges };
   }
   async retryFailedBatches() {
-    const { store, provider, invertedIndex } = await this.ensureInitialized();
-    const failedBatches = this.loadFailedBatches();
+    const { store, provider, invertedIndex, database, configuredProviderInfo } = await this.ensureInitialized();
+    const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
+    const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
+    const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
+    const { scoped: scopedFailedBatches, retained: retainedFailedBatches } = roots ? this.partitionFailedBatches(roots, maxChunkTokens) : { scoped: this.loadFailedBatches(maxChunkTokens), retained: [] };
+    const failedBatches = scopedFailedBatches;
     if (failedBatches.length === 0) {
       return { succeeded: 0, failed: 0, remaining: 0 };
     }
@@ -6446,49 +7958,170 @@ var Indexer = class {
     let failed = 0;
     const stillFailing = [];
     for (const batch of failedBatches) {
+      const batchChunksById = new Map(batch.chunks.map((chunk) => [chunk.id, chunk]));
+      const embeddingPartsByChunk = /* @__PURE__ */ new Map();
+      const completedChunkIds = /* @__PURE__ */ new Set();
+      const failedChunkIds = /* @__PURE__ */ new Set();
+      const failedChunksForBatch = /* @__PURE__ */ new Map();
+      const pooledResults = [];
       try {
-        const result = await pRetry(
-          async () => {
-            const texts = batch.chunks.map((c) => c.text);
-            return provider.embedBatch(texts);
-          },
-          {
-            retries: this.config.indexing.retries,
-            minTimeout: this.config.indexing.retryDelayMs
-          }
+        const requestBatches = createPendingEmbeddingRequestBatches(
+          batch.chunks,
+          getDynamicBatchOptions(configuredProviderInfo)
         );
-        const items = batch.chunks.map((chunk, idx) => ({
+        for (const requestBatch of requestBatches) {
+          try {
+            const result = await pRetry(
+              async () => {
+                const texts = requestBatch.map((request) => request.text);
+                return provider.embedBatch(texts);
+              },
+              {
+                retries: this.config.indexing.retries,
+                minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
+                maxTimeout: providerRateLimits.maxRetryMs,
+                factor: 2,
+                shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError)
+              }
+            );
+            const touchedChunkIds = /* @__PURE__ */ new Set();
+            requestBatch.forEach((request, idx) => {
+              if (failedChunkIds.has(request.chunk.id) || completedChunkIds.has(request.chunk.id)) {
+                return;
+              }
+              const vector = result.embeddings[idx];
+              if (!vector) {
+                throw new Error(`Embedding API returned too few vectors for chunk ${request.chunk.id}`);
+              }
+              const parts = embeddingPartsByChunk.get(request.chunk.id) ?? [];
+              parts[request.partIndex] = {
+                vector,
+                tokenCount: request.tokenCount
+              };
+              embeddingPartsByChunk.set(request.chunk.id, parts);
+              touchedChunkIds.add(request.chunk.id);
+            });
+            for (const chunkId of touchedChunkIds) {
+              if (failedChunkIds.has(chunkId) || completedChunkIds.has(chunkId)) {
+                continue;
+              }
+              const chunk = batchChunksById.get(chunkId);
+              if (!chunk) {
+                continue;
+              }
+              const parts = embeddingPartsByChunk.get(chunk.id) ?? [];
+              if (!hasAllEmbeddingParts(parts, chunk.texts.length)) {
+                continue;
+              }
+              const orderedParts = parts;
+              pooledResults.push({
+                chunk,
+                vector: poolEmbeddingVectors(
+                  orderedParts.map((part) => part.vector),
+                  orderedParts.map((part) => part.tokenCount)
+                )
+              });
+            }
+            this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
+          } catch (error) {
+            const failureMessage = String(error);
+            const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+            const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id) && !failedChunkIds.has(chunk.id));
+            for (const chunk of failedChunks) {
+              failedChunkIds.add(chunk.id);
+              embeddingPartsByChunk.delete(chunk.id);
+              failedChunksForBatch.set(chunk.id, {
+                chunks: [chunk],
+                attemptCount: batch.attemptCount + 1,
+                lastAttempt: failureTimestamp,
+                error: failureMessage
+              });
+            }
+            failed += failedChunks.length;
+            this.logger.recordEmbeddingError();
+          }
+        }
+        const successfulResults = pooledResults.filter(({ chunk }) => !failedChunkIds.has(chunk.id));
+        const items = successfulResults.map(({ chunk, vector }) => ({
           id: chunk.id,
-          vector: result.embeddings[idx],
+          vector,
           metadata: chunk.metadata
         }));
-        store.addBatch(items);
-        for (const chunk of batch.chunks) {
+        if (items.length > 0) {
+          store.addBatch(items);
+        }
+        if (successfulResults.length > 0) {
+          try {
+            database.upsertEmbeddingsBatch(
+              successfulResults.map(({ chunk, vector }) => ({
+                contentHash: chunk.contentHash,
+                embedding: float32ArrayToBuffer(vector),
+                chunkText: chunk.storageText,
+                model: configuredProviderInfo.modelInfo.model
+              }))
+            );
+          } catch (dbError) {
+            this.rebuildVectorStoreExcludingChunkIds(
+              store,
+              database,
+              successfulResults.map(({ chunk }) => chunk.id)
+            );
+            throw dbError;
+          }
+        }
+        for (const { chunk } of successfulResults) {
           invertedIndex.removeChunk(chunk.id);
           invertedIndex.addChunk(chunk.id, chunk.content);
+          completedChunkIds.add(chunk.id);
+          embeddingPartsByChunk.delete(chunk.id);
         }
-        this.logger.recordChunksEmbedded(batch.chunks.length);
-        this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
-        succeeded += batch.chunks.length;
+        database.addChunksToBranchBatch(
+          this.getBranchCatalogKey(),
+          successfulResults.map(({ chunk }) => chunk.id)
+        );
+        this.logger.recordChunksEmbedded(successfulResults.length);
+        succeeded += successfulResults.length;
+        stillFailing.push(...failedChunksForBatch.values());
       } catch (error) {
-        failed += batch.chunks.length;
+        const failureMessage = getErrorMessage(error);
+        const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const unaccountedChunks = batch.chunks.filter(
+          (chunk) => !failedChunksForBatch.has(chunk.id) && !completedChunkIds.has(chunk.id)
+        );
+        for (const chunk of unaccountedChunks) {
+          failedChunksForBatch.set(chunk.id, {
+            chunks: [chunk],
+            attemptCount: batch.attemptCount + 1,
+            lastAttempt: failureTimestamp,
+            error: failureMessage
+          });
+        }
+        failed += unaccountedChunks.length;
         this.logger.recordEmbeddingError();
-        stillFailing.push({
-          ...batch,
-          attemptCount: batch.attemptCount + 1,
-          lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
-          error: String(error)
-        });
+        stillFailing.push(...coalesceFailedBatches(Array.from(failedChunksForBatch.values())));
       }
     }
-    this.saveFailedBatches(stillFailing);
+    const persistedStillFailing = coalesceFailedBatches(stillFailing);
+    if (roots) {
+      this.saveFailedBatches([...retainedFailedBatches, ...persistedStillFailing]);
+    } else {
+      this.saveFailedBatches(persistedStillFailing);
+    }
     if (succeeded > 0) {
       store.save();
       invertedIndex.save();
     }
-    return { succeeded, failed, remaining: stillFailing.length };
+    if (roots && succeeded > 0 && persistedStillFailing.length === 0 && this.hasProjectForceReembedPending()) {
+      database.deleteMetadata(this.getProjectForceReembedMetadataKey());
+      this.saveIndexMetadata(configuredProviderInfo);
+      this.indexCompatibility = { compatible: true };
+    }
+    return { succeeded, failed, remaining: persistedStillFailing.length };
   }
   getFailedBatchesCount() {
+    if (this.config.scope === "global") {
+      return this.partitionFailedBatches(this.getScopedRoots()).scoped.length;
+    }
     return this.loadFailedBatches().length;
   }
   getCurrentBranch() {
@@ -6537,20 +8170,23 @@ var Indexer = class {
     const semanticResults = store.search(embedding, limit * 2);
     const vectorMs = performance2.now() - vectorStartTime;
     let branchChunkIds = null;
-    if (filterByBranch && this.currentBranch !== "default") {
-      branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
+    if (filterByBranch && (this.config.scope === "global" || this.currentBranch !== "default")) {
+      branchChunkIds = new Set(
+        this.getBranchCatalogKeys().flatMap((branchKey) => database.getBranchChunkIds(branchKey))
+      );
     }
     const prefilterStartTime = performance2.now();
-    const shouldPrefilterByBranch = branchChunkIds !== null && branchChunkIds.size > 0;
+    const shouldPrefilterByBranch = branchChunkIds !== null && (this.config.scope === "global" || branchChunkIds.size > 0);
+    const allowBranchPrefilterFallback = this.config.scope !== "global";
     const prefilteredSemantic = shouldPrefilterByBranch && branchChunkIds ? semanticResults.filter((r) => branchChunkIds.has(r.id)) : semanticResults;
-    const semanticCandidates = shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
+    const semanticCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
     const prefilterMs = performance2.now() - prefilterStartTime;
-    if (branchChunkIds && branchChunkIds.size === 0) {
+    if (this.config.scope !== "global" && branchChunkIds && branchChunkIds.size === 0) {
       this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
         branch: this.currentBranch
       });
     }
-    if (shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
+    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
       this.logger.search("warn", "Branch prefilter produced no semantic overlap, using unfiltered semantic candidates", {
         branch: this.currentBranch
       });
@@ -6623,11 +8259,39 @@ var Indexer = class {
   }
   async getCallers(targetName) {
     const { database } = await this.ensureInitialized();
-    return database.getCallersWithContext(targetName, this.currentBranch);
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const branchKey of this.getBranchCatalogKeys()) {
+      for (const edge of database.getCallersWithContext(targetName, branchKey)) {
+        if (!seen.has(edge.id)) {
+          seen.add(edge.id);
+          results.push(edge);
+        }
+      }
+    }
+    return results;
   }
   async getCallees(symbolId) {
     const { database } = await this.ensureInitialized();
-    return database.getCallees(symbolId, this.currentBranch);
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const branchKey of this.getBranchCatalogKeys()) {
+      for (const edge of database.getCallees(symbolId, branchKey)) {
+        if (!seen.has(edge.id)) {
+          seen.add(edge.id);
+          results.push(edge);
+        }
+      }
+    }
+    return results;
+  }
+  async close() {
+    await this.database?.close();
+    this.database = null;
+    this.store = null;
+    this.invertedIndex = null;
+    this.provider = null;
+    this.reranker = null;
   }
 };
 
@@ -6878,9 +8542,9 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
 }
 
 // src/eval/schema.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function parseJsonFile(filePath) {
-  const content = readFileSync6(filePath, "utf-8");
+  const content = readFileSync7(filePath, "utf-8");
   return JSON.parse(content);
 }
 function isRecord(value) {
@@ -6889,23 +8553,23 @@ function isRecord(value) {
 function isStringArray2(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function asPositiveNumber(value, path11) {
+function asPositiveNumber(value, path13) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path11} must be a non-negative number`);
+    throw new Error(`${path13} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path11) {
+function parseQueryType(value, path13) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
     return value;
   }
   throw new Error(
-    `${path11} must be one of: definition, implementation-intent, similarity, keyword-heavy`
+    `${path13} must be one of: definition, implementation-intent, similarity, keyword-heavy`
   );
 }
-function parseExpected(input, path11) {
+function parseExpected(input, path13) {
   if (!isRecord(input)) {
-    throw new Error(`${path11} must be an object`);
+    throw new Error(`${path13} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -6914,16 +8578,16 @@ function parseExpected(input, path11) {
   const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
   const acceptableFiles = isStringArray2(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
   if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path11} must include either expected.filePath or expected.acceptableFiles`);
+    throw new Error(`${path13} must include either expected.filePath or expected.acceptableFiles`);
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray2(acceptableFilesRaw)) {
-    throw new Error(`${path11}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path13}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path11}.symbol must be a string when provided`);
+    throw new Error(`${path13}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path11}.branch must be a string when provided`);
+    throw new Error(`${path13}.branch must be a string when provided`);
   }
   return {
     filePath,
@@ -6933,25 +8597,25 @@ function parseExpected(input, path11) {
   };
 }
 function parseQuery(input, index) {
-  const path11 = `queries[${index}]`;
+  const path13 = `queries[${index}]`;
   if (!isRecord(input)) {
-    throw new Error(`${path11} must be an object`);
+    throw new Error(`${path13} 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(`${path11}.id must be a non-empty string`);
+    throw new Error(`${path13}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path11}.query must be a non-empty string`);
+    throw new Error(`${path13}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path11}.queryType`),
-    expected: parseExpected(expected, `${path11}.expected`)
+    queryType: parseQueryType(queryType, `${path13}.queryType`),
+    expected: parseExpected(expected, `${path13}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -7048,35 +8712,83 @@ function loadBudget(budgetPath) {
 
 // src/eval/runner.ts
 function toAbsolute(projectRoot, maybeRelative) {
-  return path7.isAbsolute(maybeRelative) ? maybeRelative : path7.join(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 && existsSync5(fromPath)) {
-    return JSON.parse(readFileSync7(fromPath, "utf-8"));
+  if (fromPath && existsSync7(fromPath)) {
+    return normalizeEvalConfigKnowledgeBases(
+      JSON.parse(readFileSync8(fromPath, "utf-8")),
+      projectRoot,
+      fromPath
+    );
   }
-  const projectConfig = path7.join(projectRoot, ".opencode", "codebase-index.json");
-  if (existsSync5(projectConfig)) {
-    return JSON.parse(readFileSync7(projectConfig, "utf-8"));
+  const projectConfig = resolveProjectConfigPath(projectRoot);
+  if (existsSync7(projectConfig)) {
+    return normalizeEvalConfigKnowledgeBases(
+      JSON.parse(readFileSync8(projectConfig, "utf-8")),
+      projectRoot,
+      projectConfig
+    );
   }
-  const globalConfig = path7.join(os3.homedir(), ".config", "opencode", "codebase-index.json");
-  if (existsSync5(globalConfig)) {
-    return JSON.parse(readFileSync7(globalConfig, "utf-8"));
+  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) {
-  if (scope === "global") {
-    return path7.join(os3.homedir(), ".opencode", "global-index");
-  }
-  return path7.join(projectRoot, ".opencode", "index");
+  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 = getIndexRootPath(projectRoot, scope);
-  if (existsSync5(indexRoot)) {
+  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);
@@ -7107,94 +8819,99 @@ async function runEvaluation(options) {
   const againstPath = options.againstPath ? toAbsolute(options.projectRoot, options.againstPath) : void 0;
   const budgetPath = options.budgetPath ? toAbsolute(options.projectRoot, options.budgetPath) : void 0;
   const dataset = loadGoldenDataset(datasetPath);
-  const parsedConfig = loadParsedConfig(options.projectRoot, options.configPath);
+  const resolvedEvalConfigPath = options.reindex ? ensureLocalEvalProjectConfig(options.projectRoot, options.configPath) : options.configPath;
+  const parsedConfig = loadParsedConfig(options.projectRoot, resolvedEvalConfigPath);
   const effectiveConfig = resolveSearchConfig(parsedConfig, options.searchOverrides);
   if (options.reindex) {
     clearIndexRoot(options.projectRoot, effectiveConfig.scope);
   }
   const indexer = new Indexer(options.projectRoot, effectiveConfig);
-  await indexer.index();
-  const perQuery = [];
-  for (const query of dataset.queries) {
-    if (query.expected.branch && query.expected.branch !== indexer.getCurrentBranch()) {
-      throw new Error(
-        `Query '${query.id}' expects branch '${query.expected.branch}', but current branch is '${indexer.getCurrentBranch()}'. Switch branch before running this dataset.`
-      );
-    }
-    const start = performance3.now();
-    const result = await indexer.search(query.query, 10, {
-      metadataOnly: true,
-      filterByBranch: query.expected.branch ? true : false
-    });
-    const elapsed = performance3.now() - start;
-    const materialized = result.map((item) => ({
-      filePath: item.filePath,
-      startLine: item.startLine,
-      endLine: item.endLine,
-      score: item.score,
-      chunkType: item.chunkType,
-      name: item.name
-    }));
-    perQuery.push(buildPerQueryResult(query, materialized, elapsed, 10));
-  }
-  const logger = indexer.getLogger();
-  const metricSnapshot = logger.getMetrics();
-  const costPer1MTokensUsd = effectiveConfig.embeddingProvider === "custom" || effectiveConfig.embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(effectiveConfig.embeddingProvider).costPer1MTokens;
-  const summary = {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    projectRoot: options.projectRoot,
-    datasetPath,
-    datasetName: dataset.name,
-    datasetVersion: dataset.version,
-    queryCount: dataset.queries.length,
-    topK: 10,
-    searchConfig: {
-      fusionStrategy: effectiveConfig.search.fusionStrategy,
-      hybridWeight: effectiveConfig.search.hybridWeight,
-      rrfK: effectiveConfig.search.rrfK,
-      rerankTopN: effectiveConfig.search.rerankTopN
-    },
-    metrics: computeEvalMetrics(
-      dataset.queries,
-      perQuery,
-      metricSnapshot.embeddingApiCalls,
-      metricSnapshot.embeddingTokensUsed,
-      costPer1MTokensUsd
-    )
-  };
-  const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
-  const perQueryArtifact = buildPerQueryArtifact(perQuery);
-  writeJson(path7.join(outputDir, "summary.json"), summary);
-  writeJson(path7.join(outputDir, "per-query.json"), perQueryArtifact);
-  let comparison;
-  if (againstPath) {
-    const baseline = loadSummary(againstPath);
-    comparison = compareSummaries(summary, baseline, againstPath);
-    writeJson(path7.join(outputDir, "compare.json"), comparison);
-  }
-  let gate;
-  if (options.ciMode) {
-    if (!budgetPath) {
-      throw new Error("CI mode requires --budget path");
-    }
-    const budget = loadBudget(budgetPath);
-    if (!comparison && budget.baselinePath) {
-      const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
-      if (existsSync5(resolvedBaseline)) {
-        const baselineSummary = loadSummary(resolvedBaseline);
-        comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
-        writeJson(path7.join(outputDir, "compare.json"), comparison);
-      } else if (budget.failOnMissingBaseline) {
+  try {
+    await indexer.index();
+    const perQuery = [];
+    for (const query of dataset.queries) {
+      if (query.expected.branch && query.expected.branch !== indexer.getCurrentBranch()) {
         throw new Error(
-          `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
+          `Query '${query.id}' expects branch '${query.expected.branch}', but current branch is '${indexer.getCurrentBranch()}'. Switch branch before running this dataset.`
         );
       }
+      const start = performance3.now();
+      const result = await indexer.search(query.query, 10, {
+        metadataOnly: true,
+        filterByBranch: query.expected.branch ? true : false
+      });
+      const elapsed = performance3.now() - start;
+      const materialized = result.map((item) => ({
+        filePath: item.filePath,
+        startLine: item.startLine,
+        endLine: item.endLine,
+        score: item.score,
+        chunkType: item.chunkType,
+        name: item.name
+      }));
+      perQuery.push(buildPerQueryResult(query, materialized, elapsed, 10));
+    }
+    const logger = indexer.getLogger();
+    const metricSnapshot = logger.getMetrics();
+    const costPer1MTokensUsd = effectiveConfig.embeddingProvider === "custom" || effectiveConfig.embeddingProvider === "auto" ? 0 : getDefaultModelForProvider(effectiveConfig.embeddingProvider).costPer1MTokens;
+    const summary = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot: options.projectRoot,
+      datasetPath,
+      datasetName: dataset.name,
+      datasetVersion: dataset.version,
+      queryCount: dataset.queries.length,
+      topK: 10,
+      searchConfig: {
+        fusionStrategy: effectiveConfig.search.fusionStrategy,
+        hybridWeight: effectiveConfig.search.hybridWeight,
+        rrfK: effectiveConfig.search.rrfK,
+        rerankTopN: effectiveConfig.search.rerankTopN
+      },
+      metrics: computeEvalMetrics(
+        dataset.queries,
+        perQuery,
+        metricSnapshot.embeddingApiCalls,
+        metricSnapshot.embeddingTokensUsed,
+        costPer1MTokensUsd
+      )
+    };
+    const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
+    const perQueryArtifact = buildPerQueryArtifact(perQuery);
+    writeJson(path9.join(outputDir, "summary.json"), summary);
+    writeJson(path9.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);
+    }
+    let gate;
+    if (options.ciMode) {
+      if (!budgetPath) {
+        throw new Error("CI mode requires --budget path");
+      }
+      const budget = loadBudget(budgetPath);
+      if (!comparison && budget.baselinePath) {
+        const resolvedBaseline = toAbsolute(options.projectRoot, budget.baselinePath);
+        if (existsSync7(resolvedBaseline)) {
+          const baselineSummary = loadSummary(resolvedBaseline);
+          comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
+          writeJson(path9.join(outputDir, "compare.json"), comparison);
+        } else if (budget.failOnMissingBaseline) {
+          throw new Error(
+            `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
+          );
+        }
+      }
+      gate = evaluateBudgetGate(budget, summary, comparison);
     }
-    gate = evaluateBudgetGate(budget, summary, comparison);
+    const markdown = createSummaryMarkdown(summary, comparison, gate);
+    writeText(path9.join(outputDir, "summary.md"), markdown);
+    return { outputDir, summary, perQuery, comparison, gate };
+  } finally {
+    await indexer.close();
   }
-  const markdown = createSummaryMarkdown(summary, comparison, gate);
-  writeText(path7.join(outputDir, "summary.md"), markdown);
-  return { outputDir, summary, perQuery, comparison, gate };
 }
 async function runSweep(options, sweep) {
   const fusionValues = sweep.fusionStrategy && sweep.fusionStrategy.length > 0 ? [...sweep.fusionStrategy] : [void 0];
@@ -7248,15 +8965,15 @@ async function runSweep(options, sweep) {
     bestByMrrAt10,
     bestByP95Latency
   };
-  writeJson(path7.join(outputDir, "compare.json"), aggregate);
+  writeJson(path9.join(outputDir, "compare.json"), aggregate);
   const md = createSummaryMarkdown(
     bestByHitAt5?.summary ?? runs[0].summary,
     bestByHitAt5?.comparison,
     void 0,
     aggregate
   );
-  writeText(path7.join(outputDir, "summary.md"), md);
-  writeJson(path7.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  writeText(path9.join(outputDir, "summary.md"), md);
+  writeJson(path9.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
   return { outputDir, aggregate };
 }
 
@@ -7332,12 +9049,12 @@ function parseEvalArgs(argv, cwd) {
     const arg = argv[i];
     const next = argv[i + 1];
     if (arg === "--project" && next) {
-      parsed.projectRoot = path8.resolve(cwd, next);
+      parsed.projectRoot = path10.resolve(cwd, next);
       i += 1;
       continue;
     }
     if (arg === "--config" && next) {
-      parsed.configPath = path8.resolve(cwd, next);
+      parsed.configPath = path10.resolve(cwd, next);
       i += 1;
       continue;
     }
@@ -7531,22 +9248,22 @@ async function handleEvalCommand(args, cwd) {
     if (!parsed.againstPath.endsWith(".json")) {
       throw new Error("eval diff --against must point to a summary JSON file");
     }
-    const currentSummary = loadSummary(path8.resolve(parsed.projectRoot, currentPath), {
+    const currentSummary = loadSummary(path10.resolve(parsed.projectRoot, currentPath), {
       allowLegacyDiversityMetrics: true
     });
-    const baselineSummary = loadSummary(path8.resolve(parsed.projectRoot, parsed.againstPath), {
+    const baselineSummary = loadSummary(path10.resolve(parsed.projectRoot, parsed.againstPath), {
       allowLegacyDiversityMetrics: true
     });
     const comparison = compareSummaries(
       currentSummary,
       baselineSummary,
-      path8.resolve(parsed.projectRoot, parsed.againstPath)
+      path10.resolve(parsed.projectRoot, parsed.againstPath)
     );
-    const outputDir = createRunDirectory(path8.resolve(parsed.projectRoot, parsed.outputRoot));
+    const outputDir = createRunDirectory(path10.resolve(parsed.projectRoot, parsed.outputRoot));
     const summaryMd = createSummaryMarkdown(currentSummary, comparison);
-    writeJson(path8.join(outputDir, "compare.json"), comparison);
-    writeText(path8.join(outputDir, "summary.md"), summaryMd);
-    writeJson(path8.join(outputDir, "summary.json"), currentSummary);
+    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;
   }
@@ -7556,6 +9273,8 @@ async function handleEvalCommand(args, cwd) {
 // 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;
@@ -7565,36 +9284,24 @@ function truncateContent(content) {
   return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
 // ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
 }
-function formatDefinitionLookup(results, query) {
-  if (results.length === 0) {
-    return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
-  }
-  const formatted = results.map((r, idx) => {
-    const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
-    return `${header} (score: ${r.score.toFixed(2)})
-\`\`\`
-${truncateContent(r.content)}
-\`\`\``;
-  });
-  return formatted.join("\n\n");
-}
-
-// src/mcp-server.ts
-var MAX_CONTENT_LINES2 = 30;
-function truncateContent2(content) {
-  const lines = content.split("\n");
-  if (lines.length <= MAX_CONTENT_LINES2) return content;
-  return lines.slice(0, MAX_CONTENT_LINES2).join("\n") + `
-// ... (${lines.length - MAX_CONTENT_LINES2} more lines)`;
-}
 function formatIndexStats(stats, verbose = false) {
+  if (stats.resetCorruptedIndex) {
+    return stats.warning ?? "Detected a corrupted local index and reset it during indexing. Run index_codebase again to rebuild search data.";
+  }
   const lines = [];
+  if (stats.failedChunks > 0) {
+    lines.push(`INDEXING WARNING: ${stats.failedChunks} chunks failed to embed.`);
+    if (stats.failedBatchesPath) {
+      lines.push(`Inspect failed batches at: ${stats.failedBatchesPath}`);
+    }
+    lines.push("");
+  }
   if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
-    lines.push(`Indexed. ${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
+    lines.push(`${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
   } else if (stats.indexedChunks === 0) {
-    lines.push(`Indexed. ${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
+    lines.push(`${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
   } else {
-    let main2 = `Indexed. ${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
+    let main2 = `${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
     if (stats.existingChunks > 0) {
       main2 += ` ${stats.existingChunks} unchanged chunks skipped.`;
     }
@@ -7633,21 +9340,103 @@ function formatIndexStats(stats, verbose = false) {
 }
 function formatStatus(status) {
   if (!status.indexed) {
+    if (status.warning) {
+      return status.warning;
+    }
+    if (status.failedBatchesCount > 0) {
+      const lines2 = [
+        "Codebase is not indexed. The last indexing run left failed embedding batches.",
+        "Fix the provider/model configuration, then rerun index_codebase normally to retry the saved failed batches. Use force=true only for a full rebuild or compatibility reset."
+      ];
+      if (status.failedBatchesPath) {
+        lines2.push(`Failed batches: ${status.failedBatchesPath}`);
+      }
+      return lines2.join("\n");
+    }
     return "Codebase is not indexed. Run index_codebase to create an index.";
   }
   const lines = [
-    `Index status:`,
-    `  Indexed chunks: ${status.vectorCount.toLocaleString()}`,
-    `  Provider: ${status.provider}`,
-    `  Model: ${status.model}`,
-    `  Location: ${status.indexPath}`
+    `Indexed chunks: ${status.vectorCount.toLocaleString()}`,
+    `Provider: ${status.provider}`,
+    `Model: ${status.model}`,
+    `Location: ${status.indexPath}`
   ];
   if (status.currentBranch !== "default") {
-    lines.push(`  Current branch: ${status.currentBranch}`);
-    lines.push(`  Base branch: ${status.baseBranch}`);
+    lines.push(`Current branch: ${status.currentBranch}`);
+    lines.push(`Base branch: ${status.baseBranch}`);
+  }
+  if (status.failedBatchesCount > 0) {
+    lines.push("");
+    lines.push(`INDEXING WARNING: ${status.failedBatchesCount} failed embedding batch${status.failedBatchesCount === 1 ? " remains" : "es remain"}.`);
+    if (status.failedBatchesPath) {
+      lines.push(`Failed batches: ${status.failedBatchesPath}`);
+    }
+  }
+  if (status.compatibility && !status.compatibility.compatible) {
+    lines.push("");
+    lines.push(`COMPATIBILITY WARNING: ${status.compatibility.reason}`);
+    if (status.compatibility.storedMetadata) {
+      const stored = status.compatibility.storedMetadata;
+      lines.push(`Index was built with: ${stored.embeddingProvider}/${stored.embeddingModel} (${stored.embeddingDimensions}D)`);
+      lines.push(`Current config:       ${status.provider}/${status.model}`);
+    }
+  } else if (!status.compatibility) {
+    lines.push(`Compatibility: No compatibility information found. Maybe the index is not initialized yet, try running index_codebase.`);
+  } else {
+    lines.push(`Compatibility: Index is compatible with the current provider and model.`);
+  }
+  return lines.join("\n");
+}
+function formatHealthCheck(result) {
+  if (result.resetCorruptedIndex) {
+    return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
+  }
+  if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0 && result.gcOrphanSymbols === 0 && result.gcOrphanCallEdges === 0) {
+    return "Index is healthy. No stale entries found.";
+  }
+  const lines = [];
+  if (result.removed > 0) {
+    lines.push(`Removed stale entries: ${result.removed}`);
+  }
+  if (result.gcOrphanEmbeddings > 0) {
+    lines.push(`Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
+  }
+  if (result.gcOrphanChunks > 0) {
+    lines.push(`Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
+  }
+  if (result.gcOrphanSymbols > 0) {
+    lines.push(`Garbage collected orphan symbols: ${result.gcOrphanSymbols}`);
+  }
+  if (result.gcOrphanCallEdges > 0) {
+    lines.push(`Garbage collected orphan call edges: ${result.gcOrphanCallEdges}`);
+  }
+  if (result.filePaths.length > 0) {
+    lines.push(`Cleaned paths: ${result.filePaths.join(", ")}`);
   }
   return lines.join("\n");
 }
+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}`;
+    return `${header} (score: ${r.score.toFixed(2)})
+\`\`\`
+${truncateContent(r.content)}
+\`\`\``;
+  });
+  return formatted.join("\n\n");
+}
+
+// src/mcp-server.ts
+var MAX_CONTENT_LINES2 = 30;
+function truncateContent2(content) {
+  const lines = content.split("\n");
+  if (lines.length <= MAX_CONTENT_LINES2) return content;
+  return lines.slice(0, MAX_CONTENT_LINES2).join("\n") + `
+// ... (${lines.length - MAX_CONTENT_LINES2} more lines)`;
+}
 var CHUNK_TYPE_ENUM = [
   "function",
   "class",
@@ -7666,8 +9455,25 @@ function createMcpServer(projectRoot, config) {
     name: "opencode-codebase-index",
     version: "0.5.1"
   });
-  const indexer = new Indexer(projectRoot, config);
+  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();
@@ -7750,13 +9556,22 @@ Use Read tool to examine specific files.` }] };
       verbose: z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
     },
     async (args) => {
-      await ensureInitialized();
       if (args.estimateOnly) {
+        await ensureInitialized();
         const estimate = await indexer.estimateCost();
         return { content: [{ type: "text", text: formatCostEstimate(estimate) }] };
       }
       if (args.force) {
+        if (shouldForceLocalizeProjectIndex()) {
+          materializeLocalProjectConfig(projectRoot, loadProjectConfigLayer(projectRoot));
+          refreshIndexerFromConfig();
+        }
+        await ensureInitialized();
         await indexer.clearIndex();
+        refreshIndexerFromConfig();
+        await ensureInitialized();
+      } else {
+        await ensureInitialized();
       }
       const stats = await indexer.index();
       return { content: [{ type: "text", text: formatIndexStats(stats, args.verbose ?? false) }] };
@@ -7779,29 +9594,7 @@ Use Read tool to examine specific files.` }] };
     async () => {
       await ensureInitialized();
       const result = await indexer.healthCheck();
-      if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0 && result.gcOrphanSymbols === 0 && result.gcOrphanCallEdges === 0) {
-        return { content: [{ type: "text", text: "Index is healthy. No stale entries found." }] };
-      }
-      const lines = [`Health check complete:`];
-      if (result.removed > 0) {
-        lines.push(`  Removed stale entries: ${result.removed}`);
-      }
-      if (result.gcOrphanEmbeddings > 0) {
-        lines.push(`  Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
-      }
-      if (result.gcOrphanChunks > 0) {
-        lines.push(`  Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
-      }
-      if (result.gcOrphanSymbols > 0) {
-        lines.push(`  Garbage collected orphan symbols: ${result.gcOrphanSymbols}`);
-      }
-      if (result.gcOrphanCallEdges > 0) {
-        lines.push(`  Garbage collected orphan call edges: ${result.gcOrphanCallEdges}`);
-      }
-      if (result.filePaths.length > 0) {
-        lines.push(`  Cleaned paths: ${result.filePaths.join(", ")}`);
-      }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
+      return { content: [{ type: "text", text: formatHealthCheck(result) }] };
     }
   );
   server.tool(
@@ -8030,115 +9823,15 @@ Use the implementation_lookup tool to find where this symbol is defined. This pr
   return server;
 }
 
-// src/config/merger.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
-import * as path9 from "path";
-import * as os4 from "os";
-function loadJsonFile(filePath) {
-  try {
-    if (existsSync6(filePath)) {
-      const content = readFileSync8(filePath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return null;
-}
-function loadMergedConfig(projectRoot) {
-  const globalConfigPath = path9.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
-  const globalConfig = loadJsonFile(globalConfigPath);
-  const projectConfigPath = path9.join(projectRoot, ".opencode", "codebase-index.json");
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!globalConfig && !projectConfig) {
-    return {};
-  }
-  if (!projectConfig && globalConfig) {
-    return globalConfig;
-  }
-  if (!globalConfig && projectConfig) {
-    return projectConfig;
-  }
-  const merged = { ...globalConfig };
-  if (projectConfig && "embeddingProvider" in projectConfig) {
-    merged.embeddingProvider = projectConfig.embeddingProvider;
-  } else if (globalConfig && globalConfig.embeddingProvider) {
-    merged.embeddingProvider = globalConfig.embeddingProvider;
-  }
-  if (projectConfig && "customProvider" in projectConfig) {
-    merged.customProvider = projectConfig.customProvider;
-  } else if (globalConfig && globalConfig.customProvider) {
-    merged.customProvider = globalConfig.customProvider;
-  }
-  if (projectConfig && "embeddingModel" in projectConfig) {
-    merged.embeddingModel = projectConfig.embeddingModel;
-  } else if (globalConfig && globalConfig.embeddingModel) {
-    merged.embeddingModel = globalConfig.embeddingModel;
-  }
-  if (projectConfig && "reranker" in projectConfig) {
-    merged.reranker = projectConfig.reranker;
-  } else if (globalConfig && globalConfig.reranker) {
-    merged.reranker = globalConfig.reranker;
-  }
-  if (projectConfig && "include" in projectConfig) {
-    merged.include = projectConfig.include;
-  } else if (globalConfig && globalConfig.include) {
-    merged.include = globalConfig.include;
-  }
-  if (projectConfig && "exclude" in projectConfig) {
-    merged.exclude = projectConfig.exclude;
-  } else if (globalConfig && globalConfig.exclude) {
-    merged.exclude = globalConfig.exclude;
-  }
-  if (projectConfig && "indexing" in projectConfig) {
-    merged.indexing = projectConfig.indexing;
-  } else if (globalConfig && globalConfig.indexing) {
-    merged.indexing = globalConfig.indexing;
-  }
-  if (projectConfig && "search" in projectConfig) {
-    merged.search = projectConfig.search;
-  } else if (globalConfig && globalConfig.search) {
-    merged.search = globalConfig.search;
-  }
-  if (projectConfig && "debug" in projectConfig) {
-    merged.debug = projectConfig.debug;
-  } else if (globalConfig && globalConfig.debug) {
-    merged.debug = globalConfig.debug;
-  }
-  if (projectConfig && "scope" in projectConfig) {
-    merged.scope = projectConfig.scope;
-  } else if (globalConfig && "scope" in globalConfig) {
-    merged.scope = globalConfig.scope;
-  }
-  if (projectConfig) {
-    for (const key of Object.keys(projectConfig)) {
-      if (key === "embeddingProvider" || key === "customProvider" || key === "embeddingModel" || key === "reranker" || key === "include" || key === "exclude" || key === "indexing" || key === "search" || key === "debug" || key === "scope" || key === "knowledgeBases" || key === "additionalInclude") {
-        continue;
-      }
-      merged[key] = projectConfig[key];
-    }
-  }
-  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig && Array.isArray(projectConfig.knowledgeBases) ? projectConfig.knowledgeBases : [];
-  const allKbs = [...globalKbs, ...projectKbs];
-  const uniqueKbs = [...new Set(allKbs.map((p) => String(p).trim()))];
-  merged.knowledgeBases = uniqueKbs;
-  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
-  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
-  const allAdditional = [...globalAdditional, ...projectAdditional];
-  const uniqueAdditional = [...new Set(allAdditional.map((p) => String(p).trim()))];
-  merged.additionalInclude = uniqueAdditional;
-  return merged;
-}
-
 // src/cli.ts
 function parseArgs(argv) {
   let project = process.cwd();
   let config;
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path10.resolve(argv[++i]);
+      project = path12.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path10.resolve(argv[++i]);
+      config = path12.resolve(argv[++i]);
     }
   }
   return { project, config };