opencode-codebase-index 0.20.1 → 0.21.0

package/dist/cli.cjs

@@ -664,8 +664,10 @@ __export(cli_exports, {
   parseArgs: () => parseArgs
 });
 module.exports = __toCommonJS(cli_exports);
+
+// src/adapters/mcp/cli.ts
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_fs19 = require("fs");
+var import_fs20 = require("fs");
 var os8 = __toESM(require("os"), 1);
 var path29 = __toESM(require("path"), 1);
 var import_url = require("url");
@@ -4152,24 +4154,62 @@ var os2 = __toESM(require("os"), 1);
 var path5 = __toESM(require("path"), 1);
 var module2 = __toESM(require("module"), 1);
 var import_node_url = require("url");
+
+// src/identity-catalog.json
+var identity_catalog_default = {
+  product: {
+    current: {
+      productName: "opencode-codebase-index",
+      packageName: "opencode-codebase-index",
+      repository: "https://github.com/Helweg/opencode-codebase-index",
+      mcpBinary: "opencode-codebase-index-mcp",
+      mcpServerName: "opencode-codebase-index"
+    },
+    future: {
+      productName: "open-codebase-index",
+      packageName: "open-codebase-index",
+      repository: "https://github.com/Helweg/open-codebase-index",
+      mcpBinary: "open-codebase-index-mcp",
+      mcpServerName: "open-codebase-index"
+    }
+  },
+  native: {
+    binaryName: "codebase-index-native"
+  }
+};
+
+// src/identity-catalog.ts
+var IDENTITY_CATALOG = identity_catalog_default;
+var CURRENT_PRODUCT = IDENTITY_CATALOG.product.current;
+var FUTURE_PRODUCT = IDENTITY_CATALOG.product.future;
+var MCP_SERVER_CURRENT_NAME = CURRENT_PRODUCT.mcpServerName;
+var MCP_BINARY_CURRENT_NAME = CURRENT_PRODUCT.mcpBinary;
+var STABLE_NATIVE_BINARY_NAME = IDENTITY_CATALOG.native.binaryName;
+
+// src/native/binding.ts
 var import_meta = {};
-function getNativeBinding() {
-  const platform2 = os2.platform();
-  const arch2 = os2.arch();
-  let bindingName;
+function getNativeBindingFilename(platform2 = os2.platform(), arch2 = os2.arch()) {
   if (platform2 === "darwin" && arch2 === "arm64") {
-    bindingName = "codebase-index-native.darwin-arm64.node";
-  } else if (platform2 === "darwin" && arch2 === "x64") {
-    bindingName = "codebase-index-native.darwin-x64.node";
-  } else if (platform2 === "linux" && arch2 === "x64") {
-    bindingName = "codebase-index-native.linux-x64-gnu.node";
-  } else if (platform2 === "linux" && arch2 === "arm64") {
-    bindingName = "codebase-index-native.linux-arm64-gnu.node";
-  } else if (platform2 === "win32" && arch2 === "x64") {
-    bindingName = "codebase-index-native.win32-x64-msvc.node";
-  } else {
-    throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
+    return `${STABLE_NATIVE_BINARY_NAME}.darwin-arm64.node`;
+  }
+  if (platform2 === "darwin" && arch2 === "x64") {
+    return `${STABLE_NATIVE_BINARY_NAME}.darwin-x64.node`;
+  }
+  if (platform2 === "linux" && arch2 === "x64") {
+    return `${STABLE_NATIVE_BINARY_NAME}.linux-x64-gnu.node`;
   }
+  if (platform2 === "linux" && arch2 === "arm64") {
+    return `${STABLE_NATIVE_BINARY_NAME}.linux-arm64-gnu.node`;
+  }
+  if (platform2 === "win32" && arch2 === "x64") {
+    return `${STABLE_NATIVE_BINARY_NAME}.win32-x64-msvc.node`;
+  }
+  throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
+}
+function resolveNativeBindingPath(packageRoot, platform2 = os2.platform(), arch2 = os2.arch()) {
+  return path5.join(packageRoot, "native", getNativeBindingFilename(platform2, arch2));
+}
+function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import_meta !== "undefined" && import_meta.url) {
@@ -4185,7 +4225,7 @@ function getNativeBinding() {
   const normalizedDir = currentDir.replace(/\\/g, "/");
   const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path5.join("src", "native"));
   const packageRoot = isDevMode ? path5.resolve(currentDir, "../..") : path5.resolve(currentDir, "..");
-  const nativePath = path5.join(packageRoot, "native", bindingName);
+  const nativePath = resolveNativeBindingPath(packageRoot);
   const require2 = module2.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -5515,8 +5555,37 @@ function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const fallbackPath = path10.join(mainRepoRoot, relativePath);
   return (0, import_fs7.existsSync)(fallbackPath) ? fallbackPath : null;
 }
