scip-query 0.3.5 → 0.4.1

package/dist/cli.js

@@ -3,8 +3,8 @@
 // src/cli.ts
 import { program } from "commander";
 import { createRequire } from "module";
-import { existsSync as existsSync8, realpathSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, realpathSync } from "fs";
+import { join as join12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/db.ts
@@ -42,12 +42,23 @@ var ScipDatabase = class {
    * that need SQL-level filtering, use excludedPathPatterns().
    */
   get localSymbolPredicate() {
-    return `EXISTS (
-      SELECT 1
-      FROM defn_enclosing_ranges local_der
-      JOIN documents local_d ON local_der.document_id = local_d.id
-      WHERE local_der.symbol_id = gs.id
-        ${this.pathExclusionsFor("local_d").trimStart()}
+    return `(
+      EXISTS (
+        SELECT 1
+        FROM defn_enclosing_ranges local_der
+        JOIN documents local_d ON local_der.document_id = local_d.id
+        WHERE local_der.symbol_id = gs.id
+          ${this.pathExclusionsFor("local_d").trimStart()}
+      )
+      OR EXISTS (
+        SELECT 1
+        FROM mentions local_m
+        JOIN chunks local_c ON local_m.chunk_id = local_c.id
+        JOIN documents local_d ON local_c.document_id = local_d.id
+        WHERE local_m.symbol_id = gs.id
+          AND local_m.role = 1
+          ${this.pathExclusionsFor("local_d").trimStart()}
+      )
     )`;
   }
   /**
@@ -275,8 +286,8 @@ function ensureDir(dir) {
 
 // src/reindex/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync6, renameSync } from "fs";
+import { join as join6 } from "path";
 
 // src/scip-cli.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -284,7 +295,9 @@ import { platform as platform2, arch } from "os";
 
 // src/reindex/install.ts
 import { execFileSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
 import { platform } from "os";
+import { join as join3 } from "path";
 var IS_WINDOWS = platform() === "win32";
 function isBinaryAvailable(name) {
   const cmd = IS_WINDOWS ? "where" : "which";
@@ -313,6 +326,67 @@ function resolveIndexerBinary(config) {
 function isIndexerInstalled(config) {
   return resolveIndexerBinary(config) !== null;
 }
+function resolveProjectLocalIndexerBinary(config, projectRoot) {
+  for (const relativePath of config.projectLocalBinaries ?? []) {
+    const candidate = join3(projectRoot, relativePath);
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveIndexerBinaryForProject(config, projectRoot) {
+  return resolveProjectLocalIndexerBinary(config, projectRoot) ?? resolveIndexerBinary(config);
+}
+function getIndexerExecutionEnv(config, baseEnv = process.env, binary = config.indexerBinary) {
+  if (config.indexerBinary !== "scip-dotnet") {
+    return baseEnv;
+  }
+  if (canRunDotnetIndexer(binary, baseEnv)) {
+    return baseEnv;
+  }
+  const dotnetRoot = resolveWorkingDotnetRoot(binary, baseEnv);
+  if (!dotnetRoot) {
+    return baseEnv;
+  }
+  return {
+    ...baseEnv,
+    DOTNET_ROOT: dotnetRoot
+  };
+}
+function getIndexerDependencyStatus(config, projectRoot) {
+  const binaryLabel = describeIndexerBinary(config);
+  const resolvedBinary = projectRoot ? resolveIndexerBinaryForProject(config, projectRoot) : resolveIndexerBinary(config);
+  if (!resolvedBinary) {
+    return {
+      language: config.language,
+      binaryLabel,
+      installed: false,
+      runnable: false,
+      resolvedBinary: null,
+      installUrl: config.installUrl
+    };
+  }
+  if (config.indexerBinary !== "scip-dotnet") {
+    return {
+      language: config.language,
+      binaryLabel,
+      installed: true,
+      runnable: true,
+      resolvedBinary
+    };
+  }
+  const runtimeProbe = probeDotnetRuntime(resolvedBinary);
+  return {
+    language: config.language,
+    binaryLabel,
+    installed: true,
+    runnable: runtimeProbe.runnable,
+    resolvedBinary,
+    installUrl: config.installUrl,
+    note: runtimeProbe.note
+  };
+}
 function tryInstallIndexer(config, onStatus) {
   const methods2 = config.installMethods;
   const binaryLabel = describeIndexerBinary(config);
@@ -352,6 +426,64 @@ function tryInstallIndexer(config, onStatus) {
   }
   return false;
 }
+function probeDotnetRuntime(binary) {
+  if (canRunDotnetIndexer(binary, process.env)) {
+    return { runnable: true };
+  }
+  const dotnetRoot = resolveWorkingDotnetRoot(binary, process.env);
+  if (dotnetRoot) {
+    return {
+      runnable: true,
+      note: `using .NET 9 runtime from ${dotnetRoot}`
+    };
+  }
+  const attemptedRoots = getDotnetRootCandidates(process.env);
+  const attemptedNote = attemptedRoots.length > 0 ? `.NET 9 runtime still unavailable after checking ${attemptedRoots.join(", ")}` : "binary is present, but scip-dotnet still needs a .NET 9 runtime";
+  return {
+    runnable: false,
+    note: attemptedNote
+  };
+}
+function resolveWorkingDotnetRoot(binary, env) {
+  for (const dotnetRoot of getDotnetRootCandidates(env)) {
+    if (canRunDotnetIndexer(binary, { ...env, DOTNET_ROOT: dotnetRoot })) {
+      return dotnetRoot;
+    }
+  }
+  return null;
+}
+function getDotnetRootCandidates(env) {
+  const candidates = [];
+  const configured = env["DOTNET_ROOT"];
+  if (configured && existsSync3(configured)) {
+    candidates.push(configured);
+  }
+  if (platform() === "darwin" && isBinaryAvailable("brew")) {
+    try {
+      const prefix = execFileSync("brew", ["--prefix", "dotnet@9"], {
+        stdio: "pipe",
+        env
+      }).toString().trim();
+      const candidate = join3(prefix, "libexec");
+      if (existsSync3(candidate) && !candidates.includes(candidate)) {
+        candidates.push(candidate);
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+function canRunDotnetIndexer(binary, env) {
+  try {
+    execFileSync(binary, ["--version"], {
+      stdio: "pipe",
+      env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/scip-cli.ts
 var IS_WINDOWS2 = platform2() === "win32";
@@ -461,46 +593,151 @@ function tryInstallScipCli(onStatus) {
 }
 
 // src/reindex/detect.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readdirSync } from "fs";
+import { extname, join as join4 } from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".idea",
+  ".vscode",
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  "target",
+  "bin",
+  "obj",
+  ".dart_tool",
+  ".gradle",
+  ".next",
+  ".venv",
+  "venv",
+  "__pycache__"
+]);
 var LANGUAGE_MARKERS = [
-  { language: "typescript", files: ["tsconfig.json", "tsconfig.base.json"] },
-  { language: "rust", files: ["Cargo.toml"] },
-  { language: "go", files: ["go.mod"] },
-  { language: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts"] },
-  { language: "kotlin", files: ["build.gradle.kts"] },
-  { language: "scala", files: ["build.sbt"] },
-  { language: "python", files: ["pyproject.toml", "setup.py", "setup.cfg", "Pipfile"] },
-  { language: "ruby", files: ["Gemfile"] },
-  { language: "csharp", files: ["*.csproj", "*.sln"] },
-  { language: "dart", files: ["pubspec.yaml"] },
-  { language: "php", files: ["composer.json"] },
-  { language: "javascript", files: ["package.json"] }
-  // Last — very common, low specificity
+  { language: "typescript", files: ["tsconfig.json", "tsconfig.base.json"], extensions: [".ts", ".tsx", ".mts", ".cts"] },
+  { language: "rust", files: ["Cargo.toml"], extensions: [".rs"] },
+  { language: "go", files: ["go.mod"], extensions: [".go"] },
+  { language: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts"], extensions: [".java"] },
+  { language: "kotlin", files: ["build.gradle.kts"], extensions: [".kt", ".kts"] },
+  { language: "scala", files: ["build.sbt"], extensions: [".scala"] },
+  { language: "python", files: ["pyproject.toml", "setup.py", "setup.cfg", "Pipfile"], extensions: [".py", ".pyi"] },
+  { language: "ruby", files: ["Gemfile"], extensions: [".rb"] },
+  { language: "cpp", files: ["compile_commands.json", "CMakeLists.txt", "Makefile"], extensions: [".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"] },
+  { language: "c", files: ["compile_commands.json", "CMakeLists.txt", "Makefile"], extensions: [".c", ".h"] },
+  { language: "csharp", globs: ["*.csproj", "*.sln"], extensions: [".cs"] },
+  { language: "vb", globs: ["*.vbproj"], extensions: [".vb"] },
+  { language: "dart", files: ["pubspec.yaml"], extensions: [".dart"] },
+  { language: "php", files: ["composer.json"], extensions: [".php"] },
+  { language: "javascript", files: ["package.json"], extensions: [".js", ".jsx", ".mjs", ".cjs"] }
+  // Last — very common
 ];
 function detectLanguages(projectRoot) {
   const detected = [];
+  const rootEntries = safeReadDir(projectRoot);
+  const extensionSet = collectExtensions(projectRoot);
   for (const marker of LANGUAGE_MARKERS) {
-    for (const file of marker.files) {
-      if (file.includes("*")) {
-        continue;
+    if (hasMarkerFile(projectRoot, marker.files)) {
+      detected.push(marker.language);
+      continue;
+    }
+    if (matchesRootGlob(rootEntries, marker.globs)) {
+      detected.push(marker.language);
+      continue;
+    }
+    if (hasExtension(extensionSet, marker.extensions)) {
+      detected.push(marker.language);
+    }
+  }
+  if (detected.includes("typescript")) {
+    removeLanguage(detected, "javascript");
+  }
+  if (detected.includes("cpp") && !extensionSet.has(".c")) {
+    removeLanguage(detected, "c");
+  }
+  return detected;
+}
+function safeReadDir(projectRoot) {
+  try {
+    return readdirSync(projectRoot);
+  } catch {
+    return [];
+  }
+}
+function hasMarkerFile(projectRoot, files2) {
+  if (!files2?.length) {
+    return false;
+  }
+  return files2.some((file) => existsSync4(join4(projectRoot, file)));
+}
+function matchesRootGlob(entries, globs) {
+  if (!globs?.length) {
+    return false;
+  }
+  return entries.some((entry) => globs.some((glob) => matchesSimpleGlob(entry, glob)));
+}
+function matchesSimpleGlob(entry, pattern) {
+  if (pattern === "*") {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return entry === pattern;
+  }
+  const [prefix, suffix] = pattern.split("*");
+  return entry.startsWith(prefix ?? "") && entry.endsWith(suffix ?? "");
+}
+function collectExtensions(projectRoot) {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [projectRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && !entry.name.endsWith("proj") && !entry.name.endsWith("sln")) {
+        if (entry.isDirectory()) {
+          continue;
+        }
       }
-      if (existsSync3(join3(projectRoot, file))) {
-        if (!detected.includes(marker.language)) {
-          detected.push(marker.language);
+      const fullPath = join4(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRS.has(entry.name)) {
+          stack.push(fullPath);
         }
-        break;
+        continue;
+      }
+      const extension = extname(entry.name).toLowerCase();
+      if (extension) {
+        found.add(extension);
       }
     }
   }
-  if (detected.includes("typescript")) {
-    const jsIdx = detected.indexOf("javascript");
-    if (jsIdx !== -1) detected.splice(jsIdx, 1);
+  return found;
+}
+function hasExtension(extensionSet, extensions) {
+  if (!extensions?.length) {
+    return false;
+  }
+  return extensions.some((extension) => extensionSet.has(extension));
+}
+function removeLanguage(detected, language) {
+  const index = detected.indexOf(language);
+  if (index !== -1) {
+    detected.splice(index, 1);
   }
-  return detected;
 }
 
 // src/reindex/indexers.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
 var INDEXER_CONFIGS = {
   typescript: {
     language: "typescript",
@@ -540,9 +777,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["pom.xml", "build.gradle"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   scala: {
@@ -554,9 +789,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["build.sbt"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   kotlin: {
@@ -568,9 +801,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["build.gradle.kts"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   rust: {
@@ -606,10 +837,11 @@ var INDEXER_CONFIGS = {
     language: "ruby",
     indexerBinary: "scip-ruby",
     checkCommand: "scip-ruby --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-ruby",
-      args: ["--output", outputPath]
+    indexArgs: ({ indexerBinary }) => ({
+      binary: indexerBinary,
+      args: ["--dir", "."]
     }),
+    defaultOutputPath: "index.scip",
     markerFiles: ["Gemfile"],
     installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-ruby/releases"
@@ -634,7 +866,7 @@ var INDEXER_CONFIGS = {
     checkCommand: "scip-clang --version",
     indexArgs: ({ outputPath }) => ({
       binary: "scip-clang",
-      args: ["--output", outputPath]
+      args: ["--compdb-path", "compile_commands.json", "--index-output-path", outputPath]
     }),
     markerFiles: ["CMakeLists.txt", "Makefile"],
     installMethods: [],
@@ -646,7 +878,7 @@ var INDEXER_CONFIGS = {
     checkCommand: "scip-clang --version",
     indexArgs: ({ outputPath }) => ({
       binary: "scip-clang",
-      args: ["--output", outputPath]
+      args: ["--compdb-path", "compile_commands.json", "--index-output-path", outputPath]
     }),
     markerFiles: ["CMakeLists.txt", "Makefile"],
     installMethods: [],
@@ -656,11 +888,25 @@ var INDEXER_CONFIGS = {
     language: "csharp",
     indexerBinary: "scip-dotnet",
     checkCommand: "scip-dotnet --version",
-    indexArgs: ({ outputPath }) => ({
+    indexArgs: ({ projectRoot, outputPath }) => ({
       binary: "scip-dotnet",
-      args: ["index", "--output", outputPath]
+      args: ["index", resolveDotnetProject(projectRoot, [".sln", ".csproj"]) ?? projectRoot, "--output", outputPath, "--working-directory", projectRoot]
+    }),
+    markerFiles: ["*.csproj", "*.sln"],
+    installMethods: [
+      { label: "dotnet", prerequisite: "dotnet", binary: "dotnet", args: ["tool", "install", "--global", "scip-dotnet"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-dotnet/releases"
+  },
+  vb: {
+    language: "vb",
+    indexerBinary: "scip-dotnet",
+    checkCommand: "scip-dotnet --version",
+    indexArgs: ({ projectRoot, outputPath }) => ({
+      binary: "scip-dotnet",
+      args: ["index", resolveDotnetProject(projectRoot, [".sln", ".vbproj"]) ?? projectRoot, "--output", outputPath, "--working-directory", projectRoot]
     }),
-    markerFiles: [],
+    markerFiles: ["*.vbproj", "*.sln"],
     installMethods: [
       { label: "dotnet", prerequisite: "dotnet", binary: "dotnet", args: ["tool", "install", "--global", "scip-dotnet"] }
     ],
@@ -670,9 +916,9 @@ var INDEXER_CONFIGS = {
     language: "dart",
     indexerBinary: "scip-dart",
     checkCommand: "scip-dart --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-dart",
-      args: ["index", "--output", outputPath]
+    indexArgs: ({ indexerBinary, outputPath }) => ({
+      binary: indexerBinary,
+      args: ["--output", outputPath]
     }),
     markerFiles: ["pubspec.yaml"],
     installMethods: [
@@ -683,21 +929,44 @@ var INDEXER_CONFIGS = {
   php: {
     language: "php",
     indexerBinary: "scip-php",
+    projectLocalBinaries: ["vendor/davidrjenni/scip-php/bin/scip-php", "vendor/bin/scip-php"],
     checkCommand: "scip-php --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-php",
-      args: ["index", "--output", outputPath]
-    }),
+    indexArgs: ({ projectRoot, indexerBinary }) => {
+      const localBinary = join5(projectRoot, "vendor", "bin", "scip-php");
+      const nestedLocalBinary = join5(projectRoot, "vendor", "davidrjenni", "scip-php", "bin", "scip-php");
+      const targetBinary = existsSync5(nestedLocalBinary) ? nestedLocalBinary : existsSync5(localBinary) ? localBinary : indexerBinary;
+      return {
+        binary: "php",
+        args: [
+          "-d",
+          "error_reporting=E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED",
+          targetBinary
+        ]
+      };
+    },
+    defaultOutputPath: "index.scip",
     markerFiles: ["composer.json"],
-    installMethods: [
-      { label: "composer", prerequisite: "composer", binary: "composer", args: ["global", "require", "davidrjenni/scip-php"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/davidrjenni/scip-php/releases"
   }
 };
 function getIndexerConfig(language) {
   return INDEXER_CONFIGS[language];
 }
+function resolveDotnetProject(projectRoot, suffixes) {
+  let entries;
+  try {
+    entries = readdirSync2(projectRoot);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (suffixes.some((suffix) => entry.endsWith(suffix))) {
+      return join5(projectRoot, entry);
+    }
+  }
+  return null;
+}
 
 // src/reindex/index.ts
 async function reindex(opts) {
@@ -707,8 +976,8 @@ async function reindex(opts) {
     onStatus = console.log,
     skipAutoInstall = false
   } = opts;
-  const outputScip = opts.outputScip ?? join4(projectRoot, "index.scip");
-  const outputDb = opts.outputDb ?? join4(projectRoot, "index.db");
+  const outputScip = opts.outputScip ?? join6(projectRoot, "index.scip");
+  const outputDb = opts.outputDb ?? join6(projectRoot, "index.db");
   const start = Date.now();
   const languages = opts.languages ?? detectLanguages(projectRoot);
   if (languages.length === 0) {
@@ -737,7 +1006,8 @@ async function reindex(opts) {
   for (const lang of languages) {
     const config = getIndexerConfig(lang);
     const binaryLabel = describeIndexerBinary(config);
-    if (!isIndexerInstalled(config)) {
+    const projectLocalBinary = resolveProjectLocalIndexerBinary(config, projectRoot);
+    if (!projectLocalBinary && !isIndexerInstalled(config)) {
       if (skipAutoInstall) {
         throw new Error(
           `${binaryLabel} is required to index ${lang} but not found on PATH.
@@ -752,7 +1022,7 @@ async function reindex(opts) {
         );
       }
     }
-    const resolvedBinary = resolveIndexerBinary(config);
+    const resolvedBinary = projectLocalBinary ?? resolveIndexerBinary(config);
     if (!resolvedBinary) {
       throw new Error(
         `${binaryLabel} is required to index ${lang} but was not found on PATH after installation checks.
@@ -760,6 +1030,7 @@ async function reindex(opts) {
       );
     }
     onStatus(`Indexing ${lang} with ${resolvedBinary}...`);
+    const indexerEnv = getIndexerExecutionEnv(config, env, resolvedBinary);
     const { binary, args } = config.indexArgs({
       projectRoot,
       outputPath: outputScip,
@@ -769,7 +1040,7 @@ async function reindex(opts) {
     try {
       execFileSync3(binary, args, {
         cwd: projectRoot,
-        env,
+        env: indexerEnv,
         stdio: "pipe",
         maxBuffer: 50 * 1024 * 1024
       });
@@ -777,12 +1048,14 @@ async function reindex(opts) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
         `Failed to index ${lang} with ${resolvedBinary}: ${msg}
-Make sure ${binaryLabel} is installed and available on PATH.`
+Make sure ${binaryLabel} is installed and available on PATH.`,
+        { cause: err }
       );
     }
+    moveDefaultOutputIfNeeded(config, projectRoot, outputScip);
   }
   onStatus("Converting to SQLite...");
-  if (!existsSync4(outputScip)) {
+  if (!existsSync6(outputScip)) {
     throw new Error(`SCIP index not found at ${outputScip} after indexing`);
   }
   try {
@@ -793,17 +1066,26 @@ Make sure ${binaryLabel} is installed and available on PATH.`
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to convert SCIP index to SQLite: ${msg}`);
+    throw new Error(`Failed to convert SCIP index to SQLite: ${msg}`, { cause: err });
   }
   const durationMs = Date.now() - start;
   onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
   return { languages, indexPath: outputScip, dbPath: outputDb, durationMs };
 }
