opencode-codebase-index 0.8.1 → 0.9.0

package/dist/index.cjs

@@ -329,7 +329,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;
@@ -338,7 +338,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;
           }
@@ -359,17 +359,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}"`,
@@ -378,7 +378,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 {
@@ -408,19 +408,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(
@@ -433,18 +433,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,
@@ -452,29 +452,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.
@@ -657,7 +657,7 @@ __export(index_exports, {
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
-var path11 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 
 // src/config/constants.ts
@@ -674,7 +674,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{md,mdx}",
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
-  "**/*.zig"
+  "**/*.zig",
+  "**/*.gd"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -773,28 +774,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,
@@ -826,12 +806,6 @@ function getDefaultSearchConfig() {
     routingHints: true
   };
 }
-function isValidFusionStrategy(value) {
-  return value === "weighted" || value === "rrf";
-}
-function isValidRerankerProvider(value) {
-  return value === "cohere" || value === "jina" || value === "custom";
-}
 function getDefaultRerankerBaseUrl(provider) {
   switch (provider) {
     case "cohere":
@@ -854,8 +828,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);
 }
@@ -883,6 +886,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");
@@ -937,9 +942,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;
@@ -972,7 +977,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];
       }
@@ -1035,16 +1040,20 @@ var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
 );
 
 // src/config/merger.ts
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var os2 = __toESM(require("os"), 1);
-var path3 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/config/paths.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var os = __toESM(require("os"), 1);
-var path2 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 
 // src/git/index.ts
