opencode-codebase-index 0.17.1 → 0.18.1

package/dist/pi-extension.cjs

@@ -678,7 +678,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
   "**/*.zig",
-  "**/*.gd"
+  "**/*.gd",
+  "**/*.metal"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -869,6 +870,9 @@ function isValidProvider(value) {
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS).includes(value);
 }
 function isValidModel(value, provider) {
+  if (typeof value === "string" && provider === "ollama" && value.trim().length > 0) {
+    return true;
+  }
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS[provider]).includes(value);
 }
 function isValidScope(value) {
@@ -1068,6 +1072,9 @@ function loadOpenCodeAuth() {
   return {};
 }
 async function detectEmbeddingProvider(preferredProvider, model) {
+  if (preferredProvider === "ollama") {
+    return detectOllamaProvider(model);
+  }
   const credentials = await getProviderCredentials(preferredProvider);
   if (credentials) {
     if (!model) {
@@ -1083,10 +1090,16 @@ async function detectEmbeddingProvider(preferredProvider, model) {
       );
     }
     const providerModels = EMBEDDING_MODELS[preferredProvider];
+    const modelInfo = Object.values(providerModels).find((candidate) => candidate.model === model);
+    if (!modelInfo) {
+      throw new Error(
+        `Model '${model}' is not supported by provider '${preferredProvider}'`
+      );
+    }
     return {
       provider: preferredProvider,
       credentials,
-      modelInfo: providerModels[model]
+      modelInfo
     };
   }
   throw new Error(
@@ -1095,6 +1108,13 @@ async function detectEmbeddingProvider(preferredProvider, model) {
 }
 async function tryDetectProvider() {
   for (const provider of autoDetectProviders) {
+    if (provider === "ollama") {
+      const ollamaProvider = await tryDetectOllamaProvider();
+      if (ollamaProvider) {
+        return ollamaProvider;
+      }
+      continue;
+    }
     const credentials = await getProviderCredentials(provider);
     if (credentials) {
       return {
@@ -1162,32 +1182,105 @@ function getGoogleCredentials() {
   }
   return null;
 }
-async function getOllamaCredentials() {
-  const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
+async function fetchOllama(url, init) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 2e3);
   try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2e3);
-    const response = await fetch(`${baseUrl}/api/tags`, {
-      signal: controller.signal
-    });
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
     clearTimeout(timeoutId);
+  }
+}
+async function getOllamaCredentials() {
+  const baseUrl = (process.env.OLLAMA_HOST || "http://localhost:11434").replace(/\/+$/, "");
+  try {
+    const response = await fetchOllama(`${baseUrl}/api/tags`);
     if (response.ok) {
-      const data = await response.json();
-      const hasEmbeddingModel = data.models?.some(
-        (m) => m.name.includes("nomic-embed") || m.name.includes("mxbai-embed") || m.name.includes("all-minilm")
-      );
-      if (hasEmbeddingModel) {
-        return {
-          provider: "ollama",
-          baseUrl
-        };
-      }
+      return {
+        provider: "ollama",
+        baseUrl
+      };
     }
   } catch {
     return null;
   }
   return null;
 }
+function findCatalogOllamaModel(model) {
+  const stableName = model.endsWith(":latest") ? model.slice(0, -":latest".length) : model;
+  return Object.values(EMBEDDING_MODELS.ollama).find((candidate) => candidate.model === stableName) ?? null;
+}
+function getPositiveIntegerMetadata(modelInfo, suffix) {
+  const values = Object.entries(modelInfo).filter(([key]) => key.endsWith(suffix)).map(([, value]) => value).filter((value) => typeof value === "number" && Number.isInteger(value) && value > 0);
+  return values.length === 1 ? values[0] : null;
+}
+async function fetchOllamaModelInfo(credentials, model) {
+  const response = await fetchOllama(`${credentials.baseUrl}/api/show`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model })
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  if (!data.capabilities?.includes("embedding") || !data.model_info) {
+    return null;
+  }
+  const dimensions = getPositiveIntegerMetadata(data.model_info, ".embedding_length");
+  const maxTokens = getPositiveIntegerMetadata(data.model_info, ".context_length");
+  if (!dimensions || !maxTokens) {
+    return null;
+  }
+  return {
+    provider: "ollama",
+    model,
+    dimensions,
+    maxTokens,
+    costPer1MTokens: 0
+  };
+}
+async function listOllamaModels(credentials) {
+  const response = await fetchOllama(`${credentials.baseUrl}/api/tags`);
+  if (!response.ok) {
+    return [];
+  }
+  const data = await response.json();
+  return [...new Set((data.models ?? []).map((entry) => entry.name ?? entry.model).filter((name) => typeof name === "string" && name.trim().length > 0))];
+}
+async function detectOllamaProvider(model) {
+  const credentials = await getOllamaCredentials();
+  if (!credentials) {
+    throw new Error("Preferred provider 'ollama' is not configured or authenticated");
+  }
+  const requestedModel = model?.trim();
+  if (requestedModel) {
+    const catalogModel = findCatalogOllamaModel(requestedModel);
+    if (catalogModel) {
+      return { provider: "ollama", credentials, modelInfo: catalogModel };
+    }
+  }
+  const candidates = requestedModel ? [requestedModel] : await listOllamaModels(credentials);
+  for (const candidate of candidates) {
+    const modelInfo = await fetchOllamaModelInfo(credentials, candidate);
+    if (modelInfo) {
+      return {
+        provider: "ollama",
+        credentials,
+        modelInfo: findCatalogOllamaModel(candidate) ?? modelInfo
+      };
+    }
+  }
+  const detail = model ? `Model '${model}' is not installed or is not embedding-capable` : "No installed embedding-capable Ollama model was found";
+  throw new Error(detail);
+}
+async function tryDetectOllamaProvider() {
+  try {
+    return await detectOllamaProvider();
+  } catch {
+    return null;
+  }
+}
 function getProviderDisplayName(provider) {
   switch (provider) {
     case "github-copilot":
@@ -1340,10 +1433,6 @@ function formatPrImpact(result) {
 var import_fs10 = require("fs");
 var path16 = __toESM(require("path"), 1);
 
-// src/config/merger.ts
-var import_fs5 = require("fs");
-var path7 = __toESM(require("path"), 1);
-
 // src/config/paths.ts
 var import_fs4 = require("fs");
 var os2 = __toESM(require("os"), 1);
@@ -1516,16 +1605,6 @@ function resolveWorktreeFallbackPath(projectRoot3, relativePath) {
   const fallbackPath = path4.join(mainRepoRoot, relativePath);
   return (0, import_fs4.existsSync)(fallbackPath) ? fallbackPath : null;
 }
-function resolveWorktreeFallbackProjectIndexPath(projectRoot3, host) {
-  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
-  if (inheritedHostPath) {
-    return inheritedHostPath;
-  }
-  if (host !== "opencode") {
-    return resolveWorktreeFallbackPath(projectRoot3, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
-  }
-  return null;
-}
 function getHostProjectConfigRelativePath(host) {
   return getProjectConfigRelativePath(host);
 }
@@ -1630,6 +1709,9 @@ function resolveProjectIndexPath(projectRoot3, scope, host = "opencode") {
   if (hasHostProjectConfig(projectRoot3, host)) {
     return localIndexPath;
   }
+  if (resolveWorktreeMainRepoRoot(projectRoot3)) {
+    return localIndexPath;
+  }
   const hostFallback = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
   if (hostFallback) {
     return hostFallback;
@@ -1643,210 +1725,9 @@ function resolveProjectIndexPath(projectRoot3, scope, host = "opencode") {
   return localIndexPath;
 }
 
-// src/config/rebase.ts
-var path6 = __toESM(require("path"), 1);
-
-// src/utils/paths.ts
-var path5 = __toESM(require("path"), 1);
-function normalizePathSeparators(value) {
-  return value.replace(/\\/g, "/");
-}
-function isHiddenPathSegment(part) {
-  return part.startsWith(".") && part !== "." && part !== "..";
-}
-function isBuildPathSegment(part) {
-  return part.toLowerCase().includes("build");
-}
-
-// src/config/rebase.ts
-function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path6.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
-}
-function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return trimmed;
-    }
-    if (path6.isAbsolute(trimmed)) {
-      if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizePathSeparators(path6.normalize(path6.relative(sourceRoot, trimmed) || "."));
-      }
-      return path6.normalize(trimmed);
-    }
-    const resolvedFromSource = path6.resolve(sourceRoot, trimmed);
-    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizePathSeparators(path6.normalize(trimmed));
-    }
-    return normalizePathSeparators(path6.normalize(path6.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 = path7.normalize(String(value).trim());
-  const root = path7.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_fs5.existsSync)(filePath)) {
-    return null;
-  }
-  try {
-    const content = (0, import_fs5.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}`);
-  }
-}
-function materializeLocalProjectConfig(projectRoot3, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot3, host);
-  (0, import_fs5.mkdirSync)(path7.dirname(localConfigPath), { recursive: true });
-  (0, import_fs5.writeFileSync)(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
-}
-function loadProjectConfigLayer(projectRoot3, host = "opencode") {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!projectConfig) {
-    return {};
-  }
-  const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path7.dirname(path7.dirname(projectConfigPath));
-  if (Array.isArray(normalizedConfig.knowledgeBases)) {
-    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
-      normalizedConfig.knowledgeBases,
-      projectConfigBaseDir,
-      projectRoot3
-    );
-  }
-  return normalizedConfig;
-}
-function loadMergedConfig(projectRoot3, host = "opencode") {
-  const globalConfigPath = resolveGlobalConfigPath(host);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
-  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(projectRoot3, host);
-  if (globalConfigError) {
-    if (!projectConfig) {
-      throw globalConfigError;
-    }
-    globalConfig = null;
-  }
-  if (!globalConfig && !projectConfig) {
-    return {};
-  }
-  if (!projectConfig && globalConfig) {
-    return globalConfig;
-  }
-  if (!globalConfig && projectConfig) {
-    return normalizedProjectConfig;
-  }
-  if (!globalConfig || !projectConfig) {
-    return globalConfig ?? normalizedProjectConfig;
-  }
-  const merged = { ...globalConfig };
-  for (const key of PROJECT_OVERRIDE_KEYS) {
-    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
-  }
-  if (projectConfig) {
-    for (const key of Object.keys(projectConfig)) {
-      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
-        continue;
-      }
-      merged[key] = normalizedProjectConfig[key];
-    }
-  }
-  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
-  const allKbs = [...globalKbs, ...projectKbs];
-  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
-  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
-  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
-  const allAdditional = [...globalAdditional, ...projectAdditional];
-  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
-  return merged;
-}
-
 // src/indexer/index.ts
-var import_fs8 = require("fs");
-var path13 = __toESM(require("path"), 1);
+var import_fs7 = require("fs");
+var path11 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
 var import_child_process3 = require("child_process");
 var import_util3 = require("util");
@@ -3197,6 +3078,7 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
 // src/embeddings/providers/ollama.ts
 var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddingProvider {
   static MIN_TRUNCATION_CHARS = 512;
+  static REQUEST_TIMEOUT_MS = 12e4;
   constructor(credentials, modelInfo) {
     super(credentials, modelInfo);
   }
@@ -3271,22 +3153,45 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     }
   }
   async embedSingle(text3) {
-    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.modelInfo.model,
-        prompt: text3,
-        truncate: false
-      })
-    });
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      _OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS
+    );
+    let response;
+    try {
+      response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          prompt: text3,
+          truncate: false
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `Ollama embedding request timed out after ${_OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS}ms`
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
     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();
+    if (!Array.isArray(data.embedding) || data.embedding.length !== this.modelInfo.dimensions || data.embedding.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+      throw new Error(
+        `Ollama returned an invalid embedding; expected ${this.modelInfo.dimensions} finite dimensions`
+      );
+    }
     return {
       embedding: data.embedding,
       tokensUsed: this.estimateTokens(text3)
@@ -3433,9 +3338,23 @@ var SiliconFlowReranker = class {
 };
 
 // src/utils/files.ts
-var import_ignore = __toESM(require_ignore(), 1);
-var import_fs6 = require("fs");
-var path8 = __toESM(require("path"), 1);
+var import_ignore = __toESM(require_ignore(), 1);
+var import_fs5 = require("fs");
+var path6 = __toESM(require("path"), 1);
+
+// src/utils/paths.ts
+var path5 = __toESM(require("path"), 1);
+function normalizePathSeparators(value) {
+  return value.replace(/\\/g, "/");
+}
+function isHiddenPathSegment(part) {
+  return part.startsWith(".") && part !== "." && part !== "..";
+}
+function isBuildPathSegment(part) {
+  return part.toLowerCase().includes("build");
+}
+
+// src/utils/files.ts
 function createIgnoreFilter(projectRoot3) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -3457,9 +3376,9 @@ function createIgnoreFilter(projectRoot3) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path8.join(projectRoot3, ".gitignore");
-  if ((0, import_fs6.existsSync)(gitignorePath)) {
-    const gitignoreContent = (0, import_fs6.readFileSync)(gitignorePath, "utf-8");
+  const gitignorePath = path6.join(projectRoot3, ".gitignore");
+  if ((0, import_fs5.existsSync)(gitignorePath)) {
+    const gitignoreContent = (0, import_fs5.readFileSync)(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
@@ -3480,12 +3399,12 @@ function matchGlob(filePath, pattern) {
   return regex.test(filePath);
 }
 async function* walkDirectory(dir, projectRoot3, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped, options, currentDepth = 0) {
-  const entries = await import_fs6.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 = path8.join(dir, entry.name);
-    const relativePath = path8.relative(projectRoot3, fullPath);
+    const fullPath = path6.join(dir, entry.name);
+    const relativePath = path6.relative(projectRoot3, fullPath);
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3505,7 +3424,7 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
     if (entry.isDirectory()) {
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
-      const stat = await import_fs6.promises.stat(fullPath);
+      const stat = await import_fs5.promises.stat(fullPath);
       if (stat.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
@@ -3534,7 +3453,7 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path8.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path6.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3574,14 +3493,14 @@ async function collectFiles(projectRoot3, includePatterns, excludePatterns, maxF
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path8.normalize(
-        path8.isAbsolute(kbRoot) ? kbRoot : path8.resolve(projectRoot3, kbRoot)
+      const resolved = path6.normalize(
+        path6.isAbsolute(kbRoot) ? kbRoot : path6.resolve(projectRoot3, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
     for (const resolvedKbRoot of normalizedRoots) {
       try {
-        const stat = await import_fs6.promises.stat(resolvedKbRoot);
+        const stat = await import_fs5.promises.stat(resolvedKbRoot);
         if (!stat.isDirectory()) {
           skipped.push({ path: resolvedKbRoot, reason: "excluded" });
           continue;
@@ -3922,7 +3841,7 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-var path9 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 var os3 = __toESM(require("os"), 1);
 var module2 = __toESM(require("module"), 1);
 var import_url = require("url");
@@ -3947,19 +3866,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import_meta !== "undefined" && import_meta.url) {
-    currentDir = path9.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    currentDir = path7.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 = path9.join(currentDir, "index.js");
+    requireTarget = path7.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path9.join("src", "native"));
-  const packageRoot = isDevMode ? path9.resolve(currentDir, "../..") : path9.resolve(currentDir, "..");
-  const nativePath = path9.join(packageRoot, "native", bindingName);
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path7.join("src", "native"));
+  const packageRoot = isDevMode ? path7.resolve(currentDir, "../..") : path7.resolve(currentDir, "..");
+  const nativePath = path7.join(packageRoot, "native", bindingName);
   const require2 = module2.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -4045,7 +3964,9 @@ function mapChunk(c) {
   return {
     content: c.content,
     startLine: c.startLine ?? c.start_line,
+    startCol: c.startCol ?? c.start_col,
     endLine: c.endLine ?? c.end_line,
+    endCol: c.endCol ?? c.end_col,
     chunkType: c.chunkType ?? c.chunk_type,
     name: c.name ?? void 0,
     language: c.language
@@ -4166,6 +4087,7 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     javascript: "JavaScript",
     python: "Python",
     rust: "Rust",
+    swift: "Swift",
     go: "Go",
     java: "Java"
   };
@@ -4174,7 +4096,16 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     function: "function",
     arrow_function: "arrow function",
     method_definition: "method",
+    method_declaration: "method",
+    protocol_function_declaration: "protocol requirement",
+    init_declaration: "initializer",
+    deinit_declaration: "deinitializer",
+    subscript_declaration: "subscript",
     class_declaration: "class",
+    actor_declaration: "actor",
+    extension_declaration: "extension",
+    protocol_declaration: "protocol",
+    struct_declaration: "struct",
     interface_declaration: "interface",
     type_alias_declaration: "type alias",
     enum_declaration: "enum",
@@ -4692,7 +4623,7 @@ var Database = class _Database {
 };
 
 // src/tools/changed-files.ts
-var path10 = __toESM(require("path"), 1);
+var path8 = __toESM(require("path"), 1);
 var import_child_process = require("child_process");
 var import_util = require("util");
 var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
@@ -4780,8 +4711,8 @@ function normalizeFiles(rawFiles, projectRoot3) {
   for (const raw of rawFiles) {
     const trimmed = raw.trim();
     if (!trimmed) continue;
-    const absolute = path10.resolve(projectRoot3, trimmed);
-    const relative7 = path10.relative(projectRoot3, absolute);
+    const absolute = path8.resolve(projectRoot3, trimmed);
+    const relative7 = path8.relative(projectRoot3, absolute);
     const cleaned = relative7.startsWith("./") ? relative7.slice(2) : relative7;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
@@ -4793,7 +4724,7 @@ function normalizeFiles(rawFiles, projectRoot3) {
 
 // src/indexer/git-blame.ts
 var import_child_process2 = require("child_process");
-var path11 = __toESM(require("path"), 1);
+var path9 = __toESM(require("path"), 1);
 var import_util2 = require("util");
 var execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
 function parseGitBlamePorcelain(output) {
@@ -4831,7 +4762,7 @@ function parseGitBlamePorcelain(output) {
   return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
 }
 async function getChunkGitBlame(projectRoot3, filePath, startLine, endLine) {
-  const relativePath = path11.relative(projectRoot3, filePath);
+  const relativePath = path9.relative(projectRoot3, filePath);
   try {
     const { stdout } = await execFileAsync2(
       "git",
@@ -4846,9 +4777,9 @@ async function getChunkGitBlame(projectRoot3, filePath, startLine, endLine) {
 
 // src/indexer/index-lock.ts
 var import_crypto = require("crypto");
-var import_fs7 = require("fs");
+var import_fs6 = require("fs");
 var os4 = __toESM(require("os"), 1);
-var path12 = __toESM(require("path"), 1);
+var path10 = __toESM(require("path"), 1);
 var OWNER_FILE_NAME = "owner.json";
 var RECLAIM_DIRECTORY_NAME = "reclaiming";
 var RECOVERY_MARKER_PREFIX = "indexing.lock.recovery.";
@@ -4905,7 +4836,7 @@ function parseReclaimOwner(value) {
 }
 function readJsonDirectory(directoryPath, parser) {
   try {
-    return parser(JSON.parse((0, import_fs7.readFileSync)(path12.join(directoryPath, OWNER_FILE_NAME), "utf-8")));
+    return parser(JSON.parse((0, import_fs6.readFileSync)(path10.join(directoryPath, OWNER_FILE_NAME), "utf-8")));
   } catch {
     return null;
   }
@@ -4921,7 +4852,7 @@ function readRecoveryOwner(markerPath) {
 }
 function readLegacyOwner(lockPath) {
   try {
-    const parsed = JSON.parse((0, import_fs7.readFileSync)(lockPath, "utf-8"));
+    const parsed = JSON.parse((0, import_fs6.readFileSync)(lockPath, "utf-8"));
     if (!Number.isInteger(parsed.pid) || Number(parsed.pid) <= 0) return null;
     if (typeof parsed.startedAt !== "string" || Number.isNaN(Date.parse(parsed.startedAt))) return null;
     return {
@@ -4956,23 +4887,23 @@ function sameReclaimOwner(left, right) {
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${(0, import_crypto.randomUUID)()}`;
   try {
-    (0, import_fs7.mkdirSync)(candidatePath, { mode: 448 });
+    (0, import_fs6.mkdirSync)(candidatePath, { mode: 448 });
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
   }
   try {
-    (0, import_fs7.writeFileSync)(path12.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
+    (0, import_fs6.writeFileSync)(path10.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
       flag: "wx",
       mode: 384
     });
-    if ((0, import_fs7.existsSync)(finalPath)) return false;
+    if ((0, import_fs6.existsSync)(finalPath)) return false;
     try {
-      (0, import_fs7.renameSync)(candidatePath, finalPath);
+      (0, import_fs6.renameSync)(candidatePath, finalPath);
       return true;
     } catch (error) {
-      if ((0, import_fs7.existsSync)(finalPath)) return false;
+      if ((0, import_fs6.existsSync)(finalPath)) return false;
       if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
@@ -4980,7 +4911,7 @@ function publishJsonDirectory(finalPath, value) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
   } finally {
-    if ((0, import_fs7.existsSync)(candidatePath)) (0, import_fs7.rmSync)(candidatePath, { recursive: true, force: true });
+    if ((0, import_fs6.existsSync)(candidatePath)) (0, import_fs6.rmSync)(candidatePath, { recursive: true, force: true });
   }
 }
 function createOwner(operation) {
@@ -4993,7 +4924,7 @@ function createOwner(operation) {
   };
 }
 function recoveryMarkerPath(indexPath, owner) {
-  return path12.join(indexPath, `${RECOVERY_MARKER_PREFIX}${owner.token}`);
+  return path10.join(indexPath, `${RECOVERY_MARKER_PREFIX}${owner.token}`);
 }
 function publishRecoveryMarker(indexPath, owner) {
   const markerPath = recoveryMarkerPath(indexPath, owner);
@@ -5007,16 +4938,16 @@ function publishRecoveryMarker(indexPath, owner) {
 }
 function getPendingRecoveries(indexPath) {
   const recoveries = [];
-  const markerNames = (0, import_fs7.readdirSync)(indexPath).filter((name) => {
+  const markerNames = (0, import_fs6.readdirSync)(indexPath).filter((name) => {
     if (!name.startsWith(RECOVERY_MARKER_PREFIX)) return false;
     return UUID_PATTERN.test(name.slice(RECOVERY_MARKER_PREFIX.length));
   }).sort();
   for (const markerName of markerNames) {
-    const markerPath = path12.join(indexPath, markerName);
+    const markerPath = path10.join(indexPath, markerName);
     const markerToken = markerName.slice(RECOVERY_MARKER_PREFIX.length);
     let markerStats;
     try {
-      markerStats = (0, import_fs7.lstatSync)(markerPath);
+      markerStats = (0, import_fs6.lstatSync)(markerPath);
     } catch (error) {
       if (getErrorCode(error) === "ENOENT") continue;
       throw error;
@@ -5038,17 +4969,17 @@ function getPendingRecoveries(indexPath) {
 }
 function cleanupDeadPublicationCandidates(indexPath) {
   const candidatePattern = /^indexing\.lock(?:\.recovery\.[0-9a-f-]{36})?\.candidate\.(\d+)\.[0-9a-f-]{36}$/i;
-  for (const entry of (0, import_fs7.readdirSync)(indexPath)) {
+  for (const entry of (0, import_fs6.readdirSync)(indexPath)) {
     const match = candidatePattern.exec(entry);
     if (!match) continue;
     const pid = Number(match[1]);
     if (!Number.isInteger(pid) || pid <= 0) continue;
     if (getOwnerLiveness({ pid, hostname: os4.hostname() }) !== "dead") continue;
-    (0, import_fs7.rmSync)(path12.join(indexPath, entry), { recursive: true, force: true });
+    (0, import_fs6.rmSync)(path10.join(indexPath, entry), { recursive: true, force: true });
   }
 }
 function removeDeadReclaimMarker(lockPath, expectedOwner) {
-  const markerPath = path12.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const markerPath = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const marker = readReclaimOwner(markerPath);
   if (!marker || marker.expectedOwnerToken !== expectedOwner.token || getOwnerLiveness(marker) !== "dead") {
     return false;
@@ -5059,7 +4990,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   }
   const claimedMarkerPath = `${markerPath}.stale.${marker.pid}.${marker.token}.${(0, import_crypto.randomUUID)()}`;
   try {
-    (0, import_fs7.renameSync)(markerPath, claimedMarkerPath);
+    (0, import_fs6.renameSync)(markerPath, claimedMarkerPath);
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
@@ -5067,16 +4998,16 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   const claimedMarker = readReclaimOwner(claimedMarkerPath);
   const ownerAfterClaim = readDirectoryOwner(lockPath);
   if (!claimedMarker || !sameReclaimOwner(claimedMarker, marker) || !ownerAfterClaim || !sameOwner(ownerAfterClaim, expectedOwner) || getOwnerLiveness(ownerAfterClaim) !== "dead") {
-    if (!(0, import_fs7.existsSync)(markerPath) && (0, import_fs7.existsSync)(claimedMarkerPath)) {
-      (0, import_fs7.renameSync)(claimedMarkerPath, markerPath);
+    if (!(0, import_fs6.existsSync)(markerPath) && (0, import_fs6.existsSync)(claimedMarkerPath)) {
+      (0, import_fs6.renameSync)(claimedMarkerPath, markerPath);
     }
     return false;
   }
-  (0, import_fs7.rmSync)(claimedMarkerPath, { recursive: true, force: true });
+  (0, import_fs6.rmSync)(claimedMarkerPath, { recursive: true, force: true });
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path12.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os4.hostname(),
@@ -5102,8 +5033,8 @@ function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
       return false;
     }
     const quarantinePath = `${lockPath}.stale.${expectedOwner.token}.${reclaimOwner.token}`;
-    (0, import_fs7.renameSync)(lockPath, quarantinePath);
-    (0, import_fs7.rmSync)(quarantinePath, { recursive: true, force: true });
+    (0, import_fs6.renameSync)(lockPath, quarantinePath);
+    (0, import_fs6.rmSync)(quarantinePath, { recursive: true, force: true });
     return true;
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") return false;
@@ -5128,9 +5059,9 @@ function isIndexLockContentionError(error) {
   return error instanceof IndexLockContentionError || typeof error === "object" && error !== null && "code" in error && error.code === "INDEX_BUSY";
 }
 function acquireIndexLock(indexPath, operation) {
-  (0, import_fs7.mkdirSync)(indexPath, { recursive: true });
-  const canonicalIndexPath = import_fs7.realpathSync.native(indexPath);
-  const lockPath = path12.join(canonicalIndexPath, "indexing.lock");
+  (0, import_fs6.mkdirSync)(indexPath, { recursive: true });
+  const canonicalIndexPath = import_fs6.realpathSync.native(indexPath);
+  const lockPath = path10.join(canonicalIndexPath, "indexing.lock");
   cleanupDeadPublicationCandidates(canonicalIndexPath);
   for (let attempt = 0; attempt < 6; attempt += 1) {
     const owner = createOwner(operation);
@@ -5151,7 +5082,7 @@ function acquireIndexLock(indexPath, operation) {
     }
     let stats;
     try {
-      stats = (0, import_fs7.lstatSync)(lockPath);
+      stats = (0, import_fs6.lstatSync)(lockPath);
     } catch (error) {
       if (getErrorCode(error) === "ENOENT") continue;
       throw error;
@@ -5179,78 +5110,44 @@ function releaseIndexLock(lease) {
   if (!currentOwner || !sameOwner(currentOwner, lease.owner)) return false;
   const releasePath = `${lease.lockPath}.release.${lease.owner.pid}.${lease.owner.token}`;
   try {
-    retryTransientFilesystemOperation(() => (0, import_fs7.renameSync)(lease.lockPath, releasePath));
+    retryTransientFilesystemOperation(() => (0, import_fs6.renameSync)(lease.lockPath, releasePath));
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
   }
   const claimedOwner = readDirectoryOwner(releasePath);
   if (!claimedOwner || !sameOwner(claimedOwner, lease.owner)) {
-    if (!(0, import_fs7.existsSync)(lease.lockPath) && (0, import_fs7.existsSync)(releasePath)) {
-      (0, import_fs7.renameSync)(releasePath, lease.lockPath);
+    if (!(0, import_fs6.existsSync)(lease.lockPath) && (0, import_fs6.existsSync)(releasePath)) {
+      (0, import_fs6.renameSync)(releasePath, lease.lockPath);
     }
     return false;
   }
   try {
-    retryTransientFilesystemOperation(() => (0, import_fs7.rmSync)(releasePath, { recursive: true, force: true }));
+    retryTransientFilesystemOperation(() => (0, import_fs6.rmSync)(releasePath, { recursive: true, force: true }));
   } catch (error) {
     console.error(`[codebase-index] Lease released but tombstone cleanup failed: ${releasePath}`, error);
   }
   return true;
 }
-async function withIndexLock(indexPath, operation, callback, options = {}) {
-  const lease = acquireIndexLock(indexPath, operation);
-  let result;
-  let callbackError;
-  let callbackFailed = false;
-  try {
-    result = await callback(lease);
-  } catch (error) {
-    callbackFailed = true;
-    callbackError = error;
-  }
-  if (!callbackFailed && options.completeRecoveries !== false) {
-    try {
-      completeLeaseRecovery(lease);
-    } catch (error) {
-      callbackFailed = true;
-      callbackError = error;
-    }
-  }
-  let releaseError;
-  try {
-    if (!releaseIndexLock(lease)) {
-      releaseError = new Error(`Lost ownership of index mutation lease ${lease.owner.token}`);
-    }
-  } catch (error) {
-    releaseError = error;
-  }
-  if (releaseError !== void 0) {
-    if (callbackFailed) throw new AggregateError([callbackError, releaseError], "Index mutation and lease release both failed");
-    throw releaseError;
-  }
-  if (callbackFailed) throw callbackError;
-  return result;
-}
 function createLeaseTemporaryPath(targetPath, owner, kind = "tmp") {
   if (kind === "bak") return `${targetPath}.bak.${owner.pid}.${owner.token}`;
   temporaryCounter += 1;
   return `${targetPath}.tmp.${owner.pid}.${owner.token}.${temporaryCounter}`;
 }
 function removeLeaseTemporaryPath(temporaryPath) {
-  if ((0, import_fs7.existsSync)(temporaryPath)) (0, import_fs7.rmSync)(temporaryPath, { recursive: true, force: true });
+  if ((0, import_fs6.existsSync)(temporaryPath)) (0, import_fs6.rmSync)(temporaryPath, { recursive: true, force: true });
 }
 function recoverLeaseArtifacts(indexPath, owner, backupTargets) {
   for (const targetPath of backupTargets) {
     const backupPath = createLeaseTemporaryPath(targetPath, owner, "bak");
-    if (!(0, import_fs7.existsSync)(backupPath)) continue;
-    if ((0, import_fs7.existsSync)(targetPath)) (0, import_fs7.rmSync)(targetPath, { recursive: true, force: true });
-    (0, import_fs7.renameSync)(backupPath, targetPath);
+    if (!(0, import_fs6.existsSync)(backupPath)) continue;
+    if ((0, import_fs6.existsSync)(targetPath)) (0, import_fs6.rmSync)(targetPath, { recursive: true, force: true });
+    (0, import_fs6.renameSync)(backupPath, targetPath);
   }
   const temporaryOwnerMarker = `.tmp.${owner.pid}.${owner.token}.`;
-  for (const entry of (0, import_fs7.readdirSync)(indexPath)) {
+  for (const entry of (0, import_fs6.readdirSync)(indexPath)) {
     if (!entry.includes(temporaryOwnerMarker)) continue;
-    (0, import_fs7.rmSync)(path12.join(indexPath, entry), { recursive: true, force: true });
+    (0, import_fs6.rmSync)(path10.join(indexPath, entry), { recursive: true, force: true });
   }
 }
 function completeLeaseRecovery(lease) {
@@ -5261,13 +5158,23 @@ function completeLeaseRecovery(lease) {
     }
   }
   for (const recovery of lease.recoveries) {
-    (0, import_fs7.rmSync)(recovery.markerPath, { recursive: true, force: true });
+    (0, import_fs6.rmSync)(recovery.markerPath, { recursive: true, force: true });
   }
 }
 
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab", "bash"]);
-var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "swift", "php", "apex", "zig", "gdscript", "matlab", "bash", "c", "cpp", "metal"]);
+var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex", "php"]);
+var CALL_GRAPH_RESOLUTION_VERSION = "4";
+var PHP_FUNCTION_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "function_definition"
+]);
+var PHP_CLASS_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "class_definition"
+]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
@@ -5280,6 +5187,9 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "enum_declaration",
   "function_definition",
   "class_definition",
+  "class_specifier",
+  "struct_specifier",
+  "namespace_definition",
   "decorated_definition",
   "method_declaration",
   "type_declaration",
@@ -5295,6 +5205,14 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "test_declaration",
   "struct_declaration",
   "union_declaration",
+  // Synthetic Swift declarations or declarations specific to tree-sitter-swift.
+  "actor_declaration",
+  "extension_declaration",
+  "protocol_declaration",
+  "protocol_function_declaration",
+  "init_declaration",
+  "deinit_declaration",
+  "subscript_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).
@@ -5304,6 +5222,53 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "const_statement",
   "class_name_statement"
 ]);
+var C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set(["class_specifier", "struct_specifier"]);
+function isCompatibleCFamilyCallTarget(language, callType, symbolKind) {
+  if (language !== "c" && language !== "cpp") return true;
+  if (symbolKind === "namespace_definition") return callType === "Import";
+  const isTypeSymbol = C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES.has(symbolKind);
+  if (callType === "Constructor" || callType === "Inherits" || callType === "Implements") {
+    return isTypeSymbol;
+  }
+  return !isTypeSymbol;
+}
+var EXECUTABLE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "function_item",
+  "protocol_function_declaration",
+  "init_declaration",
+  "deinit_declaration",
+  "subscript_declaration",
+  "constructor_definition",
+  "trigger_declaration",
+  "test_declaration"
+]);
+function findEnclosingSymbol(symbols, line, column) {
+  let best;
+  for (const symbol of symbols) {
+    if (line < symbol.startLine || line > symbol.endLine) continue;
+    if (column !== void 0 && (line === symbol.startLine && column < symbol.startCol || line === symbol.endLine && column >= symbol.endCol)) {
+      continue;
+    }
+    if (!best) {
+      best = symbol;
+      continue;
+    }
+    const span = symbol.endLine - symbol.startLine;
+    const bestSpan = best.endLine - best.startLine;
+    const isNarrowerPositionRange = column !== void 0 && span === bestSpan && symbol.startLine === best.startLine && symbol.endLine === best.endLine && symbol.startCol >= best.startCol && symbol.endCol <= best.endCol && (symbol.startCol > best.startCol || symbol.endCol < best.endCol);
+    const isMoreSpecificTie = span === bestSpan && symbol.startLine === best.startLine && EXECUTABLE_SYMBOL_CHUNK_TYPES.has(symbol.kind) && !EXECUTABLE_SYMBOL_CHUNK_TYPES.has(best.kind);
+    if (span < bestSpan || span === bestSpan && symbol.startLine > best.startLine || isNarrowerPositionRange || isMoreSpecificTie) {
+      best = symbol;
+    }
+  }
+  return best;
+}
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
   return Buffer.from(float32.buffer);
@@ -5388,6 +5353,8 @@ function hasBlameMetadata(metadata) {
 }
 var INDEX_METADATA_VERSION = "1";
 var EMBEDDING_STRATEGY_VERSION = "2";
+var SWIFT_PARSER_VERSION = "1";
+var METAL_PARSER_VERSION = "1";
 var RANKING_TOKEN_CACHE_LIMIT = 4096;
 var RANK_HYBRID_CACHE_LIMIT = 256;
 function createPendingChunkStorageText(texts) {
@@ -5544,9 +5511,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path13.resolve(filePath);
-  const normalizedRoot = path13.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path13.sep}`);
+  const normalizedFilePath = path11.resolve(filePath);
+  const normalizedRoot = path11.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path11.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5710,15 +5677,25 @@ function chunkTypeBoost(chunkType) {
     case "function_declaration":
     case "method":
     case "method_definition":
+    case "method_declaration":
+    case "protocol_function_declaration":
+    case "init_declaration":
+    case "deinit_declaration":
+    case "subscript_declaration":
     case "class":
     case "class_declaration":
+    case "actor_declaration":
+    case "extension_declaration":
       return 0.2;
     case "interface":
     case "type":
     case "enum":
+    case "enum_declaration":
     case "struct":
+    case "struct_declaration":
     case "impl":
     case "trait":
+    case "protocol_declaration":
     case "module":
       return 0.1;
     default:
@@ -5825,11 +5802,21 @@ function isImplementationChunkType(chunkType) {
     "function_declaration",
     "method",
     "method_definition",
+    "method_declaration",
+    "protocol_function_declaration",
+    "init_declaration",
+    "deinit_declaration",
+    "subscript_declaration",
     "class",
     "class_declaration",
+    "actor_declaration",
+    "extension_declaration",
     "interface",
+    "protocol_declaration",
     "type",
     "enum",
+    "enum_declaration",
+    "struct_declaration",
     "module"
   ].includes(chunkType);
 }
@@ -6646,24 +6633,24 @@ var Indexer = class {
     this.config = config;
     this.host = host;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   isLocalProjectIndexPath() {
-    const localProjectIndexPaths = [path13.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    const localProjectIndexPaths = [path11.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
     if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path13.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+      localProjectIndexPaths.push(path11.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
     }
     return localProjectIndexPaths.some((localPath) => {
-      if (!(0, import_fs8.existsSync)(localPath) || !(0, import_fs8.existsSync)(this.indexPath)) {
-        return path13.resolve(this.indexPath) === path13.resolve(localPath);
+      if (!(0, import_fs7.existsSync)(localPath) || !(0, import_fs7.existsSync)(this.indexPath)) {
+        return path11.resolve(this.indexPath) === path11.resolve(localPath);
       }
-      const indexStats = (0, import_fs8.statSync)(this.indexPath);
-      const localStats = (0, import_fs8.statSync)(localPath);
+      const indexStats = (0, import_fs7.statSync)(this.indexPath);
+      const localStats = (0, import_fs7.statSync)(localPath);
       return indexStats.dev === localStats.dev && indexStats.ino === localStats.ino;
     });
   }
@@ -6702,8 +6689,8 @@ var Indexer = class {
   async withIndexMutationLease(operation, callback) {
     const lease = acquireIndexLock(this.indexPath, operation);
     this.indexPath = lease.canonicalIndexPath;
-    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
     this.activeIndexLease = lease;
     let result;
     let callbackError;
@@ -6737,7 +6724,7 @@ var Indexer = class {
     } catch (error) {
       releaseError = error;
       this.writerArtifactFingerprint = null;
-      if (!(0, import_fs8.existsSync)(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+      if (!(0, import_fs7.existsSync)(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
         this.activeIndexLease = null;
       }
     }
@@ -6755,11 +6742,11 @@ var Indexer = class {
     return this.activeIndexLease;
   }
   loadFileHashCache() {
-    if (!(0, import_fs8.existsSync)(this.fileHashCachePath)) {
+    if (!(0, import_fs7.existsSync)(this.fileHashCachePath)) {
       return;
     }
     try {
-      const data = (0, import_fs8.readFileSync)(this.fileHashCachePath, "utf-8");
+      const data = (0, import_fs7.readFileSync)(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -6781,24 +6768,24 @@ var Indexer = class {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    (0, import_fs8.mkdirSync)(path13.dirname(targetPath), { recursive: true });
+    (0, import_fs7.mkdirSync)(path11.dirname(targetPath), { recursive: true });
     try {
-      (0, import_fs8.writeFileSync)(tempPath, data);
-      (0, import_fs8.renameSync)(tempPath, targetPath);
+      (0, import_fs7.writeFileSync)(tempPath, data);
+      (0, import_fs7.renameSync)(tempPath, targetPath);
     } finally {
       removeLeaseTemporaryPath(tempPath);
     }
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path13.join(this.indexPath, "inverted-index.json"),
+      path11.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path13.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path11.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path13.resolve(this.projectRoot, kbRoot));
+      roots.add(path11.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6807,31 +6794,54 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getBranchCatalogKeyFor(branchName) {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
+  getCallGraphResolutionMetadataKey() {
+    if (this.config.scope !== "global") {
+      return "index.callGraphResolutionVersion";
+    }
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    return `index.callGraphResolutionVersion.${projectHash}`;
+  }
+  getSwiftParserVersionMetadataKey() {
+    const key = "index.parser.swiftVersion";
+    if (this.config.scope !== "global") {
+      return key;
+    }
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
+  getMetalParserVersionMetadataKey() {
+    const key = "index.parser.metalVersion";
+    if (this.config.scope !== "global") {
+      return key;
+    }
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
   hasProjectForceReembedPending() {
     return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
   }
@@ -6923,7 +6933,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path13.resolve(this.projectRoot);
+    const projectRootPath = path11.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6946,7 +6956,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -7030,7 +7040,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -7064,7 +7074,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path13.resolve(this.projectRoot);
+    const projectRootPath = path11.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -7142,8 +7152,8 @@ var Indexer = class {
       });
     }
     if (this.config.scope === "global") {
-      if ((0, import_fs8.existsSync)(this.fileHashCachePath)) {
-        (0, import_fs8.unlinkSync)(this.fileHashCachePath);
+      if ((0, import_fs7.existsSync)(this.fileHashCachePath)) {
+        (0, import_fs7.unlinkSync)(this.fileHashCachePath);
       }
       await this.healthCheckUnlocked();
     }
@@ -7162,10 +7172,10 @@ var Indexer = class {
     }
   }
   loadSerializedFailedBatches() {
-    if (!(0, import_fs8.existsSync)(this.failedBatchesPath)) {
+    if (!(0, import_fs7.existsSync)(this.failedBatchesPath)) {
       return [];
     }
-    const data = (0, import_fs8.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 : [];
@@ -7182,9 +7192,9 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if ((0, import_fs8.existsSync)(this.failedBatchesPath)) {
+      if ((0, import_fs7.existsSync)(this.failedBatchesPath)) {
         try {
-          (0, import_fs8.unlinkSync)(this.failedBatchesPath);
+          (0, import_fs7.unlinkSync)(this.failedBatchesPath);
         } catch {
         }
       }
@@ -7370,7 +7380,7 @@ var Indexer = class {
     const intent = isLikelyImplementationPath(candidate.metadata.filePath) ? "implementation" : "doc_or_test";
     parts.push(`intent_hint: ${intent}`);
     try {
-      const fileContent = await import_fs8.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);
@@ -7464,7 +7474,7 @@ var Indexer = class {
   }
   getReaderFileFingerprint(filePath, identityOnly = false) {
     try {
-      const stats = (0, import_fs8.statSync)(filePath);
+      const stats = (0, import_fs7.statSync)(filePath);
       if (identityOnly) {
         return `${stats.dev}:${stats.ino}`;
       }
@@ -7474,12 +7484,12 @@ var Indexer = class {
     }
   }
   captureReaderArtifactFingerprint() {
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     return {
       vectors: `${this.getReaderFileFingerprint(storePath)}|${this.getReaderFileFingerprint(`${storePath}.meta.json`)}`,
-      keyword: this.getReaderFileFingerprint(path13.join(this.indexPath, "inverted-index.json")),
-      database: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db")),
-      databaseIdentity: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db"), true)
+      keyword: this.getReaderFileFingerprint(path11.join(this.indexPath, "inverted-index.json")),
+      database: this.getReaderFileFingerprint(path11.join(this.indexPath, "codebase.db")),
+      databaseIdentity: this.getReaderFileFingerprint(path11.join(this.indexPath, "codebase.db"), true)
     };
   }
   refreshReaderArtifacts() {
@@ -7504,13 +7514,13 @@ var Indexer = class {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
-    const dbPath = path13.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
-      const vectorStoreExists = (0, import_fs8.existsSync)(storePath);
-      const vectorMetadataExists = (0, import_fs8.existsSync)(vectorMetadataPath);
+      const vectorStoreExists = (0, import_fs7.existsSync)(storePath);
+      const vectorMetadataExists = (0, import_fs7.existsSync)(vectorMetadataPath);
       if (vectorStoreExists && vectorMetadataExists) {
         try {
           const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
@@ -7525,8 +7535,8 @@ var Indexer = class {
         setIssue("vectors", this.getVectorReadIssueMessage());
       }
     }
-    if (keywordChanged || retryDue("keyword") || !(0, import_fs8.existsSync)(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
-      if ((0, import_fs8.existsSync)(invertedIndexPath)) {
+    if (keywordChanged || retryDue("keyword") || !(0, import_fs7.existsSync)(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if ((0, import_fs7.existsSync)(invertedIndexPath)) {
         try {
           const invertedIndex = new InvertedIndex(invertedIndexPath);
           invertedIndex.load();
@@ -7541,7 +7551,7 @@ var Indexer = class {
       }
     }
     if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
-      if ((0, import_fs8.existsSync)(dbPath)) {
+      if ((0, import_fs7.existsSync)(dbPath)) {
         try {
           const database = Database.openReadOnly(dbPath);
           if (this.database) {
@@ -7632,14 +7642,14 @@ var Indexer = class {
       }
     }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
-    const dbPath = path13.join(this.indexPath, "codebase.db");
-    let dbIsNew = !(0, import_fs8.existsSync)(dbPath);
+    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
+    let dbIsNew = !(0, import_fs7.existsSync)(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
-      await import_fs8.promises.mkdir(this.indexPath, { recursive: true });
+      await import_fs7.promises.mkdir(this.indexPath, { recursive: true });
       if (recoveredOwners.length > 0 && this.config.scope === "project" && !this.isLocalProjectIndexPath()) {
         throw new Error(
           "Interrupted indexing recovery is unsafe while using an inherited worktree index. Run index_codebase with force=true to create a local project index boundary."
@@ -7655,15 +7665,15 @@ var Indexer = class {
         await this.resetLocalIndexArtifacts();
       }
       this.store = new VectorStore(storePath, dimensions);
-      if ((0, import_fs8.existsSync)(storePath) || (0, import_fs8.existsSync)(vectorMetadataPath)) {
+      if ((0, import_fs7.existsSync)(storePath) || (0, import_fs7.existsSync)(vectorMetadataPath)) {
         this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
       try {
         this.invertedIndex.load();
       } catch {
-        if ((0, import_fs8.existsSync)(invertedIndexPath)) {
-          await import_fs8.promises.unlink(invertedIndexPath);
+        if ((0, import_fs7.existsSync)(invertedIndexPath)) {
+          await import_fs7.promises.unlink(invertedIndexPath);
         }
         this.invertedIndex = new InvertedIndex(invertedIndexPath);
       }
@@ -7680,8 +7690,8 @@ var Indexer = class {
       }
     } else {
       this.store = new VectorStore(storePath, dimensions);
-      const vectorStoreExists = (0, import_fs8.existsSync)(storePath);
-      const vectorMetadataExists = (0, import_fs8.existsSync)(vectorMetadataPath);
+      const vectorStoreExists = (0, import_fs7.existsSync)(storePath);
+      const vectorMetadataExists = (0, import_fs7.existsSync)(vectorMetadataPath);
       const vectorReadFailureMessage = this.getVectorReadIssueMessage();
       if (vectorStoreExists !== vectorMetadataExists) {
         this.recordReadIssue("vectors", vectorReadFailureMessage);
@@ -7694,7 +7704,7 @@ var Indexer = class {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if ((0, import_fs8.existsSync)(invertedIndexPath)) {
+      if ((0, import_fs7.existsSync)(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -7708,7 +7718,7 @@ var Indexer = class {
       } else if (this.store.count() > 0) {
         this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
       }
-      if ((0, import_fs8.existsSync)(dbPath)) {
+      if ((0, import_fs7.existsSync)(dbPath)) {
         try {
           this.database = Database.openReadOnly(dbPath);
         } catch (error) {
@@ -7799,7 +7809,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -7814,7 +7824,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path13.join(this.indexPath, "vectors");
+    const storeBasePath = path11.join(this.indexPath, "vectors");
     const storeIndexPath = storeBasePath;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const lease = this.requireActiveLease();
@@ -7824,19 +7834,19 @@ var Indexer = class {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if ((0, import_fs8.existsSync)(backupIndexPath)) {
-      (0, import_fs8.unlinkSync)(backupIndexPath);
+    if ((0, import_fs7.existsSync)(backupIndexPath)) {
+      (0, import_fs7.unlinkSync)(backupIndexPath);
     }
-    if ((0, import_fs8.existsSync)(backupMetadataPath)) {
-      (0, import_fs8.unlinkSync)(backupMetadataPath);
+    if ((0, import_fs7.existsSync)(backupMetadataPath)) {
+      (0, import_fs7.unlinkSync)(backupMetadataPath);
     }
     try {
-      if ((0, import_fs8.existsSync)(storeIndexPath)) {
-        (0, import_fs8.renameSync)(storeIndexPath, backupIndexPath);
+      if ((0, import_fs7.existsSync)(storeIndexPath)) {
+        (0, import_fs7.renameSync)(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if ((0, import_fs8.existsSync)(storeMetadataPath)) {
-        (0, import_fs8.renameSync)(storeMetadataPath, backupMetadataPath);
+      if ((0, import_fs7.existsSync)(storeMetadataPath)) {
+        (0, import_fs7.renameSync)(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -7856,11 +7866,11 @@ var Indexer = class {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && (0, import_fs8.existsSync)(backupIndexPath)) {
-        (0, import_fs8.unlinkSync)(backupIndexPath);
+      if (backedUpIndex && (0, import_fs7.existsSync)(backupIndexPath)) {
+        (0, import_fs7.unlinkSync)(backupIndexPath);
       }
-      if (backedUpMetadata && (0, import_fs8.existsSync)(backupMetadataPath)) {
-        (0, import_fs8.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,
@@ -7872,17 +7882,17 @@ var Indexer = class {
         store.clear();
       } catch {
       }
-      if ((0, import_fs8.existsSync)(storeIndexPath)) {
-        (0, import_fs8.unlinkSync)(storeIndexPath);
+      if ((0, import_fs7.existsSync)(storeIndexPath)) {
+        (0, import_fs7.unlinkSync)(storeIndexPath);
       }
-      if ((0, import_fs8.existsSync)(storeMetadataPath)) {
-        (0, import_fs8.unlinkSync)(storeMetadataPath);
+      if ((0, import_fs7.existsSync)(storeMetadataPath)) {
+        (0, import_fs7.unlinkSync)(storeMetadataPath);
       }
-      if (backedUpIndex && (0, import_fs8.existsSync)(backupIndexPath)) {
-        (0, import_fs8.renameSync)(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && (0, import_fs7.existsSync)(backupIndexPath)) {
+        (0, import_fs7.renameSync)(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && (0, import_fs8.existsSync)(backupMetadataPath)) {
-        (0, import_fs8.renameSync)(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && (0, import_fs7.existsSync)(backupMetadataPath)) {
+        (0, import_fs7.renameSync)(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -7909,24 +7919,24 @@ var Indexer = class {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path13.join(this.indexPath, "codebase.db"),
-      path13.join(this.indexPath, "codebase.db-shm"),
-      path13.join(this.indexPath, "codebase.db-wal"),
-      path13.join(this.indexPath, "vectors"),
-      path13.join(this.indexPath, "vectors.usearch"),
-      path13.join(this.indexPath, "vectors.meta.json"),
-      path13.join(this.indexPath, "inverted-index.json"),
-      path13.join(this.indexPath, "file-hashes.json"),
-      path13.join(this.indexPath, "failed-batches.json")
+      path11.join(this.indexPath, "codebase.db"),
+      path11.join(this.indexPath, "codebase.db-shm"),
+      path11.join(this.indexPath, "codebase.db-wal"),
+      path11.join(this.indexPath, "vectors"),
+      path11.join(this.indexPath, "vectors.usearch"),
+      path11.join(this.indexPath, "vectors.meta.json"),
+      path11.join(this.indexPath, "inverted-index.json"),
+      path11.join(this.indexPath, "file-hashes.json"),
+      path11.join(this.indexPath, "failed-batches.json")
     ];
-    await Promise.all(resetPaths.map((targetPath) => import_fs8.promises.rm(targetPath, { recursive: true, force: true })));
-    await import_fs8.promises.mkdir(this.indexPath, { recursive: true });
+    await Promise.all(resetPaths.map((targetPath) => import_fs7.promises.rm(targetPath, { recursive: true, force: true })));
+    await import_fs7.promises.mkdir(this.indexPath, { recursive: true });
   }
   async tryResetCorruptedIndex(stage, error) {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path13.join(this.indexPath, "codebase.db");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
@@ -7992,6 +8002,7 @@ var Indexer = class {
     this.database.setMetadata("index.embeddingProvider", provider.provider);
     this.database.setMetadata("index.embeddingModel", provider.modelInfo.model);
     this.database.setMetadata("index.embeddingDimensions", provider.modelInfo.dimensions.toString());
+    this.database.setMetadata(this.getCallGraphResolutionMetadataKey(), CALL_GRAPH_RESOLUTION_VERSION);
     if (this.config.scope === "global") {
       if (completeProjectEmbeddingStrategyReset) {
         this.database.setMetadata(this.getProjectEmbeddingStrategyMetadataKey(), EMBEDDING_STRATEGY_VERSION);
@@ -8179,6 +8190,20 @@ var Indexer = class {
       totalChunks: 0
     });
     this.loadFileHashCache();
+    const swiftParserMetadataKey = this.getSwiftParserVersionMetadataKey();
+    const reparseCachedSwiftFiles = database.getMetadata(swiftParserMetadataKey) !== SWIFT_PARSER_VERSION;
+    const metalParserMetadataKey = this.getMetalParserVersionMetadataKey();
+    const reparseCachedMetalFiles = database.getMetadata(metalParserMetadataKey) !== METAL_PARSER_VERSION;
+    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path11.extname(filePath).toLowerCase() === ".swift"
+    )) {
+      this.logger.info("Reindexing cached Swift files for parser support");
+    }
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path11.extname(filePath).toLowerCase() === ".metal"
+    )) {
+      this.logger.info("Reindexing cached Metal files for parser support");
+    }
     const includePatterns = [...this.config.include, ...this.config.additionalInclude];
     const { files, skipped } = await collectFiles(
       this.projectRoot,
@@ -8198,14 +8223,21 @@ var Indexer = class {
     const changedFiles = [];
     const unchangedFilePaths = /* @__PURE__ */ new Set();
     const currentFileHashes = /* @__PURE__ */ new Map();
+    const needsCallGraphResolutionMigration = database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION;
     for (const f of files) {
       const currentHash = hashFile(f.path);
       currentFileHashes.set(f.path, currentHash);
-      if (this.fileHashCache.get(f.path) === currentHash) {
+      const cachedHashMatches = this.fileHashCache.get(f.path) === currentHash;
+      const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(f.path).some(
+        (chunk) => chunk.language === "php" || chunk.language === "c" || chunk.language === "cpp"
+      );
+      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path11.extname(f.path).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path11.extname(f.path).toLowerCase() === ".metal";
+      if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade) {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
-        const content = await import_fs8.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();
       }
@@ -8303,7 +8335,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path13.relative(this.projectRoot, parsed.path);
+        const relativePath = path11.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let chunksToProcess = parsed.chunks;
@@ -8403,16 +8435,28 @@ var Indexer = class {
       const fileSymbols = [];
       for (const chunk of parsed.chunks) {
         if (!chunk.name || !CALL_GRAPH_SYMBOL_CHUNK_TYPES.has(chunk.chunkType)) continue;
-        const symbolId = `sym_${hashContent(parsed.path + ":" + chunk.name + ":" + chunk.chunkType + ":" + chunk.startLine).slice(0, 16)}`;
+        const existingMetalSymbol = chunk.language === "metal" ? fileSymbols.find(
+          (symbol2) => symbol2.name === chunk.name && symbol2.kind === chunk.chunkType && symbol2.startLine <= chunk.endLine && chunk.startLine <= symbol2.endLine
+        ) : void 0;
+        if (existingMetalSymbol) {
+          existingMetalSymbol.startLine = Math.min(existingMetalSymbol.startLine, chunk.startLine);
+          existingMetalSymbol.endLine = Math.max(existingMetalSymbol.endLine, chunk.endLine);
+          existingMetalSymbol.startCol = Math.min(existingMetalSymbol.startCol, chunk.startCol ?? 0);
+          existingMetalSymbol.endCol = Math.max(existingMetalSymbol.endCol, chunk.endCol ?? 0);
+          continue;
+        }
+        const symbolId = `sym_${hashContent(
+          parsed.path + ":" + chunk.name + ":" + chunk.chunkType + ":" + chunk.startLine + ":" + (chunk.startCol ?? 0)
+        ).slice(0, 16)}`;
         const symbol = {
           id: symbolId,
           filePath: parsed.path,
           name: chunk.name,
           kind: chunk.chunkType,
           startLine: chunk.startLine,
-          startCol: 0,
+          startCol: chunk.startCol ?? 0,
           endLine: chunk.endLine,
-          endCol: 0,
+          endCol: chunk.endCol ?? 0,
           language: chunk.language
         };
         fileSymbols.push(symbol);
@@ -8437,8 +8481,10 @@ var Indexer = class {
       if (callSites.length === 0) continue;
       const edges = [];
       for (const site of callSites) {
-        const enclosingSymbol = fileSymbols.find(
-          (sym) => site.line >= sym.startLine && site.line <= sym.endLine
+        const enclosingSymbol = findEnclosingSymbol(
+          fileSymbols,
+          site.line,
+          site.column
         );
         if (!enclosingSymbol) continue;
         const edgeId = `edge_${hashContent(enclosingSymbol.id + ":" + site.calleeName + ":" + site.line + ":" + site.column).slice(0, 16)}`;
@@ -8457,7 +8503,21 @@ var Indexer = class {
       if (edges.length > 0) {
         database.upsertCallEdgesBatch(edges);
         for (const edge of edges) {
-          const candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
+          let candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
+          if (fileLanguage === "php" && candidates) {
+            if (edge.callType === "Constructor") {
+              candidates = candidates.filter(
+                (candidate) => PHP_CLASS_SYMBOL_CHUNK_TYPES.has(candidate.kind)
+              );
+            } else if (edge.callType === "Call") {
+              candidates = candidates.filter(
+                (candidate) => PHP_FUNCTION_SYMBOL_CHUNK_TYPES.has(candidate.kind)
+              );
+            }
+          }
+          candidates = candidates?.filter(
+            (symbol) => isCompatibleCFamilyCallTarget(fileLanguage, edge.callType, symbol.kind)
+          );
           if (candidates && candidates.length === 1) {
             database.resolveCallEdge(edge.id, candidates[0].id);
           }
@@ -8499,8 +8559,8 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
-      const vectorPath = path13.join(this.indexPath, "vectors");
-      const shouldFingerprintLegacyPair = !store.hasFingerprint() && (0, import_fs8.existsSync)(vectorPath) && (0, import_fs8.existsSync)(`${vectorPath}.meta.json`);
+      const vectorPath = path11.join(this.indexPath, "vectors");
+      const shouldFingerprintLegacyPair = !store.hasFingerprint() && (0, import_fs7.existsSync)(vectorPath) && (0, import_fs7.existsSync)(`${vectorPath}.meta.json`);
       if (backfilledBlameMetadata || shouldFingerprintLegacyPair) {
         store.save();
       }
@@ -8512,6 +8572,8 @@ var Indexer = class {
         this.saveFileHashCache();
         this.saveFailedBatches([]);
       }
+      database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+      database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
@@ -8539,6 +8601,8 @@ var Indexer = class {
         this.saveFileHashCache();
         this.saveFailedBatches([]);
       }
+      database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+      database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
@@ -8809,6 +8873,8 @@ var Indexer = class {
     if (forceScopedReembed && failedForcedChunkIds.size === 0) {
       database.deleteMetadata(this.getProjectForceReembedMetadataKey());
     }
+    database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+    database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
     this.saveIndexMetadata(configuredProviderInfo);
     this.indexCompatibility = { compatible: true };
     this.logger.recordIndexingEnd();
@@ -9055,7 +9121,7 @@ var Indexer = class {
         let contextEndLine = r.metadata.endLine;
         if (!metadataOnly && this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs8.promises.readFile(
+            const fileContent = await import_fs7.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -9242,7 +9308,7 @@ var Indexer = class {
     const removedChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!(0, import_fs8.existsSync)(filePath)) {
+      if (!(0, import_fs7.existsSync)(filePath)) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           removedChunkKeys.push(key);
@@ -9291,7 +9357,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -9601,7 +9667,7 @@ var Indexer = class {
         let content = "";
         if (this.config.search.includeContext) {
           try {
-            const fileContent = await import_fs8.promises.readFile(
+            const fileContent = await import_fs7.promises.readFile(
               r.metadata.filePath,
               "utf-8"
             );
@@ -9721,7 +9787,7 @@ var Indexer = class {
         "Run index_codebase first to build the call graph and symbol index for this branch."
       );
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path13.resolve(this.projectRoot, f));
+    const absoluteChangedFiles = changedFiles.map((f) => path11.resolve(this.projectRoot, f));
     const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
@@ -9804,7 +9870,7 @@ var Indexer = class {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path13.resolve(this.projectRoot, f));
+            const otherAbsolute = otherChanged.files.map((f) => path11.resolve(this.projectRoot, f));
             const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
             const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
@@ -9868,12 +9934,12 @@ var Indexer = class {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path13.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path11.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path13.resolve(filePath);
+          const absoluteFilePath = path11.resolve(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path13.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path11.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -9916,43 +9982,43 @@ var Indexer = class {
 };
 
 // src/tools/knowledge-base-paths.ts
-var path14 = __toESM(require("path"), 1);
+var path12 = __toESM(require("path"), 1);
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path14.isAbsolute(trimmed) ? trimmed : path14.resolve(baseDir, trimmed);
-  return path14.normalize(absolutePath);
+  const absolutePath = path12.isAbsolute(trimmed) ? trimmed : path12.resolve(baseDir, trimmed);
+  return path12.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path14.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path14.normalize(trimmed));
+  if (!path12.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path12.normalize(trimmed));
   }
-  const relativePath = path14.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path14.normalize(relativePath || "."));
+  const relativePath = path12.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path12.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path12.normalize(relativePath || "."));
   }
-  return path14.normalize(trimmed);
+  return path12.normalize(trimmed);
 }
 function resolveKnowledgeBasePath(value, projectRoot3) {
-  return path14.isAbsolute(value) ? value : path14.resolve(projectRoot3, value);
+  return path12.isAbsolute(value) ? value : path12.resolve(projectRoot3, value);
 }
-function normalizeKnowledgeBasePath2(value, projectRoot3) {
-  return path14.normalize(resolveKnowledgeBasePath(value, projectRoot3));
+function normalizeKnowledgeBasePath(value, projectRoot3) {
+  return path12.normalize(resolveKnowledgeBasePath(value, projectRoot3));
 }
 function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot3) {
-  const normalizedInput = path14.normalize(inputPath);
-  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput);
+  const normalizedInput = path12.normalize(inputPath);
+  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath(kb, projectRoot3) === normalizedInput);
 }
 function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot3) {
-  const normalizedInput = path14.normalize(inputPath);
+  const normalizedInput = path12.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path14.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput
+    (kb) => path12.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath(kb, projectRoot3) === normalizedInput
   );
 }
 
@@ -10354,6 +10420,193 @@ ${truncateContent(r.content)}
 // src/tools/config-state.ts
 var import_fs9 = require("fs");
 var path15 = __toESM(require("path"), 1);
+
+// src/config/merger.ts
+var import_fs8 = require("fs");
+var path14 = __toESM(require("path"), 1);
+
+// src/config/rebase.ts
+var path13 = __toESM(require("path"), 1);
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path13.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath);
+}
+function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    if (path13.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizePathSeparators(path13.normalize(path13.relative(sourceRoot, trimmed) || "."));
+      }
+      return path13.normalize(trimmed);
+    }
+    const resolvedFromSource = path13.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizePathSeparators(path13.normalize(trimmed));
+    }
+    return normalizePathSeparators(path13.normalize(path13.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 normalizeKnowledgeBasePath2(value) {
+  let normalized = path14.normalize(String(value).trim());
+  const root = path14.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) => normalizeKnowledgeBasePath2(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_fs8.existsSync)(filePath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_fs8.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}`);
+  }
+}
+function loadProjectConfigLayer(projectRoot3, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
+  }
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path14.dirname(path14.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot3
+    );
+  }
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot3, host = "opencode") {
+  const globalConfigPath = resolveGlobalConfigPath(host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
+  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(projectRoot3, host);
+  if (globalConfigError) {
+    if (!projectConfig) {
+      throw globalConfigError;
+    }
+    globalConfig = null;
+  }
+  if (!globalConfig && !projectConfig) {
+    return {};
+  }
+  if (!projectConfig && globalConfig) {
+    return globalConfig;
+  }
+  if (!globalConfig && projectConfig) {
+    return normalizedProjectConfig;
+  }
+  if (!globalConfig || !projectConfig) {
+    return globalConfig ?? normalizedProjectConfig;
+  }
+  const merged = { ...globalConfig };
+  for (const key of PROJECT_OVERRIDE_KEYS) {
+    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
+  }
+  if (projectConfig) {
+    for (const key of Object.keys(projectConfig)) {
+      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
+        continue;
+      }
+      merged[key] = normalizedProjectConfig[key];
+    }
+  }
+  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
+  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
+  const allKbs = [...globalKbs, ...projectKbs];
+  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
+  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
+  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
+  const allAdditional = [...globalAdditional, ...projectAdditional];
+  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
+  return merged;
+}
+
+// src/tools/config-state.ts
 function normalizeKnowledgeBasePaths(config, projectRoot3) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -10451,15 +10704,6 @@ function refreshIndexerForDirectory(projectRoot3, host = "opencode", config = pa
   indexerCache.set(key, indexer);
   configCache.set(key, config);
 }
-function shouldForceLocalizeProjectIndex(projectRoot3, host = "opencode") {
-  const root = getProjectRoot(projectRoot3, host);
-  const localIndexPath = path16.join(root, getHostProjectIndexRelativePath(host));
-  if ((0, import_fs10.existsSync)(localIndexPath)) {
-    return false;
-  }
-  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
-  return inheritedIndexPath !== null;
-}
 async function searchCodebase(projectRoot3, host, query, options = {}) {
   const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.search(query, options.limit, {
@@ -10509,9 +10753,7 @@ async function getCallGraphPath(projectRoot3, host, from, to, maxDepth) {
 }
 async function runIndexCodebase(projectRoot3, host, args, onProgress) {
   const root = getProjectRoot(projectRoot3, host);
-  const key = getIndexerCacheKey(root, host);
-  let indexer = getIndexerForProject(root, host);
-  const runtimeConfig = configCache.get(key);
+  const indexer = getIndexerForProject(root, host);
   try {
     if (args.estimateOnly) {
       return { kind: "estimate", estimate: await indexer.estimateCost() };
@@ -10532,19 +10774,7 @@ async function runIndexCodebase(projectRoot3, host, args, onProgress) {
         return Promise.resolve();
       });
     };
-    let stats;
-    if (args.force && shouldForceLocalizeProjectIndex(root, host)) {
-      const inheritedIndexPath = resolveProjectIndexPath(root, runtimeConfig.scope, host);
-      stats = await withIndexLock(inheritedIndexPath, "force-index", async () => {
-        materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
-        refreshIndexerForDirectory(root, host, runtimeConfig);
-        indexer = getIndexerForProject(root, host);
-        return runIndex(indexer);
-      }, { completeRecoveries: false });
-    } else {
-      stats = await runIndex(indexer);
-    }
-    return { kind: "stats", stats };
+    return { kind: "stats", stats: await runIndex(indexer) };
   } catch (error) {
     const busyResult = getIndexBusyResult(error);
     if (!busyResult) throw error;