+function moveDefaultOutputIfNeeded(config, projectRoot, outputScip) {
+  if (!config.defaultOutputPath) {
+    return;
+  }
+  const defaultOutputPath = join6(projectRoot, config.defaultOutputPath);
+  if (outputScip !== defaultOutputPath && existsSync6(defaultOutputPath)) {
+    renameSync(defaultOutputPath, outputScip);
+  }
+}
 
 // src/watch.ts
 import { watch } from "fs";
-import { existsSync as existsSync5, renameSync } from "fs";
-import { join as join5, relative } from "path";
+import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
+import { join as join7, relative } from "path";
 import { fork } from "child_process";
 import ignore2 from "ignore";
 var Watcher = class {
@@ -881,7 +1163,7 @@ var Watcher = class {
   }
   // ── Internal ─────────────────────────────────────────────
   handleFileChange(filename) {
-    const rel = relative(this.projectRoot, join5(this.projectRoot, filename));
+    const rel = relative(this.projectRoot, join7(this.projectRoot, filename));
     if (this.gitignoreFilter.isIgnored(rel)) return;
     if (this.extraIgnore.ignores(rel)) return;
     if (filename.endsWith("index.db") || filename.endsWith("index.scip") || filename.endsWith("index.db.tmp") || filename.endsWith(".scipquery.json")) {
@@ -984,11 +1266,11 @@ var Watcher = class {
       child.on("exit", (code2) => {
         if (code2 === 0) {
           try {
-            if (existsSync5(tmpDb)) {
-              renameSync(tmpDb, this.indexPaths.dbPath);
+            if (existsSync7(tmpDb)) {
+              renameSync2(tmpDb, this.indexPaths.dbPath);
             }
-            if (existsSync5(tmpScip)) {
-              renameSync(tmpScip, this.indexPaths.indexPath);
+            if (existsSync7(tmpScip)) {
+              renameSync2(tmpScip, this.indexPaths.indexPath);
             }
             resolve4(Date.now() - start);
           } catch (err) {
@@ -1042,27 +1324,36 @@ function files(db, pattern) {
 }
 
 // src/query-support.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 
 // src/source-analysis.ts
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync4
+  existsSync as existsSync8,
+  readFileSync as readFileSync3
 } from "fs";
 import {
+  basename,
   dirname as dirname2,
-  extname,
-  join as join6,
+  extname as extname2,
+  join as join8,
   relative as relative2,
   resolve as resolve2
 } from "path";
 var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_EXPORT_CACHE = /* @__PURE__ */ new WeakMap();
 var SOURCE_TEXT_CACHE = /* @__PURE__ */ new WeakMap();
 var SOURCE_CALL_CACHE = /* @__PURE__ */ new WeakMap();
 var SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
 var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
 var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
+var JVM_SOURCE_EXTENSIONS = [".java", ".scala", ".kt", ".kts"];
+var RUST_SOURCE_EXTENSIONS = [".rs"];
+var RUBY_SOURCE_EXTENSIONS = [".rb"];
+var C_LIKE_SOURCE_EXTENSIONS = [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"];
+var DOTNET_SOURCE_EXTENSIONS = [".cs", ".vb"];
+var DART_SOURCE_EXTENSIONS = [".dart"];
+var PHP_SOURCE_EXTENSIONS = [".php"];
 function getSourceImports(db, relativePath) {
   const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
   const normalized = normalizePath(relativePath);
@@ -1070,13 +1361,30 @@ function getSourceImports(db, relativePath) {
   if (cached) {
     return cached;
   }
-  const fullPath = join6(db.config.projectRoot, normalized);
-  if (!existsSync6(fullPath)) {
+  const fullPath = join8(db.config.projectRoot, normalized);
+  if (!existsSync8(fullPath)) {
+    cache.set(normalized, []);
+    return [];
+  }
+  const source = readFileSync3(fullPath, "utf-8");
+  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : isJavaScriptSourcePath(normalized) ? parseJavaScriptImports(db, normalized, source) : isJvmSourcePath(normalized) ? parseJvmImports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustImports(db, normalized, source) : isRubySourcePath(normalized) ? parseRubyImports(db, normalized, source) : isCLikeSourcePath(normalized) ? parseCLikeImports(db, normalized, source) : isDotNetSourcePath(normalized) ? parseDotNetImports(db, normalized, source) : isDartSourcePath(normalized) ? parseDartImports(db, normalized, source) : isPhpSourcePath(normalized) ? parsePhpImports(db, normalized, source) : [];
+  cache.set(normalized, parsed);
+  return parsed;
+}
+function getSourceExports(db, relativePath) {
+  const cache = getCachedMap(SOURCE_EXPORT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const fullPath = join8(db.config.projectRoot, normalized);
+  if (!existsSync8(fullPath)) {
     cache.set(normalized, []);
     return [];
   }
-  const source = readFileSync4(fullPath, "utf-8");
-  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : parseJavaScriptImports(db, normalized, source);
+  const source = readFileSync3(fullPath, "utf-8");
+  const parsed = isDartSourcePath(normalized) ? parseDartExports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustExports(db, normalized, source) : [];
   cache.set(normalized, parsed);
   return parsed;
 }
@@ -1225,97 +1533,358 @@ function parseJavaScriptImportStatement(db, importerPath, clause, specifier, sta
     };
   });
 }
-function parsePythonCalls(lines, baseLine) {
-  const calls = [];
-  const controlKeywords = /* @__PURE__ */ new Set([
-    "if",
-    "for",
-    "while",
-    "with",
-    "except",
-    "elif",
-    "return",
-    "yield",
-    "assert",
-    "raise",
-    "lambda",
-    "class",
-    "def"
-  ]);
-  for (let index = 0; index < lines.length; index++) {
-    const rawLine = lines[index] ?? "";
-    const stripped = stripCommentsAndStrings(rawLine);
-    if (!stripped.trim()) continue;
-    const attributeMatches = [...stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w]*)\s*\(/g)];
-    const attributeRanges = attributeMatches.map((match) => ({
-      start: match.index ?? -1,
-      end: (match.index ?? -1) + match[0].length
-    }));
-    for (const match of attributeMatches) {
-      const receiverName = match[1];
-      const calleeName = match[2];
-      if (!receiverName || !calleeName) continue;
-      calls.push({
-        receiverName,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-    for (const match of stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
-      const calleeName = match[1];
-      const start = match.index ?? -1;
-      if (!calleeName || start < 0) continue;
-      if (controlKeywords.has(calleeName)) continue;
-      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
-      const prefix = stripped.slice(0, start).trimEnd();
-      if (prefix.endsWith("def") || prefix.endsWith("class") || prefix.endsWith("async def")) {
-        continue;
-      }
-      calls.push({
-        receiverName: null,
-        calleeName,
-        line: baseLine + index
-      });
-    }
+function parseJvmImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*import\s+(?:static\s+)?(.+?)\s*;?$/gm)) {
+    const clause = match[1]?.trim();
+    const full = match[0];
+    if (!clause || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    statements.push(...parseJvmImportClause(db, importerPath, clause, body));
   }
-  return calls;
+  return statements;
 }
-function parseJavaScriptCalls(lines, baseLine) {
-  const calls = [];
-  const controlKeywords = /* @__PURE__ */ new Set([
-    "if",
-    "for",
-    "while",
-    "switch",
-    "catch",
-    "function",
-    "class",
-    "return",
-    "typeof",
-    "import"
-  ]);
-  for (let index = 0; index < lines.length; index++) {
-    const stripped = stripCommentsAndStrings(lines[index] ?? "");
-    if (!stripped.trim()) continue;
-    const attributeMatches = [
-      ...stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g),
-      ...stripped.matchAll(/\bthis\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g)
-    ];
-    const attributeRanges = attributeMatches.map((match) => ({
-      start: match.index ?? -1,
-      end: (match.index ?? -1) + match[0].length
-    }));
-    for (const match of attributeMatches) {
-      const receiverName = match[2] ? match[1] : "this";
-      const calleeName = match[2] ?? match[1];
-      if (!receiverName || !calleeName) continue;
-      calls.push({
-        receiverName,
-        calleeName,
-        line: baseLine + index
-      });
-    }
-    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+function parseJvmImportClause(db, importerPath, clause, body) {
+  if (clause.includes("{") && clause.includes("}")) {
+    const prefix = clause.slice(0, clause.indexOf("{")).replace(/\.$/, "").trim();
+    const inner = clause.slice(clause.indexOf("{") + 1, clause.lastIndexOf("}")).trim();
+    return splitTopLevel(inner).flatMap((entry) => {
+      const cleaned = entry.trim();
+      if (!cleaned) return [];
+      const [importedPart, aliasPart] = cleaned.includes("=>") ? cleaned.split(/\s*=>\s*/) : cleaned.split(/\s+as\s+/);
+      const importedName = importedPart?.trim();
+      if (!importedName || importedName === "_") return [];
+      const localName = (aliasPart ?? importedName.split(".").pop() ?? importedName).trim();
+      const qualified = importedName === "_" ? prefix : `${prefix}.${importedName}`.replace(/\.\./g, ".");
+      return [buildSimpleImport(db, importerPath, body, qualified, importedName, localName)];
+    });
+  }
+  return [buildSimpleImport(
+    db,
+    importerPath,
+    body,
+    clause,
+    clause.split(".").pop() ?? clause,
+    clause.split(".").pop() ?? clause
+  )];
+}
+function parseRustImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*use\s+(.+?)\s*;$/gm)) {
+    const clause = match[1]?.trim();
+    const full = match[0];
+    if (!clause || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    statements.push(...parseRustUseClause(db, importerPath, clause, body));
+  }
+  return statements;
+}
+function parseRustUseClause(db, importerPath, clause, body) {
+  const trimmed = clause.trim();
+  if (trimmed.includes("{") && trimmed.includes("}")) {
+    const prefix = trimmed.slice(0, trimmed.indexOf("{")).replace(/::$/, "").trim();
+    const inner = trimmed.slice(trimmed.indexOf("{") + 1, trimmed.lastIndexOf("}")).trim();
+    return splitTopLevel(inner).flatMap((entry) => {
+      const cleaned = entry.trim();
+      if (!cleaned || cleaned === "self") return [];
+      const [importedPart2, aliasPart2] = cleaned.split(/\s+as\s+/);
+      const importedName2 = importedPart2?.trim();
+      if (!importedName2) return [];
+      const localName2 = (aliasPart2 ?? importedName2.split("::").pop() ?? importedName2).trim();
+      const moduleSpecifier = `${prefix}::${importedName2}`.replace(/::::/g, "::");
+      return [buildSimpleImport(
+        db,
+        importerPath,
+        body,
+        moduleSpecifier,
+        importedName2.split("::").pop() ?? importedName2,
+        localName2,
+        resolveRustImportPath(db, importerPath, prefix)
+      )];
+    });
+  }
+  const [importedPart, aliasPart] = trimmed.split(/\s+as\s+/);
+  const importedName = importedPart?.trim() ?? trimmed;
+  const localName = (aliasPart ?? importedName.split("::").pop() ?? importedName).trim();
+  const resolved = resolveRustImportPath(db, importerPath, importedName) ?? resolveRustImportPath(db, importerPath, importedName.split("::").slice(0, -1).join("::"));
+  return [buildSimpleImport(
+    db,
+    importerPath,
+    body,
+    importedName,
+    importedName.split("::").pop() ?? importedName,
+    localName,
+    resolved
+  )];
+}
+function parseRustExports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*pub\s+use\s+(.+?)\s*;$/gm)) {
+    const clause = match[1]?.trim();
+    if (!clause) continue;
+    statements.push(...parseRustExportClause(db, importerPath, clause));
+  }
+  return statements;
+}
+function parseRustExportClause(db, importerPath, clause) {
+  const trimmed = clause.trim();
+  if (trimmed.includes("{") && trimmed.includes("}")) {
+    const prefix = trimmed.slice(0, trimmed.indexOf("{")).replace(/::$/, "").trim();
+    const inner = trimmed.slice(trimmed.indexOf("{") + 1, trimmed.lastIndexOf("}")).trim();
+    return splitTopLevel(inner).flatMap((entry) => {
+      const cleaned = entry.trim();
+      if (!cleaned || cleaned === "self") return [];
+      const [qualifiedPart] = cleaned.split(/\s+as\s+/);
+      const qualified = `${prefix}::${qualifiedPart?.trim() ?? cleaned}`.replace(/::::/g, "::");
+      return [buildRustExport(db, importerPath, qualified)];
+    });
+  }
+  return [buildRustExport(db, importerPath, trimmed)];
+}
+function buildRustExport(db, importerPath, specifier) {
+  return {
+    specifier,
+    sourcePath: resolveRustImportPath(db, importerPath, specifier) ?? resolveRustImportPath(db, importerPath, specifier.split("::").slice(0, -1).join("::"))
+  };
+}
+function parseRubyImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*(require_relative|require)\s+["']([^"']+)["']\s*$/gm)) {
+    const kind = match[1];
+    const specifier = match[2];
+    const full = match[0];
+    if (!kind || !specifier || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    const sourcePath = kind === "require_relative" ? resolveRubyImportPath(db, importerPath, specifier) : null;
+    if (sourcePath) {
+      const localName = rubyConstantName(specifier);
+      statements.push({
+        importedName: localName,
+        localName,
+        sourcePath,
+        kind: "named",
+        used: hasIdentifierUsage(body, localName),
+        usedMembers: []
+      });
+      continue;
+    }
+    statements.push({
+      importedName: specifier,
+      localName: null,
+      sourcePath,
+      kind: "side-effect",
+      used: true,
+      usedMembers: []
+    });
+  }
+  return statements;
+}
+function rubyConstantName(specifier) {
+  return basename(specifier).replace(/\.[^.]+$/, "").split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function parseCLikeImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*#include\s+[<"]([^">]+)[">]\s*$/gm)) {
+    const specifier = match[1]?.trim();
+    const full = match[0];
+    if (!specifier || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    const localName = basename(specifier).replace(/\.[^.]+$/, "");
+    statements.push({
+      importedName: specifier,
+      localName,
+      sourcePath: resolveCLikeImportPath(db, importerPath, specifier),
+      kind: "named",
+      used: hasIdentifierUsage(body, localName),
+      usedMembers: []
+    });
+  }
+  return statements;
+}
+function parseDotNetImports(db, importerPath, source) {
+  const statements = [];
+  const lineRegex = isVisualBasicSourcePath(importerPath) ? /^[ \t]*Imports\s+(.+?)\s*$/gm : /^[ \t]*using\s+(.+?)\s*;$/gm;
+  for (const match of source.matchAll(lineRegex)) {
+    const clause = match[1]?.trim();
+    const full = match[0];
+    if (!clause || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    const [aliasPart, targetPart] = isVisualBasicSourcePath(importerPath) ? clause.split(/\s*=\s*/) : clause.split(/\s*=\s*/);
+    const hasAlias = Boolean(targetPart);
+    const qualified = (hasAlias ? targetPart : aliasPart)?.trim() ?? clause;
+    const importedName = qualified.split(".").pop() ?? qualified;
+    const localName = hasAlias ? aliasPart?.trim() ?? importedName : importedName;
+    statements.push(buildSimpleImport(
+      db,
+      importerPath,
+      body,
+      qualified,
+      importedName,
+      localName,
+      resolveQualifiedImportPath(db, qualified, DOTNET_SOURCE_EXTENSIONS)
+    ));
+  }
+  return statements;
+}
+function parseDartImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*import\s+['"]([^'"]+)['"](?:\s+as\s+([A-Za-z_]\w*))?[\s\S]*?;$/gm)) {
+    const specifier = match[1]?.trim();
+    const alias = match[2]?.trim() ?? null;
+    const full = match[0];
+    if (!specifier || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    statements.push({
+      importedName: specifier,
+      localName: alias,
+      sourcePath: resolveDartImportPath(db, importerPath, specifier),
+      kind: alias ? "namespace" : "side-effect",
+      used: alias ? hasIdentifierUsage(body, alias) : true,
+      usedMembers: alias ? collectNamespaceMembers(body, alias) : []
+    });
+  }
+  return statements;
+}
+function parseDartExports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*export\s+['"]([^'"]+)['"][\s\S]*?;$/gm)) {
+    const specifier = match[1]?.trim();
+    if (!specifier) continue;
+    statements.push({
+      specifier,
+      sourcePath: resolveDartImportPath(db, importerPath, specifier)
+    });
+  }
+  return statements;
+}
+function parsePhpImports(db, importerPath, source) {
+  const statements = [];
+  for (const match of source.matchAll(/^[ \t]*use\s+(.+?)\s*;$/gm)) {
+    const clause = match[1]?.trim();
+    const full = match[0];
+    if (!clause || !full || typeof match.index !== "number") continue;
+    const body = buildUsageBody(source, match.index, match.index + full.length);
+    for (const entry of splitTopLevel(clause)) {
+      const cleaned = entry.trim();
+      if (!cleaned) continue;
+      const [qualifiedPart, aliasPart] = cleaned.split(/\s+as\s+/i);
+      const qualified = qualifiedPart?.trim() ?? cleaned;
+      const importedName = qualified.split("\\").pop() ?? qualified;
+      const localName = (aliasPart ?? importedName).trim();
+      statements.push(buildSimpleImport(
+        db,
+        importerPath,
+        body,
+        qualified,
+        importedName,
+        localName,
+        resolveQualifiedImportPath(db, qualified.replace(/\\/g, "."), PHP_SOURCE_EXTENSIONS)
+      ));
+    }
+  }
+  return statements;
+}
+function buildSimpleImport(db, importerPath, body, qualifiedName, importedName, localName, sourcePath) {
+  return {
+    importedName,
+    localName,
+    sourcePath: sourcePath ?? resolveQualifiedImportPath(db, qualifiedName, extensionFamilyFor(importerPath)),
+    kind: "named",
+    used: hasIdentifierUsage(body, localName),
+    usedMembers: []
+  };
+}
+function parsePythonCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "with",
+    "except",
+    "elif",
+    "return",
+    "yield",
+    "assert",
+    "raise",
+    "lambda",
+    "class",
+    "def"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const rawLine = lines[index] ?? "";
+    const stripped = stripCommentsAndStrings(rawLine);
+    if (!stripped.trim()) continue;
+    const attributeMatches = [...stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w]*)\s*\(/g)];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[1];
+      const calleeName = match[2];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      if (controlKeywords.has(calleeName)) continue;
+      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
+      const prefix = stripped.slice(0, start).trimEnd();
+      if (prefix.endsWith("def") || prefix.endsWith("class") || prefix.endsWith("async def")) {
+        continue;
+      }
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+  }
+  return calls;
+}
+function parseJavaScriptCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "class",
+    "return",
+    "typeof",
+    "import"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const stripped = stripCommentsAndStrings(lines[index] ?? "");
+    if (!stripped.trim()) continue;
+    const attributeMatches = [
+      ...stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g),
+      ...stripped.matchAll(/\bthis\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g)
+    ];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[2] ? match[1] : "this";
+      const calleeName = match[2] ?? match[1];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
       const calleeName = match[1];
       const start = match.index ?? -1;
       if (!calleeName || start < 0) continue;
@@ -1574,18 +2143,33 @@ function resolveImportPath(db, importerPath, specifier) {
   if (isPythonSourcePath(importerPath)) {
     return resolvePythonImportPath(db, importerPath, specifier);
   }
+  if (isRustSourcePath(importerPath)) {
+    return resolveRustImportPath(db, importerPath, specifier);
+  }
+  if (isRubySourcePath(importerPath)) {
+    return resolveRubyImportPath(db, importerPath, specifier);
+  }
+  if (isCLikeSourcePath(importerPath)) {
+    return resolveCLikeImportPath(db, importerPath, specifier);
+  }
+  if (isJvmSourcePath(importerPath) || isDotNetSourcePath(importerPath) || isPhpSourcePath(importerPath)) {
+    return resolveQualifiedImportPath(db, specifier.replace(/\\/g, "."), extensionFamilyFor(importerPath));
+  }
+  if (isDartSourcePath(importerPath)) {
+    return resolveDartImportPath(db, importerPath, specifier);
+  }
   return resolveJavaScriptImportPath(db, importerPath, specifier);
 }
 function resolveJavaScriptImportPath(db, importerPath, specifier) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return null;
   }
