opencode-codebase-index 0.17.1 → 0.18.1

package/dist/cli.js

@@ -653,7 +653,7 @@ var require_ignore = __commonJS({
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { realpathSync as realpathSync3, writeFileSync as writeFileSync7 } from "fs";
+import { realpathSync as realpathSync3, writeFileSync as writeFileSync6 } from "fs";
 import * as os6 from "os";
 import * as path26 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -673,7 +673,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
   "**/*.zig",
-  "**/*.gd"
+  "**/*.gd",
+  "**/*.metal"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -864,6 +865,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) {
@@ -2446,6 +2450,9 @@ function loadOpenCodeAuth() {
   return {};
 }
 async function detectEmbeddingProvider(preferredProvider, model) {
+  if (preferredProvider === "ollama") {
+    return detectOllamaProvider(model);
+  }
   const credentials = await getProviderCredentials(preferredProvider);
   if (credentials) {
     if (!model) {
@@ -2461,10 +2468,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(
@@ -2473,6 +2486,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 {
@@ -2540,32 +2560,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":
@@ -2905,6 +2998,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);
   }
@@ -2979,22 +3073,45 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     }
   }
   async embedSingle(text) {
-    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.modelInfo.model,
-        prompt: text,
-        truncate: false
-      })
-    });
+    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: text,
+          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(text)
@@ -3905,7 +4022,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
@@ -4026,6 +4145,7 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     javascript: "JavaScript",
     python: "Python",
     rust: "Rust",
+    swift: "Swift",
     go: "Go",
     java: "Java"
   };
@@ -4034,7 +4154,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",
@@ -4728,16 +4857,6 @@ function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const fallbackPath = path8.join(mainRepoRoot, relativePath);
   return existsSync5(fallbackPath) ? fallbackPath : null;
 }
-function resolveWorktreeFallbackProjectIndexPath(projectRoot, host) {
-  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot, getProjectIndexRelativePath(host));
-  if (inheritedHostPath) {
-    return inheritedHostPath;
-  }
-  if (host !== "opencode") {
-    return resolveWorktreeFallbackPath(projectRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
-  }
-  return null;
-}
 function getHostProjectIndexRelativePath(host) {
   return getProjectIndexRelativePath(host);
 }
@@ -4839,6 +4958,9 @@ function resolveProjectIndexPath(projectRoot, scope, host = "opencode") {
   if (hasHostProjectConfig(projectRoot, host)) {
     return localIndexPath;
   }
+  if (resolveWorktreeMainRepoRoot(projectRoot)) {
+    return localIndexPath;
+  }
   const hostFallback = resolveWorktreeFallbackPath(projectRoot, getProjectIndexRelativePath(host));
   if (hostFallback) {
     return hostFallback;
@@ -5373,40 +5495,6 @@ function releaseIndexLock(lease) {
   }
   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;
@@ -5441,8 +5529,18 @@ function completeLeaseRecovery(lease) {
 }
 
 // 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",
@@ -5455,6 +5553,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",
@@ -5470,6 +5571,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).
@@ -5479,6 +5588,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);
@@ -5563,6 +5719,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) {
@@ -5885,15 +6043,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:
@@ -6000,11 +6168,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);
 }
