opencode-codebase-index 0.8.1 → 0.10.0

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(path12, checkUnignored, mode) {
+      test(path18, 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(path12);
+          const matched = rule[mode].test(path18);
           if (!matched) {
             return;
           }
@@ -354,17 +354,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path12, originalPath, doThrow) => {
-      if (!isString(path12)) {
+    var checkPath = (path18, originalPath, doThrow) => {
+      if (!isString(path18)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path12) {
+      if (!path18) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path12)) {
+      if (checkPath.isNotRelative(path18)) {
         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 = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
+    var isNotRelative = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
     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 path12 = originalPath && checkPath.convert(originalPath);
+        const path18 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path12,
+          path18,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path12, cache, checkUnignored, slices);
+        return this._t(path18, cache, checkUnignored, slices);
       }
-      checkIgnore(path12) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path12)) {
-          return this.test(path12);
+      checkIgnore(path18) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path18)) {
+          return this.test(path18);
         }
-        const slices = path12.split(SLASH2).filter(Boolean);
+        const slices = path18.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(path12, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path18, false, MODE_CHECK_IGNORE);
       }
-      _t(path12, cache, checkUnignored, slices) {
-        if (path12 in cache) {
-          return cache[path12];
+      _t(path18, cache, checkUnignored, slices) {
+        if (path18 in cache) {
+          return cache[path18];
         }
         if (!slices) {
-          slices = path12.split(SLASH2).filter(Boolean);
+          slices = path18.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path12] = this._rules.test(path12, checkUnignored, MODE_IGNORE);
+          return cache[path18] = this._rules.test(path18, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -447,29 +447,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path12] = parent.ignored ? parent : this._rules.test(path12, checkUnignored, MODE_IGNORE);
+        return cache[path18] = parent.ignored ? parent : this._rules.test(path18, checkUnignored, MODE_IGNORE);
       }
-      ignores(path12) {
-        return this._test(path12, this._ignoreCache, false).ignored;
+      ignores(path18) {
+        return this._test(path18, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path12) => !this.ignores(path12);
+        return (path18) => !this.ignores(path18);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path12) {
-        return this._test(path12, this._testCache, true);
+      test(path18) {
+        return this._test(path18, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, RETURN_FALSE);
+    var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path12) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
+      checkPath.isNotRelative = (path18) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -647,7 +647,8 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/index.ts
-import * as path11 from "path";
+import * as os6 from "os";
+import * as path17 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -664,7 +665,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{md,mdx}",
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
-  "**/*.zig"
+  "**/*.zig",
+  "**/*.gd"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -763,28 +765,7 @@ var AUTO_DETECT_PROVIDER_ORDER = [
   "google"
 ];
 
-// src/config/env-substitution.ts
-var ENV_REFERENCE_PATTERN = /^\{env:([A-Z_][A-Z0-9_]*)\}$/;
-var ENV_REFERENCE_LIKE_PATTERN = /\{env:[^}]+\}/;
-function substituteEnvString(value, keyPath) {
-  const match = value.match(ENV_REFERENCE_PATTERN);
-  if (!match) {
-    if (ENV_REFERENCE_LIKE_PATTERN.test(value)) {
-      throw new Error(
-        `Invalid environment variable reference at '${keyPath}'. Expected the entire string to match '{env:VAR_NAME}' with VAR_NAME matching [A-Z_][A-Z0-9_]*.`
-      );
-    }
-    return value;
-  }
-  const variableName = match[1];
-  const envValue = process.env[variableName];
-  if (envValue === void 0) {
-    throw new Error(`Missing environment variable '${variableName}' referenced by config at '${keyPath}'.`);
-  }
-  return envValue;
-}
-
-// src/config/schema.ts
+// src/config/defaults.ts
 function getDefaultIndexingConfig() {
   return {
     autoIndex: false,
@@ -813,15 +794,10 @@ function getDefaultSearchConfig() {
     rrfK: 60,
     rerankTopN: 20,
     contextLines: 0,
-    routingHints: true
+    routingHints: true,
+    routingHintRole: "system"
   };
 }
-function isValidFusionStrategy(value) {
-  return value === "weighted" || value === "rrf";
-}
-function isValidRerankerProvider(value) {
-  return value === "cohere" || value === "jina" || value === "custom";
-}
 function getDefaultRerankerBaseUrl(provider) {
   switch (provider) {
     case "cohere":
@@ -844,8 +820,37 @@ function getDefaultDebugConfig() {
     metrics: true
   };
 }
+
+// src/config/env-substitution.ts
+var ENV_REFERENCE_PATTERN = /^\{env:([A-Z_][A-Z0-9_]*)\}$/;
+var ENV_REFERENCE_LIKE_PATTERN = /\{env:[^}]+\}/;
+function substituteEnvString(value, keyPath) {
+  const match = value.match(ENV_REFERENCE_PATTERN);
+  if (!match) {
+    if (ENV_REFERENCE_LIKE_PATTERN.test(value)) {
+      throw new Error(
+        `Invalid environment variable reference at '${keyPath}'. Expected the entire string to match '{env:VAR_NAME}' with VAR_NAME matching [A-Z_][A-Z0-9_]*.`
+      );
+    }
+    return value;
+  }
+  const variableName = match[1];
+  const envValue = process.env[variableName];
+  if (envValue === void 0) {
+    throw new Error(`Missing environment variable '${variableName}' referenced by config at '${keyPath}'.`);
+  }
+  return envValue;
+}
+
+// src/config/validators.ts
 var VALID_SCOPES = ["project", "global"];
 var VALID_LOG_LEVELS = ["error", "warn", "info", "debug"];
+function isValidFusionStrategy(value) {
+  return value === "weighted" || value === "rrf";
+}
+function isValidRerankerProvider(value) {
+  return value === "cohere" || value === "jina" || value === "custom";
+}
 function isValidProvider(value) {
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS).includes(value);
 }
@@ -873,6 +878,8 @@ function getResolvedStringArray(value, keyPath) {
 function isValidLogLevel(value) {
   return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
 }
+
+// src/config/schema.ts
 function parseConfig(raw) {
   const input = raw && typeof raw === "object" ? raw : {};
   const embeddingProviderValue = getResolvedString(input.embeddingProvider, "$root.embeddingProvider");
@@ -909,7 +916,8 @@ function parseConfig(raw) {
     rrfK: typeof rawSearch.rrfK === "number" ? Math.max(1, Math.floor(rawSearch.rrfK)) : defaultSearch.rrfK,
     rerankTopN: typeof rawSearch.rerankTopN === "number" ? Math.min(200, Math.max(0, Math.floor(rawSearch.rerankTopN))) : defaultSearch.rerankTopN,
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines,
-    routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints
+    routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints,
+    routingHintRole: rawSearch.routingHintRole === "developer" || rawSearch.routingHintRole === "system" ? rawSearch.routingHintRole : defaultSearch.routingHintRole
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
   const debug = {
@@ -927,9 +935,9 @@ function parseConfig(raw) {
   const rawAdditionalInclude = input.additionalInclude;
   const additionalInclude = isStringArray(rawAdditionalInclude) ? rawAdditionalInclude.filter((p) => typeof p === "string" && p.trim().length > 0).map((p) => p.trim()) : [];
   let embeddingProvider;
-  let embeddingModel = void 0;
-  let customProvider = void 0;
-  let reranker = void 0;
+  let embeddingModel;
+  let customProvider;
+  let reranker;
   if (embeddingProviderValue === "custom") {
     embeddingProvider = "custom";
     const rawCustom = input.customProvider && typeof input.customProvider === "object" ? input.customProvider : null;
@@ -962,7 +970,7 @@ function parseConfig(raw) {
     embeddingProvider = embeddingProviderValue;
     const rawEmbeddingModel = input.embeddingModel;
     if (typeof rawEmbeddingModel === "string") {
-      const embeddingModelValue = substituteEnvString(rawEmbeddingModel, "$root.embeddingModel");
+      const embeddingModelValue = getResolvedString(rawEmbeddingModel, "$root.embeddingModel");
       if (embeddingModelValue) {
         embeddingModel = isValidModel(embeddingModelValue, embeddingProvider) ? embeddingModelValue : DEFAULT_PROVIDER_MODELS[embeddingProvider];
       }
@@ -1025,16 +1033,20 @@ var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
 );
 
 // src/config/merger.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path6 from "path";
 
 // src/config/paths.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import * as os from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/git/index.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import * as path2 from "path";
+
+// src/git/refs.ts
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import * as path from "path";
 function readPackedRefs(gitDir) {
@@ -1067,38 +1079,40 @@ function resolveCommonGitDir(gitDir) {
   }
   return gitDir;
 }
+
+// src/git/index.ts
 function resolveWorktreeMainRepoRoot(repoRoot) {
   const gitDir = resolveGitDir(repoRoot);
   if (!gitDir) {
     return null;
   }
   const commonGitDir = resolveCommonGitDir(gitDir);
-  if (commonGitDir === gitDir || path.basename(commonGitDir) !== ".git") {
+  if (commonGitDir === gitDir || path2.basename(commonGitDir) !== ".git") {
     return null;
   }
-  const mainRepoRoot = path.dirname(commonGitDir);
-  if (!existsSync(mainRepoRoot)) {
+  const mainRepoRoot = path2.dirname(commonGitDir);
+  if (!existsSync2(mainRepoRoot)) {
     return null;
   }
-  return path.resolve(mainRepoRoot) === path.resolve(repoRoot) ? null : mainRepoRoot;
+  return path2.resolve(mainRepoRoot) === path2.resolve(repoRoot) ? null : mainRepoRoot;
 }
 function resolveGitDir(repoRoot) {
-  const gitPath = path.join(repoRoot, ".git");
-  if (!existsSync(gitPath)) {
+  const gitPath = path2.join(repoRoot, ".git");
+  if (!existsSync2(gitPath)) {
     return null;
   }
   try {
-    const stat4 = statSync(gitPath);
+    const stat4 = statSync2(gitPath);
     if (stat4.isDirectory()) {
       return gitPath;
     }
     if (stat4.isFile()) {
-      const content = readFileSync(gitPath, "utf-8").trim();
+      const content = readFileSync2(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)) {
+        const resolvedPath = path2.isAbsolute(gitdir) ? gitdir : path2.resolve(repoRoot, gitdir);
+        if (existsSync2(resolvedPath)) {
           return resolvedPath;
         }
       }
@@ -1115,12 +1129,12 @@ function getCurrentBranch(repoRoot) {
   if (!gitDir) {
     return null;
   }
-  const headPath = path.join(gitDir, "HEAD");
-  if (!existsSync(headPath)) {
+  const headPath = path2.join(gitDir, "HEAD");
+  if (!existsSync2(headPath)) {
     return null;
   }
   try {
-    const headContent = readFileSync(headPath, "utf-8").trim();
+    const headContent = readFileSync2(headPath, "utf-8").trim();
     const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
     if (match) {
       return match[1];
@@ -1139,8 +1153,8 @@ function getBaseBranch(repoRoot) {
   const candidates = ["main", "master", "develop", "trunk"];
   if (refStoreDir) {
     for (const candidate of candidates) {
-      const refPath = path.join(refStoreDir, "refs", "heads", candidate);
-      if (existsSync(refPath)) {
+      const refPath = path2.join(refStoreDir, "refs", "heads", candidate);
+      if (existsSync2(refPath)) {
         return candidate;
       }
       const packedRefs = readPackedRefs(refStoreDir);
@@ -1160,44 +1174,44 @@ function getBranchOrDefault(repoRoot) {
 function getHeadPath(repoRoot) {
   const gitDir = resolveGitDir(repoRoot);
   if (gitDir) {
-    return path.join(gitDir, "HEAD");
+    return path2.join(gitDir, "HEAD");
   }
-  return path.join(repoRoot, ".git", "HEAD");
+  return path2.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");
+var PROJECT_CONFIG_RELATIVE_PATH = path3.join(".opencode", "codebase-index.json");
+var PROJECT_INDEX_RELATIVE_PATH = path3.join(".opencode", "index");
 function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
   if (!mainRepoRoot) {
     return null;
   }
-  const fallbackPath = path2.join(mainRepoRoot, relativePath);
-  return existsSync2(fallbackPath) ? fallbackPath : null;
+  const fallbackPath = path3.join(mainRepoRoot, relativePath);
+  return existsSync3(fallbackPath) ? fallbackPath : null;
 }
 function hasProjectConfig(projectRoot) {
-  return existsSync2(path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
+  return existsSync3(path3.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
 }
 function getGlobalIndexPath() {
-  return path2.join(os.homedir(), ".opencode", "global-index");
+  return path3.join(os.homedir(), ".opencode", "global-index");
 }
 function resolveProjectConfigPath(projectRoot) {
-  const localConfigPath = path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
-  if (existsSync2(localConfigPath)) {
+  const localConfigPath = path3.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+  if (existsSync3(localConfigPath)) {
     return localConfigPath;
   }
   return resolveWorktreeFallbackPath(projectRoot, PROJECT_CONFIG_RELATIVE_PATH) ?? localConfigPath;
 }
 function resolveWritableProjectConfigPath(projectRoot) {
-  return path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+  return path3.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)) {
+  const localIndexPath = path3.join(projectRoot, PROJECT_INDEX_RELATIVE_PATH);
+  if (existsSync3(localIndexPath)) {
     return localIndexPath;
   }
   if (hasProjectConfig(projectRoot)) {
@@ -1206,23 +1220,56 @@ function resolveProjectIndexPath(projectRoot, scope) {
   return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
 }
 
-// src/config/merger.ts
-function loadJsonFile(filePath) {
-  try {
-    if (existsSync3(filePath)) {
-      const content = readFileSync2(filePath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return null;
+// src/config/rebase.ts
+import * as path5 from "path";
+
+// src/utils/paths.ts
+import * as path4 from "path";
+function normalizePathSeparators(value) {
+  return value.replace(/\\/g, "/");
 }
-function normalizeRelativeConfigPath(candidate) {
-  return candidate.replace(/\\/g, "/");
+function isHiddenPathSegment(part) {
+  return part.startsWith(".") && part !== "." && part !== "..";
 }
+function isBuildPathSegment(part) {
+  return part.toLowerCase().includes("build");
+}
+function hasFilteredPathSegment(relativePath, separator = path4.sep) {
+  return relativePath.split(separator).some(
+    (part) => isHiddenPathSegment(part) || isBuildPathSegment(part)
+  );
+}
+var RESTRICTED_DIRECTORIES = /* @__PURE__ */ new Set([
+  // macOS
+  "library",
+  "applications",
+  "system",
+  "volumes",
+  "private",
+  "cores",
+  // Linux
+  "proc",
+  "sys",
+  "dev",
+  "run",
+  "snap",
+  // Windows
+  "windows",
+  "programdata",
+  "program files",
+  "program files (x86)",
+  "$recycle.bin"
+]);
+function isRestrictedDirectory(relativePath, separator = path4.sep) {
+  const firstSegment = relativePath.split(separator)[0];
+  if (!firstSegment) return false;
+  return RESTRICTED_DIRECTORIES.has(firstSegment.toLowerCase());
+}
+
+// src/config/rebase.ts
 function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path3.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path3.isAbsolute(relativePath);
+  const relativePath = path5.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
 }
 function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
   if (!Array.isArray(values)) {
@@ -1233,22 +1280,106 @@ function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
     if (!trimmed) {
       return trimmed;
     }
-    if (path3.isAbsolute(trimmed)) {
+    if (path5.isAbsolute(trimmed)) {
       if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizeRelativeConfigPath(path3.normalize(path3.relative(sourceRoot, trimmed) || "."));
+        return normalizePathSeparators(path5.normalize(path5.relative(sourceRoot, trimmed) || "."));
       }
-      return path3.normalize(trimmed);
+      return path5.normalize(trimmed);
     }
-    const resolvedFromSource = path3.resolve(sourceRoot, trimmed);
+    const resolvedFromSource = path5.resolve(sourceRoot, trimmed);
     if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizeRelativeConfigPath(path3.normalize(trimmed));
+      return normalizePathSeparators(path5.normalize(trimmed));
     }
-    return normalizeRelativeConfigPath(path3.normalize(path3.relative(targetRoot, resolvedFromSource)));
+    return normalizePathSeparators(path5.normalize(path5.relative(targetRoot, resolvedFromSource)));
   }).filter(Boolean);
 }
+
+// src/config/merger.ts
+var PROJECT_OVERRIDE_KEYS = [
+  "embeddingProvider",
+  "customProvider",
+  "embeddingModel",
+  "reranker",
+  "include",
+  "exclude",
+  "indexing",
+  "search",
+  "debug",
+  "scope"
+];
+var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
+  if (key in normalizedProjectConfig) {
+    merged[key] = normalizedProjectConfig[key];
+    return;
+  }
+  if (key in globalConfig) {
+    merged[key] = globalConfig[key];
+  }
+}
+function mergeUniqueStringArray(values) {
+  return [...new Set(values.map((value) => String(value).trim()))];
+}
+function normalizeKnowledgeBasePath(value) {
+  let normalized = path6.normalize(String(value).trim());
+  const root = path6.parse(normalized).root;
+  while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function mergeKnowledgeBasePaths(values) {
+  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
+}
+function validateConfigLayerShape(rawConfig, filePath) {
+  if (!isRecord(rawConfig)) {
+    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+  }
+  if (rawConfig.knowledgeBases !== void 0 && !isStringArray2(rawConfig.knowledgeBases)) {
+    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (rawConfig.additionalInclude !== void 0 && !isStringArray2(rawConfig.additionalInclude)) {
+    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (rawConfig.include !== void 0 && !isStringArray2(rawConfig.include)) {
+    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (rawConfig.exclude !== void 0 && !isStringArray2(rawConfig.exclude)) {
+    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
+  }
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = rawConfig[section];
+    if (value !== void 0 && !isRecord(value)) {
+      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
+    }
+  }
+  return rawConfig;
+}
+function loadJsonFile(filePath) {
+  if (!existsSync4(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    return validateConfigLayerShape(JSON.parse(content), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Config file ")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config file ${filePath}: ${message}`);
+  }
+  return null;
+}
 function materializeLocalProjectConfig(projectRoot, config) {
-  const localConfigPath = path3.join(projectRoot, ".opencode", "codebase-index.json");
-  mkdirSync(path3.dirname(localConfigPath), { recursive: true });
+  const localConfigPath = path6.join(projectRoot, ".opencode", "codebase-index.json");
+  mkdirSync(path6.dirname(localConfigPath), { recursive: true });
   writeFileSync(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
   return localConfigPath;
 }
@@ -1259,7 +1390,7 @@ function loadProjectConfigLayer(projectRoot) {
     return {};
   }
   const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path3.dirname(path3.dirname(projectConfigPath));
+  const projectConfigBaseDir = path6.dirname(path6.dirname(projectConfigPath));
   if (Array.isArray(normalizedConfig.knowledgeBases)) {
     normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
       normalizedConfig.knowledgeBases,
@@ -1271,10 +1402,22 @@ function loadProjectConfigLayer(projectRoot) {
 }
 function loadMergedConfig(projectRoot) {
   const globalConfigPath = os2.homedir() + "/.config/opencode/codebase-index.json";
-  const globalConfig = loadJsonFile(globalConfigPath);
   const projectConfigPath = resolveProjectConfigPath(projectRoot);
+  let globalConfig = null;
+  let globalConfigError = null;
+  try {
+    globalConfig = loadJsonFile(globalConfigPath);
+  } catch (error) {
+    globalConfigError = error instanceof Error ? error : new Error(String(error));
+  }
   const projectConfig = loadJsonFile(projectConfigPath);
   const normalizedProjectConfig = loadProjectConfigLayer(projectRoot);
+  if (globalConfigError) {
+    if (!projectConfig) {
+      throw globalConfigError;
+    }
+    globalConfig = null;
+  }
   if (!globalConfig && !projectConfig) {
     return {};
   }
@@ -1284,60 +1427,16 @@ function loadMergedConfig(projectRoot) {
   if (!globalConfig && projectConfig) {
     return normalizedProjectConfig;
   }
+  if (!globalConfig || !projectConfig) {
+    return globalConfig ?? normalizedProjectConfig;
+  }
   const merged = { ...globalConfig };
-  if (projectConfig && "embeddingProvider" in normalizedProjectConfig) {
-    merged.embeddingProvider = normalizedProjectConfig.embeddingProvider;
-  } else if (globalConfig && globalConfig.embeddingProvider) {
-    merged.embeddingProvider = globalConfig.embeddingProvider;
-  }
-  if (projectConfig && "customProvider" in normalizedProjectConfig) {
-    merged.customProvider = normalizedProjectConfig.customProvider;
-  } else if (globalConfig && globalConfig.customProvider) {
-    merged.customProvider = globalConfig.customProvider;
-  }
-  if (projectConfig && "embeddingModel" in normalizedProjectConfig) {
-    merged.embeddingModel = normalizedProjectConfig.embeddingModel;
-  } else if (globalConfig && globalConfig.embeddingModel) {
-    merged.embeddingModel = globalConfig.embeddingModel;
-  }
-  if (projectConfig && "reranker" in normalizedProjectConfig) {
-    merged.reranker = normalizedProjectConfig.reranker;
-  } else if (globalConfig && globalConfig.reranker) {
-    merged.reranker = globalConfig.reranker;
-  }
-  if (projectConfig && "include" in normalizedProjectConfig) {
-    merged.include = normalizedProjectConfig.include;
-  } else if (globalConfig && globalConfig.include) {
-    merged.include = globalConfig.include;
-  }
-  if (projectConfig && "exclude" in normalizedProjectConfig) {
-    merged.exclude = normalizedProjectConfig.exclude;
-  } else if (globalConfig && globalConfig.exclude) {
-    merged.exclude = globalConfig.exclude;
-  }
-  if (projectConfig && "indexing" in normalizedProjectConfig) {
-    merged.indexing = normalizedProjectConfig.indexing;
-  } else if (globalConfig && globalConfig.indexing) {
-    merged.indexing = globalConfig.indexing;
-  }
-  if (projectConfig && "search" in normalizedProjectConfig) {
-    merged.search = normalizedProjectConfig.search;
-  } else if (globalConfig && globalConfig.search) {
-    merged.search = globalConfig.search;
-  }
-  if (projectConfig && "debug" in normalizedProjectConfig) {
-    merged.debug = normalizedProjectConfig.debug;
-  } else if (globalConfig && globalConfig.debug) {
-    merged.debug = globalConfig.debug;
-  }
-  if (projectConfig && "scope" in normalizedProjectConfig) {
-    merged.scope = normalizedProjectConfig.scope;
-  } else if (globalConfig && "scope" in globalConfig) {
-    merged.scope = globalConfig.scope;
+  for (const key of PROJECT_OVERRIDE_KEYS) {
+    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
   }
   if (projectConfig) {
     for (const key of Object.keys(projectConfig)) {
-      if (key === "embeddingProvider" || key === "customProvider" || key === "embeddingModel" || key === "reranker" || key === "include" || key === "exclude" || key === "indexing" || key === "search" || key === "debug" || key === "scope" || key === "knowledgeBases" || key === "additionalInclude") {
+      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
         continue;
       }
       merged[key] = normalizedProjectConfig[key];
@@ -1346,13 +1445,11 @@ function loadMergedConfig(projectRoot) {
   const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
   const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
   const allKbs = [...globalKbs, ...projectKbs];
-  const uniqueKbs = [...new Set(allKbs.map((p) => String(p).trim()))];
-  merged.knowledgeBases = uniqueKbs;
+  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
   const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
   const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
   const allAdditional = [...globalAdditional, ...projectAdditional];
-  const uniqueAdditional = [...new Set(allAdditional.map((p) => String(p).trim()))];
-  merged.additionalInclude = uniqueAdditional;
+  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
   return merged;
 }
 
@@ -1446,7 +1543,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path12) => statMethod(path12, { bigint: true });
+      this._stat = (path18) => statMethod(path18, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1471,8 +1568,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path12, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path12));
+          const { path: path18, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -1512,20 +1609,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path12, depth) {
+  async _exploreDir(path18, depth) {
     let files;
     try {
-      files = await readdir(path12, this._rdOptions);
+      files = await readdir(path18, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path12 };
+    return { files, depth, path: path18 };
   }
-  async _formatEntry(dirent, path12) {
+  async _formatEntry(dirent, path18) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path12, basename5));
+      const fullPath = presolve(pjoin(path18, basename5));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1925,16 +2022,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path12, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path12);
-    emitRaw(rawEvent, evPath, { watchedPath: path12 });
-    if (evPath && path12 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path12, evPath), KEY_LISTENERS, sp.join(path12, evPath));
+    listener(path18);
+    emitRaw(rawEvent, evPath, { watchedPath: path18 });
+    if (evPath && path18 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
     }
   };
   try {
-    return fs_watch(path12, {
+    return fs_watch(path18, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1950,12 +2047,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path12, fullPath, options, handlers) => {
+var setFsWatchListener = (path18, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path12, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1966,7 +2063,7 @@ var setFsWatchListener = (path12, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path12,
+      path18,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1981,7 +2078,7 @@ var setFsWatchListener = (path12, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path12, "r");
+          const fd = await open(path18, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -2012,7 +2109,7 @@ var setFsWatchListener = (path12, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path12, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -2034,7 +2131,7 @@ var setFsWatchFileListener = (path12, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path12, curr));
+          foreach(cont.listeners, (listener2) => listener2(path18, curr));
         }
       })
     };
@@ -2064,13 +2161,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path12, listener) {
+  _watchWithNodeFs(path18, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path12);
-    const basename5 = sp.basename(path12);
+    const directory = sp.dirname(path18);
+    const basename5 = sp.basename(path18);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path12);
+    const absolutePath = sp.resolve(path18);
     const options = {
       persistent: opts.persistent
     };
@@ -2080,12 +2177,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path12, absolutePath, options, {
+      closer = setFsWatchFileListener(path18, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path12, absolutePath, options, {
+      closer = setFsWatchListener(path18, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -2107,7 +2204,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path12, newStats) => {
+    const listener = async (path18, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -2121,11 +2218,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path12);
+            this.fsw._closeFile(path18);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path12, closer2);
+              this.fsw._addPathCloser(path18, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -2157,7 +2254,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, path12, item) {
+  async _handleSymlink(entry, directory, path18, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -2167,7 +2264,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path12);
+        linkPath = await fsrealpath(path18);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -2177,12 +2274,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, path12, entry.stats);
+          this.fsw._emit(EV.CHANGE, path18, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path12, entry.stats);
+        this.fsw._emit(EV.ADD, path18, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -2212,9 +2309,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path12 = sp.join(directory, item);
+      let path18 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path12, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -2223,11 +2320,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path12 = sp.join(dir, sp.relative(dir, path12));
-        this._addToNodeFs(path12, initialAdd, wh, depth + 1);
+        path18 = sp.join(dir, sp.relative(dir, path18));
+        this._addToNodeFs(path18, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -2236,7 +2333,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve9(void 0);
+        resolve12(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -2293,13 +2390,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path12, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path12) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path18) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path12);
+    const wh = this.fsw._getWatchHelpers(path18);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -2315,8 +2412,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path12);
-        const targetPath = follow ? await fsrealpath(path12) : path12;
+        const absPath = sp.resolve(path18);
+        const targetPath = follow ? await fsrealpath(path18) : path18;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -2326,29 +2423,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path12) : path12;
+        const targetPath = follow ? await fsrealpath(path18) : path18;
         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, path12, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path18, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path12), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path12, closer);
+        this.fsw._addPathCloser(path18, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path12;
+        return path18;
       }
     }
   }
@@ -2391,24 +2488,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path12) {
-  if (typeof path12 !== "string")
+function normalizePath(path18) {
+  if (typeof path18 !== "string")
     throw new Error("string expected");
-  path12 = sp2.normalize(path12);
-  path12 = path12.replace(/\\/g, "/");
+  path18 = sp2.normalize(path18);
+  path18 = path18.replace(/\\/g, "/");
   let prepend = false;
-  if (path12.startsWith("//"))
+  if (path18.startsWith("//"))
     prepend = true;
-  path12 = path12.replace(DOUBLE_SLASH_RE, "/");
+  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path12 = "/" + path12;
-  return path12;
+    path18 = "/" + path18;
+  return path18;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path12 = normalizePath(testString);
+  const path18 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path12, stats)) {
+    if (pattern(path18, stats)) {
       return true;
     }
   }
@@ -2446,19 +2543,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-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));
+var normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
+var normalizeIgnored = (cwd = "") => (path18) => {
+  if (typeof path18 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
   } else {
-    return path12;
+    return path18;
   }
 };
-var getAbsolutePath = (path12, cwd) => {
-  if (sp2.isAbsolute(path12)) {
-    return path12;
+var getAbsolutePath = (path18, cwd) => {
+  if (sp2.isAbsolute(path18)) {
+    return path18;
   }
-  return sp2.join(cwd, path12);
+  return sp2.join(cwd, path18);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -2523,10 +2620,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path12, follow, fsw) {
+  constructor(path18, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path12;
-    this.path = path12 = path12.replace(REPLACER_RE, "");
+    const watchPath = path18;
+    this.path = path18 = path18.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -2666,20 +2763,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path12) => {
-        const absPath = getAbsolutePath(path12, cwd);
+      paths = paths.map((path18) => {
+        const absPath = getAbsolutePath(path18, cwd);
         return absPath;
       });
     }
-    paths.forEach((path12) => {
-      this._removeIgnoredPath(path12);
+    paths.forEach((path18) => {
+      this._removeIgnoredPath(path18);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path12) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path12, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path18) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2701,17 +2798,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path12) => {
-      if (!sp2.isAbsolute(path12) && !this._closers.has(path12)) {
+    paths.forEach((path18) => {
+      if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
         if (cwd)
-          path12 = sp2.join(cwd, path12);
-        path12 = sp2.resolve(path12);
+          path18 = sp2.join(cwd, path18);
+        path18 = sp2.resolve(path18);
       }
-      this._closePath(path12);
-      this._addIgnoredPath(path12);
-      if (this._watched.has(path12)) {
+      this._closePath(path18);
+      this._addIgnoredPath(path18);
+      if (this._watched.has(path18)) {
         this._addIgnoredPath({
-          path: path12,
+          path: path18,
           recursive: true
         });
       }
@@ -2775,38 +2872,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, path12, stats) {
+  async _emit(event, path18, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path12 = sp2.normalize(path12);
+      path18 = sp2.normalize(path18);
     if (opts.cwd)
-      path12 = sp2.relative(opts.cwd, path12);
-    const args = [path12];
+      path18 = sp2.relative(opts.cwd, path18);
+    const args = [path18];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path12))) {
+    if (awf && (pw = this._pendingWrites.get(path18))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path12, [event, ...args]);
+        this._pendingUnlinks.set(path18, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path13) => {
+          this._pendingUnlinks.forEach((entry, path19) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path13);
+            this._pendingUnlinks.delete(path19);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path12)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path12);
+        this._pendingUnlinks.delete(path18);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2824,16 +2921,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path12, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path12, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 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, path12) : path12;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path18) : path18;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -2864,23 +2961,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, path12, timeout) {
+  _throttle(actionType, path18, 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(path12);
+    const actionPath = action.get(path18);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path12);
+      const item = action.get(path18);
       const count = item ? item.count : 0;
-      action.delete(path12);
+      action.delete(path18);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2888,7 +2985,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path12, thr);
+    action.set(path18, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2902,44 +2999,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path12, threshold, event, awfEmit) {
+  _awaitWriteFinish(path18, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path12;
-    if (this.options.cwd && !sp2.isAbsolute(path12)) {
-      fullPath = sp2.join(this.options.cwd, path12);
+    let fullPath = path18;
+    if (this.options.cwd && !sp2.isAbsolute(path18)) {
+      fullPath = sp2.join(this.options.cwd, path18);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path12)) {
+        if (err || !writes.has(path18)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path12).lastChange = now2;
+          writes.get(path18).lastChange = now2;
         }
-        const pw = writes.get(path12);
+        const pw = writes.get(path18);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path12);
+          writes.delete(path18);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path12)) {
-      writes.set(path12, {
+    if (!writes.has(path18)) {
+      writes.set(path18, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path12);
+          writes.delete(path18);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2950,8 +3047,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path12, stats) {
-    if (this.options.atomic && DOT_RE.test(path12))
+  _isIgnored(path18, stats) {
+    if (this.options.atomic && DOT_RE.test(path18))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2961,17 +3058,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path12, stats);
+    return this._userIgnored(path18, stats);
   }
-  _isntIgnored(path12, stat4) {
-    return !this._isIgnored(path12, stat4);
+  _isntIgnored(path18, stat4) {
+    return !this._isIgnored(path18, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path12) {
-    return new WatchHelper(path12, this.options.followSymlinks, this);
+  _getWatchHelpers(path18) {
+    return new WatchHelper(path18, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -3003,63 +3100,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    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))
+    const path18 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path18);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path18, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path12);
+    const wp = this._getWatchedDir(path18);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path12, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path18, 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 = path12;
+    let relPath = path18;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path12);
+      relPath = sp2.relative(this.options.cwd, path18);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path12);
+    this._watched.delete(path18);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path12))
-      this._emit(eventName, path12);
-    this._closePath(path12);
+    if (wasTracked && !this._isIgnored(path18))
+      this._emit(eventName, path18);
+    this._closePath(path18);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path12) {
-    this._closeFile(path12);
-    const dir = sp2.dirname(path12);
-    this._getWatchedDir(dir).remove(sp2.basename(path12));
+  _closePath(path18) {
+    this._closeFile(path18);
+    const dir = sp2.dirname(path18);
+    this._getWatchedDir(dir).remove(sp2.basename(path18));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path12) {
-    const closers = this._closers.get(path12);
+  _closeFile(path18) {
+    const closers = this._closers.get(path18);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path12);
+    this._closers.delete(path18);
   }
-  _addPathCloser(path12, closer) {
+  _addPathCloser(path18, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path12);
+    let list = this._closers.get(path18);
     if (!list) {
       list = [];
-      this._closers.set(path12, list);
+      this._closers.set(path18, list);
     }
     list.push(closer);
   }
@@ -3088,13 +3185,13 @@ function watch(paths, options = {}) {
 }
 var chokidar_default = { watch, FSWatcher };
 
-// src/watcher/index.ts
-import * as path5 from "path";
+// src/watcher/file-watcher.ts
+import * as path8 from "path";
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync4, readFileSync as readFileSync3, promises as fsPromises } from "fs";
-import * as path4 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, promises as fsPromises } from "fs";
+import * as path7 from "path";
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -3113,7 +3210,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if (existsSync4(path4.join(projectRoot, marker))) {
+    if (existsSync5(path7.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3139,23 +3236,17 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path4.join(projectRoot, ".gitignore");
-  if (existsSync4(gitignorePath)) {
-    const gitignoreContent = readFileSync3(gitignorePath, "utf-8");
+  const gitignorePath = path7.join(projectRoot, ".gitignore");
+  if (existsSync5(gitignorePath)) {
+    const gitignoreContent = readFileSync4(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
 }
 function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
-  const relativePath = path4.relative(projectRoot, filePath);
-  const pathParts = relativePath.split(path4.sep);
-  for (const part of pathParts) {
-    if (part.startsWith(".") && part !== "." && part !== "..") {
-      return false;
-    }
-    if (part.toLowerCase().includes("build")) {
-      return false;
-    }
+  const relativePath = path7.relative(projectRoot, filePath);
+  if (hasFilteredPathSegment(relativePath, path7.sep)) {
+    return false;
   }
   if (ignoreFilter.ignores(relativePath)) {
     return false;
@@ -3192,15 +3283,15 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
-    const relativePath = path4.relative(projectRoot, fullPath);
-    if (entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..") {
+    const fullPath = path7.join(dir, entry.name);
+    const relativePath = path7.relative(projectRoot, fullPath);
+    if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
       }
       continue;
     }
-    if (entry.isDirectory() && entry.name.toLowerCase().includes("build")) {
+    if (entry.isDirectory() && isBuildPathSegment(entry.name)) {
       skipped.push({ path: relativePath, reason: "excluded" });
       continue;
     }
@@ -3242,7 +3333,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path4.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path7.relative(projectRoot, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3282,8 +3373,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 = path4.normalize(
-        path4.isAbsolute(kbRoot) ? kbRoot : path4.resolve(projectRoot, kbRoot)
+      const resolved = path7.normalize(
+        path7.isAbsolute(kbRoot) ? kbRoot : path7.resolve(projectRoot, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3316,7 +3407,7 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
   return { files, skipped };
 }
 
-// src/watcher/index.ts
+// src/watcher/file-watcher.ts
 var FileWatcher = class {
   watcher = null;
   projectRoot;
@@ -3337,16 +3428,13 @@ var FileWatcher = class {
     const ignoreFilter = createIgnoreFilter(this.projectRoot);
     this.watcher = chokidar_default.watch(this.projectRoot, {
       ignored: (filePath) => {
-        const relativePath = path5.relative(this.projectRoot, filePath);
+        const relativePath = path8.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
-        const pathParts = relativePath.split(path5.sep);
-        for (const part of pathParts) {
-          if (part.startsWith(".") && part !== "." && part !== "..") {
-            return true;
-          }
-          if (part.toLowerCase().includes("build")) {
-            return true;
-          }
+        if (hasFilteredPathSegment(relativePath, path8.sep)) {
+          return true;
+        }
+        if (isRestrictedDirectory(relativePath, path8.sep)) {
+          return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
           return true;
@@ -3360,6 +3448,13 @@ var FileWatcher = class {
         pollInterval: 100
       }
     });
+    this.watcher.on("error", (error) => {
+      const err = error instanceof Error ? error : null;
+      if (err?.code === "EPERM" || err?.code === "EACCES") {
+        return;
+      }
+      console.error("[codebase-index] Watcher error:", err?.message ?? error);
+    });
     this.watcher.on("add", (filePath) => this.handleChange("add", filePath));
     this.watcher.on("change", (filePath) => this.handleChange("change", filePath));
     this.watcher.on("unlink", (filePath) => this.handleChange("unlink", filePath));
@@ -3391,7 +3486,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path12, type]) => ({ path: path12, type })
+      ([path18, type]) => ({ path: path18, type })
     );
     this.pendingChanges.clear();
     try {
@@ -3416,6 +3511,9 @@ var FileWatcher = class {
     return this.watcher !== null;
   }
 };
+
+// src/watcher/git-head-watcher.ts
+import * as path9 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -3437,7 +3535,7 @@ var GitHeadWatcher = class {
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path5.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path9.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -3489,7 +3587,9 @@ var GitHeadWatcher = class {
     return this.watcher !== null;
   }
 };
-function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
+
+// src/watcher/index.ts
+function createWatcherWithIndexer(getIndexer, projectRoot, config) {
   const fileWatcher = new FileWatcher(projectRoot, config);
   fileWatcher.start(async (changes) => {
     const hasAddOrChange = changes.some(
@@ -3497,7 +3597,7 @@ function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
     );
     const hasDelete = changes.some((c) => c.type === "unlink");
     if (hasAddOrChange || hasDelete) {
-      await getIndexer2().index();
+      await getIndexer().index();
     }
   });
   let gitWatcher = null;
@@ -3505,7 +3605,7 @@ function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
     gitWatcher = new GitHeadWatcher(projectRoot);
     gitWatcher.start(async (oldBranch, newBranch) => {
       console.log(`Branch changed: ${oldBranch ?? "(none)"} -> ${newBranch}`);
-      await getIndexer2().index();
+      await getIndexer().index();
     });
   }
   return {
@@ -3522,8 +3622,8 @@ function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
 import { tool } from "@opencode-ai/plugin";
 
 // src/indexer/index.ts
-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 { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync2, renameSync, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
+import * as path12 from "path";
 import { performance as performance2 } from "perf_hooks";
 
 // node_modules/eventemitter3/index.mjs
@@ -3548,7 +3648,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve9, reject) => {
+  const wrappedPromise = new Promise((resolve12, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -3562,7 +3662,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve9, reject);
+    promise.then(resolve12, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -3570,7 +3670,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve9(fallback());
+          resolve12(fallback());
         } catch (error) {
           reject(error);
         }
@@ -3580,7 +3680,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve9();
+        resolve12();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -3982,7 +4082,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve12, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -4022,7 +4122,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve9(result);
+          resolve12(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -4210,13 +4310,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve12) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve9();
+        resolve12();
       };
       this.on(event, listener);
     });
@@ -4502,7 +4602,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve12, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -4510,7 +4610,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve9();
+        resolve12();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -4571,17 +4671,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import * as path6 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import * as path10 from "path";
 import * as os3 from "os";
 function getOpenCodeAuthPath() {
-  return path6.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
+  return path10.join(os3.homedir(), ".local", "share", "opencode", "auth.json");
 }
 function loadOpenCodeAuth() {
   const authPath = getOpenCodeAuthPath();
   try {
-    if (existsSync5(authPath)) {
-      return JSON.parse(readFileSync4(authPath, "utf-8"));
+    if (existsSync6(authPath)) {
+      return JSON.parse(readFileSync5(authPath, "utf-8"));
     }
   } catch {
   }
@@ -4648,7 +4748,8 @@ function getGitHubCopilotCredentials() {
   if (!copilotAuth || copilotAuth.type !== "oauth") {
     return null;
   }
-  const baseUrl = copilotAuth.enterpriseUrl ? `https://copilot-api.${copilotAuth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
+  const auth = copilotAuth;
+  const baseUrl = auth.enterpriseUrl ? `https://copilot-api.${auth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
   return {
     provider: "github-copilot",
     baseUrl,
@@ -4744,42 +4845,12 @@ function createCustomProviderInfo(config) {
   };
 }
 
-// src/embeddings/provider.ts
-var CustomProviderNonRetryableError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CustomProviderNonRetryableError";
-  }
-};
-function createEmbeddingProvider(configuredProviderInfo) {
-  switch (configuredProviderInfo.provider) {
-    case "github-copilot":
-      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "openai":
-      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "google":
-      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "ollama":
-      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    case "custom":
-      return new CustomEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
-    default: {
-      const _exhaustive = configuredProviderInfo;
-      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
-    }
-  }
-}
-var GitHubCopilotEmbeddingProvider = class {
+// src/embeddings/provider-types.ts
+var BaseEmbeddingProvider = class {
   constructor(credentials, modelInfo) {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  getToken() {
-    if (!this.credentials.refreshToken) {
-      throw new Error("No OAuth token available for GitHub");
-    }
-    return this.credentials.refreshToken;
-  }
   async embedQuery(query) {
     const result = await this.embedBatch([query]);
     return {
@@ -4794,69 +4865,204 @@ var GitHubCopilotEmbeddingProvider = class {
       tokensUsed: result.totalTokensUsed
     };
   }
-  async embedBatch(texts) {
-    const token = this.getToken();
-    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
-      body: JSON.stringify({
-        model: `openai/${this.modelInfo.model}`,
-        input: texts
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
-    }
-    const data = await response.json();
-    return {
-      embeddings: data.data.map((d) => d.embedding),
-      totalTokensUsed: data.usage.total_tokens
-    };
-  }
   getModelInfo() {
     return this.modelInfo;
   }
 };
-var OpenAIEmbeddingProvider = class {
+var CustomProviderNonRetryableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomProviderNonRetryableError";
+  }
+};
+
+// src/utils/url-validation.ts
+var BLOCKED_METADATA_IPS = [
+  /^169\.254\.169\.254$/,
+  // AWS/Azure/GCP metadata
+  /^169\.254\.170\.2$/,
+  // AWS ECS task metadata
+  /^fd00:ec2::254$/
+  // AWS IMDSv2 IPv6
+];
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "metadata.google.internal",
+  "metadata.google",
+  "metadata.goog",
+  "kubernetes.default.svc"
+]);
+function validateExternalUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    return { valid: false, reason: `Invalid URL: ${sanitizeUrlForError(urlString)}` };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { valid: false, reason: `Blocked protocol: ${parsed.protocol}` };
+  }
+  const hostname = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname)) {
+    return { valid: false, reason: `Blocked: cloud metadata service (${hostname})` };
+  }
+  for (const pattern of BLOCKED_METADATA_IPS) {
+    if (pattern.test(hostname)) {
+      return { valid: false, reason: `Blocked: cloud metadata IP (${hostname})` };
+    }
+  }
+  if (/^169\.254\./.test(hostname)) {
+    return { valid: false, reason: `Blocked: link-local address (${hostname})` };
+  }
+  return { valid: true };
+}
+function sanitizeUrlForError(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    const maxLen = 80;
+    if (url.length > maxLen) {
+      return url.slice(0, maxLen) + "...";
+    }
+    return url;
+  }
+}
+
+// src/embeddings/providers/custom.ts
+var CustomEmbeddingProvider = class extends BaseEmbeddingProvider {
   constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+    super(credentials, modelInfo);
   }
-  async embedQuery(query) {
-    const result = await this.embedBatch([query]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+  splitIntoRequestBatches(texts) {
+    const maxBatchSize = this.modelInfo.maxBatchSize;
+    if (!maxBatchSize || texts.length <= maxBatchSize) {
+      return [texts];
+    }
+    const batches = [];
+    for (let i = 0; i < texts.length; i += maxBatchSize) {
+      batches.push(texts.slice(i, i + maxBatchSize));
+    }
+    return batches;
+  }
+  async embedRequest(texts) {
+    if (texts.length === 0) {
+      return {
+        embeddings: [],
+        totalTokensUsed: 0
+      };
+    }
+    const headers = {
+      "Content-Type": "application/json"
     };
+    if (this.credentials.apiKey) {
+      headers.Authorization = `Bearer ${this.credentials.apiKey}`;
+    }
+    const baseUrl = this.credentials.baseUrl ?? "";
+    const fullUrl = `${baseUrl}/embeddings`;
+    const urlCheck = validateExternalUrl(fullUrl);
+    if (!urlCheck.valid) {
+      throw new CustomProviderNonRetryableError(
+        `Custom embedding provider URL blocked (SSRF protection): ${urlCheck.reason}`
+      );
+    }
+    const timeoutMs = this.modelInfo.timeoutMs;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(fullUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          input: texts
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Custom embedding API request timed out after ${timeoutMs}ms for ${sanitizeUrlForError(fullUrl)}`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const errorText = (await response.text()).slice(0, 500);
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+        throw new CustomProviderNonRetryableError(`Custom embedding API error (non-retryable): ${response.status} - ${errorText}`);
+      }
+      throw new Error(`Custom embedding API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data)) {
+      if (data.data.length > 0) {
+        const actualDims = data.data[0].embedding.length;
+        if (actualDims !== this.modelInfo.dimensions) {
+          throw new Error(
+            `Dimension mismatch: customProvider.dimensions is ${this.modelInfo.dimensions}, but the API returned vectors with ${actualDims} dimensions. Update your config to match the model's actual output dimensions.`
+          );
+        }
+      }
+      if (data.data.length !== texts.length) {
+        throw new Error(
+          `Embedding count mismatch: sent ${texts.length} texts but received ${data.data.length} embeddings. The custom embedding server may not support batch input.`
+        );
+      }
+      return {
+        embeddings: data.data.map((d) => d.embedding),
+        totalTokensUsed: data.usage?.total_tokens ?? texts.reduce((sum, t) => sum + Math.ceil(t.length / 4), 0)
+      };
+    }
+    throw new Error("Custom embedding API returned unexpected response format. Expected OpenAI-compatible format with data[].embedding.");
   }
-  async embedDocument(document) {
-    const result = await this.embedBatch([document]);
+  async embedBatch(texts) {
+    const requestBatches = this.splitIntoRequestBatches(texts);
+    const embeddings = [];
+    let totalTokensUsed = 0;
+    for (const batch of requestBatches) {
+      const result = await this.embedRequest(batch);
+      embeddings.push(...result.embeddings);
+      totalTokensUsed += result.totalTokensUsed;
+    }
     return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+      embeddings,
+      totalTokensUsed
     };
   }
+};
+
+// src/embeddings/providers/github-copilot.ts
+var GitHubCopilotEmbeddingProvider = class extends BaseEmbeddingProvider {
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
+  }
+  getToken() {
+    if (!this.credentials.refreshToken) {
+      throw new Error("No OAuth token available for GitHub");
+    }
+    return this.credentials.refreshToken;
+  }
   async embedBatch(texts) {
-    const response = await fetch(`${this.credentials.baseUrl}/embeddings`, {
+    const token = this.getToken();
+    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${this.credentials.apiKey}`,
-        "Content-Type": "application/json"
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
       },
       body: JSON.stringify({
-        model: this.modelInfo.model,
+        model: `openai/${this.modelInfo.model}`,
         input: texts
       })
     });
     if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI embedding API error: ${response.status} - ${error}`);
+      const error = (await response.text()).slice(0, 500);
+      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
     }
     const data = await response.json();
     return {
@@ -4864,16 +5070,14 @@ var OpenAIEmbeddingProvider = class {
       totalTokensUsed: data.usage.total_tokens
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
-var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
+
+// src/embeddings/providers/google.ts
+var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddingProvider {
+  static BATCH_SIZE = 20;
   constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
+    super(credentials, modelInfo);
   }
-  static BATCH_SIZE = 20;
   async embedQuery(query) {
     const taskType = this.modelInfo.taskAble ? "CODE_RETRIEVAL_QUERY" : void 0;
     const result = await this.embedWithTaskType([query], taskType);
@@ -4894,12 +5098,6 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
     const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
     return this.embedWithTaskType(texts, taskType);
   }
-  /**
-   * Embeds texts using the Google embedContent API.
-   * Sends multiple texts as parts in batched requests (up to BATCH_SIZE per call).
-   * When taskType is provided (gemini-embedding-001), includes it in the request
-   * for task-specific embedding optimization.
-   */
   async embedWithTaskType(texts, taskType) {
     const batches = [];
     for (let i = 0; i < texts.length; i += _GoogleEmbeddingProvider.BATCH_SIZE) {
@@ -4916,17 +5114,18 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
           outputDimensionality: this.modelInfo.dimensions
         }));
         const response = await fetch(
-          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents?key=${this.credentials.apiKey}`,
+          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents`,
           {
             method: "POST",
             headers: {
-              "Content-Type": "application/json"
+              "Content-Type": "application/json",
+              ...this.credentials.apiKey && { "x-goog-api-key": this.credentials.apiKey }
             },
             body: JSON.stringify({ requests })
           }
         );
         if (!response.ok) {
-          const error = await response.text();
+          const error = (await response.text()).slice(0, 500);
           throw new Error(`Google embedding API error: ${response.status} - ${error}`);
         }
         const data = await response.json();
@@ -4941,29 +5140,13 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
       totalTokensUsed: batchResults.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
-var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
-  constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
-  }
+
+// src/embeddings/providers/ollama.ts
+var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddingProvider {
   static MIN_TRUNCATION_CHARS = 512;
-  async embedQuery(query) {
-    const result = await this.embedBatch([query]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
-    };
-  }
-  async embedDocument(document) {
-    const result = await this.embedBatch([document]);
-    return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
-    };
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
   }
   estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -5027,166 +5210,97 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider {
           return await this.embedSingle(truncated);
         } catch (retryError) {
           if (!this.isContextLengthError(retryError)) {
-            throw retryError;
-          }
-          lastError = retryError;
-        }
-      }
-      throw lastError;
-    }
-  }
-  async embedSingle(text) {
-    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.modelInfo.model,
-        prompt: text,
-        truncate: false
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
-    }
-    const data = await response.json();
-    return {
-      embedding: data.embedding,
-      tokensUsed: this.estimateTokens(text)
-    };
-  }
-  async embedBatch(texts) {
-    const results = [];
-    for (const text of texts) {
-      results.push(await this.embedSingleWithFallback(text));
-    }
-    return {
-      embeddings: results.map((r) => r.embedding),
-      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
-    };
-  }
-  getModelInfo() {
-    return this.modelInfo;
-  }
-};
-var CustomEmbeddingProvider = class {
-  constructor(credentials, modelInfo) {
-    this.credentials = credentials;
-    this.modelInfo = modelInfo;
-  }
-  splitIntoRequestBatches(texts) {
-    const maxBatchSize = this.modelInfo.maxBatchSize;
-    if (!maxBatchSize || texts.length <= maxBatchSize) {
-      return [texts];
-    }
-    const batches = [];
-    for (let i = 0; i < texts.length; i += maxBatchSize) {
-      batches.push(texts.slice(i, i + maxBatchSize));
-    }
-    return batches;
-  }
-  async embedRequest(texts) {
-    if (texts.length === 0) {
-      return {
-        embeddings: [],
-        totalTokensUsed: 0
-      };
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.credentials.apiKey) {
-      headers["Authorization"] = `Bearer ${this.credentials.apiKey}`;
-    }
-    const baseUrl = this.credentials.baseUrl ?? "";
-    const timeoutMs = this.modelInfo.timeoutMs;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response;
-    try {
-      response = await fetch(`${baseUrl}/embeddings`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          model: this.modelInfo.model,
-          input: texts
-        }),
-        signal: controller.signal
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Custom embedding API request timed out after ${timeoutMs}ms for ${baseUrl}/embeddings`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-        throw new CustomProviderNonRetryableError(`Custom embedding API error (non-retryable): ${response.status} - ${errorText}`);
-      }
-      throw new Error(`Custom embedding API error: ${response.status} - ${errorText}`);
-    }
-    const data = await response.json();
-    if (data.data && Array.isArray(data.data)) {
-      if (data.data.length > 0) {
-        const actualDims = data.data[0].embedding.length;
-        if (actualDims !== this.modelInfo.dimensions) {
-          throw new Error(
-            `Dimension mismatch: customProvider.dimensions is ${this.modelInfo.dimensions}, but the API returned vectors with ${actualDims} dimensions. Update your config to match the model's actual output dimensions.`
-          );
+            throw retryError;
+          }
+          lastError = retryError;
         }
       }
-      if (data.data.length !== texts.length) {
-        throw new Error(
-          `Embedding count mismatch: sent ${texts.length} texts but received ${data.data.length} embeddings. The custom embedding server may not support batch input.`
-        );
-      }
-      return {
-        embeddings: data.data.map((d) => d.embedding),
-        // Rough estimate: ~4 chars per token. Used as fallback when the server
-        // doesn't return usage.total_tokens (e.g. llama.cpp, some vLLM configs).
-        totalTokensUsed: data.usage?.total_tokens ?? texts.reduce((sum, t) => sum + Math.ceil(t.length / 4), 0)
-      };
+      throw lastError;
     }
-    throw new Error("Custom embedding API returned unexpected response format. Expected OpenAI-compatible format with data[].embedding.");
   }
-  async embedQuery(query) {
-    const result = await this.embedBatch([query]);
+  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()).slice(0, 500);
+      throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
     return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+      embedding: data.embedding,
+      tokensUsed: this.estimateTokens(text)
     };
   }
-  async embedDocument(document) {
-    const result = await this.embedBatch([document]);
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embedSingleWithFallback(text));
+    }
     return {
-      embedding: result.embeddings[0],
-      tokensUsed: result.totalTokensUsed
+      embeddings: results.map((r) => r.embedding),
+      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
+};
+
+// src/embeddings/providers/openai.ts
+var OpenAIEmbeddingProvider = class extends BaseEmbeddingProvider {
+  constructor(credentials, modelInfo) {
+    super(credentials, modelInfo);
+  }
   async embedBatch(texts) {
-    const requestBatches = this.splitIntoRequestBatches(texts);
-    const embeddings = [];
-    let totalTokensUsed = 0;
-    for (const batch of requestBatches) {
-      const result = await this.embedRequest(batch);
-      embeddings.push(...result.embeddings);
-      totalTokensUsed += result.totalTokensUsed;
+    const response = await fetch(`${this.credentials.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.credentials.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.modelInfo.model,
+        input: texts
+      })
+    });
+    if (!response.ok) {
+      const error = (await response.text()).slice(0, 500);
+      throw new Error(`OpenAI embedding API error: ${response.status} - ${error}`);
     }
+    const data = await response.json();
     return {
-      embeddings,
-      totalTokensUsed
+      embeddings: data.data.map((d) => d.embedding),
+      totalTokensUsed: data.usage.total_tokens
     };
   }
-  getModelInfo() {
-    return this.modelInfo;
-  }
 };
 
+// src/embeddings/provider.ts
+function createEmbeddingProvider(configuredProviderInfo) {
+  switch (configuredProviderInfo.provider) {
+    case "github-copilot":
+      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "openai":
+      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "google":
+      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "ollama":
+      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "custom":
+      return new CustomEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    default: {
+      const _exhaustive = configuredProviderInfo;
+      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
+    }
+  }
+}
+
 // src/rerank/index.ts
 function createReranker(config) {
   if (!config.enabled) {
@@ -5222,7 +5336,10 @@ var SiliconFlowReranker = class {
     if (this.config.apiKey) {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
-    const baseUrl = this.config.baseUrl ?? "https://api.siliconflow.cn/v1";
+    const baseUrl = this.config.baseUrl;
+    if (!baseUrl) {
+      throw new Error("Reranker baseUrl is required. Configure reranker.baseUrl in your codebase-index.json.");
+    }
     const timeoutMs = this.config.timeoutMs ?? 3e4;
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -5296,20 +5413,21 @@ function createCostEstimate(files, provider) {
 }
 function formatCostEstimate(estimate) {
   const sizeFormatted = formatBytes(estimate.totalSizeBytes);
+  const filesFormatted = `${estimate.filesCount.toLocaleString()} files`;
   const costFormatted = estimate.isFree ? "Free" : `~$${estimate.estimatedCost.toFixed(4)}`;
   return `
 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
 \u2502  \u{1F4CA} Indexing Estimate                                           \u2502
 \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
 \u2502                                                                 \u2502
-\u2502  Files to index:     ${padRight(estimate.filesCount.toLocaleString() + " files", 40)}\u2502
-\u2502  Total size:         ${padRight(sizeFormatted, 40)}\u2502
-\u2502  Estimated chunks:   ${padRight("~" + estimate.estimatedChunks.toLocaleString() + " chunks", 40)}\u2502
-\u2502  Estimated tokens:   ${padRight("~" + estimate.estimatedTokens.toLocaleString() + " tokens", 40)}\u2502
+\u2502  Files to index:     ${filesFormatted.padEnd(40)}\u2502
+\u2502  Total size:         ${sizeFormatted.padEnd(40)}\u2502
+\u2502  Estimated chunks:   ${("~" + estimate.estimatedChunks.toLocaleString() + " chunks").padEnd(40)}\u2502
+\u2502  Estimated tokens:   ${("~" + estimate.estimatedTokens.toLocaleString() + " tokens").padEnd(40)}\u2502
 \u2502                                                                 \u2502
-\u2502  Provider: ${padRight(estimate.provider, 52)}\u2502
-\u2502  Model:    ${padRight(estimate.model, 52)}\u2502
-\u2502  Cost:     ${padRight(costFormatted, 52)}\u2502
+\u2502  Provider: ${estimate.provider.padEnd(52)}\u2502
+\u2502  Model:    ${estimate.model.padEnd(52)}\u2502
+\u2502  Cost:     ${costFormatted.padEnd(52)}\u2502
 \u2502                                                                 \u2502
 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
 `;
@@ -5321,9 +5439,6 @@ function formatBytes(bytes) {
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
 }
-function padRight(str, length) {
-  return str.padEnd(length);
-}
 
 // src/utils/logger.ts
 var LOG_LEVEL_PRIORITY = {
@@ -5390,6 +5505,10 @@ var Logger = class {
       this.logs.shift();
     }
   }
+  withMetrics(fn) {
+    if (!this.config.metrics) return;
+    fn();
+  }
   search(level, message, data) {
     if (this.config.logSearch) {
       this.log(level, "search", message, data);
@@ -5428,89 +5547,107 @@ var Logger = class {
     this.log("debug", "general", message, data);
   }
   recordIndexingStart() {
-    if (!this.config.metrics) return;
-    this.metrics.indexingStartTime = Date.now();
+    this.withMetrics(() => {
+      this.metrics.indexingStartTime = Date.now();
+    });
   }
   recordIndexingEnd() {
-    if (!this.config.metrics) return;
-    this.metrics.indexingEndTime = Date.now();
+    this.withMetrics(() => {
+      this.metrics.indexingEndTime = Date.now();
+    });
   }
   recordFilesScanned(count) {
-    if (!this.config.metrics) return;
-    this.metrics.filesScanned = count;
+    this.withMetrics(() => {
+      this.metrics.filesScanned = count;
+    });
   }
   recordFilesParsed(count) {
-    if (!this.config.metrics) return;
-    this.metrics.filesParsed = count;
+    this.withMetrics(() => {
+      this.metrics.filesParsed = count;
+    });
   }
   recordParseDuration(durationMs) {
-    if (!this.config.metrics) return;
-    this.metrics.parseMs = durationMs;
+    this.withMetrics(() => {
+      this.metrics.parseMs = durationMs;
+    });
   }
   recordChunksProcessed(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksProcessed += count;
+    this.withMetrics(() => {
+      this.metrics.chunksProcessed += count;
+    });
   }
   recordChunksEmbedded(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksEmbedded += count;
+    this.withMetrics(() => {
+      this.metrics.chunksEmbedded += count;
+    });
   }
   recordChunksFromCache(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksFromCache += count;
+    this.withMetrics(() => {
+      this.metrics.chunksFromCache += count;
+    });
   }
   recordChunksRemoved(count) {
-    if (!this.config.metrics) return;
-    this.metrics.chunksRemoved += count;
+    this.withMetrics(() => {
+      this.metrics.chunksRemoved += count;
+    });
   }
   recordEmbeddingApiCall(tokens) {
-    if (!this.config.metrics) return;
-    this.metrics.embeddingApiCalls++;
-    this.metrics.embeddingTokensUsed += tokens;
+    this.withMetrics(() => {
+      this.metrics.embeddingApiCalls++;
+      this.metrics.embeddingTokensUsed += tokens;
+    });
   }
   recordEmbeddingError() {
-    if (!this.config.metrics) return;
-    this.metrics.embeddingErrors++;
+    this.withMetrics(() => {
+      this.metrics.embeddingErrors++;
+    });
   }
   recordSearch(durationMs, breakdown) {
-    if (!this.config.metrics) return;
-    this.metrics.searchCount++;
-    this.metrics.searchTotalMs += durationMs;
-    this.metrics.searchLastMs = durationMs;
-    this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
-    if (breakdown) {
-      this.metrics.embeddingCallMs = breakdown.embeddingMs;
-      this.metrics.vectorSearchMs = breakdown.vectorMs;
-      this.metrics.keywordSearchMs = breakdown.keywordMs;
-      this.metrics.fusionMs = breakdown.fusionMs;
-    }
+    this.withMetrics(() => {
+      this.metrics.searchCount++;
+      this.metrics.searchTotalMs += durationMs;
+      this.metrics.searchLastMs = durationMs;
+      this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
+      if (breakdown) {
+        this.metrics.embeddingCallMs = breakdown.embeddingMs;
+        this.metrics.vectorSearchMs = breakdown.vectorMs;
+        this.metrics.keywordSearchMs = breakdown.keywordMs;
+        this.metrics.fusionMs = breakdown.fusionMs;
+      }
+    });
   }
   recordCacheHit() {
-    if (!this.config.metrics) return;
-    this.metrics.cacheHits++;
+    this.withMetrics(() => {
+      this.metrics.cacheHits++;
+    });
   }
   recordCacheMiss() {
-    if (!this.config.metrics) return;
-    this.metrics.cacheMisses++;
+    this.withMetrics(() => {
+      this.metrics.cacheMisses++;
+    });
   }
   recordQueryCacheHit() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheHits++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheHits++;
+    });
   }
   recordQueryCacheSimilarHit() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheSimilarHits++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheSimilarHits++;
+    });
   }
   recordQueryCacheMiss() {
-    if (!this.config.metrics) return;
-    this.metrics.queryCacheMisses++;
+    this.withMetrics(() => {
+      this.metrics.queryCacheMisses++;
+    });
   }
   recordGc(orphans, chunks, embeddings) {
-    if (!this.config.metrics) return;
-    this.metrics.gcRuns++;
-    this.metrics.gcOrphansRemoved += orphans;
-    this.metrics.gcChunksRemoved += chunks;
-    this.metrics.gcEmbeddingsRemoved += embeddings;
+    this.withMetrics(() => {
+      this.metrics.gcRuns++;
+      this.metrics.gcOrphansRemoved += orphans;
+      this.metrics.gcChunksRemoved += chunks;
+      this.metrics.gcEmbeddingsRemoved += embeddings;
+    });
   }
   getMetrics() {
     return { ...this.metrics };
@@ -5617,7 +5754,7 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path7 from "path";
+import * as path11 from "path";
 import * as os4 from "os";
 import * as module from "module";
 import { fileURLToPath } from "url";
@@ -5641,19 +5778,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path7.dirname(fileURLToPath(import.meta.url));
+    currentDir = path11.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path7.join(currentDir, "index.js");
+    requireTarget = path11.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path7.join("src", "native"));
-  const packageRoot = isDevMode ? path7.resolve(currentDir, "../..") : path7.resolve(currentDir, "..");
-  const nativePath = path7.join(packageRoot, "native", bindingName);
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path11.join("src", "native"));
+  const packageRoot = isDevMode ? path11.resolve(currentDir, "../..") : path11.resolve(currentDir, "..");
+  const nativePath = path11.join(packageRoot, "native", bindingName);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -6223,7 +6360,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.getStats();
   }
-  // ── Symbol methods ──────────────────────────────────────────────
   upsertSymbol(symbol) {
     this.throwIfClosed();
     this.inner.upsertSymbol(symbol);
@@ -6253,7 +6389,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
   }
-  // ── Call Edge methods ────────────────────────────────────────────
   upsertCallEdge(edge) {
     this.throwIfClosed();
     this.inner.upsertCallEdge(edge);
@@ -6283,7 +6418,6 @@ var Database = class {
     this.throwIfClosed();
     this.inner.resolveCallEdge(edgeId, toSymbolId);
   }
-  // ── Branch Symbol methods ────────────────────────────────────────
   addSymbolsToBranch(branch, symbolIds) {
     this.throwIfClosed();
     this.inner.addSymbolsToBranch(branch, symbolIds);
@@ -6316,7 +6450,6 @@ var Database = class {
     if (symbolIds.length === 0) return 0;
     return this.inner.deleteBranchSymbolsForBranch(branch, symbolIds);
   }
-  // ── GC methods for symbols/edges ─────────────────────────────────
   gcOrphanSymbols() {
     this.throwIfClosed();
     return this.inner.gcOrphanSymbols();
@@ -6328,7 +6461,7 @@ var Database = class {
 };
 
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -6355,7 +6488,15 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "trigger_declaration",
   "test_declaration",
   "struct_declaration",
-  "union_declaration"
+  "union_declaration",
+  // GDScript declarations whose names participate in the call graph.
+  // `function_definition` and `class_definition` are already in the set
+  // above (shared with Python/C/Bash and Python, respectively).
+  "constructor_definition",
+  "enum_definition",
+  "signal_statement",
+  "const_statement",
+  "class_name_statement"
 ]);
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
@@ -6557,9 +6698,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path8.resolve(filePath);
-  const normalizedRoot = path8.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path8.sep}`);
+  const normalizedFilePath = path12.resolve(filePath);
+  const normalizedRoot = path12.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path12.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -7612,22 +7753,28 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path8.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path8.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path8.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path12.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path12.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path12.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return resolveProjectIndexPath(this.projectRoot, this.config.scope);
   }
   loadFileHashCache() {
+    if (!existsSync7(this.fileHashCachePath)) {
+      return;
+    }
     try {
-      if (existsSync6(this.fileHashCachePath)) {
-        const data = readFileSync5(this.fileHashCachePath, "utf-8");
-        const parsed = JSON.parse(data);
-        this.fileHashCache = new Map(Object.entries(parsed));
-      }
-    } catch {
+      const data = readFileSync6(this.fileHashCachePath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.fileHashCache = new Map(Object.entries(parsed));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("Failed to load file hash cache, resetting cache state", {
+        fileHashCachePath: this.fileHashCachePath,
+        error: message
+      });
       this.fileHashCache = /* @__PURE__ */ new Map();
     }
   }
@@ -7640,14 +7787,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    mkdirSync2(path8.dirname(targetPath), { recursive: true });
+    mkdirSync2(path12.dirname(targetPath), { recursive: true });
     writeFileSync2(tempPath, data);
     renameSync(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path8.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path12.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path8.resolve(this.projectRoot, kbRoot));
+      roots.add(path12.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -7656,22 +7803,22 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -7765,7 +7912,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectRootPath = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -7788,7 +7935,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -7872,7 +8019,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path8.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -7906,7 +8053,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path8.resolve(this.projectRoot);
+    const projectRootPath = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -7975,7 +8122,7 @@ var Indexer = class {
     };
   }
   checkForInterruptedIndexing() {
-    return existsSync6(this.indexingLockPath);
+    return existsSync7(this.indexingLockPath);
   }
   acquireIndexingLock() {
     const lockData = {
@@ -7985,13 +8132,13 @@ var Indexer = class {
     writeFileSync2(this.indexingLockPath, JSON.stringify(lockData));
   }
   releaseIndexingLock() {
-    if (existsSync6(this.indexingLockPath)) {
+    if (existsSync7(this.indexingLockPath)) {
       unlinkSync(this.indexingLockPath);
     }
   }
   async recoverFromInterruptedIndexing() {
     this.logger.warn("Detected interrupted indexing session, recovering...");
-    if (existsSync6(this.fileHashCachePath)) {
+    if (existsSync7(this.fileHashCachePath)) {
       unlinkSync(this.fileHashCachePath);
     }
     await this.healthCheck();
@@ -8001,15 +8148,20 @@ var Indexer = class {
   loadFailedBatches(maxChunkTokens) {
     try {
       return this.loadSerializedFailedBatches().map((batch) => normalizeFailedBatch(batch, maxChunkTokens)).filter((batch) => batch !== null);
-    } catch {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("Failed to load failed batch state, skipping persisted retries", {
+        failedBatchesPath: this.failedBatchesPath,
+        error: message
+      });
       return [];
     }
   }
   loadSerializedFailedBatches() {
-    if (!existsSync6(this.failedBatchesPath)) {
+    if (!existsSync7(this.failedBatchesPath)) {
       return [];
     }
-    const data = readFileSync5(this.failedBatchesPath, "utf-8");
+    const data = readFileSync6(this.failedBatchesPath, "utf-8");
     const parsed = JSON.parse(data);
     return parsed.map((batch) => {
       const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
@@ -8026,7 +8178,7 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync6(this.failedBatchesPath)) {
+      if (existsSync7(this.failedBatchesPath)) {
         try {
           unlinkSync(this.failedBatchesPath);
         } catch {
@@ -8261,24 +8413,24 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path8.join(this.indexPath, "vectors");
+    const storePath = path12.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path8.join(this.indexPath, "vectors.usearch");
-    if (existsSync6(indexFilePath)) {
+    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
+    if (existsSync7(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path8.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path12.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
     } catch {
-      if (existsSync6(invertedIndexPath)) {
+      if (existsSync7(invertedIndexPath)) {
         await fsPromises2.unlink(invertedIndexPath);
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path8.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync6(dbPath);
+    const dbPath = path12.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync7(dbPath);
     try {
       this.database = new Database(dbPath);
     } catch (error) {
@@ -8358,7 +8510,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -8373,7 +8525,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path8.join(this.indexPath, "vectors");
+    const storeBasePath = path12.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -8382,18 +8534,18 @@ var Indexer = class {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync6(backupIndexPath)) {
+    if (existsSync7(backupIndexPath)) {
       unlinkSync(backupIndexPath);
     }
-    if (existsSync6(backupMetadataPath)) {
+    if (existsSync7(backupMetadataPath)) {
       unlinkSync(backupMetadataPath);
     }
     try {
-      if (existsSync6(storeIndexPath)) {
+      if (existsSync7(storeIndexPath)) {
         renameSync(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync6(storeMetadataPath)) {
+      if (existsSync7(storeMetadataPath)) {
         renameSync(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
@@ -8414,10 +8566,10 @@ var Indexer = class {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync6(backupIndexPath)) {
+      if (backedUpIndex && existsSync7(backupIndexPath)) {
         unlinkSync(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync6(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
         unlinkSync(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -8430,16 +8582,16 @@ var Indexer = class {
         store.clear();
       } catch {
       }
-      if (existsSync6(storeIndexPath)) {
+      if (existsSync7(storeIndexPath)) {
         unlinkSync(storeIndexPath);
       }
-      if (existsSync6(storeMetadataPath)) {
+      if (existsSync7(storeMetadataPath)) {
         unlinkSync(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync6(backupIndexPath)) {
+      if (backedUpIndex && existsSync7(backupIndexPath)) {
         renameSync(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync6(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
         renameSync(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
@@ -8458,7 +8610,7 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path8.join(this.indexPath, "codebase.db");
+    const dbPath = path12.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage(error);
     if (this.config.scope === "global") {
@@ -8481,15 +8633,15 @@ var Indexer = class {
     this.indexCompatibility = null;
     this.fileHashCache.clear();
     const resetPaths = [
-      path8.join(this.indexPath, "codebase.db"),
-      path8.join(this.indexPath, "codebase.db-shm"),
-      path8.join(this.indexPath, "codebase.db-wal"),
-      path8.join(this.indexPath, "vectors.usearch"),
-      path8.join(this.indexPath, "inverted-index.json"),
-      path8.join(this.indexPath, "file-hashes.json"),
-      path8.join(this.indexPath, "failed-batches.json"),
-      path8.join(this.indexPath, "indexing.lock"),
-      path8.join(this.indexPath, "vectors")
+      path12.join(this.indexPath, "codebase.db"),
+      path12.join(this.indexPath, "codebase.db-shm"),
+      path12.join(this.indexPath, "codebase.db-wal"),
+      path12.join(this.indexPath, "vectors.usearch"),
+      path12.join(this.indexPath, "inverted-index.json"),
+      path12.join(this.indexPath, "file-hashes.json"),
+      path12.join(this.indexPath, "failed-batches.json"),
+      path12.join(this.indexPath, "indexing.lock"),
+      path12.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -8754,7 +8906,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path8.relative(this.projectRoot, parsed.path);
+        const relativePath = path12.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -9037,7 +9189,7 @@ var Indexer = class {
     for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve9) => setTimeout(resolve9, rateLimitBackoffMs));
+          await new Promise((resolve12) => setTimeout(resolve12, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -9598,8 +9750,8 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPath = path8.join(this.projectRoot, ".opencode", "index");
-    if (path8.resolve(this.indexPath) !== path8.resolve(localProjectIndexPath)) {
+    const localProjectIndexPath = path12.join(this.projectRoot, ".opencode", "index");
+    if (path12.resolve(this.indexPath) !== path12.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."
       );
@@ -9638,7 +9790,7 @@ var Indexer = class {
     const removedChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync6(filePath)) {
+      if (!existsSync7(filePath)) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           removedChunkKeys.push(key);
@@ -9687,7 +9839,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path8.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -10239,12 +10391,15 @@ function formatLogs(logs) {
     return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
   }).join("\n");
 }
+function formatResultHeader(result, index) {
+  return result.name ? `[${index + 1}] ${result.chunkType} "${result.name}" in ${result.filePath}:${result.startLine}-${result.endLine}` : `[${index + 1}] ${result.chunkType} in ${result.filePath}:${result.startLine}-${result.endLine}`;
+}
 function formatDefinitionLookup(results, query) {
   if (results.length === 0) {
     return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
   }
   const formatted = results.map((r, idx) => {
-    const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
+    const header = formatResultHeader(r, idx);
     return `${header} (score: ${r.score.toFixed(2)})
 \`\`\`
 ${truncateContent(r.content)}
@@ -10254,7 +10409,7 @@ ${truncateContent(r.content)}
 }
 function formatSearchResults(results, scoreFormat = "similarity") {
   const formatted = results.map((r, idx) => {
-    const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
+    const header = formatResultHeader(r, idx);
     const scoreLabel = scoreFormat === "similarity" ? `(similarity: ${(r.score * 100).toFixed(1)}%)` : `(score: ${r.score.toFixed(2)})`;
     return `${header} ${scoreLabel}
 \`\`\`
@@ -10264,104 +10419,83 @@ ${truncateContent(r.content)}
   return formatted.join("\n\n");
 }
 
-// src/tools/index.ts
-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 = "";
-function initializeTools(projectRoot, config) {
-  sharedProjectRoot = projectRoot;
-  sharedIndexer = new Indexer(projectRoot, config);
-}
-function getSharedIndexer() {
-  return getIndexer();
-}
-function refreshIndexerFromConfig() {
-  if (!sharedProjectRoot) {
-    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
-  }
-  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) {
-    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
-  }
-  return sharedIndexer;
-}
-function getConfigPath() {
-  return resolveWritableProjectConfigPath(sharedProjectRoot);
-}
-function normalizeConfigPathValue(value, baseDir) {
+// src/tools/knowledge-base-paths.ts
+import * as path13 from "path";
+function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path9.isAbsolute(trimmed) ? trimmed : path9.resolve(baseDir, trimmed);
-  return path9.normalize(absolutePath);
+  const absolutePath = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
+  return path13.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));
+  if (!path13.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path13.normalize(trimmed));
   }
-  const relativePath = path9.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path9.isAbsolute(relativePath)) {
-    return normalizeRelativePath(path9.normalize(relativePath || "."));
+  const relativePath = path13.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path13.normalize(relativePath || "."));
   }
-  return path9.normalize(trimmed);
+  return path13.normalize(trimmed);
+}
+function resolveKnowledgeBasePath(value, projectRoot) {
+  return path13.isAbsolute(value) ? value : path13.resolve(projectRoot, value);
+}
+function normalizeKnowledgeBasePath2(value, projectRoot) {
+  return path13.normalize(resolveKnowledgeBasePath(value, projectRoot));
+}
+function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot) {
+  const normalizedInput = path13.normalize(inputPath);
+  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput);
 }
-function normalizeKnowledgeBasePaths(config) {
+function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
+  const normalizedInput = path13.normalize(inputPath);
+  return knowledgeBases.findIndex(
+    (kb) => path13.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
+  );
+}
+
+// src/tools/index.ts
+import { existsSync as existsSync9, realpathSync, statSync as statSync3 } from "fs";
+import * as path15 from "path";
+
+// src/tools/config-state.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import * as path14 from "path";
+function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
-    normalized.knowledgeBases = normalized.knowledgeBases.map((kb) => {
-      return normalizeConfigPathValue(kb, sharedProjectRoot);
-    });
+    normalized.knowledgeBases = normalized.knowledgeBases.map(
+      (kb) => resolveConfigPathValue(kb, projectRoot)
+    );
   }
   return normalized;
 }
-function loadRuntimeConfig() {
-  const rawConfig = loadMergedConfig(sharedProjectRoot);
-  const config = {};
-  if (rawConfig && typeof rawConfig === "object") {
-    for (const key of Object.keys(rawConfig)) {
-      config[key] = rawConfig[key];
-    }
+function toConfigRecord(rawConfig) {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
   }
-  return normalizeKnowledgeBasePaths(config);
+  return { ...rawConfig };
 }
-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 normalizeKnowledgeBasePaths(config);
+function getConfigPath(projectRoot) {
+  return resolveWritableProjectConfigPath(projectRoot);
+}
+function loadRuntimeConfig(projectRoot) {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot)), projectRoot);
 }
-function saveConfig(config) {
-  const configPath = getConfigPath();
-  const configDir = path9.dirname(configPath);
-  const configBaseDir = path9.dirname(configDir);
-  if (!existsSync7(configDir)) {
+function loadEditableConfig(projectRoot) {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadProjectConfigLayer(projectRoot)), projectRoot);
+}
+function saveConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  const configDir = path14.dirname(configPath);
+  const configBaseDir = path14.dirname(configDir);
+  if (!existsSync8(configDir)) {
     mkdirSync3(configDir, { recursive: true });
   }
   const serializableConfig = { ...config };
@@ -10372,6 +10506,53 @@ function saveConfig(config) {
   }
   writeFileSync3(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
+
+// src/tools/index.ts
+import * as os5 from "os";
+function ensureStringArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+var z = tool.schema;
+var indexerMap = /* @__PURE__ */ new Map();
+var defaultProjectRoot = "";
+function initializeTools(projectRoot, config) {
+  defaultProjectRoot = projectRoot;
+  const indexer = new Indexer(projectRoot, config);
+  indexerMap.set(projectRoot, indexer);
+}
+function refreshIndexerForDirectory(projectRoot) {
+  if (!projectRoot) {
+    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
+  }
+  const indexer = new Indexer(projectRoot, parseConfig(loadRuntimeConfig(projectRoot)));
+  indexerMap.set(projectRoot, indexer);
+}
+function shouldForceLocalizeProjectIndex(projectRoot) {
+  const currentConfig = parseConfig(loadRuntimeConfig(projectRoot));
+  if (currentConfig.scope !== "project") {
+    return false;
+  }
+  const localIndexPath = path15.join(projectRoot, ".opencode", "index");
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (!mainRepoRoot) {
+    return false;
+  }
+  const inheritedIndexPath = path15.join(mainRepoRoot, ".opencode", "index");
+  return !existsSync9(localIndexPath) && existsSync9(inheritedIndexPath);
+}
+function getIndexerForProject(directory) {
+  const projectRoot = directory || defaultProjectRoot;
+  if (!projectRoot) {
+    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
+  }
+  let indexer = indexerMap.get(projectRoot);
+  if (!indexer) {
+    const config = parseConfig(loadRuntimeConfig(projectRoot));
+    indexer = new Indexer(projectRoot, config);
+    indexerMap.set(projectRoot, indexer);
+  }
+  return indexer;
+}
 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.",
   args: {
@@ -10381,8 +10562,8 @@ var codebase_peek = tool({
     directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
     chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const results = await indexer.search(args.query, args.limit ?? 10, {
       fileType: args.fileType,
       directory: args.directory,
@@ -10400,16 +10581,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) {
-    let indexer = getIndexer();
+    const projectRoot = context?.worktree || defaultProjectRoot;
+    let indexer = getIndexerForProject(projectRoot);
     if (args.estimateOnly) {
       const estimate = await indexer.estimateCost();
       return formatCostEstimate(estimate);
     }
     if (args.force) {
-      if (shouldForceLocalizeProjectIndex()) {
-        materializeLocalProjectConfig(sharedProjectRoot, loadProjectConfigLayer(sharedProjectRoot));
-        refreshIndexerFromConfig();
-        indexer = getIndexer();
+      if (shouldForceLocalizeProjectIndex(projectRoot)) {
+        materializeLocalProjectConfig(projectRoot, loadProjectConfigLayer(projectRoot));
+        refreshIndexerForDirectory(projectRoot);
+        indexer = getIndexerForProject(projectRoot);
       }
       await indexer.clearIndex();
     }
@@ -10432,8 +10614,8 @@ var index_codebase = tool({
 var index_status = tool({
   description: "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
   args: {},
-  async execute() {
-    const indexer = getIndexer();
+  async execute(_args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const status = await indexer.getStatus();
     return formatStatus(status);
   }
@@ -10441,8 +10623,8 @@ var index_status = tool({
 var index_health_check = tool({
   description: "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
   args: {},
-  async execute() {
-    const indexer = getIndexer();
+  async execute(_args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const result = await indexer.healthCheck();
     return formatHealthCheck(result);
   }
@@ -10450,8 +10632,8 @@ var index_health_check = tool({
 var index_metrics = tool({
   description: "Get metrics and performance statistics for the codebase index. Shows indexing stats, search timings, cache hit rates, and API usage. Requires debug.enabled=true and debug.metrics=true in config.",
   args: {},
-  async execute() {
-    const indexer = getIndexer();
+  async execute(_args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const logger = indexer.getLogger();
     if (!logger.isEnabled()) {
       return 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```';
@@ -10469,8 +10651,8 @@ var index_logs = tool({
     category: z.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
     level: z.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const logger = indexer.getLogger();
     if (!logger.isEnabled()) {
       return 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```';
@@ -10496,8 +10678,8 @@ var find_similar = tool({
     chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
     excludeFile: z.string().optional().describe("Exclude results from this file path (useful when searching for duplicates of code from a specific file)")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const results = await indexer.findSimilar(args.code, args.limit, {
       fileType: args.fileType,
       directory: args.directory,
@@ -10520,8 +10702,8 @@ var codebase_search = tool({
     chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
     contextLines: z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const results = await indexer.search(args.query, args.limit ?? 5, {
       fileType: args.fileType,
       directory: args.directory,
@@ -10542,8 +10724,8 @@ var implementation_lookup = tool({
     fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
     directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     const results = await indexer.search(args.query, args.limit ?? 5, {
       fileType: args.fileType,
       directory: args.directory,
@@ -10559,8 +10741,8 @@ var call_graph = tool({
     direction: z.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
     symbolId: z.string().optional().describe("Symbol ID (required for 'callees' direction, returned by previous call_graph queries)")
   },
-  async execute(args) {
-    const indexer = getIndexer();
+  async execute(args, context) {
+    const indexer = getIndexerForProject(context?.worktree);
     if (args.direction === "callees") {
       if (!args.symbolId) {
         return "Error: 'symbolId' is required when direction is 'callees'. First use direction='callers' to find the symbol ID.";
@@ -10589,38 +10771,67 @@ var add_knowledge_base = tool({
   args: {
     path: z.string().describe("Path to the folder to add as a knowledge base (absolute or relative to project root)")
   },
-  async execute(args) {
+  async execute(args, context) {
+    const projectRoot = context?.worktree || defaultProjectRoot;
     const inputPath = args.path.trim();
-    const resolvedPath = path9.isAbsolute(inputPath) ? inputPath : path9.resolve(sharedProjectRoot, inputPath);
-    if (!existsSync7(resolvedPath)) {
-      return `Error: Directory does not exist: ${resolvedPath}`;
+    const normalizedPath = path15.resolve(
+      path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, projectRoot)
+    );
+    if (!existsSync9(normalizedPath)) {
+      return `Error: Directory does not exist: ${normalizedPath}`;
+    }
+    let realPath;
+    try {
+      realPath = realpathSync(normalizedPath);
+    } catch {
+      return `Error: Cannot resolve path: ${normalizedPath}`;
+    }
+    const blockedPrefixes = [
+      "/etc",
+      "/proc",
+      "/sys",
+      "/dev",
+      "/boot",
+      "/root",
+      "/var/run",
+      "/var/log"
+    ];
+    const homeDir = os5.homedir();
+    const sensitiveDotDirs = [".ssh", ".gnupg", ".aws", ".config/gcloud", ".docker", ".kube"];
+    for (const prefix of blockedPrefixes) {
+      if (realPath === prefix || realPath.startsWith(prefix + "/")) {
+        return `Error: Adding system directory as knowledge base is not allowed: ${normalizedPath}`;
+      }
+    }
+    for (const dotDir of sensitiveDotDirs) {
+      const sensitiveDir = path15.join(homeDir, dotDir);
+      if (realPath === sensitiveDir || realPath.startsWith(sensitiveDir + "/")) {
+        return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
+      }
     }
     try {
-      const stat4 = statSync2(resolvedPath);
+      const stat4 = statSync3(normalizedPath);
       if (!stat4.isDirectory()) {
-        return `Error: Path is not a directory: ${resolvedPath}`;
+        return `Error: Path is not a directory: ${normalizedPath}`;
       }
     } catch (error) {
-      return `Error: Cannot access directory: ${resolvedPath} - ${error instanceof Error ? error.message : String(error)}`;
+      return `Error: Cannot access directory: ${normalizedPath} - ${error instanceof Error ? error.message : String(error)}`;
     }
-    const config = loadEditableConfig();
-    const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
-    const normalizedPath = path9.normalize(resolvedPath);
-    const alreadyExists = knowledgeBases.some(
-      (kb) => path9.normalize(path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb)) === normalizedPath
-    );
+    const config = loadEditableConfig(projectRoot);
+    const knowledgeBases = ensureStringArray(config.knowledgeBases);
+    const alreadyExists = hasMatchingKnowledgeBasePath(knowledgeBases, normalizedPath, projectRoot);
     if (alreadyExists) {
-      return `Knowledge base already configured: ${resolvedPath}`;
+      return `Knowledge base already configured: ${normalizedPath}`;
     }
-    knowledgeBases.push(resolvedPath);
+    knowledgeBases.push(normalizedPath);
     config.knowledgeBases = knowledgeBases;
-    saveConfig(config);
-    refreshIndexerFromConfig();
-    let result = `${resolvedPath}
+    saveConfig(projectRoot, config);
+    refreshIndexerForDirectory(projectRoot);
+    let result = `${normalizedPath}
 `;
     result += `Total knowledge bases: ${knowledgeBases.length}
 `;
-    result += `Config saved to: ${getConfigPath()}
+    result += `Config saved to: ${getConfigPath(projectRoot)}
 `;
     result += `
 Run /index to rebuild the index with the new knowledge base.`;
@@ -10630,9 +10841,10 @@ Run /index to rebuild the index with the new knowledge base.`;
 var list_knowledge_bases = tool({
   description: "List all configured knowledge base folders that are indexed alongside the main project.",
   args: {},
-  async execute() {
-    const config = loadRuntimeConfig();
-    const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+  async execute(_args, context) {
+    const projectRoot = context?.worktree || defaultProjectRoot;
+    const config = loadRuntimeConfig(projectRoot);
+    const knowledgeBases = ensureStringArray(config.knowledgeBases);
     if (knowledgeBases.length === 0) {
       return "No knowledge bases configured. Use add_knowledge_base to add folders.";
     }
@@ -10641,8 +10853,8 @@ var list_knowledge_bases = tool({
 `;
     for (let i = 0; i < knowledgeBases.length; i++) {
       const kb = knowledgeBases[i];
-      const resolvedPath = path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb);
-      const exists = existsSync7(resolvedPath);
+      const resolvedPath = resolveKnowledgeBasePath(kb, projectRoot);
+      const exists = existsSync9(resolvedPath);
       result += `[${i + 1}] ${kb}
 `;
       result += `    Resolved: ${resolvedPath}
@@ -10651,7 +10863,7 @@ var list_knowledge_bases = tool({
 `;
       if (exists) {
         try {
-          const stat4 = statSync2(resolvedPath);
+          const stat4 = statSync3(resolvedPath);
           result += `    Type: ${stat4.isDirectory() ? "Directory" : "File"}
 `;
         } catch {
@@ -10659,7 +10871,7 @@ var list_knowledge_bases = tool({
       }
       result += "\n";
     }
-    result += `Config file: ${getConfigPath()}`;
+    result += `Config file: ${getConfigPath(projectRoot)}`;
     return result;
   }
 });
@@ -10668,17 +10880,15 @@ var remove_knowledge_base = tool({
   args: {
     path: z.string().describe("Path of the knowledge base to remove (must match the configured path exactly)")
   },
-  async execute(args) {
+  async execute(args, context) {
+    const projectRoot = context?.worktree || defaultProjectRoot;
     const inputPath = args.path.trim();
-    const config = loadEditableConfig();
-    const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+    const config = loadEditableConfig(projectRoot);
+    const knowledgeBases = ensureStringArray(config.knowledgeBases);
     if (knowledgeBases.length === 0) {
       return "No knowledge bases configured.";
     }
-    const normalizedInput = path9.normalize(inputPath);
-    const index = knowledgeBases.findIndex(
-      (kb) => path9.normalize(kb) === normalizedInput || path9.normalize(path9.isAbsolute(kb) ? kb : path9.resolve(sharedProjectRoot, kb)) === normalizedInput
-    );
+    const index = findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot);
     if (index === -1) {
       let result2 = `Knowledge base not found: ${inputPath}
 
@@ -10693,14 +10903,14 @@ var remove_knowledge_base = tool({
     }
     const removed = knowledgeBases.splice(index, 1)[0];
     config.knowledgeBases = knowledgeBases;
-    saveConfig(config);
-    refreshIndexerFromConfig();
+    saveConfig(projectRoot, config);
+    refreshIndexerForDirectory(projectRoot);
     let result = `Removed: ${removed}
 
 `;
     result += `Remaining knowledge bases: ${knowledgeBases.length}
 `;
-    result += `Config saved to: ${getConfigPath()}
+    result += `Config saved to: ${getConfigPath(projectRoot)}
 `;
     result += `
 Run /index to rebuild the index without the removed knowledge base.`;
@@ -10709,8 +10919,8 @@ Run /index to rebuild the index without the removed knowledge base.`;
 });
 
 // src/commands/loader.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import * as path10 from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
+import * as path16 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -10731,15 +10941,21 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!existsSync8(commandsDir)) {
+  if (!existsSync10(commandsDir)) {
     return commands;
   }
   const files = readdirSync2(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path10.join(commandsDir, file);
-    const content = readFileSync6(filePath, "utf-8");
+    const filePath = path16.join(commandsDir, file);
+    let content;
+    try {
+      content = readFileSync7(filePath, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load command file ${filePath}: ${message}`);
+    }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path10.basename(file, ".md");
+    const name = path16.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -10749,7 +10965,7 @@ function loadCommandsFromDirectory(commandsDir) {
   return commands;
 }
 
-// src/routing-hints.ts
+// src/routing-hints-patterns.ts
 var EXTERNAL_HINTS = [
   "docs",
   "documentation",
@@ -10840,6 +11056,8 @@ var SNAKE_PATTERN = /\b[a-z0-9]+_[a-z0-9_]+\b/g;
 var KEBAB_PATTERN = /\b[a-z0-9]+-[a-z0-9-]+\b/g;
 var BACKTICK_IDENTIFIER_PATTERN = /`([^`]+)`/g;
 var BACKTICK_IDENTIFIER_PRESENCE_PATTERN = /`([^`]+)`/;
+var DOUBLE_QUOTED_PATTERN = /"[^"]+"/;
+var SINGLE_QUOTED_PATTERN = /'[^']+'/;
 function normalizeText(text) {
   return text.trim().replace(/\s+/g, " ");
 }
@@ -10852,6 +11070,21 @@ function countWords(text) {
   }
   return text.split(/\s+/).filter(Boolean).length;
 }
+function isExternalLookup(text) {
+  return URL_PATTERN.test(text) || includesHint(text, EXTERNAL_HINTS);
+}
+function hasConceptualDiscoveryHint(text) {
+  return includesHint(text, CONCEPTUAL_DISCOVERY_HINTS);
+}
+function hasDefinitionHint(text) {
+  return includesHint(text, DEFINITION_HINTS);
+}
+function hasExactMatchHint(text) {
+  return includesHint(text, EXACT_MATCH_HINTS);
+}
+function hasNonDiscoveryHint(text) {
+  return includesHint(text, NON_DISCOVERY_HINTS);
+}
 function hasIdentifierShape(text) {
   const matches = [
     ...text.match(CAMEL_OR_PASCAL_PATTERN) ?? [],
@@ -10867,11 +11100,13 @@ function hasIdentifierShape(text) {
   });
 }
 function containsQuotedIdentifier(text) {
-  return BACKTICK_IDENTIFIER_PRESENCE_PATTERN.test(text) || /"[^"]+"/.test(text) || /'[^']+'/.test(text);
+  return BACKTICK_IDENTIFIER_PRESENCE_PATTERN.test(text) || DOUBLE_QUOTED_PATTERN.test(text) || SINGLE_QUOTED_PATTERN.test(text);
 }
 function looksLikeDirectPath(text) {
   return FILE_PATH_PATTERN.test(text) || /\b[a-z0-9_-]+\.(ts|tsx|js|jsx|rs|py|go|java|json|md|yaml|yml)\b/i.test(text);
 }
+
+// src/routing-hints.ts
 function extractUserText(parts) {
   return normalizeText(
     parts.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join(" ")
@@ -10887,21 +11122,21 @@ function assessRoutingIntent(text) {
       reason: "empty_text"
     };
   }
-  if (URL_PATTERN.test(lowered) || includesHint(lowered, EXTERNAL_HINTS)) {
+  if (isExternalLookup(lowered)) {
     return {
       intent: "external",
       text: normalizedText,
       reason: "external_lookup"
     };
   }
-  const hasConceptualHint = includesHint(lowered, CONCEPTUAL_DISCOVERY_HINTS);
-  const hasDefinitionHint = includesHint(lowered, DEFINITION_HINTS);
-  const hasExactMatchHint = includesHint(lowered, EXACT_MATCH_HINTS);
-  const hasNonDiscoveryHint = includesHint(lowered, NON_DISCOVERY_HINTS);
+  const matchedConceptualHint = hasConceptualDiscoveryHint(lowered);
+  const matchedDefinitionHint = hasDefinitionHint(lowered);
+  const matchedExactMatchHint = hasExactMatchHint(lowered);
+  const matchedNonDiscoveryHint = hasNonDiscoveryHint(lowered);
   const hasIdentifier = hasIdentifierShape(normalizedText);
   const hasQuotedIdentifier = containsQuotedIdentifier(normalizedText);
   const shortQuery = countWords(lowered) <= 10;
-  if (hasNonDiscoveryHint && !hasConceptualHint) {
+  if (matchedNonDiscoveryHint && !matchedConceptualHint) {
     return {
       intent: "other",
       text: normalizedText,
@@ -10915,21 +11150,21 @@ function assessRoutingIntent(text) {
       reason: "direct_path_reference"
     };
   }
-  if ((hasDefinitionHint || lowered.includes("where is") || lowered.includes("where are")) && (lowered.includes("defined") || lowered.includes("definition"))) {
+  if ((matchedDefinitionHint || lowered.includes("where is") || lowered.includes("where are")) && (lowered.includes("defined") || lowered.includes("definition"))) {
     return {
       intent: "definition_lookup",
       text: normalizedText,
       reason: "definition_lookup_request"
     };
   }
-  if ((hasExactMatchHint || hasQuotedIdentifier || hasIdentifier) && !hasConceptualHint && shortQuery) {
+  if ((matchedExactMatchHint || hasQuotedIdentifier || hasIdentifier) && !matchedConceptualHint && shortQuery) {
     return {
       intent: "exact_identifier",
       text: normalizedText,
-      reason: hasExactMatchHint || hasQuotedIdentifier ? "exact_match_request" : "identifier_shaped_query"
+      reason: matchedExactMatchHint || hasQuotedIdentifier ? "exact_match_request" : "identifier_shaped_query"
     };
   }
-  if (hasConceptualHint) {
+  if (matchedConceptualHint) {
     return {
       intent: "local_conceptual",
       text: normalizedText,
@@ -11018,33 +11253,55 @@ var RoutingHintController = class {
 };
 
 // src/index.ts
-var activeWatcher = null;
-function replaceActiveWatcher(nextWatcher) {
-  activeWatcher?.stop();
-  activeWatcher = nextWatcher;
+var activeWatchers = /* @__PURE__ */ new Map();
+function replaceActiveWatcher(projectRoot, nextWatcher) {
+  const existing = activeWatchers.get(projectRoot);
+  if (existing) {
+    existing.stop();
+    activeWatchers.delete(projectRoot);
+  }
+  if (nextWatcher) {
+    activeWatchers.set(projectRoot, nextWatcher);
+  }
 }
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path11.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path17.dirname(fileURLToPath2(import.meta.url));
+  }
+  return path17.join(currentDir, "..", "commands");
+}
+function appendRoutingHints(output, hints, preferredRole) {
+  const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
+  if (Array.isArray(preferredBucket)) {
+    preferredBucket.push(...hints);
+    return;
+  }
+  if (Array.isArray(output.system)) {
+    output.system.push(...hints);
   }
-  return path11.join(currentDir, "..", "commands");
 }
-var plugin = async ({ directory }) => {
+var plugin = async ({ directory, worktree }) => {
   try {
-    const projectRoot = directory;
+    const projectRoot = worktree || directory;
     const rawConfig = loadMergedConfig(projectRoot);
     const config = parseConfig(rawConfig);
     initializeTools(projectRoot, config);
-    const indexer = getSharedIndexer();
-    const routingHints = config.search.routingHints ? new RoutingHintController(() => indexer.getStatus()) : null;
-    const isValidProject = !config.indexing.requireProjectMarker || hasProjectMarker(projectRoot);
-    if (!isValidProject) {
+    const getProjectIndexer = () => getIndexerForProject(projectRoot);
+    const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus()) : null;
+    const isHomeDir = path17.resolve(projectRoot) === path17.resolve(os6.homedir());
+    const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(projectRoot));
+    if (isHomeDir) {
+      console.warn(
+        `[codebase-index] Refusing to watch or index home directory "${projectRoot}". Open a specific project directory instead.`
+      );
+    } else if (!isValidProject) {
       console.warn(
         `[codebase-index] Skipping file watching and auto-indexing: no project marker found in "${projectRoot}". Set "indexing.requireProjectMarker": false in config to override.`
       );
     }
     if (config.indexing.autoIndex && isValidProject) {
+      const indexer = getProjectIndexer();
       indexer.initialize().then(() => {
         indexer.index().catch(() => {
         });
@@ -11052,9 +11309,9 @@ var plugin = async ({ directory }) => {
       });
     }
     if (config.indexing.watchFiles && isValidProject) {
-      replaceActiveWatcher(createWatcherWithIndexer(getSharedIndexer, projectRoot, config));
+      replaceActiveWatcher(projectRoot, createWatcherWithIndexer(getProjectIndexer, projectRoot, config));
     } else {
-      replaceActiveWatcher(null);
+      replaceActiveWatcher(projectRoot, null);
     }
     return {
       tool: {
@@ -11076,8 +11333,18 @@ var plugin = async ({ directory }) => {
         routingHints?.observeUserMessage(input.sessionID, output.parts);
       },
       async "experimental.chat.system.transform"(input, output) {
+        if (config.search.routingHintRole !== "system") {
+          return;
+        }
+        const hints = await routingHints?.getSystemHints(input.sessionID) ?? [];
+        appendRoutingHints(output, hints, "system");
+      },
+      async "experimental.chat.developer.transform"(input, output) {
+        if (config.search.routingHintRole !== "developer") {
+          return;
+        }
         const hints = await routingHints?.getSystemHints(input.sessionID) ?? [];
-        output.system.push(...hints);
+        appendRoutingHints(output, hints, "developer");
       },
       async "tool.execute.after"(input) {
         routingHints?.markToolUsed(input.sessionID, input.tool);
@@ -11091,8 +11358,8 @@ var plugin = async ({ directory }) => {
         }
       }
     };
-  } catch (error) {
-    console.error("[codebase-index] Failed to initialize plugin:", error);
+  } catch {
+    console.error("[codebase-index] Failed to initialize plugin (check config and network)");
     return {
       tool: void 0,
       async config() {