scip-query 0.1.0 → 0.2.1

package/dist/cli.js

@@ -2,8 +2,9 @@
 
 // src/cli.ts
 import { program } from "commander";
-import { existsSync as existsSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/db.ts
 import Database from "better-sqlite3";
@@ -272,10 +273,192 @@ function ensureDir(dir) {
 }
 
 // src/reindex/index.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
 
+// src/scip-cli.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { platform as platform2, arch } from "os";
+
+// src/reindex/install.ts
+import { execFileSync } from "child_process";
+import { platform } from "os";
+var IS_WINDOWS = platform() === "win32";
+function isBinaryAvailable(name) {
+  const cmd = IS_WINDOWS ? "where" : "which";
+  try {
+    execFileSync(cmd, [name], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getBinaryCandidates(config) {
+  return [config.indexerBinary, ...config.binaryAliases ?? []];
+}
+function describeIndexerBinary(config) {
+  const candidates = getBinaryCandidates(config);
+  return candidates.length === 1 ? candidates[0] : candidates.join(" or ");
+}
+function resolveIndexerBinary(config) {
+  for (const candidate of getBinaryCandidates(config)) {
+    if (isBinaryAvailable(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isIndexerInstalled(config) {
+  return resolveIndexerBinary(config) !== null;
+}
+function tryInstallIndexer(config, onStatus) {
+  const methods2 = config.installMethods;
+  const binaryLabel = describeIndexerBinary(config);
+  if (!methods2?.length) {
+    onStatus(`No auto-install method available for ${binaryLabel}.`);
+    if (config.installUrl) {
+      onStatus(`Install manually from: ${config.installUrl}`);
+    }
+    return false;
+  }
+  for (const method of methods2) {
+    if (!isBinaryAvailable(method.prerequisite)) {
+      continue;
+    }
+    onStatus(`Installing ${binaryLabel} via ${method.label}...`);
+    try {
+      execFileSync(method.binary, method.args, {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      const resolvedBinary = resolveIndexerBinary(config);
+      if (resolvedBinary) {
+        const resolutionNote = resolvedBinary === config.indexerBinary ? "" : ` (using ${resolvedBinary})`;
+        onStatus(`Successfully installed ${binaryLabel} via ${method.label}${resolutionNote}`);
+        return true;
+      }
+      onStatus(`${method.label} command completed but ${binaryLabel} was not found on PATH`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`${method.label} install failed: ${msg}`);
+    }
+  }
+  onStatus(`Could not auto-install ${binaryLabel}.`);
+  if (config.installUrl) {
+    onStatus(`Install manually from: ${config.installUrl}`);
+  }
+  return false;
+}
+
+// src/scip-cli.ts
+var IS_WINDOWS2 = platform2() === "win32";
+var SCIP_VERSION = "v0.7.0";
+function isScipInstalled() {
+  try {
+    const cmd = IS_WINDOWS2 ? "where" : "which";
+    execFileSync2(cmd, ["scip"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getScipDownloadUrl() {
+  const os = platform2();
+  const cpu = arch();
+  let osName;
+  let archName;
+  let ext;
+  switch (os) {
+    case "darwin":
+      osName = "darwin";
+      ext = "tar.gz";
+      break;
+    case "linux":
+      osName = "linux";
+      ext = "tar.gz";
+      break;
+    case "win32":
+      osName = "windows";
+      ext = "zip";
+      break;
+    default:
+      return null;
+  }
+  switch (cpu) {
+    case "arm64":
+      archName = "arm64";
+      break;
+    case "x64":
+      archName = "amd64";
+      break;
+    default:
+      return null;
+  }
+  const filename = `scip-${osName}-${archName}.${ext}`;
+  const url = `https://github.com/sourcegraph/scip/releases/download/${SCIP_VERSION}/${filename}`;
+  return { url, filename };
+}
+function printScipInstallInstructions() {
+  const download = getScipDownloadUrl();
+  console.log("\nThe `scip` CLI is required but not found on PATH.\n");
+  if (platform2() === "darwin") {
+    console.log("Install via Homebrew:");
+    console.log("  brew install sourcegraph/scip/scip\n");
+    console.log("Or download manually:");
+  } else {
+    console.log("Download from:");
+  }
+  if (download) {
+    console.log(`  ${download.url}
+`);
+  } else {
+    console.log(`  https://github.com/sourcegraph/scip/releases/tag/${SCIP_VERSION}
+`);
+  }
+  console.log("After installing, ensure `scip` is on your PATH and run `scip-query reindex`.");
+}
+function tryInstallScipCli(onStatus) {
+  if (platform2() === "darwin" && isBinaryAvailable("brew")) {
+    onStatus("Installing scip CLI via Homebrew...");
+    try {
+      execFileSync2("brew", ["install", "sourcegraph/scip/scip"], {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      if (isBinaryAvailable("scip")) {
+        onStatus("Successfully installed scip CLI via Homebrew");
+        return true;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`Homebrew install failed: ${msg}`);
+    }
+  }
+  if (isBinaryAvailable("go")) {
+    onStatus("Installing scip CLI via go install...");
+    try {
+      execFileSync2("go", ["install", "github.com/sourcegraph/scip/cmd/scip@latest"], {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      if (isBinaryAvailable("scip")) {
+        onStatus("Successfully installed scip CLI via go install");
+        return true;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`go install failed: ${msg}`);
+    }
+  }
+  onStatus("Could not auto-install scip CLI.");
+  onStatus("Install manually from: https://github.com/sourcegraph/scip/releases");
+  return false;
+}
+
 // src/reindex/detect.ts
 import { existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
@@ -406,9 +589,10 @@ var INDEXER_CONFIGS = {
   python: {
     language: "python",
     indexerBinary: "scip-python",
+    binaryAliases: ["scip-python-plus"],
     checkCommand: "scip-python --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-python",
+    indexArgs: ({ outputPath, indexerBinary }) => ({
+      binary: indexerBinary,
       args: ["index", "--output", outputPath, "--project-name", "project"]
     }),
     markerFiles: ["pyproject.toml", "setup.py"],
@@ -514,98 +698,6 @@ function getIndexerConfig(language) {
   return INDEXER_CONFIGS[language];
 }
 
-// src/reindex/install.ts
-import { execFileSync } from "child_process";
-import { platform } from "os";
-var IS_WINDOWS = platform() === "win32";
-function isBinaryAvailable(name) {
-  const cmd = IS_WINDOWS ? "where" : "which";
-  try {
-    execFileSync(cmd, [name], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isIndexerInstalled(config) {
-  return isBinaryAvailable(config.indexerBinary);
-}
-function tryInstallIndexer(config, onStatus) {
-  const methods2 = config.installMethods;
-  if (!methods2?.length) {
-    onStatus(`No auto-install method available for ${config.indexerBinary}.`);
-    if (config.installUrl) {
-      onStatus(`Install manually from: ${config.installUrl}`);
-    }
-    return false;
-  }
-  for (const method of methods2) {
-    if (!isBinaryAvailable(method.prerequisite)) {
-      continue;
-    }
-    onStatus(`Installing ${config.indexerBinary} via ${method.label}...`);
-    try {
-      execFileSync(method.binary, method.args, {
-        stdio: "inherit",
-        timeout: 3e5,
-        env: process.env
-      });
-      if (isIndexerInstalled(config)) {
-        onStatus(`Successfully installed ${config.indexerBinary} via ${method.label}`);
-        return true;
-      }
-      onStatus(`${method.label} command completed but ${config.indexerBinary} not found on PATH`);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      onStatus(`${method.label} install failed: ${msg}`);
-    }
-  }
-  onStatus(`Could not auto-install ${config.indexerBinary}.`);
-  if (config.installUrl) {
-    onStatus(`Install manually from: ${config.installUrl}`);
-  }
-  return false;
-}
-function tryInstallScipCli(onStatus) {
-  if (platform() === "darwin" && isBinaryAvailable("brew")) {
-    onStatus("Installing scip CLI via Homebrew...");
-    try {
-      execFileSync("brew", ["install", "sourcegraph/scip/scip"], {
-        stdio: "inherit",
-        timeout: 3e5,
-        env: process.env
-      });
-      if (isBinaryAvailable("scip")) {
-        onStatus("Successfully installed scip CLI via Homebrew");
-        return true;
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      onStatus(`Homebrew install failed: ${msg}`);
-    }
-  }
-  if (isBinaryAvailable("go")) {
-    onStatus("Installing scip CLI via go install...");
-    try {
-      execFileSync("go", ["install", "github.com/sourcegraph/scip/cmd/scip@latest"], {
-        stdio: "inherit",
-        timeout: 3e5,
-        env: process.env
-      });
-      if (isBinaryAvailable("scip")) {
-        onStatus("Successfully installed scip CLI via go install");
-        return true;
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      onStatus(`go install failed: ${msg}`);
-    }
-  }
-  onStatus("Could not auto-install scip CLI.");
-  onStatus("Install manually from: https://github.com/sourcegraph/scip/releases");
-  return false;
-}
-
 // src/reindex/index.ts
 async function reindex(opts) {
   const {
@@ -643,29 +735,38 @@ async function reindex(opts) {
   };
   for (const lang of languages) {
     const config = getIndexerConfig(lang);
+    const binaryLabel = describeIndexerBinary(config);
     if (!isIndexerInstalled(config)) {
       if (skipAutoInstall) {
         throw new Error(
-          `${config.indexerBinary} is required to index ${lang} but not found on PATH.
-` + (config.installUrl ? `Install from: ${config.installUrl}` : `Make sure ${config.indexerBinary} is installed and available on PATH.`)
+          `${binaryLabel} is required to index ${lang} but not found on PATH.
+` + (config.installUrl ? `Install from: ${config.installUrl}` : `Make sure ${binaryLabel} is installed and available on PATH.`)
         );
       }
-      onStatus(`${config.indexerBinary} not found. Attempting auto-install...`);
+      onStatus(`${binaryLabel} not found. Attempting auto-install...`);
       if (!tryInstallIndexer(config, onStatus)) {
         throw new Error(
-          `${config.indexerBinary} is required to index ${lang} but could not be installed.
-` + (config.installUrl ? `Install manually from: ${config.installUrl}` : `Make sure ${config.indexerBinary} is installed and available on PATH.`)
+          `${binaryLabel} is required to index ${lang} but could not be installed.
+` + (config.installUrl ? `Install manually from: ${config.installUrl}` : `Make sure ${binaryLabel} is installed and available on PATH.`)
         );
       }
     }
-    onStatus(`Indexing ${lang} with ${config.indexerBinary}...`);
+    const resolvedBinary = resolveIndexerBinary(config);
+    if (!resolvedBinary) {
+      throw new Error(
+        `${binaryLabel} is required to index ${lang} but was not found on PATH after installation checks.
+` + (config.installUrl ? `Install manually from: ${config.installUrl}` : `Make sure ${binaryLabel} is installed and available on PATH.`)
+      );
+    }
+    onStatus(`Indexing ${lang} with ${resolvedBinary}...`);
     const { binary, args } = config.indexArgs({
       projectRoot,
       outputPath: outputScip,
-      pnpmWorkspaces: opts.pnpmWorkspaces
+      pnpmWorkspaces: opts.pnpmWorkspaces,
+      indexerBinary: resolvedBinary
     });
     try {
-      execFileSync2(binary, args, {
+      execFileSync3(binary, args, {
         cwd: projectRoot,
         env,
         stdio: "pipe",
@@ -674,8 +775,8 @@ async function reindex(opts) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Failed to index ${lang} with ${config.indexerBinary}: ${msg}
-Make sure ${config.indexerBinary} is installed and available on PATH.`
+        `Failed to index ${lang} with ${resolvedBinary}: ${msg}
+Make sure ${binaryLabel} is installed and available on PATH.`
       );
     }
   }
@@ -684,7 +785,7 @@ Make sure ${config.indexerBinary} is installed and available on PATH.`
     throw new Error(`SCIP index not found at ${outputScip} after indexing`);
   }
   try {
-    execFileSync2("scip", ["expt-convert", "--output", outputDb, outputScip], {
+    execFileSync3("scip", ["expt-convert", "--output", outputDb, outputScip], {
       env,
       stdio: "pipe",
       maxBuffer: 50 * 1024 * 1024
@@ -860,7 +961,7 @@ var Watcher = class {
    * Writes to index.db.tmp, then atomically renames to index.db.
    */
   runReindex() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const start = Date.now();
       const tmpDb = this.indexPaths.dbPath + ".tmp";
       const tmpScip = this.indexPaths.indexPath + ".tmp";
@@ -888,7 +989,7 @@ var Watcher = class {
             if (existsSync5(tmpScip)) {
               renameSync(tmpScip, this.indexPaths.indexPath);
             }
-            resolve3(Date.now() - start);
+            resolve4(Date.now() - start);
           } catch (err) {
             reject(new Error(`Atomic swap failed: ${err}`));
           }
@@ -913,7 +1014,7 @@ function stats(db) {
     "SELECT COUNT(*) as c FROM mentions WHERE role = 1"
   ).c;
   const references = db.get(
-    "SELECT COUNT(*) as c FROM mentions WHERE role = 0"
+    "SELECT COUNT(*) as c FROM mentions WHERE role != 1"
   ).c;
   return {
     documents,
@@ -1099,11 +1200,47 @@ function leafName(raw) {
   const last = sym.descriptors[sym.descriptors.length - 1];
   return last.name;
 }
-
-// src/queries/clean-signature.ts
-function cleanSignature(sig) {
-  if (!sig || !sig.trim()) return null;
-  return sig.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() || null;
+function leafSuffix(raw) {
+  const parsed = parseSymbol(raw);
+  if ("kind" in parsed && parsed.kind === "local") {
+    return null;
+  }
+  const sym = parsed;
+  const last = sym.descriptors[sym.descriptors.length - 1];
+  return last?.suffix ?? null;
+}
+function isFunctionLikeSymbol(raw) {
+  const suffix = leafSuffix(raw);
+  return suffix === "method" || suffix === "term";
+}
+function isModuleLikeSymbol(raw) {
+  return leafSuffix(raw) === "namespace";
+}
+function isDirectChildSymbol(parentRaw, candidateRaw) {
+  const parent = parseSymbol(parentRaw);
+  const candidate = parseSymbol(candidateRaw);
+  if ("kind" in parent || "kind" in candidate) {
+    return false;
+  }
+  const parentDescriptors = parent.descriptors;
+  const candidateDescriptors = candidate.descriptors;
+  if (candidateDescriptors.length !== parentDescriptors.length + 1) {
+    return false;
+  }
+  for (let i = 0; i < parentDescriptors.length; i++) {
+    const parentDesc = parentDescriptors[i];
+    const candidateDesc = candidateDescriptors[i];
+    if (parentDesc.name !== candidateDesc.name || parentDesc.suffix !== candidateDesc.suffix) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/queries/clean-signature.ts
+function cleanSignature(sig) {
+  if (!sig || !sig.trim()) return null;
+  return sig.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() || null;
 }
 
 // src/queries/symbols.ts
@@ -1163,7 +1300,7 @@ function refs(db, symbolPattern) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     WHERE gs.symbol LIKE ?
       AND ${db.localSymbolPredicate}
-      AND m.role = 0
+      AND m.role != 1
     ORDER BY d.relative_path, c.start_line`,
     `%${symbolPattern}%`
   );
@@ -1173,20 +1310,228 @@ function refs(db, symbolPattern) {
   }));
 }
 
+// src/query-support.ts
+var TEST_FILE_PATTERNS = [
+  "%/__tests__/%",
+  "%.test.%",
+  "%.spec.%",
+  "%/test/%",
+  "%/tests/%",
+  "%_test.%",
+  "%_spec.%",
+  "%/test_%.%",
+  "%/spec_%.%"
+];
+var TEST_SUPPORT_PATH_PATTERNS = [
+  "%/test-utils/%"
+];
+function testFileExclusionSql(alias, extraPatterns = []) {
+  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
+  return patterns.map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`).join("\n      AND ");
+}
+function buildFileDepGraph(db, scope) {
+  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
+  const edges = db.all(
+    `SELECT DISTINCT
+      d1.relative_path AS from_file,
+      d2.relative_path AS to_file
+    FROM mentions m
+    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 d1.id != d2.id
+      AND m.role != 1
+      ${db.pathExclusionsFor("d1", "d2")}
+      ${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;
+}
+function findFirstSymbolMatch(db, symbolPattern) {
+  const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
+  if (fileLineMatch) {
+    const [, filePath, startStr, endStr] = fileLineMatch;
+    const 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
+      JOIN documents d ON der.document_id = d.id
+      WHERE d.relative_path LIKE ?
+        AND der.start_line <= ? AND der.end_line >= ?
+        ${db.pathExclusionsFor("d")}
+      ORDER BY (der.end_line - der.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
+      };
+    }
+  }
+  const cleaned = normalizeLookupPattern(symbolPattern);
+  const tokens = lookupTokens(symbolPattern);
+  const candidates = getSymbolLookupCandidates(db, tokens);
+  let best = null;
+  for (const row of candidates) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const score = scoreSymbolCandidate(row, symbolPattern, cleaned, tokens);
+    if (score <= 0) continue;
+    if (!best || score > best.score) {
+      best = { row, score };
+    }
+  }
+  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 null;
+}
+function normalizeLookupPattern(symbolPattern) {
+  return symbolPattern.trim().replace(/\(\)$/, "").replace(/\(.*$/, "");
+}
+function lookupTokens(symbolPattern) {
+  const cleaned = normalizeLookupPattern(symbolPattern);
+  const tokens = cleaned.split(/[^A-Za-z0-9_]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+  return tokens.length > 0 ? [...new Set(tokens)] : [cleaned];
+}
+function getSymbolLookupCandidates(db, tokens) {
+  const tokenClauses = tokens.map(
+    () => `(gs.symbol LIKE ? OR d.relative_path LIKE ? OR COALESCE(gs.display_name, '') LIKE ?)`
+  );
+  const params = tokens.flatMap((token) => {
+    const like = `%${token}%`;
+    return [like, like, like];
+  });
+  return 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
+  );
+}
+function scoreSymbolCandidate(row, originalPattern, cleanedPattern, tokens) {
+  const original = originalPattern.toLowerCase();
+  const cleaned = cleanedPattern.toLowerCase();
+  const noParens = cleaned.replace(/\(\)$/, "");
+  const raw = row.symbol.toLowerCase();
+  const short = shortenSymbol(row.symbol).toLowerCase();
+  const leaf = leafName(row.symbol).toLowerCase();
+  const display = (row.display_name ?? "").toLowerCase();
+  const path2 = row.relative_path.toLowerCase();
+  const looksPathLike = /[/:.]/.test(cleanedPattern);
+  let score = 0;
+  if (raw === original || raw === cleaned) score += 1e3;
+  if (short === original || short === cleaned) score += 950;
+  if (path2 === original || path2 === cleaned) score += 925;
+  if (path2.endsWith(`/${cleaned}`) || path2.endsWith(`/${original}`)) score += 875;
+  if (display === noParens) score += 850;
+  if (leaf === noParens) score += 825;
+  if (`${leaf}()` === original || `${leaf}()` === cleaned) score += 820;
+  if (short.endsWith(`:${cleaned}`) || short.endsWith(`:${noParens}`) || short.endsWith(`:${noParens}()`)) score += 800;
+  if (raw.includes(cleaned)) score += 120;
+  if (short.includes(cleaned)) score += 140;
+  if (path2.includes(cleaned)) score += 140;
+  if (display.includes(cleaned)) score += 110;
+  if (tokens.every((token) => {
+    const lower = token.toLowerCase();
+    return raw.includes(lower) || short.includes(lower) || path2.includes(lower) || display.includes(lower);
+  })) {
+    score += 100 + tokens.length * 15;
+  }
+  if (isFunctionLikeSymbol(row.symbol) && leaf === noParens) {
+    score += 60;
+  }
+  if (!looksPathLike && isModuleLikeSymbol(row.symbol)) {
+    score -= 160;
+  }
+  score -= Math.min(50, Math.max(0, row.end_line - row.start_line));
+  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 ?" : ""}`,
+    ...calleeQueryParams(symbol, opts.limit)
+  );
+  return rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
+    symbol: row.symbol,
+    file: row.file,
+    chunkId: row.chunk_id
+  }));
+}
+function calleeQueryParams(symbol, limit) {
+  const params = [
+    symbol.documentId,
+    symbol.startLine,
+    symbol.endLine,
+    symbol.symbolId
+  ];
+  if (typeof limit === "number") {
+    params.push(limit);
+  }
+  return params;
+}
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+
 // src/queries/trace.ts
 function trace(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) {
+    return { definitions: [], referencedBy: [] };
+  }
   const defRows = db.all(
     `SELECT d.relative_path, der.start_line, der.end_line,
       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.symbol LIKE ?
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
+    WHERE gs.id = ?
     ORDER BY d.relative_path, der.start_line
     LIMIT 10`,
-    `%${symbolPattern}%`
+    match.symbolId
   );
   const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     relativePath: r.relative_path,
@@ -1199,13 +1544,10 @@ function trace(db, symbolPattern) {
     FROM mentions m
     JOIN chunks c ON m.chunk_id = c.id
     JOIN documents d ON c.document_id = d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE gs.symbol LIKE ?
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
-      AND m.role = 0
+    WHERE m.symbol_id = ?
+      AND m.role != 1
     ORDER BY d.relative_path`,
-    `%${symbolPattern}%`
+    match.symbolId
   );
   const referencedBy = refRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
   return { definitions, referencedBy };
@@ -1323,7 +1665,7 @@ function surface(db, modulePattern) {
     WHERE d2.relative_path LIKE ?
       AND d1.relative_path NOT LIKE ?
       AND ${db.localSymbolPredicate}
-      AND m.role = 0
+      AND m.role != 1
     ORDER BY d1.relative_path`,
     `%${modulePattern}%`,
     `%${modulePattern}%`
@@ -1335,152 +1677,78 @@ function surface(db, modulePattern) {
   }));
 }
 
-// src/query-support.ts
-var TEST_FILE_PATTERNS = [
-  "%/__tests__/%",
-  "%.test.%",
-  "%.spec.%",
-  "%/test/%",
-  "%/tests/%",
-  "%_test.%",
-  "%_spec.%",
-  "%/test_%.%",
-  "%/spec_%.%"
-];
-var TEST_SUPPORT_PATH_PATTERNS = [
-  "%/test-utils/%"
-];
-function testFileMatchSql(alias, patterns = TEST_FILE_PATTERNS) {
-  return `(${patterns.map((pattern) => `${alias}.relative_path LIKE '${pattern}'`).join(" OR ")})`;
+// src/entry-surfaces.ts
+var liveBarrelCache = /* @__PURE__ */ new WeakMap();
+function normalizePath(path2) {
+  return path2.replace(/\\/g, "/");
 }
-function testFileExclusionSql(alias, extraPatterns = []) {
-  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
-  return patterns.map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`).join("\n      AND ");
+function isBarrelFile(path2) {
+  const normalized = normalizePath(path2);
+  return normalized === "index.ts" || normalized === "index.js" || normalized.endsWith("/index.ts") || normalized.endsWith("/index.js") || normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
 }
-function buildFileDepGraph(db, scope) {
-  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
-  const edges = db.all(
-    `SELECT DISTINCT
-      d1.relative_path AS from_file,
-      d2.relative_path AS to_file
-    FROM mentions m
-    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 d1.id != d2.id
-      AND m.role = 0
-      ${db.pathExclusionsFor("d1", "d2")}
-      ${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);
+function isWorkerEntrySurface(path2) {
+  const normalized = normalizePath(path2);
+  return /(^|\/)[^/]*worker\.(ts|js|mjs|cjs|rs|py|go)$/.test(normalized);
+}
+function isStructuralEntrySurface(path2) {
+  const normalized = normalizePath(path2);
+  const segments = normalized.split("/");
+  const basename = segments[segments.length - 1] ?? normalized;
+  if (basename === "cli.ts" || basename === "cli.js" || basename === "postinstall.ts" || basename === "postinstall.js" || basename === "main.ts" || basename === "main.js" || basename === "main.rs" || basename === "main.go" || basename === "main.py") {
+    return true;
   }
-  return graph;
+  if (basename === "index.ts" || basename === "index.js") {
+    return segments.length <= 2;
+  }
+  return normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
 }
-function findFirstSymbolMatch(db, symbolPattern) {
-  const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
-  if (fileLineMatch) {
-    const [, filePath, startStr, endStr] = fileLineMatch;
-    const 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
-      JOIN documents d ON der.document_id = d.id
-      WHERE d.relative_path LIKE ?
-        AND der.start_line <= ? AND der.end_line >= ?
-        ${db.pathExclusionsFor("d")}
-      ORDER BY (der.end_line - der.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
-      };
+function getIndexedPaths(db) {
+  return db.all(
+    `SELECT d.relative_path
+     FROM documents d
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("d")}
+     ORDER BY d.relative_path`
+  ).map((row) => row.relative_path).filter((path2) => !db.isIgnored(path2));
+}
+function getLiveBarrelPaths(db) {
+  const cached = liveBarrelCache.get(db);
+  if (cached) {
+    return cached;
+  }
+  const graph = buildFileDepGraph(db);
+  const queue = getIndexedPaths(db).filter(
+    (path2) => isStructuralEntrySurface(path2) || isWorkerEntrySurface(path2)
+  );
+  const visited = /* @__PURE__ */ new Set();
+  const liveBarrels = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
     }
-  }
-  const cleaned = symbolPattern.replace(/\(\)$/, "").replace(/\(.*$/, "");
-  for (const useNoiseFilter of [true, false]) {
-    const noiseClause = useNoiseFilter ? db.symbolNoiseFor("gs") : "";
-    const 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
-      JOIN documents d ON der.document_id = d.id
-      WHERE gs.symbol LIKE ?
-        ${db.pathExclusionsFor("d")}
-        ${noiseClause}
-      ORDER BY (der.end_line - der.start_line) DESC
-      LIMIT 1`,
-      `%${cleaned}%`
-    );
-    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
-      };
+    visited.add(current);
+    if (isBarrelFile(current)) {
+      liveBarrels.add(current);
+    }
+    for (const dep of graph.get(current) ?? []) {
+      if (!visited.has(dep)) {
+        queue.push(dep);
+      }
     }
   }
-  return null;
+  liveBarrelCache.set(db, liveBarrels);
+  return liveBarrels;
 }
-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 = 0
-      AND callee_gs.id != ?
-      ${db.symbolNoiseFor("callee_gs")}
-      ${db.pathExclusionsFor("callee_d")}
-    ORDER BY callee_d.relative_path
-    ${opts.limit ? "LIMIT ?" : ""}`,
-    ...calleeQueryParams(symbol, opts.limit)
-  );
-  return rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
-    symbol: row.symbol,
-    file: row.file,
-    chunkId: row.chunk_id
-  }));
+function isLiveBarrel(db, path2) {
+  return getLiveBarrelPaths(db).has(normalizePath(path2));
 }
-function calleeQueryParams(symbol, limit) {
-  const params = [
-    symbol.documentId,
-    symbol.startLine,
-    symbol.endLine,
-    symbol.symbolId
-  ];
-  if (typeof limit === "number") {
-    params.push(limit);
-  }
-  return params;
+function isEntrySurface(db, path2) {
+  return isStructuralEntrySurface(path2) || isWorkerEntrySurface(path2) || isLiveBarrel(db, path2);
 }
-function uniquePatterns(patterns) {
-  return [...new Set(patterns)];
+function getInactiveBarrelPaths(db) {
+  const liveBarrels = getLiveBarrelPaths(db);
+  return getIndexedPaths(db).filter((path2) => isBarrelFile(path2)).filter((path2) => !liveBarrels.has(path2));
 }
 
 // src/queries/dead.ts
@@ -1495,6 +1763,7 @@ function dead(db, opts = {}) {
   const params = [minLoc];
   let testFileExclusions = "";
   let memberExclusion = "";
+  let barrelExclusions = "";
   if (scope) {
     params.push(`%${scope}%`);
   }
@@ -1506,10 +1775,13 @@ function dead(db, opts = {}) {
   if (!includeMembers) {
     memberExclusion = `AND gs.symbol NOT LIKE '%#%'`;
   }
-  const barrelExclusions = skipBarrels ? `AND ref_d.relative_path NOT LIKE '%/index.ts'
-       AND ref_d.relative_path NOT LIKE '%/index.js'
-       AND ref_d.relative_path NOT LIKE '%/mod.rs'
-       AND ref_d.relative_path NOT LIKE '%/__init__.py'` : "";
+  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
       d.relative_path,
@@ -1519,7 +1791,7 @@ function dead(db, opts = {}) {
       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 = 0 AND c2.document_id = d.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
@@ -1537,7 +1809,7 @@ function dead(db, opts = {}) {
         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 = 0
+          AND ref_m.role != 1
           AND ref_d.id != d.id
           ${barrelExclusions}
       )
@@ -1547,7 +1819,7 @@ function dead(db, opts = {}) {
   let deadCodeCount = 0;
   let fileInternalCount = 0;
   let totalLoc = 0;
-  const symbols2 = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => {
+  const symbols2 = rows.filter((r) => !db.isIgnored(r.relative_path)).filter((r) => !isEntrySurface(db, r.relative_path)).map((r) => {
     const kind = r.same_file_refs === 0 ? "dead-code" : "file-internal";
     if (kind === "dead-code") deadCodeCount++;
     else fileInternalCount++;
@@ -1588,7 +1860,7 @@ function hotspots(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents def_d ON der.document_id = def_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       ${db.pathExclusionsFor("def_d")}
       ${db.symbolNoiseFor("gs")}
       ${scopeFilter}
@@ -1597,19 +1869,447 @@ function hotspots(db, opts = {}) {
     LIMIT ?`,
     limit
   );
-  return 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
-  }));
+  return 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
+  }));
+}
+
+// src/source-analysis.ts
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync4
+} from "fs";
+import {
+  dirname as dirname2,
+  extname,
+  join as join6,
+  relative as relative2,
+  resolve as resolve2
+} from "path";
+var SOURCE_IMPORT_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"];
+function getSourceImports(db, relativePath) {
+  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
+  const normalized = normalizePath2(relativePath);
+  const cached = cache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const fullPath = join6(db.config.projectRoot, normalized);
+  if (!existsSync6(fullPath)) {
+    cache.set(normalized, []);
+    return [];
+  }
+  const source = readFileSync4(fullPath, "utf-8");
+  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : parseJavaScriptImports(db, normalized, source);
+  cache.set(normalized, parsed);
+  return parsed;
+}
+function parseJavaScriptImports(db, importerPath, source) {
+  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
+    db,
+    importerPath,
+    statement.clause,
+    statement.specifier,
+    statement.start,
+    statement.end,
+    source
+  ));
+}
+function parseJavaScriptImportStatements(source) {
+  const statements = [];
+  const importFromRegex = /^[ \t]*import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(importFromRegex)) {
+    const full = match[0];
+    const clause = match[1];
+    const specifier = match[2];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  const sideEffectRegex = /^[ \t]*import\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(sideEffectRegex)) {
+    const full = match[0];
+    const specifier = match[1];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause: null,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  return statements.sort((a, b) => a.start - b.start);
+}
+function parseJavaScriptImportStatement(db, importerPath, clause, specifier, start, end, source) {
+  const resolvedSource = resolveImportPath(db, importerPath, specifier);
+  const body = buildUsageBody(source, start, end);
+  if (!clause) {
+    return [{
+      importedName: "*",
+      localName: null,
+      sourcePath: resolvedSource,
+      kind: "side-effect",
+      used: true,
+      usedMembers: []
+    }];
+  }
+  const bindings = parseImportClause(clause).map((binding) => ({
+    ...binding,
+    sourcePath: resolvedSource
+  }));
+  return bindings.map((binding) => {
+    if (binding.kind === "namespace") {
+      const usedMembers = collectNamespaceMembers(body, binding.localName);
+      return {
+        ...binding,
+        used: usedMembers.length > 0 || hasIdentifierUsage(body, binding.localName),
+        usedMembers
+      };
+    }
+    if (binding.kind === "side-effect") {
+      return { ...binding, used: true, usedMembers: [] };
+    }
+    return {
+      ...binding,
+      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
+      usedMembers: []
+    };
+  });
+}
+function parsePythonImports(db, importerPath, source) {
+  return collectPythonImportStatements(source).flatMap(
+    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
+  );
+}
+function collectPythonImportStatements(source) {
+  const lines = source.split("\n");
+  const statements = [];
+  let offset = 0;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const trimmed = line.trimStart();
+    const lineStart = offset;
+    offset += line.length + 1;
+    if (!trimmed.startsWith("import ") && !trimmed.startsWith("from ")) {
+      continue;
+    }
+    let statement = line;
+    let statementEnd = lineStart + line.length;
+    let balance = pythonParenBalance(line);
+    while (lineIndex + 1 < lines.length && (balance > 0 || statement.trimEnd().endsWith("\\"))) {
+      lineIndex++;
+      const nextLine = lines[lineIndex];
+      statement += `
+${nextLine}`;
+      statementEnd += 1 + nextLine.length;
+      balance += pythonParenBalance(nextLine);
+      offset += nextLine.length + 1;
+    }
+    const parsed = parsePythonStatementHeader(statement);
+    if (parsed) {
+      statements.push({
+        ...parsed,
+        start: lineStart,
+        end: statementEnd
+      });
+    }
+  }
+  return statements;
+}
+function parsePythonStatementHeader(statement) {
+  const normalized = statement.replace(/\\\s*\n/g, " ").trim();
+  if (normalized.startsWith("import ")) {
+    return {
+      kind: "import",
+      module: null,
+      clause: normalized.slice("import ".length).trim()
+    };
+  }
+  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
+  if (!fromMatch) {
+    return null;
+  }
+  let clause = fromMatch[2].trim();
+  if (clause.startsWith("(") && clause.endsWith(")")) {
+    clause = clause.slice(1, -1).trim();
+  }
+  return {
+    kind: "from",
+    module: fromMatch[1],
+    clause
+  };
+}
+function parsePythonImportStatement(db, importerPath, statement, source) {
+  const body = buildUsageBody(source, statement.start, statement.end);
+  const normalizedClause = statement.clause.replace(/\n/g, " ").trim();
+  if (statement.kind === "import") {
+    return splitTopLevel(normalizedClause).flatMap((entry) => {
+      const cleaned = entry.trim().replace(/,$/, "");
+      if (!cleaned) return [];
+      const [moduleName, alias] = cleaned.split(/\s+as\s+/);
+      const importedName = moduleName.trim();
+      const localName = (alias ?? importedName.split(".")[0] ?? importedName).trim();
+      const sourcePath2 = resolvePythonImportPath(db, importerPath, importedName);
+      const usedMembers = collectNamespaceMembers(body, localName);
+      return [{
+        importedName,
+        localName,
+        sourcePath: sourcePath2,
+        kind: "namespace",
+        used: hasIdentifierUsage(body, localName) || usedMembers.length > 0,
+        usedMembers
+      }];
+    });
+  }
+  const sourcePath = statement.module ? resolvePythonImportPath(db, importerPath, statement.module) : null;
+  const results = [];
+  for (const entry of splitTopLevel(normalizedClause)) {
+    const cleaned = entry.trim().replace(/,$/, "");
+    if (!cleaned) continue;
+    if (cleaned === "*") {
+      results.push({
+        importedName: "*",
+        localName: null,
+        sourcePath,
+        kind: "side-effect",
+        used: true,
+        usedMembers: []
+      });
+      continue;
+    }
+    const [importedName, alias] = cleaned.split(/\s+as\s+/);
+    const localName = (alias ?? importedName).trim();
+    results.push({
+      importedName: importedName.trim(),
+      localName,
+      sourcePath,
+      kind: "named",
+      used: hasIdentifierUsage(body, localName),
+      usedMembers: []
+    });
+  }
+  return results;
+}
+function parseImportClause(clause) {
+  const trimmed = clause.trim().replace(/^type\s+/, "");
+  const [first, second] = splitImportClause(trimmed);
+  const entries = [];
+  if (first) {
+    entries.push(...parseImportBinding(first));
+  }
+  if (second) {
+    entries.push(...parseImportBinding(second));
+  }
+  return entries;
+}
+function parseImportBinding(binding) {
+  const trimmed = binding.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("{")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitTopLevel(inner).map((entry) => {
+      const cleaned = entry.trim().replace(/^type\s+/, "");
+      const [importedName, alias] = cleaned.split(/\s+as\s+/);
+      return {
+        importedName: importedName.trim(),
+        localName: (alias ?? importedName).trim(),
+        kind: "named"
+      };
+    });
+  }
+  if (trimmed.startsWith("* as ")) {
+    return [{
+      importedName: "*",
+      localName: trimmed.slice(5).trim(),
+      kind: "namespace"
+    }];
+  }
+  return [{
+    importedName: "default",
+    localName: trimmed,
+    kind: "default"
+  }];
+}
+function splitImportClause(clause) {
+  let depth = 0;
+  for (let i = 0; i < clause.length; i++) {
+    const char = clause[i];
+    if (char === "{") depth++;
+    if (char === "}") depth--;
+    if (char === "," && depth === 0) {
+      return [clause.slice(0, i).trim(), clause.slice(i + 1).trim()];
+    }
+  }
+  return [clause.trim(), null];
+}
+function splitTopLevel(input) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "{" || char === "[" || char === "(") depth++;
+    if (char === "}" || char === "]" || char === ")") depth--;
+    if (char === "," && depth === 0) {
+      parts.push(input.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(input.slice(start));
+  return parts;
+}
+function buildUsageBody(source, start, end) {
+  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
+  return stripCommentsAndStrings(masked);
+}
+function stripCommentsAndStrings(source) {
+  return source.replace(/'''[\s\S]*?'''/g, " ").replace(/"""[\s\S]*?"""/g, " ").replace(/#.*$/gm, " ").replace(/\/\/.*$/gm, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/`(?:\\[\s\S]|[^`])*`/g, " ").replace(/'(?:\\.|[^'\\\r\n])*'/g, " ").replace(/"(?:\\.|[^"\\\r\n])*"/g, " ");
+}
+function hasIdentifierUsage(body, identifier) {
+  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
+}
+function collectNamespaceMembers(body, namespaceName) {
+  const members2 = /* @__PURE__ */ new Set();
+  const regex = new RegExp(`\\b${escapeRegex(namespaceName)}\\s*\\.\\s*([A-Za-z_$][\\w$]*)`, "g");
+  for (const match of body.matchAll(regex)) {
+    const member = match[1];
+    if (member) {
+      members2.add(member);
+    }
+  }
+  return [...members2];
+}
+function resolveImportPath(db, importerPath, specifier) {
+  if (isPythonSourcePath(importerPath)) {
+    return resolvePythonImportPath(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 absolute = resolve2(importerDir, specifier);
+  const indexedPaths = getIndexedPaths2(db);
+  for (const candidate of candidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath2(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return normalizePath2(relative2(db.config.projectRoot, absolute));
+}
+function resolvePythonImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths2(db);
+  let basePath;
+  if (specifier.startsWith(".")) {
+    const match = specifier.match(/^(\.+)(.*)$/);
+    if (!match) return null;
+    const dots = match[1].length;
+    const remainder = match[2].replace(/^\./, "");
+    let baseDir = dirname2(join6(db.config.projectRoot, importerPath));
+    for (let i = 1; i < dots; i++) {
+      baseDir = dirname2(baseDir);
+    }
+    basePath = remainder ? resolve2(baseDir, remainder.replace(/\./g, "/")) : baseDir;
+  } else {
+    basePath = resolve2(db.config.projectRoot, specifier.replace(/\./g, "/"));
+  }
+  for (const candidate of pythonCandidateImportPaths(basePath)) {
+    const relativeCandidate = normalizePath2(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function pythonCandidateImportPaths(basePath) {
+  const ext = extname(basePath);
+  if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [
+    `${basePath}.py`,
+    `${basePath}.pyi`,
+    join6(basePath, "__init__.py"),
+    join6(basePath, "__init__.pyi")
+  ];
+}
+function candidateImportPaths(absolute) {
+  const ext = extname(absolute);
+  const candidates = /* @__PURE__ */ new Set();
+  if (ext) {
+    candidates.add(absolute);
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(absolute.slice(0, -ext.length) + sourceExt);
+    }
+  } else {
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(`${absolute}${sourceExt}`);
+      candidates.add(join6(absolute, `index${sourceExt}`));
+    }
+  }
+  return [...candidates];
+}
+function getIndexedPaths2(db) {
+  const cached = INDEXED_PATH_CACHE.get(db);
+  if (cached) {
+    return cached;
+  }
+  const paths = new Set(
+    db.all(
+      `SELECT relative_path
+       FROM documents
+       WHERE 1 = 1
+         ${db.pathExclusionsFor("documents")}`
+    ).map((row) => normalizePath2(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
+  );
+  INDEXED_PATH_CACHE.set(db, paths);
+  return paths;
+}
+function getCachedMap(cache, db) {
+  let map = cache.get(db);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    cache.set(db, map);
+  }
+  return map;
+}
+function normalizePath2(path2) {
+  return path2.replace(/\\/g, "/");
+}
+function isPythonSourcePath(relativePath) {
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function pythonParenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance++;
+    if (char === ")") balance--;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 // src/queries/imports.ts
 function imports(db, filePattern) {
   const rows = db.all(
-    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file
+    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file, imp_d.relative_path AS importer
     FROM mentions m
     JOIN chunks c ON m.chunk_id = c.id
     JOIN documents imp_d ON c.document_id = imp_d.id
@@ -1621,11 +2321,21 @@ function imports(db, filePattern) {
     ORDER BY def_d.relative_path, gs.symbol`,
     `%${filePattern}%`
   );
-  return rows.map((r) => ({
+  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     fromFile: r.from_file ?? "(external)"
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const importer = findIndexedFile(db, filePattern);
+  if (!importer) return [];
+  return getSourceImports(db, importer).map((entry) => ({
+    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    fromFile: entry.sourcePath ?? "(external)"
+  }));
 }
 function importedBy(db, symbolPattern) {
   const rows = db.all(
@@ -1639,15 +2349,55 @@ function importedBy(db, symbolPattern) {
     ORDER BY d.relative_path`,
     `%${symbolPattern}%`
   );
-  return rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     fromFile: r.importer
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const target = findFirstSymbolMatch(db, symbolPattern);
+  const targetFile = target?.relativePath ?? null;
+  const targetLeaf = target ? leafName(target.symbol) : symbolPattern.replace(/\(\)$/, "");
+  const targetIsModule = target ? isModuleLikeSymbol(target.symbol) : false;
+  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)) continue;
+    for (const entry of getSourceImports(db, row.relative_path)) {
+      if (!entry.sourcePath) continue;
+      if (targetFile && normalizePath3(entry.sourcePath) !== normalizePath3(targetFile)) {
+        continue;
+      }
+      if (targetIsModule) {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (entry.kind === "named" && entry.importedName === targetLeaf) {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (entry.kind === "namespace" && entry.usedMembers.includes(targetLeaf)) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return [...importers].sort().map((importer) => ({
+    symbol: target?.symbol ?? targetLeaf,
+    shortName: target ? shortenSymbol(target.symbol) : targetLeaf,
+    fromFile: importer
+  }));
 }
 function unusedImports(db, filePattern) {
   const rows = db.all(
-    `SELECT gs.symbol, d.relative_path AS imported_in
+    `SELECT gs.symbol, d.relative_path AS imported_in, d.relative_path AS importer
     FROM mentions m
     JOIN chunks c ON m.chunk_id = c.id
     JOIN documents d ON c.document_id = d.id
@@ -1659,17 +2409,59 @@ function unusedImports(db, filePattern) {
         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 = 0
+          AND ref_m.role != 1
           AND ref_c.document_id = d.id
       )
     ORDER BY d.relative_path, gs.symbol`,
     `%${filePattern}%`
   );
-  return rows.map((r) => ({
+  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     importedIn: r.imported_in
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const importer = findIndexedFile(db, filePattern);
+  if (!importer) return [];
+  return getSourceImports(db, importer).filter((entry) => entry.kind !== "side-effect" && !entry.used).map((entry) => ({
+    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    importedIn: importer
+  }));
+}
+function findIndexedFile(db, filePattern) {
+  const doc = db.get(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE ?
+       ${db.pathExclusionsFor("documents")}
+     LIMIT 1`,
+    `%${filePattern}%`
+  );
+  if (!doc || db.isIgnored(doc.relative_path)) {
+    return null;
+  }
+  return doc.relative_path;
+}
+function renderImportSymbol(importedName, localName, kind) {
+  if (kind === "namespace" && importedName === "*" && localName) {
+    return `* as ${localName}`;
+  }
+  if (kind === "default" && localName) {
+    return `default as ${localName}`;
+  }
+  if (kind === "side-effect") {
+    return "(side effect import)";
+  }
+  if (localName && localName !== importedName) {
+    return `${importedName} as ${localName}`;
+  }
+  return importedName;
+}
+function normalizePath3(path2) {
+  return path2.replace(/\\/g, "/");
 }
 
 // src/queries/outline.ts
@@ -1709,38 +2501,26 @@ function outline(db, filePattern) {
 
 // src/queries/members.ts
 function members(db, symbolPattern) {
-  const parents = db.all(
-    `SELECT symbol FROM global_symbols WHERE symbol LIKE ?`,
-    `%${symbolPattern}%`
-  );
-  if (parents.length === 0) return [];
-  const placeholders = parents.map(() => "?").join(",");
-  const parentSymbols = parents.map((p) => p.symbol);
+  const parent = findFirstSymbolMatch(db, symbolPattern);
+  if (!parent) return [];
   const rows = db.all(
     `SELECT gs.symbol, der.start_line, der.end_line
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    WHERE gs.enclosing_symbol IN (${placeholders})
-      ${db.symbolNoise}
-    ORDER BY der.start_line`,
-    ...parentSymbols
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     WHERE der.document_id = ?
+       AND gs.symbol != ?
+       ${db.symbolNoiseFor("gs")}
+     ORDER BY der.start_line`,
+    parent.documentId,
+    parent.symbol
   );
-  return rows.map((r) => {
-    const parsed = parseSymbol(r.symbol);
-    let kind = "unknown";
-    if (!("kind" in parsed)) {
-      const sym = parsed;
-      const last = sym.descriptors[sym.descriptors.length - 1];
-      if (last) kind = last.suffix;
-    }
-    return {
-      symbol: r.symbol,
-      shortName: shortenSymbol(r.symbol),
-      startLine: r.start_line,
-      endLine: r.end_line,
-      kind
-    };
-  });
+  return rows.filter((row) => isDirectChildSymbol(parent.symbol, row.symbol)).map((row) => ({
+    symbol: row.symbol,
+    shortName: shortenSymbol(row.symbol),
+    startLine: row.start_line,
+    endLine: row.end_line,
+    kind: leafSuffix(row.symbol) ?? "unknown"
+  }));
 }
 
 // src/queries/fan.ts
@@ -1751,7 +2531,7 @@ function fanIn(db, symbolPattern) {
     JOIN chunks c ON m.chunk_id = c.id
     JOIN global_symbols gs ON m.symbol_id = gs.id
     WHERE gs.symbol LIKE ?
-      AND m.role = 0
+      AND m.role != 1
     GROUP BY gs.id
     ORDER BY file_count DESC`,
     `%${symbolPattern}%`
@@ -1771,7 +2551,7 @@ function fanOut(db, filePattern) {
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents def_d ON der.document_id = def_d.id
     WHERE d.relative_path LIKE ?
-      AND m.role = 0
+      AND m.role != 1
       AND def_d.id != d.id
     GROUP BY d.id
     ORDER BY symbol_count DESC`,
@@ -1792,7 +2572,7 @@ function topFanIn(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents def_d ON der.document_id = def_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       ${db.pathExclusionsFor("def_d")}
       ${db.symbolNoiseFor("gs")}
       ${scopeFilter}
@@ -1818,7 +2598,7 @@ function topFanOut(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents def_d ON der.document_id = def_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       AND def_d.id != d.id
       ${db.pathExclusionsFor("d")}
       ${db.symbolNoiseFor("gs")}
@@ -1850,7 +2630,7 @@ function coupling(db, file1, file2) {
         SELECT 1 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 = gs.id AND m.role = 0 AND d.relative_path LIKE ?
+        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path LIKE ?
       )
     ) OR (
       -- Defined in file2, referenced in file1
@@ -1863,7 +2643,7 @@ function coupling(db, file1, file2) {
         SELECT 1 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 = gs.id AND m.role = 0 AND d.relative_path LIKE ?
+        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path LIKE ?
       )
     )`,
     `%${file1}%`,
@@ -1891,7 +2671,7 @@ function topCoupling(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents def_d ON der.document_id = def_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       AND def_d.id != ref_d.id
       ${db.pathExclusionsFor("def_d", "ref_d")}
       ${scopeFilter}
@@ -1972,7 +2752,7 @@ function bottlenecks(db, opts = {}) {
         (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 = 0
+         WHERE ref_m.symbol_id = gs.id AND ref_m.role != 1
         ) AS fan_in,
         (SELECT COUNT(DISTINCT ref_gs.id)
          FROM mentions ref_m
@@ -1980,7 +2760,7 @@ function bottlenecks(db, opts = {}) {
          JOIN global_symbols ref_gs ON ref_m.symbol_id = ref_gs.id
          JOIN defn_enclosing_ranges ref_der ON ref_gs.id = ref_der.symbol_id
          WHERE ref_c.document_id = def_d.id
-           AND ref_m.role = 0
+           AND ref_m.role != 1
            AND ref_der.document_id != def_d.id
         ) AS fan_out
       FROM global_symbols gs
@@ -2032,18 +2812,18 @@ function isolated(db, opts = {}) {
       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 = 0 AND c.document_id != d.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 = 0 AND c.document_id = d.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)).map((r) => ({
+  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,
@@ -2216,80 +2996,6 @@ function kindCounts(db, opts = {}) {
   }));
 }
 
-// src/queries/test-coverage.ts
-function testCoverage(db, symbolPattern) {
-  const syms = db.all(
-    `SELECT gs.id, gs.symbol, 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")}
-      ${db.symbolNoiseFor("gs")}
-    ORDER BY d.relative_path`,
-    `%${symbolPattern}%`
-  );
-  const testPatternSql = testFileMatchSql("ref_d", TEST_FILE_PATTERNS);
-  return syms.filter((s) => !db.isIgnored(s.relative_path)).map((s) => {
-    const testFiles = db.all(
-      `SELECT DISTINCT ref_d.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
-        WHERE m.symbol_id = ?
-          AND m.role = 0
-          AND (${testPatternSql})
-        ORDER BY ref_d.relative_path`,
-      s.id
-    ).map((r) => r.relative_path);
-    return {
-      symbol: s.symbol,
-      shortName: shortenSymbol(s.symbol),
-      definedIn: s.relative_path,
-      testFiles,
-      covered: testFiles.length > 0
-    };
-  });
-}
-function testCoverageSummary(db, opts = {}) {
-  const { scope, minLoc = 3 } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const testPatternSql = testFileExclusionSql("d");
-  const symbols2 = db.all(
-    `SELECT gs.id
-    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 ${testPatternSql}
-      ${db.symbolNoiseFor("gs")}
-      AND gs.symbol NOT LIKE '%#%'
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}`,
-    minLoc
-  );
-  const testRefSql = testFileMatchSql("ref_d", TEST_FILE_PATTERNS);
-  let covered = 0;
-  for (const s of symbols2) {
-    const hasTest = db.get(
-      `SELECT COUNT(*) AS c 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 = 0 AND (${testRefSql})`,
-      s.id
-    );
-    if (hasTest && hasTest.c > 0) covered++;
-  }
-  const total = symbols2.length;
-  return {
-    total,
-    covered,
-    uncovered: total - covered,
-    percent: total > 0 ? Math.round(covered / total * 100) : 0
-  };
-}
-
 // src/queries/doc-coverage.ts
 function docCoverage(db, opts = {}) {
   const { scope, minLoc = 3, limit = 50 } = opts;
@@ -2393,10 +3099,12 @@ function deepChains(db, opts = {}) {
 
 // src/queries/hierarchy.ts
 function hierarchy(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) return [];
   const sym = db.get(
     `SELECT symbol, enclosing_symbol FROM global_symbols
-     WHERE symbol LIKE ? LIMIT 1`,
-    `%${symbolPattern}%`
+     WHERE id = ? LIMIT 1`,
+    match.symbolId
   );
   if (!sym) return [];
   const chain = [
@@ -2420,7 +3128,30 @@ function hierarchy(db, symbolPattern) {
     current = parent.enclosing_symbol;
     depth++;
   }
-  return chain;
+  if (chain.length > 1) {
+    return chain;
+  }
+  const parsed = parseSymbol(sym.symbol);
+  if ("kind" in parsed) {
+    return chain;
+  }
+  const descriptors = parsed.descriptors;
+  if (descriptors.length <= 1) {
+    return chain;
+  }
+  const syntheticChain = [chain[0]];
+  for (let i = descriptors.length - 2, syntheticDepth = 1; i >= 0; i--, syntheticDepth++) {
+    const partial = descriptors.slice(0, i + 1);
+    const shortName = partial.map(
+      (descriptor) => descriptor.suffix === "method" ? `${descriptor.name}()` : descriptor.name.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|rs|java|scala|kt|kts|rb|go|cs|vb|dart|php|c|cc|cpp|cxx|h|hpp)$/, "")
+    ).join(":");
+    syntheticChain.push({
+      symbol: shortName,
+      shortName,
+      depth: syntheticDepth
+    });
+  }
+  return syntheticChain;
 }
 
 // src/queries/call-graph.ts
@@ -2440,7 +3171,7 @@ function callGraph(db, symbolPattern) {
     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 = 0
+      AND m.role != 1
       AND caller_gs.id != ?
       ${db.symbolNoiseFor("caller_gs")}
       ${db.pathExclusionsFor("caller_d")}
@@ -2471,6 +3202,7 @@ 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 (!isFunctionLikeSymbol(target.symbol)) return [];
   const candidates = getAllCalleeFingerprints(db, {
     minCallees: 3,
     excludeSymbol: target.symbol
@@ -2620,6 +3352,7 @@ function getAllCalleeFingerprints(db, opts) {
   const fingerprints = [];
   for (const sym of symbols2) {
     if (db.isIgnored(sym.relative_path)) continue;
+    if (!isFunctionLikeSymbol(sym.symbol)) continue;
     const calleeRows = getCalleeRowsForSymbol(db, {
       documentId: sym.document_id,
       startLine: sym.start_line,
@@ -3068,7 +3801,7 @@ function affected(db, symbolPattern, opts = {}) {
       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 IN (${placeholders})
-        AND m.role = 0
+        AND m.role != 1
         AND enc_gs.id NOT IN (${placeholders})
         ${db.symbolNoiseFor("enc_gs")}
         ${db.pathExclusionsFor("enc_d")}
@@ -3113,39 +3846,24 @@ function changeSurface(db, filePattern) {
     ORDER BY der.start_line`,
     doc.id
   );
-  const testPatternSql = testFileMatchSql("ref_d", TEST_FILE_PATTERNS);
   const symbols2 = [];
   let totalExternalConsumers = 0;
-  let coveredCount = 0;
   for (const sym of syms) {
     const consumerRow = db.get(
       `SELECT COUNT(DISTINCT c.document_id) AS consumer_count
       FROM mentions m
       JOIN chunks c ON m.chunk_id = c.id
       WHERE m.symbol_id = ?
-        AND m.role = 0
+        AND m.role != 1
         AND c.document_id != ?`,
       sym.symbol_id,
       doc.id
     );
     const externalConsumers = consumerRow?.consumer_count ?? 0;
-    const testFiles = db.all(
-      `SELECT DISTINCT ref_d.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
-      WHERE m.symbol_id = ?
-        AND m.role = 0
-        AND (${testPatternSql})
-      ORDER BY ref_d.relative_path`,
-      sym.symbol_id
-    ).map((r) => r.relative_path);
-    const hasTests = testFiles.length > 0;
-    if (hasTests) coveredCount++;
     let riskLevel;
-    if (externalConsumers > 10 && !hasTests) {
+    if (externalConsumers > 10) {
       riskLevel = "high";
-    } else if (externalConsumers > 5 || !hasTests) {
+    } else if (externalConsumers > 0) {
       riskLevel = "medium";
     } else {
       riskLevel = "low";
@@ -3157,42 +3875,33 @@ function changeSurface(db, filePattern) {
       startLine: sym.start_line,
       endLine: sym.end_line,
       externalConsumers,
-      testFiles,
       riskLevel
     });
   }
-  const testCoveragePercent = symbols2.length > 0 ? Math.round(coveredCount / symbols2.length * 100) : 0;
   return {
     file: doc.relative_path,
     symbols: symbols2,
-    totalExternalConsumers,
-    testCoveragePercent
+    totalExternalConsumers
   };
 }
 
 // src/queries/diff-impact.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 function diffImpact(db, opts = {}) {
   const { base = "HEAD" } = opts;
   let changedFileLines;
   try {
-    const stdout = execFileSync3("git", ["diff", "--name-only", base], {
-      encoding: "utf-8",
-      cwd: db.config.projectRoot,
-      timeout: 1e4
-    });
-    changedFileLines = stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    changedFileLines = getChangedFiles(db.config.projectRoot, base);
   } catch {
     return {
       changedFiles: [],
       changedSymbols: [],
       affectedConsumers: [],
-      uncoveredSymbols: [],
       summary: {
         totalChangedFiles: 0,
         totalChangedSymbols: 0,
         totalAffectedFiles: 0,
-        testCoveragePercent: 0
+        note: "Unable to compute git diff."
       }
     };
   }
@@ -3201,12 +3910,11 @@ function diffImpact(db, opts = {}) {
       changedFiles: [],
       changedSymbols: [],
       affectedConsumers: [],
-      uncoveredSymbols: [],
       summary: {
         totalChangedFiles: 0,
         totalChangedSymbols: 0,
         totalAffectedFiles: 0,
-        testCoveragePercent: 0
+        note: "No changed files found."
       }
     };
   }
@@ -3229,12 +3937,11 @@ function diffImpact(db, opts = {}) {
       changedFiles: changedFileLines,
       changedSymbols: [],
       affectedConsumers: [],
-      uncoveredSymbols: [],
       summary: {
         totalChangedFiles: changedFileLines.length,
         totalChangedSymbols: 0,
         totalAffectedFiles: 0,
-        testCoveragePercent: 0
+        note: "Changed files are not present in the current SCIP index."
       }
     };
   }
@@ -3249,18 +3956,15 @@ function diffImpact(db, opts = {}) {
     ORDER BY d.relative_path`,
     ...changedDocIds
   );
-  const testPatternSql = testFileMatchSql("ref_d", TEST_FILE_PATTERNS);
   const changedSymbols = [];
   const consumerMap = /* @__PURE__ */ new Map();
-  const uncoveredSymbols = [];
-  let coveredCount = 0;
   for (const sym of syms) {
     const fanInRow = db.get(
       `SELECT COUNT(DISTINCT c.document_id) AS fan_in
       FROM mentions m
       JOIN chunks c ON m.chunk_id = c.id
       WHERE m.symbol_id = ?
-        AND m.role = 0`,
+        AND m.role != 1`,
       sym.symbol_id
     );
     const fanIn2 = fanInRow?.fan_in ?? 0;
@@ -3277,7 +3981,7 @@ function diffImpact(db, opts = {}) {
       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 = 0
+        AND m.role != 1
         AND ref_d.relative_path NOT IN (${changedFiles.map(() => "?").join(",")})
         ${db.pathExclusionsFor("ref_d")}`,
       sym.symbol_id,
@@ -3290,42 +3994,39 @@ function diffImpact(db, opts = {}) {
       }
       consumerMap.get(consumer.relative_path).add(shortName);
     }
-    const hasTest = db.get(
-      `SELECT COUNT(*) AS c
-      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 = 0
-        AND (${testPatternSql})`,
-      sym.symbol_id
-    );
-    if (hasTest && hasTest.c > 0) {
-      coveredCount++;
-    } else {
-      uncoveredSymbols.push({
-        symbol: sym.symbol,
-        shortName,
-        file: sym.relative_path
-      });
-    }
   }
   const affectedConsumers = [...consumerMap.entries()].map(([file, symbols2]) => ({ file, consumedSymbols: symbols2.size })).sort((a, b) => b.consumedSymbols - a.consumedSymbols);
-  const totalSymbols = changedSymbols.length;
-  const testCoveragePercent = totalSymbols > 0 ? Math.round(coveredCount / totalSymbols * 100) : 0;
   return {
     changedFiles,
     changedSymbols,
     affectedConsumers,
-    uncoveredSymbols,
     summary: {
       totalChangedFiles: changedFiles.length,
-      totalChangedSymbols: totalSymbols,
-      totalAffectedFiles: affectedConsumers.length,
-      testCoveragePercent
+      totalChangedSymbols: changedSymbols.length,
+      totalAffectedFiles: affectedConsumers.length
     }
   };
 }
+function getChangedFiles(projectRoot, base) {
+  const diff = execFileSync4("git", ["diff", "--name-only", base], {
+    encoding: "utf-8",
+    cwd: projectRoot,
+    timeout: 1e4
+  });
+  const staged = execFileSync4("git", ["diff", "--name-only", "--cached", base], {
+    encoding: "utf-8",
+    cwd: projectRoot,
+    timeout: 1e4
+  });
+  const untracked = execFileSync4("git", ["ls-files", "--others", "--exclude-standard"], {
+    encoding: "utf-8",
+    cwd: projectRoot,
+    timeout: 1e4
+  });
+  return [...new Set(
+    [diff, staged, untracked].flatMap((chunk) => chunk.split("\n")).map((line) => line.trim()).filter((line) => line.length > 0)
+  )];
+}
 
 // src/queries/drift.ts
 import path from "path";
@@ -3335,9 +4036,10 @@ function drift(db, opts) {
   const symbolRefs = buildSymbolRefGraph(db, scope);
   const results = [];
   for (const [file, deps2] of depGraph) {
-    if (isStructuralRole(path.basename(file))) continue;
+    if (shouldSkipDriftFile(file)) continue;
     const referencedFiles = symbolRefs.get(file) ?? /* @__PURE__ */ new Set();
     for (const dep of deps2) {
+      if (shouldSkipDriftFile(dep)) continue;
       if (!referencedFiles.has(dep)) {
         if (isLikelyTypeOnlyDep(dep)) continue;
         results.push({
@@ -3351,10 +4053,11 @@ function drift(db, opts) {
   }
   const layerRules = inferLayerRules(depGraph);
   for (const [file, deps2] of depGraph) {
-    if (isStructuralRole(path.basename(file))) continue;
-    const fileLayer = getTopDir(file);
+    if (shouldSkipDriftFile(file)) continue;
+    const fileLayer = getArchitecturalLayer(file);
     for (const dep of deps2) {
-      const depLayer = getTopDir(dep);
+      if (shouldSkipDriftFile(dep)) continue;
+      const depLayer = getArchitecturalLayer(dep);
       if (fileLayer === depLayer) continue;
       const violation = layerRules.get(`${fileLayer}->${depLayer}`);
       if (violation === "violation") {
@@ -3378,14 +4081,16 @@ function drift(db, opts) {
     if (files2.length < 3) continue;
     const depFreq = /* @__PURE__ */ new Map();
     for (const file of files2) {
-      if (isStructuralRole(path.basename(file))) continue;
+      if (shouldSkipDriftFile(file)) continue;
       for (const dep of depGraph.get(file) ?? []) {
+        if (shouldSkipDriftFile(dep)) continue;
         depFreq.set(dep, (depFreq.get(dep) ?? 0) + 1);
       }
     }
     for (const file of files2) {
-      if (isStructuralRole(path.basename(file))) continue;
+      if (shouldSkipDriftFile(file)) continue;
       for (const dep of depGraph.get(file) ?? []) {
+        if (shouldSkipDriftFile(dep)) continue;
         if ((depFreq.get(dep) ?? 0) === 1) {
           if (path.dirname(dep) === dir) continue;
           results.push({
@@ -3416,7 +4121,7 @@ function buildSymbolRefGraph(db, scope) {
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents d2 ON der.document_id = d2.id
     WHERE d1.id != d2.id
-      AND m.role = 0
+      AND m.role != 1
       ${db.pathExclusionsFor("d1", "d2")}
       ${scopeFilter}`
   );
@@ -3432,10 +4137,12 @@ function inferLayerRules(depGraph) {
   const layerEdges = /* @__PURE__ */ new Map();
   const layerSet = /* @__PURE__ */ new Set();
   for (const [file, deps2] of depGraph) {
-    const fromLayer = getTopDir(file);
+    if (shouldSkipDriftFile(file)) continue;
+    const fromLayer = getArchitecturalLayer(file);
     layerSet.add(fromLayer);
     for (const dep of deps2) {
-      const toLayer = getTopDir(dep);
+      if (shouldSkipDriftFile(dep)) continue;
+      const toLayer = getArchitecturalLayer(dep);
       if (fromLayer === toLayer) continue;
       layerSet.add(toLayer);
       const key = `${fromLayer}->${toLayer}`;
@@ -3448,13 +4155,23 @@ function inferLayerRules(depGraph) {
   }
   return rules;
 }
-function getTopDir(filePath) {
-  const parts = filePath.split("/");
-  return parts[0] ?? filePath;
+function getArchitecturalLayer(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length <= 1) {
+    return "(root)";
+  }
+  if (parts.length >= 3 && ["src", "lib", "app", "server", "client"].includes(parts[0])) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
 }
 function isLikelyTypeOnlyDep(dep) {
   return dep.includes("types") || dep.endsWith(".d.ts");
 }
+function shouldSkipDriftFile(filePath) {
+  return isStructuralRole(path.basename(filePath)) || isTestLikePath(filePath);
+}
 function isStructuralRole(basename) {
   if (basename === "index.ts" || basename === "index.js") return true;
   if (basename === "cli.ts" || basename === "main.ts" || basename === "main.rs") return true;
@@ -3462,6 +4179,11 @@ function isStructuralRole(basename) {
   if (basename === "health.ts" || basename === "health.js") return true;
   return false;
 }
+function isTestLikePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const basename = path.basename(normalized);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename) || /^test[_-]/.test(basename) || /^test\./.test(basename);
+}
 
 // src/queries/wrapper-candidates.ts
 function wrapperCandidates(db, opts) {
@@ -3486,7 +4208,7 @@ function wrapperCandidates(db, opts) {
            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 = 0
+           AND ref_m.role != 1
            AND ref_c.document_id != der.document_id
          LIMIT 1
         ) AS caller_symbol,
@@ -3503,11 +4225,11 @@ function wrapperCandidates(db, opts) {
              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 = 0
+             AND ref_m2.role != 1
              AND ref_c2.document_id != der.document_id
            LIMIT 1
          )
-         AND caller_ref_m.role = 0
+         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
@@ -3527,7 +4249,7 @@ function wrapperCandidates(db, opts) {
           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 = 0
+            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
@@ -3624,7 +4346,7 @@ function staleAbstractions(db, opts) {
          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 = 0
+           AND ref_m.role != 1
            AND ref_c.document_id != der.document_id
         ) AS consumers
       FROM global_symbols gs
@@ -3676,7 +4398,7 @@ function complexityHotspots(db, opts) {
       (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 = 0
+       WHERE ref_m.symbol_id = gs.id AND ref_m.role != 1
       ) AS fan_in,
       -- fanOut: distinct symbols referenced within this definition range
       -- that are defined in different files
@@ -3688,7 +4410,7 @@ function complexityHotspots(db, opts) {
        WHERE out_c.document_id = der.document_id
          AND out_c.start_line >= der.start_line
          AND out_c.end_line <= der.end_line
-         AND out_m.role = 0
+         AND out_m.role != 1
          AND out_gs.id != gs.id
          AND out_der.document_id != der.document_id
       ) AS fan_out,
@@ -3700,7 +4422,7 @@ function complexityHotspots(db, opts) {
        WHERE callee_c.document_id = der.document_id
          AND callee_c.start_line >= der.start_line
          AND callee_c.end_line <= der.end_line
-         AND callee_m.role = 0
+         AND callee_m.role != 1
          AND callee_gs.id != gs.id
       ) AS callee_count
     FROM global_symbols gs
@@ -3717,7 +4439,7 @@ function complexityHotspots(db, opts) {
       * CAST((SELECT COUNT(DISTINCT ref_c2.document_id)
               FROM mentions ref_m2
               JOIN chunks ref_c2 ON ref_m2.chunk_id = ref_c2.id
-              WHERE ref_m2.symbol_id = gs.id AND ref_m2.role = 0
+              WHERE ref_m2.symbol_id = gs.id AND ref_m2.role != 1
              ) AS REAL) / 5.0
       * MAX(CAST((SELECT COUNT(DISTINCT out_gs2.id)
                   FROM mentions out_m2
@@ -3727,7 +4449,7 @@ function complexityHotspots(db, opts) {
                   WHERE out_c2.document_id = der.document_id
                     AND out_c2.start_line >= der.start_line
                     AND out_c2.end_line <= der.end_line
-                    AND out_m2.role = 0
+                    AND out_m2.role != 1
                     AND out_gs2.id != gs.id
                     AND out_der2.document_id != der.document_id
                  ) AS REAL) / 5.0, 1.0)
@@ -3756,7 +4478,7 @@ function complexityHotspots(db, opts) {
 function health(db, opts = {}) {
   const { scope } = opts;
   const s = stats(db);
-  const deadResult = dead(db, { scope, minLoc: 3, skipBarrels: false });
+  const deadResult = dead(db, { scope, minLoc: 3, skipBarrels: true });
   const isolatedResult = isolated(db, { scope, minLoc: 3 });
   const cycleResult = cycles(db, { scope });
   const similarResult = similarAll(db, { scope, minSimilarity: 0.6, limit: 50, minCallees: 4 });
@@ -3766,20 +4488,13 @@ function health(db, opts = {}) {
   const staleResult = staleAbstractions(db, { scope, minLoc: 3, limit: 50 });
   const driftResult = drift(db, { scope });
   const complexResult = complexityHotspots(db, { scope, minLoc: 10, limit: 10 });
-  const testResult = testCoverageSummary(db, { scope, minLoc: 3 });
-  const isolatedLoc = isolatedResult.reduce((sum, r) => sum + r.loc, 0);
-  const entryPointPatterns = ["/index.ts", "/index.js", "cli.ts", "worker.ts", "postinstall.ts", "/mod.rs", "__init__.py", "main.ts", "main.rs", "main.go", "main.py"];
-  const isEntryPoint = (path2) => entryPointPatterns.some((p) => path2.endsWith(p));
   const trueDeadSymbols = deadResult.symbols.filter(
-    (s2) => !isEntryPoint(s2.relativePath) && s2.kind === "dead-code"
+    (s2) => !isEntrySurface(db, s2.relativePath) && s2.kind === "dead-code"
   );
   const trueDeadCount = trueDeadSymbols.length;
   const trueDeadLoc = trueDeadSymbols.reduce((sum, s2) => sum + s2.loc, 0);
-  const fileInternalCount = deadResult.symbols.filter(
-    (s2) => !isEntryPoint(s2.relativePath) && s2.kind === "file-internal"
-  ).length;
   const trueIsolatedCount = isolatedResult.filter(
-    (s2) => !isEntryPoint(s2.relativePath)
+    (s2) => !isEntrySurface(db, s2.relativePath)
   ).length;
   const filesWithFunctions = new Set(
     db.all(
@@ -3808,16 +4523,6 @@ function health(db, opts = {}) {
       locRecoverable: trueDeadLoc
     });
   }
-  if (testResult.percent < 50) {
-    actions.push({
-      category: "Test coverage",
-      description: `${testResult.percent}% of symbols referenced by tests (${testResult.uncovered} uncovered)`,
-      effort: "high",
-      impact: "high",
-      count: testResult.uncovered,
-      locRecoverable: 0
-    });
-  }
   if (trueIsolatedCount > 0) {
     actions.push({
       category: "Isolated symbols",
@@ -3825,7 +4530,7 @@ function health(db, opts = {}) {
       effort: "low",
       impact: "medium",
       count: trueIsolatedCount,
-      locRecoverable: isolatedResult.filter((s2) => !isEntryPoint(s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0)
+      locRecoverable: isolatedResult.filter((s2) => !isEntrySurface(db, s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0)
     });
   }
   if (cycleResult.length > 0) {
@@ -3936,8 +4641,6 @@ function health(db, opts = {}) {
   score -= Math.min(5, Math.round(driftPercent * 50));
   const extremeComplexity = complexResult.filter((r) => r.score > 50).length;
   score -= Math.min(5, extremeComplexity * 2);
-  const coverageDeduction = Math.round(15 * (1 - testResult.percent / 100));
-  score -= coverageDeduction;
   score = Math.max(0, Math.min(100, score));
   return {
     score,
@@ -3950,7 +4653,7 @@ function health(db, opts = {}) {
       deadSymbols: trueDeadCount,
       deadLoc: trueDeadLoc,
       isolatedSymbols: trueIsolatedCount,
-      isolatedLoc: isolatedResult.filter((s2) => !isEntryPoint(s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0),
+      isolatedLoc: isolatedResult.filter((s2) => !isEntrySurface(db, s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0),
       cycles: cycleResult.length,
       similarPairs: trueSimilarCount,
       extractionCandidates: extractResult.length,
@@ -3958,8 +4661,7 @@ function health(db, opts = {}) {
       passthroughs: passthroughResult.length,
       staleTypes: trueStaleCount,
       driftedFiles: trueDriftCount,
-      complexityHotspotCount: complexResult.length,
-      testCoveragePercent: testResult.percent
+      complexityHotspotCount: complexResult.length
     },
     actions,
     topComplexity: complexResult.slice(0, 5).map((r) => ({
@@ -3995,7 +4697,11 @@ function convergence(db, symbolPatternA, symbolPatternB) {
   const union = /* @__PURE__ */ new Set([...calleesA, ...calleesB]);
   const similarity = union.size > 0 ? shared.length / union.size : 0;
   let strategy;
-  if (uniqueA.length === 0 && uniqueB.length === 0) {
+  if (union.size === 0) {
+    strategy = "Neither function calls other tracked symbols. There is no callee-pattern evidence for consolidation; inspect the source bodies directly.";
+  } else if (shared.length === 0) {
+    strategy = "These functions do not share any callees. They are not a callee-based consolidation candidate.";
+  } else if (uniqueA.length === 0 && uniqueB.length === 0) {
     strategy = "These functions have identical callee sets. One can replace the other directly.";
   } else if (uniqueA.length === 0) {
     strategy = `A is a subset of B. A can be replaced by calling B (B does everything A does plus more).`;
@@ -4030,8 +4736,8 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 }
 
 // src/queries/code.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 function code(db, symbolPattern, opts = {}) {
   const { context = 0 } = opts;
   const fileLineMatch = symbolPattern.match(/^(.+\.\w+):(\d+)-(\d+)$/);
@@ -4044,10 +4750,10 @@ function code(db, symbolPattern, opts = {}) {
     `SELECT language FROM documents WHERE relative_path = ?`,
     match.relativePath
   );
-  const filePath = join6(db.config.projectRoot, match.relativePath);
+  const filePath = join7(db.config.projectRoot, match.relativePath);
   let fileContent;
   try {
-    fileContent = readFileSync4(filePath, "utf-8");
+    fileContent = readFileSync5(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -4072,10 +4778,10 @@ function readFileRange(db, filePath, startLine, endLine, context) {
     `%${filePath}%`
   );
   if (!doc) return null;
-  const fullPath = join6(db.config.projectRoot, doc.relative_path);
+  const fullPath = join7(db.config.projectRoot, doc.relative_path);
   let fileContent;
   try {
-    fileContent = readFileSync4(fullPath, "utf-8");
+    fileContent = readFileSync5(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -4095,8 +4801,8 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 }
 
 // src/queries/complexity.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
 function complexity(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
   if (!match) return null;
@@ -4105,10 +4811,10 @@ function complexity(db, symbolPattern) {
     match.relativePath
   );
   const language = doc?.language ?? "unknown";
-  const filePath = join7(db.config.projectRoot, match.relativePath);
+  const filePath = join8(db.config.projectRoot, match.relativePath);
   let source = "";
   try {
-    const lines = readFileSync5(filePath, "utf-8").split("\n");
+    const lines = readFileSync6(filePath, "utf-8").split("\n");
     source = lines.slice(match.startLine, match.endLine + 1).join("\n");
   } catch {
   }
@@ -4120,7 +4826,7 @@ function complexity(db, symbolPattern) {
     `SELECT COUNT(DISTINCT c.document_id) AS c
     FROM mentions m
     JOIN chunks c ON m.chunk_id = c.id
-    WHERE m.symbol_id = ? AND m.role = 0`,
+    WHERE m.symbol_id = ? AND m.role != 1`,
     match.symbolId
   );
   const fanOut2 = new Set(
@@ -4141,7 +4847,7 @@ function complexity(db, symbolPattern) {
   };
 }
 function countBranches(source, language) {
-  const stripped = stripCommentsAndStrings(source);
+  const stripped = stripCommentsAndStrings2(source);
   let count = 0;
   const universalPatterns = [
     /\bif\b/g,
@@ -4188,7 +4894,7 @@ function countBranches(source, language) {
   }
   return count;
 }
-function stripCommentsAndStrings(source) {
+function stripCommentsAndStrings2(source) {
   return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "").replace(/#.*/g, "").replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/`(?:[^`\\]|\\.)*`/g, "``");
 }
 
@@ -4219,7 +4925,7 @@ function dataflow(db, symbolPattern) {
     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 = 0
+    WHERE m.symbol_id = ? AND m.role != 1
       ${db.pathExclusionsFor("d")}
     ORDER BY d.relative_path, c.start_line`,
     match.symbolId
@@ -4233,7 +4939,7 @@ function dataflow(db, symbolPattern) {
     JOIN documents other_d ON other_der.document_id = other_d.id
     WHERE other_c.document_id = ?
       AND other_c.start_line >= ? AND other_c.end_line <= ?
-      AND other_m.role = 0
+      AND other_m.role != 1
       AND other_gs.id != ?
       ${db.symbolNoiseFor("other_gs")}
       ${db.pathExclusionsFor("other_d")}
@@ -4256,11 +4962,11 @@ function dataflow(db, symbolPattern) {
       AND enc_der.end_line >= ref_c.end_line
     JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
     -- Find other symbols defined by that enclosing function's file
-    JOIN mentions consumer_m ON consumer_m.symbol_id = enc_gs.id AND consumer_m.role = 0
+    JOIN mentions consumer_m ON consumer_m.symbol_id = enc_gs.id AND consumer_m.role != 1
     JOIN chunks consumer_c ON consumer_m.chunk_id = consumer_c.id
     JOIN documents consumer_d ON consumer_c.document_id = consumer_d.id
     JOIN global_symbols consumer_gs ON consumer_m.symbol_id = consumer_gs.id
-    WHERE ref_m.symbol_id = ? AND ref_m.role = 0
+    WHERE ref_m.symbol_id = ? AND ref_m.role != 1
       AND consumer_d.id != ref_d.id
       ${db.symbolNoiseFor("consumer_gs")}
       ${db.pathExclusionsFor("consumer_d")}
@@ -4359,7 +5065,7 @@ function forwardSlice(db, match) {
     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
     -- Find other symbols referenced within that enclosing function
-    JOIN mentions out_m ON out_m.role = 0
+    JOIN mentions out_m ON out_m.role != 1
     JOIN chunks out_c ON out_m.chunk_id = out_c.id
       AND out_c.document_id = enc_der.document_id
       AND out_c.start_line >= enc_der.start_line
@@ -4367,7 +5073,7 @@ function forwardSlice(db, match) {
     JOIN global_symbols out_gs ON out_m.symbol_id = out_gs.id
     JOIN defn_enclosing_ranges out_der ON out_gs.id = out_der.symbol_id
     JOIN documents out_d ON out_der.document_id = out_d.id
-    WHERE ref_m.symbol_id = ? AND ref_m.role = 0
+    WHERE ref_m.symbol_id = ? AND ref_m.role != 1
       AND out_gs.id != ? AND out_gs.id != enc_gs.id
       AND out_d.id != ref_d.id
       ${db.symbolNoiseFor("out_gs")}
@@ -4415,7 +5121,7 @@ function redundantReexports(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents orig_d ON der.document_id = orig_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       AND (barrel_d.relative_path LIKE '%/index.ts'
         OR barrel_d.relative_path LIKE '%/index.js'
         OR barrel_d.relative_path = 'index.ts'
@@ -4431,6 +5137,7 @@ function redundantReexports(db, opts = {}) {
   const results = [];
   for (const row of reexportRows) {
     if (db.isIgnored(row.barrel_path) || db.isIgnored(row.original_path)) continue;
+    if (isLiveBarrel(db, row.barrel_path)) continue;
     const consumerCounts = db.get(
       `SELECT
         SUM(CASE WHEN uses_barrel = 1 THEN 1 ELSE 0 END) AS barrel_consumers,
@@ -4443,20 +5150,20 @@ function redundantReexports(db, opts = {}) {
             FROM mentions barrel_m
             JOIN chunks barrel_c ON barrel_m.chunk_id = barrel_c.id
             WHERE barrel_c.document_id = consumer_d.id
-              AND barrel_m.role = 0
+              AND barrel_m.role != 1
               AND barrel_m.symbol_id IN (
                 SELECT m2.symbol_id
                 FROM mentions m2
                 JOIN chunks c2 ON m2.chunk_id = c2.id
                 WHERE c2.document_id = ?
-                  AND m2.role = 0
+                  AND m2.role != 1
               )
           ) THEN 1 ELSE 0 END) AS uses_barrel
         FROM mentions ref_m
         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
         JOIN documents consumer_d ON ref_c.document_id = consumer_d.id
         WHERE ref_m.symbol_id = ?
-          AND ref_m.role = 0
+          AND ref_m.role != 1
           AND consumer_d.id != ?
           AND consumer_d.id != ?
           ${db.pathExclusionsFor("consumer_d")}
@@ -4562,27 +5269,25 @@ function normalizeSignature(raw) {
 
 // src/setup.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync2,
   symlinkSync,
   readlinkSync,
   unlinkSync
 } from "fs";
-import { join as join8, dirname as dirname2, resolve as resolve2 } from "path";
-import { homedir as homedir2, platform as platform2, arch } from "os";
-import { execFileSync as execFileSync4 } from "child_process";
+import { join as join9, dirname as dirname3, resolve as resolve3 } from "path";
+import { homedir as homedir2, platform as platform3 } from "os";
 import { fileURLToPath } from "url";
-var IS_WINDOWS2 = platform2() === "win32";
+var IS_WINDOWS3 = platform3() === "win32";
 var SKILLS = ["concrete-plan", "scip-explore", "scip-debloat", "scip-verify"];
-var SCIP_VERSION = "v0.7.0";
 function installSkills(opts = {}) {
   const log = opts.quiet ? () => {
   } : console.log;
   const thisFile = fileURLToPath(import.meta.url);
-  const skillsSource = resolve2(dirname2(thisFile), "..", "skills");
+  const skillsSource = resolve3(dirname3(thisFile), "..", "skills");
   const targets = [
-    join8(homedir2(), ".claude", "skills"),
-    join8(homedir2(), ".codex", "skills")
+    join9(homedir2(), ".claude", "skills"),
+    join9(homedir2(), ".codex", "skills")
   ];
   const result = {
     installed: [],
@@ -4590,23 +5295,23 @@ function installSkills(opts = {}) {
     alreadyLinked: []
   };
   for (const targetDir of targets) {
-    const parentDir = dirname2(targetDir);
-    if (!existsSync6(parentDir)) {
+    const parentDir = dirname3(targetDir);
+    if (!existsSync7(parentDir)) {
       continue;
     }
     mkdirSync2(targetDir, { recursive: true });
     const toolName = targetDir.includes(".codex") ? "Codex" : "Claude";
     for (const skill of SKILLS) {
-      const source = join8(skillsSource, skill);
-      const target = join8(targetDir, skill);
-      if (!existsSync6(source)) {
+      const source = join9(skillsSource, skill);
+      const target = join9(targetDir, skill);
+      if (!existsSync7(source)) {
         result.skipped.push(`${toolName}/${skill}`);
         continue;
       }
-      if (existsSync6(target)) {
+      if (existsSync7(target)) {
         try {
           const existing = readlinkSync(target);
-          if (resolve2(existing) === resolve2(source)) {
+          if (resolve3(existing) === resolve3(source)) {
             result.alreadyLinked.push(`${toolName}/${skill}`);
             log(`  ok:   ${skill} \u2192 ${toolName} (already linked)`);
             continue;
@@ -4618,88 +5323,29 @@ function installSkills(opts = {}) {
         }
         unlinkSync(target);
       }
-      symlinkSync(source, target, IS_WINDOWS2 ? "junction" : "dir");
+      symlinkSync(source, target, IS_WINDOWS3 ? "junction" : "dir");
       result.installed.push(`${toolName}/${skill}`);
       log(`  done: ${skill} \u2192 ${toolName}`);
     }
   }
   return result;
 }
-function isScipInstalled() {
-  try {
-    const cmd = IS_WINDOWS2 ? "where" : "which";
-    execFileSync4(cmd, ["scip"], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getScipDownloadUrl() {
-  const os = platform2();
-  const cpu = arch();
-  let osName;
-  let archName;
-  let ext;
-  switch (os) {
-    case "darwin":
-      osName = "darwin";
-      ext = "tar.gz";
-      break;
-    case "linux":
-      osName = "linux";
-      ext = "tar.gz";
-      break;
-    case "win32":
-      osName = "windows";
-      ext = "zip";
-      break;
-    default:
-      return null;
-  }
-  switch (cpu) {
-    case "arm64":
-      archName = "arm64";
-      break;
-    case "x64":
-      archName = "amd64";
-      break;
-    default:
-      return null;
-  }
-  const filename = `scip-${osName}-${archName}.${ext}`;
-  const url = `https://github.com/sourcegraph/scip/releases/download/${SCIP_VERSION}/${filename}`;
-  return { url, filename };
-}
-function printScipInstallInstructions() {
-  const download = getScipDownloadUrl();
-  console.log("\nThe `scip` CLI is required but not found on PATH.\n");
-  if (platform2() === "darwin") {
-    console.log("Install via Homebrew:");
-    console.log("  brew install sourcegraph/scip/scip\n");
-    console.log("Or download manually:");
-  } else {
-    console.log("Download from:");
-  }
-  if (download) {
-    console.log(`  ${download.url}
-`);
-  } else {
-    console.log(`  https://github.com/sourcegraph/scip/releases/tag/${SCIP_VERSION}
-`);
-  }
-  console.log("After installing, ensure `scip` is on your PATH and run `scip-query reindex`.");
-}
 
 // src/cli.ts
 function resolveProjectRoot() {
   return process.env["SCIP_QUERY_PROJECT_ROOT"] ?? process.cwd();
 }
+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"));
+}
 function openDb() {
   const projectRoot = resolveProjectRoot();
   const config = loadProjectConfig(projectRoot);
   const paths = resolveIndexPaths(projectRoot, config);
-  const dbPath = process.env["SCIP_QUERY_INDEX_DB"] ?? (existsSync7(paths.dbPath) ? paths.dbPath : join9(projectRoot, "index.db"));
-  if (!existsSync7(dbPath)) {
+  const dbPath = resolveActiveDbPath(projectRoot);
+  if (!existsSync8(dbPath)) {
     console.error(`error: No index.db found. Run: scip-query reindex`);
     process.exit(1);
   }
@@ -4724,6 +5370,61 @@ function runQuery(query, render) {
     render(query(db));
   });
 }
+var queries = {
+  stats,
+  files,
+  symbols,
+  methods,
+  refs,
+  trace,
+  deps,
+  rdeps,
+  system,
+  surface,
+  dead,
+  hotspots,
+  imports,
+  importedBy,
+  unusedImports,
+  outline,
+  members,
+  fanIn,
+  fanOut,
+  topFanIn,
+  topFanOut,
+  coupling,
+  topCoupling,
+  cycles,
+  bottlenecks,
+  isolated,
+  byKind,
+  kindCounts,
+  docCoverage,
+  deepChains,
+  hierarchy,
+  callGraph,
+  similar,
+  similarAll,
+  similarFiles,
+  similarChains,
+  extractCandidates,
+  affected,
+  changeSurface,
+  diffImpact,
+  drift,
+  wrapperCandidates,
+  passthroughCandidates,
+  staleAbstractions,
+  complexityHotspots,
+  health,
+  convergence,
+  code,
+  complexity,
+  dataflow,
+  slice,
+  redundantReexports,
+  similarSignatures
+};
 program.name("scip-query").description("Language-agnostic code intelligence CLI powered by SCIP indexes").version("0.1.0");
 program.command("reindex").description("Index the codebase and convert to SQLite").option("-l, --language <lang>", "Index only this language (can be repeated)", collect, []).option("--pnpm-workspaces", "Enable pnpm workspace support (TypeScript)").action(async (opts) => {
   const projectRoot = resolveProjectRoot();
@@ -4741,7 +5442,7 @@ program.command("reindex").description("Index the codebase and convert to SQLite
 });
 program.command("stats").description("Show index statistics").action(() => {
   runQuery(
-    (db) => stats(db),
+    (db) => queries.stats(db),
     (s) => {
       console.log(`Documents:   ${s.documents}`);
       console.log(`Symbols:     ${s.symbols}`);
@@ -4756,7 +5457,7 @@ program.command("stats").description("Show index statistics").action(() => {
 });
 program.command("files <pattern>").description("Find files matching a pattern").action((pattern) => {
   runQuery(
-    (db) => files(db, pattern),
+    (db) => queries.files(db, pattern),
     (results) => {
       for (const r of results) console.log(r.relativePath);
     }
@@ -4764,7 +5465,7 @@ program.command("files <pattern>").description("Find files matching a pattern").
 });
 program.command("symbols <file>").description("List symbols defined in a file (with line ranges + signatures)").action((file) => {
   runQuery(
-    (db) => symbols(db, file),
+    (db) => queries.symbols(db, file),
     (results) => {
       for (const r of results) {
         const sig = r.signature ? `  \u2014 ${r.signature}` : "";
@@ -4775,7 +5476,7 @@ program.command("symbols <file>").description("List symbols defined in a file (w
 });
 program.command("methods <className>").description("List methods of a class (with line ranges)").action((className) => {
   runQuery(
-    (db) => methods(db, className),
+    (db) => queries.methods(db, className),
     (results) => {
       for (const r of results) {
         console.log(`  ${r.startLine}-${r.endLine}  ${r.name}`);
@@ -4785,7 +5486,7 @@ program.command("methods <className>").description("List methods of a class (wit
 });
 program.command("refs <symbol>").description("Find all files referencing a symbol").action((symbol) => {
   runQuery(
-    (db) => refs(db, symbol),
+    (db) => queries.refs(db, symbol),
     (results) => {
       let prevFile = "";
       for (const r of results) {
@@ -4801,7 +5502,7 @@ program.command("refs <symbol>").description("Find all files referencing a symbo
 });
 program.command("trace <symbol>").description("Trace a symbol: definition + all references").action((symbol) => {
   runQuery(
-    (db) => trace(db, symbol),
+    (db) => queries.trace(db, symbol),
     (result) => {
       console.log("\u2550\u2550\u2550 DEFINITION \u2550\u2550\u2550");
       for (const d of result.definitions) {
@@ -4817,7 +5518,7 @@ program.command("trace <symbol>").description("Trace a symbol: definition + all
 });
 program.command("deps <file>").description("Files this file depends on (internal)").action((file) => {
   runQuery(
-    (db) => deps(db, file),
+    (db) => queries.deps(db, file),
     (results) => {
       for (const r of results) console.log(r.relativePath);
     }
@@ -4825,7 +5526,7 @@ program.command("deps <file>").description("Files this file depends on (internal
 });
 program.command("rdeps <file>").description("Files that depend on this file/module").action((file) => {
   runQuery(
-    (db) => rdeps(db, file),
+    (db) => queries.rdeps(db, file),
     (results) => {
       for (const r of results) console.log(r.relativePath);
     }
@@ -4833,7 +5534,7 @@ program.command("rdeps <file>").description("Files that depend on this file/modu
 });
 program.command("system <module>").description("Full module map: files, symbols, deps in/out").action((module) => {
   runQuery(
-    (db) => system(db, module),
+    (db) => queries.system(db, module),
     (result) => {
       console.log("\u2550\u2550\u2550 FILES \u2550\u2550\u2550");
       for (const f of result.files) console.log(f);
@@ -4850,7 +5551,7 @@ program.command("system <module>").description("Full module map: files, symbols,
 });
 program.command("surface <module>").description("What symbols consumers actually use from this module").action((module) => {
   runQuery(
-    (db) => surface(db, module),
+    (db) => queries.surface(db, module),
     (results) => {
       for (const r of results) {
         console.log(`  ${r.consumer} \u2192 ${r.shortName}`);
@@ -4867,7 +5568,7 @@ program.command("dead [scope]").description("Find dead code and file-internal sy
       skipBarrels: opts.skipBarrels,
       includeMembers: opts.includeMembers
     };
-    const result = dead(db, deadOpts);
+    const result = queries.dead(db, deadOpts);
     if (result.symbols.length === 0) {
       console.log("No dead code found.");
       return;
@@ -4890,7 +5591,7 @@ program.command("dead [scope]").description("Find dead code and file-internal sy
 });
 program.command("hotspots").description("Most-referenced symbols in the codebase (choke points)").option("-n, --limit <n>", "Number of results", parseIntSafe, 30).option("-s, --scope <path>", "Limit to files matching path").action((opts) => {
   runQuery(
-    (db) => hotspots(db, { limit: opts.limit, scope: opts.scope }),
+    (db) => queries.hotspots(db, { limit: opts.limit, scope: opts.scope }),
     (results) => {
       console.log("  refs  files  symbol");
       console.log("  \u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500");
@@ -4902,7 +5603,7 @@ program.command("hotspots").description("Most-referenced symbols in the codebase
 });
 program.command("imports <file>").description("What symbols does this file import?").action((file) => {
   runQuery(
-    (db) => imports(db, file),
+    (db) => queries.imports(db, file),
     (results) => {
       if (results.length === 0) {
         console.log("No imports found (indexer may not emit role=2 for this language).");
@@ -4915,7 +5616,7 @@ program.command("imports <file>").description("What symbols does this file impor
 });
 program.command("imported-by <symbol>").description("Which files import this symbol?").action((symbol) => {
   runQuery(
-    (db) => importedBy(db, symbol),
+    (db) => queries.importedBy(db, symbol),
     (results) => {
       for (const r of results) {
         console.log(`  ${r.fromFile}`);
@@ -4925,7 +5626,7 @@ program.command("imported-by <symbol>").description("Which files import this sym
 });
 program.command("unused-imports <file>").description("Find imports not referenced in the same file").action((file) => {
   runQuery(
-    (db) => unusedImports(db, file),
+    (db) => queries.unusedImports(db, file),
     (results) => {
       if (results.length === 0) {
         console.log("No unused imports found.");
@@ -4941,7 +5642,7 @@ ${results.length} unused import(s)`);
 });
 program.command("outline <file>").description("Tree view of symbols in a file (using nesting hierarchy)").action((file) => {
   runQuery(
-    (db) => outline(db, file),
+    (db) => queries.outline(db, file),
     (roots) => {
       function printTree(nodes, indent) {
         for (const n of nodes) {
@@ -4956,7 +5657,7 @@ program.command("outline <file>").description("Tree view of symbols in a file (u
 });
 program.command("members <symbol>").description("All children of a symbol (methods, fields, nested types)").action((symbol) => {
   runQuery(
-    (db) => members(db, symbol),
+    (db) => queries.members(db, symbol),
     (results) => {
       for (const r of results) {
         console.log(`  ${r.startLine}-${r.endLine}  [${r.kind}]  ${r.shortName}`);
@@ -4967,12 +5668,12 @@ program.command("members <symbol>").description("All children of a symbol (metho
 program.command("fan-in [symbol]").description("How many files reference a symbol (or top fan-in across codebase)").option("-n, --limit <n>", "Number of results for top mode", parseIntSafe, 30).option("-s, --scope <path>", "Limit to files matching path").action((symbol, opts) => {
   withDb((db) => {
     if (symbol) {
-      const results = fanIn(db, symbol);
+      const results = queries.fanIn(db, symbol);
       for (const r of results) {
         console.log(`  ${String(r.count).padStart(4)} files  ${r.name}`);
       }
     } else {
-      const results = topFanIn(db, { limit: opts.limit, scope: opts.scope });
+      const results = queries.topFanIn(db, { limit: opts.limit, scope: opts.scope });
       console.log("  files  symbol");
       console.log("  \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500");
       for (const r of results) {
@@ -4984,12 +5685,12 @@ program.command("fan-in [symbol]").description("How many files reference a symbo
 program.command("fan-out [file]").description("How many external symbols a file uses (or top fan-out across codebase)").option("-n, --limit <n>", "Number of results for top mode", parseIntSafe, 30).option("-s, --scope <path>", "Limit to files matching path").action((file, opts) => {
   withDb((db) => {
     if (file) {
-      const results = fanOut(db, file);
+      const results = queries.fanOut(db, file);
       for (const r of results) {
         console.log(`  ${String(r.count).padStart(4)} symbols  ${r.name}`);
       }
     } else {
-      const results = topFanOut(db, { limit: opts.limit, scope: opts.scope });
+      const results = queries.topFanOut(db, { limit: opts.limit, scope: opts.scope });
       console.log("  symbols  file");
       console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500");
       for (const r of results) {
@@ -5001,10 +5702,10 @@ program.command("fan-out [file]").description("How many external symbols a file
 program.command("coupling [file1] [file2]").description("Coupling between two files, or top coupled pairs in codebase").option("-n, --limit <n>", "Number of results for top mode", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").action((file1, file2, opts) => {
   withDb((db) => {
     if (file1 && file2) {
-      const result = coupling(db, file1, file2);
+      const result = queries.coupling(db, file1, file2);
       console.log(`${result.file1} \u2194 ${result.file2}: ${result.sharedSymbols} shared symbols`);
     } else {
-      const results = topCoupling(db, { limit: opts.limit, scope: opts.scope });
+      const results = queries.topCoupling(db, { limit: opts.limit, scope: opts.scope });
       console.log("  shared  file1 \u2192 file2");
       console.log("  \u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       for (const r of results) {
@@ -5015,7 +5716,7 @@ program.command("coupling [file1] [file2]").description("Coupling between two fi
 });
 program.command("cycles").description("Detect circular dependency chains between files").option("-s, --scope <path>", "Limit to files matching path").option("--max-depth <n>", "Maximum cycle depth", parseIntSafe, 10).action((opts) => {
   runQuery(
-    (db) => cycles(db, { scope: opts.scope, maxDepth: opts.maxDepth }),
+    (db) => queries.cycles(db, { scope: opts.scope, maxDepth: opts.maxDepth }),
     (results) => {
       if (results.length === 0) {
         console.log("No circular dependencies found.");
@@ -5036,7 +5737,7 @@ ${results.length} cycle(s) found.`);
 });
 program.command("bottlenecks").description("Find coupling hubs: high fan-in AND high fan-out").option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-fan-in <n>", "Minimum fan-in", parseIntSafe, 2).option("--min-fan-out <n>", "Minimum fan-out", parseIntSafe, 2).action((opts) => {
   runQuery(
-    (db) => bottlenecks(db, {
+    (db) => queries.bottlenecks(db, {
       limit: opts.limit,
       scope: opts.scope,
       minFanIn: opts.minFanIn,
@@ -5057,7 +5758,7 @@ program.command("bottlenecks").description("Find coupling hubs: high fan-in AND
 });
 program.command("isolated").description("Find completely orphaned symbols (no references at all)").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum lines of code", parseIntSafe, 3).action((opts) => {
   runQuery(
-    (db) => isolated(db, { scope: opts.scope, minLoc: opts.minLoc }),
+    (db) => queries.isolated(db, { scope: opts.scope, minLoc: opts.minLoc }),
     (results) => {
       if (results.length === 0) {
         console.log("No isolated symbols found.");
@@ -5079,7 +5780,7 @@ ${results.length} isolated symbol(s)`);
 });
 program.command("by-kind <kind>").description("Find symbols by SCIP kind (class, interface, enum, function, etc.)").option("-s, --scope <path>", "Limit to files matching path").option("-n, --limit <n>", "Number of results", parseIntSafe, 100).action((kind, opts) => {
   runQuery(
-    (db) => byKind(db, kind, { scope: opts.scope, limit: opts.limit }),
+    (db) => queries.byKind(db, kind, { scope: opts.scope, limit: opts.limit }),
     (results) => {
       if (results.length === 0) {
         console.log(`No symbols found for kind "${kind}". Use "kind-counts" to see available kinds.`);
@@ -5095,7 +5796,7 @@ ${results.length} symbol(s)`);
 });
 program.command("kind-counts").description("Histogram of symbol kinds in the codebase").option("-s, --scope <path>", "Limit to files matching path").action((opts) => {
   runQuery(
-    (db) => kindCounts(db, { scope: opts.scope }),
+    (db) => queries.kindCounts(db, { scope: opts.scope }),
     (results) => {
       console.log("  count  kind");
       console.log("  \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500");
@@ -5105,29 +5806,9 @@ program.command("kind-counts").description("Histogram of symbol kinds in the cod
     }
   );
 });
-program.command("test-coverage [symbol]").description("Check if symbols are referenced by test files").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum LOC for summary mode", parseIntSafe, 3).action((symbol, opts) => {
-  withDb((db) => {
-    if (symbol) {
-      const results = testCoverage(db, symbol);
-      for (const r of results) {
-        const status = r.covered ? "covered" : "NOT COVERED";
-        console.log(`  [${status}]  ${r.shortName}  (${r.definedIn})`);
-        for (const tf of r.testFiles) {
-          console.log(`    \u2190 ${tf}`);
-        }
-      }
-    } else {
-      const summary = testCoverageSummary(db, { scope: opts.scope, minLoc: opts.minLoc });
-      console.log(`Test coverage: ${summary.percent}%`);
-      console.log(`  Total symbols:  ${summary.total}`);
-      console.log(`  Covered:        ${summary.covered}`);
-      console.log(`  Not covered:    ${summary.uncovered}`);
-    }
-  });
-});
 program.command("doc-coverage").description("Check documentation coverage across symbols").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum LOC to consider", parseIntSafe, 3).option("-n, --limit <n>", "Max undocumented symbols to show", parseIntSafe, 50).action((opts) => {
   runQuery(
-    (db) => docCoverage(db, {
+    (db) => queries.docCoverage(db, {
       scope: opts.scope,
       minLoc: opts.minLoc,
       limit: opts.limit
@@ -5148,7 +5829,7 @@ program.command("doc-coverage").description("Check documentation coverage across
 });
 program.command("deep-chains").description("Find the longest transitive dependency chains").option("-n, --limit <n>", "Number of chains to show", parseIntSafe, 10).option("-s, --scope <path>", "Limit to files matching path").option("--min-depth <n>", "Minimum chain depth", parseIntSafe, 3).action((opts) => {
   runQuery(
-    (db) => deepChains(db, {
+    (db) => queries.deepChains(db, {
       limit: opts.limit,
       scope: opts.scope,
       minDepth: opts.minDepth
@@ -5170,7 +5851,7 @@ Chain ${i + 1} (depth ${results[i].depth}):`);
 });
 program.command("hierarchy <symbol>").description("Show a symbol's ancestry chain (method \u2192 class \u2192 module)").action((symbol) => {
   runQuery(
-    (db) => hierarchy(db, symbol),
+    (db) => queries.hierarchy(db, symbol),
     (chain) => {
       if (chain.length === 0) {
         console.log("Symbol not found.");
@@ -5185,7 +5866,7 @@ program.command("hierarchy <symbol>").description("Show a symbol's ancestry chai
 });
 program.command("call-graph <symbol>").description("Show incoming callers and outgoing callees for a symbol").action((symbol) => {
   runQuery(
-    (db) => callGraph(db, symbol),
+    (db) => queries.callGraph(db, symbol),
     (result) => {
       if (!result) {
         console.log("Symbol not found.");
@@ -5208,7 +5889,7 @@ program.command("call-graph <symbol>").description("Show incoming callers and ou
 program.command("similar [symbol]").description("Find functions with similar callee fingerprints (consolidation candidates)").option("--min-similarity <n>", "Minimum Jaccard similarity (0-1)", parseFloat, 0.4).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-callees <n>", "Minimum callees to consider", parseIntSafe, 4).action((symbol, opts) => {
   withDb((db) => {
     if (symbol) {
-      const results = similar(db, symbol, {
+      const results = queries.similar(db, symbol, {
         minSimilarity: opts.minSimilarity,
         limit: opts.limit
       });
@@ -5226,7 +5907,7 @@ ${Math.round(r.similarity * 100)}% similar:`);
         }
       }
     } else {
-      const results = similarAll(db, {
+      const results = queries.similarAll(db, {
         minSimilarity: opts.minSimilarity,
         limit: opts.limit,
         scope: opts.scope,
@@ -5250,7 +5931,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) => {
   runQuery(
-    (db) => similarFiles(db, {
+    (db) => queries.similarFiles(db, {
       minSimilarity: opts.minSimilarity,
       limit: opts.limit,
       scope: opts.scope,
@@ -5278,7 +5959,7 @@ ${results.length} similar pair(s) found.`);
 });
 program.command("similar-chains").description("Find end-to-end dependency flows that diverge at few points").option("--min-similarity <n>", "Minimum chain similarity (0-1)", parseFloat, 0.5).option("-n, --limit <n>", "Number of results", parseIntSafe, 15).option("-s, --scope <path>", "Limit to files matching path").option("--min-length <n>", "Minimum chain length", parseIntSafe, 3).option("--max-length <n>", "Maximum chain length", parseIntSafe, 8).action((opts) => {
   runQuery(
-    (db) => similarChains(db, {
+    (db) => queries.similarChains(db, {
       minSimilarity: opts.minSimilarity,
       limit: opts.limit,
       scope: opts.scope,
@@ -5310,7 +5991,7 @@ ${results.length} similar chain pair(s) found.`);
 });
 program.command("extract-candidates").description("Find functions with natural extraction seams (isolated callee clusters)").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum function LOC", parseIntSafe, 10).option("--min-callees <n>", "Minimum callees to analyze", parseIntSafe, 6).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).action((opts) => {
   runQuery(
-    (db) => extractCandidates(db, {
+    (db) => queries.extractCandidates(db, {
       scope: opts.scope,
       minLoc: opts.minLoc,
       minCallees: opts.minCallees,
@@ -5339,7 +6020,7 @@ ${results.length} extraction candidate(s) found.`);
 });
 program.command("affected <symbol>").description("Transitive closure of symbols that could break if this symbol changes").option("--max-depth <n>", "Maximum traversal depth", parseIntSafe, 5).option("-s, --scope <path>", "Limit to files matching path").action((symbol, opts) => {
   const db = openDb();
-  const results = affected(db, symbol, { maxDepth: opts.maxDepth, scope: opts.scope });
+  const results = queries.affected(db, symbol, { maxDepth: opts.maxDepth, scope: opts.scope });
   if (results.length === 0) {
     console.log("No affected symbols found.");
   } else {
@@ -5357,44 +6038,39 @@ ${results.length} affected symbol(s) across ${new Set(results.map((r) => r.file)
   }
   db.close();
 });
-program.command("change-surface <file>").description("Pre-change briefing: exports, consumers, test coverage, risk").action((file) => {
+program.command("change-surface <file>").description("Pre-change briefing: exports, consumers, and blast-radius risk").action((file) => {
   const db = openDb();
-  const result = changeSurface(db, file);
+  const result = queries.changeSurface(db, file);
   if (!result) {
     console.log("File not found in index.");
     db.close();
     return;
   }
   console.log(`File: ${result.file}`);
-  console.log(`Test coverage: ${result.testCoveragePercent}% | External consumers: ${result.totalExternalConsumers}
+  console.log(`External consumers: ${result.totalExternalConsumers}
 `);
   for (const s of result.symbols) {
     const risk = s.riskLevel === "high" ? " *** HIGH RISK ***" : s.riskLevel === "medium" ? " * medium risk *" : "";
-    const tests = s.testFiles.length > 0 ? ` (${s.testFiles.length} test file(s))` : " (no tests)";
-    console.log(`  ${s.startLine}-${s.endLine}  ${s.shortName}  [${s.externalConsumers} consumers]${tests}${risk}`);
+    console.log(`  ${s.startLine}-${s.endLine}  ${s.shortName}  [${s.externalConsumers} consumers]${risk}`);
   }
   db.close();
 });
-program.command("diff-impact").description("Compute affected symbols from current git diff").option("--base <ref>", "Git ref to diff against (default: HEAD)").action((opts) => {
+program.command("diff-impact").description("Compute changed symbols and downstream consumers from current git diff").option("--base <ref>", "Git ref to diff against (default: HEAD)").action((opts) => {
   const db = openDb();
-  const result = diffImpact(db, { base: opts.base });
+  const result = queries.diffImpact(db, { base: opts.base });
   console.log(`Changed files: ${result.summary.totalChangedFiles}`);
   console.log(`Changed symbols: ${result.summary.totalChangedSymbols}`);
   console.log(`Affected consumer files: ${result.summary.totalAffectedFiles}`);
-  console.log(`Test coverage: ${result.summary.testCoveragePercent}%
-`);
+  if (result.summary.note) {
+    console.log(`Note: ${result.summary.note}`);
+  }
+  console.log("");
   if (result.changedSymbols.length > 0) {
     console.log("Changed symbols:");
     for (const s of result.changedSymbols) {
       console.log(`  ${s.file}  ${s.shortName}  (fan-in: ${s.fanIn})`);
     }
   }
-  if (result.uncoveredSymbols.length > 0) {
-    console.log("\nUncovered (no test references):");
-    for (const s of result.uncoveredSymbols) {
-      console.log(`  ${s.file}  ${s.shortName}`);
-    }
-  }
   if (result.affectedConsumers.length > 0) {
     console.log("\nAffected consumer files:");
     for (const c of result.affectedConsumers) {
@@ -5405,7 +6081,7 @@ program.command("diff-impact").description("Compute affected symbols from curren
 });
 program.command("drift [module]").description("Detect unused imports, layer violations, and pattern deviations").action((module) => {
   const db = openDb();
-  const summary = drift(db, { scope: module });
+  const summary = queries.drift(db, { scope: module });
   if (summary.results.length === 0) {
     console.log("No drift detected.");
   } else {
@@ -5430,7 +6106,7 @@ ${summary.unusedImports} unused import(s), ${summary.layerViolations} layer viol
 });
 program.command("wrapper-candidates").description("Find symbols only called by one consumer (premature abstractions)").option("-s, --scope <path>", "Limit to files matching path").option("--max-loc <n>", "Maximum LOC for candidates", parseIntSafe, 15).option("-n, --limit <n>", "Number of results", parseIntSafe, 30).action((opts) => {
   const db = openDb();
-  const results = wrapperCandidates(db, { scope: opts.scope, maxLoc: opts.maxLoc, limit: opts.limit });
+  const results = queries.wrapperCandidates(db, { scope: opts.scope, maxLoc: opts.maxLoc, limit: opts.limit });
   if (results.length === 0) {
     console.log("No wrapper candidates found.");
   } else {
@@ -5445,7 +6121,7 @@ ${results.length} wrapper candidate(s).`);
 });
 program.command("passthrough-candidates").description("Find functions that just forward to one other function").option("-s, --scope <path>", "Limit to files matching path").option("--max-loc <n>", "Maximum LOC for candidates", parseIntSafe, 15).option("-n, --limit <n>", "Number of results", parseIntSafe, 30).action((opts) => {
   const db = openDb();
-  const results = passthroughCandidates(db, { scope: opts.scope, maxLoc: opts.maxLoc, limit: opts.limit });
+  const results = queries.passthroughCandidates(db, { scope: opts.scope, maxLoc: opts.maxLoc, limit: opts.limit });
   if (results.length === 0) {
     console.log("No passthrough candidates found.");
   } else {
@@ -5460,7 +6136,7 @@ ${results.length} passthrough candidate(s).`);
 });
 program.command("stale-abstractions").description("Find types/interfaces with 0-1 consumers (premature abstractions)").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum LOC", parseIntSafe, 3).option("-n, --limit <n>", "Number of results", parseIntSafe, 30).action((opts) => {
   const db = openDb();
-  const results = staleAbstractions(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
+  const results = queries.staleAbstractions(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
   if (results.length === 0) {
     console.log("No stale abstractions found.");
   } else {
@@ -5475,7 +6151,7 @@ ${results.length} stale abstraction(s).`);
 });
 program.command("complexity-hotspots").description("Composite complexity score: LOC x fan-in x fan-out").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum LOC", parseIntSafe, 10).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).action((opts) => {
   const db = openDb();
-  const results = complexityHotspots(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
+  const results = queries.complexityHotspots(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
   if (results.length === 0) {
     console.log("No complexity hotspots found.");
   } else {
@@ -5489,7 +6165,7 @@ program.command("complexity-hotspots").description("Composite complexity score:
 });
 program.command("health").description("Composite codebase health report with prioritized action list").option("-s, --scope <path>", "Limit to files matching path").option("--json", "Output as JSON for programmatic consumption").action((opts) => {
   const db = openDb();
-  const report = health(db, { scope: opts.scope });
+  const report = queries.health(db, { scope: opts.scope });
   if (opts.json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
@@ -5510,7 +6186,6 @@ program.command("health").description("Composite codebase health report with pri
     if (f.staleTypes > 0) console.log(`    Stale abstractions:   ${f.staleTypes}`);
     if (f.driftedFiles > 0) console.log(`    Pattern drift:        ${f.driftedFiles} files`);
     if (f.complexityHotspotCount > 0) console.log(`    Complexity hotspots:  ${f.complexityHotspotCount}`);
-    console.log(`    Test coverage:        ${f.testCoveragePercent}%`);
     if (report.actions.length > 0) {
       console.log("\n  Prioritized Actions (highest impact + lowest effort first):");
       for (let i = 0; i < report.actions.length; i++) {
@@ -5533,7 +6208,7 @@ program.command("health").description("Composite codebase health report with pri
 });
 program.command("convergence <symbol1> <symbol2>").description("Show what a consolidated version of two similar functions would look like").action((symbol1, symbol2) => {
   const db = openDb();
-  const result = convergence(db, symbol1, symbol2);
+  const result = queries.convergence(db, symbol1, symbol2);
   if (!result) {
     console.log("One or both symbols not found.");
     db.close();
@@ -5563,7 +6238,7 @@ ${Math.round(result.similarity * 100)}% callee overlap
 });
 program.command("code <symbol>").description("Read the source code for a symbol (bounded to its definition range)").option("-C, --context <n>", "Extra lines of context above/below", parseIntSafe, 0).action((symbol, opts) => {
   const db = openDb();
-  const result = code(db, symbol, { context: opts.context });
+  const result = queries.code(db, symbol, { context: opts.context });
   if (!result) {
     console.log("Symbol not found or file unreadable.");
     db.close();
@@ -5579,7 +6254,7 @@ program.command("code <symbol>").description("Read the source code for a symbol
 });
 program.command("complexity <symbol>").description("Per-symbol complexity: branches, cyclomatic estimate, fan-in/out, callees").action((symbol) => {
   const db = openDb();
-  const result = complexity(db, symbol);
+  const result = queries.complexity(db, symbol);
   if (!result) {
     console.log("Symbol not found.");
     db.close();
@@ -5597,7 +6272,7 @@ program.command("complexity <symbol>").description("Per-symbol complexity: branc
 });
 program.command("dataflow <symbol>").description("Reference-level dataflow: definition sites, usage sites, producers, consumers").action((symbol) => {
   const db = openDb();
-  const result = dataflow(db, symbol);
+  const result = queries.dataflow(db, symbol);
   if (!result) {
     console.log("Symbol not found.");
     db.close();
@@ -5634,7 +6309,7 @@ program.command("dataflow <symbol>").description("Reference-level dataflow: defi
 program.command("slice <symbol>").description("Reference-level program slice: what affects this (backward) or what this affects (forward)").option("--forward", "Forward slice (what does this affect). Default is backward.").action((symbol, opts) => {
   const db = openDb();
   const direction = opts.forward ? "forward" : "backward";
-  const result = slice(db, symbol, { direction });
+  const result = queries.slice(db, symbol, { direction });
   if (!result) {
     console.log("Symbol not found.");
     db.close();
@@ -5672,7 +6347,7 @@ program.command("check-deps").description("Check if required dependencies (scip
 });
 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();
-  const results = redundantReexports(db, { scope: opts.scope, limit: opts.limit });
+  const results = queries.redundantReexports(db, { scope: opts.scope, limit: opts.limit });
   if (results.length === 0) {
     console.log("No redundant re-exports found.");
   } else {
@@ -5693,7 +6368,7 @@ ${results.length} redundant re-export(s).`);
 });
 program.command("similar-signatures").description("Find functions with near-identical type signatures (same shape)").option("-s, --scope <path>", "Limit to files matching path").option("--min-loc <n>", "Minimum LOC per function", parseIntSafe, 3).option("-n, --limit <n>", "Number of groups", parseIntSafe, 20).action((opts) => {
   const db = openDb();
-  const groups = similarSignatures(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
+  const groups = queries.similarSignatures(db, { scope: opts.scope, minLoc: opts.minLoc, limit: opts.limit });
   if (groups.length === 0) {
     console.log("No same-shape function groups found.");
   } else {
@@ -5750,12 +6425,16 @@ program.command("status").description("Show index status for this project").acti
   const projectRoot = resolveProjectRoot();
   const config = loadProjectConfig(projectRoot);
   const paths = resolveIndexPaths(projectRoot, config);
+  const dbPath = resolveActiveDbPath(projectRoot);
   console.log(`Project:  ${projectRoot}`);
-  console.log(`DB path:  ${paths.dbPath}`);
-  console.log(`Exists:   ${existsSync7(paths.dbPath) ? "yes" : "no"}`);
-  if (existsSync7(paths.dbPath)) {
+  console.log(`DB path:  ${dbPath}`);
+  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)) {
     withDb((db) => {
-      const s = stats(db);
+      const s = queries.stats(db);
       console.log(`Symbols:  ${s.symbols}`);
       console.log(`Files:    ${s.documents}`);
       console.log(`Size:     ${formatBytes(s.indexSizeBytes)}`);
@@ -5766,7 +6445,9 @@ program.command("status").description("Show index status for this project").acti
     });
   }
 });
-program.parse();
+if (process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1]) {
+  program.parse();
+}
 function collect(value, prev) {
   return prev.concat([value]);
 }
@@ -5795,4 +6476,7 @@ function formatStatus(status) {
     }
   }
 }
+export {
+  program
+};
 //# sourceMappingURL=cli.js.map