-function getHostProjectIndexRelativePath(host) {
-  return getProjectIndexRelativePath(host);
+function getProjectConfigCandidatePaths(projectRoot, host) {
+  const candidates = [path10.join(projectRoot, getProjectConfigRelativePath(host))];
+  if (host !== "opencode") {
+    candidates.push(path10.join(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH));
+  }
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (mainRepoRoot) {
+    candidates.push(path10.join(mainRepoRoot, getProjectConfigRelativePath(host)));
+    if (host !== "opencode") {
+      candidates.push(path10.join(mainRepoRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH));
+    }
+  }
+  return [...new Set(candidates)];
+}
+function isProjectIndexPathOwnedByProject(projectRoot, indexPath, host) {
+  const projectRoots = [projectRoot];
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (mainRepoRoot) {
+    projectRoots.push(mainRepoRoot);
+  }
+  const ownedIndexPaths = projectRoots.flatMap((root) => {
+    const indexPaths = [path10.join(root, getProjectIndexRelativePath(host))];
+    if (host !== "opencode") {
+      indexPaths.push(path10.join(root, OPENCODE_PROJECT_INDEX_RELATIVE_PATH));
+    }
+    return indexPaths;
+  });
+  const canonicalIndexPath = canonicalizePathForComparison(indexPath);
+  return ownedIndexPaths.some(
+    (ownedPath) => canonicalizePathForComparison(ownedPath) === canonicalIndexPath
+  );
 }
 function hasHostProjectConfig(projectRoot, host) {
   return (0, import_fs7.existsSync)(path10.join(projectRoot, getProjectConfigRelativePath(host)));
@@ -5524,7 +5593,7 @@ function hasHostProjectConfig(projectRoot, host) {
 function hasHostGlobalConfig(host) {
   return (0, import_fs7.existsSync)(getGlobalConfigPath(host));
 }
-function getGlobalIndexPath(host = "opencode") {
+function getGlobalIndexPath(host) {
   switch (host) {
     case "opencode":
       return path10.join(os4.homedir(), ".opencode", "global-index");
@@ -5534,7 +5603,7 @@ function getGlobalIndexPath(host = "opencode") {
       return path10.join(os4.homedir(), ".codebase-index", "global-index");
   }
 }
-function getGlobalConfigPath(host = "opencode") {
+function getGlobalConfigPath(host) {
   switch (host) {
     case "opencode":
       return path10.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
@@ -5544,7 +5613,7 @@ function getGlobalConfigPath(host = "opencode") {
       return path10.join(os4.homedir(), ".config", "codebase-index", "config.json");
   }
 }
-function resolveGlobalConfigPath(host = "opencode") {
+function resolveGlobalConfigPath(host) {
   const hostConfigPath = getGlobalConfigPath(host);
   if ((0, import_fs7.existsSync)(hostConfigPath)) {
     return hostConfigPath;
@@ -5557,7 +5626,7 @@ function resolveGlobalConfigPath(host = "opencode") {
   }
   return hostConfigPath;
 }
-function resolveGlobalIndexPath(host = "opencode") {
+function resolveGlobalIndexPath(host) {
   const hostIndexPath = getGlobalIndexPath(host);
   if ((0, import_fs7.existsSync)(hostIndexPath)) {
     return hostIndexPath;
@@ -5573,37 +5642,35 @@ function resolveGlobalIndexPath(host = "opencode") {
   }
   return hostIndexPath;
 }
-function resolveProjectConfigPath(projectRoot, host = "opencode") {
-  const hostConfigPath = path10.join(projectRoot, getProjectConfigRelativePath(host));
-  if ((0, import_fs7.existsSync)(hostConfigPath)) {
-    return hostConfigPath;
-  }
-  if (host !== "opencode") {
-    const legacyConfigPath = path10.join(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
-    if ((0, import_fs7.existsSync)(legacyConfigPath)) {
-      return legacyConfigPath;
-    }
-  }
-  const hostFallback = resolveWorktreeFallbackPath(projectRoot, getProjectConfigRelativePath(host));
-  if (hostFallback) {
-    return hostFallback;
-  }
-  if (host !== "opencode") {
-    const legacyFallback = resolveWorktreeFallbackPath(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
-    if (legacyFallback) {
-      return legacyFallback;
-    }
-  }
-  return hostConfigPath;
-}
-function resolveWritableProjectConfigPath(projectRoot, host = "opencode") {
-  return path10.join(projectRoot, getProjectConfigRelativePath(host));
+function resolveProjectConfigPath(projectRoot, host) {
+  const candidates = getProjectConfigCandidatePaths(projectRoot, host);
+  return candidates.find((candidate) => (0, import_fs7.existsSync)(candidate)) ?? path10.join(projectRoot, getProjectConfigRelativePath(host));
 }
-function resolveProjectIndexPath(projectRoot, scope, host = "opencode") {
+function resolveProjectIndexPath(projectRoot, scope, host) {
   if (scope === "global") {
     return resolveGlobalIndexPath(host);
   }
   const localIndexPath = path10.join(projectRoot, getProjectIndexRelativePath(host));
+  const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
+  if (mainRepoRoot) {
+    if (hasHostProjectConfig(projectRoot, host)) {
+      return localIndexPath;
+    }
+    if (host !== "opencode") {
+      const localLegacyConfigPath = path10.join(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+      if ((0, import_fs7.existsSync)(localLegacyConfigPath)) {
+        return path10.join(projectRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+      }
+      const mainHostConfigPath = path10.join(mainRepoRoot, getProjectConfigRelativePath(host));
+      const mainHostIndexPath = path10.join(mainRepoRoot, getProjectIndexRelativePath(host));
+      const mainLegacyConfigPath = path10.join(mainRepoRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+      const mainLegacyIndexPath = path10.join(mainRepoRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+      if (!(0, import_fs7.existsSync)(mainHostConfigPath) && !(0, import_fs7.existsSync)(mainHostIndexPath) && ((0, import_fs7.existsSync)(mainLegacyConfigPath) || (0, import_fs7.existsSync)(mainLegacyIndexPath))) {
+        return mainLegacyIndexPath;
+      }
+    }
+    return path10.join(mainRepoRoot, getProjectIndexRelativePath(host));
+  }
   if ((0, import_fs7.existsSync)(localIndexPath)) {
     return localIndexPath;
   }
@@ -5616,9 +5683,6 @@ 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;
@@ -7685,6 +7749,8 @@ function hasBlameMetadata(metadata) {
   return blameFromMetadata(metadata) !== void 0;
 }
 var INDEX_METADATA_VERSION = "1";
+var PROJECT_PATH_STORAGE_VERSION = "2";
+var GLOBAL_PATH_STORAGE_VERSION = "1";
 var EMBEDDING_STRATEGY_VERSION = "2";
 var SWIFT_PARSER_VERSION = "1";
 var METAL_PARSER_VERSION = "1";
@@ -8015,18 +8081,20 @@ function selectIndexableChunks(chunks, limit, semanticOnly) {
   const indexableChunks = semanticOnly ? chunks.filter((chunk) => chunk.chunkType !== "other") : chunks;
   return selectChunksWithFileCoverage(indexableChunks, limit);
 }
-function matchesHardSearchFilters(candidate, options) {
+function matchesHardSearchFilters(candidate, options, projectRoot) {
   if (options?.fileType) {
     const ext = candidate.metadata.filePath.split(".").pop()?.toLowerCase();
     const requestedExtension = options.fileType.trim().toLowerCase().replace(/^\./, "");
     if (ext !== requestedExtension) return false;
   }
   if (options?.directory) {
-    const normalizedPath = candidate.metadata.filePath.replace(/\\/g, "/");
-    const normalizedDir = options.directory.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
-    const isAbsoluteDirectory = normalizedDir.startsWith("/");
-    const matchesDirectory = isAbsoluteDirectory ? normalizedPath === normalizedDir || normalizedPath.startsWith(`${normalizedDir}/`) : normalizedPath === normalizedDir || normalizedPath.startsWith(`${normalizedDir}/`) || normalizedPath.includes(`/${normalizedDir}/`) || normalizedPath.endsWith(`/${normalizedDir}`);
-    if (!matchesDirectory) return false;
+    const candidatePath = canonicalizePathForComparison(
+      path14.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path14.sep))
+    );
+    const directoryPath = canonicalizePathForComparison(
+      path14.resolve(projectRoot, options.directory.trim().replace(/\\/g, path14.sep))
+    );
+    if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
   if (options?.chunkType && candidate.metadata.chunkType !== options.chunkType) {
     return false;
@@ -8048,8 +8116,8 @@ function matchesHardSearchFilters(candidate, options) {
   }
   return true;
 }
-function matchesSearchFilters(candidate, options, minScore) {
-  return candidate.score >= minScore && matchesHardSearchFilters(candidate, options);
+function matchesSearchFilters(candidate, options, minScore, projectRoot) {
+  return candidate.score >= minScore && matchesHardSearchFilters(candidate, options, projectRoot);
 }
 function unionCandidates(semanticCandidates, keywordCandidates) {
   const byId = /* @__PURE__ */ new Map();
@@ -8100,7 +8168,7 @@ var Indexer = class _Indexer {
   readerArtifactFingerprint = null;
   writerArtifactFingerprint = null;
   readerArtifactRetryAfter = /* @__PURE__ */ new Map();
-  constructor(projectRoot, config, host = "opencode", runtimeOptions = {}) {
+  constructor(projectRoot, config, host, runtimeOptions = {}) {
     this.projectRoot = projectRoot;
     this.projectIdentityHash = hashContent(this.getCanonicalPath(projectRoot)).slice(0, 16);
     this.materializedProjectRoot = runtimeOptions.materializedProjectRoot ?? projectRoot;
@@ -8113,37 +8181,90 @@ var Indexer = class _Indexer {
     this.indexPathOverride = runtimeOptions.indexPath;
     this.config = config;
     this.host = host;
+    if (isGitRepo(this.materializedProjectRoot)) {
+      this.currentBranch = this.branchNameOverride ?? getBranchOrDefault(this.materializedProjectRoot);
+      this.baseBranch = getBaseBranch(this.materializedProjectRoot);
+    } else {
+      this.currentBranch = "default";
+      this.baseBranch = "default";
+    }
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = this.getRuntimeArtifactPath("file-hashes.json");
-    this.failedBatchesPath = this.getRuntimeArtifactPath("failed-batches.json");
+    this.refreshRuntimeArtifactPaths();
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return this.indexPathOverride ?? resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   toCanonicalFilePath(filePath) {
+    if (!path14.isAbsolute(filePath)) {
+      return this.resolveStoredFilePath(filePath, this.projectRoot);
+    }
     if (path14.resolve(this.materializedProjectRoot) === path14.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.materializedProjectRoot)) {
       return filePath;
     }
     return path14.resolve(this.projectRoot, path14.relative(this.materializedProjectRoot, filePath));
   }
-  toMaterializedFilePath(filePath) {
-    if (path14.resolve(this.materializedProjectRoot) === path14.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.projectRoot)) {
+  toStoredFilePath(filePath) {
+    const canonicalFilePath = this.toCanonicalFilePath(filePath);
+    if (this.config.scope !== "project" || !isPathWithinRoot2(canonicalFilePath, this.projectRoot)) {
+      return canonicalFilePath;
+    }
+    return path14.relative(this.projectRoot, canonicalFilePath).split(path14.sep).join("/");
+  }
+  resolveStoredFilePath(filePath, rootPath = this.projectRoot) {
+    if (path14.isAbsolute(filePath)) {
       return filePath;
     }
-    return path14.resolve(this.materializedProjectRoot, path14.relative(this.projectRoot, filePath));
+    const resolvedPath = path14.resolve(rootPath, ...filePath.split("/"));
+    if (!isPathWithinRoot2(resolvedPath, rootPath)) {
+      throw new Error(`Stored project path escapes project root: ${JSON.stringify(filePath)}`);
+    }
+    return resolvedPath;
+  }
+  getCanonicalStoredFilePath(filePath) {
+    return this.getCanonicalPath(this.resolveStoredFilePath(filePath));
+  }
+  resolveFilePathRecord(record) {
+    return {
+      ...record,
+      filePath: this.resolveStoredFilePath(record.filePath)
+    };
+  }
+  resolveCallEdgeFilePath(edge) {
+    if (!edge.fromSymbolFilePath) return edge;
+    return {
+      ...edge,
+      fromSymbolFilePath: this.resolveStoredFilePath(edge.fromSymbolFilePath)
+    };
+  }
+  toMaterializedFilePath(filePath) {
+    const storedFilePath = this.toStoredFilePath(filePath);
+    if (path14.isAbsolute(storedFilePath)) {
+      return storedFilePath;
+    }
+    return this.resolveStoredFilePath(storedFilePath, this.materializedProjectRoot);
   }
   getPreparedBranchNamespace() {
     if (!this.branchNameOverride && !this.catalogIdentityOverride) return null;
     return hashContent(this.getBranchCatalogKey()).slice(0, 16);
   }
+  getRuntimeArtifactNamespace() {
+    if (this.config.scope !== "project" || this.getBranchCatalogIdentity() === "default") {
+      return this.getPreparedBranchNamespace();
+    }
+    return hashContent(this.getBranchCatalogKey()).slice(0, 16);
+  }
   getRuntimeArtifactPath(fileName) {
-    const namespace = this.getPreparedBranchNamespace();
+    const namespace = this.getRuntimeArtifactNamespace();
     if (!namespace) return path14.join(this.indexPath, fileName);
     const extension = path14.extname(fileName);
     const baseName = fileName.slice(0, fileName.length - extension.length);
     return path14.join(this.indexPath, `${baseName}.${namespace}${extension}`);
   }
+  refreshRuntimeArtifactPaths() {
+    this.fileHashCachePath = this.getRuntimeArtifactPath("file-hashes.json");
+    this.failedBatchesPath = this.getRuntimeArtifactPath("failed-batches.json");
+  }
   getPreparedChunkId(chunkId) {
     const namespace = this.getPreparedBranchNamespace();
     return namespace ? `${chunkId}_${namespace}` : chunkId;
@@ -8169,19 +8290,8 @@ var Indexer = class _Indexer {
       return path14.resolve(targetPath);
     }
   }
-  isLocalProjectIndexPath() {
-    const localProjectIndexPaths = [path14.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
-    if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path14.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
-    }
-    return localProjectIndexPaths.some((localPath) => {
-      if (!(0, import_fs10.existsSync)(localPath) || !(0, import_fs10.existsSync)(this.indexPath)) {
-        return path14.resolve(this.indexPath) === path14.resolve(localPath);
-      }
-      const indexStats = (0, import_fs10.statSync)(this.indexPath);
-      const localStats = (0, import_fs10.statSync)(localPath);
-      return indexStats.dev === localStats.dev && indexStats.ino === localStats.ino;
-    });
+  isProjectOwnedIndexPath() {
+    return isProjectIndexPathOwnedByProject(this.projectRoot, this.indexPath, this.host);
   }
   resetLoadedIndexState(retireDatabase = false) {
     if (this.database) {
@@ -8216,10 +8326,10 @@ var Indexer = class _Indexer {
     this.readerArtifactRetryAfter.clear();
   }
   async withIndexMutationLease(operation, callback) {
+    this.refreshBranchInfo();
     const lease = acquireIndexLock(this.indexPath, operation);
     this.indexPath = lease.canonicalIndexPath;
-    this.fileHashCachePath = this.getRuntimeArtifactPath("file-hashes.json");
-    this.failedBatchesPath = this.getRuntimeArtifactPath("failed-batches.json");
+    this.refreshRuntimeArtifactPaths();
     this.activeIndexLease = lease;
     let result;
     let callbackError;
@@ -8391,29 +8501,24 @@ var Indexer = class _Indexer {
   getProjectForceReembedMetadataKey() {
     return `index.forceReembed.${this.projectIdentityHash}`;
   }
-  getCallGraphResolutionMetadataKey() {
-    if (this.config.scope !== "global") {
-      return "index.callGraphResolutionVersion";
-    }
-    return `index.callGraphResolutionVersion.${this.projectIdentityHash}`;
+  getBranchMigrationMetadataKey(prefix, catalogIdentity = this.getBranchCatalogIdentity()) {
+    const branchKey = this.getBranchCatalogKeyFor(catalogIdentity);
+    return `${prefix}.${hashContent(branchKey).slice(0, 24)}`;
   }
-  getSwiftParserVersionMetadataKey() {
-    const key = "index.parser.swiftVersion";
-    if (this.config.scope !== "global") {
-      return key;
-    }
-    return `${key}.${this.projectIdentityHash}`;
+  getCallGraphResolutionMetadataKey(catalogIdentity = this.getBranchCatalogIdentity()) {
+    return this.getBranchMigrationMetadataKey("index.callGraphResolutionVersion", catalogIdentity);
   }
-  getMetalParserVersionMetadataKey() {
-    const key = "index.parser.metalVersion";
-    if (this.config.scope !== "global") {
-      return key;
-    }
-    return `${key}.${this.projectIdentityHash}`;
+  getSwiftParserVersionMetadataKey(catalogIdentity = this.getBranchCatalogIdentity()) {
+    return this.getBranchMigrationMetadataKey("index.parser.swiftVersion", catalogIdentity);
+  }
+  getMetalParserVersionMetadataKey(catalogIdentity = this.getBranchCatalogIdentity()) {
+    return this.getBranchMigrationMetadataKey("index.parser.metalVersion", catalogIdentity);
   }
   getSymbolExtractorVersionMetadataKey(catalogIdentity = this.getBranchCatalogIdentity()) {
-    const branchKey = this.getBranchCatalogKeyFor(catalogIdentity);
-    return `index.symbolExtractorVersion.${hashContent(branchKey).slice(0, 24)}`;
+    return this.getBranchMigrationMetadataKey("index.symbolExtractorVersion", catalogIdentity);
+  }
+  areBranchMigrationVersionsCurrent(database, catalogIdentity = this.getBranchCatalogIdentity()) {
+    return database.getMetadata(this.getCallGraphResolutionMetadataKey(catalogIdentity)) === CALL_GRAPH_RESOLUTION_VERSION && database.getMetadata(this.getSwiftParserVersionMetadataKey(catalogIdentity)) === SWIFT_PARSER_VERSION && database.getMetadata(this.getMetalParserVersionMetadataKey(catalogIdentity)) === METAL_PARSER_VERSION && database.getMetadata(this.getSymbolExtractorVersionMetadataKey(catalogIdentity)) === SYMBOL_EXTRACTOR_VERSION;
   }
   hasProjectForceReembedPending() {
     return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
@@ -8548,13 +8653,14 @@ var Indexer = class _Indexer {
     return Array.from(keys);
   }
   isFileInCurrentScope(filePath, roots) {
-    if (roots.some((root) => isPathWithinRoot2(filePath, root))) return true;
-    const canonicalFilePath = this.getCanonicalPath(filePath);
+    const canonicalFilePath = this.getCanonicalStoredFilePath(filePath);
     return roots.some((root) => isPathWithinRoot2(canonicalFilePath, root));
   }
   isFileInProjectRoot(filePath) {
-    if (isPathWithinRoot2(filePath, this.projectRoot)) return true;
-    return isPathWithinRoot2(this.getCanonicalPath(filePath), this.getCanonicalPath(this.projectRoot));
+    return isPathWithinRoot2(
+      this.getCanonicalStoredFilePath(filePath),
+      this.getCanonicalPath(this.projectRoot)
+    );
   }
   clearScopedFileHashCache(roots) {
     for (const filePath of Array.from(this.fileHashCache.keys())) {
@@ -8955,7 +9061,10 @@ var Indexer = class _Indexer {
     const intent = isLikelyImplementationPath2(candidate.metadata.filePath) ? "implementation" : "doc_or_test";
     parts.push(`intent_hint: ${intent}`);
     try {
-      const fileContent = await import_fs10.promises.readFile(candidate.metadata.filePath, "utf-8");
+      const fileContent = await import_fs10.promises.readFile(
+        this.toMaterializedFilePath(candidate.metadata.filePath),
+        "utf-8"
+      );
       const lines = fileContent.split("\n");
       const snippetStartLine = Math.max(1, candidate.metadata.startLine);
       const snippetEndLine = Math.min(lines.length, candidate.metadata.endLine);
@@ -9024,7 +9133,7 @@ var Indexer = class _Indexer {
     if (this.config.scope === "global") {
       return "Shared vector index could not be read. Restore or repair the complete fingerprinted shared vector artifacts; automatic reset is disabled for global scope.";
     }
-    if (!this.isLocalProjectIndexPath()) {
+    if (!this.isProjectOwnedIndexPath()) {
       return "Vector index could not be read from an inherited project index. Restore or fingerprint it from the checkout that owns the index; do not remove or rebuild it from this worktree.";
     }
     return "Vector index could not be read. Run index_codebase after the active writer finishes to fingerprint a structurally valid legacy pair, or remove this checkout's local index directory and run index_codebase to rebuild it.";
@@ -9033,7 +9142,7 @@ var Indexer = class _Indexer {
     if (this.config.scope === "global") {
       return "Shared keyword index could not be read; semantic search remains available. Restore or repair the shared keyword artifact; automatic reset is disabled for global scope.";
     }
-    if (!this.isLocalProjectIndexPath()) {
+    if (!this.isProjectOwnedIndexPath()) {
       return "Keyword index could not be read from an inherited project index; semantic search remains available. Restore or repair it from the checkout that owns the index; do not rebuild it from this worktree.";
     }
     return "Keyword index could not be read; semantic search remains available. Restore a readable published keyword index, or run index_codebase with force=true after the active writer finishes.";
@@ -9042,10 +9151,10 @@ var Indexer = class _Indexer {
     if (this.config.scope === "global") {
       return "Shared index database could not be read. Restore or repair the shared SQLite database; automatic reset is disabled for global scope.";
     }
-    if (!this.isLocalProjectIndexPath()) {
+    if (!this.isProjectOwnedIndexPath()) {
       return "Index database could not be read from an inherited project index. Restore or repair it from the checkout that owns the index; do not migrate or rebuild it from this worktree.";
     }
-    return "Index database could not be read. Run index_codebase after the active writer finishes to repair or migrate it under the writer lease.";
+    return "Index database could not be read. Run index_codebase with force=true to rebuild a legacy absolute-path schema, or repair the database after the active writer finishes.";
   }
   getReaderFileFingerprint(filePath, identityOnly = false) {
     try {
@@ -9225,7 +9334,7 @@ var Indexer = class _Indexer {
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
       await import_fs10.promises.mkdir(this.indexPath, { recursive: true });
-      if (recoveredOwners.length > 0 && this.config.scope === "project" && !this.isLocalProjectIndexPath()) {
+      if (recoveredOwners.length > 0 && this.config.scope === "project" && !this.isProjectOwnedIndexPath()) {
         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."
         );
@@ -9326,6 +9435,7 @@ var Indexer = class _Indexer {
       this.baseBranch = "default";
       this.logger.branch("debug", "Not a git repository, using default branch");
     }
+    this.refreshRuntimeArtifactPaths();
     if (mode === "writer" && recoveredOwners.length > 0) {
       await this.recoverFromInterruptedIndexingUnlocked(recoveredOwners);
     }
@@ -9481,6 +9591,14 @@ var Indexer = class _Indexer {
     }
     return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
   }
+  async removeProjectRuntimeStateArtifacts() {
+    if (!(0, import_fs10.existsSync)(this.indexPath)) return;
+    const names = await import_fs10.promises.readdir(this.indexPath);
+    const runtimeStatePattern = /^(?:file-hashes|failed-batches)(?:\.[a-f0-9]{16})?\.json$/;
+    await Promise.all(
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => import_fs10.promises.rm(path14.join(this.indexPath, name), { force: true }))
+    );
+  }
   async resetLocalIndexArtifacts() {
     this.store = null;
     this.invertedIndex = null;
@@ -9500,11 +9618,10 @@ var Indexer = class _Indexer {
       path14.join(this.indexPath, "vectors"),
       path14.join(this.indexPath, "vectors.usearch"),
       path14.join(this.indexPath, "vectors.meta.json"),
-      path14.join(this.indexPath, "inverted-index.json"),
-      path14.join(this.indexPath, "file-hashes.json"),
-      path14.join(this.indexPath, "failed-batches.json")
+      path14.join(this.indexPath, "inverted-index.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => import_fs10.promises.rm(targetPath, { recursive: true, force: true })));
+    await this.removeProjectRuntimeStateArtifacts();
     await import_fs10.promises.mkdir(this.indexPath, { recursive: true });
   }
   async tryResetCorruptedIndex(stage, error) {
@@ -9554,12 +9671,20 @@ var Indexer = class _Indexer {
     }
     this.database.addChunksToBranchBatch(this.getBranchCatalogKey(), chunkIds);
   }
+  getExpectedPathStorageVersion() {
+    return this.config.scope === "project" ? PROJECT_PATH_STORAGE_VERSION : GLOBAL_PATH_STORAGE_VERSION;
+  }
+  hasStoredIndexData() {
+    const stats = this.database?.getStats();
+    return (this.store?.count() ?? 0) > 0 || (stats?.chunkCount ?? 0) > 0 || (stats?.symbolCount ?? 0) > 0 || this.fileHashCache.size > 0;
+  }
   loadIndexMetadata() {
     if (!this.database) return null;
     const version = this.database.getMetadata("index.version");
     if (!version) return null;
     return {
       indexVersion: version,
+      pathStorageVersion: this.database.getMetadata("index.pathStorageVersion") ?? GLOBAL_PATH_STORAGE_VERSION,
       embeddingProvider: this.database.getMetadata("index.embeddingProvider") ?? "",
       embeddingModel: this.database.getMetadata("index.embeddingModel") ?? "",
       embeddingDimensions: parseInt(this.database.getMetadata("index.embeddingDimensions") ?? "0", 10),
@@ -9574,6 +9699,7 @@ var Indexer = class _Indexer {
     const existingCreatedAt = this.database.getMetadata("index.createdAt");
     const completeProjectEmbeddingStrategyReset = !this.hasProjectForceReembedPending();
     this.database.setMetadata("index.version", INDEX_METADATA_VERSION);
+    this.database.setMetadata("index.pathStorageVersion", this.getExpectedPathStorageVersion());
     this.database.setMetadata("index.embeddingProvider", provider.provider);
     this.database.setMetadata("index.embeddingModel", provider.modelInfo.model);
     this.database.setMetadata("index.embeddingDimensions", provider.modelInfo.dimensions.toString());
@@ -9596,6 +9722,16 @@ var Indexer = class _Indexer {
   }
   validateIndexCompatibility(provider) {
     const storedMetadata = this.loadIndexMetadata();
+    const storedPathStorageVersion = this.database?.getMetadata("index.pathStorageVersion") ?? GLOBAL_PATH_STORAGE_VERSION;
+    const expectedPathStorageVersion = this.getExpectedPathStorageVersion();
+    if (this.hasStoredIndexData() && storedPathStorageVersion !== expectedPathStorageVersion) {
+      return {
+        compatible: false,
+        code: "PATH_STORAGE_MISMATCH" /* PATH_STORAGE_MISMATCH */,
+        reason: `Path storage format mismatch: index uses v${storedPathStorageVersion} checkout-absolute paths, but this project requires portable v${expectedPathStorageVersion} paths. Run index_codebase with force=true to rebuild the shared project index once.`,
+        storedMetadata: storedMetadata ?? void 0
+      };
+    }
     if (!storedMetadata) {
       return { compatible: true };
     }
@@ -9647,6 +9783,7 @@ var Indexer = class _Indexer {
     return this.indexCompatibility;
   }
   async ensureInitialized() {
+    this.refreshBranchInfo();
     let initializedReader = false;
     while (true) {
       if (this.initializationPromise) {
@@ -9754,8 +9891,8 @@ var Indexer = class _Indexer {
       }
       const branchKey = this.getBranchCatalogKey();
       const alreadyIndexed = database.getBranchChunkIds(branchKey).length > 0 && database.getBranchSymbolIds(branchKey).length > 0;
-      const symbolsCurrent = database.getMetadata(this.getSymbolExtractorVersionMetadataKey()) === SYMBOL_EXTRACTOR_VERSION;
-      if (alreadyIndexed && symbolsCurrent && this.getStoredBranchCommit(database) === normalizedCommit) {
+      const migrationsCurrent = this.areBranchMigrationVersionsCurrent(database);
+      if (alreadyIndexed && migrationsCurrent && this.getStoredBranchCommit(database) === normalizedCommit) {
         return { prepared: false };
       }
       const stats = await this.indexUnlocked(onProgress, [], true);
@@ -9849,21 +9986,21 @@ var Indexer = class _Indexer {
     const currentFileHashes = /* @__PURE__ */ new Map();
     const needsCallGraphResolutionMigration = database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION;
     for (const f of files) {
-      const canonicalPath = this.toCanonicalFilePath(f.path);
+      const storedPath = this.toStoredFilePath(f.path);
       const currentHash = hashFile(f.path);
-      currentFileHashes.set(canonicalPath, currentHash);
-      const cachedHashMatches = this.fileHashCache.get(canonicalPath) === currentHash;
-      const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(canonicalPath).some(
+      currentFileHashes.set(storedPath, currentHash);
+      const cachedHashMatches = this.fileHashCache.get(storedPath) === currentHash;
+      const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(storedPath).some(
         (chunk) => chunk.language === "php" || chunk.language === "c" || chunk.language === "cpp"
       );
-      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path14.extname(canonicalPath).toLowerCase() === ".swift";
-      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path14.extname(canonicalPath).toLowerCase() === ".metal";
+      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path14.extname(storedPath).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path14.extname(storedPath).toLowerCase() === ".metal";
       if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade && !refreshCachedSymbols) {
-        unchangedFilePaths.add(canonicalPath);
+        unchangedFilePaths.add(storedPath);
         this.logger.recordCacheHit();
       } else {
         const content = await import_fs10.promises.readFile(f.path, "utf-8");
-        changedFiles.push({ path: canonicalPath, content, hash: currentHash });
+        changedFiles.push({ path: storedPath, content, hash: currentHash });
         this.logger.recordCacheMiss();
       }
     }
@@ -9968,8 +10105,7 @@ var Indexer = class _Indexer {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path14.relative(this.projectRoot, parsed.path);
-        stats.parseFailures.push(relativePath);
+        stats.parseFailures.push(path14.isAbsolute(parsed.path) ? path14.relative(this.projectRoot, parsed.path) : parsed.path);
       }
       let chunksToProcess = parsed.chunks;
       if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
@@ -10610,6 +10746,43 @@ var Indexer = class _Indexer {
     const union = a.size + b.size - intersection;
     return intersection / union;
   }
+  getBranchPrefilterState(database, branchChunkIds) {
+    const hasInitializedBranchCatalog = branchChunkIds !== null && database.getAllBranches().length > 0;
+    return {
+      hasInitializedBranchCatalog,
+      shouldPrefilterByBranch: branchChunkIds !== null && (this.config.scope === "global" || hasInitializedBranchCatalog)
+    };
+  }
+  searchCandidatesWithBranchPrefilter(initialLimit, totalCount, branchChunkIds, shouldPrefilterByBranch, search, getChunkId) {
+    const normalizedLimit = Math.max(0, Math.floor(initialLimit));
+    if (normalizedLimit === 0) return [];
+    if (!shouldPrefilterByBranch || !branchChunkIds) {
+      return search(normalizedLimit);
+    }
+    const targetCount = Math.min(normalizedLimit, branchChunkIds.size);
+    if (targetCount === 0 || totalCount === 0) return [];
+    let requestedLimit = Math.min(normalizedLimit, totalCount);
+    while (true) {
+      const results = search(requestedLimit);
+      const branchResults = results.filter((candidate) => branchChunkIds.has(getChunkId(candidate)));
+      if (branchResults.length >= targetCount || results.length < requestedLimit || requestedLimit >= totalCount) {
+        return branchResults;
+      }
+      const nextLimit = Math.min(totalCount, Math.max(requestedLimit + 1, requestedLimit * 2));
+      if (nextLimit === requestedLimit) return branchResults;
+      requestedLimit = nextLimit;
+    }
+  }
+  searchSemanticCandidates(store, embedding, initialLimit, branchChunkIds, shouldPrefilterByBranch) {
+    return this.searchCandidatesWithBranchPrefilter(
+      initialLimit,
+      store.count(),
+      branchChunkIds,
+      shouldPrefilterByBranch,
+      (requestedLimit) => store.search(embedding, requestedLimit),
+      (candidate) => candidate.id
+    );
+  }
   async search(query, limit, options) {
     const { store, provider, invertedIndex, database, readIssues, compatibility } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "vectors", "database");
@@ -10654,12 +10827,7 @@ var Indexer = class _Indexer {
       });
     }
     const embeddingMs = import_perf_hooks.performance.now() - embeddingStartTime;
-    const vectorStartTime = import_perf_hooks.performance.now();
-    const semanticResults = embedding ? store.search(embedding, maxResults * 4) : [];
-    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
-    const keywordStartTime = import_perf_hooks.performance.now();
-    const keywordResults = await this.keywordSearch(query, maxResults * 4, store, invertedIndex);
-    const keywordMs = import_perf_hooks.performance.now() - keywordStartTime;
+    const prefilterStartTime = import_perf_hooks.performance.now();
     let branchChunkIds = null;
     let branchSymbolIds = null;
     if (filterByBranch && (this.config.scope === "global" || this.currentBranch !== "default")) {
@@ -10667,35 +10835,38 @@ var Indexer = class _Indexer {
       branchChunkIds = new Set(branchCatalogKeys.flatMap((branchKey) => database.getBranchChunkIds(branchKey)));
       branchSymbolIds = new Set(branchCatalogKeys.flatMap((branchKey) => database.getBranchSymbolIds(branchKey)));
     }
-    const prefilterStartTime = import_perf_hooks.performance.now();
-    const shouldPrefilterByBranch = branchChunkIds !== null && (this.config.scope === "global" || branchChunkIds.size > 0);
-    const allowBranchPrefilterFallback = this.config.scope !== "global";
-    const prefilteredSemantic = shouldPrefilterByBranch && branchChunkIds ? semanticResults.filter((r) => branchChunkIds.has(r.id)) : semanticResults;
-    const prefilteredKeyword = shouldPrefilterByBranch && branchChunkIds ? keywordResults.filter((r) => branchChunkIds.has(r.id)) : keywordResults;
-    const semanticCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
-    const keywordCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0 ? keywordResults : prefilteredKeyword;
+    const { hasInitializedBranchCatalog, shouldPrefilterByBranch } = this.getBranchPrefilterState(database, branchChunkIds);
+    const prefilterMs = import_perf_hooks.performance.now() - prefilterStartTime;
+    const vectorStartTime = import_perf_hooks.performance.now();
+    const semanticCandidates = embedding ? this.searchSemanticCandidates(
+      store,
+      embedding,
+      maxResults * 4,
+      branchChunkIds,
+      shouldPrefilterByBranch
+    ) : [];
+    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
+    const keywordStartTime = import_perf_hooks.performance.now();
+    const keywordCandidates = await this.keywordSearch(
+      query,
+      maxResults * 4,
+      store,
+      invertedIndex,
+      branchChunkIds,
+      shouldPrefilterByBranch
+    );
+    const keywordMs = import_perf_hooks.performance.now() - keywordStartTime;
     const scopedSemanticCandidates = semanticCandidates.filter(
-      (candidate) => matchesHardSearchFilters(candidate, options)
+      (candidate) => matchesHardSearchFilters(candidate, options, this.projectRoot)
     );
     const scopedKeywordCandidates = keywordCandidates.filter(
-      (candidate) => matchesHardSearchFilters(candidate, options)
+      (candidate) => matchesHardSearchFilters(candidate, options, this.projectRoot)
     );
-    const prefilterMs = import_perf_hooks.performance.now() - prefilterStartTime;
-    if (this.config.scope !== "global" && branchChunkIds && branchChunkIds.size === 0) {
+    if (this.config.scope !== "global" && branchChunkIds && !hasInitializedBranchCatalog) {
       this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
         branch: this.currentBranch
       });
     }
-    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
-      this.logger.search("warn", "Branch prefilter produced no semantic overlap, using unfiltered semantic candidates", {
-        branch: this.currentBranch
-      });
-    }
-    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0) {
-      this.logger.search("warn", "Branch prefilter produced no keyword overlap, using unfiltered keyword candidates", {
-        branch: this.currentBranch
-      });
-    }
     const fusionStartTime = import_perf_hooks.performance.now();
     const rankingHybridWeight = embedding === void 0 && fusionStrategy === "weighted" ? 1 : effectiveHybridWeight;
     const combined = rankHybridResults(query, scopedSemanticCandidates, scopedKeywordCandidates, {
@@ -10746,12 +10917,14 @@ var Indexer = class _Indexer {
     const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
     const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
     const hasCodeHints = extractCodeTermHints(query).length > 0 || identifierHints.length > 0;
-    const baseFiltered = tiered.filter((r) => matchesSearchFilters(r, options, this.config.search.minScore));
+    const baseFiltered = tiered.filter(
+      (r) => matchesSearchFilters(r, options, this.config.search.minScore, this.projectRoot)
+    );
     const implementationOnly = baseFiltered.filter(
       (r) => isLikelyImplementationPath2(r.metadata.filePath) && isImplementationChunkType(r.metadata.chunkType)
     );
     const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : baseFiltered).slice(0, maxResults);
-    const identifierFallback = !options?.definitionIntent && filtered.length === 0 && identifierHints.length > 0 ? buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbolIds, maxResults, union, true).filter((r) => matchesSearchFilters(r, options, this.config.search.minScore)).slice(0, maxResults) : [];
+    const identifierFallback = !options?.definitionIntent && filtered.length === 0 && identifierHints.length > 0 ? buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbolIds, maxResults, union, true).filter((r) => matchesSearchFilters(r, options, this.config.search.minScore, this.projectRoot)).slice(0, maxResults) : [];
     const finalResults = filtered.length > 0 ? filtered : identifierFallback;
     const totalSearchMs = import_perf_hooks.performance.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
@@ -10776,10 +10949,11 @@ var Indexer = class _Indexer {
         let content = "";
         let contextStartLine = r.metadata.startLine;
         let contextEndLine = r.metadata.endLine;
+        const resolvedFilePath = this.resolveStoredFilePath(r.metadata.filePath);
         if (!metadataOnly && this.config.search.includeContext) {
           try {
             const fileContent = await import_fs10.promises.readFile(
-              r.metadata.filePath,
+              resolvedFilePath,
               "utf-8"
             );
             const lines = fileContent.split("\n");
@@ -10792,7 +10966,7 @@ var Indexer = class _Indexer {
           }
         }
         return {
-          filePath: r.metadata.filePath,
+          filePath: resolvedFilePath,
           startLine: contextStartLine,
           endLine: contextEndLine,
           content,
@@ -10804,8 +10978,18 @@ var Indexer = class _Indexer {
       })
     );
   }
-  async keywordSearch(query, limit, store, invertedIndex) {
-    const scores = invertedIndex.search(query);
+  async keywordSearch(query, limit, store, invertedIndex, branchChunkIds = null, shouldPrefilterByBranch = false) {
+    const normalizedLimit = Math.max(0, Math.floor(limit));
+    if (normalizedLimit === 0) return [];
+    const scoreEntries = this.searchCandidatesWithBranchPrefilter(
+      normalizedLimit,
+      invertedIndex.getDocumentCount(),
+      branchChunkIds,
+      shouldPrefilterByBranch,
+      (requestedLimit) => Array.from(invertedIndex.search(query, requestedLimit)),
+      ([chunkId]) => chunkId
+    );
+    const scores = new Map(scoreEntries);
     if (scores.size === 0) {
       return [];
     }
@@ -10819,7 +11003,7 @@ var Indexer = class _Indexer {
       }
     }
     results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
+    return results.slice(0, normalizedLimit);
   }
   async getStatus() {
     const { store, configuredProviderInfo, database, readIssues, compatibility } = await this.ensureInitialized();
@@ -10886,7 +11070,7 @@ var Indexer = class _Indexer {
     );
     const currentFileHashes = /* @__PURE__ */ new Map();
     for (const file of files) {
-      currentFileHashes.set(this.toCanonicalFilePath(file.path), hashFile(file.path));
+      currentFileHashes.set(this.toStoredFilePath(file.path), hashFile(file.path));
     }
     const scopedRoots = this.config.scope === "global" ? this.getScopedRoots() : null;
     const cachedFileHashes = scopedRoots ? new Map(Array.from(this.fileHashCache).filter(([filePath]) => this.isFileInCurrentScope(filePath, scopedRoots))) : this.fileHashCache;
@@ -10898,17 +11082,7 @@ var Indexer = class _Indexer {
         return { readable: true, current: false, reason: "files-changed" };
       }
     }
-    const hasSwiftFiles = Array.from(currentFileHashes.keys()).some(
-      (filePath) => path14.extname(filePath).toLowerCase() === ".swift"
-    );
-    const hasMetalFiles = Array.from(currentFileHashes.keys()).some(
-      (filePath) => path14.extname(filePath).toLowerCase() === ".metal"
-    );
-    const hasCallGraphMigrationFiles = Array.from(currentFileHashes.keys()).some((filePath) => {
-      const extension = path14.extname(filePath).toLowerCase();
-      return extension === ".php" || extension === ".c" || extension === ".cc" || extension === ".cpp" || extension === ".cxx";
-    });
-    if (hasSwiftFiles && database.getMetadata(this.getSwiftParserVersionMetadataKey()) !== SWIFT_PARSER_VERSION || hasMetalFiles && database.getMetadata(this.getMetalParserVersionMetadataKey()) !== METAL_PARSER_VERSION || database.getMetadata(this.getSymbolExtractorVersionMetadataKey()) !== SYMBOL_EXTRACTOR_VERSION || hasCallGraphMigrationFiles && database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION) {
+    if (!this.areBranchMigrationVersionsCurrent(database)) {
       return { readable: true, current: false, reason: "migration-required" };
     }
     if (isGitRepo(this.materializedProjectRoot)) {
@@ -10968,6 +11142,7 @@ var Indexer = class _Indexer {
         this.deleteBranchCommitMetadata(database, clearedBranchKeys2);
         this.saveFailedBatches([]);
         database.deleteMetadata("index.version");
+        database.deleteMetadata("index.pathStorageVersion");
         database.deleteMetadata("index.embeddingProvider");
         database.deleteMetadata("index.embeddingModel");
         database.deleteMetadata("index.embeddingDimensions");
@@ -10986,7 +11161,7 @@ var Indexer = class _Indexer {
       this.indexCompatibility = compatibility;
       return;
     }
-    if (!this.isLocalProjectIndexPath()) {
+    if (!this.isProjectOwnedIndexPath()) {
       throw new Error(
         "Project-scoped force rebuild is unsafe while using an inherited worktree index. Create a local project config boundary before clearing the index."
       );
@@ -10997,11 +11172,11 @@ var Indexer = class _Indexer {
     invertedIndex.clear();
     this.saveInvertedIndex(invertedIndex);
     this.fileHashCache.clear();
-    this.saveFileHashCache();
+    await this.removeProjectRuntimeStateArtifacts();
     database.clearAllIndexedData();
     this.deleteBranchCommitMetadata(database, clearedBranchKeys);
-    this.saveFailedBatches([]);
     database.deleteMetadata("index.version");
+    database.deleteMetadata("index.pathStorageVersion");
     database.deleteMetadata("index.embeddingProvider");
     database.deleteMetadata("index.embeddingModel");
     database.deleteMetadata("index.embeddingDimensions");
@@ -11029,32 +11204,46 @@ var Indexer = class _Indexer {
       existing.push(key);
       filePathsToChunkKeys.set(metadata.filePath, existing);
     }
-    const removedFilePaths = [];
-    const removedChunkKeys = [];
+    const missingStoredFilePaths = [];
+    const missingChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!(0, import_fs10.existsSync)(filePath)) {
+      if (!(0, import_fs10.existsSync)(this.toMaterializedFilePath(filePath))) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
-          removedChunkKeys.push(key);
+          missingChunkKeys.push(key);
         }
-        removedFilePaths.push(filePath);
+        missingStoredFilePaths.push(filePath);
       }
     }
+    const branchCatalogKeys = this.getBranchCatalogKeys();
+    for (const branchKey of branchCatalogKeys) {
+      database.deleteBranchChunksForBranch(branchKey, missingChunkKeys);
+    }
+    const referencedChunkKeys = new Set(database.getReferencedChunkIds(missingChunkKeys));
+    const removedChunkKeys = missingChunkKeys.filter((key) => !referencedChunkKeys.has(key));
     if (removedChunkKeys.length > 0) {
       this.rebuildVectorStoreExcludingChunkIds(store, database, removedChunkKeys);
       for (const key of removedChunkKeys) {
         invertedIndex.removeChunk(key);
       }
+      database.deleteChunksByIds(removedChunkKeys);
     }
-    for (const filePath of removedFilePaths) {
-      const fileChunkKeys = chunkKeysByRemovedFile.get(filePath) ?? [];
-      if (fileChunkKeys.length > 0) {
-        database.deleteChunksByIds(fileChunkKeys);
-      }
-      database.deleteCallEdgesByFile(filePath);
-      database.deleteSymbolsByFile(filePath);
-    }
+    const missingSymbolIds = Array.from(new Set(
+      missingStoredFilePaths.flatMap(
+        (filePath) => database.getSymbolsByFile(filePath).map((symbol) => symbol.id)
+      )
+    ));
+    for (const branchKey of branchCatalogKeys) {
+      database.deleteBranchSymbolsForBranch(branchKey, missingSymbolIds);
+    }
+    const referencedSymbolIds = new Set(database.getReferencedSymbolIds(missingSymbolIds));
+    const removedSymbolIds = missingSymbolIds.filter((symbolId) => !referencedSymbolIds.has(symbolId));
+    database.clearCallEdgeTargetsForSymbols(removedSymbolIds);
+    const removedChunkKeySet = new Set(removedChunkKeys);
+    const removedStoredFilePaths = missingStoredFilePaths.filter(
+      (filePath) => (chunkKeysByRemovedFile.get(filePath) ?? []).some((key) => removedChunkKeySet.has(key))
+    );
     const removedCount = removedChunkKeys.length;
     if (removedCount > 0) {
       store.save();
@@ -11090,9 +11279,16 @@ var Indexer = class _Indexer {
       removedStale: removedCount,
       orphanEmbeddings: gcOrphanEmbeddings,
       orphanChunks: gcOrphanChunks,
-      removedFiles: removedFilePaths.length
+      removedFiles: removedStoredFilePaths.length
     });
-    return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks, gcOrphanSymbols, gcOrphanCallEdges };
+    return {
+      removed: removedCount,
+      filePaths: removedStoredFilePaths.map((filePath) => this.resolveStoredFilePath(filePath)),
+      gcOrphanEmbeddings,
+      gcOrphanChunks,
+      gcOrphanSymbols,
+      gcOrphanCallEdges
+    };
   }
   async retryFailedBatches() {
     return this.withIndexMutationLease("retry-failed-batches", async (recoveredOwners) => {
@@ -11287,9 +11483,18 @@ var Indexer = class _Indexer {
     return this.baseBranch;
   }
   refreshBranchInfo() {
+    const previousBranch = this.currentBranch;
     if (isGitRepo(this.materializedProjectRoot)) {
       this.currentBranch = this.branchNameOverride ?? getBranchOrDefault(this.materializedProjectRoot);
       this.baseBranch = getBaseBranch(this.materializedProjectRoot);
+    } else {
+      this.currentBranch = "default";
+      this.baseBranch = "default";
+    }
+    if (this.currentBranch !== previousBranch) {
+      this.refreshRuntimeArtifactPaths();
+      this.fileHashCache.clear();
+      this.loadFileHashCache();
     }
   }
   async getDatabaseStats() {
@@ -11314,6 +11519,7 @@ var Indexer = class _Indexer {
       return [];
     }
     const filterByBranch = options?.filterByBranch ?? true;
+    const excludedStoredFile = options?.excludeFile ? this.toStoredFilePath(options.excludeFile) : void 0;
     this.logger.search("debug", "Starting find similar", {
       codeLength: code.length,
       limit,
@@ -11323,31 +11529,29 @@ var Indexer = class _Indexer {
     const { embedding, tokensUsed } = await provider.embedDocument(code);
     const embeddingMs = import_perf_hooks.performance.now() - embeddingStartTime;
     this.logger.recordEmbeddingApiCall(tokensUsed);
-    const vectorStartTime = import_perf_hooks.performance.now();
-    const semanticResults = store.search(embedding, limit * 2);
-    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
+    const prefilterStartTime = import_perf_hooks.performance.now();
     let branchChunkIds = null;
     if (filterByBranch && (this.config.scope === "global" || this.currentBranch !== "default")) {
       branchChunkIds = new Set(
         this.getBranchCatalogKeys().flatMap((branchKey) => database.getBranchChunkIds(branchKey))
       );
     }
-    const prefilterStartTime = import_perf_hooks.performance.now();
-    const shouldPrefilterByBranch = branchChunkIds !== null && (this.config.scope === "global" || branchChunkIds.size > 0);
-    const allowBranchPrefilterFallback = this.config.scope !== "global";
-    const prefilteredSemantic = shouldPrefilterByBranch && branchChunkIds ? semanticResults.filter((r) => branchChunkIds.has(r.id)) : semanticResults;
-    const semanticCandidates = allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
+    const { hasInitializedBranchCatalog, shouldPrefilterByBranch } = this.getBranchPrefilterState(database, branchChunkIds);
     const prefilterMs = import_perf_hooks.performance.now() - prefilterStartTime;
-    if (this.config.scope !== "global" && branchChunkIds && branchChunkIds.size === 0) {
+    const vectorStartTime = import_perf_hooks.performance.now();
+    const semanticCandidates = this.searchSemanticCandidates(
+      store,
+      embedding,
+      limit * 2,
+      branchChunkIds,
+      shouldPrefilterByBranch
+    );
+    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
+    if (this.config.scope !== "global" && branchChunkIds && !hasInitializedBranchCatalog) {
       this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
         branch: this.currentBranch
       });
     }
-    if (allowBranchPrefilterFallback && shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0) {
-      this.logger.search("warn", "Branch prefilter produced no semantic overlap, using unfiltered semantic candidates", {
-        branch: this.currentBranch
-      });
-    }
     const rerankTopN = this.config.search.rerankTopN;
     const ranked = rankSemanticOnlyResults(code, semanticCandidates, {
       rerankTopN,
@@ -11356,21 +11560,10 @@ var Indexer = class _Indexer {
     });
     const filtered = ranked.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
-      if (options?.excludeFile) {
-        if (r.metadata.filePath === options.excludeFile) return false;
+      if (excludedStoredFile) {
+        if (r.metadata.filePath === excludedStoredFile) return false;
       }
-      if (options?.fileType) {
-        const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
-        if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
-      }
-      if (options?.directory) {
-        const normalizedDir = options.directory.replace(/^\/|\/$/g, "");
-        if (!r.metadata.filePath.includes(`/${normalizedDir}/`) && !r.metadata.filePath.includes(`${normalizedDir}/`)) return false;
-      }
-      if (options?.chunkType) {
-        if (r.metadata.chunkType !== options.chunkType) return false;
-      }
-      return true;
+      return matchesHardSearchFilters(r, options, this.projectRoot);
     }).slice(0, limit);
     const totalSearchMs = import_perf_hooks.performance.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
@@ -11390,10 +11583,11 @@ var Indexer = class _Indexer {
     return Promise.all(
       filtered.map(async (r) => {
         let content = "";
+        const resolvedFilePath = this.resolveStoredFilePath(r.metadata.filePath);
         if (this.config.search.includeContext) {
           try {
             const fileContent = await import_fs10.promises.readFile(
-              r.metadata.filePath,
+              resolvedFilePath,
               "utf-8"
             );
             const lines = fileContent.split("\n");
@@ -11403,7 +11597,7 @@ var Indexer = class _Indexer {
           }
         }
         return {
-          filePath: r.metadata.filePath,
+          filePath: resolvedFilePath,
           startLine: r.metadata.startLine,
           endLine: r.metadata.endLine,
           content,
@@ -11424,7 +11618,7 @@ var Indexer = class _Indexer {
       for (const edge of database.getCallersWithContext(targetName, branchKey, callTypeFilter)) {
         if (!seen.has(edge.id)) {
           seen.add(edge.id);
-          results.push(edge);
+          results.push(this.resolveCallEdgeFilePath(edge));
         }
       }
     }
@@ -11443,7 +11637,7 @@ var Indexer = class _Indexer {
         const safelyMatchesUnresolvedSymbol = includeUnresolved && !edge.toSymbolId;
         if (!matchesResolvedSymbol && !safelyMatchesUnresolvedSymbol || seen.has(edge.id)) continue;
         seen.add(edge.id);
-        results.push(edge);
+        results.push(this.resolveCallEdgeFilePath(edge));
       }
     }
     return results;
@@ -11457,7 +11651,7 @@ var Indexer = class _Indexer {
       for (const edge of database.getCallees(symbolId, branchKey, callTypeFilter)) {
         if (!seen.has(edge.id)) {
           seen.add(edge.id);
-          results.push(edge);
+          results.push(this.resolveCallEdgeFilePath(edge));
         }
       }
     }
@@ -11473,7 +11667,7 @@ var Indexer = class _Indexer {
         shortest = path30;
       }
     }
-    return shortest;
+    return shortest.map((hop) => this.resolveFilePathRecord(hop));
   }
   async findCallPathBySymbolIds(fromSymbolId, toSymbolId, maxDepth = 10) {
     const { database, readIssues } = await this.ensureInitialized();
@@ -11539,7 +11733,7 @@ var Indexer = class _Indexer {
         shortest = path30;
       }
     }
-    return shortest;
+    return shortest.map((hop) => this.resolveFilePathRecord(hop));
   }
   async getCallGraphSymbols() {
     const { database, readIssues } = await this.ensureInitialized();
@@ -11547,7 +11741,7 @@ var Indexer = class _Indexer {
     const symbols = /* @__PURE__ */ new Map();
     for (const branchKey of this.getBranchCatalogKeys()) {
       for (const symbol of database.getSymbolsForBranch(branchKey)) {
-        symbols.set(symbol.id, symbol);
+        symbols.set(symbol.id, this.resolveFilePathRecord(symbol));
       }
     }
     return [...symbols.values()];
@@ -11556,31 +11750,32 @@ var Indexer = class _Indexer {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
-    return database.getSymbolsForBranch(resolvedBranch);
+    return database.getSymbolsForBranch(resolvedBranch).map((symbol) => this.resolveFilePathRecord(symbol));
   }
   async getSymbolsForFiles(filePaths, branch) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
-    return database.getSymbolsForFiles(filePaths, resolvedBranch);
+    const storedFilePaths = filePaths.map((filePath) => this.toStoredFilePath(filePath));
+    return database.getSymbolsForFiles(storedFilePaths, resolvedBranch).map((symbol) => this.resolveFilePathRecord(symbol));
   }
   async getTransitiveReachability(rootSymbolIds, direction, maxDepth) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
     const branch = this.getBranchCatalogKey();
-    return database.getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth);
+    return database.getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth).map((entry) => this.resolveFilePathRecord(entry));
   }
   async detectCommunities(branch, symbolIds) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
-    return database.detectCommunities(resolvedBranch, symbolIds);
+    return database.detectCommunities(resolvedBranch, symbolIds).map((entry) => this.resolveFilePathRecord(entry));
   }
   async computeCentrality(branch) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
     const resolvedBranch = branch ?? this.getBranchCatalogKey();
-    return database.computeCentrality(resolvedBranch);
+    return database.computeCentrality(resolvedBranch).map((entry) => this.resolveFilePathRecord(entry));
   }
   async getPrImpact(opts, onPreparationProgress) {
     const initialState = await this.ensureInitialized();
@@ -11616,10 +11811,8 @@ var Indexer = class _Indexer {
     const requestedRef = opts.pr !== void 0 ? expectedCommit : headRefName ?? resolvedBranch;
     const storedCommit = this.getStoredBranchCommit(database, catalogIdentity);
     const catalogIdentityMatches = storedCommit === expectedCommit;
-    const symbolsCurrent = database.getMetadata(
-      this.getSymbolExtractorVersionMetadataKey(catalogIdentity)
-    ) === SYMBOL_EXTRACTOR_VERSION;
-    if (branchSymbols.length === 0 || !catalogIdentityMatches || !symbolsCurrent) {
+    const migrationsCurrent = this.areBranchMigrationVersionsCurrent(database, catalogIdentity);
+    if (branchSymbols.length === 0 || !catalogIdentityMatches || !migrationsCurrent) {
       if (!resolvedBranch || resolvedBranch === "default") {
         throw new Error("Run index_codebase first to build the call graph and symbol index for this project.");
       }
@@ -11675,8 +11868,9 @@ var Indexer = class _Indexer {
         );
       }
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path14.resolve(this.projectRoot, f));
-    const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
+    const toStoredChangedFiles = (filePaths) => filePaths.map((filePath) => this.toStoredFilePath(path14.resolve(this.projectRoot, filePath)));
+    const storedChangedFiles = toStoredChangedFiles(changedFiles);
+    const directSymbols = database.getSymbolsForFiles(storedChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
     const maxDepth = opts.maxDepth ?? 5;
@@ -11718,7 +11912,7 @@ var Indexer = class _Indexer {
       id: c.symbolId,
       name: c.symbolName,
       callerCount: c.callerCount,
-      filePath: c.filePath
+      filePath: this.resolveStoredFilePath(c.filePath)
     }));
     const totalAffected = allAffectedIds.length;
     let riskLevel;
@@ -11758,9 +11952,9 @@ var Indexer = class _Indexer {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path14.resolve(this.projectRoot, f));
+            const otherStored = toStoredChangedFiles(otherChanged.files);
             const prBranchKey = this.getBranchCatalogKeyFor(otherChanged.catalogIdentity);
-            const otherSymbols = database.getSymbolsForFiles(otherAbsolute, prBranchKey);
+            const otherSymbols = database.getSymbolsForFiles(otherStored, prBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
             for (const sym of otherSymbols) {
               const label = symbolToCommunity.get(structuralKey(sym.filePath, sym.name));
@@ -11791,12 +11985,12 @@ var Indexer = class _Indexer {
         id: s.id,
         name: s.name,
         kind: s.kind,
-        filePath: s.filePath
+        filePath: this.resolveStoredFilePath(s.filePath)
       })),
       transitiveCallers: transitiveCallers.map((c) => ({
         id: c.symbolId,
         name: c.symbolName,
-        filePath: c.filePath,
+        filePath: this.resolveStoredFilePath(c.filePath),
         depth: c.depth
       })),
       totalAffected,
@@ -11826,7 +12020,7 @@ var Indexer = class _Indexer {
       const absoluteDirectoryFilter = directory ? path14.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path14.resolve(filePath);
+          const absoluteFilePath = this.resolveStoredFilePath(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
           const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path14.sep));
           if (!matchesRelative && !matchesProjectRelative) {
@@ -11835,14 +12029,14 @@ var Indexer = class _Indexer {
         }
         for (const sym of database.getSymbolsByFile(filePath)) {
           if (symbolIdSet.has(sym.id) && !seenSymbols.has(sym.id)) {
-            seenSymbols.set(sym.id, sym);
+            seenSymbols.set(sym.id, this.resolveFilePathRecord(sym));
           }
         }
       }
       for (const symbolId of seenSymbols.keys()) {
         for (const edge of database.getCallees(symbolId, branchKey)) {
           if (!seenEdges.has(edge.id)) {
-            seenEdges.set(edge.id, edge);
+            seenEdges.set(edge.id, this.resolveCallEdgeFilePath(edge));
           }
         }
       }
@@ -12114,11 +12308,11 @@ function formatIndexStats(stats, verbose = false) {
   } else if (stats.indexedChunks === 0) {
     lines.push(`${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
   } else {
-    let main2 = `${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
+    let main = `${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
     if (stats.existingChunks > 0) {
-      main2 += ` ${stats.existingChunks} unchanged chunks skipped.`;
+      main += ` ${stats.existingChunks} unchanged chunks skipped.`;
     }
-    lines.push(main2);
+    lines.push(main);
     if (stats.removedChunks > 0) {
       lines.push(`Removed ${stats.removedChunks} stale chunks.`);
     }
@@ -13292,10 +13486,10 @@ function configureAutoIndex(projectRoot, host, config, getIndexer) {
   }
   coordinatorKeysByProject.set(projectKey, key);
 }
-function startAutoIndex(projectRoot, host = "opencode", source = "startup") {
+function startAutoIndex(projectRoot, host, source = "startup") {
   return getCoordinator(projectRoot, host)?.start(source) ?? null;
 }
-function requestBackgroundIndex(projectRoot, host = "opencode") {
+function requestBackgroundIndex(projectRoot, host) {
   return getCoordinator(projectRoot, host)?.request({
     checkFreshness: false,
     force: false,
@@ -13310,14 +13504,14 @@ function runCoordinatedIndex(projectRoot, host, force, onProgress) {
     source: "manual"
   }) ?? null;
 }
-function getAutoIndexStatus(projectRoot, host = "opencode") {
+function getAutoIndexStatus(projectRoot, host) {
   return getCoordinator(projectRoot, host)?.snapshot() ?? {
     enabled: false,
     state: "idle",
     updatedAt: now()
   };
 }
-async function waitForAutoIndexForRetrieval(projectRoot, host = "opencode") {
+async function waitForAutoIndexForRetrieval(projectRoot, host) {
   const coordinator = getCoordinator(projectRoot, host);
   if (!coordinator) return { ready: true };
   const initial = coordinator.snapshot();
@@ -13364,7 +13558,7 @@ async function waitForAutoIndexForRetrieval(projectRoot, host = "opencode") {
     text: `Automatic indexing is ${status.state}. Retry shortly or call index_status for progress. You can also run index_codebase explicitly.`
   };
 }
-async function stopAutoIndex(projectRoot, host = "opencode") {
+async function stopAutoIndex(projectRoot, host) {
   await getCoordinator(projectRoot, host)?.stop();
 }
 async function hasReadableCurrentIndex(coordinator) {
@@ -13511,7 +13705,7 @@ function loadJsonFile(filePath) {
 function loadConfigFile(filePath) {
   return loadJsonFile(filePath);
 }
-function loadProjectConfigLayer(projectRoot, host = "opencode") {
+function loadProjectConfigLayer(projectRoot, host) {
   const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
   const projectConfig = loadJsonFile(projectConfigPath);
   if (!projectConfig) {
@@ -13528,7 +13722,7 @@ function loadProjectConfigLayer(projectRoot, host = "opencode") {
   }
   return normalizedConfig;
 }
-function loadMergedConfig(projectRoot, host = "opencode") {
+function loadMergedConfig(projectRoot, host) {
   const globalConfigPath = resolveGlobalConfigPath(host);
   const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
   let globalConfig = null;
@@ -13597,7 +13791,7 @@ function toConfigRecord(rawConfig) {
   }
   return { ...rawConfig };
 }
-function loadRuntimeConfig(projectRoot, host = "opencode") {
+function loadRuntimeConfig(projectRoot, host) {
   return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot, host)), projectRoot);
 }
 
@@ -13680,14 +13874,14 @@ function getOrCreateIndexer(projectRoot, host) {
   configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
   return indexer;
 }
-function initializeTools(projectRoot, config, host = "opencode") {
+function initializeTools(projectRoot, config, host) {
   defaultProjectRoots.set(host, projectRoot);
   const key = getIndexerCacheKey(projectRoot, host);
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
   configureAutoIndex(projectRoot, host, config, () => getOrCreateIndexer(projectRoot, host));
 }
-function getIndexerForProject(projectRoot, host = "opencode") {
+function getIndexerForProject(projectRoot, host) {
   const root = getProjectRoot(projectRoot, host);
   return getOrCreateIndexer(root, host);
 }
@@ -13695,7 +13889,7 @@ function recordToolEffectiveness(projectRoot, host, event) {
   if (!isToolEffectivenessEnabled(projectRoot, host)) return;
   safelyRecordToolEffectiveness(event);
 }
-function refreshIndexerForDirectory(projectRoot, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot, host))) {
+function refreshIndexerForDirectory(projectRoot, host, config = parseConfig(loadRuntimeConfig(projectRoot, host))) {
   const key = getIndexerCacheKey(projectRoot, host);
   configCache.set(key, config);
   indexerCache.set(key, new Indexer(projectRoot, config, host));
@@ -15229,7 +15423,7 @@ function loadRawConfig(projectRoot, configPath) {
       fromPath
     );
   }
-  const projectConfig = resolveProjectConfigPath(projectRoot);
+  const projectConfig = resolveProjectConfigPath(projectRoot, "opencode");
   if ((0, import_fs15.existsSync)(projectConfig)) {
     return normalizeEvalConfigKnowledgeBases(
       parseJsonConfigFile(projectConfig),
@@ -15244,7 +15438,7 @@ function loadRawConfig(projectRoot, configPath) {
   return {};
 }
 function getIndexRootPath(projectRoot, scope) {
-  return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
+  return scope === "global" ? getGlobalIndexPath("opencode") : resolveProjectIndexPath(projectRoot, scope, "opencode");
 }
 function getLocalProjectIndexRoot(projectRoot) {
   return path21.join(projectRoot, ".opencode", "index");
@@ -15260,7 +15454,7 @@ function clearIndexRoot(projectRoot, scope) {
 }
 function ensureLocalEvalProjectConfig(projectRoot, configPath) {
   const localConfigPath = getLocalProjectConfigPath(projectRoot);
-  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot);
+  const resolvedConfigPath = configPath ? toAbsolute(projectRoot, configPath) : resolveProjectConfigPath(projectRoot, "opencode");
   if (!configPath && (0, import_fs15.existsSync)(localConfigPath)) {
     return localConfigPath;
   }
@@ -15695,7 +15889,7 @@ async function runEvaluation(options) {
   if (options.reindex) {
     clearIndexRoot(options.projectRoot, effectiveConfig.scope);
   }
-  const indexer = new Indexer(options.projectRoot, effectiveConfig);
+  const indexer = new Indexer(options.projectRoot, effectiveConfig, "opencode");
   try {
     await indexer.index();
     const perQuery = [];
@@ -15898,9 +16092,9 @@ var path23 = __toESM(require("path"), 1);
 function printUsage() {
   console.log(`
 Usage:
-  opencode-codebase-index-mcp eval run [options]
-  opencode-codebase-index-mcp eval compare --against <summary.json> [options]
-  opencode-codebase-index-mcp eval diff --current <summary.json> --against <summary.json> [options]
+  ${MCP_BINARY_CURRENT_NAME} eval run [options]
+  ${MCP_BINARY_CURRENT_NAME} eval compare --against <summary.json> [options]
+  ${MCP_BINARY_CURRENT_NAME} eval diff --current <summary.json> --against <summary.json> [options]
 
 Options:
   --project <path>                 Project root (default: cwd)
@@ -16189,11 +16383,21 @@ async function handleEvalCommand(args, cwd) {
   throw new Error(`Unknown eval subcommand: ${subcommand}`);
 }
 
-// src/mcp-server.ts
+// src/adapters/mcp/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/package-metadata.ts
 var import_fs18 = require("fs");
+var import_meta2 = {};
+function getPackageVersion() {
+  const raw = JSON.parse((0, import_fs18.readFileSync)(new URL("../package.json", import_meta2.url), "utf-8"));
+  if (raw && typeof raw === "object" && "version" in raw && typeof raw.version === "string") {
+    return raw.version;
+  }
+  return "0.0.0";
+}
 
-// src/mcp-server/register-prompts.ts
+// src/adapters/mcp/register-prompts.ts
 var import_zod = require("zod");
 function registerMcpPrompts(server) {
   server.prompt(
@@ -16283,7 +16487,7 @@ Use the implementation_lookup tool to find where this symbol is defined. This pr
   );
 }
 
-// src/mcp-server/register-tools.ts
+// src/adapters/mcp/register-tools.ts
 var import_zod2 = require("zod");
 
 // src/tools/contracts.ts
@@ -16423,13 +16627,89 @@ function formatPrImpact(result) {
   return lines.join("\n");
 }
 
-// src/mcp-server/register-tools.ts
+// src/tools/tool-names.ts
+var TOOL_NAME = {
+  CODEBASE_CONTEXT: "codebase_context",
+  CODEBASE_SEARCH: "codebase_search",
+  CODEBASE_PEEK: "codebase_peek",
+  FIND_SIMILAR: "find_similar",
+  IMPLEMENTATION_LOOKUP: "implementation_lookup",
+  INDEX_CODEBASE: "index_codebase",
+  INDEX_STATUS: "index_status",
+  INDEX_HEALTH_CHECK: "index_health_check",
+  INDEX_METRICS: "index_metrics",
+  INDEX_LOGS: "index_logs",
+  CALL_GRAPH: "call_graph",
+  CALL_GRAPH_PATH: "call_graph_path",
+  PR_IMPACT: "pr_impact",
+  ADD_KNOWLEDGE_BASE: "add_knowledge_base",
+  LIST_KNOWLEDGE_BASES: "list_knowledge_bases",
+  REMOVE_KNOWLEDGE_BASE: "remove_knowledge_base",
+  PI_KNOWLEDGE_BASE_ADD: "knowledge_base_add",
+  PI_KNOWLEDGE_BASE_LIST: "knowledge_base_list",
+  PI_KNOWLEDGE_BASE_REMOVE: "knowledge_base_remove",
+  INDEX_VISUALIZE: "index_visualize"
+};
+var PORTABLE_TOOL_NAMES = [
+  TOOL_NAME.CODEBASE_CONTEXT,
+  TOOL_NAME.CODEBASE_SEARCH,
+  TOOL_NAME.CODEBASE_PEEK,
+  TOOL_NAME.INDEX_CODEBASE,
+  TOOL_NAME.INDEX_STATUS,
+  TOOL_NAME.INDEX_HEALTH_CHECK,
+  TOOL_NAME.INDEX_METRICS,
+  TOOL_NAME.INDEX_LOGS,
+  TOOL_NAME.FIND_SIMILAR,
+  TOOL_NAME.IMPLEMENTATION_LOOKUP,
+  TOOL_NAME.CALL_GRAPH,
+  TOOL_NAME.CALL_GRAPH_PATH,
+  TOOL_NAME.PR_IMPACT
+];
+var OPENCODE_TOOL_NAMES = [
+  TOOL_NAME.CODEBASE_CONTEXT,
+  TOOL_NAME.CODEBASE_SEARCH,
+  TOOL_NAME.CODEBASE_PEEK,
+  TOOL_NAME.INDEX_CODEBASE,
+  TOOL_NAME.INDEX_STATUS,
+  TOOL_NAME.INDEX_HEALTH_CHECK,
+  TOOL_NAME.INDEX_METRICS,
+  TOOL_NAME.INDEX_LOGS,
+  TOOL_NAME.FIND_SIMILAR,
+  TOOL_NAME.CALL_GRAPH,
+  TOOL_NAME.CALL_GRAPH_PATH,
+  TOOL_NAME.IMPLEMENTATION_LOOKUP,
+  TOOL_NAME.ADD_KNOWLEDGE_BASE,
+  TOOL_NAME.LIST_KNOWLEDGE_BASES,
+  TOOL_NAME.REMOVE_KNOWLEDGE_BASE,
+  TOOL_NAME.PR_IMPACT,
+  TOOL_NAME.INDEX_VISUALIZE
+];
+var PI_TOOL_NAMES = [
+  TOOL_NAME.CODEBASE_CONTEXT,
+  TOOL_NAME.CODEBASE_SEARCH,
+  TOOL_NAME.CODEBASE_PEEK,
+  TOOL_NAME.FIND_SIMILAR,
+  TOOL_NAME.IMPLEMENTATION_LOOKUP,
+  TOOL_NAME.INDEX_CODEBASE,
+  TOOL_NAME.INDEX_STATUS,
+  TOOL_NAME.INDEX_HEALTH_CHECK,
+  TOOL_NAME.INDEX_METRICS,
+  TOOL_NAME.INDEX_LOGS,
+  TOOL_NAME.CALL_GRAPH,
+  TOOL_NAME.CALL_GRAPH_PATH,
+  TOOL_NAME.PR_IMPACT,
+  TOOL_NAME.PI_KNOWLEDGE_BASE_LIST,
+  TOOL_NAME.PI_KNOWLEDGE_BASE_ADD,
+  TOOL_NAME.PI_KNOWLEDGE_BASE_REMOVE
+];
+
+// src/adapters/mcp/register-tools.ts
 function allowNullAsUndefined(schema) {
   return import_zod2.z.preprocess((value) => value === null ? void 0 : value, schema);
 }
 function registerMcpTools(server, runtime) {
   server.tool(
-    "codebase_context",
+    TOOL_NAME.CODEBASE_CONTEXT,
     "PREFERRED FIRST TOOL for any question about this repository. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Use before built-in code search, grep, shell search, or broad file reads. Provide from+to for a dependency path, with optional fromFilePath/toFilePath when names are ambiguous; provide symbol for a definition; or provide only query for low-token conceptual discovery. Use call_graph directly for callers or callees.",
     {
       query: import_zod2.z.string().describe("The codebase question or behavior to locate. Always provide the user's repository question here."),
@@ -16456,7 +16736,7 @@ function registerMcpTools(server, runtime) {
     }
   );
   server.tool(
-    "codebase_search",
+    TOOL_NAME.CODEBASE_SEARCH,
     "FULL-CONTENT semantic retrieval. Use after codebase_peek when you need implementation text, not as the default first step. For exact identifiers or exhaustive matches use grep instead.",
     {
       query: import_zod2.z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
@@ -16488,7 +16768,7 @@ ${formatSearchResults(results, "score")}`;
     }
   );
   server.tool(
-    "codebase_peek",
+    TOOL_NAME.CODEBASE_PEEK,
     "DIRECT LOW-TOKEN semantic location lookup for unfamiliar-code discovery. Prefer codebase_context when the request may involve definitions or graph navigation; use this specialized tool when you only need conceptual locations.",
     {
       query: import_zod2.z.string().describe("Natural language description of what code you're looking for."),
@@ -16519,7 +16799,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "index_codebase",
+    TOOL_NAME.INDEX_CODEBASE,
     "Create or refresh the semantic index. Call index_status first when readiness is unknown, then use this tool only if the index is missing, stale, or incompatible. Incremental by default; force=true rebuilds everything.",
     {
       force: allowNullAsUndefined(import_zod2.z.boolean().optional().default(false)).describe("Force reindex even if already indexed"),
@@ -16532,7 +16812,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "index_status",
+    TOOL_NAME.INDEX_STATUS,
     "START HERE once per repository task when index readiness or freshness is unknown. Reports whether semantic retrieval is ready, chunk counts, compatibility, and the embedding provider. If ready, continue with codebase_peek or implementation_lookup; otherwise run index_codebase.",
     {},
     async () => {
@@ -16541,7 +16821,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "index_health_check",
+    TOOL_NAME.INDEX_HEALTH_CHECK,
     "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
     {},
     async () => {
@@ -16550,7 +16830,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "index_metrics",
+    TOOL_NAME.INDEX_METRICS,
     "Get operational metrics plus opt-in privacy-safe repository-tool effectiveness counters. Metrics are memory-only. Set reset=true to clear them before reading. Operational metrics require debug.enabled=true and debug.metrics=true. Privacy-safe aggregates require only effectivenessMetrics.enabled=true.",
     {
       reset: import_zod2.z.boolean().optional().default(false).describe("Reset in-memory operational and effectiveness metrics before returning the snapshot")
@@ -16561,7 +16841,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "index_logs",
+    TOOL_NAME.INDEX_LOGS,
     "Get recent debug logs from the codebase indexer. Requires debug.enabled=true in config.",
     {
       limit: allowNullAsUndefined(import_zod2.z.number().optional().default(20)).describe("Maximum number of log entries to return"),
@@ -16578,7 +16858,7 @@ ${formatCodebasePeek(results)}`;
     }
   );
   server.tool(
-    "find_similar",
+    TOOL_NAME.FIND_SIMILAR,
     "Use when you already have a code snippet and need analogous implementations, duplicates, patterns, or refactoring candidates. For a natural-language concept without example code, start with codebase_peek instead.",
     {
       code: import_zod2.z.string().describe("The code snippet to find similar code for"),
@@ -16605,7 +16885,7 @@ ${formatSearchResults(results)}` }] };
     }
   );
   server.tool(
-    "implementation_lookup",
+    TOOL_NAME.IMPLEMENTATION_LOOKUP,
     "FIRST TOOL only for known-symbol definition questions. Returns authoritative source locations and prefers implementations over tests, docs, examples, and fixtures. Do not use for callers, callees, dependency paths, or code flow; use codebase_context with direction or from/to for those questions.",
     {
       query: import_zod2.z.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
@@ -16619,7 +16899,7 @@ ${formatSearchResults(results)}` }] };
     }
   );
   server.tool(
-    "call_graph",
+    TOOL_NAME.CALL_GRAPH,
     "Find direct callers or callees by function or method name. Unique names resolve automatically; when duplicate names are reported, retry with filePath. Supports relationship types: Call, MethodCall, Constructor, Import, Inherits, Implements.",
     {
       name: import_zod2.z.string().describe("Function or method name to query"),
@@ -16638,7 +16918,7 @@ ${formatSearchResults(results)}` }] };
     }
   );
   server.tool(
-    "call_graph_path",
+    TOOL_NAME.CALL_GRAPH_PATH,
     "Find the shortest known call path between two named functions or methods. Unique names resolve automatically; when duplicate endpoints are reported, retry with fromFilePath or toFilePath.",
     {
       from: import_zod2.z.string().describe("Source function/method name (starting point)"),
@@ -16653,7 +16933,7 @@ ${formatSearchResults(results)}` }] };
     }
   );
   server.tool(
-    "pr_impact",
+    TOOL_NAME.PR_IMPACT,
     "FIRST TOOL for pull-request or branch blast-radius questions. Analyzes changed files, affected symbols, transitive dependencies, communities, hub nodes, conflicts, and risk before merging.",
     {
       pr: allowNullAsUndefined(import_zod2.z.number().optional()).describe("Pull request number to analyze"),
@@ -16684,22 +16964,14 @@ ${formatSearchResults(results)}` }] };
   );
 }
 
-// src/mcp-server.ts
-var import_meta2 = {};
+// src/adapters/mcp/server.ts
 function getServerInstructions(host) {
   const hostText = `host ${host}`;
   return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns a token-budgeted location pack and routes to definitions or call-graph helpers when symbol intent is present. Keep the default tokenBudget for normal discovery, then use implementation_lookup, codebase_search, or a targeted file read only for selected locations that need source content. Use codebase_peek for direct conceptual location lookup. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
 }
-function getPackageVersion() {
-  const raw = JSON.parse((0, import_fs18.readFileSync)(new URL("../package.json", import_meta2.url), "utf-8"));
-  if (raw && typeof raw === "object" && "version" in raw && typeof raw.version === "string") {
-    return raw.version;
-  }
-  return "0.0.0";
-}
-function createMcpServer(projectRoot, config, host = "opencode") {
+function createMcpServer(projectRoot, config, host) {
   const server = new import_mcp.McpServer({
-    name: "opencode-codebase-index",
+    name: MCP_SERVER_CURRENT_NAME,
     version: getPackageVersion()
   }, {
     instructions: getServerInstructions(host)
@@ -16734,6 +17006,9 @@ function createMcpServer(projectRoot, config, host = "opencode") {
   return server;
 }
 
+// src/watcher/file-watcher.ts
+var import_fs19 = require("fs");
+
 // node_modules/chokidar/index.js
 var import_node_events = require("events");
 var import_node_fs2 = require("fs");
@@ -17278,10 +17553,10 @@ var foreach = (val, fn) => {
     fn(val);
   }
 };
-var addAndConvert = (main2, prop, item) => {
-  let container = main2[prop];
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
   if (!(container instanceof Set)) {
-    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+    main[prop] = container = /* @__PURE__ */ new Set([container]);
   }
   container.add(item);
 };
@@ -17293,12 +17568,12 @@ var clearItem = (cont) => (key) => {
     delete cont[key];
   }
 };
-var delFromSet = (main2, prop, item) => {
-  const container = main2[prop];
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
   if (container instanceof Set) {
     container.delete(item);
   } else if (container === item) {
-    delete main2[prop];
+    delete main[prop];
   }
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
@@ -17479,9 +17754,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname13 = sp.dirname(file);
+    const dirname14 = sp.dirname(file);
     const basename7 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname13);
+    const parent = this.fsw._getWatchedDir(dirname14);
     let prevStats = stats;
     if (parent.has(basename7))
       return;
@@ -17508,7 +17783,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname13, basename7);
+          this.fsw._remove(dirname14, basename7);
         }
       } else if (parent.has(basename7)) {
         const at = newStats.atimeMs;
@@ -18472,8 +18747,8 @@ var FileWatcher = class {
   watcher = null;
   projectRoot;
   config;
-  host;
   configPath;
+  projectConfigPaths;
   pendingChanges = /* @__PURE__ */ new Map();
   debounceTimer = null;
   debounceMs = 1e3;
@@ -18482,11 +18757,11 @@ var FileWatcher = class {
   resolveReady = null;
   pollingFallbackAttempted = false;
   pendingClose = null;
-  constructor(projectRoot, config, host = "opencode", options = {}) {
+  constructor(projectRoot, config, host, options = {}) {
     this.projectRoot = projectRoot;
     this.config = config;
-    this.host = host;
     this.configPath = options.configPath;
+    this.projectConfigPaths = options.configPath ? [options.configPath] : getProjectConfigCandidatePaths(projectRoot, host);
   }
   start(handler) {
     if (this.watcher) {
@@ -18504,7 +18779,19 @@ var FileWatcher = class {
   }
   createWatcher(usePolling = false) {
     const ignoreFilter = createIgnoreFilter(this.projectRoot);
-    const watchTargets = this.configPath ? [this.projectRoot, this.configPath] : this.projectRoot;
+    let watchTargets = this.projectRoot;
+    if (this.configPath) {
+      watchTargets = [this.projectRoot, this.configPath];
+    } else {
+      const externalConfigTargets = this.projectConfigPaths.filter((projectConfigPath) => {
+        const relativeConfigPath = path25.relative(this.projectRoot, projectConfigPath);
+        return this.isOutsideProjectPath(relativeConfigPath);
+      }).map((projectConfigPath) => (0, import_fs19.existsSync)(projectConfigPath) ? projectConfigPath : this.getNearestExistingDirectory(path25.dirname(projectConfigPath)));
+      const uniqueExternalConfigTargets = [...new Set(externalConfigTargets)];
+      if (uniqueExternalConfigTargets.length > 0) {
+        watchTargets = [this.projectRoot, ...uniqueExternalConfigTargets];
+      }
+    }
     const watcherOptions = {
       ignored: (filePath) => {
         const relativePath = path25.relative(this.projectRoot, filePath);
@@ -18512,6 +18799,9 @@ var FileWatcher = class {
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
         }
+        if (this.isOutsideProjectPath(relativePath)) {
+          return true;
+        }
         if (hasFilteredPathSegment(relativePath, path25.sep)) {
           return true;
         }
@@ -18614,14 +18904,22 @@ var FileWatcher = class {
       (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path25.sep}`)
     );
   }
-  getProjectConfigRelativePaths() {
-    if (this.configPath) {
-      return [path25.normalize(path25.relative(this.projectRoot, this.configPath))];
+  isOutsideProjectPath(relativePath) {
+    return relativePath === ".." || relativePath.startsWith(`..${path25.sep}`) || path25.isAbsolute(relativePath);
+  }
+  getNearestExistingDirectory(directoryPath) {
+    let candidate = directoryPath;
+    while (!(0, import_fs19.existsSync)(candidate)) {
+      const parent = path25.dirname(candidate);
+      if (parent === candidate) break;
+      candidate = parent;
     }
-    return [
-      resolveProjectConfigPath(this.projectRoot, this.host),
-      resolveWritableProjectConfigPath(this.projectRoot, this.host)
-    ].map((configPath) => path25.normalize(path25.relative(this.projectRoot, configPath)));
+    return candidate;
+  }
+  getProjectConfigRelativePaths() {
+    return this.projectConfigPaths.map(
+      (configPath) => path25.normalize(path25.relative(this.projectRoot, configPath))
+    );
   }
   scheduleFlush() {
     if (this.debounceTimer) {
@@ -18748,8 +19046,9 @@ var GitHeadWatcher = class {
 };
 
 // src/watcher/index.ts
-function createWatcherWithIndexer(getIndexer, projectRoot, config, host = "opencode", options = {}) {
+function createWatcherWithIndexer(getIndexer, projectRoot, config, host, options = {}) {
   const fileWatcher = new FileWatcher(projectRoot, config, host, options);
+  const configPaths = getConfigPaths(projectRoot, host, options);
   configureAutoIndex(projectRoot, host, parseConfig(config), getIndexer);
   let stopped = false;
   const requestReindex = () => {
@@ -18766,7 +19065,6 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config, host = "openc
     );
     const hasDelete = changes.some((c) => c.type === "unlink");
     if (hasAddOrChange || hasDelete) {
-      const configPaths = getConfigPaths(projectRoot, host, options);
       if (changes.some((change) => configPaths.includes(pathNormalize(change.path)))) {
         const parsedConfig = options.configPath ? parseConfig(loadConfigFile(options.configPath)) : void 0;
         const refreshedConfig = refreshIndexerForDirectory(projectRoot, host, parsedConfig);
@@ -18781,7 +19079,9 @@ function createWatcherWithIndexer(getIndexer, projectRoot, config, host = "openc
   if (isGitRepo(projectRoot)) {
     gitWatcher = new GitHeadWatcher(projectRoot);
     gitWatcher.start(async (oldBranch, newBranch) => {
-      getIndexer().getLogger().branch("info", "Branch changed", {
+      const indexer = getIndexer();
+      indexer.refreshBranchInfo();
+      indexer.getLogger().branch("info", "Branch changed", {
         oldBranch,
         newBranch
       });
@@ -18807,10 +19107,9 @@ function getConfigPaths(projectRoot, host, options) {
   if (options.configPath) {
     return [pathNormalize(options.configPath)];
   }
-  return [
-    resolveProjectConfigPath(projectRoot, host),
-    resolveWritableProjectConfigPath(projectRoot, host)
-  ].map((configPath) => pathNormalize(configPath));
+  return getProjectConfigCandidatePaths(projectRoot, host).map(
+    (configPath) => pathNormalize(configPath)
+  );
 }
 
 // src/tools/visualize/activity.ts
@@ -19516,8 +19815,7 @@ function transformForVisualization(symbols, edges, options = {}) {
   };
 }
 
-// src/cli.ts
-var import_meta3 = {};
+// src/adapters/mcp/cli.ts
 function parseArgs(argv) {
   let project = process.cwd();
   let config;
@@ -19539,7 +19837,7 @@ function loadCliRawConfig(args) {
   return args.config ? loadConfigFile(args.config) : loadMergedConfig(args.project, args.host);
 }
 function isCliEntrypoint(moduleUrl, argvPath) {
-  return argvPath !== void 0 && (0, import_fs19.realpathSync)((0, import_url.fileURLToPath)(moduleUrl)) === (0, import_fs19.realpathSync)(argvPath);
+  return argvPath !== void 0 && (0, import_fs20.realpathSync)((0, import_url.fileURLToPath)(moduleUrl)) === (0, import_fs20.realpathSync)(argvPath);
 }
 function parseVisualizeArgs(argv, cwd) {
   let project = cwd;
@@ -19568,8 +19866,8 @@ function parseVisualizeArgs(argv, cwd) {
 async function handleVisualizeCommand(argv, cwd) {
   try {
     const args = parseVisualizeArgs(argv, cwd);
-    const config = parseConfig(loadMergedConfig(args.project));
-    const indexer = new Indexer(args.project, config);
+    const config = parseConfig(loadMergedConfig(args.project, "opencode"));
+    const indexer = new Indexer(args.project, config, "opencode");
     const rawData = await indexer.getVisualizationData({
       directory: args.directory
     });
@@ -19587,7 +19885,7 @@ async function handleVisualizeCommand(argv, cwd) {
       return 1;
     }
     const outputPath = path29.join(os8.tmpdir(), `call-graph-${Date.now()}.html`);
-    (0, import_fs19.writeFileSync)(outputPath, generateVisualizationHtml(vizData), "utf-8");
+    (0, import_fs20.writeFileSync)(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}`);
@@ -19600,16 +19898,16 @@ async function handleVisualizeCommand(argv, cwd) {
     return 1;
   }
 }
-async function main() {
-  if (process.argv[2] === "eval") {
-    const exitCode = await handleEvalCommand(process.argv.slice(3), process.cwd());
+async function runMcpCli(argv) {
+  if (argv[2] === "eval") {
+    const exitCode = await handleEvalCommand(argv.slice(3), process.cwd());
     process.exit(exitCode);
   }
-  if (process.argv[2] === "visualize") {
-    const exitCode = await handleVisualizeCommand(process.argv.slice(3), process.cwd());
+  if (argv[2] === "visualize") {
+    const exitCode = await handleVisualizeCommand(argv.slice(3), process.cwd());
     process.exit(exitCode);
   }
-  const args = parseArgs(process.argv);
+  const args = parseArgs(argv);
   const rawConfig = loadCliRawConfig(args);
   const config = parseConfig(rawConfig);
   const server = createMcpServer(args.project, config, args.host);
@@ -19660,8 +19958,11 @@ function handleMainError(error) {
   console.error("Fatal: failed to start MCP server");
   process.exit(1);
 }
+
+// src/cli.ts
+var import_meta3 = {};
 if (isCliEntrypoint(import_meta3.url, process.argv[1])) {
-  main().catch(handleMainError);
+  runMcpCli(process.argv).catch(handleMainError);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {