opencode-codebase-index 0.7.0 → 0.8.1

package/dist/index.js

@@ -324,7 +324,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(path12, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -333,7 +333,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(path12);
           if (!matched) {
             return;
           }
@@ -354,17 +354,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path11, originalPath, doThrow) => {
-      if (!isString(path11)) {
+    var checkPath = (path12, originalPath, doThrow) => {
+      if (!isString(path12)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path11) {
+      if (!path12) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path11)) {
+      if (checkPath.isNotRelative(path12)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -373,7 +373,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
+    var isNotRelative = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -403,19 +403,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path11 = originalPath && checkPath.convert(originalPath);
+        const path12 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path11,
+          path12,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path11, cache, checkUnignored, slices);
+        return this._t(path12, cache, checkUnignored, slices);
       }
-      checkIgnore(path11) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path11)) {
-          return this.test(path11);
+      checkIgnore(path12) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path12)) {
+          return this.test(path12);
         }
-        const slices = path11.split(SLASH2).filter(Boolean);
+        const slices = path12.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -428,18 +428,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path11, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path12, false, MODE_CHECK_IGNORE);
       }
-      _t(path11, cache, checkUnignored, slices) {
-        if (path11 in cache) {
-          return cache[path11];
+      _t(path12, cache, checkUnignored, slices) {
+        if (path12 in cache) {
+          return cache[path12];
         }
         if (!slices) {
-          slices = path11.split(SLASH2).filter(Boolean);
+          slices = path12.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path11] = this._rules.test(path11, checkUnignored, MODE_IGNORE);
+          return cache[path12] = this._rules.test(path12, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -447,29 +447,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path11] = parent.ignored ? parent : this._rules.test(path11, checkUnignored, MODE_IGNORE);
+        return cache[path12] = parent.ignored ? parent : this._rules.test(path12, checkUnignored, MODE_IGNORE);
       }
-      ignores(path11) {
-        return this._test(path11, this._ignoreCache, false).ignored;
+      ignores(path12) {
+        return this._test(path12, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path11) => !this.ignores(path11);
+        return (path12) => !this.ignores(path12);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path11) {
-        return this._test(path11, this._testCache, true);
+      test(path12) {
+        return this._test(path12, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
+    var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, 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 = (path12) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -647,7 +647,7 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/index.ts
-import * as path10 from "path";
+import * as path11 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -657,12 +657,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/**",
@@ -727,7 +729,7 @@ var EMBEDDING_MODELS = {
       provider: "ollama",
       model: "nomic-embed-text",
       dimensions: 768,
-      maxTokens: 8192,
+      maxTokens: 2048,
       costPer1MTokens: 0
     },
     "mxbai-embed-large": {
@@ -751,9 +753,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_]*)\}$/;
@@ -1012,26 +1020,261 @@ 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/config/merger.ts
-import { existsSync, readFileSync } from "fs";
-import * as path from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import * as os2 from "os";
+import * as path3 from "path";
+
+// src/config/paths.ts
+import { existsSync as existsSync2 } from "fs";
 import * as os from "os";
+import * as path2 from "path";
+
+// src/git/index.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import * as path from "path";
+function readPackedRefs(gitDir) {
+  const packedRefsPath = path.join(gitDir, "packed-refs");
+  if (!existsSync(packedRefsPath)) {
+    return [];
+  }
+  try {
+    return readFileSync(packedRefsPath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("^"));
+  } catch {
+    return [];
+  }
+}
+function resolveCommonGitDir(gitDir) {
+  const commonDirPath = path.join(gitDir, "commondir");
+  if (!existsSync(commonDirPath)) {
+    return gitDir;
+  }
+  try {
+    const raw = readFileSync(commonDirPath, "utf-8").trim();
+    if (!raw) {
+      return gitDir;
+    }
+    const resolved = path.isAbsolute(raw) ? raw : path.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 || path.basename(commonGitDir) !== ".git") {
+    return null;
+  }
+  const mainRepoRoot = path.dirname(commonGitDir);
+  if (!existsSync(mainRepoRoot)) {
+    return null;
+  }
+  return path.resolve(mainRepoRoot) === path.resolve(repoRoot) ? null : mainRepoRoot;
+}
+function resolveGitDir(repoRoot) {
+  const gitPath = path.join(repoRoot, ".git");
+  if (!existsSync(gitPath)) {
+    return null;
+  }
+  try {
+    const stat4 = statSync(gitPath);
+    if (stat4.isDirectory()) {
+      return gitPath;
+    }
+    if (stat4.isFile()) {
+      const content = readFileSync(gitPath, "utf-8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1];
+        const resolvedPath = path.isAbsolute(gitdir) ? gitdir : path.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 = path.join(gitDir, "HEAD");
+  if (!existsSync(headPath)) {
+    return null;
+  }
+  try {
+    const headContent = readFileSync(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 = path.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";
+}
+function getHeadPath(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (gitDir) {
+    return path.join(gitDir, "HEAD");
+  }
+  return path.join(repoRoot, ".git", "HEAD");
+}
+
+// src/config/paths.ts
+var PROJECT_CONFIG_RELATIVE_PATH = path2.join(".opencode", "codebase-index.json");
+var PROJECT_INDEX_RELATIVE_PATH = path2.join(".opencode", "index");
+function resolveWorktreeFallbackPath(projectRoot, relativePath) {
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (!mainRepoRoot) {
+    return null;
+  }
+  const fallbackPath = path2.join(mainRepoRoot, relativePath);
+  return existsSync2(fallbackPath) ? fallbackPath : null;
+}
+function hasProjectConfig(projectRoot) {
+  return existsSync2(path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
+}
+function getGlobalIndexPath() {
+  return path2.join(os.homedir(), ".opencode", "global-index");
+}
+function resolveProjectConfigPath(projectRoot) {
+  const localConfigPath = path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+  if (existsSync2(localConfigPath)) {
+    return localConfigPath;
+  }
+  return resolveWorktreeFallbackPath(projectRoot, PROJECT_CONFIG_RELATIVE_PATH) ?? localConfigPath;
+}
+function resolveWritableProjectConfigPath(projectRoot) {
+  return path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+}
+function resolveProjectIndexPath(projectRoot, scope) {
+  if (scope === "global") {
+    return getGlobalIndexPath();
+  }
+  const localIndexPath = path2.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 (existsSync(filePath)) {
-      const content = readFileSync(filePath, "utf-8");
+    if (existsSync3(filePath)) {
+      const content = readFileSync2(filePath, "utf-8");
       return JSON.parse(content);
     }
   } catch {
   }
   return null;
 }
+function normalizeRelativeConfigPath(candidate) {
+  return candidate.replace(/\\/g, "/");
+}
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path3.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path3.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 (path3.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizeRelativeConfigPath(path3.normalize(path3.relative(sourceRoot, trimmed) || "."));
+      }
+      return path3.normalize(trimmed);
+    }
+    const resolvedFromSource = path3.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizeRelativeConfigPath(path3.normalize(trimmed));
+    }
+    return normalizeRelativeConfigPath(path3.normalize(path3.relative(targetRoot, resolvedFromSource)));
+  }).filter(Boolean);
+}
+function materializeLocalProjectConfig(projectRoot, config) {
+  const localConfigPath = path3.join(projectRoot, ".opencode", "codebase-index.json");
+  mkdirSync(path3.dirname(localConfigPath), { recursive: true });
+  writeFileSync(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 = path3.dirname(path3.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot
+    );
+  }
+  return normalizedConfig;
+}
 function loadMergedConfig(projectRoot) {
-  const globalConfigPath = path.join(os.homedir(), ".config", "opencode", "codebase-index.json");
+  const globalConfigPath = os2.homedir() + "/.config/opencode/codebase-index.json";
   const globalConfig = loadJsonFile(globalConfigPath);
-  const projectConfigPath = path.join(projectRoot, ".opencode", "codebase-index.json");
+  const projectConfigPath = resolveProjectConfigPath(projectRoot);
   const projectConfig = loadJsonFile(projectConfigPath);
+  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot);
   if (!globalConfig && !projectConfig) {
     return {};
   }
@@ -1039,56 +1282,56 @@ function loadMergedConfig(projectRoot) {
     return globalConfig;
   }
   if (!globalConfig && projectConfig) {
-    return projectConfig;
+    return normalizedProjectConfig;
   }
   const merged = { ...globalConfig };
-  if (projectConfig && "embeddingProvider" in projectConfig) {
-    merged.embeddingProvider = projectConfig.embeddingProvider;
+  if (projectConfig && "embeddingProvider" in normalizedProjectConfig) {
+    merged.embeddingProvider = normalizedProjectConfig.embeddingProvider;
   } else if (globalConfig && globalConfig.embeddingProvider) {
     merged.embeddingProvider = globalConfig.embeddingProvider;
   }
-  if (projectConfig && "customProvider" in projectConfig) {
-    merged.customProvider = projectConfig.customProvider;
+  if (projectConfig && "customProvider" in normalizedProjectConfig) {
+    merged.customProvider = normalizedProjectConfig.customProvider;
   } else if (globalConfig && globalConfig.customProvider) {
     merged.customProvider = globalConfig.customProvider;
   }
-  if (projectConfig && "embeddingModel" in projectConfig) {
-    merged.embeddingModel = projectConfig.embeddingModel;
+  if (projectConfig && "embeddingModel" in normalizedProjectConfig) {
+    merged.embeddingModel = normalizedProjectConfig.embeddingModel;
   } else if (globalConfig && globalConfig.embeddingModel) {
     merged.embeddingModel = globalConfig.embeddingModel;
   }
-  if (projectConfig && "reranker" in projectConfig) {
-    merged.reranker = projectConfig.reranker;
+  if (projectConfig && "reranker" in normalizedProjectConfig) {
+    merged.reranker = normalizedProjectConfig.reranker;
   } else if (globalConfig && globalConfig.reranker) {
     merged.reranker = globalConfig.reranker;
   }
-  if (projectConfig && "include" in projectConfig) {
-    merged.include = projectConfig.include;
+  if (projectConfig && "include" in normalizedProjectConfig) {
+    merged.include = normalizedProjectConfig.include;
   } else if (globalConfig && globalConfig.include) {
     merged.include = globalConfig.include;
   }
-  if (projectConfig && "exclude" in projectConfig) {
-    merged.exclude = projectConfig.exclude;
+  if (projectConfig && "exclude" in normalizedProjectConfig) {
+    merged.exclude = normalizedProjectConfig.exclude;
   } else if (globalConfig && globalConfig.exclude) {
     merged.exclude = globalConfig.exclude;
   }
-  if (projectConfig && "indexing" in projectConfig) {
-    merged.indexing = projectConfig.indexing;
+  if (projectConfig && "indexing" in normalizedProjectConfig) {
+    merged.indexing = normalizedProjectConfig.indexing;
   } else if (globalConfig && globalConfig.indexing) {
     merged.indexing = globalConfig.indexing;
   }
-  if (projectConfig && "search" in projectConfig) {
-    merged.search = projectConfig.search;
+  if (projectConfig && "search" in normalizedProjectConfig) {
+    merged.search = normalizedProjectConfig.search;
   } else if (globalConfig && globalConfig.search) {
     merged.search = globalConfig.search;
   }
-  if (projectConfig && "debug" in projectConfig) {
-    merged.debug = projectConfig.debug;
+  if (projectConfig && "debug" in normalizedProjectConfig) {
+    merged.debug = normalizedProjectConfig.debug;
   } else if (globalConfig && globalConfig.debug) {
     merged.debug = globalConfig.debug;
   }
-  if (projectConfig && "scope" in projectConfig) {
-    merged.scope = projectConfig.scope;
+  if (projectConfig && "scope" in normalizedProjectConfig) {
+    merged.scope = normalizedProjectConfig.scope;
   } else if (globalConfig && "scope" in globalConfig) {
     merged.scope = globalConfig.scope;
   }
@@ -1097,11 +1340,11 @@ function loadMergedConfig(projectRoot) {
       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];
+      merged[key] = normalizedProjectConfig[key];
     }
   }
   const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig && Array.isArray(projectConfig.knowledgeBases) ? projectConfig.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;
@@ -1203,7 +1446,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path11) => statMethod(path11, { bigint: true });
+      this._stat = (path12) => statMethod(path12, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1228,8 +1471,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path11, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path11));
+          const { path: path12, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path12));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -1269,21 +1512,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path11, depth) {
+  async _exploreDir(path12, depth) {
     let files;
     try {
-      files = await readdir(path11, this._rdOptions);
+      files = await readdir(path12, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path11 };
+    return { files, depth, path: path12 };
   }
-  async _formatEntry(dirent, path11) {
+  async _formatEntry(dirent, path12) {
     let entry;
-    const basename4 = this._isDirent ? dirent.name : dirent;
+    const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path11, basename4));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      const fullPath = presolve(pjoin(path12, basename5));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -1682,16 +1925,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path11, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path12, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path11);
-    emitRaw(rawEvent, evPath, { watchedPath: path11 });
-    if (evPath && path11 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path11, evPath), KEY_LISTENERS, sp.join(path11, evPath));
+    listener(path12);
+    emitRaw(rawEvent, evPath, { watchedPath: path12 });
+    if (evPath && path12 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path12, evPath), KEY_LISTENERS, sp.join(path12, evPath));
     }
   };
   try {
-    return fs_watch(path11, {
+    return fs_watch(path12, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1707,12 +1950,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path11, fullPath, options, handlers) => {
+var setFsWatchListener = (path12, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path11, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path12, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1723,7 +1966,7 @@ var setFsWatchListener = (path11, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path11,
+      path12,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1738,7 +1981,7 @@ var setFsWatchListener = (path11, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path11, "r");
+          const fd = await open(path12, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1769,7 +2012,7 @@ var setFsWatchListener = (path11, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path11, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path12, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1791,7 +2034,7 @@ var setFsWatchFileListener = (path11, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path11, curr));
+          foreach(cont.listeners, (listener2) => listener2(path12, curr));
         }
       })
     };
@@ -1821,13 +2064,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path11, listener) {
+  _watchWithNodeFs(path12, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path11);
-    const basename4 = sp.basename(path11);
+    const directory = sp.dirname(path12);
+    const basename5 = sp.basename(path12);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename4);
-    const absolutePath = sp.resolve(path11);
+    parent.add(basename5);
+    const absolutePath = sp.resolve(path12);
     const options = {
       persistent: opts.persistent
     };
@@ -1836,13 +2079,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path11, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path12, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path11, absolutePath, options, {
+      closer = setFsWatchListener(path12, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1858,13 +2101,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname5 = sp.dirname(file);
-    const basename4 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname5);
+    const dirname9 = sp.dirname(file);
+    const basename5 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname9);
     let prevStats = stats;
-    if (parent.has(basename4))
+    if (parent.has(basename5))
       return;
-    const listener = async (path11, newStats) => {
+    const listener = async (path12, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1878,18 +2121,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path11);
+            this.fsw._closeFile(path12);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path11, closer2);
+              this.fsw._addPathCloser(path12, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname5, basename4);
+          this.fsw._remove(dirname9, basename5);
         }
-      } else if (parent.has(basename4)) {
+      } else if (parent.has(basename5)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -1914,7 +2157,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path11, item) {
+  async _handleSymlink(entry, directory, path12, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1924,7 +2167,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path11);
+        linkPath = await fsrealpath(path12);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1934,12 +2177,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path11, entry.stats);
+          this.fsw._emit(EV.CHANGE, path12, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path11, entry.stats);
+        this.fsw._emit(EV.ADD, path12, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1969,9 +2212,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path11 = sp.join(directory, item);
+      let path12 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path11, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path12, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1980,11 +2223,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path11 = sp.join(dir, sp.relative(dir, path11));
-        this._addToNodeFs(path11, initialAdd, wh, depth + 1);
+        path12 = sp.join(dir, sp.relative(dir, path12));
+        this._addToNodeFs(path12, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -1993,7 +2236,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve7(void 0);
+        resolve9(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -2050,13 +2293,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path11, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path12, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path11) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path12) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path11);
+    const wh = this.fsw._getWatchHelpers(path12);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -2072,8 +2315,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path11);
-        const targetPath = follow ? await fsrealpath(path11) : path11;
+        const absPath = sp.resolve(path12);
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -2083,29 +2326,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path11) : path11;
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path11, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path12, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path11), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path12), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path11, closer);
+        this.fsw._addPathCloser(path12, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path11;
+        return path12;
       }
     }
   }
@@ -2137,35 +2380,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative6 = sp2.relative(matcher.path, string);
-        if (!relative6) {
+        const relative8 = sp2.relative(matcher.path, string);
+        if (!relative8) {
           return false;
         }
-        return !relative6.startsWith("..") && !sp2.isAbsolute(relative6);
+        return !relative8.startsWith("..") && !sp2.isAbsolute(relative8);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path11) {
-  if (typeof path11 !== "string")
+function normalizePath(path12) {
+  if (typeof path12 !== "string")
     throw new Error("string expected");
-  path11 = sp2.normalize(path11);
-  path11 = path11.replace(/\\/g, "/");
+  path12 = sp2.normalize(path12);
+  path12 = path12.replace(/\\/g, "/");
   let prepend = false;
-  if (path11.startsWith("//"))
+  if (path12.startsWith("//"))
     prepend = true;
-  path11 = path11.replace(DOUBLE_SLASH_RE, "/");
+  path12 = path12.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path11 = "/" + path11;
-  return path11;
+    path12 = "/" + path12;
+  return path12;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path11 = normalizePath(testString);
+  const path12 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path11, stats)) {
+    if (pattern(path12, stats)) {
       return true;
     }
   }
@@ -2203,19 +2446,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path11) => toUnix(sp2.normalize(toUnix(path11)));
-var normalizeIgnored = (cwd = "") => (path11) => {
-  if (typeof path11 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path11) ? path11 : sp2.join(cwd, path11));
+var normalizePathToUnix = (path12) => toUnix(sp2.normalize(toUnix(path12)));
+var normalizeIgnored = (cwd = "") => (path12) => {
+  if (typeof path12 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path12) ? path12 : sp2.join(cwd, path12));
   } else {
-    return path11;
+    return path12;
   }
 };
-var getAbsolutePath = (path11, cwd) => {
-  if (sp2.isAbsolute(path11)) {
-    return path11;
+var getAbsolutePath = (path12, cwd) => {
+  if (sp2.isAbsolute(path12)) {
+    return path12;
   }
-  return sp2.join(cwd, path11);
+  return sp2.join(cwd, path12);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -2280,10 +2523,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path11, follow, fsw) {
+  constructor(path12, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path11;
-    this.path = path11 = path11.replace(REPLACER_RE, "");
+    const watchPath = path12;
+    this.path = path12 = path12.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -2423,20 +2666,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path11) => {
-        const absPath = getAbsolutePath(path11, cwd);
+      paths = paths.map((path12) => {
+        const absPath = getAbsolutePath(path12, cwd);
         return absPath;
       });
     }
-    paths.forEach((path11) => {
-      this._removeIgnoredPath(path11);
+    paths.forEach((path12) => {
+      this._removeIgnoredPath(path12);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path11) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path11, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path12) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path12, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2458,17 +2701,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path11) => {
-      if (!sp2.isAbsolute(path11) && !this._closers.has(path11)) {
+    paths.forEach((path12) => {
+      if (!sp2.isAbsolute(path12) && !this._closers.has(path12)) {
         if (cwd)
-          path11 = sp2.join(cwd, path11);
-        path11 = sp2.resolve(path11);
+          path12 = sp2.join(cwd, path12);
+        path12 = sp2.resolve(path12);
       }
-      this._closePath(path11);
-      this._addIgnoredPath(path11);
-      if (this._watched.has(path11)) {
+      this._closePath(path12);
+      this._addIgnoredPath(path12);
+      if (this._watched.has(path12)) {
         this._addIgnoredPath({
-          path: path11,
+          path: path12,
           recursive: true
         });
       }
@@ -2532,38 +2775,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path11, stats) {
+  async _emit(event, path12, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path11 = sp2.normalize(path11);
+      path12 = sp2.normalize(path12);
     if (opts.cwd)
-      path11 = sp2.relative(opts.cwd, path11);
-    const args = [path11];
+      path12 = sp2.relative(opts.cwd, path12);
+    const args = [path12];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path11))) {
+    if (awf && (pw = this._pendingWrites.get(path12))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path11, [event, ...args]);
+        this._pendingUnlinks.set(path12, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path12) => {
+          this._pendingUnlinks.forEach((entry, path13) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path12);
+            this._pendingUnlinks.delete(path13);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path11)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path12)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path11);
+        this._pendingUnlinks.delete(path12);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2581,16 +2824,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path11, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path12, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path11, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path12, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path11) : path11;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path12) : path12;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -2621,23 +2864,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path11, timeout) {
+  _throttle(actionType, path12, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path11);
+    const actionPath = action.get(path12);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path11);
+      const item = action.get(path12);
       const count = item ? item.count : 0;
-      action.delete(path11);
+      action.delete(path12);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2645,7 +2888,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path11, thr);
+    action.set(path12, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2659,44 +2902,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path11, threshold, event, awfEmit) {
+  _awaitWriteFinish(path12, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path11;
-    if (this.options.cwd && !sp2.isAbsolute(path11)) {
-      fullPath = sp2.join(this.options.cwd, path11);
+    let fullPath = path12;
+    if (this.options.cwd && !sp2.isAbsolute(path12)) {
+      fullPath = sp2.join(this.options.cwd, path12);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path11)) {
+        if (err || !writes.has(path12)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path11).lastChange = now2;
+          writes.get(path12).lastChange = now2;
         }
-        const pw = writes.get(path11);
+        const pw = writes.get(path12);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path11);
+          writes.delete(path12);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path11)) {
-      writes.set(path11, {
+    if (!writes.has(path12)) {
+      writes.set(path12, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path11);
+          writes.delete(path12);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2707,8 +2950,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path11, stats) {
-    if (this.options.atomic && DOT_RE.test(path11))
+  _isIgnored(path12, stats) {
+    if (this.options.atomic && DOT_RE.test(path12))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2718,17 +2961,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path11, stats);
+    return this._userIgnored(path12, stats);
   }
-  _isntIgnored(path11, stat4) {
-    return !this._isIgnored(path11, stat4);
+  _isntIgnored(path12, stat4) {
+    return !this._isIgnored(path12, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path11) {
-    return new WatchHelper(path11, this.options.followSymlinks, this);
+  _getWatchHelpers(path12) {
+    return new WatchHelper(path12, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2760,63 +3003,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path11 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path11);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path11) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path11, 100))
+    const path12 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path12);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path12) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path12, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path11);
+    const wp = this._getWatchedDir(path12);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path11, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path12, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path11;
+    let relPath = path12;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path11);
+      relPath = sp2.relative(this.options.cwd, path12);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path11);
+    this._watched.delete(path12);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path11))
-      this._emit(eventName, path11);
-    this._closePath(path11);
+    if (wasTracked && !this._isIgnored(path12))
+      this._emit(eventName, path12);
+    this._closePath(path12);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path11) {
-    this._closeFile(path11);
-    const dir = sp2.dirname(path11);
-    this._getWatchedDir(dir).remove(sp2.basename(path11));
+  _closePath(path12) {
+    this._closeFile(path12);
+    const dir = sp2.dirname(path12);
+    this._getWatchedDir(dir).remove(sp2.basename(path12));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path11) {
-    const closers = this._closers.get(path11);
+  _closeFile(path12) {
+    const closers = this._closers.get(path12);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path11);
+    this._closers.delete(path12);
   }
-  _addPathCloser(path11, closer) {
+  _addPathCloser(path12, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path11);
+    let list = this._closers.get(path12);
     if (!list) {
       list = [];
-      this._closers.set(path11, list);
+      this._closers.set(path12, list);
     }
     list.push(closer);
   }
@@ -2846,12 +3089,12 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/index.ts
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync2, readFileSync as readFileSync2, promises as fsPromises } from "fs";
-import * as path2 from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, promises as fsPromises } from "fs";
+import * as path4 from "path";
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -2870,7 +3113,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if (existsSync2(path2.join(projectRoot, marker))) {
+    if (existsSync4(path4.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -2896,16 +3139,16 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path2.join(projectRoot, ".gitignore");
-  if (existsSync2(gitignorePath)) {
-    const gitignoreContent = readFileSync2(gitignorePath, "utf-8");
+  const gitignorePath = path4.join(projectRoot, ".gitignore");
+  if (existsSync4(gitignorePath)) {
+    const gitignoreContent = readFileSync3(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
 function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path2.relative(projectRoot, filePath);
-  const pathParts = relativePath.split(path2.sep);
+  const relativePath = path4.relative(projectRoot, filePath);
+  const pathParts = relativePath.split(path4.sep);
   for (const part of pathParts) {
     if (part.startsWith(".") && part !== "." && part !== "..") {
       return false;
@@ -2949,8 +3192,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    const relativePath = path2.relative(projectRoot, fullPath);
+    const fullPath = path4.join(dir, entry.name);
+    const relativePath = path4.relative(projectRoot, fullPath);
     if (entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..") {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -2999,7 +3242,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path2.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path4.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3039,8 +3282,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 = path2.normalize(
-        path2.isAbsolute(kbRoot) ? kbRoot : path2.resolve(projectRoot, kbRoot)
+      const resolved = path4.normalize(
+        path4.isAbsolute(kbRoot) ? kbRoot : path4.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3073,122 +3316,6 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   return { files, skipped };
 }
 
-// src/git/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
-import * as path3 from "path";
-function readPackedRefs(gitDir) {
-  const packedRefsPath = path3.join(gitDir, "packed-refs");
-  if (!existsSync3(packedRefsPath)) {
-    return [];
-  }
-  try {
-    return readFileSync3(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 = path3.join(gitDir, "commondir");
-  if (!existsSync3(commonDirPath)) {
-    return gitDir;
-  }
-  try {
-    const raw = readFileSync3(commonDirPath, "utf-8").trim();
-    if (!raw) {
-      return gitDir;
-    }
-    const resolved = path3.isAbsolute(raw) ? raw : path3.resolve(gitDir, raw);
-    if (existsSync3(resolved)) {
-      return resolved;
-    }
-  } catch {
-    return gitDir;
-  }
-  return gitDir;
-}
-function resolveGitDir(repoRoot) {
-  const gitPath = path3.join(repoRoot, ".git");
-  if (!existsSync3(gitPath)) {
-    return null;
-  }
-  try {
-    const stat4 = statSync(gitPath);
-    if (stat4.isDirectory()) {
-      return gitPath;
-    }
-    if (stat4.isFile()) {
-      const content = readFileSync3(gitPath, "utf-8").trim();
-      const match = content.match(/^gitdir:\s*(.+)$/);
-      if (match) {
-        const gitdir = match[1];
-        const resolvedPath = path3.isAbsolute(gitdir) ? gitdir : path3.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 = path3.join(gitDir, "HEAD");
-  if (!existsSync3(headPath)) {
-    return null;
-  }
-  try {
-    const headContent = readFileSync3(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 = path3.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";
-}
-function getHeadPath(repoRoot) {
-  const gitDir = resolveGitDir(repoRoot);
-  if (gitDir) {
-    return path3.join(gitDir, "HEAD");
-  }
-  return path3.join(repoRoot, ".git", "HEAD");
-}
-
 // src/watcher/index.ts
 var FileWatcher = class {
   watcher = null;
@@ -3210,9 +3337,9 @@ var FileWatcher = class {
     const ignoreFilter = createIgnoreFilter(this.projectRoot);
     this.watcher = chokidar_default.watch(this.projectRoot, {
       ignored: (filePath) => {
-        const relativePath = path4.relative(this.projectRoot, filePath);
+        const relativePath = path5.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
-        const pathParts = relativePath.split(path4.sep);
+        const pathParts = relativePath.split(path5.sep);
         for (const part of pathParts) {
           if (part.startsWith(".") && part !== "." && part !== "..") {
             return true;
@@ -3264,7 +3391,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path11, type]) => ({ path: path11, type })
+      ([path12, type]) => ({ path: path12, type })
     );
     this.pendingChanges.clear();
     try {
@@ -3310,7 +3437,7 @@ var GitHeadWatcher = class {
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path4.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path5.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -3395,8 +3522,8 @@ function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
 import { tool } from "@opencode-ai/plugin";
 
 // src/indexer/index.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, renameSync, unlinkSync, promises as fsPromises2 } from "fs";
-import * as path7 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2, renameSync, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
+import * as path8 from "path";
 import { performance as performance2 } from "perf_hooks";
 
 // node_modules/eventemitter3/index.mjs
@@ -3421,7 +3548,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve7, reject) => {
+  const wrappedPromise = new Promise((resolve9, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -3435,7 +3562,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve7, reject);
+    promise.then(resolve9, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -3443,7 +3570,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve7(fallback());
+          resolve9(fallback());
         } catch (error) {
           reject(error);
         }
@@ -3453,7 +3580,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve7();
+        resolve9();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -3855,7 +3982,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -3895,7 +4022,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve7(result);
+          resolve9(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -4083,13 +4210,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve7();
+        resolve9();
       };
       this.on(event, listener);
     });
@@ -4375,7 +4502,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve9, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -4383,7 +4510,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve7();
+        resolve9();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -4444,16 +4571,16 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import * as path5 from "path";
-import * as os2 from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
 function getOpenCodeAuthPath() {
-  return path5.join(os2.homedir(), ".local", "share", "opencode", "auth.json");
+  return path6.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync4(authPath)) {
+    if (existsSync5(authPath)) {
       return JSON.parse(readFileSync4(authPath, "utf-8"));
     }
   } catch {
@@ -4487,7 +4614,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 {
@@ -4498,7 +4625,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) {
@@ -4818,11 +4945,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 {
@@ -4837,30 +4965,103 @@ 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)
-        };
-      })
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  truncateToCharLimit(text, maxChars) {
+    if (text.length <= maxChars) {
+      return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 17))}
+... [truncated]`;
+  }
+  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");
+  }
+  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);
+    }
+    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)
@@ -5416,13 +5617,13 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path6 from "path";
-import * as os3 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 = os3.platform();
-  const arch2 = os3.arch();
+  const platform2 = os4.platform();
+  const arch2 = os4.arch();
   let bindingName;
   if (platform2 === "darwin" && arch2 === "arm64") {
     bindingName = "codebase-index-native.darwin-arm64.node";
@@ -5440,18 +5641,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path6.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 = path6.join(currentDir, "index.js");
+    requireTarget = path7.join(currentDir, "index.js");
   }
-  const isDevMode = currentDir.includes("/src/native");
-  const packageRoot = isDevMode ? path6.resolve(currentDir, "../..") : path6.resolve(currentDir, "..");
-  const nativePath = path6.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);
 }
@@ -5482,11 +5684,20 @@ function createMockNativeBinding() {
       constructor() {
         throw error;
       }
+      serialize() {
+        throw error;
+      }
+      deserialize() {
+        throw error;
+      }
     },
     Database: class {
       constructor() {
         throw error;
       }
+      close() {
+        throw error;
+      }
     }
   };
 }
@@ -5619,7 +5830,7 @@ var MAX_SINGLE_CHUNK_TOKENS = 2e3;
 function estimateTokens(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("/");
@@ -5666,23 +5877,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 = estimateTokens(chunk.text);
-    if (currentBatch.length > 0 && currentTokens + chunkTokens > MAX_BATCH_TOKENS) {
+    const chunkTokens = chunk.tokenCount ?? estimateTokens(chunk.text);
+    if (currentBatch.length > 0 && (currentTokens + chunkTokens > maxBatchTokens || currentBatch.length >= maxBatchItems)) {
       batches.push(currentBatch);
       currentBatch = [];
       currentTokens = 0;
@@ -5801,6 +6041,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);
   }
@@ -5827,158 +6073,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/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",
@@ -6000,7 +6351,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);
@@ -6025,12 +6380,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 : estimateTokens(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: estimateTokens(text)
+        }))
+      );
+    } else {
+      texts.push({
+        text: chunk.text,
+        tokenCount: estimateTokens(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",
@@ -6246,7 +6781,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();
@@ -6268,7 +6812,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);
@@ -6535,9 +7079,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);
@@ -6687,13 +7230,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);
@@ -6990,6 +7558,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) {
@@ -7029,21 +7612,17 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path7.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path7.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path7.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 path7.join(homeDir, ".opencode", "global-index");
-    }
-    return path7.join(this.projectRoot, ".opencode", "index");
+    return resolveProjectIndexPath(this.projectRoot, this.config.scope);
   }
   loadFileHashCache() {
     try {
-      if (existsSync5(this.fileHashCachePath)) {
+      if (existsSync6(this.fileHashCachePath)) {
         const data = readFileSync5(this.fileHashCachePath, "utf-8");
         const parsed = JSON.parse(data);
         this.fileHashCache = new Map(Object.entries(parsed));
@@ -7061,95 +7640,455 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    writeFileSync(tempPath, data);
+    mkdirSync2(path8.dirname(targetPath), { recursive: true });
+    writeFileSync2(tempPath, data);
     renameSync(tempPath, targetPath);
   }
-  checkForInterruptedIndexing() {
-    return existsSync5(this.indexingLockPath);
+  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);
   }
-  acquireIndexingLock() {
-    const lockData = {
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pid: process.pid
-    };
-    writeFileSync(this.indexingLockPath, JSON.stringify(lockData));
+  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}`;
   }
-  releaseIndexingLock() {
-    if (existsSync5(this.indexingLockPath)) {
-      unlinkSync(this.indexingLockPath);
+  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));
   }
-  async recoverFromInterruptedIndexing() {
-    this.logger.warn("Detected interrupted indexing session, recovering...");
-    if (existsSync5(this.fileHashCachePath)) {
-      unlinkSync(this.fileHashCachePath);
+  loadStoredEmbeddingStrategyVersion() {
+    if (!this.database) {
+      return null;
     }
-    await this.healthCheck();
-    this.releaseIndexingLock();
-    this.logger.info("Recovery complete, next index will re-process all files");
+    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;
   }
-  loadFailedBatches() {
-    try {
-      if (existsSync5(this.failedBatchesPath)) {
-        const data = readFileSync5(this.failedBatchesPath, "utf-8");
-        return JSON.parse(data);
+  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);
       }
-    } catch {
-      return [];
     }
-    return [];
+    return { chunkIds, symbolIds };
   }
-  saveFailedBatches(batches) {
-    if (batches.length === 0) {
-      if (existsSync5(this.failedBatchesPath)) {
-        fsPromises2.unlink(this.failedBatchesPath).catch(() => {
-        });
+  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;
       }
-      return;
+      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);
     }
-    writeFileSync(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    return Array.from(keys);
   }
-  addFailedBatch(batch, error) {
-    const existing = this.loadFailedBatches();
-    existing.push({
-      chunks: batch,
-      error,
-      attemptCount: 1,
-      lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    this.saveFailedBatches(existing);
+  isFileInCurrentScope(filePath, roots) {
+    return roots.some((root) => isPathWithinRoot(filePath, root));
   }
-  getProviderRateLimits(provider) {
-    switch (provider) {
-      case "github-copilot":
-        return { concurrency: 1, intervalMs: 4e3, minRetryMs: 5e3, maxRetryMs: 6e4 };
-      case "openai":
-        return { concurrency: 3, intervalMs: 500, minRetryMs: 1e3, maxRetryMs: 3e4 };
-      case "google":
-        return { concurrency: 5, intervalMs: 200, minRetryMs: 1e3, maxRetryMs: 3e4 };
-      case "ollama":
-        return { concurrency: 5, intervalMs: 0, minRetryMs: 500, maxRetryMs: 5e3 };
-      case "custom": {
-        const customConfig = this.config.customProvider;
-        return {
-          concurrency: customConfig?.concurrency ?? 3,
-          intervalMs: customConfig?.requestIntervalMs ?? 1e3,
-          minRetryMs: 1e3,
-          maxRetryMs: 3e4
-        };
+  clearScopedFileHashCache(roots) {
+    for (const filePath of Array.from(this.fileHashCache.keys())) {
+      if (this.isFileInCurrentScope(filePath, roots)) {
+        this.fileHashCache.delete(filePath);
       }
-      default:
-        return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
     }
+    this.saveFileHashCache();
   }
-  async rerankCandidatesWithApi(query, candidates, options) {
-    const reranker = this.config.reranker;
-    if (!reranker || !reranker.enabled || candidates.length <= 1) {
-      return candidates;
+  replaceScopedFileHashCache(currentFileHashes, roots) {
+    for (const filePath of Array.from(this.fileHashCache.keys())) {
+      if (this.isFileInCurrentScope(filePath, roots)) {
+        this.fileHashCache.delete(filePath);
+      }
     }
-    const queryTokens = Array.from(tokenizeTextForRanking(query));
-    const preferSourcePaths = classifyQueryIntentRaw(query) === "source";
-    const docIntent = classifyDocIntent(queryTokens) === "docs";
+    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 existsSync6(this.indexingLockPath);
+  }
+  acquireIndexingLock() {
+    const lockData = {
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid
+    };
+    writeFileSync2(this.indexingLockPath, JSON.stringify(lockData));
+  }
+  releaseIndexingLock() {
+    if (existsSync6(this.indexingLockPath)) {
+      unlinkSync(this.indexingLockPath);
+    }
+  }
+  async recoverFromInterruptedIndexing() {
+    this.logger.warn("Detected interrupted indexing session, recovering...");
+    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(maxChunkTokens) {
+    try {
+      return this.loadSerializedFailedBatches().map((batch) => normalizeFailedBatch(batch, maxChunkTokens)).filter((batch) => batch !== null);
+    } catch {
+      return [];
+    }
+  }
+  loadSerializedFailedBatches() {
+    if (!existsSync6(this.failedBatchesPath)) {
+      return [];
+    }
+    const data = readFileSync5(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 (existsSync6(this.failedBatchesPath)) {
+        try {
+          unlinkSync(this.failedBatchesPath);
+        } catch {
+        }
+      }
+      return;
+    }
+    writeFileSync2(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+  }
+  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) {
+      case "github-copilot":
+        return { concurrency: 1, intervalMs: 4e3, minRetryMs: 5e3, maxRetryMs: 6e4 };
+      case "openai":
+        return { concurrency: 3, intervalMs: 500, minRetryMs: 1e3, maxRetryMs: 3e4 };
+      case "google":
+        return { concurrency: 5, intervalMs: 200, minRetryMs: 1e3, maxRetryMs: 3e4 };
+      case "ollama":
+        return { concurrency: 5, intervalMs: 0, minRetryMs: 500, maxRetryMs: 5e3 };
+      case "custom": {
+        const customConfig = this.config.customProvider;
+        return {
+          concurrency: customConfig?.concurrency ?? 3,
+          intervalMs: customConfig?.requestIntervalMs ?? 1e3,
+          minRetryMs: 1e3,
+          maxRetryMs: 3e4
+        };
+      }
+      default:
+        return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
+    }
+  }
+  async rerankCandidatesWithApi(query, candidates, options) {
+    const reranker = this.config.reranker;
+    if (!reranker || !reranker.enabled || candidates.length <= 1) {
+      return candidates;
+    }
+    const queryTokens = Array.from(tokenizeTextForRanking(query));
+    const preferSourcePaths = classifyQueryIntentRaw(query) === "source";
+    const docIntent = classifyDocIntent(queryTokens) === "docs";
     if (options?.definitionIntent === true) {
       return candidates;
     }
@@ -7322,31 +8261,54 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path7.join(this.indexPath, "vectors");
+    const storePath = path8.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path7.join(this.indexPath, "vectors.usearch");
-    if (existsSync5(indexFilePath)) {
+    const indexFilePath = path8.join(this.indexPath, "vectors.usearch");
+    if (existsSync6(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path7.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 (existsSync5(invertedIndexPath)) {
+      if (existsSync6(invertedIndexPath)) {
         await fsPromises2.unlink(invertedIndexPath);
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path7.join(this.indexPath, "codebase.db");
-    const dbIsNew = !existsSync5(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", {
@@ -7355,18 +8317,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();
     }
@@ -7386,20 +8336,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;
@@ -7423,7 +8522,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;
@@ -7434,6 +8533,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") ?? ""
     };
@@ -7442,10 +8542,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);
@@ -7475,6 +8587,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,
@@ -7522,6 +8642,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.`
@@ -7543,6 +8667,7 @@ var Indexer = class {
       skippedFiles: [],
       parseFailures: []
     };
+    const failedBatchesForCurrentRun = [];
     onProgress?.({
       phase: "scanning",
       filesProcessed: 0,
@@ -7602,6 +8727,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);
@@ -7623,7 +8754,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path7.relative(this.projectRoot, parsed.path);
+        const relativePath = path8.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7659,7 +8790,10 @@ var Indexer = class {
           fileChunkCount++;
           continue;
         }
-        const text = createEmbeddingText(chunk, parsed.path);
+        const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
+          text,
+          tokenCount: estimateTokens(text)
+        }));
         const metadata = {
           filePath: parsed.path,
           startLine: chunk.startLine,
@@ -7669,10 +8803,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);
     }
@@ -7701,17 +8863,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;
@@ -7736,7 +8901,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);
           }
@@ -7749,14 +8914,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;
@@ -7768,12 +8939,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",
@@ -7786,14 +8965,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",
@@ -7814,8 +9001,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
@@ -7837,17 +9025,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((resolve7) => setTimeout(resolve7, rateLimitBackoffMs));
+          await new Promise((resolve9) => setTimeout(resolve9, 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);
             },
             {
@@ -7877,29 +9072,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?.({
@@ -7910,17 +9158,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,
@@ -7928,18 +9208,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();
@@ -8068,27 +9378,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
       });
@@ -8141,26 +9454,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,
@@ -8230,7 +9530,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(),
@@ -8239,23 +9540,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);
@@ -8271,28 +9635,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 (!existsSync5(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,
@@ -8303,8 +9700,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 };
     }
@@ -8312,49 +9713,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() {
@@ -8403,20 +9925,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
       });
@@ -8489,11 +10014,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;
   }
 };
 
@@ -8506,7 +10059,17 @@ function truncateContent(content) {
 // ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
 }
 function formatIndexStats(stats, verbose = false) {
+  if (stats.resetCorruptedIndex) {
+    return stats.warning ?? "Detected a corrupted local index and reset it during indexing. Run index_codebase again to rebuild search data.";
+  }
   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(`${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
   } else if (stats.indexedChunks === 0) {
@@ -8551,6 +10114,19 @@ 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 = [
@@ -8563,6 +10139,13 @@ function formatStatus(status) {
     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}`);
@@ -8620,6 +10203,9 @@ function formatCodebasePeek(results) {
   return formatted.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.";
   }
@@ -8679,8 +10265,8 @@ ${truncateContent(r.content)}
 }
 
 // src/tools/index.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync2, mkdirSync, statSync as statSync2 } from "fs";
-import * as path8 from "path";
+import { existsSync as existsSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, statSync as statSync2 } from "fs";
+import * as path9 from "path";
 var z = tool.schema;
 var sharedIndexer = null;
 var sharedProjectRoot = "";
@@ -8695,7 +10281,20 @@ function refreshIndexerFromConfig() {
   if (!sharedProjectRoot) {
     throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
   }
-  sharedIndexer = new Indexer(sharedProjectRoot, parseConfig(loadConfig()));
+  sharedIndexer = new Indexer(sharedProjectRoot, parseConfig(loadRuntimeConfig()));
+}
+function shouldForceLocalizeProjectIndex() {
+  const currentConfig = parseConfig(loadRuntimeConfig());
+  if (currentConfig.scope !== "project") {
+    return false;
+  }
+  const localIndexPath = path9.join(sharedProjectRoot, ".opencode", "index");
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(sharedProjectRoot);
+  if (!mainRepoRoot) {
+    return false;
+  }
+  const inheritedIndexPath = path9.join(mainRepoRoot, ".opencode", "index");
+  return !existsSync7(localIndexPath) && existsSync7(inheritedIndexPath);
 }
 function getIndexer() {
   if (!sharedIndexer) {
@@ -8704,9 +10303,41 @@ function getIndexer() {
   return sharedIndexer;
 }
 function getConfigPath() {
-  return path8.join(sharedProjectRoot, ".opencode", "codebase-index.json");
+  return resolveWritableProjectConfigPath(sharedProjectRoot);
 }
-function loadConfig() {
+function normalizeConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const absolutePath = path9.isAbsolute(trimmed) ? trimmed : path9.resolve(baseDir, trimmed);
+  return path9.normalize(absolutePath);
+}
+function serializeConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const normalizeRelativePath = (candidate) => candidate.replace(/\\/g, "/");
+  if (!path9.isAbsolute(trimmed)) {
+    return normalizeRelativePath(path9.normalize(trimmed));
+  }
+  const relativePath = path9.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path9.isAbsolute(relativePath)) {
+    return normalizeRelativePath(path9.normalize(relativePath || "."));
+  }
+  return path9.normalize(trimmed);
+}
+function normalizeKnowledgeBasePaths(config) {
+  const normalized = { ...config };
+  if (Array.isArray(normalized.knowledgeBases)) {
+    normalized.knowledgeBases = normalized.knowledgeBases.map((kb) => {
+      return normalizeConfigPathValue(kb, sharedProjectRoot);
+    });
+  }
+  return normalized;
+}
+function loadRuntimeConfig() {
   const rawConfig = loadMergedConfig(sharedProjectRoot);
   const config = {};
   if (rawConfig && typeof rawConfig === "object") {
@@ -8714,27 +10345,32 @@ function loadConfig() {
       config[key] = rawConfig[key];
     }
   }
-  if (Array.isArray(config.knowledgeBases)) {
-    config.knowledgeBases = config.knowledgeBases.map((kb) => {
-      const resolved = path8.isAbsolute(kb) ? kb : path8.resolve(sharedProjectRoot, kb);
-      return path8.normalize(resolved);
-    });
-  }
-  if (Array.isArray(config.additionalInclude)) {
-    config.additionalInclude = config.additionalInclude.map((pattern) => {
-      const resolved = path8.isAbsolute(pattern) ? pattern : path8.resolve(sharedProjectRoot, pattern);
-      return path8.normalize(resolved);
-    });
+  return normalizeKnowledgeBasePaths(config);
+}
+function loadEditableConfig() {
+  const rawConfig = loadProjectConfigLayer(sharedProjectRoot);
+  const config = {};
+  if (rawConfig && typeof rawConfig === "object") {
+    for (const key of Object.keys(rawConfig)) {
+      config[key] = rawConfig[key];
+    }
   }
-  return config;
+  return normalizeKnowledgeBasePaths(config);
 }
 function saveConfig(config) {
-  const configDir = path8.join(sharedProjectRoot, ".opencode");
-  if (!existsSync6(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
   const configPath = getConfigPath();
-  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configDir = path9.dirname(configPath);
+  const configBaseDir = path9.dirname(configDir);
+  if (!existsSync7(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
+  }
+  const serializableConfig = { ...config };
+  if (Array.isArray(serializableConfig.knowledgeBases)) {
+    serializableConfig.knowledgeBases = serializableConfig.knowledgeBases.map(
+      (kb) => serializeConfigPathValue(kb, configBaseDir)
+    );
+  }
+  writeFileSync3(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
 var codebase_peek = tool({
   description: "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Use this first to find WHERE code is, then use Read tool to examine specific files. Saves tokens by not returning full code blocks. Best for: discovery, navigation, finding multiple related locations.",
@@ -8764,12 +10400,17 @@ var index_codebase = tool({
     verbose: z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
   },
   async execute(args, context) {
-    const indexer = getIndexer();
+    let indexer = getIndexer();
     if (args.estimateOnly) {
       const estimate = await indexer.estimateCost();
       return formatCostEstimate(estimate);
     }
     if (args.force) {
+      if (shouldForceLocalizeProjectIndex()) {
+        materializeLocalProjectConfig(sharedProjectRoot, loadProjectConfigLayer(sharedProjectRoot));
+        refreshIndexerFromConfig();
+        indexer = getIndexer();
+      }
       await indexer.clearIndex();
     }
     const stats = await indexer.index((progress) => {
@@ -8950,8 +10591,8 @@ var add_knowledge_base = tool({
   },
   async execute(args) {
     const inputPath = args.path.trim();
-    const resolvedPath = path8.isAbsolute(inputPath) ? inputPath : path8.resolve(sharedProjectRoot, inputPath);
-    if (!existsSync6(resolvedPath)) {
+    const resolvedPath = path9.isAbsolute(inputPath) ? inputPath : path9.resolve(sharedProjectRoot, inputPath);
+    if (!existsSync7(resolvedPath)) {
       return `Error: Directory does not exist: ${resolvedPath}`;
     }
     try {
@@ -8962,11 +10603,11 @@ var add_knowledge_base = tool({
     } catch (error) {
       return `Error: Cannot access directory: ${resolvedPath} - ${error instanceof Error ? error.message : String(error)}`;
     }
-    const config = loadConfig();
+    const config = loadEditableConfig();
     const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
-    const normalizedPath = path8.normalize(resolvedPath);
+    const normalizedPath = path9.normalize(resolvedPath);
     const alreadyExists = knowledgeBases.some(
-      (kb) => path8.normalize(path8.isAbsolute(kb) ? kb : path8.resolve(sharedProjectRoot, kb)) === normalizedPath
+      (kb) => path9.normalize(path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb)) === normalizedPath
     );
     if (alreadyExists) {
       return `Knowledge base already configured: ${resolvedPath}`;
@@ -8990,7 +10631,7 @@ var list_knowledge_bases = tool({
   description: "List all configured knowledge base folders that are indexed alongside the main project.",
   args: {},
   async execute() {
-    const config = loadConfig();
+    const config = loadRuntimeConfig();
     const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
     if (knowledgeBases.length === 0) {
       return "No knowledge bases configured. Use add_knowledge_base to add folders.";
@@ -9000,8 +10641,8 @@ var list_knowledge_bases = tool({
 `;
     for (let i = 0; i < knowledgeBases.length; i++) {
       const kb = knowledgeBases[i];
-      const resolvedPath = path8.isAbsolute(kb) ? kb : path8.resolve(sharedProjectRoot, kb);
-      const exists = existsSync6(resolvedPath);
+      const resolvedPath = path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb);
+      const exists = existsSync7(resolvedPath);
       result += `[${i + 1}] ${kb}
 `;
       result += `    Resolved: ${resolvedPath}
@@ -9029,14 +10670,14 @@ var remove_knowledge_base = tool({
   },
   async execute(args) {
     const inputPath = args.path.trim();
-    const config = loadConfig();
+    const config = loadEditableConfig();
     const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
     if (knowledgeBases.length === 0) {
       return "No knowledge bases configured.";
     }
-    const normalizedInput = path8.normalize(inputPath);
+    const normalizedInput = path9.normalize(inputPath);
     const index = knowledgeBases.findIndex(
-      (kb) => path8.normalize(kb) === normalizedInput || path8.normalize(path8.isAbsolute(kb) ? kb : path8.resolve(sharedProjectRoot, kb)) === normalizedInput
+      (kb) => path9.normalize(kb) === normalizedInput || path9.normalize(path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb)) === normalizedInput
     );
     if (index === -1) {
       let result2 = `Knowledge base not found: ${inputPath}
@@ -9068,8 +10709,8 @@ Run /index to rebuild the index without the removed knowledge base.`;
 });
 
 // src/commands/loader.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import * as path9 from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import * as path10 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -9090,15 +10731,15 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!existsSync7(commandsDir)) {
+  if (!existsSync8(commandsDir)) {
     return commands;
   }
   const files = readdirSync2(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path9.join(commandsDir, file);
+    const filePath = path10.join(commandsDir, file);
     const content = readFileSync6(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path9.basename(file, ".md");
+    const name = path10.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -9385,9 +11026,9 @@ function replaceActiveWatcher(nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path10.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path11.dirname(fileURLToPath2(import.meta.url));
   }
-  return path10.join(currentDir, "..", "commands");
+  return path11.join(currentDir, "..", "commands");
 }
 var plugin = async ({ directory }) => {
   try {