+var import_fs2 = require("fs");
+var path2 = __toESM(require("path"), 1);
+
+// src/git/refs.ts
 var import_fs = require("fs");
 var path = __toESM(require("path"), 1);
 function readPackedRefs(gitDir) {
@@ -1077,38 +1086,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 (!(0, import_fs.existsSync)(mainRepoRoot)) {
+  const mainRepoRoot = path2.dirname(commonGitDir);
+  if (!(0, import_fs2.existsSync)(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 (!(0, import_fs.existsSync)(gitPath)) {
+  const gitPath = path2.join(repoRoot, ".git");
+  if (!(0, import_fs2.existsSync)(gitPath)) {
     return null;
   }
   try {
-    const stat4 = (0, import_fs.statSync)(gitPath);
+    const stat4 = (0, import_fs2.statSync)(gitPath);
     if (stat4.isDirectory()) {
       return gitPath;
     }
     if (stat4.isFile()) {
-      const content = (0, import_fs.readFileSync)(gitPath, "utf-8").trim();
+      const content = (0, import_fs2.readFileSync)(gitPath, "utf-8").trim();
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
         const gitdir = match[1];
-        const resolvedPath = path.isAbsolute(gitdir) ? gitdir : path.resolve(repoRoot, gitdir);
-        if ((0, import_fs.existsSync)(resolvedPath)) {
+        const resolvedPath = path2.isAbsolute(gitdir) ? gitdir : path2.resolve(repoRoot, gitdir);
+        if ((0, import_fs2.existsSync)(resolvedPath)) {
           return resolvedPath;
         }
       }
@@ -1125,12 +1136,12 @@ function getCurrentBranch(repoRoot) {
   if (!gitDir) {
     return null;
   }
-  const headPath = path.join(gitDir, "HEAD");
-  if (!(0, import_fs.existsSync)(headPath)) {
+  const headPath = path2.join(gitDir, "HEAD");
+  if (!(0, import_fs2.existsSync)(headPath)) {
     return null;
   }
   try {
-    const headContent = (0, import_fs.readFileSync)(headPath, "utf-8").trim();
+    const headContent = (0, import_fs2.readFileSync)(headPath, "utf-8").trim();
     const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
     if (match) {
       return match[1];
@@ -1149,8 +1160,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 ((0, import_fs.existsSync)(refPath)) {
+      const refPath = path2.join(refStoreDir, "refs", "heads", candidate);
+      if ((0, import_fs2.existsSync)(refPath)) {
         return candidate;
       }
       const packedRefs = readPackedRefs(refStoreDir);
@@ -1170,44 +1181,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 (0, import_fs2.existsSync)(fallbackPath) ? fallbackPath : null;
+  const fallbackPath = path3.join(mainRepoRoot, relativePath);
+  return (0, import_fs3.existsSync)(fallbackPath) ? fallbackPath : null;
 }
 function hasProjectConfig(projectRoot) {
-  return (0, import_fs2.existsSync)(path2.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
+  return (0, import_fs3.existsSync)(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 ((0, import_fs2.existsSync)(localConfigPath)) {
+  const localConfigPath = path3.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
+  if ((0, import_fs3.existsSync)(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 ((0, import_fs2.existsSync)(localIndexPath)) {
+  const localIndexPath = path3.join(projectRoot, PROJECT_INDEX_RELATIVE_PATH);
+  if ((0, import_fs3.existsSync)(localIndexPath)) {
     return localIndexPath;
   }
   if (hasProjectConfig(projectRoot)) {
@@ -1216,23 +1227,30 @@ function resolveProjectIndexPath(projectRoot, scope) {
   return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
 }
 
-// src/config/merger.ts
-function loadJsonFile(filePath) {
-  try {
-    if ((0, import_fs3.existsSync)(filePath)) {
-      const content = (0, import_fs3.readFileSync)(filePath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return null;
+// src/config/rebase.ts
+var path5 = __toESM(require("path"), 1);
+
+// src/utils/paths.ts
+var path4 = __toESM(require("path"), 1);
+function normalizePathSeparators(value) {
+  return value.replace(/\\/g, "/");
+}
+function isHiddenPathSegment(part) {
+  return part.startsWith(".") && part !== "." && part !== "..";
 }
-function normalizeRelativeConfigPath(candidate) {
-  return candidate.replace(/\\/g, "/");
+function isBuildPathSegment(part) {
+  return part.toLowerCase().includes("build");
+}
+function hasFilteredPathSegment(relativePath, separator = path4.sep) {
+  return relativePath.split(separator).some(
+    (part) => isHiddenPathSegment(part) || isBuildPathSegment(part)
+  );
 }
+
+// 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)) {
@@ -1243,23 +1261,107 @@ 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 (!(0, import_fs4.existsSync)(filePath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_fs4.readFileSync)(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");
-  (0, import_fs3.mkdirSync)(path3.dirname(localConfigPath), { recursive: true });
-  (0, import_fs3.writeFileSync)(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
+  const localConfigPath = path6.join(projectRoot, ".opencode", "codebase-index.json");
+  (0, import_fs4.mkdirSync)(path6.dirname(localConfigPath), { recursive: true });
+  (0, import_fs4.writeFileSync)(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
   return localConfigPath;
 }
 function loadProjectConfigLayer(projectRoot) {
@@ -1269,7 +1371,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,
@@ -1281,10 +1383,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 {};
   }
@@ -1294,60 +1408,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];
@@ -1356,13 +1426,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;
 }
 
@@ -1456,7 +1524,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path12) => statMethod(path12, { bigint: true });
+      this._stat = (path18) => statMethod(path18, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1481,8 +1549,8 @@ var ReaddirpStream = class extends import_node_stream.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)
@@ -1522,20 +1590,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path12, depth) {
+  async _exploreDir(path18, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path12, this._rdOptions);
+      files = await (0, import_promises.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 = (0, import_node_path.resolve)((0, import_node_path.join)(path12, basename5));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path18, basename5));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1935,16 +2003,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 (0, import_node_fs.watch)(path12, {
+    return (0, import_node_fs.watch)(path18, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1960,12 +2028,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);
@@ -1976,7 +2044,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,
@@ -1991,7 +2059,7 @@ var setFsWatchListener = (path12, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path12, "r");
+          const fd = await (0, import_promises2.open)(path18, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -2022,7 +2090,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;
@@ -2044,7 +2112,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));
         }
       })
     };
@@ -2074,13 +2142,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
     };
@@ -2090,12 +2158,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
@@ -2117,7 +2185,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) {
@@ -2131,11 +2199,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;
           }
@@ -2167,7 +2235,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;
     }
@@ -2177,7 +2245,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path12);
+        linkPath = await (0, import_promises2.realpath)(path18);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -2187,12 +2255,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;
@@ -2222,9 +2290,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) {
@@ -2233,11 +2301,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((resolve11, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -2246,7 +2314,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve9(void 0);
+        resolve11(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -2303,13 +2371,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);
@@ -2325,8 +2393,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path12);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path12) : path12;
+        const absPath = sp.resolve(path18);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -2336,29 +2404,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path12) : path12;
+        const targetPath = follow ? await (0, import_promises2.realpath)(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;
       }
     }
   }
@@ -2401,24 +2469,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;
     }
   }
@@ -2456,19 +2524,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 {
@@ -2533,10 +2601,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 = [];
@@ -2676,20 +2744,20 @@ var FSWatcher = class extends import_node_events.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;
@@ -2711,17 +2779,17 @@ var FSWatcher = class extends import_node_events.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
         });
       }
@@ -2785,38 +2853,38 @@ var FSWatcher = class extends import_node_events.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) {
@@ -2834,16 +2902,16 @@ var FSWatcher = class extends import_node_events.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 (0, import_promises3.stat)(fullPath);
@@ -2874,23 +2942,23 @@ var FSWatcher = class extends import_node_events.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);
@@ -2898,7 +2966,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path12, thr);
+    action.set(path18, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2912,44 +2980,44 @@ var FSWatcher = class extends import_node_events.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) {
       (0, import_node_fs2.stat)(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;
         }
@@ -2960,8 +3028,8 @@ var FSWatcher = class extends import_node_events.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;
@@ -2971,17 +3039,17 @@ var FSWatcher = class extends import_node_events.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
   // -----------------
@@ -3013,63 +3081,63 @@ var FSWatcher = class extends import_node_events.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);
   }
@@ -3098,13 +3166,13 @@ function watch(paths, options = {}) {
 }
 var chokidar_default = { watch, FSWatcher };
 
-// src/watcher/index.ts
-var path5 = __toESM(require("path"), 1);
+// src/watcher/file-watcher.ts
+var path8 = __toESM(require("path"), 1);
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
-var import_fs4 = require("fs");
-var path4 = __toESM(require("path"), 1);
+var import_fs5 = require("fs");
+var path7 = __toESM(require("path"), 1);
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -3123,7 +3191,7 @@ var PROJECT_MARKERS = [
 ];
 function hasProjectMarker(projectRoot) {
   for (const marker of PROJECT_MARKERS) {
-    if ((0, import_fs4.existsSync)(path4.join(projectRoot, marker))) {
+    if ((0, import_fs5.existsSync)(path7.join(projectRoot, marker))) {
       return true;
     }
   }
@@ -3149,23 +3217,17 @@ function createIgnoreFilter(projectRoot) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path4.join(projectRoot, ".gitignore");
-  if ((0, import_fs4.existsSync)(gitignorePath)) {
-    const gitignoreContent = (0, import_fs4.readFileSync)(gitignorePath, "utf-8");
+  const gitignorePath = path7.join(projectRoot, ".gitignore");
+  if ((0, import_fs5.existsSync)(gitignorePath)) {
+    const gitignoreContent = (0, import_fs5.readFileSync)(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;
@@ -3198,19 +3260,19 @@ function matchGlob(filePath, pattern) {
   return regex.test(filePath);
 }
 async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped, options, currentDepth = 0) {
-  const entries = await import_fs4.promises.readdir(dir, { withFileTypes: true });
+  const entries = await import_fs5.promises.readdir(dir, { withFileTypes: true });
   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;
     }
@@ -3223,7 +3285,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     if (entry.isDirectory()) {
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
-      const stat4 = await import_fs4.promises.stat(fullPath);
+      const stat4 = await import_fs5.promises.stat(fullPath);
       if (stat4.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
@@ -3252,7 +3314,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) {
@@ -3292,14 +3354,14 @@ 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);
     }
     for (const resolvedKbRoot of normalizedRoots) {
       try {
-        const stat4 = await import_fs4.promises.stat(resolvedKbRoot);
+        const stat4 = await import_fs5.promises.stat(resolvedKbRoot);
         if (!stat4.isDirectory()) {
           skipped.push({ path: resolvedKbRoot, reason: "excluded" });
           continue;
@@ -3326,7 +3388,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;
@@ -3347,16 +3409,10 @@ 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 (ignoreFilter.ignores(relativePath)) {
           return true;
@@ -3401,7 +3457,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 {
@@ -3426,6 +3482,9 @@ var FileWatcher = class {
     return this.watcher !== null;
   }
 };
+
+// src/watcher/git-head-watcher.ts
+var path9 = __toESM(require("path"), 1);
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -3447,7 +3506,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,
@@ -3499,6 +3558,8 @@ var GitHeadWatcher = class {
     return this.watcher !== null;
   }
 };
+
+// src/watcher/index.ts
 function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
   const fileWatcher = new FileWatcher(projectRoot, config);
   fileWatcher.start(async (changes) => {
@@ -3532,8 +3593,8 @@ function createWatcherWithIndexer(getIndexer2, projectRoot, config) {
 var import_plugin = require("@opencode-ai/plugin");
 
 // src/indexer/index.ts
-var import_fs6 = require("fs");
-var path8 = __toESM(require("path"), 1);
+var import_fs7 = require("fs");
+var path12 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
 
 // node_modules/eventemitter3/index.mjs
@@ -3558,7 +3619,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve9, reject) => {
+  const wrappedPromise = new Promise((resolve11, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -3572,7 +3633,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve9, reject);
+    promise.then(resolve11, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -3580,7 +3641,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve9(fallback());
+          resolve11(fallback());
         } catch (error) {
           reject(error);
         }
@@ -3590,7 +3651,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve9();
+        resolve11();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -3992,7 +4053,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((resolve11, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -4032,7 +4093,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve9(result);
+          resolve11(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -4220,13 +4281,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve11) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve9();
+        resolve11();
       };
       this.on(event, listener);
     });
@@ -4512,7 +4573,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((resolve11, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -4520,7 +4581,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve9();
+        resolve11();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -4581,17 +4642,17 @@ async function pRetry(input, options = {}) {
 }
 
 // src/embeddings/detector.ts
-var import_fs5 = require("fs");
-var path6 = __toESM(require("path"), 1);
+var import_fs6 = require("fs");
+var path10 = __toESM(require("path"), 1);
 var os3 = __toESM(require("os"), 1);
 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 ((0, import_fs5.existsSync)(authPath)) {
-      return JSON.parse((0, import_fs5.readFileSync)(authPath, "utf-8"));
+    if ((0, import_fs6.existsSync)(authPath)) {
+      return JSON.parse((0, import_fs6.readFileSync)(authPath, "utf-8"));
     }
   } catch {
   }
@@ -4658,7 +4719,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,
@@ -4754,42 +4816,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 {
@@ -4804,69 +4836,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 {
@@ -4874,16 +5041,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);
@@ -4904,12 +5069,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) {
@@ -4926,17 +5085,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();
@@ -4951,29 +5111,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);
@@ -5037,166 +5181,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) {
@@ -5232,7 +5307,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);
@@ -5306,20 +5384,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
 `;
@@ -5331,9 +5410,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 = {
@@ -5400,6 +5476,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);
@@ -5438,89 +5518,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 };
@@ -5627,7 +5725,7 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-var path7 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 var os4 = __toESM(require("os"), 1);
 var module2 = __toESM(require("module"), 1);
 var import_url = require("url");
@@ -5652,19 +5750,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import_meta !== "undefined" && import_meta.url) {
-    currentDir = path7.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    currentDir = path11.dirname((0, import_url.fileURLToPath)(import_meta.url));
     requireTarget = import_meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = 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 = module2.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -6234,7 +6332,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.getStats();
   }
-  // ── Symbol methods ──────────────────────────────────────────────
   upsertSymbol(symbol) {
     this.throwIfClosed();
     this.inner.upsertSymbol(symbol);
@@ -6264,7 +6361,6 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
   }
-  // ── Call Edge methods ────────────────────────────────────────────
   upsertCallEdge(edge) {
     this.throwIfClosed();
     this.inner.upsertCallEdge(edge);
@@ -6294,7 +6390,6 @@ var Database = class {
     this.throwIfClosed();
     this.inner.resolveCallEdge(edgeId, toSymbolId);
   }
-  // ── Branch Symbol methods ────────────────────────────────────────
   addSymbolsToBranch(branch, symbolIds) {
     this.throwIfClosed();
     this.inner.addSymbolsToBranch(branch, symbolIds);
@@ -6327,7 +6422,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();
@@ -6339,7 +6433,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",
@@ -6366,7 +6460,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);
@@ -6568,9 +6670,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();
@@ -7623,22 +7725,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 (!(0, import_fs7.existsSync)(this.fileHashCachePath)) {
+      return;
+    }
     try {
-      if ((0, import_fs6.existsSync)(this.fileHashCachePath)) {
-        const data = (0, import_fs6.readFileSync)(this.fileHashCachePath, "utf-8");
-        const parsed = JSON.parse(data);
-        this.fileHashCache = new Map(Object.entries(parsed));
-      }
-    } catch {
+      const data = (0, import_fs7.readFileSync)(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();
     }
   }
@@ -7651,14 +7759,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    (0, import_fs6.mkdirSync)(path8.dirname(targetPath), { recursive: true });
-    (0, import_fs6.writeFileSync)(tempPath, data);
-    (0, import_fs6.renameSync)(tempPath, targetPath);
+    (0, import_fs7.mkdirSync)(path12.dirname(targetPath), { recursive: true });
+    (0, import_fs7.writeFileSync)(tempPath, data);
+    (0, import_fs7.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);
   }
@@ -7667,22 +7775,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() {
@@ -7776,7 +7884,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)
@@ -7799,7 +7907,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);
@@ -7883,7 +7991,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(
@@ -7917,7 +8025,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))
     );
@@ -7986,24 +8094,24 @@ var Indexer = class {
     };
   }
   checkForInterruptedIndexing() {
-    return (0, import_fs6.existsSync)(this.indexingLockPath);
+    return (0, import_fs7.existsSync)(this.indexingLockPath);
   }
   acquireIndexingLock() {
     const lockData = {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       pid: process.pid
     };
-    (0, import_fs6.writeFileSync)(this.indexingLockPath, JSON.stringify(lockData));
+    (0, import_fs7.writeFileSync)(this.indexingLockPath, JSON.stringify(lockData));
   }
   releaseIndexingLock() {
-    if ((0, import_fs6.existsSync)(this.indexingLockPath)) {
-      (0, import_fs6.unlinkSync)(this.indexingLockPath);
+    if ((0, import_fs7.existsSync)(this.indexingLockPath)) {
+      (0, import_fs7.unlinkSync)(this.indexingLockPath);
     }
   }
   async recoverFromInterruptedIndexing() {
     this.logger.warn("Detected interrupted indexing session, recovering...");
-    if ((0, import_fs6.existsSync)(this.fileHashCachePath)) {
-      (0, import_fs6.unlinkSync)(this.fileHashCachePath);
+    if ((0, import_fs7.existsSync)(this.fileHashCachePath)) {
+      (0, import_fs7.unlinkSync)(this.fileHashCachePath);
     }
     await this.healthCheck();
     this.releaseIndexingLock();
@@ -8012,15 +8120,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 (!(0, import_fs6.existsSync)(this.failedBatchesPath)) {
+    if (!(0, import_fs7.existsSync)(this.failedBatchesPath)) {
       return [];
     }
-    const data = (0, import_fs6.readFileSync)(this.failedBatchesPath, "utf-8");
+    const data = (0, import_fs7.readFileSync)(this.failedBatchesPath, "utf-8");
     const parsed = JSON.parse(data);
     return parsed.map((batch) => {
       const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
@@ -8037,15 +8150,15 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if ((0, import_fs6.existsSync)(this.failedBatchesPath)) {
+      if ((0, import_fs7.existsSync)(this.failedBatchesPath)) {
         try {
-          (0, import_fs6.unlinkSync)(this.failedBatchesPath);
+          (0, import_fs7.unlinkSync)(this.failedBatchesPath);
         } catch {
         }
       }
       return;
     }
-    (0, import_fs6.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+    (0, import_fs7.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
   collectRetryableFailedChunks(currentFileHashes, unchangedFilePaths, maxChunkTokens) {
     const retryableById = /* @__PURE__ */ new Map();
@@ -8225,7 +8338,7 @@ var Indexer = class {
     const intent = isLikelyImplementationPath(candidate.metadata.filePath) ? "implementation" : "doc_or_test";
     parts.push(`intent_hint: ${intent}`);
     try {
-      const fileContent = await import_fs6.promises.readFile(candidate.metadata.filePath, "utf-8");
+      const fileContent = await import_fs7.promises.readFile(candidate.metadata.filePath, "utf-8");
       const lines = fileContent.split("\n");
       const snippetStartLine = Math.max(1, candidate.metadata.startLine - 2);
       const snippetEndLine = Math.min(lines.length, candidate.metadata.endLine + 2);
@@ -8270,26 +8383,26 @@ var Indexer = class {
         });
       }
     }
-    await import_fs6.promises.mkdir(this.indexPath, { recursive: true });
+    await import_fs7.promises.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 ((0, import_fs6.existsSync)(indexFilePath)) {
+    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
+    if ((0, import_fs7.existsSync)(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 ((0, import_fs6.existsSync)(invertedIndexPath)) {
-        await import_fs6.promises.unlink(invertedIndexPath);
+      if ((0, import_fs7.existsSync)(invertedIndexPath)) {
+        await import_fs7.promises.unlink(invertedIndexPath);
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path8.join(this.indexPath, "codebase.db");
-    let dbIsNew = !(0, import_fs6.existsSync)(dbPath);
+    const dbPath = path12.join(this.indexPath, "codebase.db");
+    let dbIsNew = !(0, import_fs7.existsSync)(dbPath);
     try {
       this.database = new Database(dbPath);
     } catch (error) {
@@ -8369,7 +8482,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;
@@ -8384,7 +8497,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`;
@@ -8393,19 +8506,19 @@ var Indexer = class {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if ((0, import_fs6.existsSync)(backupIndexPath)) {
-      (0, import_fs6.unlinkSync)(backupIndexPath);
+    if ((0, import_fs7.existsSync)(backupIndexPath)) {
+      (0, import_fs7.unlinkSync)(backupIndexPath);
     }
-    if ((0, import_fs6.existsSync)(backupMetadataPath)) {
-      (0, import_fs6.unlinkSync)(backupMetadataPath);
+    if ((0, import_fs7.existsSync)(backupMetadataPath)) {
+      (0, import_fs7.unlinkSync)(backupMetadataPath);
     }
     try {
-      if ((0, import_fs6.existsSync)(storeIndexPath)) {
-        (0, import_fs6.renameSync)(storeIndexPath, backupIndexPath);
+      if ((0, import_fs7.existsSync)(storeIndexPath)) {
+        (0, import_fs7.renameSync)(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if ((0, import_fs6.existsSync)(storeMetadataPath)) {
-        (0, import_fs6.renameSync)(storeMetadataPath, backupMetadataPath);
+      if ((0, import_fs7.existsSync)(storeMetadataPath)) {
+        (0, import_fs7.renameSync)(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -8425,11 +8538,11 @@ var Indexer = class {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && (0, import_fs6.existsSync)(backupIndexPath)) {
-        (0, import_fs6.unlinkSync)(backupIndexPath);
+      if (backedUpIndex && (0, import_fs7.existsSync)(backupIndexPath)) {
+        (0, import_fs7.unlinkSync)(backupIndexPath);
       }
-      if (backedUpMetadata && (0, import_fs6.existsSync)(backupMetadataPath)) {
-        (0, import_fs6.unlinkSync)(backupMetadataPath);
+      if (backedUpMetadata && (0, import_fs7.existsSync)(backupMetadataPath)) {
+        (0, import_fs7.unlinkSync)(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
         excludedChunks: excludedSet.size,
@@ -8441,17 +8554,17 @@ var Indexer = class {
         store.clear();
       } catch {
       }
-      if ((0, import_fs6.existsSync)(storeIndexPath)) {
-        (0, import_fs6.unlinkSync)(storeIndexPath);
+      if ((0, import_fs7.existsSync)(storeIndexPath)) {
+        (0, import_fs7.unlinkSync)(storeIndexPath);
       }
-      if ((0, import_fs6.existsSync)(storeMetadataPath)) {
-        (0, import_fs6.unlinkSync)(storeMetadataPath);
+      if ((0, import_fs7.existsSync)(storeMetadataPath)) {
+        (0, import_fs7.unlinkSync)(storeMetadataPath);
       }
-      if (backedUpIndex && (0, import_fs6.existsSync)(backupIndexPath)) {
-        (0, import_fs6.renameSync)(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && (0, import_fs7.existsSync)(backupIndexPath)) {
+        (0, import_fs7.renameSync)(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && (0, import_fs6.existsSync)(backupMetadataPath)) {
-        (0, import_fs6.renameSync)(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && (0, import_fs7.existsSync)(backupMetadataPath)) {
+        (0, import_fs7.renameSync)(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -8469,7 +8582,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") {
@@ -8492,23 +8605,23 @@ 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 {
-        await import_fs6.promises.rm(targetPath, { recursive: true, force: true });
+        await import_fs7.promises.rm(targetPath, { recursive: true, force: true });
       } catch {
       }
     }));
-    await import_fs6.promises.mkdir(this.indexPath, { recursive: true });
+    await import_fs7.promises.mkdir(this.indexPath, { recursive: true });
     return true;
   }
   migrateFromLegacyIndex() {
@@ -8713,7 +8826,7 @@ var Indexer = class {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
-        const content = await import_fs6.promises.readFile(f.path, "utf-8");
+        const content = await import_fs7.promises.readFile(f.path, "utf-8");
         changedFiles.push({ path: f.path, content, hash: currentHash });
         this.logger.recordCacheMiss();
       }
@@ -8765,7 +8878,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;
@@ -9048,7 +9161,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((resolve11) => setTimeout(resolve11, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -9497,7 +9610,7 @@ var Indexer = class {
         let contextEndLine = r.metadata.endLine;
         if (!metadataOnly && this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs6.promises.readFile(
+            const fileContent = await import_fs7.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -9609,8 +9722,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."
       );
@@ -9649,7 +9762,7 @@ var Indexer = class {
     const removedChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!(0, import_fs6.existsSync)(filePath)) {
+      if (!(0, import_fs7.existsSync)(filePath)) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           removedChunkKeys.push(key);
@@ -9698,7 +9811,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);
@@ -10001,7 +10114,7 @@ var Indexer = class {
         let content = "";
         if (this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs6.promises.readFile(
+            const fileContent = await import_fs7.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -10250,12 +10363,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)}
@@ -10265,7 +10381,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}
 \`\`\`
@@ -10275,9 +10391,99 @@ ${truncateContent(r.content)}
   return formatted.join("\n\n");
 }
 
+// src/tools/knowledge-base-paths.ts
+var path13 = __toESM(require("path"), 1);
+function resolveConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  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;
+  }
+  if (!path13.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path13.normalize(trimmed));
+  }
+  const relativePath = path13.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path13.normalize(relativePath || "."));
+  }
+  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 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
-var import_fs7 = require("fs");
-var path9 = __toESM(require("path"), 1);
+var import_fs9 = require("fs");
+var path15 = __toESM(require("path"), 1);
+
+// src/tools/config-state.ts
+var import_fs8 = require("fs");
+var path14 = __toESM(require("path"), 1);
+function normalizeKnowledgeBasePaths(config, projectRoot) {
+  const normalized = { ...config };
+  if (Array.isArray(normalized.knowledgeBases)) {
+    normalized.knowledgeBases = normalized.knowledgeBases.map(
+      (kb) => resolveConfigPathValue(kb, projectRoot)
+    );
+  }
+  return normalized;
+}
+function toConfigRecord(rawConfig) {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
+  }
+  return { ...rawConfig };
+}
+function getConfigPath(projectRoot) {
+  return resolveWritableProjectConfigPath(projectRoot);
+}
+function loadRuntimeConfig(projectRoot) {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot)), projectRoot);
+}
+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 (!(0, import_fs8.existsSync)(configDir)) {
+    (0, import_fs8.mkdirSync)(configDir, { recursive: true });
+  }
+  const serializableConfig = { ...config };
+  if (Array.isArray(serializableConfig.knowledgeBases)) {
+    serializableConfig.knowledgeBases = serializableConfig.knowledgeBases.map(
+      (kb) => serializeConfigPathValue(kb, configBaseDir)
+    );
+  }
+  (0, import_fs8.writeFileSync)(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+}
+
+// src/tools/index.ts
+var os5 = __toESM(require("os"), 1);
+function ensureStringArray(value) {
+  return Array.isArray(value) ? value : [];
+}
 var z = import_plugin.tool.schema;
 var sharedIndexer = null;
 var sharedProjectRoot = "";
@@ -10292,20 +10498,20 @@ function refreshIndexerFromConfig() {
   if (!sharedProjectRoot) {
     throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
   }
-  sharedIndexer = new Indexer(sharedProjectRoot, parseConfig(loadRuntimeConfig()));
+  sharedIndexer = new Indexer(sharedProjectRoot, parseConfig(loadRuntimeConfig(sharedProjectRoot)));
 }
 function shouldForceLocalizeProjectIndex() {
-  const currentConfig = parseConfig(loadRuntimeConfig());
+  const currentConfig = parseConfig(loadRuntimeConfig(sharedProjectRoot));
   if (currentConfig.scope !== "project") {
     return false;
   }
-  const localIndexPath = path9.join(sharedProjectRoot, ".opencode", "index");
+  const localIndexPath = path15.join(sharedProjectRoot, ".opencode", "index");
   const mainRepoRoot = resolveWorktreeMainRepoRoot(sharedProjectRoot);
   if (!mainRepoRoot) {
     return false;
   }
-  const inheritedIndexPath = path9.join(mainRepoRoot, ".opencode", "index");
-  return !(0, import_fs7.existsSync)(localIndexPath) && (0, import_fs7.existsSync)(inheritedIndexPath);
+  const inheritedIndexPath = path15.join(mainRepoRoot, ".opencode", "index");
+  return !(0, import_fs9.existsSync)(localIndexPath) && (0, import_fs9.existsSync)(inheritedIndexPath);
 }
 function getIndexer() {
   if (!sharedIndexer) {
@@ -10313,76 +10519,6 @@ function getIndexer() {
   }
   return sharedIndexer;
 }
-function getConfigPath() {
-  return resolveWritableProjectConfigPath(sharedProjectRoot);
-}
-function normalizeConfigPathValue(value, baseDir) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  const absolutePath = path9.isAbsolute(trimmed) ? trimmed : path9.resolve(baseDir, trimmed);
-  return path9.normalize(absolutePath);
-}
-function serializeConfigPathValue(value, baseDir) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  const normalizeRelativePath = (candidate) => candidate.replace(/\\/g, "/");
-  if (!path9.isAbsolute(trimmed)) {
-    return normalizeRelativePath(path9.normalize(trimmed));
-  }
-  const relativePath = path9.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path9.isAbsolute(relativePath)) {
-    return normalizeRelativePath(path9.normalize(relativePath || "."));
-  }
-  return path9.normalize(trimmed);
-}
-function normalizeKnowledgeBasePaths(config) {
-  const normalized = { ...config };
-  if (Array.isArray(normalized.knowledgeBases)) {
-    normalized.knowledgeBases = normalized.knowledgeBases.map((kb) => {
-      return normalizeConfigPathValue(kb, sharedProjectRoot);
-    });
-  }
-  return normalized;
-}
-function loadRuntimeConfig() {
-  const rawConfig = loadMergedConfig(sharedProjectRoot);
-  const config = {};
-  if (rawConfig && typeof rawConfig === "object") {
-    for (const key of Object.keys(rawConfig)) {
-      config[key] = rawConfig[key];
-    }
-  }
-  return normalizeKnowledgeBasePaths(config);
-}
-function loadEditableConfig() {
-  const rawConfig = loadProjectConfigLayer(sharedProjectRoot);
-  const config = {};
-  if (rawConfig && typeof rawConfig === "object") {
-    for (const key of Object.keys(rawConfig)) {
-      config[key] = rawConfig[key];
-    }
-  }
-  return normalizeKnowledgeBasePaths(config);
-}
-function saveConfig(config) {
-  const configPath = getConfigPath();
-  const configDir = path9.dirname(configPath);
-  const configBaseDir = path9.dirname(configDir);
-  if (!(0, import_fs7.existsSync)(configDir)) {
-    (0, import_fs7.mkdirSync)(configDir, { recursive: true });
-  }
-  const serializableConfig = { ...config };
-  if (Array.isArray(serializableConfig.knowledgeBases)) {
-    serializableConfig.knowledgeBases = serializableConfig.knowledgeBases.map(
-      (kb) => serializeConfigPathValue(kb, configBaseDir)
-    );
-  }
-  (0, import_fs7.writeFileSync)(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
-}
 var codebase_peek = (0, import_plugin.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: {
@@ -10602,36 +10738,64 @@ var add_knowledge_base = (0, import_plugin.tool)({
   },
   async execute(args) {
     const inputPath = args.path.trim();
-    const resolvedPath = path9.isAbsolute(inputPath) ? inputPath : path9.resolve(sharedProjectRoot, inputPath);
-    if (!(0, import_fs7.existsSync)(resolvedPath)) {
-      return `Error: Directory does not exist: ${resolvedPath}`;
+    const normalizedPath = path15.resolve(
+      path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, sharedProjectRoot)
+    );
+    if (!(0, import_fs9.existsSync)(normalizedPath)) {
+      return `Error: Directory does not exist: ${normalizedPath}`;
+    }
+    let realPath;
+    try {
+      realPath = (0, import_fs9.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 = (0, import_fs7.statSync)(resolvedPath);
+      const stat4 = (0, import_fs9.statSync)(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(sharedProjectRoot);
+    const knowledgeBases = ensureStringArray(config.knowledgeBases);
+    const alreadyExists = hasMatchingKnowledgeBasePath(knowledgeBases, normalizedPath, sharedProjectRoot);
     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);
+    saveConfig(sharedProjectRoot, config);
     refreshIndexerFromConfig();
-    let result = `${resolvedPath}
+    let result = `${normalizedPath}
 `;
     result += `Total knowledge bases: ${knowledgeBases.length}
 `;
-    result += `Config saved to: ${getConfigPath()}
+    result += `Config saved to: ${getConfigPath(sharedProjectRoot)}
 `;
     result += `
 Run /index to rebuild the index with the new knowledge base.`;
@@ -10642,8 +10806,8 @@ var list_knowledge_bases = (0, import_plugin.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 : [];
+    const config = loadRuntimeConfig(sharedProjectRoot);
+    const knowledgeBases = ensureStringArray(config.knowledgeBases);
     if (knowledgeBases.length === 0) {
       return "No knowledge bases configured. Use add_knowledge_base to add folders.";
     }
@@ -10652,8 +10816,8 @@ var list_knowledge_bases = (0, import_plugin.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 = (0, import_fs7.existsSync)(resolvedPath);
+      const resolvedPath = resolveKnowledgeBasePath(kb, sharedProjectRoot);
+      const exists = (0, import_fs9.existsSync)(resolvedPath);
       result += `[${i + 1}] ${kb}
 `;
       result += `    Resolved: ${resolvedPath}
@@ -10662,7 +10826,7 @@ var list_knowledge_bases = (0, import_plugin.tool)({
 `;
       if (exists) {
         try {
-          const stat4 = (0, import_fs7.statSync)(resolvedPath);
+          const stat4 = (0, import_fs9.statSync)(resolvedPath);
           result += `    Type: ${stat4.isDirectory() ? "Directory" : "File"}
 `;
         } catch {
@@ -10670,7 +10834,7 @@ var list_knowledge_bases = (0, import_plugin.tool)({
       }
       result += "\n";
     }
-    result += `Config file: ${getConfigPath()}`;
+    result += `Config file: ${getConfigPath(sharedProjectRoot)}`;
     return result;
   }
 });
@@ -10681,15 +10845,12 @@ var remove_knowledge_base = (0, import_plugin.tool)({
   },
   async execute(args) {
     const inputPath = args.path.trim();
-    const config = loadEditableConfig();
-    const knowledgeBases = Array.isArray(config.knowledgeBases) ? config.knowledgeBases : [];
+    const config = loadEditableConfig(sharedProjectRoot);
+    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, sharedProjectRoot);
     if (index === -1) {
       let result2 = `Knowledge base not found: ${inputPath}
 
@@ -10704,14 +10865,14 @@ var remove_knowledge_base = (0, import_plugin.tool)({
     }
     const removed = knowledgeBases.splice(index, 1)[0];
     config.knowledgeBases = knowledgeBases;
-    saveConfig(config);
+    saveConfig(sharedProjectRoot, config);
     refreshIndexerFromConfig();
     let result = `Removed: ${removed}
 
 `;
     result += `Remaining knowledge bases: ${knowledgeBases.length}
 `;
-    result += `Config saved to: ${getConfigPath()}
+    result += `Config saved to: ${getConfigPath(sharedProjectRoot)}
 `;
     result += `
 Run /index to rebuild the index without the removed knowledge base.`;
@@ -10720,8 +10881,8 @@ Run /index to rebuild the index without the removed knowledge base.`;
 });
 
 // src/commands/loader.ts
-var import_fs8 = require("fs");
-var path10 = __toESM(require("path"), 1);
+var import_fs10 = require("fs");
+var path16 = __toESM(require("path"), 1);
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -10742,15 +10903,21 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!(0, import_fs8.existsSync)(commandsDir)) {
+  if (!(0, import_fs10.existsSync)(commandsDir)) {
     return commands;
   }
-  const files = (0, import_fs8.readdirSync)(commandsDir).filter((f) => f.endsWith(".md"));
+  const files = (0, import_fs10.readdirSync)(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path10.join(commandsDir, file);
-    const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+    const filePath = path16.join(commandsDir, file);
+    let content;
+    try {
+      content = (0, import_fs10.readFileSync)(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,
@@ -10760,7 +10927,7 @@ function loadCommandsFromDirectory(commandsDir) {
   return commands;
 }
 
-// src/routing-hints.ts
+// src/routing-hints-patterns.ts
 var EXTERNAL_HINTS = [
   "docs",
   "documentation",
@@ -10851,6 +11018,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, " ");
 }
@@ -10863,6 +11032,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) ?? [],
@@ -10878,11 +11062,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(" ")
@@ -10898,21 +11084,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,
@@ -10926,21 +11112,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,
@@ -11038,9 +11224,9 @@ function replaceActiveWatcher(nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import_meta2 !== "undefined" && import_meta2.url) {
-    currentDir = path11.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+    currentDir = path17.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
   }
-  return path11.join(currentDir, "..", "commands");
+  return path17.join(currentDir, "..", "commands");
 }
 var plugin = async ({ directory }) => {
   try {