opencode-codebase-index 0.5.1 → 0.5.2

package/dist/cli.js

@@ -782,9 +782,15 @@ function getDefaultSearchConfig() {
     minScore: 0.1,
     includeContext: true,
     hybridWeight: 0.5,
+    fusionStrategy: "rrf",
+    rrfK: 60,
+    rerankTopN: 20,
     contextLines: 0
   };
 }
+function isValidFusionStrategy(value) {
+  return value === "weighted" || value === "rrf";
+}
 function getDefaultDebugConfig() {
   return {
     enabled: false,
@@ -839,6 +845,9 @@ function parseConfig(raw) {
     minScore: typeof rawSearch.minScore === "number" ? rawSearch.minScore : defaultSearch.minScore,
     includeContext: typeof rawSearch.includeContext === "boolean" ? rawSearch.includeContext : defaultSearch.includeContext,
     hybridWeight: typeof rawSearch.hybridWeight === "number" ? Math.min(1, Math.max(0, rawSearch.hybridWeight)) : defaultSearch.hybridWeight,
+    fusionStrategy: isValidFusionStrategy(rawSearch.fusionStrategy) ? rawSearch.fusionStrategy : defaultSearch.fusionStrategy,
+    rrfK: typeof rawSearch.rrfK === "number" ? Math.max(1, Math.floor(rawSearch.rrfK)) : defaultSearch.rrfK,
+    rerankTopN: typeof rawSearch.rerankTopN === "number" ? Math.min(200, Math.max(0, Math.floor(rawSearch.rerankTopN))) : defaultSearch.rerankTopN,
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
@@ -2936,6 +2945,9 @@ function hashContent(content) {
 function hashFile(filePath) {
   return native.hashFile(filePath);
 }
+function extractCalls(content, language) {
+  return native.extractCalls(content, language);
+}
 var VectorStore = class {
   inner;
   dimensions;
@@ -3267,6 +3279,12 @@ var Database = class {
   getChunksByFile(filePath) {
     return this.inner.getChunksByFile(filePath);
   }
+  getChunksByName(name) {
+    return this.inner.getChunksByName(name);
+  }
+  getChunksByNameCi(name) {
+    return this.inner.getChunksByNameCi(name);
+  }
   deleteChunksByFile(filePath) {
     return this.inner.deleteChunksByFile(filePath);
   }
@@ -3310,6 +3328,73 @@ var Database = class {
   getStats() {
     return this.inner.getStats();
   }
+  // ── Symbol methods ──────────────────────────────────────────────
+  upsertSymbol(symbol) {
+    this.inner.upsertSymbol(symbol);
+  }
+  upsertSymbolsBatch(symbols) {
+    if (symbols.length === 0) return;
+    this.inner.upsertSymbolsBatch(symbols);
+  }
+  getSymbolsByFile(filePath) {
+    return this.inner.getSymbolsByFile(filePath);
+  }
+  getSymbolByName(name, filePath) {
+    return this.inner.getSymbolByName(name, filePath) ?? null;
+  }
+  getSymbolsByName(name) {
+    return this.inner.getSymbolsByName(name);
+  }
+  getSymbolsByNameCi(name) {
+    return this.inner.getSymbolsByNameCi(name);
+  }
+  deleteSymbolsByFile(filePath) {
+    return this.inner.deleteSymbolsByFile(filePath);
+  }
+  // ── Call Edge methods ────────────────────────────────────────────
+  upsertCallEdge(edge) {
+    this.inner.upsertCallEdge(edge);
+  }
+  upsertCallEdgesBatch(edges) {
+    if (edges.length === 0) return;
+    this.inner.upsertCallEdgesBatch(edges);
+  }
+  getCallers(targetName, branch) {
+    return this.inner.getCallers(targetName, branch);
+  }
+  getCallersWithContext(targetName, branch) {
+    return this.inner.getCallersWithContext(targetName, branch);
+  }
+  getCallees(symbolId, branch) {
+    return this.inner.getCallees(symbolId, branch);
+  }
+  deleteCallEdgesByFile(filePath) {
+    return this.inner.deleteCallEdgesByFile(filePath);
+  }
+  resolveCallEdge(edgeId, toSymbolId) {
+    this.inner.resolveCallEdge(edgeId, toSymbolId);
+  }
+  // ── Branch Symbol methods ────────────────────────────────────────
+  addSymbolsToBranch(branch, symbolIds) {
+    this.inner.addSymbolsToBranch(branch, symbolIds);
+  }
+  addSymbolsToBranchBatch(branch, symbolIds) {
+    if (symbolIds.length === 0) return;
+    this.inner.addSymbolsToBranchBatch(branch, symbolIds);
+  }
+  getBranchSymbolIds(branch) {
+    return this.inner.getBranchSymbolIds(branch);
+  }
+  clearBranchSymbols(branch) {
+    return this.inner.clearBranchSymbols(branch);
+  }
+  // ── GC methods for symbols/edges ─────────────────────────────────
+  gcOrphanSymbols() {
+    return this.inner.gcOrphanSymbols();
+  }
+  gcOrphanCallEdges() {
+    return this.inner.gcOrphanCallEdges();
+  }
 };
 
 // src/git/index.ts
@@ -3410,6 +3495,29 @@ function getBranchOrDefault(repoRoot) {
 }
 
 // src/indexer/index.ts
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust"]);
+var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "arrow_function",
+  "method_definition",
+  "class_declaration",
+  "interface_declaration",
+  "type_alias_declaration",
+  "enum_declaration",
+  "function_definition",
+  "class_definition",
+  "decorated_definition",
+  "method_declaration",
+  "type_declaration",
+  "type_spec",
+  "function_item",
+  "impl_item",
+  "struct_item",
+  "enum_item",
+  "trait_item",
+  "mod_item"
+]);
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
   return Buffer.from(float32.buffer);
@@ -3434,6 +3542,892 @@ function isRateLimitError(error) {
   return message.includes("429") || message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("too many requests");
 }
 var INDEX_METADATA_VERSION = "1";
+var RANKING_TOKEN_CACHE_LIMIT = 4096;
+var rankingQueryTokenCache = /* @__PURE__ */ new Map();
+var rankingNameTokenCache = /* @__PURE__ */ new Map();
+var rankingPathTokenCache = /* @__PURE__ */ new Map();
+var rankingTextTokenCache = /* @__PURE__ */ new Map();
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "from",
+  "that",
+  "this",
+  "into",
+  "using",
+  "where",
+  "what",
+  "when",
+  "why",
+  "how",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "find",
+  "show",
+  "get",
+  "run",
+  "use",
+  "code",
+  "function",
+  "implementation",
+  "retrieve",
+  "results",
+  "result",
+  "search",
+  "pipeline",
+  "top",
+  "in",
+  "on",
+  "of",
+  "to",
+  "by",
+  "as",
+  "or",
+  "an",
+  "a"
+]);
+var TEST_PATH_SEGMENTS = [
+  "tests/",
+  "__tests__/",
+  "/test/",
+  "fixtures/",
+  "benchmark",
+  "README",
+  "ARCHITECTURE",
+  "docs/"
+];
+var IMPLEMENTATION_EXCLUDE_PATH_SEGMENTS = [
+  "tests/",
+  "__tests__/",
+  "/test/",
+  "fixtures/",
+  "benchmark",
+  "readme",
+  "architecture",
+  "docs/",
+  "examples/",
+  "example/",
+  ".github/",
+  "/scripts/",
+  "/migrations/",
+  "/generated/"
+];
+var SOURCE_INTENT_HINTS = /* @__PURE__ */ new Set([
+  "implement",
+  "implementation",
+  "function",
+  "method",
+  "class",
+  "logic",
+  "algorithm",
+  "pipeline",
+  "indexer",
+  "where"
+]);
+var DOC_TEST_INTENT_HINTS = /* @__PURE__ */ new Set([
+  "test",
+  "tests",
+  "fixture",
+  "fixtures",
+  "benchmark",
+  "readme",
+  "docs",
+  "documentation"
+]);
+var DOC_INTENT_HINTS = /* @__PURE__ */ new Set([
+  "readme",
+  "docs",
+  "documentation",
+  "guide",
+  "usage"
+]);
+function setBoundedCache(cache, key, value) {
+  if (cache.size >= RANKING_TOKEN_CACHE_LIMIT) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) {
+      cache.delete(oldest);
+    }
+  }
+  cache.set(key, value);
+}
+function tokenizeTextForRanking(text) {
+  if (!text) {
+    return /* @__PURE__ */ new Set();
+  }
+  const lowered = text.toLowerCase();
+  const cache = rankingQueryTokenCache.get(lowered) ?? rankingTextTokenCache.get(lowered);
+  if (cache) {
+    return cache;
+  }
+  const tokens = new Set(
+    lowered.replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 1 && !STOPWORDS.has(token))
+  );
+  setBoundedCache(rankingQueryTokenCache, lowered, tokens);
+  setBoundedCache(rankingTextTokenCache, lowered, tokens);
+  return tokens;
+}
+function splitPathTokens(filePath) {
+  const lowered = filePath.toLowerCase();
+  const cache = rankingPathTokenCache.get(lowered);
+  if (cache) {
+    return cache;
+  }
+  const normalized = lowered.replace(/[^a-z0-9/._-]/g, " ").split(/[/._-]+/).filter((token) => token.length > 1);
+  const tokens = new Set(normalized);
+  setBoundedCache(rankingPathTokenCache, lowered, tokens);
+  return tokens;
+}
+function splitNameTokens(name) {
+  if (!name) {
+    return /* @__PURE__ */ new Set();
+  }
+  const lowered = name.toLowerCase();
+  const cache = rankingNameTokenCache.get(lowered);
+  if (cache) {
+    return cache;
+  }
+  const tokens = new Set(
+    lowered.replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 1)
+  );
+  setBoundedCache(rankingNameTokenCache, lowered, tokens);
+  return tokens;
+}
+function chunkTypeBoost(chunkType) {
+  switch (chunkType) {
+    case "function":
+    case "function_declaration":
+    case "method":
+    case "method_definition":
+    case "class":
+    case "class_declaration":
+      return 0.2;
+    case "interface":
+    case "type":
+    case "enum":
+    case "struct":
+    case "impl":
+    case "trait":
+    case "module":
+      return 0.1;
+    default:
+      return 0;
+  }
+}
+function isTestOrDocPath(filePath) {
+  return TEST_PATH_SEGMENTS.some((segment) => filePath.includes(segment));
+}
+function isLikelyImplementationPath(filePath) {
+  const lowered = filePath.toLowerCase();
+  if (IMPLEMENTATION_EXCLUDE_PATH_SEGMENTS.some((segment) => lowered.includes(segment))) {
+    return false;
+  }
+  const ext = lowered.split(".").pop() ?? "";
+  if (["md", "mdx", "txt", "rst", "adoc", "snap", "json", "yaml", "yml", "lock"].includes(ext)) {
+    return false;
+  }
+  return true;
+}
+function classifyQueryIntent(tokens) {
+  const sourceIntentHits = tokens.filter((t) => SOURCE_INTENT_HINTS.has(t)).length;
+  const docTestIntentHits = tokens.filter((t) => DOC_TEST_INTENT_HINTS.has(t)).length;
+  return sourceIntentHits >= docTestIntentHits ? "source" : "doc_test";
+}
+function classifyQueryIntentRaw(query) {
+  const lowerQuery = query.toLowerCase();
+  const docTestRawHits = Array.from(DOC_TEST_INTENT_HINTS).filter(
+    (hint) => new RegExp(`\\b${hint}\\b`).test(lowerQuery)
+  ).length;
+  const sourceRawHits = [
+    "implement",
+    "implementation",
+    "implements",
+    "function",
+    "method",
+    "class",
+    "logic",
+    "algorithm",
+    "pipeline",
+    "indexer"
+  ].filter((hint) => new RegExp(`\\b${hint}\\b`).test(lowerQuery)).length;
+  if (docTestRawHits > sourceRawHits) {
+    return "doc_test";
+  }
+  if (sourceRawHits > docTestRawHits) {
+    return "source";
+  }
+  const hasWhereIsPattern = /\bwhere\s+is\b/.test(lowerQuery);
+  const hasIdentifierHints = extractIdentifierHints(query).length > 0;
+  if (hasWhereIsPattern && hasIdentifierHints && docTestRawHits === 0) {
+    return "source";
+  }
+  const queryTokens = Array.from(tokenizeTextForRanking(query));
+  return classifyQueryIntent(queryTokens);
+}
+function classifyDocIntent(tokens) {
+  const docHits = tokens.filter((t) => DOC_INTENT_HINTS.has(t)).length;
+  const testHits = tokens.filter((t) => ["test", "tests", "fixture", "fixtures", "benchmark"].includes(t)).length;
+  if (docHits > 0 && testHits === 0) return "docs";
+  if (testHits > 0 && docHits === 0) return "test";
+  if (testHits > 0 || docHits > 0) return "mixed";
+  return "none";
+}
+function isImplementationChunkType(chunkType) {
+  return [
+    "export_statement",
+    "function",
+    "function_declaration",
+    "method",
+    "method_definition",
+    "class",
+    "class_declaration",
+    "interface",
+    "type",
+    "enum",
+    "module"
+  ].includes(chunkType);
+}
+function extractIdentifierHints(query) {
+  const identifiers = query.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [];
+  return identifiers.filter((id) => id.length >= 3).filter((id) => {
+    const lower = id.toLowerCase();
+    if (STOPWORDS.has(lower)) return false;
+    return /[A-Z]/.test(id) || id.includes("_") || id.endsWith("Results") || id.endsWith("Result");
+  }).map((id) => id.toLowerCase());
+}
+function extractCodeTermHints(query) {
+  const terms = query.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [];
+  return terms.map((term) => term.toLowerCase()).filter((term) => term.length >= 3).filter((term) => !STOPWORDS.has(term));
+}
+function normalizeIdentifierVariants(identifier) {
+  const lower = identifier.toLowerCase();
+  const compact = lower.replace(/[^a-z0-9]/g, "");
+  const snake = compact.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+  const kebab = snake.replace(/_/g, "-");
+  const variants = [lower, compact, snake, kebab].filter((value) => value.length > 0);
+  return Array.from(new Set(variants));
+}
+function scoreIdentifierMatch(name, filePath, hints) {
+  const nameLower = (name ?? "").toLowerCase();
+  const pathLower = filePath.toLowerCase();
+  let best = 0;
+  for (const hint of hints) {
+    const variants = normalizeIdentifierVariants(hint);
+    for (const variant of variants) {
+      if (nameLower === variant) {
+        best = Math.max(best, 1);
+      } else if (nameLower.includes(variant)) {
+        best = Math.max(best, 0.8);
+      } else if (pathLower.includes(variant)) {
+        best = Math.max(best, 0.6);
+      }
+    }
+  }
+  return best;
+}
+function extractPrimaryIdentifierQueryHint(query) {
+  const identifiers = extractIdentifierHints(query);
+  if (identifiers.length > 0) {
+    return identifiers[0] ?? null;
+  }
+  const codeTerms = extractCodeTermHints(query);
+  const best = codeTerms.find((term) => term.length >= 6);
+  return best ?? null;
+}
+var FILE_PATH_HINT_EXTENSIONS = [
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "mts",
+  "cts",
+  "py",
+  "rs",
+  "go",
+  "java",
+  "kt",
+  "kts",
+  "swift",
+  "rb",
+  "php",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "cxx",
+  "hpp",
+  "cs",
+  "scala",
+  "lua",
+  "sh",
+  "bash",
+  "zsh",
+  "json",
+  "yaml",
+  "yml",
+  "toml"
+];
+var FILE_PATH_HINT_SUFFIX_REGEX = new RegExp(
+  "\\s+\\bin\\s+[\"'`]?((?:\\.\\/)?(?:[A-Za-z0-9._-]+\\/)+[A-Za-z0-9._-]+\\.(?:" + FILE_PATH_HINT_EXTENSIONS.join("|") + "))[\"'`]?[\\])}>.,;!?]*\\s*$",
+  "i"
+);
+function normalizeFilePathForHintMatch(filePath) {
+  return filePath.replace(/\\/g, "/").toLowerCase().replace(/^\.\//, "");
+}
+function pathMatchesHint(filePath, hint) {
+  const normalizedPath = normalizeFilePathForHintMatch(filePath);
+  const normalizedHint = normalizeFilePathForHintMatch(hint);
+  return normalizedPath.endsWith(normalizedHint) || normalizedPath.includes(`/${normalizedHint}`) || normalizedPath.includes(normalizedHint);
+}
+function extractFilePathHint(query) {
+  const match = query.match(FILE_PATH_HINT_SUFFIX_REGEX);
+  const rawPath = match?.[1];
+  if (!rawPath) {
+    return null;
+  }
+  return rawPath.replace(/^\.\//, "");
+}
+function stripFilePathHint(query) {
+  const stripped = query.replace(FILE_PATH_HINT_SUFFIX_REGEX, "").trim();
+  return stripped.length > 0 ? stripped : query;
+}
+function buildDeterministicIdentifierPass(query, candidates, limit) {
+  if (classifyQueryIntentRaw(query) !== "source") {
+    return [];
+  }
+  const primary = extractPrimaryIdentifierQueryHint(query);
+  if (!primary) {
+    return [];
+  }
+  const filePathHint = extractFilePathHint(query);
+  const primaryVariants = normalizeIdentifierVariants(primary);
+  const hints = [primary, ...extractIdentifierHints(query), ...extractCodeTermHints(query)].map((value) => value.toLowerCase()).filter((value, idx, arr) => value.length >= 3 && arr.indexOf(value) === idx).slice(0, 8);
+  const deterministic = candidates.filter(
+    (candidate) => isLikelyImplementationPath(candidate.metadata.filePath) && isImplementationChunkType(candidate.metadata.chunkType)
+  ).map((candidate) => {
+    const nameLower = (candidate.metadata.name ?? "").toLowerCase();
+    const pathLower = candidate.metadata.filePath.toLowerCase();
+    let maxMatch = 0;
+    const nameMatchesPrimary = primaryVariants.some(
+      (variant) => nameLower === variant || nameLower.replace(/[^a-z0-9]/g, "") === variant.replace(/[^a-z0-9]/g, "")
+    );
+    const pathMatchesFileHint = filePathHint ? pathMatchesHint(candidate.metadata.filePath, filePathHint) : false;
+    for (const hint of hints) {
+      const variants = normalizeIdentifierVariants(hint);
+      for (const variant of variants) {
+        if (nameLower === variant) {
+          maxMatch = Math.max(maxMatch, 1);
+        } else if (nameLower.includes(variant)) {
+          maxMatch = Math.max(maxMatch, 0.85);
+        } else if (pathLower.includes(variant)) {
+          maxMatch = Math.max(maxMatch, 0.7);
+        }
+      }
+    }
+    if (pathMatchesFileHint && nameMatchesPrimary) {
+      maxMatch = Math.max(maxMatch, 1);
+    }
+    return {
+      candidate,
+      maxMatch,
+      pathMatchesFileHint,
+      nameMatchesPrimary
+    };
+  }).filter((entry) => entry.maxMatch >= 0.7).sort((a, b) => {
+    const aAnchored = a.pathMatchesFileHint && a.nameMatchesPrimary ? 1 : 0;
+    const bAnchored = b.pathMatchesFileHint && b.nameMatchesPrimary ? 1 : 0;
+    if (aAnchored !== bAnchored) return bAnchored - aAnchored;
+    if (b.maxMatch !== a.maxMatch) return b.maxMatch - a.maxMatch;
+    if (b.candidate.score !== a.candidate.score) return b.candidate.score - a.candidate.score;
+    return a.candidate.id.localeCompare(b.candidate.id);
+  }).slice(0, Math.max(limit * 2, 12));
+  return deterministic.map((entry) => ({
+    id: entry.candidate.id,
+    score: entry.pathMatchesFileHint && entry.nameMatchesPrimary ? 0.995 : Math.min(1, 0.9 + entry.maxMatch * 0.09),
+    metadata: entry.candidate.metadata
+  }));
+}
+function fuseResultsWeighted(semanticResults, keywordResults, keywordWeight, limit) {
+  const semanticWeight = 1 - keywordWeight;
+  const fusedScores = /* @__PURE__ */ new Map();
+  for (const r of semanticResults) {
+    fusedScores.set(r.id, {
+      score: r.score * semanticWeight,
+      metadata: r.metadata
+    });
+  }
+  for (const r of keywordResults) {
+    const existing = fusedScores.get(r.id);
+    if (existing) {
+      existing.score += r.score * keywordWeight;
+    } else {
+      fusedScores.set(r.id, {
+        score: r.score * keywordWeight,
+        metadata: r.metadata
+      });
+    }
+  }
+  const results = Array.from(fusedScores.entries()).map(([id, data]) => ({
+    id,
+    score: data.score,
+    metadata: data.metadata
+  }));
+  results.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  return results.slice(0, limit);
+}
+function fuseResultsRrf(semanticResults, keywordResults, rrfK, limit) {
+  const maxPossibleRaw = 2 / (rrfK + 1);
+  const rankByIdSemantic = /* @__PURE__ */ new Map();
+  const rankByIdKeyword = /* @__PURE__ */ new Map();
+  const metadataById = /* @__PURE__ */ new Map();
+  semanticResults.forEach((result, index) => {
+    rankByIdSemantic.set(result.id, index + 1);
+    metadataById.set(result.id, result.metadata);
+  });
+  keywordResults.forEach((result, index) => {
+    rankByIdKeyword.set(result.id, index + 1);
+    if (!metadataById.has(result.id)) {
+      metadataById.set(result.id, result.metadata);
+    }
+  });
+  const allIds = /* @__PURE__ */ new Set([...rankByIdSemantic.keys(), ...rankByIdKeyword.keys()]);
+  const fused = [];
+  for (const id of allIds) {
+    const semanticRank = rankByIdSemantic.get(id);
+    const keywordRank = rankByIdKeyword.get(id);
+    const semanticScore = semanticRank ? 1 / (rrfK + semanticRank) : 0;
+    const keywordScore = keywordRank ? 1 / (rrfK + keywordRank) : 0;
+    const metadata = metadataById.get(id);
+    if (!metadata) continue;
+    fused.push({
+      id,
+      score: maxPossibleRaw > 0 ? (semanticScore + keywordScore) / maxPossibleRaw : 0,
+      metadata
+    });
+  }
+  fused.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  return fused.slice(0, limit);
+}
+function rerankResults(query, candidates, rerankTopN, options) {
+  if (rerankTopN <= 0 || candidates.length <= 1) {
+    return candidates;
+  }
+  const topN = Math.min(rerankTopN, candidates.length);
+  const queryTokens = tokenizeTextForRanking(query);
+  if (queryTokens.size === 0) {
+    return candidates;
+  }
+  const queryTokenList = Array.from(queryTokens);
+  const intent = classifyQueryIntentRaw(query);
+  const docIntent = classifyDocIntent(queryTokenList);
+  const preferSourcePaths = options?.prioritizeSourcePaths ?? intent === "source";
+  const identifierHints = extractIdentifierHints(query);
+  const head = candidates.slice(0, topN).map((candidate, idx) => {
+    const pathTokens = splitPathTokens(candidate.metadata.filePath);
+    const nameTokens = splitNameTokens(candidate.metadata.name ?? "");
+    const chunkTypeTokens = tokenizeTextForRanking(candidate.metadata.chunkType);
+    let exactOrPrefixNameHits = 0;
+    let pathOverlap = 0;
+    let chunkTypeHits = 0;
+    for (const token of queryTokenList) {
+      if (nameTokens.has(token)) {
+        exactOrPrefixNameHits += 1;
+      } else {
+        for (const nameToken of nameTokens) {
+          if (nameToken.startsWith(token) || token.startsWith(nameToken)) {
+            exactOrPrefixNameHits += 1;
+            break;
+          }
+        }
+      }
+      if (pathTokens.has(token)) {
+        pathOverlap += 1;
+      }
+      if (chunkTypeTokens.has(token)) {
+        chunkTypeHits += 1;
+      }
+    }
+    const likelyTestOrDoc = isTestOrDocPath(candidate.metadata.filePath);
+    const lowerPath = candidate.metadata.filePath.toLowerCase();
+    const lowerName = (candidate.metadata.name ?? "").toLowerCase();
+    const hasIdentifierMatch = identifierHints.some((id) => lowerPath.includes(id) || lowerName.includes(id));
+    const implementationPathBoost = preferSourcePaths && isLikelyImplementationPath(candidate.metadata.filePath) ? 0.08 : 0;
+    const isReadmePath = candidate.metadata.filePath.toLowerCase().includes("readme");
+    const testDocPenalty = preferSourcePaths && likelyTestOrDoc ? 0.12 : 0;
+    const readmeDocBoost = !preferSourcePaths && isReadmePath ? 0.08 : 0;
+    const identifierBoost = hasIdentifierMatch ? 0.12 : 0;
+    const tokenCoverage = queryTokenList.length > 0 ? (exactOrPrefixNameHits + pathOverlap + chunkTypeHits) / queryTokenList.length : 0;
+    const coverageBoost = Math.min(0.12, tokenCoverage * 0.06);
+    const deterministicBoost = exactOrPrefixNameHits * 0.08 + pathOverlap * 0.03 + chunkTypeHits * 0.02 + coverageBoost + identifierBoost + implementationPathBoost - testDocPenalty + readmeDocBoost + chunkTypeBoost(candidate.metadata.chunkType);
+    return {
+      candidate,
+      boostedScore: candidate.score + deterministicBoost,
+      originalIndex: idx,
+      hasIdentifierMatch,
+      implementationChunk: isImplementationChunkType(candidate.metadata.chunkType),
+      isLikelyImplementationPath: isLikelyImplementationPath(candidate.metadata.filePath),
+      isTestOrDocPath: likelyTestOrDoc,
+      isReadmePath
+    };
+  });
+  head.sort((a, b) => {
+    if (b.boostedScore !== a.boostedScore) return b.boostedScore - a.boostedScore;
+    if (b.candidate.score !== a.candidate.score) return b.candidate.score - a.candidate.score;
+    if (a.originalIndex !== b.originalIndex) return a.originalIndex - b.originalIndex;
+    return a.candidate.id.localeCompare(b.candidate.id);
+  });
+  if (preferSourcePaths) {
+    head.sort((a, b) => {
+      const aId = a.hasIdentifierMatch ? 1 : 0;
+      const bId = b.hasIdentifierMatch ? 1 : 0;
+      if (aId !== bId) return bId - aId;
+      const aImpl = a.implementationChunk ? 1 : 0;
+      const bImpl = b.implementationChunk ? 1 : 0;
+      if (aImpl !== bImpl) return bImpl - aImpl;
+      const aImplementationPath = a.isLikelyImplementationPath ? 1 : 0;
+      const bImplementationPath = b.isLikelyImplementationPath ? 1 : 0;
+      if (aImplementationPath !== bImplementationPath) return bImplementationPath - aImplementationPath;
+      const aTestDoc = a.isTestOrDocPath ? 1 : 0;
+      const bTestDoc = b.isTestOrDocPath ? 1 : 0;
+      if (aTestDoc !== bTestDoc) return aTestDoc - bTestDoc;
+      return 0;
+    });
+  } else if (docIntent === "docs") {
+    head.sort((a, b) => {
+      const aReadme = a.isReadmePath ? 1 : 0;
+      const bReadme = b.isReadmePath ? 1 : 0;
+      if (aReadme !== bReadme) return bReadme - aReadme;
+      return 0;
+    });
+  }
+  const tail = candidates.slice(topN);
+  return [...head.map((entry) => entry.candidate), ...tail];
+}
+function rankHybridResults(query, semanticResults, keywordResults, options) {
+  const overfetchLimit = Math.max(options.limit * 4, options.limit);
+  const fused = options.fusionStrategy === "rrf" ? fuseResultsRrf(semanticResults, keywordResults, options.rrfK, overfetchLimit) : fuseResultsWeighted(semanticResults, keywordResults, options.hybridWeight, overfetchLimit);
+  const rerankPoolLimit = Math.max(overfetchLimit, options.rerankTopN * 3, options.limit * 6);
+  const rerankPool = fused.slice(0, rerankPoolLimit);
+  const intent = classifyQueryIntentRaw(query);
+  return rerankResults(query, rerankPool, options.rerankTopN, {
+    prioritizeSourcePaths: intent === "source"
+  });
+}
+function rankSemanticOnlyResults(query, semanticResults, options) {
+  const overfetchLimit = Math.max(options.limit * 4, options.limit);
+  const bounded = semanticResults.slice(0, overfetchLimit);
+  return rerankResults(query, bounded, options.rerankTopN, {
+    prioritizeSourcePaths: options.prioritizeSourcePaths ?? false
+  });
+}
+function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCandidates, database, branchChunkIds) {
+  if (combined.length === 0) {
+    return combined;
+  }
+  if (classifyQueryIntentRaw(query) !== "source") {
+    return combined;
+  }
+  const identifierHints = extractIdentifierHints(query);
+  if (identifierHints.length === 0) {
+    return combined;
+  }
+  const combinedById = new Map(combined.map((candidate) => [candidate.id, candidate]));
+  const candidateUnion = /* @__PURE__ */ new Map();
+  for (const candidate of semanticCandidates) {
+    candidateUnion.set(candidate.id, candidate);
+  }
+  for (const candidate of keywordCandidates) {
+    if (!candidateUnion.has(candidate.id)) {
+      candidateUnion.set(candidate.id, candidate);
+    }
+  }
+  if (database) {
+    for (const identifier of identifierHints) {
+      const symbols = database.getSymbolsByName(identifier);
+      for (const symbol of symbols) {
+        const chunks = database.getChunksByFile(symbol.filePath);
+        for (const chunk of chunks) {
+          if (branchChunkIds && !branchChunkIds.has(chunk.chunkId)) {
+            continue;
+          }
+          const chunkType = chunk.nodeType ?? "other";
+          if (!isImplementationChunkType(chunkType)) {
+            continue;
+          }
+          if (!isLikelyImplementationPath(chunk.filePath)) {
+            continue;
+          }
+          if (chunk.startLine > symbol.startLine || chunk.endLine < symbol.endLine) {
+            continue;
+          }
+          const existing = combinedById.get(chunk.chunkId) ?? candidateUnion.get(chunk.chunkId);
+          const metadata = existing?.metadata ?? {
+            filePath: chunk.filePath,
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            chunkType,
+            name: chunk.name ?? void 0,
+            language: chunk.language,
+            hash: chunk.contentHash
+          };
+          const baselineScore = existing?.score ?? 0.5;
+          candidateUnion.set(chunk.chunkId, {
+            id: chunk.chunkId,
+            score: Math.min(1, baselineScore + 0.5),
+            metadata
+          });
+        }
+      }
+    }
+  }
+  const promoted = [];
+  for (const candidate of candidateUnion.values()) {
+    const filePathLower = candidate.metadata.filePath.toLowerCase();
+    const nameLower = (candidate.metadata.name ?? "").toLowerCase();
+    const exactIdentifierMatch = identifierHints.some((hint) => nameLower === hint);
+    const hasIdentifierMatch = exactIdentifierMatch || identifierHints.some(
+      (hint) => nameLower.includes(hint) || filePathLower.includes(hint)
+    );
+    if (!hasIdentifierMatch) {
+      continue;
+    }
+    if (!isImplementationChunkType(candidate.metadata.chunkType)) {
+      continue;
+    }
+    if (!isLikelyImplementationPath(candidate.metadata.filePath)) {
+      continue;
+    }
+    const existing = combinedById.get(candidate.id) ?? candidate;
+    const rescueBoost = exactIdentifierMatch ? 0.45 : 0.25;
+    const boostedScore = Math.min(1, Math.max(existing.score, candidate.score) + rescueBoost);
+    promoted.push({
+      id: existing.id,
+      score: boostedScore,
+      metadata: existing.metadata
+    });
+  }
+  if (promoted.length === 0) {
+    return combined;
+  }
+  promoted.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  const promotedIds = new Set(promoted.map((candidate) => candidate.id));
+  const remainder = combined.filter((candidate) => !promotedIds.has(candidate.id));
+  return [...promoted, ...remainder];
+}
+function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallbackCandidates) {
+  if (classifyQueryIntentRaw(query) !== "source") {
+    return [];
+  }
+  const identifierHints = extractIdentifierHints(query);
+  const codeTermHints = extractCodeTermHints(query);
+  if (identifierHints.length === 0 && codeTermHints.length === 0) {
+    return [];
+  }
+  const symbolCandidates = /* @__PURE__ */ new Map();
+  const filePathHint = extractFilePathHint(query);
+  const primaryHint = extractPrimaryIdentifierQueryHint(query);
+  const upsertChunkCandidate = (chunk, identifier, normalizedIdentifier, baseScore) => {
+    if (branchChunkIds && !branchChunkIds.has(chunk.chunkId)) {
+      return;
+    }
+    const chunkType = chunk.nodeType ?? "other";
+    if (!isImplementationChunkType(chunkType)) {
+      return;
+    }
+    if (!isLikelyImplementationPath(chunk.filePath)) {
+      return;
+    }
+    const nameLower = (chunk.name ?? "").toLowerCase();
+    const exactName = nameLower === identifier || nameLower.replace(/_/g, "") === normalizedIdentifier;
+    const base = baseScore ?? (exactName ? 0.99 : 0.88);
+    const existing = symbolCandidates.get(chunk.chunkId);
+    if (!existing || base > existing.score) {
+      symbolCandidates.set(chunk.chunkId, {
+        id: chunk.chunkId,
+        score: base,
+        metadata: {
+          filePath: chunk.filePath,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          chunkType,
+          name: chunk.name ?? void 0,
+          language: chunk.language,
+          hash: chunk.contentHash
+        }
+      });
+    }
+  };
+  const normalizedHints = identifierHints.flatMap((hint) => [
+    hint,
+    hint.replace(/_/g, ""),
+    hint.replace(/_/g, "-")
+  ]).filter((hint, idx, arr) => hint.length >= 3 && arr.indexOf(hint) === idx).slice(0, 6);
+  for (const identifier of normalizedHints) {
+    const symbols = [
+      ...database.getSymbolsByName(identifier),
+      ...database.getSymbolsByNameCi(identifier)
+    ];
+    const chunksByName = [
+      ...database.getChunksByName(identifier),
+      ...database.getChunksByNameCi(identifier)
+    ];
+    const normalizedIdentifier = identifier.replace(/_/g, "");
+    const dedupSymbols = /* @__PURE__ */ new Map();
+    for (const symbol of symbols) {
+      dedupSymbols.set(symbol.id, symbol);
+    }
+    for (const symbol of dedupSymbols.values()) {
+      const chunks = database.getChunksByFile(symbol.filePath);
+      for (const chunk of chunks) {
+        if (chunk.startLine > symbol.startLine || chunk.endLine < symbol.endLine) {
+          continue;
+        }
+        upsertChunkCandidate(chunk, identifier, normalizedIdentifier);
+      }
+    }
+    const dedupChunksByName = /* @__PURE__ */ new Map();
+    for (const chunk of chunksByName) {
+      dedupChunksByName.set(chunk.chunkId, chunk);
+    }
+    for (const chunk of dedupChunksByName.values()) {
+      upsertChunkCandidate(chunk, identifier, normalizedIdentifier);
+    }
+  }
+  if (filePathHint && primaryHint) {
+    const primaryChunks = [
+      ...database.getChunksByName(primaryHint),
+      ...database.getChunksByNameCi(primaryHint)
+    ];
+    const dedupPrimaryChunks = /* @__PURE__ */ new Map();
+    for (const chunk of primaryChunks) {
+      dedupPrimaryChunks.set(chunk.chunkId, chunk);
+    }
+    for (const chunk of dedupPrimaryChunks.values()) {
+      if (!pathMatchesHint(chunk.filePath, filePathHint)) {
+        continue;
+      }
+      const normalizedPrimary = primaryHint.replace(/_/g, "");
+      upsertChunkCandidate(chunk, primaryHint, normalizedPrimary, 1);
+    }
+  }
+  const ranked = Array.from(symbolCandidates.values()).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  if (ranked.length === 0) {
+    const implementationFallback = fallbackCandidates.filter(
+      (candidate) => isImplementationChunkType(candidate.metadata.chunkType) && isLikelyImplementationPath(candidate.metadata.filePath)
+    );
+    for (const candidate of implementationFallback) {
+      const nameLower = (candidate.metadata.name ?? "").toLowerCase();
+      const pathLower = candidate.metadata.filePath.toLowerCase();
+      const exactHintMatch = normalizedHints.some((hint) => nameLower === hint || nameLower.replace(/_/g, "") === hint.replace(/_/g, ""));
+      const tokenizedName = tokenizeTextForRanking(nameLower);
+      const tokenHits = codeTermHints.filter((term) => tokenizedName.has(term) || pathLower.includes(term)).length;
+      if (!exactHintMatch && tokenHits === 0) {
+        continue;
+      }
+      const laneScore = exactHintMatch ? Math.min(1, Math.max(candidate.score, 0.97)) : Math.min(0.95, Math.max(candidate.score, 0.82 + tokenHits * 0.03));
+      symbolCandidates.set(candidate.id, {
+        id: candidate.id,
+        score: laneScore,
+        metadata: candidate.metadata
+      });
+    }
+    if (symbolCandidates.size === 0) {
+      const queryTokenSet = tokenizeTextForRanking(query);
+      const rankedFallback = implementationFallback.map((candidate) => {
+        const nameTokens = tokenizeTextForRanking(candidate.metadata.name ?? "");
+        const pathTokens = splitPathTokens(candidate.metadata.filePath);
+        let overlap = 0;
+        for (const token of queryTokenSet) {
+          if (nameTokens.has(token) || pathTokens.has(token)) {
+            overlap += 1;
+          }
+        }
+        const overlapScore = queryTokenSet.size > 0 ? overlap / queryTokenSet.size : 0;
+        return {
+          candidate,
+          overlapScore
+        };
+      }).filter((entry) => entry.overlapScore > 0).sort((a, b) => b.overlapScore - a.overlapScore || b.candidate.score - a.candidate.score).slice(0, Math.max(limit, 3));
+      for (const entry of rankedFallback) {
+        symbolCandidates.set(entry.candidate.id, {
+          id: entry.candidate.id,
+          score: Math.min(0.94, Math.max(entry.candidate.score, 0.8 + entry.overlapScore * 0.1)),
+          metadata: entry.candidate.metadata
+        });
+      }
+    }
+  }
+  const withFallback = Array.from(symbolCandidates.values()).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  return withFallback.slice(0, Math.max(limit * 2, limit));
+}
+function buildIdentifierDefinitionLane(query, candidates, limit) {
+  if (classifyQueryIntentRaw(query) !== "source") {
+    return [];
+  }
+  const primaryHint = extractPrimaryIdentifierQueryHint(query);
+  if (!primaryHint) {
+    return [];
+  }
+  const hints = [primaryHint, ...extractIdentifierHints(query), ...extractCodeTermHints(query)].slice(0, 8);
+  const scored = candidates.filter(
+    (candidate) => isLikelyImplementationPath(candidate.metadata.filePath) && isImplementationChunkType(candidate.metadata.chunkType)
+  ).map((candidate) => {
+    const matchScore = scoreIdentifierMatch(candidate.metadata.name, candidate.metadata.filePath, hints);
+    return {
+      candidate,
+      matchScore
+    };
+  }).filter((entry) => entry.matchScore > 0).sort((a, b) => {
+    if (b.matchScore !== a.matchScore) return b.matchScore - a.matchScore;
+    if (b.candidate.score !== a.candidate.score) return b.candidate.score - a.candidate.score;
+    return a.candidate.id.localeCompare(b.candidate.id);
+  }).slice(0, Math.max(limit * 2, 10));
+  return scored.map((entry) => ({
+    id: entry.candidate.id,
+    score: Math.min(1, 0.9 + entry.matchScore * 0.09),
+    metadata: entry.candidate.metadata
+  }));
+}
+function mergeTieredResults(symbolLane, hybridLane, limit) {
+  if (symbolLane.length === 0) {
+    return hybridLane.slice(0, limit);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of symbolLane) {
+    if (seen.has(candidate.id)) continue;
+    out.push(candidate);
+    seen.add(candidate.id);
+    if (out.length >= limit) return out;
+  }
+  for (const candidate of hybridLane) {
+    if (seen.has(candidate.id)) continue;
+    out.push(candidate);
+    seen.add(candidate.id);
+    if (out.length >= limit) return out;
+  }
+  return out;
+}
+function unionCandidates(semanticCandidates, keywordCandidates) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const candidate of semanticCandidates) {
+    byId.set(candidate.id, candidate);
+  }
+  for (const candidate of keywordCandidates) {
+    const existing = byId.get(candidate.id);
+    if (!existing || candidate.score > existing.score) {
+      byId.set(candidate.id, candidate);
+    }
+  }
+  return Array.from(byId.values());
+}
 var Indexer = class {
   config;
   projectRoot;
@@ -3936,6 +4930,79 @@ var Indexer = class {
     if (chunkDataBatch.length > 0) {
       database.upsertChunksBatch(chunkDataBatch);
     }
+    const allSymbolIds = /* @__PURE__ */ new Set();
+    const symbolsByFile = /* @__PURE__ */ new Map();
+    for (let i = 0; i < parsedFiles.length; i++) {
+      const parsed = parsedFiles[i];
+      const changedFile = changedFiles[i];
+      database.deleteCallEdgesByFile(parsed.path);
+      database.deleteSymbolsByFile(parsed.path);
+      const fileSymbols = [];
+      for (const chunk of parsed.chunks) {
+        if (!chunk.name || !CALL_GRAPH_SYMBOL_CHUNK_TYPES.has(chunk.chunkType)) continue;
+        const symbolId = `sym_${hashContent(parsed.path + ":" + chunk.name + ":" + chunk.chunkType + ":" + chunk.startLine).slice(0, 16)}`;
+        const symbol = {
+          id: symbolId,
+          filePath: parsed.path,
+          name: chunk.name,
+          kind: chunk.chunkType,
+          startLine: chunk.startLine,
+          startCol: 0,
+          endLine: chunk.endLine,
+          endCol: 0,
+          language: chunk.language
+        };
+        fileSymbols.push(symbol);
+        allSymbolIds.add(symbolId);
+      }
+      const symbolsByName = /* @__PURE__ */ new Map();
+      for (const symbol of fileSymbols) {
+        const existing = symbolsByName.get(symbol.name) ?? [];
+        existing.push(symbol);
+        symbolsByName.set(symbol.name, existing);
+      }
+      if (fileSymbols.length > 0) {
+        database.upsertSymbolsBatch(fileSymbols);
+        symbolsByFile.set(parsed.path, fileSymbols);
+      }
+      const fileLanguage = parsed.chunks[0]?.language;
+      if (!fileLanguage || !CALL_GRAPH_LANGUAGES.has(fileLanguage)) continue;
+      const callSites = extractCalls(changedFile.content, fileLanguage);
+      if (callSites.length === 0) continue;
+      const edges = [];
+      for (const site of callSites) {
+        const enclosingSymbol = fileSymbols.find(
+          (sym) => site.line >= sym.startLine && site.line <= sym.endLine
+        );
+        if (!enclosingSymbol) continue;
+        const edgeId = `edge_${hashContent(enclosingSymbol.id + ":" + site.calleeName + ":" + site.line + ":" + site.column).slice(0, 16)}`;
+        edges.push({
+          id: edgeId,
+          fromSymbolId: enclosingSymbol.id,
+          targetName: site.calleeName,
+          toSymbolId: void 0,
+          callType: site.callType,
+          line: site.line,
+          col: site.column,
+          isResolved: false
+        });
+      }
+      if (edges.length > 0) {
+        database.upsertCallEdgesBatch(edges);
+        for (const edge of edges) {
+          const candidates = symbolsByName.get(edge.targetName);
+          if (candidates && candidates.length === 1) {
+            database.resolveCallEdge(edge.id, candidates[0].id);
+          }
+        }
+      }
+    }
+    for (const filePath of unchangedFilePaths) {
+      const existingSymbols = database.getSymbolsByFile(filePath);
+      for (const sym of existingSymbols) {
+        allSymbolIds.add(sym.id);
+      }
+    }
     let removedCount = 0;
     for (const [chunkId] of existingChunks) {
       if (!currentChunkIds.has(chunkId)) {
@@ -3957,6 +5024,8 @@ var Indexer = class {
     if (pendingChunks.length === 0 && removedCount === 0) {
       database.clearBranch(this.currentBranch);
       database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+      database.clearBranchSymbols(this.currentBranch);
+      database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
       this.fileHashCache = currentFileHashes;
       this.saveFileHashCache();
       stats.durationMs = Date.now() - startTime;
@@ -3973,6 +5042,8 @@ var Indexer = class {
     if (pendingChunks.length === 0) {
       database.clearBranch(this.currentBranch);
       database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+      database.clearBranchSymbols(this.currentBranch);
+      database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
       store.save();
       invertedIndex.save();
       this.fileHashCache = currentFileHashes;
@@ -4113,6 +5184,8 @@ var Indexer = class {
     });
     database.clearBranch(this.currentBranch);
     database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+    database.clearBranchSymbols(this.currentBranch);
+    database.addSymbolsToBranchBatch(this.currentBranch, Array.from(allSymbolIds));
     store.save();
     invertedIndex.save();
     this.fileHashCache = currentFileHashes;
@@ -4223,15 +5296,22 @@ var Indexer = class {
     }
     const maxResults = limit ?? this.config.search.maxResults;
     const hybridWeight = options?.hybridWeight ?? this.config.search.hybridWeight;
+    const fusionStrategy = this.config.search.fusionStrategy;
+    const rrfK = this.config.search.rrfK;
+    const rerankTopN = this.config.search.rerankTopN;
     const filterByBranch = options?.filterByBranch ?? true;
     this.logger.search("debug", "Starting search", {
       query,
       maxResults,
       hybridWeight,
+      fusionStrategy,
+      rrfK,
+      rerankTopN,
       filterByBranch
     });
     const embeddingStartTime = performance2.now();
-    const embedding = await this.getQueryEmbedding(query, provider);
+    const embeddingQuery = stripFilePathHint(query);
+    const embedding = await this.getQueryEmbedding(embeddingQuery, provider);
     const embeddingMs = performance2.now() - embeddingStartTime;
     const vectorStartTime = performance2.now();
     const semanticResults = store.search(embedding, maxResults * 4);
@@ -4239,16 +5319,74 @@ var Indexer = class {
     const keywordStartTime = performance2.now();
     const keywordResults = await this.keywordSearch(query, maxResults * 4);
     const keywordMs = performance2.now() - keywordStartTime;
-    const fusionStartTime = performance2.now();
-    const combined = this.fuseResults(semanticResults, keywordResults, hybridWeight, maxResults * 4);
-    const fusionMs = performance2.now() - fusionStartTime;
     let branchChunkIds = null;
     if (filterByBranch && this.currentBranch !== "default") {
       branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
     }
-    const filtered = combined.filter((r) => {
+    const prefilterStartTime = performance2.now();
+    const shouldPrefilterByBranch = branchChunkIds !== null && branchChunkIds.size > 0;
+    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 = shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
+    const keywordCandidates = shouldPrefilterByBranch && keywordResults.length > 0 && prefilteredKeyword.length === 0 ? keywordResults : prefilteredKeyword;
+    const prefilterMs = performance2.now() - prefilterStartTime;
+    if (branchChunkIds && branchChunkIds.size === 0) {
+      this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
+        branch: this.currentBranch
+      });
+    }
+    if (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 (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 = performance2.now();
+    const combined = rankHybridResults(query, semanticCandidates, keywordCandidates, {
+      fusionStrategy,
+      rrfK,
+      rerankTopN,
+      limit: maxResults,
+      hybridWeight
+    });
+    const fusionMs = performance2.now() - fusionStartTime;
+    const rescued = promoteIdentifierMatches(
+      query,
+      combined,
+      semanticCandidates,
+      keywordCandidates,
+      database,
+      branchChunkIds
+    );
+    const union = unionCandidates(semanticCandidates, keywordCandidates);
+    const deterministicIdentifierLane = buildDeterministicIdentifierPass(
+      query,
+      union,
+      maxResults
+    );
+    const identifierLane = buildIdentifierDefinitionLane(
+      query,
+      union,
+      maxResults
+    );
+    const symbolLane = buildSymbolDefinitionLane(
+      query,
+      database,
+      branchChunkIds,
+      maxResults,
+      union
+    );
+    const prePrimaryLane = mergeTieredResults(deterministicIdentifierLane, identifierLane, maxResults * 4);
+    const primaryLane = mergeTieredResults(prePrimaryLane, symbolLane, maxResults * 4);
+    const tiered = mergeTieredResults(primaryLane, rescued, maxResults * 4);
+    const sourceIntent = classifyQueryIntentRaw(query) === "source";
+    const hasCodeHints = extractCodeTermHints(query).length > 0 || extractIdentifierHints(query).length > 0;
+    const baseFiltered = tiered.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
-      if (branchChunkIds && !branchChunkIds.has(r.id)) return false;
       if (options?.fileType) {
         const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
         if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
@@ -4261,7 +5399,11 @@ var Indexer = class {
         if (r.metadata.chunkType !== options.chunkType) return false;
       }
       return true;
-    }).slice(0, maxResults);
+    });
+    const implementationOnly = baseFiltered.filter(
+      (r) => isLikelyImplementationPath(r.metadata.filePath) && isImplementationChunkType(r.metadata.chunkType)
+    );
+    const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : baseFiltered).slice(0, maxResults);
     const totalSearchMs = performance2.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
       embeddingMs,
@@ -4276,6 +5418,7 @@ var Indexer = class {
       embeddingMs: Math.round(embeddingMs * 100) / 100,
       vectorMs: Math.round(vectorMs * 100) / 100,
       keywordMs: Math.round(keywordMs * 100) / 100,
+      prefilterMs: Math.round(prefilterMs * 100) / 100,
       fusionMs: Math.round(fusionMs * 100) / 100
     });
     const metadataOnly = options?.metadataOnly ?? false;
@@ -4329,34 +5472,6 @@ var Indexer = class {
     results.sort((a, b) => b.score - a.score);
     return results.slice(0, limit);
   }
-  fuseResults(semanticResults, keywordResults, keywordWeight, limit) {
-    const semanticWeight = 1 - keywordWeight;
-    const fusedScores = /* @__PURE__ */ new Map();
-    for (const r of semanticResults) {
-      fusedScores.set(r.id, {
-        score: r.score * semanticWeight,
-        metadata: r.metadata
-      });
-    }
-    for (const r of keywordResults) {
-      const existing = fusedScores.get(r.id);
-      if (existing) {
-        existing.score += r.score * keywordWeight;
-      } else {
-        fusedScores.set(r.id, {
-          score: r.score * keywordWeight,
-          metadata: r.metadata
-        });
-      }
-    }
-    const results = Array.from(fusedScores.entries()).map(([id, data]) => ({
-      id,
-      score: data.score,
-      metadata: data.metadata
-    }));
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
-  }
   async getStatus() {
     const { store, configuredProviderInfo } = await this.ensureInitialized();
     return {
@@ -4379,6 +5494,7 @@ var Indexer = class {
     this.fileHashCache.clear();
     this.saveFileHashCache();
     database.clearBranch(this.currentBranch);
+    database.clearBranchSymbols(this.currentBranch);
     database.deleteMetadata("index.version");
     database.deleteMetadata("index.embeddingProvider");
     database.deleteMetadata("index.embeddingModel");
@@ -4407,6 +5523,8 @@ var Indexer = class {
           removedCount++;
         }
         database.deleteChunksByFile(filePath);
+        database.deleteCallEdgesByFile(filePath);
+        database.deleteSymbolsByFile(filePath);
         removedFilePaths.push(filePath);
       }
     }
@@ -4416,6 +5534,8 @@ var Indexer = class {
     }
     const gcOrphanEmbeddings = database.gcOrphanEmbeddings();
     const gcOrphanChunks = database.gcOrphanChunks();
+    const gcOrphanSymbols = database.gcOrphanSymbols();
+    const gcOrphanCallEdges = database.gcOrphanCallEdges();
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
     this.logger.gc("info", "Health check complete", {
       removedStale: removedCount,
@@ -4423,7 +5543,7 @@ var Indexer = class {
       orphanChunks: gcOrphanChunks,
       removedFiles: removedFilePaths.length
     });
-    return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks };
+    return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks, gcOrphanSymbols, gcOrphanCallEdges };
   }
   async retryFailedBatches() {
     const { store, provider, invertedIndex } = await this.ensureInitialized();
@@ -4529,9 +5649,29 @@ var Indexer = class {
     if (filterByBranch && this.currentBranch !== "default") {
       branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
     }
-    const filtered = semanticResults.filter((r) => {
+    const prefilterStartTime = performance2.now();
+    const shouldPrefilterByBranch = branchChunkIds !== null && branchChunkIds.size > 0;
+    const prefilteredSemantic = shouldPrefilterByBranch && branchChunkIds ? semanticResults.filter((r) => branchChunkIds.has(r.id)) : semanticResults;
+    const semanticCandidates = shouldPrefilterByBranch && semanticResults.length > 0 && prefilteredSemantic.length === 0 ? semanticResults : prefilteredSemantic;
+    const prefilterMs = performance2.now() - prefilterStartTime;
+    if (branchChunkIds && branchChunkIds.size === 0) {
+      this.logger.search("warn", "Branch prefilter skipped because branch catalog is empty", {
+        branch: this.currentBranch
+      });
+    }
+    if (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,
+      limit,
+      prioritizeSourcePaths: false
+    });
+    const filtered = ranked.filter((r) => {
       if (r.score < this.config.search.minScore) return false;
-      if (branchChunkIds && !branchChunkIds.has(r.id)) return false;
       if (options?.excludeFile) {
         if (r.metadata.filePath === options.excludeFile) return false;
       }
@@ -4560,7 +5700,8 @@ var Indexer = class {
       results: filtered.length,
       totalMs: Math.round(totalSearchMs * 100) / 100,
       embeddingMs: Math.round(embeddingMs * 100) / 100,
-      vectorMs: Math.round(vectorMs * 100) / 100
+      vectorMs: Math.round(vectorMs * 100) / 100,
+      prefilterMs: Math.round(prefilterMs * 100) / 100
     });
     return Promise.all(
       filtered.map(async (r) => {
@@ -4589,6 +5730,14 @@ var Indexer = class {
       })
     );
   }
+  async getCallers(targetName) {
+    const { database } = await this.ensureInitialized();
+    return database.getCallersWithContext(targetName, this.currentBranch);
+  }
+  async getCallees(symbolId) {
+    const { database } = await this.ensureInitialized();
+    return database.getCallees(symbolId, this.currentBranch);
+  }
 };
 
 // src/mcp-server.ts
@@ -4791,7 +5940,7 @@ Use Read tool to examine specific files.` }] };
     async () => {
       await ensureInitialized();
       const result = await indexer.healthCheck();
-      if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0) {
+      if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0 && result.gcOrphanSymbols === 0 && result.gcOrphanCallEdges === 0) {
         return { content: [{ type: "text", text: "Index is healthy. No stale entries found." }] };
       }
       const lines = [`Health check complete:`];
@@ -4804,6 +5953,12 @@ Use Read tool to examine specific files.` }] };
       if (result.gcOrphanChunks > 0) {
         lines.push(`  Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
       }
+      if (result.gcOrphanSymbols > 0) {
+        lines.push(`  Garbage collected orphan symbols: ${result.gcOrphanSymbols}`);
+      }
+      if (result.gcOrphanCallEdges > 0) {
+        lines.push(`  Garbage collected orphan call edges: ${result.gcOrphanCallEdges}`);
+      }
       if (result.filePaths.length > 0) {
         lines.push(`  Cleaned paths: ${result.filePaths.join(", ")}`);
       }
@@ -4892,6 +6047,43 @@ ${truncateContent(r.content)}
 ${formatted.join("\n\n")}` }] };
     }
   );
+  server.tool(
+    "call_graph",
+    "Query the call graph to find callers or callees of a function/method. Use to understand code flow and dependencies.",
+    {
+      name: z.string().describe("Function or method name to query"),
+      direction: z.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
+      symbolId: z.string().optional().describe("Symbol ID (required for 'callees' direction)")
+    },
+    async (args) => {
+      await ensureInitialized();
+      if (args.direction === "callees") {
+        if (!args.symbolId) {
+          return { content: [{ type: "text", text: "Error: 'symbolId' is required when direction is 'callees'." }] };
+        }
+        const callees = await indexer.getCallees(args.symbolId);
+        if (callees.length === 0) {
+          return { content: [{ type: "text", text: `No callees found for symbol ${args.symbolId}.` }] };
+        }
+        const formatted2 = callees.map(
+          (e, i) => `[${i + 1}] \u2192 ${e.targetName} (${e.callType}) at line ${e.line}${e.isResolved ? ` [resolved: ${e.toSymbolId}]` : " [unresolved]"}`
+        );
+        return { content: [{ type: "text", text: `Callees (${callees.length}):
+
+${formatted2.join("\n")}` }] };
+      }
+      const callers = await indexer.getCallers(args.name);
+      if (callers.length === 0) {
+        return { content: [{ type: "text", text: `No callers found for "${args.name}".` }] };
+      }
+      const formatted = callers.map(
+        (e, i) => `[${i + 1}] \u2190 from ${e.fromSymbolName ?? "<unknown>"} in ${e.fromSymbolFilePath ?? "<unknown file>"} [${e.fromSymbolId}] (${e.callType}) at line ${e.line}${e.isResolved ? " [resolved]" : " [unresolved]"}`
+      );
+      return { content: [{ type: "text", text: `"${args.name}" is called by ${callers.length} function(s):
+
+${formatted.join("\n")}` }] };
+    }
+  );
   server.prompt(
     "search",
     "Search codebase by meaning using semantic search",