-  const importerDir = dirname2(join6(db.config.projectRoot, importerPath));
+  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
   const absolute = resolve2(importerDir, specifier);
   const indexedPaths = getIndexedPaths(db);
   for (const candidate of candidateImportPaths(absolute)) {
     const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+    if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
   }
@@ -1599,7 +2183,7 @@ function resolvePythonImportPath(db, importerPath, specifier) {
     if (!match) return null;
     const dots = match[1].length;
     const remainder = match[2].replace(/^\./, "");
-    let baseDir = dirname2(join6(db.config.projectRoot, importerPath));
+    let baseDir = dirname2(join8(db.config.projectRoot, importerPath));
     for (let i = 1; i < dots; i++) {
       baseDir = dirname2(baseDir);
     }
@@ -1609,26 +2193,145 @@ function resolvePythonImportPath(db, importerPath, specifier) {
   }
   for (const candidate of pythonCandidateImportPaths(basePath)) {
     const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+    if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function resolveRustImportPath(db, importerPath, specifier) {
+  if (!specifier) return null;
+  const normalizedSpecifier = specifier.replace(/\s+as\s+.+$/, "").trim();
+  if (!normalizedSpecifier.startsWith("crate::") && !normalizedSpecifier.startsWith("self::") && !normalizedSpecifier.startsWith("super::")) {
+    return null;
+  }
+  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  let basePath;
+  if (normalizedSpecifier.startsWith("crate::")) {
+    basePath = resolve2(db.config.projectRoot, "src", normalizedSpecifier.slice("crate::".length).replace(/::/g, "/"));
+  } else if (normalizedSpecifier.startsWith("self::")) {
+    basePath = resolve2(importerDir, normalizedSpecifier.slice("self::".length).replace(/::/g, "/"));
+  } else {
+    basePath = resolve2(dirname2(importerDir), normalizedSpecifier.slice("super::".length).replace(/::/g, "/"));
+  }
+  for (const candidate of rustCandidateImportPaths(basePath)) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (getIndexedPaths(db).has(relativeCandidate) || existsSync8(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function resolveRubyImportPath(db, importerPath, specifier) {
+  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  const absolute = resolve2(importerDir, specifier);
+  for (const candidate of rubyCandidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (getIndexedPaths(db).has(relativeCandidate) || existsSync8(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function resolveCLikeImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths(db);
+  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  const candidates = [
+    resolve2(importerDir, specifier),
+    resolve2(db.config.projectRoot, specifier),
+    resolve2(db.config.projectRoot, "include", specifier),
+    resolve2(db.config.projectRoot, "src", specifier)
+  ];
+  for (const candidate of candidates) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function resolveQualifiedImportPath(db, specifier, extensions) {
+  const indexedPaths = getIndexedPaths(db);
+  const normalized = specifier.replace(/\\/g, ".").replace(/::/g, ".").replace(/^global::/, "");
+  const pathified = normalized.replace(/\./g, "/");
+  const basenameOnly = normalized.split(".").pop() ?? normalized;
+  for (const ext of extensions) {
+    const exactSuffix = `${pathified}${ext}`;
+    const exact = [...indexedPaths].find((relativePath) => relativePath.endsWith(exactSuffix));
+    if (exact) return exact;
+  }
+  for (const ext of extensions) {
+    const basenameMatch = [...indexedPaths].find((relativePath) => basename(relativePath) === `${basenameOnly}${ext}`);
+    if (basenameMatch) return basenameMatch;
+  }
+  const folderMatches = [...indexedPaths].filter((relativePath) => extensions.includes(extname2(relativePath).toLowerCase())).filter((relativePath) => relativePath.includes(`/${pathified}/`) || relativePath.includes(`/${basenameOnly}/`)).sort((left, right) => left.localeCompare(right));
+  if (folderMatches.length === 1) {
+    return folderMatches[0];
+  }
+  return null;
+}
+function resolveDartImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths(db);
+  if (specifier.startsWith("package:")) {
+    const withoutScheme = specifier.slice("package:".length);
+    const slashIndex = withoutScheme.indexOf("/");
+    if (slashIndex < 0) return null;
+    const packageRelative = withoutScheme.slice(slashIndex + 1);
+    const candidate = normalizePath(packageRelative.startsWith("lib/") ? packageRelative : `lib/${packageRelative}`);
+    if (indexedPaths.has(candidate)) return candidate;
+    return null;
+  }
+  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  const absolute = resolve2(importerDir, specifier);
+  for (const candidate of dartCandidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
   }
   return null;
 }
 function pythonCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
+  const ext = extname2(basePath);
   if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
   return [
     `${basePath}.py`,
     `${basePath}.pyi`,
-    join6(basePath, "__init__.py"),
-    join6(basePath, "__init__.pyi")
+    join8(basePath, "__init__.py"),
+    join8(basePath, "__init__.pyi")
+  ];
+}
+function rustCandidateImportPaths(basePath) {
+  const ext = extname2(basePath);
+  if (RUST_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [
+    `${basePath}.rs`,
+    join8(basePath, "mod.rs")
+  ];
+}
+function rubyCandidateImportPaths(basePath) {
+  const ext = extname2(basePath);
+  if (RUBY_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [
+    `${basePath}.rb`,
+    join8(basePath, "index.rb")
   ];
 }
+function dartCandidateImportPaths(basePath) {
+  const ext = extname2(basePath);
+  if (DART_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [`${basePath}.dart`, basePath];
+}
 function candidateImportPaths(absolute) {
-  const ext = extname(absolute);
+  const ext = extname2(absolute);
   const candidates = /* @__PURE__ */ new Set();
   if (ext) {
     candidates.add(absolute);
@@ -1638,7 +2341,7 @@ function candidateImportPaths(absolute) {
   } else {
     for (const sourceExt of SOURCE_EXTENSIONS) {
       candidates.add(`${absolute}${sourceExt}`);
-      candidates.add(join6(absolute, `index${sourceExt}`));
+      candidates.add(join8(absolute, `index${sourceExt}`));
     }
   }
   return [...candidates];
@@ -1671,10 +2374,44 @@ function normalizePath(path2) {
   return path2.replace(/\\/g, "/");
 }
 function isJavaScriptSourcePath(relativePath) {
-  return SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
 }
 function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isJvmSourcePath(relativePath) {
+  return JVM_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isRustSourcePath(relativePath) {
+  return RUST_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isRubySourcePath(relativePath) {
+  return RUBY_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isCLikeSourcePath(relativePath) {
+  return C_LIKE_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isDotNetSourcePath(relativePath) {
+  return DOTNET_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isVisualBasicSourcePath(relativePath) {
+  return extname2(relativePath).toLowerCase() === ".vb";
+}
+function isDartSourcePath(relativePath) {
+  return DART_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function isPhpSourcePath(relativePath) {
+  return PHP_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+}
+function extensionFamilyFor(relativePath) {
+  if (isJvmSourcePath(relativePath)) return JVM_SOURCE_EXTENSIONS;
+  if (isDotNetSourcePath(relativePath)) return DOTNET_SOURCE_EXTENSIONS;
+  if (isPhpSourcePath(relativePath)) return PHP_SOURCE_EXTENSIONS;
+  if (isDartSourcePath(relativePath)) return DART_SOURCE_EXTENSIONS;
+  if (isCLikeSourcePath(relativePath)) return C_LIKE_SOURCE_EXTENSIONS;
+  if (isRustSourcePath(relativePath)) return RUST_SOURCE_EXTENSIONS;
+  if (isRubySourcePath(relativePath)) return RUBY_SOURCE_EXTENSIONS;
+  return SOURCE_EXTENSIONS;
 }
 function getSourceText(db, relativePath) {
   const cache = getCachedMap(SOURCE_TEXT_CACHE, db);
@@ -1683,12 +2420,12 @@ function getSourceText(db, relativePath) {
   if (typeof cached === "string") {
     return cached;
   }
-  const fullPath = join6(db.config.projectRoot, normalized);
-  if (!existsSync6(fullPath)) {
+  const fullPath = join8(db.config.projectRoot, normalized);
+  if (!existsSync8(fullPath)) {
     cache.set(normalized, "");
     return "";
   }
-  const source = readFileSync4(fullPath, "utf-8");
+  const source = readFileSync3(fullPath, "utf-8");
   cache.set(normalized, source);
   return source;
 }
@@ -1790,7 +2527,6 @@ function parseDescriptors(input) {
       const closingTick = input.indexOf("`", i + 1);
       if (closingTick === -1) {
         name = input.slice(i + 1);
-        i = input.length;
         descriptors.push({ name, suffix: "term" });
         break;
       }
@@ -1942,18 +2678,43 @@ function buildFileDepGraph(db, scope) {
       ${scopeFilter}`
   );
   const graph = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    if (db.isIgnored(edge.from_file) || db.isIgnored(edge.to_file)) continue;
-    if (!graph.has(edge.from_file)) graph.set(edge.from_file, /* @__PURE__ */ new Set());
-    graph.get(edge.from_file).add(edge.to_file);
-  }
-  return graph;
-}
+  const indexedFiles = new Set(
+    db.all(
+      `SELECT relative_path
+       FROM documents
+       WHERE 1 = 1
+         ${db.pathExclusionsFor("documents")}
+       ORDER BY relative_path`
+    ).map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath))
+  );
+  const addEdge = (fromFile, toFile) => {
+    if (fromFile === toFile) return;
+    if (db.isIgnored(fromFile) || db.isIgnored(toFile)) return;
+    if (!indexedFiles.has(toFile)) return;
+    if (!graph.has(fromFile)) graph.set(fromFile, /* @__PURE__ */ new Set());
+    graph.get(fromFile).add(toFile);
+  };
+  for (const edge of edges) {
+    addEdge(edge.from_file, edge.to_file);
+  }
+  for (const relativePath of indexedFiles) {
+    if (scope && !relativePath.includes(scope)) continue;
+    for (const entry of getSourceImports(db, relativePath)) {
+      if (!entry.sourcePath) continue;
+      addEdge(relativePath, entry.sourcePath);
+    }
+  }
+  return graph;
+}
 function findFirstSymbolMatch(db, symbolPattern) {
+  const exact = findExactSymbolMatch(db, symbolPattern.trim());
+  if (exact) {
+    return exact;
+  }
   const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
   if (fileLineMatch) {
     const [, filePath, startStr, endStr] = fileLineMatch;
-    const row = db.get(
+    let row = db.get(
       `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
       FROM global_symbols gs
       JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
@@ -1962,25 +2723,41 @@ function findFirstSymbolMatch(db, symbolPattern) {
         AND der.start_line <= ? AND der.end_line >= ?
         ${db.pathExclusionsFor("d")}
       ORDER BY (der.end_line - der.start_line) ASC
-      LIMIT 1`,
+        LIMIT 1`,
       `%${filePath}%`,
       parseInt(startStr, 10),
       parseInt(endStr, 10)
     );
+    if (!row) {
+      row = db.get(
+        `SELECT gs.id, gs.symbol, c.document_id, MIN(c.start_line) AS start_line, MAX(c.end_line) AS end_line, d.relative_path
+         FROM global_symbols gs
+         JOIN mentions m ON m.symbol_id = gs.id
+         JOIN chunks c ON m.chunk_id = c.id
+         JOIN documents d ON c.document_id = d.id
+         WHERE m.role = 1
+           AND d.relative_path LIKE ?
+           AND c.start_line <= ? AND c.end_line >= ?
+           ${db.pathExclusionsFor("d")}
+         GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path
+         ORDER BY (MAX(c.end_line) - MIN(c.start_line)) ASC
+         LIMIT 1`,
+        `%${filePath}%`,
+        parseInt(startStr, 10),
+        parseInt(endStr, 10)
+      );
+    }
     if (row && !db.isIgnored(row.relative_path)) {
-      return {
-        symbolId: row.id,
-        symbol: row.symbol,
-        documentId: row.document_id,
-        startLine: row.start_line,
-        endLine: row.end_line,
-        relativePath: row.relative_path
-      };
+      return hydrateSymbolMatch(db, row);
     }
   }
   const cleaned = normalizeLookupPattern(symbolPattern);
   const tokens = lookupTokens(symbolPattern);
   const candidates = getSymbolLookupCandidates(db, tokens);
+  const direct = findDirectSymbolCandidate(candidates, symbolPattern, cleaned);
+  if (direct && !db.isIgnored(direct.relative_path)) {
+    return hydrateSymbolMatch(db, direct);
+  }
   let best = null;
   for (const row of candidates) {
     if (db.isIgnored(row.relative_path)) continue;
@@ -1991,14 +2768,7 @@ function findFirstSymbolMatch(db, symbolPattern) {
     }
   }
   if (best) {
-    return {
-      symbolId: best.row.id,
-      symbol: best.row.symbol,
-      documentId: best.row.document_id,
-      startLine: best.row.start_line,
-      endLine: best.row.end_line,
-      relativePath: best.row.relative_path
-    };
+    return hydrateSymbolMatch(db, best.row);
   }
   return null;
 }
@@ -2017,14 +2787,7 @@ function findExactSymbolMatch(db, symbol) {
   if (!row || db.isIgnored(row.relative_path)) {
     return null;
   }
-  return {
-    symbolId: row.id,
-    symbol: row.symbol,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    relativePath: row.relative_path
-  };
+  return hydrateSymbolMatch(db, row);
 }
 function resolveIndexedFile(db, filePattern) {
   return resolveDocumentCandidates(db, filePattern, { allowMultiple: false })[0]?.relativePath ?? null;
@@ -2048,28 +2811,63 @@ function getSymbolLookupCandidates(db, tokens) {
     const like = `%${token}%`;
     return [like, like, like];
   });
-  return db.all(
+  const primary = db.all(
     `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path, gs.display_name
      FROM global_symbols gs
      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
      JOIN documents d ON der.document_id = d.id
      WHERE ${tokenClauses.join("\n       AND ")}
        ${db.pathExclusionsFor("d")}
+      LIMIT 200`,
+    ...params
+  );
+  if (primary.length > 0) {
+    return primary;
+  }
+  return db.all(
+    `SELECT
+      gs.id,
+      gs.symbol,
+      c.document_id,
+      MIN(c.start_line) AS start_line,
+      MAX(c.end_line) AS end_line,
+      d.relative_path,
+      gs.display_name
+     FROM global_symbols gs
+     JOIN mentions m ON m.symbol_id = gs.id
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.role = 1
+       AND ${tokenClauses.join("\n       AND ")}
+       ${db.pathExclusionsFor("d")}
+     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.display_name
      LIMIT 200`,
     ...params
   );
 }
 function scoreSymbolCandidate(row, originalPattern, cleanedPattern, tokens) {
+  const originalCase = originalPattern.trim();
+  const cleanedCase = cleanedPattern;
+  const noParensCase = cleanedCase.replace(/\(\)$/, "");
   const original = originalPattern.toLowerCase();
   const cleaned = cleanedPattern.toLowerCase();
   const noParens = cleaned.replace(/\(\)$/, "");
+  const rawCase = row.symbol;
+  const shortCase = shortenSymbol(row.symbol);
+  const leafCase = leafName(row.symbol);
+  const displayCase = row.display_name ?? "";
   const raw = row.symbol.toLowerCase();
-  const short = shortenSymbol(row.symbol).toLowerCase();
-  const leaf = leafName(row.symbol).toLowerCase();
-  const display = (row.display_name ?? "").toLowerCase();
+  const short = shortCase.toLowerCase();
+  const leaf = leafCase.toLowerCase();
+  const display = displayCase.toLowerCase();
   const path2 = row.relative_path.toLowerCase();
   const looksPathLike = /[/:.]/.test(cleanedPattern);
   let score = 0;
+  if (rawCase === originalCase || rawCase === cleanedCase) score += 1150;
+  if (shortCase === originalCase || shortCase === cleanedCase) score += 1100;
+  if (displayCase === noParensCase) score += 980;
+  if (leafCase === noParensCase) score += 960;
+  if (`${leafCase}()` === originalCase || `${leafCase}()` === cleanedCase) score += 955;
   if (raw === original || raw === cleaned) score += 1e3;
   if (short === original || short === cleaned) score += 950;
   if (path2 === original || path2 === cleaned) score += 925;
@@ -2098,48 +2896,42 @@ function scoreSymbolCandidate(row, originalPattern, cleanedPattern, tokens) {
   return score;
 }
 function getCalleeRowsForSymbol(db, symbol, opts = {}) {
-  const rows = db.all(
-    `SELECT DISTINCT
-      callee_gs.symbol AS symbol,
-      callee_d.relative_path AS file,
-      c.id AS chunk_id
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN global_symbols callee_gs ON m.symbol_id = callee_gs.id
-    JOIN defn_enclosing_ranges callee_der ON callee_gs.id = callee_der.symbol_id
-    JOIN documents callee_d ON callee_der.document_id = callee_d.id
-    WHERE c.document_id = ?
-      AND c.start_line >= ?
-      AND c.end_line <= ?
-      AND m.role != 1
-      AND callee_gs.id != ?
-      ${db.symbolNoiseFor("callee_gs")}
-      ${db.pathExclusionsFor("callee_d")}
-    ORDER BY callee_d.relative_path
-    ${opts.limit ? "LIMIT ?" : ""}`,
+  const mentions = db.all(
+    `SELECT DISTINCT m.symbol_id, c.id AS chunk_id
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     WHERE c.document_id = ?
+       AND c.start_line >= ?
+       AND c.end_line <= ?
+       AND m.role != 1
+       AND m.symbol_id != ?
+     ${opts.limit ? "LIMIT ?" : ""}`,
     ...calleeQueryParams(symbol, opts.limit)
   );
-  const primary = rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
-    symbol: row.symbol,
-    file: row.file,
-    chunkId: row.chunk_id
-  }));
-  const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
-  if (sourceFallback.length === 0) {
-    return primary;
+  const primary = [];
+  const directSeen = /* @__PURE__ */ new Set();
+  for (const mention of mentions) {
+    const callee = getFullSymbolMatch(db, {
+      symbolId: mention.symbol_id,
+      documentId: symbol.documentId,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine
+    });
+    if (!callee || db.isIgnored(callee.relativePath)) continue;
+    const key = `${callee.symbol}|${callee.relativePath}|${mention.chunk_id}`;
+    if (directSeen.has(key)) continue;
+    directSeen.add(key);
+    primary.push({
+      symbol: callee.symbol,
+      file: callee.relativePath,
+      chunkId: mention.chunk_id
+    });
   }
-  if (primary.length === 0) {
+  const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
+  if (sourceFallback.length > 0) {
     return applyLimit(sourceFallback, opts.limit);
   }
-  const seen = new Set(primary.map((row) => `${row.symbol}|${row.file}`));
-  const merged = [...primary];
-  for (const row of sourceFallback) {
-    const key = `${row.symbol}|${row.file}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(row);
-  }
-  return applyLimit(merged, opts.limit);
+  return primary;
 }
 function getCallerRowsForSymbol(db, symbol, opts = {}) {
   const match = getFullSymbolMatch(db, symbol);
@@ -2147,35 +2939,38 @@ function getCallerRowsForSymbol(db, symbol, opts = {}) {
     return [];
   }
   const primary = db.all(
-    `SELECT DISTINCT caller_gs.symbol AS caller_symbol, caller_d.relative_path AS caller_file
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents ref_d ON c.document_id = ref_d.id
-    JOIN defn_enclosing_ranges caller_der
-      ON caller_der.document_id = ref_d.id
-      AND c.start_line >= caller_der.start_line
-      AND c.end_line <= caller_der.end_line
-    JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
-    JOIN documents caller_d ON caller_der.document_id = caller_d.id
-    WHERE m.symbol_id = ?
-      AND m.role != 1
-      AND caller_gs.id != ?
-      ${db.symbolNoiseFor("caller_gs")}
-      ${db.pathExclusionsFor("caller_d")}
-    ORDER BY caller_d.relative_path
-    ${opts.limit ? "LIMIT ?" : ""}`,
-    ...callerQueryParams(match, opts.limit)
-  ).filter((row) => !db.isIgnored(row.caller_file)).map((row) => ({
-    symbol: row.caller_symbol,
-    file: row.caller_file
-  }));
-  const sourceFallback = getPythonSourceCallerRows(db, match, opts.limit);
+    `SELECT DISTINCT ref_d.relative_path AS caller_file, c.start_line AS line
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents ref_d ON c.document_id = ref_d.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("ref_d")}
+     ORDER BY ref_d.relative_path
+     ${opts.limit ? "LIMIT ?" : ""}`,
+    ...referenceQueryParams(match, opts.limit)
+  ).filter((row) => !db.isIgnored(row.caller_file)).flatMap((row) => {
+    const enclosing = findEnclosingDefinition(getDefinitionsForFile(db, row.caller_file), row.line);
+    if (!enclosing || enclosing.symbolId === match.symbolId) {
+      return [];
+    }
+    return [{
+      symbol: enclosing.symbol,
+      file: row.caller_file
+    }];
+  });
+  const sourceFallback = dedupeCallerRows([
+    ...getPythonSourceCallerRows(db, match, opts.limit),
+    ...getGenericSourceCallerRows(db, match, opts.limit)
+  ]);
   if (sourceFallback.length === 0) {
-    return primary;
+    return dedupeCallerRows(primary);
   }
-  const merged = sourceFallback.length > 0 ? [...sourceFallback] : [];
+  const merged = [...sourceFallback];
+  const fallbackFiles = new Set(sourceFallback.map((row) => row.file));
   const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
   for (const row of primary) {
+    if (fallbackFiles.has(row.file)) continue;
     const key = `${row.symbol}|${row.file}`;
     if (seen.has(key)) continue;
     if (isFunctionLikeSymbol(row.symbol) || merged.length === 0) {
@@ -2185,6 +2980,26 @@ function getCallerRowsForSymbol(db, symbol, opts = {}) {
   }
   return applyLimit(merged, opts.limit);
 }
+function getGenericSourceCallerRows(db, symbol, limit) {
+  return applyLimit(
+    getSourceReferenceSites(db, symbol).filter((site) => site.enclosingSymbol && site.enclosingSymbol !== symbol.symbol).map((site) => ({
+      symbol: site.enclosingSymbol,
+      file: site.file
+    })),
+    limit
+  );
+}
+function dedupeCallerRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
 function getSourceReferenceSites(db, symbol) {
   const match = getFullSymbolMatch(db, symbol);
   if (!match) {
@@ -2206,21 +3021,9 @@ function getSourceReferenceSites(db, symbol) {
   for (const document of documents) {
     if (db.isIgnored(document.relative_path)) continue;
     const lines = findIdentifierLines(db, document.relative_path, identifier, document.relative_path === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {});
+    const definitions = getDefinitionsForFile(db, document.relative_path);
     for (const line of lines) {
-      const enclosing = db.get(
-        `SELECT gs.symbol
-         FROM defn_enclosing_ranges der
-         JOIN global_symbols gs ON der.symbol_id = gs.id
-         JOIN documents d ON der.document_id = d.id
-         WHERE d.relative_path = ?
-           AND der.start_line <= ?
-           AND der.end_line >= ?
-         ORDER BY (der.end_line - der.start_line) ASC
-         LIMIT 1`,
-        document.relative_path,
-        line,
-        line
-      );
+      const enclosing = findEnclosingDefinition(definitions, line);
       const key = `${document.relative_path}|${line}|${enclosing?.symbol ?? ""}`;
       if (seen.has(key)) continue;
       seen.add(key);
@@ -2245,13 +3048,23 @@ function calleeQueryParams(symbol, limit) {
   }
   return params;
 }
-function callerQueryParams(symbol, limit) {
-  const params = [symbol.symbolId, symbol.symbolId];
+function referenceQueryParams(symbol, limit) {
+  const params = [symbol.symbolId];
   if (typeof limit === "number") {
     params.push(limit);
   }
   return params;
 }
+function findEnclosingDefinition(definitions, line) {
+  let best = null;
+  for (const definition of definitions) {
+    if (definition.startLine > line || definition.endLine < line) continue;
+    if (!best || definition.endLine - definition.startLine < best.endLine - best.startLine) {
+      best = definition;
+    }
+  }
+  return best;
+}
 function getPythonSourceCalleeRows(db, symbol, limit) {
   const match = getFullSymbolMatch(db, symbol);
   if (!match || !isPythonDocument(db, match.relativePath)) {
@@ -2342,6 +3155,94 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
   }
   return applyLimit(rows, limit);
 }
+function getJavaSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isJavaDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseJavaFieldBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getKotlinSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isKotlinDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseKotlinFieldBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getScalaSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isScalaDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getCSharpSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isCSharpDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getVisualBasicSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isVisualBasicDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getCppSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isCppDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  const bindings = parseCppReceiverBindings(getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
+}
+function getRustSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isRustDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getRubySourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isRubyDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, { allowInstanceVariables: true });
+  const rubyCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, {
+    allowInstanceVariables: true,
+    allowBareMemberCalls: true
+  });
+  const bindings = parseRubyReceiverBindings(db, getSourceText(db, match.relativePath));
+  return resolveSimpleSourceCallees(db, match, rubyCalls.length > 0 ? rubyCalls : calls, bindings, limit);
+}
+function getDartSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isDartDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
+function getPhpSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isPhpDocument(db, match.relativePath)) {
+    return [];
+  }
+  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
+  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
+}
 function getSourceBackedCalleeRows(db, symbol, limit) {
   const match = getFullSymbolMatch(db, symbol);
   if (!match) {
@@ -2353,6 +3254,36 @@ function getSourceBackedCalleeRows(db, symbol, limit) {
   if (isJavaScriptDocument(db, match.relativePath)) {
     return getJavaScriptSourceCalleeRows(db, match, limit);
   }
+  if (isJavaDocument(db, match.relativePath)) {
+    return getJavaSourceCalleeRows(db, match, limit);
+  }
+  if (isScalaDocument(db, match.relativePath)) {
+    return getScalaSourceCalleeRows(db, match, limit);
+  }
+  if (isKotlinDocument(db, match.relativePath)) {
+    return getKotlinSourceCalleeRows(db, match, limit);
+  }
+  if (isCSharpDocument(db, match.relativePath)) {
+    return getCSharpSourceCalleeRows(db, match, limit);
+  }
+  if (isVisualBasicDocument(db, match.relativePath)) {
+    return getVisualBasicSourceCalleeRows(db, match, limit);
+  }
+  if (isCppDocument(db, match.relativePath)) {
+    return getCppSourceCalleeRows(db, match, limit);
+  }
+  if (isRustDocument(db, match.relativePath)) {
+    return getRustSourceCalleeRows(db, match, limit);
+  }
+  if (isRubyDocument(db, match.relativePath)) {
+    return getRubySourceCalleeRows(db, match, limit);
+  }
+  if (isDartDocument(db, match.relativePath)) {
+    return getDartSourceCalleeRows(db, match, limit);
+  }
+  if (isPhpDocument(db, match.relativePath)) {
+    return getPhpSourceCalleeRows(db, match, limit);
+  }
   return [];
 }
 function getPythonSourceCallerRows(db, target, limit) {
@@ -2378,27 +3309,49 @@ function getPythonSourceCallerRows(db, target, limit) {
   }
   return rows;
 }
-function getFullSymbolMatch(db, symbol) {
-  if ("symbol" in symbol && "relativePath" in symbol) {
-    return symbol;
-  }
-  const row = db.get(
-    `SELECT gs.symbol, d.relative_path
+function getDefinitionRowsForSymbolId(db, symbolId) {
+  const primary = db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path, gs.display_name
      FROM global_symbols gs
      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
      JOIN documents d ON der.document_id = d.id
      WHERE gs.id = ?
-     LIMIT 1`,
-    symbol.symbolId
+     ORDER BY der.start_line, der.end_line`,
+    symbolId
+  );
+  if (primary.length > 0) {
+    return primary;
+  }
+  return db.all(
+    `SELECT
+      gs.id,
+      gs.symbol,
+      c.document_id,
+      MIN(c.start_line) AS start_line,
+      MAX(c.end_line) AS end_line,
+      d.relative_path,
+      gs.display_name
+     FROM global_symbols gs
+     JOIN mentions m ON m.symbol_id = gs.id
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE gs.id = ?
+       AND m.role = 1
+       ${db.pathExclusionsFor("d")}
+     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.display_name
+     ORDER BY start_line, end_line`,
+    symbolId
   );
+}
+function getFullSymbolMatch(db, symbol) {
+  if ("symbol" in symbol && "relativePath" in symbol) {
+    return symbol;
+  }
+  const row = getDefinitionRowsForSymbolId(db, symbol.symbolId)[0];
   if (!row) {
     return null;
   }
-  return {
-    ...symbol,
-    symbol: row.symbol,
-    relativePath: row.relative_path
-  };
+  return hydrateSymbolMatch(db, row);
 }
 function getDefinitionsForFile(db, relativePath) {
   let cache = FILE_DEFINITION_CACHE.get(db);
@@ -2410,8 +3363,18 @@ function getDefinitionsForFile(db, relativePath) {
   if (cached) {
     return cached;
   }
-  const definitions = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+  const primary = db.all(
+    `SELECT
+      gs.id,
+      gs.symbol,
+      der.document_id,
+      der.start_line,
+      der.end_line,
+      d.relative_path,
+      gs.display_name,
+      gs.kind,
+      gs.documentation,
+      gs.enclosing_symbol
      FROM global_symbols gs
      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
      JOIN documents d ON der.document_id = d.id
@@ -2419,54 +3382,272 @@ function getDefinitionsForFile(db, relativePath) {
        ${db.symbolNoiseFor("gs")}
      ORDER BY der.start_line, der.end_line`,
     relativePath
-  ).map((row) => ({
-    symbolId: row.id,
-    symbol: row.symbol,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    relativePath: row.relative_path,
-    leaf: leafName(row.symbol),
-    parentTypeName: parentTypeName(row.symbol),
-    isFunctionLike: isFunctionLikeSymbol(row.symbol),
-    isTypeLike: leafSuffix(row.symbol) === "type"
-  }));
-  cache.set(relativePath, definitions);
-  return definitions;
-}
-function getAllFunctionLikeDefinitions(db) {
-  const rows = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+  );
+  const fallback = primary.length > 0 ? [] : db.all(
+    `SELECT
+      gs.id,
+      gs.symbol,
+      c.document_id,
+      MIN(c.start_line) AS start_line,
+      MAX(c.end_line) AS end_line,
+      d.relative_path,
+      gs.display_name,
+      gs.kind,
+      gs.documentation,
+      gs.enclosing_symbol
      FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     JOIN documents d ON der.document_id = d.id
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("d")}
+     JOIN mentions m ON m.symbol_id = gs.id
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE d.relative_path = ?
+       AND m.role = 1
        ${db.symbolNoiseFor("gs")}
-     ORDER BY d.relative_path, der.start_line`
+     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path
+     ORDER BY start_line, end_line`,
+    relativePath
+  );
+  const definitions = correctDefinitionRangesFromSource(
+    db,
+    relativePath,
+    (primary.length > 0 ? primary : fallback).map((row) => ({
+      symbolId: row.id,
+      symbol: row.symbol,
+      documentId: row.document_id,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      relativePath: row.relative_path,
+      leaf: leafName(row.symbol),
+      parentTypeName: parentTypeName(row.symbol),
+      isFunctionLike: isFunctionLikeSymbol(row.symbol),
+      isTypeLike: leafSuffix(row.symbol) === "type",
+      kind: row.kind ?? null,
+      documentation: row.documentation ?? null,
+      enclosingSymbol: row.enclosing_symbol ?? null
+    }))
   );
-  return rows.filter((row) => !db.isIgnored(row.relative_path)).filter((row) => isFunctionLikeSymbol(row.symbol)).map((row) => ({
+  cache.set(relativePath, definitions);
+  return definitions;
+}
+function hydrateSymbolMatch(db, row) {
+  const corrected = getDefinitionsForFile(db, row.relative_path).find((definition) => definition.symbolId === row.id);
+  if (corrected) {
+    return {
+      symbolId: corrected.symbolId,
+      symbol: corrected.symbol,
+      documentId: corrected.documentId,
+      startLine: corrected.startLine,
+      endLine: corrected.endLine,
+      relativePath: corrected.relativePath
+    };
+  }
+  return {
     symbolId: row.id,
     symbol: row.symbol,
     documentId: row.document_id,
     startLine: row.start_line,
     endLine: row.end_line,
-    relativePath: row.relative_path,
-    leaf: leafName(row.symbol),
-    parentTypeName: parentTypeName(row.symbol),
-    isFunctionLike: true,
-    isTypeLike: false
-  }));
+    relativePath: row.relative_path
+  };
 }
-function resolvePythonCallTarget(db, current, currentFileDefinitions, imports2, constructorBindings, receiverName, calleeName) {
-  if (receiverName === "self" || receiverName === "cls") {
-    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
+function findDirectSymbolCandidate(candidates, symbolPattern, cleanedPattern) {
+  const trimmed = symbolPattern.trim();
+  const directMatches = candidates.filter((row) => {
+    const short = shortenSymbol(row.symbol);
+    const display = (row.display_name ?? "").trim();
+    return row.symbol === trimmed || short === trimmed || short === cleanedPattern || display === trimmed || display === cleanedPattern || `${display}()` === trimmed || row.relative_path === trimmed;
+  });
+  if (directMatches.length === 0) {
+    return null;
   }
-  if (receiverName) {
-    const inferredType = constructorBindings.get(receiverName);
-    if (inferredType) {
-      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
-      if (boundMethod) {
+  directMatches.sort(
+    (left, right) => left.end_line - left.start_line - (right.end_line - right.start_line) || left.relative_path.localeCompare(right.relative_path) || left.symbol.localeCompare(right.symbol)
+  );
+  return directMatches[0] ?? null;
+}
+function correctDefinitionRangesFromSource(db, relativePath, definitions) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return definitions;
+  }
+  const lines = source.split(/\r?\n/);
+  const correctedStarts = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    correctedStarts.set(
+      definition.symbolId,
+      resolveCallableDefinitionStartLine(lines, definition)
+    );
+  }
+  const correctedRanges = /* @__PURE__ */ new Map();
+  const callableDefinitions = definitions.filter((definition) => isCallableDefinition(definition.symbol)).map((definition) => ({
+    definition,
+    startLine: correctedStarts.get(definition.symbolId) ?? definition.startLine
+  })).sort(
+    (left, right) => left.startLine - right.startLine || left.definition.startLine - right.definition.startLine || left.definition.symbol.localeCompare(right.definition.symbol)
+  );
+  for (let index = 0; index < callableDefinitions.length; index += 1) {
+    const current = callableDefinitions[index];
+    const next = callableDefinitions[index + 1];
+    const maxEndLine = next ? Math.max(current.startLine, next.startLine - 1) : lines.length - 1;
+    correctedRanges.set(current.definition.symbolId, {
+      startLine: current.startLine,
+      endLine: resolveCallableDefinitionEndLine(
+        lines,
+        current.definition,
+        current.startLine,
+        maxEndLine
+      )
+    });
+  }
+  return definitions.map((definition) => {
+    const corrected = correctedRanges.get(definition.symbolId);
+    if (!corrected) {
+      return definition;
+    }
+    return {
+      ...definition,
+      startLine: corrected.startLine,
+      endLine: corrected.endLine
+    };
+  });
+}
+function resolveCallableDefinitionStartLine(lines, definition) {
+  if (!isCallableDefinition(definition.symbol)) {
+    return definition.startLine;
+  }
+  const escapedLeaf = escapeRegex2(definition.leaf);
+  const strongPatterns = [
+    new RegExp(`\\b(?:function|def|fn)\\s+${escapedLeaf}\\b`),
+    new RegExp(`\\b${escapedLeaf}\\b\\s*[:=]\\s*(?:async\\s*)?(?:function\\b|\\()`)
+  ];
+  const fallbackPatterns = [
+    new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`)
+  ];
+  return findNearestMatchingLine(
+    lines,
+    [...strongPatterns, ...fallbackPatterns],
+    definition.startLine,
+    definition.endLine
+  );
+}
+function findNearestMatchingLine(lines, patterns, preferredStartLine, preferredEndLine) {
+  const windowStart = Math.max(0, preferredStartLine - 40);
+  const windowEnd = Math.min(lines.length - 1, Math.max(preferredEndLine + 40, preferredStartLine + 5));
+  const windowMatch = matchNearestLine(lines, patterns, preferredStartLine, windowStart, windowEnd);
+  if (windowMatch !== null) {
+    return windowMatch;
+  }
+  const fullMatch = matchNearestLine(lines, patterns, preferredStartLine, 0, lines.length - 1);
+  return fullMatch ?? Math.max(0, Math.min(preferredStartLine, lines.length - 1));
+}
+function matchNearestLine(lines, patterns, preferredLine, startLine, endLine) {
+  let best = null;
+  for (let lineIndex = startLine; lineIndex <= endLine; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if (!patterns.some((pattern) => pattern.test(line))) continue;
+    const distance = Math.abs(lineIndex - preferredLine);
+    if (!best || distance < best.distance) {
+      best = { line: lineIndex, distance };
+    }
+  }
+  return best?.line ?? null;
+}
+function resolveCallableDefinitionEndLine(lines, definition, startLine, maxEndLine) {
+  const boundedEndLine = Math.max(startLine, Math.min(lines.length - 1, maxEndLine));
+  const fallbackEndLine = Math.max(startLine, Math.min(boundedEndLine, definition.endLine));
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let sawOpeningBrace = false;
+  for (let lineIndex = startLine; lineIndex <= boundedEndLine; lineIndex += 1) {
+    const masked = maskStructuralLine(lines[lineIndex] ?? "");
+    for (const char of masked) {
+      if (char === "{") {
+        braceDepth += 1;
+        sawOpeningBrace = true;
+      } else if (char === "}") {
+        braceDepth = Math.max(0, braceDepth - 1);
+      } else if (char === "(") {
+        parenDepth += 1;
+      } else if (char === ")") {
+        parenDepth = Math.max(0, parenDepth - 1);
+      }
+    }
+    if (sawOpeningBrace && braceDepth === 0) {
+      return lineIndex;
+    }
+    if (!sawOpeningBrace && parenDepth === 0 && lineIndex >= fallbackEndLine) {
+      return lineIndex;
+    }
+  }
+  return fallbackEndLine;
+}
+function maskStructuralLine(line) {
+  let masked = "";
+  let quote = null;
+  let escaping = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    const next = line[index + 1];
+    if (!quote && char === "/" && next === "/") {
+      masked += " ".repeat(line.length - index);
+      break;
+    }
+    if (quote) {
+      if (escaping) {
+        escaping = false;
+        masked += " ";
+        continue;
+      }
+      if (char === "\\") {
+        escaping = true;
+        masked += " ";
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      masked += " ";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      masked += " ";
+      continue;
+    }
+    masked += char;
+  }
+  return masked;
+}
+function isCallableDefinition(symbol) {
+  return symbol.includes("().");
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getAllDefinitions(db, opts = {}) {
+  const { scope } = opts;
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scope ? "AND relative_path LIKE ?" : ""}
+     ORDER BY relative_path`,
+    ...scope ? [`%${scope}%`] : []
+  );
+  return rows.filter((row) => !db.isIgnored(row.relative_path)).flatMap((row) => getDefinitionsForFile(db, row.relative_path));
+}
+function getAllFunctionLikeDefinitions(db) {
+  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike);
+}
+function resolvePythonCallTarget(db, current, currentFileDefinitions, imports2, constructorBindings, receiverName, calleeName) {
+  if (receiverName === "self" || receiverName === "cls") {
+    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
+  }
+  if (receiverName) {
+    const inferredType = constructorBindings.get(receiverName);
+    if (inferredType) {
+      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
+      if (boundMethod) {
         return boundMethod;
       }
       for (const entry of imports2) {
@@ -2557,6 +3738,225 @@ function resolveJavaScriptCallTarget(db, current, currentFileDefinitions, import
   }
   return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
 }
+function resolveSimpleSourceCallees(db, current, calls, bindings, limit) {
+  const currentFileDefinitions = getDefinitionsForFile(db, current.relativePath);
+  const currentDefinition = currentFileDefinitions.find((definition) => definition.symbolId === current.symbolId);
+  if (!currentDefinition) {
+    return [];
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    const resolved = resolveSimpleSourceCallTarget(
+      db,
+      currentDefinition,
+      currentFileDefinitions,
+      bindings,
+      call.receiverName,
+      call.calleeName
+    );
+    if (!resolved || resolved.symbolId === current.symbolId || db.isIgnored(resolved.relativePath)) continue;
+    const chunkId = 2e9 + call.line;
+    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: resolved.symbol,
+      file: resolved.relativePath,
+      chunkId
+    });
+  }
+  return applyLimit(rows, limit);
+}
+function resolveSimpleSourceCallTarget(db, current, currentFileDefinitions, bindings, receiverName, calleeName) {
+  if (!receiverName) {
+    const localMethod = findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
+    if (localMethod) {
+      return localMethod;
+    }
+    if (current.parentTypeName) {
+      return findProjectDefinitionByTypeAndLeaf(db, current.parentTypeName, calleeName);
+    }
+    return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
+  }
+  const normalizedReceiver = normalizeReceiverName(receiverName);
+  const inferredType = bindings.get(normalizedReceiver) ?? inferTypeNameFromReceiver(db, normalizedReceiver);
+  if (!inferredType) {
+    return null;
+  }
+  return findProjectDefinitionByTypeAndLeaf(db, inferredType, calleeName);
+}
+function findProjectDefinitionByTypeAndLeaf(db, typeName, calleeName) {
+  const definitions = getAllDefinitions(db).filter((definition) => definition.isFunctionLike || definition.symbol.endsWith("()."));
+  const exact = definitions.find((definition) => definition.leaf === calleeName && (definition.parentTypeName === typeName || definition.symbol.includes(typeName)));
+  if (exact) {
+    return exact;
+  }
+  const normalizedType = normalizeLookupName(typeName);
+  const normalizedMatch = definitions.find((definition) => definition.leaf === calleeName && normalizeLookupName(definition.parentTypeName ?? "").includes(normalizedType));
+  if (normalizedMatch) {
+    return normalizedMatch;
+  }
+  return findLooseProjectDefinitionByTypeAndLeaf(db, typeName, calleeName);
+}
+function inferTypeNameFromReceiver(db, receiverName) {
+  const normalizedReceiver = normalizeLookupName(receiverName);
+  if (!normalizedReceiver) {
+    return null;
+  }
+  const candidates = getAllDefinitions(db).filter((definition) => definition.isTypeLike || definition.symbol.endsWith("#")).map((definition) => definition.leaf).filter((leaf) => leaf.length > 0);
+  let best = null;
+  for (const candidate of candidates) {
+    const normalizedCandidate = normalizeLookupName(candidate);
+    let score = 0;
+    if (normalizedCandidate === normalizedReceiver) score += 100;
+    if (normalizedCandidate.endsWith(normalizedReceiver)) score += 80;
+    if (normalizedCandidate.includes(normalizedReceiver)) score += 40;
+    if (normalizedReceiver.includes(normalizedCandidate)) score += 20;
+    if (score > 0 && (!best || score > best.score || score === best.score && candidate.length < best.name.length)) {
+      best = { name: candidate, score };
+    }
+  }
+  return best?.name ?? null;
+}
+function getSimpleSourceCalls(db, relativePath, startLine, endLine, opts = {}) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return [];
+  }
+  const lines = source.split("\n");
+  const scoped = lines.slice(startLine, endLine + 1);
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pattern = opts.allowInstanceVariables ? /(@?[A-Za-z_][\w]*)\s*(?:\.|::)\s*([A-Za-z_][\w!?=]*)\s*\(/g : /\b([A-Za-z_][\w]*)\s*(?:\.|::)\s*([A-Za-z_][\w]*)\s*\(/g;
+  for (let index = 0; index < scoped.length; index++) {
+    const rawLine = scoped[index] ?? "";
+    for (const match of rawLine.matchAll(pattern)) {
+      const receiverName = match[1];
+      const calleeName = match[2];
+      if (!receiverName || !calleeName) continue;
+      const key = `${startLine + index}|${receiverName}|${calleeName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      calls.push({
+        receiverName,
+        calleeName,
+        line: startLine + index
+      });
+    }
+    if (opts.allowBareMemberCalls) {
+      for (const match of rawLine.matchAll(/(@?[A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w!?=]*)\b(?!\s*[:=])/g)) {
+        const receiverName = match[1];
+        const calleeName = match[2];
+        if (!receiverName || !calleeName) continue;
+        const key = `${startLine + index}|${receiverName}|${calleeName}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        calls.push({
+          receiverName,
+          calleeName,
+          line: startLine + index
+        });
+      }
+    }
+    for (const match of rawLine.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      const prefix = rawLine.slice(0, start).trimEnd();
+      if (prefix.endsWith("def") || prefix.endsWith("fun") || prefix.endsWith("fn") || /\b(?:class|interface|trait|module|object)\s*$/.test(prefix)) {
+        continue;
+      }
+      if (rawLine.slice(Math.max(0, start - 3), start).includes(".")) {
+        continue;
+      }
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: startLine + index
+      });
+    }
+  }
+  return calls;
+}
+function parseJavaFieldBindings(source) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/\b(?:private|protected|public)\s+(?:final\s+)?([A-Z][A-Za-z0-9_$<>?, ]*)\s+([A-Za-z_][\w$]*)\s*;/g)) {
+    const typeName = stripGenericType(match[1]);
+    const localName = match[2];
+    if (typeName && localName) {
+      bindings.set(localName, typeName);
+    }
+  }
+  return bindings;
+}
+function parseKotlinFieldBindings(source) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/\b(?:private|protected|public)?\s*(?:val|var)\s+([A-Za-z_][\w]*)\s*:\s*([A-Z][A-Za-z0-9_.<>?]*)/g)) {
+    const localName = match[1];
+    const typeName = stripGenericType(match[2]);
+    if (typeName && localName) {
+      bindings.set(localName, typeName);
+    }
+  }
+  return bindings;
+}
+function parseCppReceiverBindings(source) {
+  const bindings = /* @__PURE__ */ new Map();
+  const constructorMatch = source.match(/RunCoordinator::RunCoordinator\s*\(([\s\S]*?)\)\s*(?::\s*([\s\S]*?))?\s*\{/);
+  if (!constructorMatch) {
+    return bindings;
+  }
+  const params = constructorMatch[1] ?? "";
+  const initializers = constructorMatch[2] ?? "";
+  const parameterTypes = /* @__PURE__ */ new Map();
+  for (const param of params.split(",")) {
+    const trimmed = param.trim();
+    const match = trimmed.match(/(.+?)\s+([A-Za-z_][\w]*)$/);
+    if (!match) continue;
+    const [, rawType, rawName] = match;
+    if (!rawType || !rawName) continue;
+    const typeName = stripGenericType(rawType.replace(/[&*]+/g, " ").replace(/\bconst\b/g, " ").trim());
+    if (!typeName) continue;
+    parameterTypes.set(normalizeReceiverName(rawName), typeName);
+  }
+  for (const initializer of initializers.split(",")) {
+    const trimmed = initializer.trim();
+    const match = trimmed.match(/([A-Za-z_][\w]*)\s*\(\s*([A-Za-z_][\w]*)\s*\)$/);
+    if (!match) continue;
+    const [, fieldName, sourceName] = match;
+    if (!fieldName || !sourceName) continue;
+    const typeName = parameterTypes.get(normalizeReceiverName(sourceName));
+    if (!typeName) continue;
+    bindings.set(normalizeReceiverName(fieldName), typeName);
+  }
+  return bindings;
+}
+function parseRubyReceiverBindings(db, source) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/@([A-Za-z_][\w]*)\s*=\s*([A-Za-z_][\w]*)/g)) {
+    const ivarName = `@${match[1]}`;
+    const localName = match[2];
+    const typeName = inferTypeNameFromReceiver(db, localName ?? match[1] ?? "");
+    if (typeName) {
+      bindings.set(ivarName, typeName);
+      bindings.set(match[1], typeName);
+    }
+  }
+  return bindings;
+}
+function stripGenericType(typeName) {
+  return (typeName ?? "").replace(/<.*$/, "").replace(/^.*\./, "").trim();
+}
+function normalizeReceiverName(receiverName) {
+  return receiverName.replace(/^@/, "").replace(/^this(?:\.|->)/, "").replace(/^_+/, "").replace(/_+$/, "").trim();
+}
+function normalizeLookupName(value) {
+  return value.replace(/[^A-Za-z0-9]+/g, "").toLowerCase();
+}
+function isLikelyTestPath(relativePath) {
+  return /(^|\/)(tests?|__tests__)\//.test(relativePath) || /\.(?:spec|test)\./.test(relativePath) || /_test\./.test(relativePath);
+}
 function findDefinitionByName(definitions, leaf, parentType, preference) {
   const candidates = definitions.filter((definition) => definition.leaf === leaf && definition.parentTypeName === parentType);
   if (candidates.length === 0) {
@@ -2570,6 +3970,58 @@ function findDefinitionByName(definitions, leaf, parentType, preference) {
   }
   return candidates[0] ?? null;
 }
+function findLooseProjectDefinitionByTypeAndLeaf(db, typeName, calleeName) {
+  const rows = db.all(
+    `SELECT
+      gs.id,
+      gs.symbol,
+      c.document_id,
+      MIN(c.start_line) AS start_line,
+      MAX(c.end_line) AS end_line,
+      d.relative_path,
+      gs.kind,
+      gs.documentation,
+      gs.enclosing_symbol
+     FROM global_symbols gs
+     JOIN mentions m ON m.symbol_id = gs.id
+     JOIN chunks c ON c.id = m.chunk_id
+     JOIN documents d ON d.id = c.document_id
+     WHERE gs.symbol LIKE ?
+       AND gs.symbol LIKE ?
+       ${db.pathExclusionsFor("d")}
+     GROUP BY gs.id, gs.symbol, c.document_id, d.relative_path, gs.kind, gs.documentation, gs.enclosing_symbol`,
+    `%${typeName}%`,
+    `%${calleeName}%`
+  );
+  const normalizedType = normalizeLookupName(typeName);
+  const candidates = rows.filter((row2) => leafName(row2.symbol) === calleeName).filter((row2) => {
+    const parentType = parentTypeName(row2.symbol);
+    return parentType === typeName || row2.symbol.includes(typeName) || normalizeLookupName(parentType ?? "").includes(normalizedType);
+  }).sort((left, right) => {
+    const leftTest = isLikelyTestPath(left.relative_path) ? 1 : 0;
+    const rightTest = isLikelyTestPath(right.relative_path) ? 1 : 0;
+    return leftTest - rightTest || left.relative_path.localeCompare(right.relative_path) || left.start_line - right.start_line;
+  });
+  const row = candidates[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path,
+    leaf: leafName(row.symbol),
+    parentTypeName: parentTypeName(row.symbol),
+    isFunctionLike: isFunctionLikeSymbol(row.symbol),
+    isTypeLike: leafSuffix(row.symbol) === "type",
+    kind: row.kind,
+    documentation: row.documentation,
+    enclosingSymbol: row.enclosing_symbol
+  };
+}
 function hasUniqueLeafDefinition(db, leaf, symbolId) {
   const rows = db.all(
     `SELECT id, symbol
@@ -2615,6 +4067,76 @@ function isJavaScriptDocument(db, relativePath) {
   );
   return row?.language === "typescript" || row?.language === "javascript" || /\.(?:[cm]?[jt]sx?)$/.test(relativePath);
 }
+function isJavaDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "java" || relativePath.endsWith(".java");
+}
+function isKotlinDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "kotlin" || relativePath.endsWith(".kt") || relativePath.endsWith(".kts");
+}
+function isScalaDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "scala" || relativePath.endsWith(".scala");
+}
+function isCSharpDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "C#" || relativePath.endsWith(".cs");
+}
+function isVisualBasicDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Visual Basic" || relativePath.endsWith(".vb");
+}
+function isCppDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "CPP" || /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/.test(relativePath);
+}
+function isRustDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Rust" || relativePath.endsWith(".rs");
+}
+function isRubyDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "ruby" || relativePath.endsWith(".rb");
+}
+function isDartDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "Dart" || relativePath.endsWith(".dart");
+}
+function isPhpDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "PHP" || relativePath.endsWith(".php");
+}
 function applyLimit(values, limit) {
   return typeof limit === "number" ? values.slice(0, limit) : values;
 }
@@ -2635,7 +4157,14 @@ function resolveDocumentCandidates(db, filePattern, opts) {
     score: scoreDocumentPath(row.relative_path, normalizedPattern)
   })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.relativePath.localeCompare(b.relativePath));
   if (scored.length === 0) {
-    return [];
+    const symbolMatch = findFirstSymbolMatch(db, filePattern);
+    if (!symbolMatch || db.isIgnored(symbolMatch.relativePath)) {
+      return [];
+    }
+    return [{
+      relativePath: symbolMatch.relativePath,
+      score: 700
+    }];
   }
   const exactish = scored.filter((row) => row.score >= 800);
   if (exactish.length > 0) {
@@ -2645,8 +4174,8 @@ function resolveDocumentCandidates(db, filePattern, opts) {
 }
 function scoreDocumentPath(relativePath, rawPattern) {
   const normalizedPath = normalizeLookupPath(relativePath);
-  const pathBase = basename(normalizedPath);
-  const patternBase = basename(rawPattern);
+  const pathBase = basename2(normalizedPath);
+  const patternBase = basename2(rawPattern);
   let score = 0;
   if (normalizedPath === rawPattern) score += 1200;
   if (normalizedPath.endsWith(`/${rawPattern}`)) score += 1100;
@@ -2674,62 +4203,69 @@ function symbols(db, filePattern) {
   if (resolvedPaths.length === 0) {
     return [];
   }
-  const placeholders = resolvedPaths.map(() => "?").join(", ");
-  const rows = db.all(
-    `SELECT
-      der.start_line,
-      der.end_line,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig,
-      gs.symbol,
-      d.relative_path
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path IN (${placeholders})
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
-    ORDER BY d.relative_path, der.start_line`,
-    ...resolvedPaths
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    signature: cleanSignature(r.sig)
-  }));
+  return resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((row) => !db.isIgnored(row.relativePath)).map((row) => {
+    const docRow = db.get(
+      `SELECT REPLACE(SUBSTR(documentation, INSTR(documentation, '|') + 1), char(10), ' ') AS sig
+         FROM global_symbols
+         WHERE id = ?`,
+      row.symbolId
+    );
+    return {
+      startLine: row.startLine,
+      endLine: row.endLine,
+      symbol: row.symbol,
+      shortName: shortenSymbol(row.symbol),
+      signature: cleanSignature(docRow?.sig ?? null)
+    };
+  });
 }
 
 // src/queries/methods.ts
+import { basename as basename3 } from "path";
 function methods(db, className) {
-  const rows = db.all(
-    `SELECT der.start_line, der.end_line, gs.symbol
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    WHERE gs.symbol LIKE ?
-      AND ${db.localSymbolPredicate}
-      AND gs.symbol LIKE '%().%'
-      ${db.symbolNoise}
-    ORDER BY der.start_line`,
-    `%${className}#%`
-  );
-  return rows.map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    name: leafName(r.symbol)
+  const classMatch = findFirstSymbolMatch(db, className);
+  if (!classMatch) {
+    return [];
+  }
+  const ownerName = leafName(classMatch.symbol);
+  const definitions = getDefinitionsForFile(db, classMatch.relativePath).filter((definition) => isCallableSymbol(definition.symbol));
+  const directMethods = definitions.filter((definition) => definition.parentTypeName === ownerName || definition.symbol.includes(ownerName));
+  const fileScopedMethods = directMethods.length > 0 ? directMethods : stripExtension(basename3(classMatch.relativePath)) === ownerName ? definitions.filter((definition) => definition.symbol.includes("<invalid-global-code>")) : [];
+  return fileScopedMethods.map((definition) => ({
+    startLine: definition.startLine,
+    endLine: definition.endLine,
+    name: leafName(definition.symbol)
   }));
 }
+function isCallableSymbol(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
+function stripExtension(relativePath) {
+  return relativePath.replace(/\.[^.]+$/, "");
+}
 
 // src/queries/refs.ts
 function refs(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
   if (match) {
+    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
+    const definitionRows = includeDefinitionSite ? [{
+      relativePath: match.relativePath,
+      line: match.startLine
+    }] : [];
     const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
       relativePath: site.file,
       line: site.line
     }));
     if (sourceSites.length > 0) {
-      return sourceSites;
+      const seen2 = /* @__PURE__ */ new Set();
+      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
+        const key = `${site.relativePath}:${site.line}`;
+        if (seen2.has(key)) return false;
+        seen2.add(key);
+        return true;
+      });
+      return rows2;
     }
   }
   const rows = db.all(
@@ -2744,10 +4280,70 @@ function refs(db, symbolPattern) {
     ORDER BY d.relative_path, c.start_line`,
     match?.symbolId ?? -1
   );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     relativePath: r.relative_path,
     line: r.start_line
   }));
+  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
+    return referenceRows;
+  }
+  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
+  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
+    referenceRows.unshift({
+      relativePath: match.relativePath,
+      line: match.startLine
+    });
+  }
+  for (const row of getRubySemanticRefs(db, match)) {
+    const key = `${row.relativePath}:${row.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    referenceRows.push(row);
+  }
+  return referenceRows;
+}
+function getRubySemanticRefs(db, match) {
+  if (!match.relativePath.endsWith(".rb")) {
+    return [];
+  }
+  const tokens = rubyReferenceTokens(match.symbol);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE '%.rb'
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const results = [];
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const source = getSourceText(db, row.relative_path);
+    if (!source) continue;
+    const lines = source.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      if (tokens.some((token) => new RegExp(`@${token}\\b|\\b${token}:`).test(line))) {
+        results.push({
+          relativePath: row.relative_path,
+          line: index
+        });
+      }
+    }
+  }
+  return results;
+}
+function rubyReferenceTokens(rawSymbol) {
+  const leaf = rawSymbol.split(":").pop() ?? rawSymbol;
+  const snake = leaf.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+  const parts = snake.split("_").filter(Boolean);
+  const candidates = /* @__PURE__ */ new Set();
+  if (snake) candidates.add(snake);
+  if (parts.length >= 1) candidates.add(parts[parts.length - 1]);
+  if (parts.length >= 2) candidates.add(parts.slice(-2).join("_"));
+  return [...candidates];
 }
 
 // src/queries/trace.ts
@@ -2756,24 +4352,22 @@ function trace(db, symbolPattern) {
   if (!match) {
     return { definitions: [], referencedBy: [] };
   }
-  const defRows = db.all(
-    `SELECT d.relative_path, der.start_line, der.end_line,
+  const definitionMeta = db.get(
+    `SELECT
       gs.display_name,
       REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
     FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
     WHERE gs.id = ?
-    ORDER BY d.relative_path, der.start_line
     LIMIT 10`,
     match.symbolId
   );
-  const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    signature: buildTraceSignature(r.sig, r.display_name, match.symbol)
-  }));
+  const definitions = db.isIgnored(match.relativePath) ? [] : [{
+    relativePath: match.relativePath,
+    startLine: match.startLine,
+    endLine: match.endLine,
+    signature: buildTraceSignature(definitionMeta?.sig ?? null, definitionMeta?.display_name ?? null, match.symbol),
+    source: definitionSource(db, match.relativePath, match.startLine, match.endLine)
+  }];
   const sourceSites = getSourceReferenceSites(db, match);
   const referencedBy = sourceSites.length > 0 ? sourceSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
     relativePath: site.file,
@@ -2806,6 +4400,15 @@ function trace(db, symbolPattern) {
   }));
   return { definitions, referencedBy };
 }
+function definitionSource(db, relativePath, startLine, endLine) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return null;
+  }
+  const lines = source.split("\n");
+  const slice2 = lines.slice(startLine, endLine + 1).join("\n").trimEnd();
+  return slice2.length > 0 ? slice2 : null;
+}
 function buildTraceSignature(signature, displayName, rawSymbol) {
   const cleaned = cleanSignature(signature);
   if (cleaned && !looksBogusSignature(cleaned)) {
@@ -2946,22 +4549,54 @@ function surface(db, modulePattern) {
     JOIN chunks c ON m.chunk_id = c.id
     JOIN documents d1 ON c.document_id = d1.id
     JOIN global_symbols gs ON m.symbol_id = gs.id
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d2 ON der.document_id = d2.id
-    WHERE d2.relative_path IN (${placeholders})
-      AND d1.relative_path NOT IN (${placeholders})
-      AND ${db.localSymbolPredicate}
+    WHERE d1.relative_path NOT IN (${placeholders})
+      AND (
+        EXISTS (
+          SELECT 1
+          FROM defn_enclosing_ranges der
+          JOIN documents d2 ON der.document_id = d2.id
+          WHERE der.symbol_id = gs.id
+            AND d2.relative_path IN (${placeholders})
+        )
+        OR EXISTS (
+          SELECT 1
+          FROM mentions def_m
+          JOIN chunks def_c ON def_m.chunk_id = def_c.id
+          JOIN documents d2 ON def_c.document_id = d2.id
+          WHERE def_m.symbol_id = gs.id
+            AND def_m.role = 1
+            AND d2.relative_path IN (${placeholders})
+        )
+      )
       AND m.role != 1
+      AND ${db.localSymbolPredicate}
+      ${db.pathExclusionsFor("d1")}
     ORDER BY d1.relative_path`,
     ...matchedPaths,
+    ...matchedPaths,
     ...matchedPaths
   );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+  const exposedDefinitions = matchedPaths.flatMap(
+    (relativePath) => getDefinitionsForFile(db, relativePath).filter((definition) => isCallableSymbol2(definition.symbol)).map((definition) => ({
+      relative_path: relativePath,
+      symbol: definition.symbol
+    }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return [...rows, ...exposedDefinitions].filter((r) => !db.isIgnored(r.relative_path)).filter((r) => {
+    const key = `${r.relative_path}|${r.symbol}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).map((r) => ({
     consumer: r.relative_path,
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol)
   }));
 }
+function isCallableSymbol2(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
 
 // src/entry-surfaces.ts
 var liveBarrelCache = /* @__PURE__ */ new WeakMap();
@@ -2979,11 +4614,11 @@ function isWorkerEntrySurface(path2) {
 function isStructuralEntrySurface(path2) {
   const normalized = normalizePath2(path2);
   const segments = normalized.split("/");
-  const basename2 = segments[segments.length - 1] ?? normalized;
-  if (basename2 === "cli.ts" || basename2 === "cli.js" || basename2 === "postinstall.ts" || basename2 === "postinstall.js" || basename2 === "main.ts" || basename2 === "main.js" || basename2 === "main.rs" || basename2 === "main.go" || basename2 === "main.py") {
+  const basename5 = segments[segments.length - 1] ?? normalized;
+  if (basename5 === "cli.ts" || basename5 === "cli.js" || basename5 === "postinstall.ts" || basename5 === "postinstall.js" || basename5 === "main.ts" || basename5 === "main.js" || basename5 === "main.rs" || basename5 === "main.go" || basename5 === "main.py") {
     return true;
   }
-  if (basename2 === "index.ts" || basename2 === "index.js") {
+  if (basename5 === "index.ts" || basename5 === "index.js") {
     return segments.length <= 2;
   }
   return normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
@@ -3046,62 +4681,49 @@ function dead(db, opts = {}) {
     skipBarrels = false,
     includeMembers = false
   } = opts;
-  const params = [minLoc];
-  let testFileExclusions = "";
-  let memberExclusion = "";
-  let barrelExclusions = "";
-  if (scope) {
-    params.push(`%${scope}%`);
-  }
-  if (!includeTests) {
-    testFileExclusions = `
-      AND ${testFileExclusionSql("d", TEST_SUPPORT_PATH_PATTERNS)}
-    `;
-  }
-  if (!includeMembers) {
-    memberExclusion = `AND gs.symbol NOT LIKE '%#%'`;
-  }
-  if (skipBarrels) {
-    const inactiveBarrelPaths = getInactiveBarrelPaths(db);
-    if (inactiveBarrelPaths.length > 0) {
-      barrelExclusions = `AND ref_d.relative_path NOT IN (${inactiveBarrelPaths.map(() => "?").join(", ")})`;
-      params.push(...inactiveBarrelPaths);
-    }
-  }
-  const sql = `
-    SELECT
+  const inactiveBarrelPaths = skipBarrels ? new Set(getInactiveBarrelPaths(db)) : /* @__PURE__ */ new Set();
+  const referenceRows = db.all(
+    `SELECT
+      m.symbol_id,
       d.relative_path,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      gs.symbol,
-      (SELECT COUNT(*) FROM mentions m2
-       JOIN chunks c2 ON m2.chunk_id = c2.id
-       WHERE m2.symbol_id = gs.id AND m2.role != 1 AND c2.document_id = d.id
-      ) AS same_file_refs
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scope ? "AND d.relative_path LIKE ?" : ""}
-      ${testFileExclusions}
-      ${memberExclusion}
-      AND NOT EXISTS (
-        SELECT 1
-        FROM mentions ref_m
-        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-        JOIN documents ref_d ON ref_c.document_id = ref_d.id
-        WHERE ref_m.symbol_id = gs.id
-          AND ref_m.role != 1
-          AND ref_d.id != d.id
-          ${barrelExclusions}
-      )
-    ORDER BY (der.end_line - der.start_line + 1) DESC, d.relative_path, der.start_line
-  `;
-  const rows = db.all(sql, ...params);
+      COUNT(*) AS ref_count
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.role != 1
+       ${db.pathExclusionsFor("d")}
+     GROUP BY m.symbol_id, d.relative_path`
+  );
+  const referencesBySymbol = /* @__PURE__ */ new Map();
+  for (const row of referenceRows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    if (inactiveBarrelPaths.has(row.relative_path)) continue;
+    let refsForSymbol = referencesBySymbol.get(row.symbol_id);
+    if (!refsForSymbol) {
+      refsForSymbol = /* @__PURE__ */ new Map();
+      referencesBySymbol.set(row.symbol_id, refsForSymbol);
+    }
+    refsForSymbol.set(row.relative_path, row.ref_count);
+  }
+  const definitions = getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isModuleLikeSymbol(definition.symbol)).filter((definition) => looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.isFunctionLike || !definition.enclosingSymbol || !looksValueLikeDefinition(definition.enclosingSymbol)).filter((definition) => includeTests || passesTestFileFilter(definition.relativePath)).filter((definition) => includeMembers || looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.endLine - definition.startLine + 1 >= minLoc);
+  const rows = definitions.map((definition) => {
+    const refMap = referencesBySymbol.get(definition.symbolId) ?? /* @__PURE__ */ new Map();
+    const sameFileRefs = refMap.get(definition.relativePath) ?? 0;
+    let crossFileRefs = 0;
+    for (const [relativePath, count] of refMap) {
+      if (relativePath === definition.relativePath) continue;
+      crossFileRefs += count;
+    }
+    return {
+      relative_path: definition.relativePath,
+      start_line: definition.startLine,
+      end_line: definition.endLine,
+      loc: definition.endLine - definition.startLine + 1,
+      symbol: definition.symbol,
+      same_file_refs: sameFileRefs,
+      cross_file_refs: crossFileRefs
+    };
+  }).filter((row) => row.cross_file_refs === 0).sort((a, b) => b.loc - a.loc || a.relative_path.localeCompare(b.relative_path) || a.start_line - b.start_line);
   let deadCodeCount = 0;
   let fileInternalCount = 0;
   let totalLoc = 0;
@@ -3129,6 +4751,17 @@ function dead(db, opts = {}) {
     totalLoc
   };
 }
+function passesTestFileFilter(relativePath) {
+  const patterns = [.../* @__PURE__ */ new Set([...TEST_FILE_PATTERNS, ...TEST_SUPPORT_PATH_PATTERNS])];
+  return patterns.every((pattern) => !likeMatches(relativePath, pattern));
+}
+function likeMatches(value, pattern) {
+  const regex = new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`);
+  return regex.test(value);
+}
+function looksValueLikeDefinition(rawSymbol) {
+  return isFunctionLikeSymbol(rawSymbol) || rawSymbol.endsWith("().") || rawSymbol.endsWith(".");
+}
 
 // src/queries/hotspots.ts
 function hotspots(db, opts = {}) {
@@ -3155,13 +4788,26 @@ function hotspots(db, opts = {}) {
     LIMIT ?`,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     refCount: r.ref_count,
     fileCount: r.file_count,
     definedIn: r.defined_in
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      refCount: callerRows.length,
+      fileCount: new Set(callerRows.map((row) => row.file)).size,
+      definedIn: definition.relativePath
+    };
+  }).filter((row) => row.refCount > 0).sort((left, right) => right.refCount - left.refCount || right.fileCount - left.fileCount).slice(0, limit);
 }
 
 // src/queries/imports.ts
@@ -3234,6 +4880,14 @@ function importedBy(db, symbolPattern) {
       if (targetFile && normalizePath3(entry.sourcePath) !== normalizePath3(targetFile)) {
         continue;
       }
+      if (entry.kind === "side-effect") {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (targetFile && isCLikeImporter(row.relative_path)) {
+        importers.add(row.relative_path);
+        continue;
+      }
       if (targetIsModule) {
         importers.add(row.relative_path);
         continue;
@@ -3307,6 +4961,9 @@ function renderImportSymbol(importedName, localName, kind) {
 function normalizePath3(path2) {
   return path2.replace(/\\/g, "/");
 }
+function isCLikeImporter(relativePath) {
+  return /\.(?:c|h|cc|cpp|cxx|hpp|hh|hxx)$/i.test(relativePath);
+}
 
 // src/queries/outline.ts
 function outline(db, filePattern) {
@@ -3411,10 +5068,22 @@ function fanOut(db, filePattern) {
     ORDER BY symbol_count DESC`,
     resolvedFile
   );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     name: r.relative_path,
     count: r.symbol_count
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const graph = buildFileDepGraph(db);
+  const deps2 = graph.get(resolvedFile);
+  if (!deps2 || deps2.size === 0) {
+    return [];
+  }
+  return [{
+    name: resolvedFile,
+    count: deps2.size
+  }];
 }
 function topFanIn(db, opts = {}) {
   const { limit = 30, scope } = opts;
@@ -3633,7 +5302,7 @@ function bottlenecks(db, opts = {}) {
     minFanOut,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     fanIn: r.fan_in,
@@ -3641,51 +5310,42 @@ function bottlenecks(db, opts = {}) {
     score: r.fan_in * r.fan_out,
     definedIn: r.defined_in
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const fanIn2 = new Set(
+      getCallerRowsForSymbol(db, definition, { limit: 500 }).map((row) => row.file)
+    ).size;
+    const fanOut2 = new Set(
+      getCalleeRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
+    ).size;
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      fanIn: fanIn2,
+      fanOut: fanOut2,
+      score: fanIn2 * fanOut2,
+      definedIn: definition.relativePath
+    };
+  }).filter((row) => row.fanIn >= minFanIn && row.fanOut >= minFanOut).sort((left, right) => right.score - left.score || right.fanIn - left.fanIn).slice(0, limit);
 }
 
 // src/queries/isolated.ts
 function isolated(db, opts = {}) {
   const { scope, minLoc = 3 } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      gs.symbol,
-      d.relative_path,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      AND ${testFileExclusionSql("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND gs.symbol NOT LIKE '%#%'
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}
-      -- No cross-file references TO this symbol
-      AND NOT EXISTS (
-        SELECT 1 FROM mentions m
-        JOIN chunks c ON m.chunk_id = c.id
-        WHERE m.symbol_id = gs.id AND m.role != 1 AND c.document_id != d.id
-      )
-      -- No same-file references either
-      AND NOT EXISTS (
-        SELECT 1 FROM mentions m
-        JOIN chunks c ON m.chunk_id = c.id
-        WHERE m.symbol_id = gs.id AND m.role != 1 AND c.document_id = d.id
-      )
-    ORDER BY loc DESC, d.relative_path`,
-    minLoc
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).filter((r) => !isEntrySurface(db, r.relative_path)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    loc: r.loc
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isEntrySurface(db, definition.relativePath)).filter((definition) => definition.isFunctionLike).map((definition) => ({
+    definition,
+    loc: definition.endLine - definition.startLine + 1
+  })).filter((entry) => entry.loc >= minLoc).filter((entry) => getCallerRowsForSymbol(db, entry.definition, { limit: 1 }).length === 0).filter((entry) => getCalleeRowsForSymbol(db, entry.definition, { limit: 1 }).length === 0).sort(
+    (left, right) => right.loc - left.loc || left.definition.relativePath.localeCompare(right.definition.relativePath) || left.definition.startLine - right.definition.startLine
+  ).map((entry) => ({
+    symbol: entry.definition.symbol,
+    shortName: shortenSymbol(entry.definition.symbol),
+    relativePath: entry.definition.relativePath,
+    startLine: entry.definition.startLine,
+    endLine: entry.definition.endLine,
+    loc: entry.loc
   }));
 }
 
@@ -3828,24 +5488,18 @@ function kindCounts(db, opts = {}) {
   }));
 }
 function loadKindRows(db, scope) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT
-      gs.symbol,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol,
-      d.relative_path,
-      der.start_line,
-      der.end_line
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${scopeFilter}
-    ORDER BY d.relative_path, der.start_line`
-  ).filter((row) => !db.isIgnored(row.relative_path));
+  return getAllDefinitions(db, { scope }).map(mapDefinitionToKindRow);
+}
+function mapDefinitionToKindRow(definition) {
+  return {
+    symbol: definition.symbol,
+    kind: definition.kind,
+    documentation: definition.documentation,
+    enclosing_symbol: definition.enclosingSymbol,
+    relative_path: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine
+  };
 }
 function resolveKindNumber(row) {
   if (row.kind !== null && row.kind !== 0) {
@@ -4027,7 +5681,7 @@ function uniqueRows(rows) {
 function similar(db, symbolPattern, opts = {}) {
   const { minSimilarity = 0.4, limit = 20 } = opts;
   const target = findCallees(db, symbolPattern);
-  if (!target || target.callees.size === 0) return [];
+  if (!target) return [];
   if (!isFunctionLikeSymbol(target.symbol)) return [];
   const candidates = getAllCalleeFingerprints(db, {
     minCallees: 3,
@@ -4038,7 +5692,7 @@ function similar(db, symbolPattern, opts = {}) {
   const results = [];
   for (const candidate of candidates) {
     if (candidate.callees.size < 3) continue;
-    const { similarity, significantShared, trivialShared } = weightedSimilarity(
+    const { similarity, significantShared } = weightedSimilarity(
       target.callees,
       candidate.callees,
       idfWeights
@@ -4059,7 +5713,10 @@ function similar(db, symbolPattern, opts = {}) {
     });
   }
   results.sort((a, b) => b.similarity - a.similarity);
-  return results.slice(0, limit);
+  if (results.length > 0) {
+    return results.slice(0, limit);
+  }
+  return similarBySourceShape(db, symbolPattern, { minSimilarity, limit });
 }
 function similarAll(db, opts = {}) {
   const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4 } = opts;
@@ -4206,10 +5863,146 @@ function difference(a, b) {
   }
   return result;
 }
+function similarBySourceShape(db, symbolPattern, opts) {
+  const target = findSourceFingerprint(db, symbolPattern);
+  if (!target || target.tokens.size < 3) {
+    return [];
+  }
+  const minSimilarity = opts.minSimilarity >= 0.5 ? opts.minSimilarity : 0.3;
+  const results = [];
+  for (const candidate of getAllSourceFingerprints(db)) {
+    if (candidate.symbol === target.symbol || candidate.tokens.size < 3) continue;
+    const shared = intersection(target.tokens, candidate.tokens);
+    if (shared.size < 2) continue;
+    const union = /* @__PURE__ */ new Set([...target.tokens, ...candidate.tokens]);
+    const similarity = union.size > 0 ? shared.size / union.size : 0;
+    if (similarity < minSimilarity) continue;
+    results.push({
+      symbolA: target.symbol,
+      shortNameA: shortenSymbol(target.symbol),
+      fileA: target.file,
+      symbolB: candidate.symbol,
+      shortNameB: shortenSymbol(candidate.symbol),
+      fileB: candidate.file,
+      similarity,
+      sharedCallees: [...shared].sort(),
+      uniqueToA: [...difference(target.tokens, candidate.tokens)].sort(),
+      uniqueToB: [...difference(candidate.tokens, target.tokens)].sort()
+    });
+  }
+  results.sort((a, b) => b.similarity - a.similarity || a.shortNameB.localeCompare(b.shortNameB));
+  return results.slice(0, opts.limit);
+}
+function findSourceFingerprint(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match || !isFunctionLikeSymbol(match.symbol)) {
+    return null;
+  }
+  const snippet = definitionSnippet(db, match.relativePath, match.startLine, match.endLine, leafName(match.symbol));
+  const tokens = sourceTokens(snippet, leafName(match.symbol));
+  if (tokens.size === 0) {
+    return null;
+  }
+  return {
+    symbol: match.symbol,
+    file: match.relativePath,
+    tokens
+  };
+}
+function getAllSourceFingerprints(db) {
+  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    tokens: sourceTokens(
+      definitionSnippet(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+      definition.leaf
+    )
+  })).filter((fingerprint) => fingerprint.tokens.size > 0);
+}
+function definitionSnippet(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return "";
+  }
+  const lines = source.split("\n");
+  if (endLine >= startLine && endLine - startLine <= 12) {
+    return lines.slice(startLine, endLine + 1).join("\n");
+  }
+  const markerPatterns = [
+    new RegExp(`\\bdef\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfun\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfn\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfunction\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\b${escapeRegex3(leaf)}\\s*\\(`)
+  ];
+  const definitionStart = lines.findIndex((line) => markerPatterns.some((pattern) => pattern.test(line)));
+  if (definitionStart >= 0) {
+    let definitionEnd = definitionStart;
+    for (let index = definitionStart + 1; index < lines.length && index <= definitionStart + 8; index++) {
+      const line = lines[index] ?? "";
+      if (index > definitionStart && looksLikeDefinitionBoundary(line)) {
+        break;
+      }
+      definitionEnd = index;
+      if (line.trim() === "" && index > definitionStart + 1) {
+        break;
+      }
+    }
+    return lines.slice(definitionStart, definitionEnd + 1).join("\n");
+  }
+  return lines.slice(startLine, Math.min(lines.length, startLine + 8)).join("\n");
+}
+function sourceTokens(snippet, leaf) {
+  if (!snippet) {
+    return /* @__PURE__ */ new Set();
+  }
+  const stopWords = /* @__PURE__ */ new Set([
+    "public",
+    "private",
+    "protected",
+    "final",
+    "static",
+    "class",
+    "def",
+    "fun",
+    "fn",
+    "function",
+    "return",
+    "string",
+    "bool",
+    "boolean",
+    "void",
+    "unit",
+    "self",
+    "this",
+    "new",
+    "const",
+    "let",
+    "var",
+    "end",
+    "pub"
+  ]);
+  const normalizedLeafParts = splitIdentifier(leaf);
+  const normalized = snippet.replace(/["'`]/g, " ").replace(/\b\d+\b/g, " NUM ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9_]+/g, " ").replace(/_/g, " ").toLowerCase();
+  const tokens = normalized.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 1).filter((token) => !stopWords.has(token)).filter((token) => !normalizedLeafParts.has(token));
+  return new Set(tokens);
+}
+function splitIdentifier(value) {
+  return new Set(
+    value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9_]+|_/).map((part) => part.toLowerCase()).filter((part) => part.length > 1)
+  );
+}
+function looksLikeDefinitionBoundary(line) {
+  return /^\s*(?:def|fun|fn|function|class|trait|module|object|enum|interface|public|private|protected)\b/.test(line);
+}
+function escapeRegex3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/queries/similar-files.ts
 function similarFiles(db, opts = {}) {
-  const { minSimilarity = 0.5, limit = 20, scope, minDeps = 3, filePattern } = opts;
+  const { minSimilarity = 0.5, limit = 20, scope, filePattern } = opts;
+  const minDeps = opts.minDeps ?? (filePattern ? 1 : 3);
   const profiles = buildFileProfiles(db, { scope, minDeps });
   const results = [];
   if (filePattern) {
@@ -4258,7 +6051,7 @@ function findUniversalDependencies(depMap) {
     }
   }
   for (const [dep, count] of depCounts) {
-    if (count / fileCount > 0.5) {
+    if (count >= 6 && count / fileCount > 0.8) {
       universalDeps.add(dep);
     }
   }
@@ -4317,8 +6110,8 @@ function similarChains(db, opts = {}) {
       tailFreq.set(chain[t], (tailFreq.get(chain[t]) ?? 0) + 1);
     }
   }
-  const infraThreshold = rawChains.length * 0.4;
-  const tailThreshold = rawChains.length * 0.3;
+  const infraThreshold = rawChains.length * 0.9;
+  const tailThreshold = rawChains.length * 0.8;
   const infraNodes = /* @__PURE__ */ new Set();
   for (const [node, freq] of nodeFreq) {
     if (freq > infraThreshold) infraNodes.add(node);
@@ -4328,13 +6121,13 @@ function similarChains(db, opts = {}) {
   }
   const structuralNames = ["index.ts", "index.js", "cli.ts", "main.ts", "health.ts", "health.js"];
   for (const node of nodeFreq.keys()) {
-    const basename2 = node.split("/").pop() ?? "";
-    if (structuralNames.includes(basename2)) infraNodes.add(node);
+    const basename5 = node.split("/").pop() ?? "";
+    if (structuralNames.includes(basename5)) infraNodes.add(node);
   }
   const filteredChains = [];
   for (const chain of rawChains) {
     const filtered = chain.filter((n) => !infraNodes.has(n));
-    if (filtered.length >= 3) {
+    if (filtered.length >= 2) {
       filteredChains.push({ original: chain, filtered });
     }
   }
@@ -4499,31 +6292,13 @@ function isSubChain(sub, full) {
 // src/queries/extract-candidates.ts
 function extractCandidates(db, opts = {}) {
   const { scope, minLoc = 10, minCallees = 6, limit = 20 } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const symbols2 = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}
-    ORDER BY (der.end_line - der.start_line + 1) DESC`,
-    minLoc
-  );
+  const symbols2 = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) >= minLoc && isFunctionLikeSymbol(definition.symbol)).sort((left, right) => definitionLoc(right) - definitionLoc(left));
   const results = [];
   for (const sym of symbols2) {
-    if (db.isIgnored(sym.relative_path)) continue;
-    const basename2 = sym.relative_path.split("/").pop() ?? "";
-    if (basename2.includes("types")) continue;
-    const calleeChunks = getCalleeRowsForSymbol(db, {
-      documentId: sym.document_id,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      symbolId: sym.id
-    });
+    if (db.isIgnored(sym.relativePath)) continue;
+    const basename5 = sym.relativePath.split("/").pop() ?? "";
+    if (basename5.includes("types")) continue;
+    const calleeChunks = getCalleeRowsForSymbol(db, sym);
     const calleeSet = new Set(calleeChunks.map((c) => c.symbol));
     if (calleeSet.size < minCallees) continue;
     const cooccurrence = /* @__PURE__ */ new Map();
@@ -4586,10 +6361,10 @@ function extractCandidates(db, opts = {}) {
       results.push({
         symbol: sym.symbol,
         shortName: shortenSymbol(sym.symbol),
-        relativePath: sym.relative_path,
-        startLine: sym.start_line,
-        endLine: sym.end_line,
-        loc: sym.end_line - sym.start_line + 1,
+        relativePath: sym.relativePath,
+        startLine: sym.startLine,
+        endLine: sym.endLine,
+        loc: definitionLoc(sym),
         totalCallees: calleeSet.size,
         clusters: scoredClusters
       });
@@ -4598,6 +6373,20 @@ function extractCandidates(db, opts = {}) {
   results.sort((a, b) => b.clusters.length - a.clusters.length || b.loc - a.loc);
   return results.slice(0, limit);
 }
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
 
 // src/queries/affected.ts
 function affected(db, symbolPattern, opts = {}) {
@@ -4638,73 +6427,39 @@ function affected(db, symbolPattern, opts = {}) {
   return results;
 }
 function getDirectAffectedRows(db, target, scope) {
-  const sourceSites = getSourceReferenceSites(db, target).filter((site) => !db.isIgnored(site.file)).filter((site) => !scope || site.file.includes(scope));
-  if (sourceSites.length > 0) {
-    const rows2 = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const site of sourceSites) {
-      if (!site.enclosingSymbol || site.enclosingSymbol === target.symbol) {
-        const key2 = `${site.file}|(top-level)`;
-        if (seen.has(key2)) continue;
-        seen.add(key2);
-        rows2.push({
-          symbolId: null,
-          symbol: site.file,
-          shortName: "(top-level)",
-          file: site.file,
-          symbolMatch: null
-        });
-        continue;
-      }
-      const enclosing = findExactSymbolMatch(db, site.enclosingSymbol);
-      if (!enclosing || enclosing.symbolId === target.symbolId || db.isIgnored(enclosing.relativePath)) {
-        continue;
-      }
-      const key = `${enclosing.symbolId}|${enclosing.relativePath}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      rows2.push({
-        symbolId: enclosing.symbolId,
-        symbol: enclosing.symbol,
-        shortName: shortenSymbol(enclosing.symbol),
-        file: enclosing.relativePath,
-        symbolMatch: enclosing
+  const callerRows = getCallerRowsForSymbol(db, target, { limit: 500 }).filter((row) => !db.isIgnored(row.file)).filter((row) => !scope || row.file.includes(scope));
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of callerRows) {
+    const match = findExactSymbolMatch(db, row.symbol);
+    if (!match) {
+      const key2 = `${row.file}|${row.symbol}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      results.push({
+        symbolId: null,
+        symbol: row.symbol,
+        shortName: shortenSymbol(row.symbol),
+        file: row.file,
+        symbolMatch: null
       });
+      continue;
     }
-    return rows2;
-  }
-  const rows = db.all(
-    `SELECT DISTINCT
-      enc_gs.id AS symbol_id,
-      enc_gs.symbol AS symbol,
-      enc_d.relative_path AS relative_path
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents ref_d ON c.document_id = ref_d.id
-    JOIN defn_enclosing_ranges enc_der
-      ON enc_der.document_id = ref_d.id
-      AND c.start_line >= enc_der.start_line
-      AND c.end_line <= enc_der.end_line
-    JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-    JOIN documents enc_d ON enc_der.document_id = enc_d.id
-    WHERE m.symbol_id = ?
-      AND m.role != 1
-      AND enc_gs.id != ?
-      ${db.symbolNoiseFor("enc_gs")}
-      ${db.pathExclusionsFor("enc_d")}
-      ${scope ? `AND enc_d.relative_path LIKE '%${scope}%'` : ""}
-    ORDER BY enc_d.relative_path
-    LIMIT 1`,
-    target.symbolId,
-    target.symbolId
-  );
-  return rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
-    symbolId: row.symbol_id,
-    symbol: row.symbol,
-    shortName: shortenSymbol(row.symbol),
-    file: row.relative_path,
-    symbolMatch: findExactSymbolMatch(db, row.symbol)
-  }));
+    if (match.symbolId === target.symbolId || db.isIgnored(match.relativePath)) {
+      continue;
+    }
+    const key = `${match.symbolId}|${match.relativePath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      symbolId: match.symbolId,
+      symbol: match.symbol,
+      shortName: shortenSymbol(match.symbol),
+      file: match.relativePath,
+      symbolMatch: match
+    });
+  }
+  return results;
 }
 
 // src/queries/change-surface.ts
@@ -5054,140 +6809,129 @@ function isLikelyTypeOnlyDep(dep) {
 function shouldSkipDriftFile(filePath) {
   return isStructuralRole(path.basename(filePath)) || isTestLikePath(filePath);
 }
-function isStructuralRole(basename2) {
-  if (basename2 === "index.ts" || basename2 === "index.js") return true;
-  if (basename2 === "cli.ts" || basename2 === "main.ts" || basename2 === "main.rs") return true;
-  if (basename2.includes("worker.") || basename2.includes("postinstall.")) return true;
-  if (basename2 === "health.ts" || basename2 === "health.js") return true;
+function isStructuralRole(basename5) {
+  if (basename5 === "index.ts" || basename5 === "index.js") return true;
+  if (basename5 === "cli.ts" || basename5 === "main.ts" || basename5 === "main.rs") return true;
+  if (basename5.includes("worker.") || basename5.includes("postinstall.")) return true;
+  if (basename5 === "health.ts" || basename5 === "health.js") return true;
   return false;
 }
 function isTestLikePath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const basename2 = path.basename(normalized);
-  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename2) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename2) || /^test[_-]/.test(basename2) || /^test\./.test(basename2);
+  const basename5 = path.basename(normalized);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename5) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename5) || /^test[_-]/.test(basename5) || /^test\./.test(basename5);
 }
 
 // src/queries/wrapper-candidates.ts
+import { basename as basename4, extname as extname3 } from "path";
 function wrapperCandidates(db, opts) {
   const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT * FROM (
-      SELECT
-        gs.symbol,
-        d.relative_path AS file,
-        der.start_line,
-        der.end_line,
-        (der.end_line - der.start_line + 1) AS loc,
-        -- The single caller: the symbol whose definition range contains
-        -- the chunk that references our target
-        (SELECT caller_gs.symbol
-         FROM mentions ref_m
-         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-         JOIN defn_enclosing_ranges caller_der
-           ON caller_der.document_id = ref_c.document_id
-           AND ref_c.start_line >= caller_der.start_line
-           AND ref_c.end_line <= caller_der.end_line
-         JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
-         WHERE ref_m.symbol_id = gs.id
-           AND ref_m.role != 1
-           AND ref_c.document_id != der.document_id
-         LIMIT 1
-        ) AS caller_symbol,
-        -- Fan-in of that single caller
-        (SELECT COUNT(DISTINCT caller_ref_c.document_id)
-         FROM mentions caller_ref_m
-         JOIN chunks caller_ref_c ON caller_ref_m.chunk_id = caller_ref_c.id
-         WHERE caller_ref_m.symbol_id = (
-           SELECT caller_der2.symbol_id
-           FROM mentions ref_m2
-           JOIN chunks ref_c2 ON ref_m2.chunk_id = ref_c2.id
-           JOIN defn_enclosing_ranges caller_der2
-             ON caller_der2.document_id = ref_c2.document_id
-             AND ref_c2.start_line >= caller_der2.start_line
-             AND ref_c2.end_line <= caller_der2.end_line
-           WHERE ref_m2.symbol_id = gs.id
-             AND ref_m2.role != 1
-             AND ref_c2.document_id != der.document_id
-           LIMIT 1
-         )
-         AND caller_ref_m.role != 1
-        ) AS caller_fan_in
-      FROM global_symbols gs
-      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-      JOIN documents d ON der.document_id = d.id
-      WHERE 1 = 1
-        ${db.pathExclusionsFor("d")}
-        AND ${testFileExclusionSql("d")}
-        ${db.symbolNoiseFor("gs")}
-        -- Only functions/terms, not type definitions (types with # are not wrappers)
-        AND gs.symbol NOT LIKE '%#'
-        AND (der.end_line - der.start_line + 1) <= ?
-        AND (der.end_line - der.start_line + 1) >= 2
-        ${scopeFilter}
-        -- Exactly 1 cross-file consumer
-        AND (
-          SELECT COUNT(DISTINCT ref_c.document_id)
-          FROM mentions ref_m
-          JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-          WHERE ref_m.symbol_id = gs.id
-            AND ref_m.role != 1
-            AND ref_c.document_id != der.document_id
-        ) = 1
-    ) WHERE caller_symbol IS NOT NULL AND caller_fan_in > 3
-    ORDER BY caller_fan_in DESC, loc DESC
-    LIMIT ?`,
-    maxLoc,
-    limit
-  );
-  return rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    file: r.file,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    loc: r.loc,
-    singleCaller: r.caller_symbol,
-    singleCallerShort: shortenSymbol(r.caller_symbol),
-    callerFanIn: r.caller_fan_in
-  }));
+  const reverseFanIn = buildReverseFileFanIn(buildFileDepGraph(db, scope));
+  const symbols2 = getScopedDefinitions2(db, scope).filter((definition) => definitionLoc2(definition) <= maxLoc && definitionLoc2(definition) >= 2);
+  const results = [];
+  for (const symbol of symbols2) {
+    if (db.isIgnored(symbol.relativePath) || !isFunctionLikeSymbol(symbol.symbol)) continue;
+    const symbolStem = basename4(symbol.relativePath, extname3(symbol.relativePath));
+    const callerRows = dedupeRows(
+      getCallerRowsForSymbol(db, symbol, { limit: 200 }).filter((row) => row.file !== symbol.relativePath)
+    ).filter((row) => basename4(row.file, extname3(row.file)) !== symbolStem);
+    if (callerRows.length !== 1) continue;
+    const caller = callerRows[0];
+    const callerDefinition = getDefinitionsForFile(db, caller.file).find((definition) => definition.symbol === caller.symbol);
+    const useDefinitionFanIn = callerDefinition?.isFunctionLike ?? false;
+    let callerFanIn;
+    if (useDefinitionFanIn && callerDefinition) {
+      callerFanIn = new Set(
+        getCallerRowsForSymbol(db, callerDefinition, { limit: 500 }).filter((row) => row.file !== callerDefinition.relativePath).map((row) => row.file)
+      ).size;
+    } else {
+      callerFanIn = fallbackCallerFanIn(db, reverseFanIn, caller.file);
+    }
+    if (callerFanIn <= 3) continue;
+    results.push({
+      symbol: symbol.symbol,
+      shortName: shortenSymbol(symbol.symbol),
+      file: symbol.relativePath,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine,
+      loc: definitionLoc2(symbol),
+      singleCaller: caller.symbol,
+      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename4(caller.file),
+      callerFanIn
+    });
+  }
+  results.sort((left, right) => right.callerFanIn - left.callerFanIn || right.loc - left.loc);
+  return results.slice(0, limit);
+}
+function definitionLoc2(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+function getScopedDefinitions2(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
+function buildReverseFileFanIn(graph) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [fromFile, deps2] of graph) {
+    if (!reverse.has(fromFile)) {
+      reverse.set(fromFile, reverse.get(fromFile) ?? 0);
+    }
+    for (const dep of deps2) {
+      reverse.set(dep, (reverse.get(dep) ?? 0) + 1);
+    }
+  }
+  return reverse;
+}
+function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
+  const functionLikeFanIn = getDefinitionsForFile(db, callerFile).filter((definition) => definition.isFunctionLike).map((definition) => new Set(
+    getCallerRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => row.file)
+  ).size).sort((left, right) => right - left)[0] ?? 0;
+  if (functionLikeFanIn > 0) {
+    return functionLikeFanIn;
+  }
+  const direct = reverseFanIn.get(callerFile) ?? 0;
+  if (direct > 0) {
+    return direct;
+  }
+  const stem = basename4(callerFile, extname3(callerFile));
+  let best = 0;
+  for (const [file, fanIn2] of reverseFanIn) {
+    if (file === callerFile) continue;
+    if (basename4(file, extname3(file)) !== stem) continue;
+    if (fanIn2 > best) {
+      best = fanIn2;
+    }
+  }
+  return best;
 }
 
 // src/queries/passthrough-candidates.ts
 function passthroughCandidates(db, opts) {
   const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const symbols2 = db.all(
-    `SELECT
-      gs.id,
-      gs.symbol,
-      der.document_id,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      d.relative_path
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      AND ${testFileExclusionSql("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= 3
-      AND (der.end_line - der.start_line + 1) <= ?
-      ${scopeFilter}
-    ORDER BY d.relative_path`,
-    maxLoc
-  );
+  const symbols2 = getScopedDefinitions3(db, scope).filter((definition) => definitionLoc3(definition) >= 3 && definitionLoc3(definition) <= maxLoc);
   const results = [];
   for (const sym of symbols2) {
-    if (db.isIgnored(sym.relative_path)) continue;
-    const callees = getCalleeRowsForSymbol(db, {
-      documentId: sym.document_id,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      symbolId: sym.id
-    });
+    if (db.isIgnored(sym.relativePath) || !isFunctionLikeSymbol(sym.symbol)) continue;
+    const rawCallees = getCalleeRowsForSymbol(db, sym);
+    const callees = rawCallees.some((callee2) => isFunctionLikeSymbol(callee2.symbol)) ? rawCallees.filter((callee2) => isFunctionLikeSymbol(callee2.symbol)) : rawCallees;
     const uniqueCallees = /* @__PURE__ */ new Map();
     for (const c of callees) {
       if (!uniqueCallees.has(c.symbol)) {
@@ -5199,10 +6943,10 @@ function passthroughCandidates(db, opts) {
     results.push({
       symbol: sym.symbol,
       shortName: shortenSymbol(sym.symbol),
-      file: sym.relative_path,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      loc: sym.loc,
+      file: sym.relativePath,
+      startLine: sym.startLine,
+      endLine: sym.endLine,
+      loc: definitionLoc3(sym),
       forwardsTo: callee.symbol,
       forwardsToShort: shortenSymbol(callee.symbol),
       forwardsToFile: callee.file
@@ -5211,42 +6955,32 @@ function passthroughCandidates(db, opts) {
   results.sort((a, b) => a.loc - b.loc || a.file.localeCompare(b.file));
   return results.slice(0, limit);
 }
+function getScopedDefinitions3(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function definitionLoc3(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
 
 // src/queries/stale-abstractions.ts
 function staleAbstractions(db, opts) {
   const { scope, minLoc = 3, limit = 30 } = opts ?? {};
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT * FROM (
-      SELECT
-        gs.symbol,
-        d.relative_path AS file,
-        der.start_line,
-        der.end_line,
-        (der.end_line - der.start_line + 1) AS loc,
-        (SELECT COUNT(DISTINCT ref_c.document_id)
-         FROM mentions ref_m
-         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-         WHERE ref_m.symbol_id = gs.id
-           AND ref_m.role != 1
-           AND ref_c.document_id != der.document_id
-        ) AS consumers
-      FROM global_symbols gs
-      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-      JOIN documents d ON der.document_id = d.id
-      WHERE 1 = 1
-        ${db.pathExclusionsFor("d")}
-        AND ${testFileExclusionSql("d")}
-        ${db.symbolNoiseFor("gs")}
-        -- Top-level type symbols: ends with # but does not contain nested #
-        AND gs.symbol LIKE '%#'
-        AND gs.symbol NOT LIKE '%#%#%'
-        AND (der.end_line - der.start_line + 1) >= ?
-        ${scopeFilter}
-    ) WHERE consumers <= 1
-    ORDER BY loc DESC, file ASC, start_line ASC`,
-    minLoc
-  );
+  const rows = getScopedDefinitions4(db, scope).filter((definition) => definition.isTypeLike && definitionLoc4(definition) >= minLoc).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine,
+    loc: definitionLoc4(definition),
+    consumers: countCrossFileConsumers(db, definition)
+  })).filter((row) => row.consumers <= 1).sort((left, right) => right.loc - left.loc || left.file.localeCompare(right.file) || left.start_line - right.start_line);
   const filesWithFunctions = getFilesWithFunctions(db, scope);
   return rows.filter((r) => !db.isIgnored(r.file)).filter((r) => isTrueStaleAbstraction(r, filesWithFunctions)).map((r) => ({
     symbol: r.symbol,
@@ -5259,22 +6993,11 @@ function staleAbstractions(db, opts) {
   })).slice(0, limit);
 }
 function getFilesWithFunctions(db, scope) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  return new Set(
-    db.all(
-      `SELECT DISTINCT d.relative_path
-       FROM global_symbols gs
-       JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-       JOIN documents d ON der.document_id = d.id
-       WHERE gs.symbol LIKE '%().'
-         ${db.pathExclusionsFor("d")}
-         ${scopeFilter}`
-    ).map((row) => row.relative_path).filter((path2) => !db.isIgnored(path2))
-  );
+  return new Set(getScopedDefinitions4(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
 }
 function isTrueStaleAbstraction(row, filesWithFunctions) {
-  const basename2 = row.file.split("/").pop() ?? "";
-  const isTypeFile = basename2.includes("types") || row.file.includes("/types/");
+  const basename5 = row.file.split("/").pop() ?? "";
+  const isTypeFile = basename5.includes("types") || row.file.includes("/types/");
   if (isTypeFile && row.consumers > 0) {
     return false;
   }
@@ -5283,6 +7006,33 @@ function isTrueStaleAbstraction(row, filesWithFunctions) {
   }
   return true;
 }
+function getScopedDefinitions4(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function countCrossFileConsumers(db, definition) {
+  const callers = db.all(
+    `SELECT DISTINCT d.relative_path
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("d")}`,
+    definition.symbolId
+  ).map((row) => row.relative_path).filter((relativePath) => relativePath !== definition.relativePath && !db.isIgnored(relativePath));
+  return new Set(callers).size;
+}
+function definitionLoc4(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
 
 // src/queries/complexity-hotspots.ts
 function complexityHotspots(db, opts) {
@@ -5359,7 +7109,7 @@ function complexityHotspots(db, opts) {
     minLoc,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     file: r.file,
@@ -5373,6 +7123,31 @@ function complexityHotspots(db, opts) {
       r.loc / 50 * (r.fan_in / 5) * Math.max(r.fan_out / 5, 1) * 100
     ) / 100
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const loc = definition.endLine - definition.startLine + 1;
+    const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
+    const calleeRows = getCalleeRowsForSymbol(db, definition, { limit: 500 });
+    const fanIn2 = new Set(callerRows.map((row) => row.file)).size;
+    const fanOut2 = new Set(
+      calleeRows.filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
+    ).size;
+    const calleeCount = new Set(calleeRows.map((row) => `${row.symbol}|${row.file}`)).size;
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc,
+      fanIn: fanIn2,
+      fanOut: fanOut2,
+      calleeCount,
+      score: Math.round(loc / 50 * (fanIn2 / 5) * Math.max(fanOut2 / 5, 1) * 100) / 100
+    };
+  }).filter((row) => row.loc >= minLoc).sort((left, right) => right.score - left.score || right.loc - left.loc).slice(0, limit);
 }
 
 // src/queries/health.ts
@@ -5620,8 +7395,8 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 }
 
 // src/queries/code.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join9 } from "path";
 function code(db, symbolPattern, opts = {}) {
   const { context = 0 } = opts;
   const fileLineMatch = symbolPattern.match(/^(.+\.\w+):(\d+)-(\d+)$/);
@@ -5634,10 +7409,10 @@ function code(db, symbolPattern, opts = {}) {
     `SELECT language FROM documents WHERE relative_path = ?`,
     match.relativePath
   );
-  const filePath = join7(db.config.projectRoot, match.relativePath);
+  const filePath = join9(db.config.projectRoot, match.relativePath);
   let fileContent;
   try {
-    fileContent = readFileSync5(filePath, "utf-8");
+    fileContent = readFileSync4(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -5664,10 +7439,10 @@ function readFileRange(db, filePath, startLine, endLine, context) {
     resolvedPath
   );
   if (!doc) return null;
-  const fullPath = join7(db.config.projectRoot, doc.relative_path);
+  const fullPath = join9(db.config.projectRoot, doc.relative_path);
   let fileContent;
   try {
-    fileContent = readFileSync5(fullPath, "utf-8");
+    fileContent = readFileSync4(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -5687,8 +7462,8 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 }
 
 // src/queries/complexity.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
 function complexity(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
   if (!match) return null;
@@ -5697,10 +7472,10 @@ function complexity(db, symbolPattern) {
     match.relativePath
   );
   const language = doc?.language ?? "unknown";
-  const filePath = join8(db.config.projectRoot, match.relativePath);
+  const filePath = join10(db.config.projectRoot, match.relativePath);
   let source = "";
   try {
-    const lines = readFileSync6(filePath, "utf-8").split("\n");
+    const lines = readFileSync5(filePath, "utf-8").split("\n");
     source = lines.slice(match.startLine, match.endLine + 1).join("\n");
   } catch {
   }
@@ -6037,46 +7812,100 @@ function redundantReexports(db, opts = {}) {
   results.sort(
     (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
   );
-  return limit ? results.slice(0, limit) : results;
+  const withDartFallback = dedupeReexports([
+    ...results,
+    ...findSourceRedundantReexports(db, scope)
+  ]);
+  withDartFallback.sort(
+    (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
+  );
+  return limit ? withDartFallback.slice(0, limit) : withDartFallback;
+}
+function findSourceRedundantReexports(db, scope) {
+  const files2 = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${scope ? "AND relative_path LIKE ?" : ""}
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`,
+    ...scope ? [`%${scope}%`] : []
+  );
+  const candidates = files2.map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath)).filter((relativePath) => getSourceExports(db, relativePath).length > 0);
+  const results = [];
+  for (const barrelPath of candidates) {
+    const exports = getSourceExports(db, barrelPath).filter((entry) => entry.sourcePath && !db.isIgnored(entry.sourcePath));
+    if (exports.length === 0) continue;
+    const barrelConsumers = countDirectImporters(db, barrelPath, barrelPath);
+    if (barrelConsumers > 0) continue;
+    for (const exported of exports) {
+      const sourcePath = exported.sourcePath;
+      const representative = representativeExportSymbol(db, sourcePath);
+      if (!representative) continue;
+      results.push({
+        barrelFile: barrelPath,
+        symbol: representative.symbol,
+        shortName: shortenSymbol(representative.symbol),
+        originalFile: sourcePath,
+        barrelConsumers: 0,
+        directConsumers: countDirectImporters(db, sourcePath, barrelPath)
+      });
+    }
+  }
+  return results;
+}
+function countDirectImporters(db, targetPath, excludedPath) {
+  const files2 = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const importers = /* @__PURE__ */ new Set();
+  for (const row of files2) {
+    if (db.isIgnored(row.relative_path) || row.relative_path === excludedPath) continue;
+    for (const imported of getSourceImports(db, row.relative_path)) {
+      if (imported.sourcePath === targetPath) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return importers.size;
+}
+function representativeExportSymbol(db, sourcePath) {
+  const definitions = getDefinitionsForFile(db, sourcePath);
+  return definitions.find((definition) => leafSuffix(definition.symbol) === "method") ?? definitions[0] ?? null;
+}
+function dedupeReexports(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.barrelFile}|${row.symbol}|${row.originalFile}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
 }
 
 // src/queries/similar-signatures.ts
 function similarSignatures(db, opts = {}) {
   const { scope, minLoc = 1, limit } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      gs.symbol,
-      d.relative_path,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE gs.documentation IS NOT NULL
-      AND gs.documentation != ''
-      AND INSTR(gs.documentation, '|') > 0
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      ${scopeFilter}
-    ORDER BY d.relative_path, der.start_line`,
-    minLoc
-  );
   const sigGroups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (db.isIgnored(row.relative_path)) continue;
-    const normalized = normalizeSignature(row.sig);
+  for (const definition of getAllDefinitions(db, { scope })) {
+    if (!definition.isFunctionLike || db.isIgnored(definition.relativePath)) continue;
+    const loc = definition.endLine - definition.startLine + 1;
+    if (loc < minLoc) continue;
+    const normalized = resolveNormalizedSignature(db, definition);
     if (!normalized) continue;
     const entry = {
-      symbol: row.symbol,
-      shortName: shortenSymbol(row.symbol),
-      file: row.relative_path,
-      startLine: row.start_line,
-      endLine: row.end_line,
-      loc: row.loc
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc
     };
     const existing = sigGroups.get(normalized);
     if (existing) {
@@ -6099,6 +7928,52 @@ function similarSignatures(db, opts = {}) {
   });
   return limit ? results.slice(0, limit) : results;
 }
+function resolveNormalizedSignature(db, definition) {
+  const documented = extractDocumentedSignature(definition.documentation);
+  const normalizedDocumented = documented ? normalizeSignature(documented) : null;
+  if (normalizedDocumented) {
+    return normalizedDocumented;
+  }
+  return normalizeSourceSignature(
+    extractDeclarationHead(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+    definition.leaf
+  );
+}
+function extractDocumentedSignature(documentation) {
+  if (!documentation || !documentation.includes("|")) {
+    return null;
+  }
+  const extracted = documentation.slice(documentation.indexOf("|") + 1).replace(/\n/g, " ").trim();
+  return extracted.length > 0 ? extracted : null;
+}
+function extractDeclarationHead(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) return null;
+  const lines = source.split(/\r?\n/);
+  const candidates = declarationStartLines(lines, startLine, endLine, leaf);
+  for (const candidate of candidates) {
+    const maxLine = Math.min(lines.length - 1, Math.max(candidate, candidate + 4));
+    let collected = "";
+    for (let lineIndex = candidate; lineIndex <= maxLine; lineIndex += 1) {
+      const line = lines[lineIndex]?.trim();
+      if (!line) continue;
+      collected = collected ? `${collected} ${line}` : line;
+      if (looksCompleteDeclaration(collected)) {
+        return collected;
+      }
+    }
+    if (collected && collected.includes("(")) {
+      return collected;
+    }
+  }
+  return null;
+}
+function looksCompleteDeclaration(declaration) {
+  const normalized = declaration.replace(/\s+/g, " ").trim();
+  if (!normalized.includes("(")) return false;
+  if (parenBalance(normalized) > 0) return false;
+  return /[;{]$/.test(normalized) || /\)\s*(?::\s*[^={]+)?\s*(?:=>|=|throws\b|where\b|$)/i.test(normalized) || /\)\s*As\s+.+$/i.test(normalized);
+}
 function normalizeSignature(raw) {
   if (!raw || !raw.trim()) return null;
   let sig = raw.replace(/^```\w*\s*/, "").replace(/\s*```$/, "").replace(/^\(method\)\s*/, "").replace(/^\(property\)\s*/, "").replace(/^\(function\)\s*/, "").replace(/^\(class\)\s*/, "").replace(/^\(interface\)\s*/, "").replace(/^\(enum\)\s*/, "").replace(/^\(type alias\)\s*/, "").replace(/^\(const\)\s*/, "").replace(/^\(var\)\s*/, "").trim();
@@ -6109,28 +7984,88 @@ function normalizeSignature(raw) {
   if (sig.length < 3) return null;
   return sig;
 }
+function normalizeSourceSignature(raw, leaf) {
+  if (!raw || !raw.trim()) return null;
+  const declaration = raw.replace(/\s+/g, " ").trim();
+  const parenIdx = declaration.indexOf("(");
+  if (parenIdx === -1) return null;
+  let prefix = declaration.slice(0, parenIdx);
+  const leafPattern = new RegExp(`\\b${escapeRegex4(leaf)}\\b`, "i");
+  const leafMatch = leafPattern.exec(prefix);
+  if (leafMatch && typeof leafMatch.index === "number") {
+    prefix = prefix.slice(0, leafMatch.index);
+  }
+  prefix = prefix.replace(/\b(public|private|protected|internal|final|static|abstract|sealed|virtual|override|async|suspend|inline|constexpr|consteval|constinit|const|pub|fn|function|def|sub|friend|shared|readonly|new|open|partial|export)\b/gi, " ").replace(/\s+/g, " ").trim();
+  const suffix = declaration.slice(parenIdx).replace(/\s*\{[\s\S]*$/, "").replace(/\s*=>[\s\S]*$/, "").replace(/\)\s*=\s*[\s\S]*$/, ")").replace(/\s+throws\s+[^={]+$/i, "").replace(/\s+where\s+.+$/i, "").replace(/\s+/g, " ").trim();
+  if (!suffix.startsWith("(")) {
+    return null;
+  }
+  const normalized = `${prefix ? `${prefix} ` : ""}${suffix}`.replace(/\s+/g, "").toLowerCase();
+  return normalized.length >= 3 ? normalized : null;
+}
+function declarationStartLines(lines, startLine, endLine, leaf) {
+  const escapedLeaf = escapeRegex4(leaf);
+  const callablePattern = new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`, "i");
+  const rubyPattern = new RegExp(`\\bdef\\s+${escapedLeaf}\\b`, "i");
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const preferredStart = Math.max(0, Math.min(startLine, lines.length - 1));
+  const preferredEnd = Math.max(preferredStart, Math.min(lines.length - 1, Math.max(endLine, startLine + 4)));
+  for (let lineIndex = preferredStart; lineIndex <= preferredEnd; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  return candidates;
+}
+function parenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance += 1;
+    if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function escapeRegex4(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/setup.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync2,
   symlinkSync,
   readlinkSync,
   unlinkSync
 } from "fs";
-import { join as join9, dirname as dirname3, resolve as resolve3 } from "path";
+import { join as join11, dirname as dirname3, resolve as resolve3 } from "path";
 import { homedir as homedir2, platform as platform3 } from "os";
 import { fileURLToPath } from "url";
 var IS_WINDOWS3 = platform3() === "win32";
-var SKILLS = ["concrete-plan", "scip-explore", "scip-debloat", "scip-verify"];
+var BUILTIN_SKILLS = [
+  "concrete-plan",
+  "scip-explore",
+  "scip-debloat",
+  "scip-verify",
+  "scip-language-playbook"
+];
 function installSkills(opts = {}) {
   const log = opts.quiet ? () => {
   } : console.log;
   const thisFile = fileURLToPath(import.meta.url);
   const skillsSource = resolve3(dirname3(thisFile), "..", "skills");
   const targets = [
-    join9(homedir2(), ".claude", "skills"),
-    join9(homedir2(), ".codex", "skills")
+    join11(homedir2(), ".claude", "skills"),
+    join11(homedir2(), ".codex", "skills")
   ];
   const result = {
     installed: [],
@@ -6139,19 +8074,19 @@ function installSkills(opts = {}) {
   };
   for (const targetDir of targets) {
     const parentDir = dirname3(targetDir);
-    if (!existsSync7(parentDir)) {
+    if (!existsSync9(parentDir)) {
       continue;
     }
     mkdirSync2(targetDir, { recursive: true });
     const toolName = targetDir.includes(".codex") ? "Codex" : "Claude";
-    for (const skill of SKILLS) {
-      const source = join9(skillsSource, skill);
-      const target = join9(targetDir, skill);
-      if (!existsSync7(source)) {
+    for (const skill of BUILTIN_SKILLS) {
+      const source = join11(skillsSource, skill);
+      const target = join11(targetDir, skill);
+      if (!existsSync9(source)) {
         result.skipped.push(`${toolName}/${skill}`);
         continue;
       }
-      if (existsSync7(target)) {
+      if (existsSync9(target)) {
         try {
           const existing = readlinkSync(target);
           if (resolve3(existing) === resolve3(source)) {
@@ -6183,14 +8118,14 @@ function resolveProjectRoot() {
 function resolveActiveDbPath(projectRoot) {
   const config = loadProjectConfig(projectRoot);
   const paths = resolveIndexPaths(projectRoot, config);
-  return process.env["SCIP_QUERY_INDEX_DB"] ?? (existsSync8(paths.dbPath) ? paths.dbPath : join10(projectRoot, "index.db"));
+  return process.env["SCIP_QUERY_INDEX_DB"] ?? (existsSync10(paths.dbPath) ? paths.dbPath : join12(projectRoot, "index.db"));
 }
 function openDb() {
   const projectRoot = resolveProjectRoot();
   const config = loadProjectConfig(projectRoot);
   const paths = resolveIndexPaths(projectRoot, config);
   const dbPath = resolveActiveDbPath(projectRoot);
-  if (!existsSync8(dbPath)) {
+  if (!existsSync10(dbPath)) {
     console.error(`error: No index.db found. Run: scip-query reindex`);
     process.exit(1);
   }
@@ -6361,6 +8296,10 @@ program.command("trace <symbol>").description("Trace a symbol: definition + all
       for (const d of result.definitions) {
         const sig = d.signature ? `  \u2014 ${d.signature}` : "";
         console.log(`  ${displayPathRange(d.relativePath, d.startLine, d.endLine)}${sig}`);
+        if (d.source) {
+          const numbered = d.source.split("\n").map((line, index) => `    ${displayLine(d.startLine + index)}  ${line}`).join("\n");
+          console.log(numbered);
+        }
       }
       console.log("\n\u2550\u2550\u2550 REFERENCED BY \u2550\u2550\u2550");
       let prevFile = "";
@@ -6767,7 +8706,7 @@ ${results.length} similar pair(s) found.`);
     }
   });
 });
-program.command("similar-files [file]").description("Find files with similar dependency profiles").option("--min-similarity <n>", "Minimum Jaccard similarity (0-1)", parseFloat, 0.5).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-deps <n>", "Minimum dependencies to consider", parseIntSafe, 3).action((file, opts) => {
+program.command("similar-files [file]").description("Find files with similar dependency profiles").option("--min-similarity <n>", "Minimum Jaccard similarity (0-1)", parseFloat, 0.5).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-deps <n>", "Minimum dependencies to consider", parseIntSafe).action((file, opts) => {
   runQuery(
     (db) => queries.similarFiles(db, {
       minSimilarity: opts.minSimilarity,
@@ -7167,7 +9106,7 @@ ${result.connectedSymbols.length} connected symbol(s).`);
   }
   db.close();
 });
-program.command("install-skills").description("Install skills (concrete-plan, scip-explore, scip-debloat, scip-verify) into Claude Code and Codex").action(() => {
+program.command("install-skills").description(`Install skills (${BUILTIN_SKILLS.join(", ")}) into Claude Code and Codex`).action(() => {
   const result = installSkills();
   const total = result.installed.length + result.alreadyLinked.length;
   console.log(`
@@ -7176,12 +9115,41 @@ ${result.installed.length} installed, ${result.alreadyLinked.length} already lin
     console.log("Skills will be available in your next Claude Code / Codex session.");
   }
 });
-program.command("check-deps").description("Check if required dependencies (scip CLI) are installed").action(() => {
+program.command("check-deps").description("Check whether scip-query and the detected language indexers are actually runnable").action(() => {
+  let hasProblems = false;
   if (isScipInstalled()) {
     console.log("scip CLI: installed");
   } else {
     printScipInstallInstructions();
+    hasProblems = true;
+  }
+  const projectRoot = resolveProjectRoot();
+  const config = loadProjectConfig(projectRoot);
+  const languages = config.languages ?? detectLanguages(projectRoot);
+  if (languages.length === 0) {
+    console.log("\nNo supported project languages detected in the current directory.");
+    process.exitCode = hasProblems ? 1 : 0;
+    return;
+  }
+  console.log(`
+Detected languages: ${languages.join(", ")}`);
+  console.log("\nIndexer readiness:");
+  for (const language of languages) {
+    const status = getIndexerDependencyStatus(getIndexerConfig(language), projectRoot);
+    const prefix = status.runnable ? "  OK" : status.installed ? "  WARN" : "  MISSING";
+    const resolved = status.resolvedBinary ? ` (${status.resolvedBinary})` : "";
+    console.log(`${prefix} ${language}: ${status.binaryLabel}${resolved}`);
+    if (status.note) {
+      console.log(`    ${status.note}`);
+    }
+    if (!status.installed && status.installUrl) {
+      console.log(`    install: ${status.installUrl}`);
+    }
+    if (!status.runnable) {
+      hasProblems = true;
+    }
   }
+  process.exitCode = hasProblems ? 1 : 0;
 });
 program.command("redundant-reexports").description("Find barrel re-exports that nobody imports through").option("-s, --scope <path>", "Limit to files matching path").option("-n, --limit <n>", "Number of results", parseIntSafe, 30).action((opts) => {
   const db = openDb();
@@ -7269,8 +9237,8 @@ program.command("status").description("Show index status for this project").acti
   if (dbPath !== paths.dbPath) {
     console.log(`Config:   ${paths.dbPath} (fallback to project root index.db)`);
   }
-  console.log(`Exists:   ${existsSync8(dbPath) ? "yes" : "no"}`);
-  if (existsSync8(dbPath)) {
+  console.log(`Exists:   ${existsSync10(dbPath) ? "yes" : "no"}`);
+  if (existsSync10(dbPath)) {
     withDb((db) => {
       const s = queries.stats(db);
       console.log(`Symbols:  ${s.symbols}`);