@@ -7007,6 +7185,29 @@ var Indexer = class {
     const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
+  getCallGraphResolutionMetadataKey() {
+    if (this.config.scope !== "global") {
+      return "index.callGraphResolutionVersion";
+    }
+    const projectHash = hashContent(path12.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(path12.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(path12.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
   hasProjectForceReembedPending() {
     return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
   }
@@ -8167,6 +8368,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);
@@ -8354,6 +8556,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) => path12.extname(filePath).toLowerCase() === ".swift"
+    )) {
+      this.logger.info("Reindexing cached Swift files for parser support");
+    }
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path12.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,
@@ -8373,10 +8589,17 @@ 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 && path12.extname(f.path).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path12.extname(f.path).toLowerCase() === ".metal";
+      if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade) {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
@@ -8578,16 +8801,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);
@@ -8612,8 +8847,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)}`;
@@ -8632,7 +8869,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);
           }
@@ -8687,6 +8938,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;
@@ -8714,6 +8967,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;
@@ -8984,6 +9239,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();
@@ -10094,251 +10351,45 @@ var Indexer = class {
 import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import * as path17 from "path";
 
-// src/config/merger.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import * as path14 from "path";
-
-// src/config/rebase.ts
+// src/tools/knowledge-base-paths.ts
 import * as path13 from "path";
-function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path13.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath);
-}
-function rebasePathEntries(values, fromDir, toDir) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed || path13.isAbsolute(trimmed)) {
-      return trimmed;
-    }
-    return normalizePathSeparators(path13.normalize(path13.relative(toDir, path13.resolve(fromDir, trimmed))));
-  }).filter(Boolean);
-}
-function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
-  if (!Array.isArray(values)) {
-    return [];
+function resolveConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
   }
-  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);
+  const absolutePath = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
+  return path13.normalize(absolutePath);
 }
 
-// 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];
+// src/tools/utils.ts
+import { get_encoding } from "tiktoken";
+var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
+var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
+var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
+var CONTEXT_TOKENIZER = get_encoding("cl100k_base");
+function clampContextPackTokenBudget(tokenBudget) {
+  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
+    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
   }
+  return Math.min(
+    MAX_CONTEXT_PACK_TOKEN_BUDGET,
+    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
+  );
 }
-function mergeUniqueStringArray(values) {
-  return [...new Set(values.map((value) => String(value).trim()))];
+function countContextTokens(text) {
+  return CONTEXT_TOKENIZER.encode(text).length;
 }
-function normalizeKnowledgeBasePath(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) => 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 (!existsSync8(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync8(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 loadConfigFile(filePath) {
-  return loadJsonFile(filePath);
-}
-function materializeLocalProjectConfig(projectRoot, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot, host);
-  mkdirSync4(path14.dirname(localConfigPath), { recursive: true });
-  writeFileSync4(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
-}
-function loadProjectConfigLayer(projectRoot, host = "opencode") {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot, 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,
-      projectRoot
-    );
-  }
-  return normalizedConfig;
-}
-function loadMergedConfig(projectRoot, host = "opencode") {
-  const globalConfigPath = resolveGlobalConfigPath(host);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot, 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(projectRoot, 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/knowledge-base-paths.ts
-import * as path15 from "path";
-function resolveConfigPathValue(value, baseDir) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  const absolutePath = path15.isAbsolute(trimmed) ? trimmed : path15.resolve(baseDir, trimmed);
-  return path15.normalize(absolutePath);
-}
-
-// src/tools/utils.ts
-import { get_encoding } from "tiktoken";
-var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
-var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
-var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
-var CONTEXT_TOKENIZER = get_encoding("cl100k_base");
-function clampContextPackTokenBudget(tokenBudget) {
-  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
-    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
-  }
-  return Math.min(
-    MAX_CONTEXT_PACK_TOKEN_BUDGET,
-    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
-  );
-}
-function countContextTokens(text) {
-  return CONTEXT_TOKENIZER.encode(text).length;
-}
-function fitTextToContextBudget(text, tokenBudget) {
-  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
-  const tokenEstimate = countContextTokens(text);
-  if (tokenEstimate <= normalizedBudget) {
-    return {
-      text,
-      tokenBudget: normalizedBudget,
-      tokenEstimate,
-      truncated: false
-    };
+function fitTextToContextBudget(text, tokenBudget) {
+  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
+  const tokenEstimate = countContextTokens(text);
+  if (tokenEstimate <= normalizedBudget) {
+    return {
+      text,
+      tokenBudget: normalizedBudget,
+      tokenEstimate,
+      truncated: false
+    };
   }
   const suffix = "\n...[truncated to context token budget]";
   const codePoints = Array.from(text);
@@ -10718,8 +10769,210 @@ ${truncateContent(r.content)}
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import * as path16 from "path";
+
+// src/config/merger.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import * as path15 from "path";
+
+// src/config/rebase.ts
+import * as path14 from "path";
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path14.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath);
+}
+function rebasePathEntries(values, fromDir, toDir) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed || path14.isAbsolute(trimmed)) {
+      return trimmed;
+    }
+    return normalizePathSeparators(path14.normalize(path14.relative(toDir, path14.resolve(fromDir, trimmed))));
+  }).filter(Boolean);
+}
+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 (path14.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizePathSeparators(path14.normalize(path14.relative(sourceRoot, trimmed) || "."));
+      }
+      return path14.normalize(trimmed);
+    }
+    const resolvedFromSource = path14.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizePathSeparators(path14.normalize(trimmed));
+    }
+    return normalizePathSeparators(path14.normalize(path14.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 = path15.normalize(String(value).trim());
+  const root = path15.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 (!existsSync8(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync8(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 loadConfigFile(filePath) {
+  return loadJsonFile(filePath);
+}
+function loadProjectConfigLayer(projectRoot, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
+  }
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path15.dirname(path15.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot
+    );
+  }
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot, host = "opencode") {
+  const globalConfigPath = resolveGlobalConfigPath(host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, 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(projectRoot, 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, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -10803,15 +11056,6 @@ function refreshIndexerForDirectory(projectRoot, host = "opencode", config = par
   indexerCache.set(key, indexer);
   configCache.set(key, config);
 }
-function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
-  const root = getProjectRoot(projectRoot, host);
-  const localIndexPath = path17.join(root, getHostProjectIndexRelativePath(host));
-  if (existsSync10(localIndexPath)) {
-    return false;
-  }
-  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
-  return inheritedIndexPath !== null;
-}
 async function searchCodebase(projectRoot, host, query, options = {}) {
   const indexer = getIndexerForProject(projectRoot, host);
   return indexer.search(query, options.limit, {
@@ -10861,9 +11105,7 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, 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() };
@@ -10884,19 +11126,7 @@ async function runIndexCodebase(projectRoot, 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;
@@ -11554,7 +11784,7 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
 }
 
 // src/eval/runner-config.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import * as os5 from "os";
 import * as path18 from "path";
 function isRecord2(value) {
@@ -11676,8 +11906,8 @@ function ensureLocalEvalProjectConfig(projectRoot, configPath) {
     projectRoot,
     resolvedConfigPath
   );
-  mkdirSync6(path18.dirname(localConfigPath), { recursive: true });
-  writeFileSync6(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
+  mkdirSync5(path18.dirname(localConfigPath), { recursive: true });
+  writeFileSync5(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
   return localConfigPath;
 }
 function loadParsedConfig(projectRoot, configPath) {
@@ -15790,7 +16020,7 @@ async function handleVisualizeCommand(argv, cwd) {
       return 1;
     }
     const outputPath = path26.join(os6.tmpdir(), `call-graph-${Date.now()}.html`);
-    writeFileSync7(outputPath, generateVisualizationHtml(vizData), "utf-8");
+    writeFileSync6(outputPath, generateVisualizationHtml(vizData), "utf-8");
     console.log(`Temporal call graph visualization generated: ${outputPath}`);
     console.log(`Nodes: ${vizData.nodes.length} | Edges: ${vizData.edges.length}`);
     console.log(`Recent change lenses: ${vizData.changes?.length ?? 0}`);