scip-query 0.2.1 → 0.3.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { program } from "commander";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync8, realpathSync } from "fs";
 import { join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -1037,431 +1037,1052 @@ function files(db, pattern) {
   return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
 }
 
-// src/symbol-parser.ts
-var SUFFIX_MAP = {
-  "/": "namespace",
-  "#": "type",
-  ".": "term",
-  "[": "type-param",
-  ":": "meta",
-  "!": "macro"
-};
-function parseSymbol(raw) {
-  if (raw.startsWith("local ")) {
-    return { kind: "local", id: raw.slice(6), raw };
+// src/query-support.ts
+import { basename } from "path";
+
+// 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 SOURCE_TEXT_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_CALL_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
+var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
+function getSourceImports(db, relativePath) {
+  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (cached) {
+    return cached;
   }
-  const parts = raw.split(" ");
-  if (parts.length < 4) {
-    return {
-      scheme: parts[0] ?? "",
-      manager: parts[1] ?? "",
-      packageName: parts[2] ?? "",
-      version: "",
-      descriptors: [],
-      raw
-    };
+  const fullPath = join6(db.config.projectRoot, normalized);
+  if (!existsSync6(fullPath)) {
+    cache.set(normalized, []);
+    return [];
   }
-  const scheme = parts[0];
-  const manager = parts[1];
-  let restAfterManager = raw.slice(scheme.length + 1 + manager.length + 1);
-  let packageName;
-  if (restAfterManager.startsWith("`")) {
-    const closingTick = restAfterManager.indexOf("`", 1);
-    if (closingTick === -1) {
-      packageName = restAfterManager.slice(1);
-      restAfterManager = "";
-    } else {
-      packageName = restAfterManager.slice(1, closingTick);
-      restAfterManager = restAfterManager.slice(closingTick + 2);
+  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 getSourceCalls(db, relativePath, opts = {}) {
+  const normalized = normalizePath(relativePath);
+  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
+    return [];
+  }
+  const cache = getCachedMap(SOURCE_CALL_CACHE, db);
+  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const source = getSourceText(db, normalized);
+  if (!source) {
+    cache.set(key, []);
+    return [];
+  }
+  const lines = source.split("\n");
+  const startLine = Math.max(0, opts.startLine ?? 0);
+  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
+  const scopedLines = lines.slice(startLine, endLine + 1);
+  const calls = isPythonSourcePath(normalized) ? parsePythonCalls(scopedLines, startLine) : parseJavaScriptCalls(scopedLines, startLine);
+  cache.set(key, calls);
+  return calls;
+}
+function getSourceConstructorBindings(db, relativePath, opts = {}) {
+  const normalized = normalizePath(relativePath);
+  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
+    return [];
+  }
+  const cache = getCachedMap(SOURCE_BINDING_CACHE, db);
+  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const source = getSourceText(db, normalized);
+  if (!source) {
+    cache.set(key, []);
+    return [];
+  }
+  const lines = source.split("\n");
+  const startLine = Math.max(0, opts.startLine ?? 0);
+  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
+  const scopedLines = lines.slice(startLine, endLine + 1);
+  const bindings = isPythonSourcePath(normalized) ? parsePythonConstructorBindings(scopedLines) : parseJavaScriptConstructorBindings(scopedLines);
+  cache.set(key, bindings);
+  return bindings;
+}
+function findIdentifierLines(db, relativePath, identifier, opts = {}) {
+  if (!identifier) {
+    return [];
+  }
+  const source = getSourceText(db, normalizePath(relativePath));
+  if (!source) {
+    return [];
+  }
+  const lines = stripCommentsAndStrings(source).split("\n");
+  const regex = new RegExp(`\\b${escapeRegex(identifier)}\\b`);
+  const results = [];
+  for (let line = 0; line < lines.length; line++) {
+    if (typeof opts.excludeStartLine === "number" && typeof opts.excludeEndLine === "number" && line >= opts.excludeStartLine && line <= opts.excludeEndLine) {
+      continue;
     }
-  } else {
-    const spaceIdx = restAfterManager.indexOf(" ");
-    if (spaceIdx === -1) {
-      packageName = restAfterManager;
-      restAfterManager = "";
-    } else {
-      packageName = restAfterManager.slice(0, spaceIdx);
-      restAfterManager = restAfterManager.slice(spaceIdx + 1);
+    if (regex.test(lines[line] ?? "")) {
+      results.push(line);
     }
   }
-  let version;
-  const versionSpaceIdx = restAfterManager.indexOf(" ");
-  if (versionSpaceIdx === -1) {
-    version = restAfterManager;
-    restAfterManager = "";
-  } else {
-    version = restAfterManager.slice(0, versionSpaceIdx);
-    restAfterManager = restAfterManager.slice(versionSpaceIdx + 1);
+  return results;
+}
+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 descriptors = parseDescriptors(restAfterManager);
-  return { scheme, manager, packageName, version, descriptors, raw };
+  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 parseDescriptors(input) {
-  const descriptors = [];
-  let i = 0;
-  while (i < input.length) {
-    if (input[i] === "[") {
-      const closeBracket = input.indexOf("]", i + 1);
-      if (closeBracket === -1) {
-        descriptors.push({ name: input.slice(i + 1), suffix: "type-param" });
-        break;
-      }
-      descriptors.push({ name: input.slice(i + 1, closeBracket), suffix: "type-param" });
-      i = closeBracket + 1;
-      continue;
+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 (input[i] === "(" && (descriptors.length === 0 || i === 0 || isSuffixChar(input[i - 1]))) {
-      const closeParen = input.indexOf(")", i + 1);
-      if (closeParen !== -1 && input[closeParen + 1] !== ".") {
-        descriptors.push({ name: input.slice(i + 1, closeParen), suffix: "parameter" });
-        i = closeParen + 1;
+    if (binding.kind === "side-effect") {
+      return { ...binding, used: true, usedMembers: [] };
+    }
+    return {
+      ...binding,
+      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
+      usedMembers: []
+    };
+  });
+}
+function parsePythonCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "with",
+    "except",
+    "elif",
+    "return",
+    "yield",
+    "assert",
+    "raise",
+    "lambda",
+    "class",
+    "def"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const rawLine = lines[index] ?? "";
+    const stripped = stripCommentsAndStrings(rawLine);
+    if (!stripped.trim()) continue;
+    const attributeMatches = [...stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w]*)\s*\(/g)];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[1];
+      const calleeName = match[2];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      if (controlKeywords.has(calleeName)) continue;
+      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
+      const prefix = stripped.slice(0, start).trimEnd();
+      if (prefix.endsWith("def") || prefix.endsWith("class") || prefix.endsWith("async def")) {
         continue;
       }
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: baseLine + index
+      });
     }
-    let name;
-    if (input[i] === "`") {
-      const closingTick = input.indexOf("`", i + 1);
-      if (closingTick === -1) {
-        name = input.slice(i + 1);
-        i = input.length;
-        descriptors.push({ name, suffix: "term" });
-        break;
-      }
-      name = input.slice(i + 1, closingTick);
-      i = closingTick + 1;
-    } else {
-      const start = i;
-      while (i < input.length && !isSuffixChar(input[i])) {
-        i++;
+  }
+  return calls;
+}
+function parseJavaScriptCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "class",
+    "return",
+    "typeof",
+    "import"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const stripped = stripCommentsAndStrings(lines[index] ?? "");
+    if (!stripped.trim()) continue;
+    const attributeMatches = [
+      ...stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g),
+      ...stripped.matchAll(/\bthis\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g)
+    ];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[2] ? match[1] : "this";
+      const calleeName = match[2] ?? match[1];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      if (controlKeywords.has(calleeName)) continue;
+      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
+      const prefix = stripped.slice(0, start).trimEnd();
+      if (prefix.endsWith("function") || prefix.endsWith("class") || prefix.endsWith("new")) {
+        continue;
       }
-      name = input.slice(start, i);
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: baseLine + index
+      });
     }
-    if (i >= input.length) {
-      if (name) descriptors.push({ name, suffix: "term" });
-      break;
+  }
+  return calls;
+}
+function parsePythonConstructorBindings(lines) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const rawLine of lines) {
+    const stripped = stripCommentsAndStrings(rawLine);
+    const constructorMatch = stripped.match(/\b([A-Za-z_][\w]*)\s*=\s*([A-Z][\w]*)\s*\(/);
+    if (constructorMatch?.[1] && constructorMatch[2]) {
+      bindings.set(constructorMatch[1], constructorMatch[2]);
     }
-    const char = input[i];
-    if (char === "(") {
-      const closeParen = input.indexOf(")", i + 1);
-      if (closeParen !== -1 && input[closeParen + 1] === ".") {
-        descriptors.push({ name, suffix: "method" });
-        i = closeParen + 2;
-      } else if (closeParen !== -1) {
-        descriptors.push({ name, suffix: "method" });
-        i = closeParen + 1;
-      } else {
-        descriptors.push({ name, suffix: "term" });
-        i++;
-      }
-    } else {
-      const suffix = SUFFIX_MAP[char];
-      if (suffix) {
-        descriptors.push({ name, suffix });
-        i += 1;
-      } else {
-        i += 1;
+  }
+  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
+}
+function parseJavaScriptConstructorBindings(lines) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const rawLine of lines) {
+    const stripped = stripCommentsAndStrings(rawLine);
+    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*([A-Z][A-Za-z0-9_$]*)\b/g)) {
+      const localName = match[1];
+      const typeName = match[2];
+      if (localName && typeName) {
+        bindings.set(localName, typeName);
       }
     }
+    const constructorMatch = stripped.match(/\b(?:const|let|var)?\s*([A-Za-z_$][\w$]*)\s*(?::\s*[A-Z][A-Za-z0-9_$<> ,]*)?\s*=\s*new\s+([A-Z][A-Za-z0-9_$]*)\s*\(/);
+    if (constructorMatch?.[1] && constructorMatch[2]) {
+      bindings.set(constructorMatch[1], constructorMatch[2]);
+    }
   }
-  return descriptors;
+  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
 }
-function isSuffixChar(c) {
-  return c === "/" || c === "#" || c === "." || c === "(" || c === "[" || c === ":" || c === "!";
-}
-function shortenSymbol(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
-    return `local:${parsed.id}`;
-  }
-  const sym = parsed;
-  if (sym.descriptors.length === 0) return sym.raw;
-  const parts = [];
-  for (const desc of sym.descriptors) {
-    let name = desc.name;
-    if (desc.suffix === "namespace") {
-      name = name.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\.(py|pyi)$/, "").replace(/\.(rs)$/, "").replace(/\.(java|scala|kt|kts)$/, "").replace(/\.(rb)$/, "").replace(/\.(go)$/, "").replace(/\.(cs|vb)$/, "").replace(/\.(dart)$/, "").replace(/\.(php)$/, "").replace(/\.(c|cc|cpp|cxx|h|hpp)$/, "");
+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;
     }
-    if (!name) continue;
-    if (desc.suffix === "method") {
-      parts.push(`${name}()`);
-    } else {
-      parts.push(name);
+    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 parts.join(":");
+  return statements;
 }
-function leafName(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
-    return parsed.id;
+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 sym = parsed;
-  if (sym.descriptors.length === 0) return "";
-  const last = sym.descriptors[sym.descriptors.length - 1];
-  return last.name;
-}
-function leafSuffix(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
+  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
+  if (!fromMatch) {
     return null;
   }
-  const sym = parsed;
-  const last = sym.descriptors[sym.descriptors.length - 1];
-  return last?.suffix ?? 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 isFunctionLikeSymbol(raw) {
-  const suffix = leafSuffix(raw);
-  return suffix === "method" || suffix === "term";
+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 isModuleLikeSymbol(raw) {
-  return leafSuffix(raw) === "namespace";
+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 isDirectChildSymbol(parentRaw, candidateRaw) {
-  const parent = parseSymbol(parentRaw);
-  const candidate = parseSymbol(candidateRaw);
-  if ("kind" in parent || "kind" in candidate) {
-    return false;
+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"
+      };
+    });
   }
-  const parentDescriptors = parent.descriptors;
-  const candidateDescriptors = candidate.descriptors;
-  if (candidateDescriptors.length !== parentDescriptors.length + 1) {
-    return false;
+  if (trimmed.startsWith("* as ")) {
+    return [{
+      importedName: "*",
+      localName: trimmed.slice(5).trim(),
+      kind: "namespace"
+    }];
   }
-  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 [{
+    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 true;
+  return [clause.trim(), null];
 }
-
-// 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 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;
 }
-
-// src/queries/symbols.ts
-function symbols(db, filePattern) {
-  const rows = db.all(
-    `SELECT
-      der.start_line,
-      der.end_line,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig,
-      gs.symbol,
-      d.relative_path
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path LIKE ?
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
-    ORDER BY der.start_line`,
-    `%${filePattern}%`
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    signature: cleanSignature(r.sig)
-  }));
+function buildUsageBody(source, start, end) {
+  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
+  return stripCommentsAndStrings(masked);
 }
-
-// src/queries/methods.ts
-function methods(db, className) {
-  const rows = db.all(
-    `SELECT der.start_line, der.end_line, gs.symbol
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    WHERE gs.symbol LIKE ?
-      AND ${db.localSymbolPredicate}
-      AND gs.symbol LIKE '%().%'
-      ${db.symbolNoise}
-    ORDER BY der.start_line`,
-    `%${className}#%`
-  );
-  return rows.map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    name: leafName(r.symbol)
-  }));
+function stripCommentsAndStrings(source) {
+  return source.replace(/'''[\s\S]*?'''/g, maskPreservingLines).replace(/"""[\s\S]*?"""/g, maskPreservingLines).replace(/#.*$/gm, maskPreservingLines).replace(/\/\/.*$/gm, maskPreservingLines).replace(/\/\*[\s\S]*?\*\//g, maskPreservingLines).replace(/`(?:\\[\s\S]|[^`])*`/g, maskPreservingLines).replace(/'(?:\\.|[^'\\\r\n])*'/g, maskPreservingLines).replace(/"(?:\\.|[^"\\\r\n])*"/g, maskPreservingLines);
 }
-
-// src/queries/refs.ts
-function refs(db, symbolPattern) {
-  const rows = db.all(
-    `SELECT DISTINCT d.relative_path, c.start_line
-    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}
-      AND m.role != 1
-    ORDER BY d.relative_path, c.start_line`,
-    `%${symbolPattern}%`
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    line: r.start_line
-  }));
+function maskPreservingLines(segment) {
+  return segment.replace(/[^\r\n]/g, " ");
 }
-
-// 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 hasIdentifierUsage(body, identifier) {
+  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
 }
-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);
+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 graph;
+  return [...members2];
 }
-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 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 = getIndexedPaths(db);
+  for (const candidate of candidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+      return relativeCandidate;
     }
   }
-  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 };
+  return normalizePath(relative2(db.config.projectRoot, absolute));
+}
+function resolvePythonImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths(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, "/"));
   }
-  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
-    };
+  for (const candidate of pythonCandidateImportPaths(basePath)) {
+    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync6(candidate)) {
+      return relativeCandidate;
+    }
   }
   return null;
 }
-function normalizeLookupPattern(symbolPattern) {
-  return symbolPattern.trim().replace(/\(\)$/, "").replace(/\(.*$/, "");
+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 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 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 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 getIndexedPaths(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) => normalizePath(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
   );
+  INDEXED_PATH_CACHE.set(db, paths);
+  return paths;
 }
-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;
+function getCachedMap(cache, db) {
+  let map = cache.get(db);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    cache.set(db, map);
+  }
+  return map;
+}
+function normalizePath(path2) {
+  return path2.replace(/\\/g, "/");
+}
+function isJavaScriptSourcePath(relativePath) {
+  return SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isPythonSourcePath(relativePath) {
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function getSourceText(db, relativePath) {
+  const cache = getCachedMap(SOURCE_TEXT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (typeof cached === "string") {
+    return cached;
+  }
+  const fullPath = join6(db.config.projectRoot, normalized);
+  if (!existsSync6(fullPath)) {
+    cache.set(normalized, "");
+    return "";
+  }
+  const source = readFileSync4(fullPath, "utf-8");
+  cache.set(normalized, source);
+  return source;
+}
+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/symbol-parser.ts
+var SUFFIX_MAP = {
+  "/": "namespace",
+  "#": "type",
+  ".": "term",
+  "[": "type-param",
+  ":": "meta",
+  "!": "macro"
+};
+function parseSymbol(raw) {
+  if (raw.startsWith("local ")) {
+    return { kind: "local", id: raw.slice(6), raw };
+  }
+  const parts = raw.split(" ");
+  if (parts.length < 4) {
+    return {
+      scheme: parts[0] ?? "",
+      manager: parts[1] ?? "",
+      packageName: parts[2] ?? "",
+      version: "",
+      descriptors: [],
+      raw
+    };
+  }
+  const scheme = parts[0];
+  const manager = parts[1];
+  let restAfterManager = raw.slice(scheme.length + 1 + manager.length + 1);
+  let packageName;
+  if (restAfterManager.startsWith("`")) {
+    const closingTick = restAfterManager.indexOf("`", 1);
+    if (closingTick === -1) {
+      packageName = restAfterManager.slice(1);
+      restAfterManager = "";
+    } else {
+      packageName = restAfterManager.slice(1, closingTick);
+      restAfterManager = restAfterManager.slice(closingTick + 2);
+    }
+  } else {
+    const spaceIdx = restAfterManager.indexOf(" ");
+    if (spaceIdx === -1) {
+      packageName = restAfterManager;
+      restAfterManager = "";
+    } else {
+      packageName = restAfterManager.slice(0, spaceIdx);
+      restAfterManager = restAfterManager.slice(spaceIdx + 1);
+    }
+  }
+  let version;
+  const versionSpaceIdx = restAfterManager.indexOf(" ");
+  if (versionSpaceIdx === -1) {
+    version = restAfterManager;
+    restAfterManager = "";
+  } else {
+    version = restAfterManager.slice(0, versionSpaceIdx);
+    restAfterManager = restAfterManager.slice(versionSpaceIdx + 1);
+  }
+  const descriptors = parseDescriptors(restAfterManager);
+  return { scheme, manager, packageName, version, descriptors, raw };
+}
+function parseDescriptors(input) {
+  const descriptors = [];
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === "[") {
+      const closeBracket = input.indexOf("]", i + 1);
+      if (closeBracket === -1) {
+        descriptors.push({ name: input.slice(i + 1), suffix: "type-param" });
+        break;
+      }
+      descriptors.push({ name: input.slice(i + 1, closeBracket), suffix: "type-param" });
+      i = closeBracket + 1;
+      continue;
+    }
+    if (input[i] === "(" && (descriptors.length === 0 || i === 0 || isSuffixChar(input[i - 1]))) {
+      const closeParen = input.indexOf(")", i + 1);
+      if (closeParen !== -1 && input[closeParen + 1] !== ".") {
+        descriptors.push({ name: input.slice(i + 1, closeParen), suffix: "parameter" });
+        i = closeParen + 1;
+        continue;
+      }
+    }
+    let name;
+    if (input[i] === "`") {
+      const closingTick = input.indexOf("`", i + 1);
+      if (closingTick === -1) {
+        name = input.slice(i + 1);
+        i = input.length;
+        descriptors.push({ name, suffix: "term" });
+        break;
+      }
+      name = input.slice(i + 1, closingTick);
+      i = closingTick + 1;
+    } else {
+      const start = i;
+      while (i < input.length && !isSuffixChar(input[i])) {
+        i++;
+      }
+      name = input.slice(start, i);
+    }
+    if (i >= input.length) {
+      if (name) descriptors.push({ name, suffix: "term" });
+      break;
+    }
+    const char = input[i];
+    if (char === "(") {
+      const closeParen = input.indexOf(")", i + 1);
+      if (closeParen !== -1 && input[closeParen + 1] === ".") {
+        descriptors.push({ name, suffix: "method" });
+        i = closeParen + 2;
+      } else if (closeParen !== -1) {
+        descriptors.push({ name, suffix: "method" });
+        i = closeParen + 1;
+      } else {
+        descriptors.push({ name, suffix: "term" });
+        i++;
+      }
+    } else {
+      const suffix = SUFFIX_MAP[char];
+      if (suffix) {
+        descriptors.push({ name, suffix });
+        i += 1;
+      } else {
+        i += 1;
+      }
+    }
+  }
+  return descriptors;
+}
+function isSuffixChar(c) {
+  return c === "/" || c === "#" || c === "." || c === "(" || c === "[" || c === ":" || c === "!";
+}
+function shortenSymbol(raw) {
+  const parsed = parseSymbol(raw);
+  if ("kind" in parsed && parsed.kind === "local") {
+    return `local:${parsed.id}`;
+  }
+  const sym = parsed;
+  if (sym.descriptors.length === 0) return sym.raw;
+  const parts = [];
+  for (const desc of sym.descriptors) {
+    let name = desc.name;
+    if (desc.suffix === "namespace") {
+      name = name.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\.(py|pyi)$/, "").replace(/\.(rs)$/, "").replace(/\.(java|scala|kt|kts)$/, "").replace(/\.(rb)$/, "").replace(/\.(go)$/, "").replace(/\.(cs|vb)$/, "").replace(/\.(dart)$/, "").replace(/\.(php)$/, "").replace(/\.(c|cc|cpp|cxx|h|hpp)$/, "");
+    }
+    if (!name) continue;
+    if (desc.suffix === "method") {
+      parts.push(`${name}()`);
+    } else {
+      parts.push(name);
+    }
+  }
+  return parts.join(":");
+}
+function leafName(raw) {
+  const parsed = parseSymbol(raw);
+  if ("kind" in parsed && parsed.kind === "local") {
+    return parsed.id;
+  }
+  const sym = parsed;
+  if (sym.descriptors.length === 0) return "";
+  const last = sym.descriptors[sym.descriptors.length - 1];
+  return last.name;
+}
+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/query-support.ts
+var FILE_DEFINITION_CACHE = /* @__PURE__ */ new WeakMap();
+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 findExactSymbolMatch(db, symbol) {
+  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 = ?
+       ${db.pathExclusionsFor("d")}
+     ORDER BY d.relative_path, der.start_line
+     LIMIT 1`,
+    symbol
+  );
+  if (!row || db.isIgnored(row.relative_path)) {
+    return null;
+  }
+  return {
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path
+  };
+}
+function resolveIndexedFile(db, filePattern) {
+  return resolveDocumentCandidates(db, filePattern, { allowMultiple: false })[0]?.relativePath ?? null;
+}
+function resolveIndexedPaths(db, filePattern) {
+  return resolveDocumentCandidates(db, filePattern, { allowMultiple: true }).map((candidate) => candidate.relativePath);
+}
+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;
@@ -1494,820 +2115,1055 @@ function getCalleeRowsForSymbol(db, symbol, opts = {}) {
     ${opts.limit ? "LIMIT ?" : ""}`,
     ...calleeQueryParams(symbol, opts.limit)
   );
-  return rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
+  const primary = 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);
+  const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
+  if (sourceFallback.length === 0) {
+    return primary;
   }
-  return params;
-}
-function uniquePatterns(patterns) {
-  return [...new Set(patterns)];
+  if (primary.length === 0) {
+    return applyLimit(sourceFallback, opts.limit);
+  }
+  const seen = new Set(primary.map((row) => `${row.symbol}|${row.file}`));
+  const merged = [...primary];
+  for (const row of sourceFallback) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(row);
+  }
+  return applyLimit(merged, opts.limit);
 }
-
-// src/queries/trace.ts
-function trace(db, symbolPattern) {
-  const match = findFirstSymbolMatch(db, symbolPattern);
+function getCallerRowsForSymbol(db, symbol, opts = {}) {
+  const match = getFullSymbolMatch(db, symbol);
   if (!match) {
-    return { definitions: [], referencedBy: [] };
+    return [];
   }
-  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.id = ?
-    ORDER BY d.relative_path, der.start_line
-    LIMIT 10`,
-    match.symbolId
-  );
-  const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    signature: cleanSignature(r.sig)
-  }));
-  const refRows = db.all(
-    `SELECT DISTINCT d.relative_path
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    WHERE m.symbol_id = ?
-      AND m.role != 1
-    ORDER BY d.relative_path`,
-    match.symbolId
-  );
-  const referencedBy = refRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
-  return { definitions, referencedBy };
-}
-
-// src/queries/deps.ts
-function deps(db, filePattern) {
-  const rows = db.all(
-    `SELECT DISTINCT d2.relative_path
-    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.relative_path LIKE ?
-      AND d2.relative_path <> d1.relative_path
-      AND ${db.localSymbolPredicate}
-    ORDER BY d2.relative_path`,
-    `%${filePattern}%`
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
-}
-function rdeps(db, filePattern) {
-  const rows = db.all(
-    `SELECT DISTINCT d1.relative_path
-    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 d2.relative_path LIKE ?
-      AND d1.relative_path NOT LIKE ?
-    ORDER BY d1.relative_path`,
-    `%${filePattern}%`,
-    `%${filePattern}%`
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
-}
-
-// src/queries/system.ts
-function system(db, modulePattern) {
-  const fileRows = db.all(
-    `SELECT relative_path FROM documents
-     WHERE relative_path LIKE ?
-     ORDER BY relative_path`,
-    `%${modulePattern}%`
-  );
-  const files2 = fileRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
-  const symbolRows = db.all(
-    `SELECT der.start_line, der.end_line, gs.symbol,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path LIKE ?
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
-      AND gs.documentation IS NOT NULL
-    ORDER BY d.relative_path, der.start_line`,
-    `%${modulePattern}%`
-  );
-  const symbols2 = symbolRows.map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    signature: cleanSignature(r.sig)
-  }));
-  const depRows = db.all(
-    `SELECT DISTINCT d2.relative_path
-    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.relative_path LIKE ?
-      AND d2.relative_path NOT LIKE ?
-      AND ${db.localSymbolPredicate}
-    ORDER BY d2.relative_path`,
-    `%${modulePattern}%`,
-    `%${modulePattern}%`
-  );
-  const dependsOn = depRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
-  const rdepRows = db.all(
-    `SELECT DISTINCT d1.relative_path
-    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 d2.relative_path LIKE ?
-      AND d1.relative_path NOT LIKE ?
-    ORDER BY d1.relative_path`,
-    `%${modulePattern}%`,
-    `%${modulePattern}%`
-  );
-  const dependedOnBy = rdepRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
-  return { files: files2, symbols: symbols2, dependsOn, dependedOnBy };
-}
-
-// src/queries/surface.ts
-function surface(db, modulePattern) {
-  const rows = db.all(
-    `SELECT DISTINCT d1.relative_path, gs.symbol
+  const primary = db.all(
+    `SELECT DISTINCT caller_gs.symbol AS caller_symbol, caller_d.relative_path AS caller_file
     FROM mentions m
     JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d1 ON c.document_id = d1.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d2 ON der.document_id = d2.id
-    WHERE d2.relative_path LIKE ?
-      AND d1.relative_path NOT LIKE ?
-      AND ${db.localSymbolPredicate}
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    JOIN defn_enclosing_ranges caller_der
+      ON caller_der.document_id = ref_d.id
+      AND c.start_line >= caller_der.start_line
+      AND c.end_line <= caller_der.end_line
+    JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
+    JOIN documents caller_d ON caller_der.document_id = caller_d.id
+    WHERE m.symbol_id = ?
       AND m.role != 1
-    ORDER BY d1.relative_path`,
-    `%${modulePattern}%`,
-    `%${modulePattern}%`
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    consumer: r.relative_path,
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol)
+      AND caller_gs.id != ?
+      ${db.symbolNoiseFor("caller_gs")}
+      ${db.pathExclusionsFor("caller_d")}
+    ORDER BY caller_d.relative_path
+    ${opts.limit ? "LIMIT ?" : ""}`,
+    ...callerQueryParams(match, opts.limit)
+  ).filter((row) => !db.isIgnored(row.caller_file)).map((row) => ({
+    symbol: row.caller_symbol,
+    file: row.caller_file
   }));
-}
-
-// src/entry-surfaces.ts
-var liveBarrelCache = /* @__PURE__ */ new WeakMap();
-function normalizePath(path2) {
-  return path2.replace(/\\/g, "/");
-}
-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 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;
+  const sourceFallback = getPythonSourceCallerRows(db, match, opts.limit);
+  if (sourceFallback.length === 0) {
+    return primary;
   }
-  if (basename === "index.ts" || basename === "index.js") {
-    return segments.length <= 2;
+  const merged = sourceFallback.length > 0 ? [...sourceFallback] : [];
+  const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
+  for (const row of primary) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    if (isFunctionLikeSymbol(row.symbol) || merged.length === 0) {
+      seen.add(key);
+      merged.push(row);
+    }
   }
-  return normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
-}
-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));
+  return applyLimit(merged, opts.limit);
 }
-function getLiveBarrelPaths(db) {
-  const cached = liveBarrelCache.get(db);
-  if (cached) {
-    return cached;
+function getSourceReferenceSites(db, symbol) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
   }
-  const graph = buildFileDepGraph(db);
-  const queue = getIndexedPaths(db).filter(
-    (path2) => isStructuralEntrySurface(path2) || isWorkerEntrySurface(path2)
+  const identifier = leafName(match.symbol);
+  if (!identifier || !hasUniqueLeafDefinition(db, identifier, match.symbolId)) {
+    return [];
+  }
+  const documents = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
   );
-  const visited = /* @__PURE__ */ new Set();
-  const liveBarrels = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (visited.has(current)) {
-      continue;
-    }
-    visited.add(current);
-    if (isBarrelFile(current)) {
-      liveBarrels.add(current);
-    }
-    for (const dep of graph.get(current) ?? []) {
-      if (!visited.has(dep)) {
-        queue.push(dep);
-      }
+  const sites = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const document of documents) {
+    if (db.isIgnored(document.relative_path)) continue;
+    const lines = findIdentifierLines(db, document.relative_path, identifier, document.relative_path === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {});
+    for (const line of lines) {
+      const enclosing = db.get(
+        `SELECT gs.symbol
+         FROM defn_enclosing_ranges der
+         JOIN global_symbols gs ON der.symbol_id = gs.id
+         JOIN documents d ON der.document_id = d.id
+         WHERE d.relative_path = ?
+           AND der.start_line <= ?
+           AND der.end_line >= ?
+         ORDER BY (der.end_line - der.start_line) ASC
+         LIMIT 1`,
+        document.relative_path,
+        line,
+        line
+      );
+      const key = `${document.relative_path}|${line}|${enclosing?.symbol ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      sites.push({
+        file: document.relative_path,
+        line,
+        enclosingSymbol: enclosing?.symbol ?? null
+      });
     }
   }
-  liveBarrelCache.set(db, liveBarrels);
-  return liveBarrels;
+  return sites;
 }
-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 callerQueryParams(symbol, limit) {
+  const params = [symbol.symbolId, symbol.symbolId];
+  if (typeof limit === "number") {
+    params.push(limit);
+  }
+  return params;
 }
-function getInactiveBarrelPaths(db) {
-  const liveBarrels = getLiveBarrelPaths(db);
-  return getIndexedPaths(db).filter((path2) => isBarrelFile(path2)).filter((path2) => !liveBarrels.has(path2));
+function getPythonSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isPythonDocument(db, match.relativePath)) {
+    return [];
+  }
+  const definitions = getDefinitionsForFile(db, match.relativePath);
+  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
+  if (!current) {
+    return [];
+  }
+  const imports2 = getSourceImports(db, match.relativePath);
+  const bindings = new Map(
+    getSourceConstructorBindings(db, match.relativePath, {
+      startLine: match.startLine,
+      endLine: match.endLine
+    }).map((binding) => [binding.localName, binding.typeName])
+  );
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of getSourceCalls(db, match.relativePath, {
+    startLine: match.startLine,
+    endLine: match.endLine
+  })) {
+    const resolved = resolvePythonCallTarget(
+      db,
+      current,
+      definitions,
+      imports2,
+      bindings,
+      call.receiverName,
+      call.calleeName
+    );
+    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
+    const chunkId = 1e9 + call.line;
+    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: resolved.symbol,
+      file: resolved.relativePath,
+      chunkId
+    });
+  }
+  return applyLimit(rows, limit);
 }
-
-// src/queries/dead.ts
-function dead(db, opts = {}) {
-  const {
-    scope,
-    minLoc = 1,
-    includeTests = false,
-    skipBarrels = false,
-    includeMembers = false
-  } = opts;
-  const params = [minLoc];
-  let testFileExclusions = "";
-  let memberExclusion = "";
-  let barrelExclusions = "";
-  if (scope) {
-    params.push(`%${scope}%`);
+function getJavaScriptSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isJavaScriptDocument(db, match.relativePath)) {
+    return [];
   }
-  if (!includeTests) {
-    testFileExclusions = `
-      AND ${testFileExclusionSql("d", TEST_SUPPORT_PATH_PATTERNS)}
-    `;
+  const definitions = getDefinitionsForFile(db, match.relativePath);
+  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
+  if (!current) {
+    return [];
   }
-  if (!includeMembers) {
-    memberExclusion = `AND gs.symbol NOT LIKE '%#%'`;
+  const imports2 = getSourceImports(db, match.relativePath);
+  const bindings = new Map(
+    getSourceConstructorBindings(db, match.relativePath, {
+      startLine: match.startLine,
+      endLine: match.endLine
+    }).map((binding) => [binding.localName, binding.typeName])
+  );
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of getSourceCalls(db, match.relativePath, {
+    startLine: match.startLine,
+    endLine: match.endLine
+  })) {
+    const resolved = resolveJavaScriptCallTarget(
+      db,
+      current,
+      definitions,
+      imports2,
+      bindings,
+      call.receiverName,
+      call.calleeName
+    );
+    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
+    const chunkId = 1e9 + call.line;
+    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: resolved.symbol,
+      file: resolved.relativePath,
+      chunkId
+    });
   }
-  if (skipBarrels) {
-    const inactiveBarrelPaths = getInactiveBarrelPaths(db);
-    if (inactiveBarrelPaths.length > 0) {
-      barrelExclusions = `AND ref_d.relative_path NOT IN (${inactiveBarrelPaths.map(() => "?").join(", ")})`;
-      params.push(...inactiveBarrelPaths);
+  return applyLimit(rows, limit);
+}
+function getSourceBackedCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  if (isPythonDocument(db, match.relativePath)) {
+    return getPythonSourceCalleeRows(db, match, limit);
+  }
+  if (isJavaScriptDocument(db, match.relativePath)) {
+    return getJavaScriptSourceCalleeRows(db, match, limit);
+  }
+  return [];
+}
+function getPythonSourceCallerRows(db, target, limit) {
+  if (!isPythonDocument(db, target.relativePath)) {
+    return [];
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of getAllFunctionLikeDefinitions(db)) {
+    if (candidate.symbolId === target.symbolId) continue;
+    const callees = getPythonSourceCalleeRows(db, candidate);
+    if (!callees.some((callee) => callee.symbol === target.symbol)) continue;
+    const key = `${candidate.symbol}|${candidate.relativePath}`;
+    if (seen.has(key) || db.isIgnored(candidate.relativePath)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: candidate.symbol,
+      file: candidate.relativePath
+    });
+    if (typeof limit === "number" && rows.length >= limit) {
+      break;
     }
   }
-  const sql = `
-    SELECT
-      d.relative_path,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      gs.symbol,
-      (SELECT COUNT(*) FROM mentions m2
-       JOIN chunks c2 ON m2.chunk_id = c2.id
-       WHERE m2.symbol_id = gs.id AND m2.role != 1 AND c2.document_id = d.id
-      ) AS same_file_refs
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scope ? "AND d.relative_path LIKE ?" : ""}
-      ${testFileExclusions}
-      ${memberExclusion}
-      AND NOT EXISTS (
-        SELECT 1
-        FROM mentions ref_m
-        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-        JOIN documents ref_d ON ref_c.document_id = ref_d.id
-        WHERE ref_m.symbol_id = gs.id
-          AND ref_m.role != 1
-          AND ref_d.id != d.id
-          ${barrelExclusions}
-      )
-    ORDER BY (der.end_line - der.start_line + 1) DESC, d.relative_path, der.start_line
-  `;
-  const rows = db.all(sql, ...params);
-  let deadCodeCount = 0;
-  let fileInternalCount = 0;
-  let totalLoc = 0;
-  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++;
-    totalLoc += r.loc;
-    return {
-      relativePath: r.relative_path,
-      startLine: r.start_line,
-      endLine: r.end_line,
-      loc: r.loc,
-      symbol: r.symbol,
-      shortName: shortenSymbol(r.symbol),
-      sameFileRefs: r.same_file_refs,
-      kind
-    };
-  });
-  return {
-    symbols: symbols2,
-    totalCount: symbols2.length,
-    deadCodeCount,
-    fileInternalCount,
-    totalLoc
-  };
+  return rows;
 }
-
-// src/queries/hotspots.ts
-function hotspots(db, opts = {}) {
-  const { limit = 30, scope } = opts;
-  const scopeFilter = scope ? `AND def_d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      gs.symbol,
-      COUNT(*) AS ref_count,
-      COUNT(DISTINCT ref_d.id) AS file_count,
-      def_d.relative_path AS defined_in
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents ref_d ON c.document_id = ref_d.id
-    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 != 1
-      ${db.pathExclusionsFor("def_d")}
-      ${db.symbolNoiseFor("gs")}
-      ${scopeFilter}
-    GROUP BY gs.id
-    ORDER BY ref_count DESC
-    LIMIT ?`,
-    limit
+function getFullSymbolMatch(db, symbol) {
+  if ("symbol" in symbol && "relativePath" in symbol) {
+    return symbol;
+  }
+  const row = db.get(
+    `SELECT 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.id = ?
+     LIMIT 1`,
+    symbol.symbolId
   );
-  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
-  }));
+  if (!row) {
+    return null;
+  }
+  return {
+    ...symbol,
+    symbol: row.symbol,
+    relativePath: row.relative_path
+  };
 }
-
-// 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);
+function getDefinitionsForFile(db, relativePath) {
+  let cache = FILE_DEFINITION_CACHE.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    FILE_DEFINITION_CACHE.set(db, cache);
+  }
+  const cached = cache.get(relativePath);
   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;
+  const definitions = db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE d.relative_path = ?
+       ${db.symbolNoiseFor("gs")}
+     ORDER BY der.start_line, der.end_line`,
+    relativePath
+  ).map((row) => ({
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path,
+    leaf: leafName(row.symbol),
+    parentTypeName: parentTypeName(row.symbol),
+    isFunctionLike: isFunctionLikeSymbol(row.symbol),
+    isTypeLike: leafSuffix(row.symbol) === "type"
+  }));
+  cache.set(relativePath, definitions);
+  return definitions;
 }
-function parseJavaScriptImports(db, importerPath, source) {
-  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
-    db,
-    importerPath,
-    statement.clause,
-    statement.specifier,
-    statement.start,
-    statement.end,
-    source
-  ));
+function getAllFunctionLikeDefinitions(db) {
+  const rows = db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("d")}
+       ${db.symbolNoiseFor("gs")}
+     ORDER BY d.relative_path, der.start_line`
+  );
+  return rows.filter((row) => !db.isIgnored(row.relative_path)).filter((row) => isFunctionLikeSymbol(row.symbol)).map((row) => ({
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path,
+    leaf: leafName(row.symbol),
+    parentTypeName: parentTypeName(row.symbol),
+    isFunctionLike: true,
+    isTypeLike: false
+  }));
 }
-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
-    });
+function resolvePythonCallTarget(db, current, currentFileDefinitions, imports2, constructorBindings, receiverName, calleeName) {
+  if (receiverName === "self" || receiverName === "cls") {
+    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
   }
-  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
-    });
+  if (receiverName) {
+    const inferredType = constructorBindings.get(receiverName);
+    if (inferredType) {
+      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
+      if (boundMethod) {
+        return boundMethod;
+      }
+      for (const entry of imports2) {
+        if (entry.localName !== inferredType || !entry.sourcePath) continue;
+        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
+        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
+        if (importedMethod) {
+          return importedMethod;
+        }
+      }
+    }
+    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
+    if (localClassMethod) {
+      return localClassMethod;
+    }
+    const namespaceImport = imports2.find((entry) => entry.localName === receiverName && entry.sourcePath);
+    if (namespaceImport?.sourcePath) {
+      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
+      const importedTypeMethod = namespaceImport.kind === "named" ? findDefinitionByName(importedDefinitions, calleeName, namespaceImport.importedName, ["function"]) : null;
+      if (importedTypeMethod) {
+        return importedTypeMethod;
+      }
+      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
+    }
+    return null;
   }
-  return statements.sort((a, b) => a.start - b.start);
+  const importedBinding = imports2.find((entry) => entry.localName === calleeName && entry.sourcePath);
+  if (importedBinding?.sourcePath) {
+    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
+    const importedName = importedBinding.importedName === "*" ? calleeName : importedBinding.importedName;
+    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
+    if (importedDefinition) {
+      return importedDefinition;
+    }
+  }
+  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
 }
-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: []
-    }];
+function resolveJavaScriptCallTarget(db, current, currentFileDefinitions, imports2, constructorBindings, receiverName, calleeName) {
+  if (receiverName === "this") {
+    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
   }
-  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 (receiverName) {
+    const inferredType = constructorBindings.get(receiverName);
+    if (inferredType) {
+      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
+      if (boundMethod) {
+        return boundMethod;
+      }
+      for (const entry of imports2) {
+        if (entry.localName !== inferredType || !entry.sourcePath) continue;
+        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
+        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
+        if (importedMethod) {
+          return importedMethod;
+        }
+      }
     }
-    if (binding.kind === "side-effect") {
-      return { ...binding, used: true, usedMembers: [] };
+    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
+    if (localClassMethod) {
+      return localClassMethod;
+    }
+    const namespaceImport = imports2.find((entry) => entry.localName === receiverName && entry.sourcePath);
+    if (namespaceImport?.sourcePath) {
+      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
+      if (namespaceImport.kind === "named" || namespaceImport.kind === "default") {
+        const importedTypeMethod = findDefinitionByName(
+          importedDefinitions,
+          calleeName,
+          namespaceImport.importedName,
+          ["function"]
+        );
+        if (importedTypeMethod) {
+          return importedTypeMethod;
+        }
+      }
+      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
     }
-    return {
-      ...binding,
-      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
-      usedMembers: []
-    };
-  });
+    return null;
+  }
+  const importedBinding = imports2.find((entry) => entry.localName === calleeName && entry.sourcePath && entry.kind !== "namespace");
+  if (importedBinding?.sourcePath) {
+    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
+    const importedName = importedBinding.importedName === "default" ? importedBinding.localName ?? calleeName : importedBinding.importedName;
+    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
+    if (importedDefinition) {
+      return importedDefinition;
+    }
+  }
+  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
 }
-function parsePythonImports(db, importerPath, source) {
-  return collectPythonImportStatements(source).flatMap(
-    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
-  );
+function findDefinitionByName(definitions, leaf, parentType, preference) {
+  const candidates = definitions.filter((definition) => definition.leaf === leaf && definition.parentTypeName === parentType);
+  if (candidates.length === 0) {
+    return null;
+  }
+  for (const preferred of preference) {
+    const match = candidates.find((candidate) => preferred === "function" ? candidate.isFunctionLike : candidate.isTypeLike);
+    if (match) {
+      return match;
+    }
+  }
+  return candidates[0] ?? null;
 }
-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;
+function hasUniqueLeafDefinition(db, leaf, symbolId) {
+  const rows = db.all(
+    `SELECT id, symbol
+     FROM global_symbols
+     WHERE symbol LIKE ?
+     LIMIT 50`,
+    `%${leaf}%`
+  );
+  let count = 0;
+  for (const row of rows) {
+    if (leafName(row.symbol) !== leaf) continue;
+    count++;
+    if (count > 1 && row.id !== symbolId) {
+      return false;
     }
-    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;
+  }
+  return count === 1;
+}
+function parentTypeName(rawSymbol) {
+  const parsed = parseSymbol(rawSymbol);
+  if ("kind" in parsed) {
+    return null;
+  }
+  for (let index = parsed.descriptors.length - 2; index >= 0; index--) {
+    const descriptor = parsed.descriptors[index];
+    if (descriptor?.suffix === "type") {
+      return descriptor.name;
     }
-    const parsed = parsePythonStatementHeader(statement);
-    if (parsed) {
-      statements.push({
-        ...parsed,
-        start: lineStart,
-        end: statementEnd
-      });
+  }
+  return null;
+}
+function isPythonDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "python" || relativePath.endsWith(".py") || relativePath.endsWith(".pyi");
+}
+function isJavaScriptDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "typescript" || row?.language === "javascript" || /\.(?:[cm]?[jt]sx?)$/.test(relativePath);
+}
+function applyLimit(values, limit) {
+  return typeof limit === "number" ? values.slice(0, limit) : values;
+}
+function resolveDocumentCandidates(db, filePattern, opts) {
+  const normalizedPattern = normalizeLookupPath(filePattern);
+  if (!normalizedPattern) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const scored = rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
+    relativePath: row.relative_path,
+    score: scoreDocumentPath(row.relative_path, normalizedPattern)
+  })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.relativePath.localeCompare(b.relativePath));
+  if (scored.length === 0) {
+    return [];
+  }
+  const exactish = scored.filter((row) => row.score >= 800);
+  if (exactish.length > 0) {
+    return opts.allowMultiple ? exactish : [exactish[0]];
+  }
+  return opts.allowMultiple ? scored : [scored[0]];
+}
+function scoreDocumentPath(relativePath, rawPattern) {
+  const normalizedPath = normalizeLookupPath(relativePath);
+  const pathBase = basename(normalizedPath);
+  const patternBase = basename(rawPattern);
+  let score = 0;
+  if (normalizedPath === rawPattern) score += 1200;
+  if (normalizedPath.endsWith(`/${rawPattern}`)) score += 1100;
+  if (pathBase === patternBase) score += 900;
+  if (normalizedPath.startsWith(`${rawPattern}/`)) score += 850;
+  if (normalizedPath.includes(rawPattern)) score += 250;
+  return score;
+}
+function normalizeLookupPath(filePattern) {
+  return filePattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+
+// 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
+function symbols(db, filePattern) {
+  const resolvedPaths = resolveIndexedPaths(db, filePattern);
+  if (resolvedPaths.length === 0) {
+    return [];
+  }
+  const placeholders = resolvedPaths.map(() => "?").join(", ");
+  const rows = db.all(
+    `SELECT
+      der.start_line,
+      der.end_line,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig,
+      gs.symbol,
+      d.relative_path
+    FROM defn_enclosing_ranges der
+    JOIN global_symbols gs ON der.symbol_id = gs.id
+    JOIN documents d ON der.document_id = d.id
+    WHERE d.relative_path IN (${placeholders})
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+    ORDER BY d.relative_path, der.start_line`,
+    ...resolvedPaths
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    startLine: r.start_line,
+    endLine: r.end_line,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    signature: cleanSignature(r.sig)
+  }));
+}
+
+// src/queries/methods.ts
+function methods(db, className) {
+  const rows = db.all(
+    `SELECT der.start_line, der.end_line, gs.symbol
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    WHERE gs.symbol LIKE ?
+      AND ${db.localSymbolPredicate}
+      AND gs.symbol LIKE '%().%'
+      ${db.symbolNoise}
+    ORDER BY der.start_line`,
+    `%${className}#%`
+  );
+  return rows.map((r) => ({
+    startLine: r.start_line,
+    endLine: r.end_line,
+    name: leafName(r.symbol)
+  }));
+}
+
+// src/queries/refs.ts
+function refs(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (match) {
+    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
+      relativePath: site.file,
+      line: site.line
+    }));
+    if (sourceSites.length > 0) {
+      return sourceSites;
     }
   }
-  return statements;
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line
+    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 m.symbol_id = ?
+      AND ${db.localSymbolPredicate}
+      AND m.role != 1
+    ORDER BY d.relative_path, c.start_line`,
+    match?.symbolId ?? -1
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.start_line
+  }));
 }
-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();
+
+// src/queries/trace.ts
+function trace(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match) {
+    return { definitions: [], referencedBy: [] };
   }
-  return {
-    kind: "from",
-    module: fromMatch[1],
-    clause
-  };
+  const defRows = db.all(
+    `SELECT d.relative_path, der.start_line, der.end_line,
+      gs.display_name,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE gs.id = ?
+    ORDER BY d.relative_path, der.start_line
+    LIMIT 10`,
+    match.symbolId
+  );
+  const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    startLine: r.start_line,
+    endLine: r.end_line,
+    signature: buildTraceSignature(r.sig, r.display_name, match.symbol)
+  }));
+  const sourceSites = getSourceReferenceSites(db, match);
+  const referencedBy = sourceSites.length > 0 ? sourceSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
+    relativePath: site.file,
+    line: site.line,
+    enclosingSymbol: site.enclosingSymbol,
+    enclosingShort: site.enclosingSymbol ? shortenSymbol(site.enclosingSymbol) : "(top-level)"
+  })) : db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line AS line,
+        (SELECT enc_gs.symbol
+         FROM defn_enclosing_ranges enc_der
+         JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+         WHERE enc_der.document_id = d.id
+           AND enc_der.start_line <= c.start_line
+           AND enc_der.end_line >= c.end_line
+         ORDER BY (enc_der.end_line - enc_der.start_line) ASC
+         LIMIT 1
+        ) AS enclosing_symbol
+      FROM mentions m
+      JOIN chunks c ON m.chunk_id = c.id
+      JOIN documents d ON c.document_id = d.id
+      WHERE m.symbol_id = ?
+        AND m.role != 1
+      ORDER BY d.relative_path, c.start_line`,
+    match.symbolId
+  ).filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.line,
+    enclosingSymbol: r.enclosing_symbol,
+    enclosingShort: r.enclosing_symbol ? shortenSymbol(r.enclosing_symbol) : "(top-level)"
+  }));
+  return { definitions, referencedBy };
 }
-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
-      }];
-    });
+function buildTraceSignature(signature, displayName, rawSymbol) {
+  const cleaned = cleanSignature(signature);
+  if (cleaned && !looksBogusSignature(cleaned)) {
+    return cleaned;
   }
-  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: []
-    });
+  const fallback = (displayName ?? "").trim();
+  if (fallback) {
+    return isFunctionLikeSymbol(rawSymbol) && !fallback.endsWith("()") ? `${fallback}()` : fallback;
   }
-  return results;
+  return shortenSymbol(rawSymbol);
 }
-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 looksBogusSignature(signature) {
+  return signature.startsWith("undefined") || signature.includes("|") || signature.includes("```");
 }
-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"
-      };
-    });
+
+// src/queries/deps.ts
+function deps(db, filePattern) {
+  const resolvedFile = resolveIndexedFile(db, filePattern);
+  if (!resolvedFile) {
+    return [];
   }
-  if (trimmed.startsWith("* as ")) {
-    return [{
-      importedName: "*",
-      localName: trimmed.slice(5).trim(),
-      kind: "namespace"
-    }];
+  const rows = db.all(
+    `SELECT DISTINCT d2.relative_path
+    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.relative_path = ?
+      AND d2.relative_path <> d1.relative_path
+      AND ${db.localSymbolPredicate}
+    ORDER BY d2.relative_path`,
+    resolvedFile
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
+}
+function rdeps(db, filePattern) {
+  const resolvedFile = resolveIndexedFile(db, filePattern);
+  if (!resolvedFile) {
+    return [];
   }
-  return [{
-    importedName: "default",
-    localName: trimmed,
-    kind: "default"
-  }];
+  const rows = db.all(
+    `SELECT DISTINCT d1.relative_path
+    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 d2.relative_path = ?
+      AND d1.relative_path != ?
+    ORDER BY d1.relative_path`,
+    resolvedFile,
+    resolvedFile
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
 }
-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()];
-    }
+
+// src/queries/system.ts
+function system(db, modulePattern) {
+  const matchedPaths = resolveIndexedPaths(db, modulePattern);
+  if (matchedPaths.length === 0) {
+    return { files: [], symbols: [], dependsOn: [], dependedOnBy: [] };
   }
-  return [clause.trim(), null];
+  const placeholders = matchedPaths.map(() => "?").join(", ");
+  const fileRows = db.all(
+    `SELECT relative_path FROM documents
+     WHERE relative_path IN (${placeholders})
+     ORDER BY relative_path`,
+    ...matchedPaths
+  );
+  const files2 = fileRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
+  const symbolRows = db.all(
+    `SELECT der.start_line, der.end_line, gs.symbol,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
+    FROM defn_enclosing_ranges der
+    JOIN global_symbols gs ON der.symbol_id = gs.id
+    JOIN documents d ON der.document_id = d.id
+    WHERE d.relative_path IN (${placeholders})
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+      AND gs.documentation IS NOT NULL
+    ORDER BY d.relative_path, der.start_line`,
+    ...matchedPaths
+  );
+  const symbols2 = symbolRows.map((r) => ({
+    startLine: r.start_line,
+    endLine: r.end_line,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    signature: cleanSignature(r.sig)
+  }));
+  const depRows = db.all(
+    `SELECT DISTINCT d2.relative_path
+    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.relative_path IN (${placeholders})
+      AND d2.relative_path NOT IN (${placeholders})
+      AND ${db.localSymbolPredicate}
+    ORDER BY d2.relative_path`,
+    ...matchedPaths,
+    ...matchedPaths
+  );
+  const dependsOn = depRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
+  const rdepRows = db.all(
+    `SELECT DISTINCT d1.relative_path
+    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 d2.relative_path IN (${placeholders})
+      AND d1.relative_path NOT IN (${placeholders})
+    ORDER BY d1.relative_path`,
+    ...matchedPaths,
+    ...matchedPaths
+  );
+  const dependedOnBy = rdepRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
+  return { files: files2, symbols: symbols2, dependsOn, dependedOnBy };
 }
-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;
-    }
+
+// src/queries/surface.ts
+function surface(db, modulePattern) {
+  const matchedPaths = resolveIndexedPaths(db, modulePattern);
+  if (matchedPaths.length === 0) {
+    return [];
   }
-  parts.push(input.slice(start));
-  return parts;
+  const placeholders = matchedPaths.map(() => "?").join(", ");
+  const rows = db.all(
+    `SELECT DISTINCT d1.relative_path, gs.symbol
+    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 d2.relative_path IN (${placeholders})
+      AND d1.relative_path NOT IN (${placeholders})
+      AND ${db.localSymbolPredicate}
+      AND m.role != 1
+    ORDER BY d1.relative_path`,
+    ...matchedPaths,
+    ...matchedPaths
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    consumer: r.relative_path,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol)
+  }));
 }
-function buildUsageBody(source, start, end) {
-  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
-  return stripCommentsAndStrings(masked);
+
+// src/entry-surfaces.ts
+var liveBarrelCache = /* @__PURE__ */ new WeakMap();
+function normalizePath2(path2) {
+  return path2.replace(/\\/g, "/");
 }
-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 isBarrelFile(path2) {
+  const normalized = normalizePath2(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 hasIdentifierUsage(body, identifier) {
-  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
+function isWorkerEntrySurface(path2) {
+  const normalized = normalizePath2(path2);
+  return /(^|\/)[^/]*worker\.(ts|js|mjs|cjs|rs|py|go)$/.test(normalized);
 }
-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);
-    }
+function isStructuralEntrySurface(path2) {
+  const normalized = normalizePath2(path2);
+  const segments = normalized.split("/");
+  const basename2 = segments[segments.length - 1] ?? normalized;
+  if (basename2 === "cli.ts" || basename2 === "cli.js" || basename2 === "postinstall.ts" || basename2 === "postinstall.js" || basename2 === "main.ts" || basename2 === "main.js" || basename2 === "main.rs" || basename2 === "main.go" || basename2 === "main.py") {
+    return true;
   }
-  return [...members2];
-}
-function resolveImportPath(db, importerPath, specifier) {
-  if (isPythonSourcePath(importerPath)) {
-    return resolvePythonImportPath(db, importerPath, specifier);
+  if (basename2 === "index.ts" || basename2 === "index.js") {
+    return segments.length <= 2;
   }
-  return resolveJavaScriptImportPath(db, importerPath, specifier);
+  return normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
 }
-function resolveJavaScriptImportPath(db, importerPath, specifier) {
-  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-    return null;
+function getIndexedPaths2(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 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;
+  const graph = buildFileDepGraph(db);
+  const queue = getIndexedPaths2(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;
     }
-  }
-  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);
+    visited.add(current);
+    if (isBarrelFile(current)) {
+      liveBarrels.add(current);
     }
-    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;
+    for (const dep of graph.get(current) ?? []) {
+      if (!visited.has(dep)) {
+        queue.push(dep);
+      }
     }
   }
-  return null;
+  liveBarrelCache.set(db, liveBarrels);
+  return liveBarrels;
 }
-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 isLiveBarrel(db, path2) {
+  return getLiveBarrelPaths(db).has(normalizePath2(path2));
 }
-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}`));
+function isEntrySurface(db, path2) {
+  return isStructuralEntrySurface(path2) || isWorkerEntrySurface(path2) || isLiveBarrel(db, path2);
+}
+function getInactiveBarrelPaths(db) {
+  const liveBarrels = getLiveBarrelPaths(db);
+  return getIndexedPaths2(db).filter((path2) => isBarrelFile(path2)).filter((path2) => !liveBarrels.has(path2));
+}
+
+// src/queries/dead.ts
+function dead(db, opts = {}) {
+  const {
+    scope,
+    minLoc = 1,
+    includeTests = false,
+    skipBarrels = false,
+    includeMembers = false
+  } = opts;
+  const params = [minLoc];
+  let testFileExclusions = "";
+  let memberExclusion = "";
+  let barrelExclusions = "";
+  if (scope) {
+    params.push(`%${scope}%`);
+  }
+  if (!includeTests) {
+    testFileExclusions = `
+      AND ${testFileExclusionSql("d", TEST_SUPPORT_PATH_PATTERNS)}
+    `;
+  }
+  if (!includeMembers) {
+    memberExclusion = `AND gs.symbol NOT LIKE '%#%'`;
+  }
+  if (skipBarrels) {
+    const inactiveBarrelPaths = getInactiveBarrelPaths(db);
+    if (inactiveBarrelPaths.length > 0) {
+      barrelExclusions = `AND ref_d.relative_path NOT IN (${inactiveBarrelPaths.map(() => "?").join(", ")})`;
+      params.push(...inactiveBarrelPaths);
     }
   }
-  return [...candidates];
+  const sql = `
+    SELECT
+      d.relative_path,
+      der.start_line,
+      der.end_line,
+      (der.end_line - der.start_line + 1) AS loc,
+      gs.symbol,
+      (SELECT COUNT(*) FROM mentions m2
+       JOIN chunks c2 ON m2.chunk_id = c2.id
+       WHERE m2.symbol_id = gs.id AND m2.role != 1 AND c2.document_id = d.id
+      ) AS same_file_refs
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE 1 = 1
+      ${db.pathExclusionsFor("d")}
+      ${db.symbolNoiseFor("gs")}
+      AND (der.end_line - der.start_line + 1) >= ?
+      ${scope ? "AND d.relative_path LIKE ?" : ""}
+      ${testFileExclusions}
+      ${memberExclusion}
+      AND NOT EXISTS (
+        SELECT 1
+        FROM mentions ref_m
+        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+        JOIN documents ref_d ON ref_c.document_id = ref_d.id
+        WHERE ref_m.symbol_id = gs.id
+          AND ref_m.role != 1
+          AND ref_d.id != d.id
+          ${barrelExclusions}
+      )
+    ORDER BY (der.end_line - der.start_line + 1) DESC, d.relative_path, der.start_line
+  `;
+  const rows = db.all(sql, ...params);
+  let deadCodeCount = 0;
+  let fileInternalCount = 0;
+  let totalLoc = 0;
+  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++;
+    totalLoc += r.loc;
+    return {
+      relativePath: r.relative_path,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      loc: r.loc,
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      sameFileRefs: r.same_file_refs,
+      kind
+    };
+  });
+  return {
+    symbols: symbols2,
+    totalCount: symbols2.length,
+    deadCodeCount,
+    fileInternalCount,
+    totalLoc
+  };
 }
-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))
+
+// src/queries/hotspots.ts
+function hotspots(db, opts = {}) {
+  const { limit = 30, scope } = opts;
+  const scopeFilter = scope ? `AND def_d.relative_path LIKE '%${scope}%'` : "";
+  const rows = db.all(
+    `SELECT
+      gs.symbol,
+      COUNT(*) AS ref_count,
+      COUNT(DISTINCT ref_d.id) AS file_count,
+      def_d.relative_path AS defined_in
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    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 != 1
+      ${db.pathExclusionsFor("def_d")}
+      ${db.symbolNoiseFor("gs")}
+      ${scopeFilter}
+    GROUP BY gs.id
+    ORDER BY ref_count DESC
+    LIMIT ?`,
+    limit
   );
-  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, "\\$&");
+  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/queries/imports.ts
 function imports(db, filePattern) {
+  const importer = resolveIndexedFile(db, filePattern);
+  if (!importer) return [];
   const rows = db.all(
     `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file, imp_d.relative_path AS importer
     FROM mentions m
@@ -2316,10 +3172,10 @@ function imports(db, filePattern) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     LEFT JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     LEFT JOIN documents def_d ON der.document_id = def_d.id
-    WHERE imp_d.relative_path LIKE ?
+    WHERE imp_d.relative_path = ?
       AND m.role = 2
     ORDER BY def_d.relative_path, gs.symbol`,
-    `%${filePattern}%`
+    importer
   );
   const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
     symbol: r.symbol,
@@ -2329,8 +3185,6 @@ function imports(db, filePattern) {
   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),
@@ -2396,13 +3250,15 @@ function importedBy(db, symbolPattern) {
   }));
 }
 function unusedImports(db, filePattern) {
+  const importer = resolveIndexedFile(db, filePattern);
+  if (!importer) return [];
   const rows = db.all(
     `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
     JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE d.relative_path LIKE ?
+    WHERE d.relative_path = ?
       AND m.role = 2
       AND NOT EXISTS (
         SELECT 1
@@ -2413,7 +3269,7 @@ function unusedImports(db, filePattern) {
           AND ref_c.document_id = d.id
       )
     ORDER BY d.relative_path, gs.symbol`,
-    `%${filePattern}%`
+    importer
   );
   const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
     symbol: r.symbol,
@@ -2423,28 +3279,12 @@ function unusedImports(db, filePattern) {
   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}`;
@@ -2466,15 +3306,20 @@ function normalizePath3(path2) {
 
 // src/queries/outline.ts
 function outline(db, filePattern) {
+  const resolvedPaths = resolveIndexedPaths(db, filePattern);
+  if (resolvedPaths.length === 0) {
+    return [];
+  }
+  const placeholders = resolvedPaths.map(() => "?").join(", ");
   const rows = db.all(
     `SELECT gs.symbol, gs.enclosing_symbol, der.start_line, der.end_line
     FROM defn_enclosing_ranges der
     JOIN global_symbols gs ON der.symbol_id = gs.id
     JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path LIKE ?
+    WHERE d.relative_path IN (${placeholders})
       ${db.symbolNoise}
-    ORDER BY der.start_line`,
-    `%${filePattern}%`
+    ORDER BY d.relative_path, der.start_line`,
+    ...resolvedPaths
   );
   const nodeMap = /* @__PURE__ */ new Map();
   const roots = [];
@@ -2542,6 +3387,10 @@ function fanIn(db, symbolPattern) {
   }));
 }
 function fanOut(db, filePattern) {
+  const resolvedFile = resolveIndexedFile(db, filePattern);
+  if (!resolvedFile) {
+    return [];
+  }
   const rows = db.all(
     `SELECT d.relative_path, COUNT(DISTINCT gs.id) AS symbol_count
     FROM mentions m
@@ -2550,12 +3399,12 @@ function fanOut(db, filePattern) {
     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 d.relative_path LIKE ?
+    WHERE d.relative_path = ?
       AND m.role != 1
       AND def_d.id != d.id
     GROUP BY d.id
     ORDER BY symbol_count DESC`,
-    `%${filePattern}%`
+    resolvedFile
   );
   return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     name: r.relative_path,
@@ -2616,6 +3465,8 @@ function topFanOut(db, opts = {}) {
 
 // src/queries/coupling.ts
 function coupling(db, file1, file2) {
+  const resolvedFile1 = resolveIndexedFile(db, file1) ?? file1;
+  const resolvedFile2 = resolveIndexedFile(db, file2) ?? file2;
   const row = db.get(
     `SELECT COUNT(DISTINCT gs.id) AS shared
     FROM global_symbols gs
@@ -2624,36 +3475,36 @@ function coupling(db, file1, file2) {
       EXISTS (
         SELECT 1 FROM defn_enclosing_ranges der
         JOIN documents d ON der.document_id = d.id
-        WHERE der.symbol_id = gs.id AND d.relative_path LIKE ?
+        WHERE der.symbol_id = gs.id AND d.relative_path = ?
       )
       AND EXISTS (
         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 != 1 AND d.relative_path LIKE ?
+        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path = ?
       )
     ) OR (
       -- Defined in file2, referenced in file1
       EXISTS (
         SELECT 1 FROM defn_enclosing_ranges der
         JOIN documents d ON der.document_id = d.id
-        WHERE der.symbol_id = gs.id AND d.relative_path LIKE ?
+        WHERE der.symbol_id = gs.id AND d.relative_path = ?
       )
       AND EXISTS (
         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 != 1 AND d.relative_path LIKE ?
+        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path = ?
       )
     )`,
-    `%${file1}%`,
-    `%${file2}%`,
-    `%${file2}%`,
-    `%${file1}%`
+    resolvedFile1,
+    resolvedFile2,
+    resolvedFile2,
+    resolvedFile1
   );
   return {
-    file1,
-    file2,
+    file1: resolvedFile1,
+    file2: resolvedFile2,
     sharedSymbols: row?.shared ?? 0
   };
 }
@@ -2949,7 +3800,7 @@ function byKind(db, kindQuery, opts = {}) {
     `SELECT COUNT(*) AS c FROM global_symbols WHERE kind IS NOT NULL`
   );
   if (!hasKinds || hasKinds.c === 0) {
-    return [];
+    return inferByKind(db, kindNum, scope, limit);
   }
   const rows = db.all(
     `SELECT gs.symbol, gs.kind, d.relative_path, der.start_line, der.end_line
@@ -2989,12 +3840,89 @@ function kindCounts(db, opts = {}) {
     GROUP BY gs.kind
     ORDER BY cnt DESC`
   );
+  if (rows.length === 0) {
+    return inferKindCounts(db, opts.scope);
+  }
   return rows.map((r) => ({
     kind: r.kind,
     kindName: KIND_NAMES[r.kind] ?? "Unknown",
     count: r.cnt
   }));
 }
+function inferByKind(db, kindNum, scope, limit = 100) {
+  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
+  const rows = db.all(
+    `SELECT gs.symbol, d.relative_path, der.start_line, der.end_line, gs.documentation, gs.enclosing_symbol
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("d")}
+       ${scopeFilter}
+     ORDER BY d.relative_path, der.start_line`
+  );
+  return rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
+    row,
+    inferredKind: inferKindNumber(row.symbol, row.documentation, row.enclosing_symbol)
+  })).filter((entry) => entry.inferredKind === kindNum).slice(0, limit).map(({ row, inferredKind }) => ({
+    symbol: row.symbol,
+    shortName: shortenSymbol(row.symbol),
+    kind: inferredKind,
+    kindName: KIND_NAMES[inferredKind] ?? "Unknown",
+    relativePath: row.relative_path,
+    startLine: row.start_line,
+    endLine: row.end_line
+  }));
+}
+function inferKindCounts(db, scope) {
+  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
+  const rows = db.all(
+    `SELECT gs.symbol, gs.documentation, gs.enclosing_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 1 = 1
+       ${db.pathExclusionsFor("d")}
+       ${scopeFilter}`
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const inferred = inferKindNumber(row.symbol, row.documentation, row.enclosing_symbol);
+    if (inferred === null || inferred === 0) continue;
+    counts.set(inferred, (counts.get(inferred) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0]).map(([kind, count]) => ({
+    kind,
+    kindName: KIND_NAMES[kind] ?? "Unknown",
+    count
+  }));
+}
+function inferKindNumber(symbol, documentation, enclosingSymbol) {
+  const parsed = parseSymbol(symbol);
+  if ("kind" in parsed) {
+    return null;
+  }
+  const descriptors = parsed.descriptors;
+  const last = descriptors[descriptors.length - 1] ?? null;
+  const parent = descriptors[descriptors.length - 2] ?? null;
+  const suffix = leafSuffix(symbol);
+  if (suffix === "type") return 9;
+  if (suffix === "method") {
+    return parent?.suffix === "type" ? 33 : 23;
+  }
+  if (suffix === "namespace") return 39;
+  if (suffix !== "term") return null;
+  const signature = (documentation ?? "").toLowerCase();
+  if (signature.includes("async def ") || signature.includes("def ")) {
+    return 23;
+  }
+  const enclosingSuffix = enclosingSymbol ? leafSuffix(enclosingSymbol) : parent?.suffix ?? null;
+  if (enclosingSuffix === "type") {
+    return 21;
+  }
+  return 83;
+}
 
 // src/queries/doc-coverage.ts
 function docCoverage(db, opts = {}) {
@@ -3158,36 +4086,15 @@ function hierarchy(db, symbolPattern) {
 function callGraph(db, symbolPattern) {
   const target = findFirstSymbolMatch(db, symbolPattern);
   if (!target) return null;
-  const callerRows = db.all(
-    `SELECT DISTINCT caller_gs.symbol AS caller_symbol, caller_d.relative_path AS caller_file
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents ref_d ON c.document_id = ref_d.id
-    -- Find the enclosing symbol for where the reference appears
-    JOIN defn_enclosing_ranges caller_der
-      ON caller_der.document_id = ref_d.id
-      AND c.start_line >= caller_der.start_line
-      AND c.end_line <= caller_der.end_line
-    JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
-    JOIN documents caller_d ON caller_der.document_id = caller_d.id
-    WHERE m.symbol_id = ?
-      AND m.role != 1
-      AND caller_gs.id != ?
-      ${db.symbolNoiseFor("caller_gs")}
-      ${db.pathExclusionsFor("caller_d")}
-    ORDER BY caller_d.relative_path
-    LIMIT 50`,
-    target.symbolId,
-    target.symbolId
-  );
-  const calleeRows = getCalleeRowsForSymbol(db, target, { limit: 50 });
+  const callerRows = getCallerRowsForSymbol(db, target, { limit: 50 });
+  const calleeRows = uniqueRows(getCalleeRowsForSymbol(db, target, { limit: 50 }));
   return {
     symbol: target.symbol,
     shortName: shortenSymbol(target.symbol),
-    callers: callerRows.filter((r) => !db.isIgnored(r.caller_file)).map((r) => ({
-      symbol: r.caller_symbol,
-      shortName: shortenSymbol(r.caller_symbol),
-      file: r.caller_file
+    callers: callerRows.map((r) => ({
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      file: r.file
     })),
     callees: calleeRows.map((r) => ({
       symbol: r.symbol,
@@ -3196,6 +4103,17 @@ function callGraph(db, symbolPattern) {
     }))
   };
 }
+function uniqueRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
 
 // src/queries/similar.ts
 function similar(db, symbolPattern, opts = {}) {
@@ -3502,8 +4420,8 @@ function similarChains(db, opts = {}) {
   }
   const structuralNames = ["index.ts", "index.js", "cli.ts", "main.ts", "health.ts", "health.js"];
   for (const node of nodeFreq.keys()) {
-    const basename = node.split("/").pop() ?? "";
-    if (structuralNames.includes(basename)) infraNodes.add(node);
+    const basename2 = node.split("/").pop() ?? "";
+    if (structuralNames.includes(basename2)) infraNodes.add(node);
   }
   const filteredChains = [];
   for (const chain of rawChains) {
@@ -3690,8 +4608,8 @@ function extractCandidates(db, opts = {}) {
   const results = [];
   for (const sym of symbols2) {
     if (db.isIgnored(sym.relative_path)) continue;
-    const basename = sym.relative_path.split("/").pop() ?? "";
-    if (basename.includes("types")) continue;
+    const basename2 = sym.relative_path.split("/").pop() ?? "";
+    if (basename2.includes("types")) continue;
     const calleeChunks = getCalleeRowsForSymbol(db, {
       documentId: sym.document_id,
       startLine: sym.start_line,
@@ -3778,63 +4696,119 @@ function affected(db, symbolPattern, opts = {}) {
   const { maxDepth = 5, scope } = opts;
   const target = findFirstSymbolMatch(db, symbolPattern);
   if (!target) return [];
-  const scopeFilter = scope ? `AND enc_d.relative_path LIKE '%${scope}%'` : "";
   const results = [];
   const visited = /* @__PURE__ */ new Set([target.symbolId]);
-  let frontier = /* @__PURE__ */ new Set([target.symbolId]);
+  const seenResults = /* @__PURE__ */ new Set();
+  let frontier = [target];
   for (let depth = 1; depth <= maxDepth; depth++) {
-    if (frontier.size === 0) break;
-    const placeholders = [...frontier].map(() => "?").join(",");
-    const nextFrontier = /* @__PURE__ */ new Set();
-    const rows = db.all(
-      `SELECT DISTINCT
-        enc_gs.id AS symbol_id,
-        enc_gs.symbol AS symbol,
-        enc_d.relative_path AS relative_path
-      FROM mentions m
-      JOIN chunks c ON m.chunk_id = c.id
-      JOIN documents ref_d ON c.document_id = ref_d.id
-      JOIN defn_enclosing_ranges enc_der
-        ON enc_der.document_id = ref_d.id
-        AND c.start_line >= enc_der.start_line
-        AND c.end_line <= enc_der.end_line
-      JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-      JOIN documents enc_d ON enc_der.document_id = enc_d.id
-      WHERE m.symbol_id IN (${placeholders})
-        AND m.role != 1
-        AND enc_gs.id NOT IN (${placeholders})
-        ${db.symbolNoiseFor("enc_gs")}
-        ${db.pathExclusionsFor("enc_d")}
-        ${scopeFilter}`,
-      ...[...frontier],
-      ...[...frontier]
-    );
-    for (const row of rows) {
-      if (visited.has(row.symbol_id)) continue;
-      if (db.isIgnored(row.relative_path)) continue;
-      visited.add(row.symbol_id);
-      nextFrontier.add(row.symbol_id);
-      results.push({
-        symbol: row.symbol,
-        shortName: shortenSymbol(row.symbol),
-        file: row.relative_path,
-        depth
-      });
+    if (frontier.length === 0) break;
+    const nextFrontier = [];
+    for (const current of frontier) {
+      for (const row of getDirectAffectedRows(db, current, scope)) {
+        const resultKey = `${row.file}|${row.shortName}`;
+        if (row.symbolId !== null) {
+          if (visited.has(row.symbolId)) continue;
+          visited.add(row.symbolId);
+        } else if (seenResults.has(resultKey)) {
+          continue;
+        }
+        seenResults.add(resultKey);
+        results.push({
+          symbol: row.symbol,
+          shortName: row.shortName,
+          file: row.file,
+          depth
+        });
+        if (row.symbolId !== null && row.symbolMatch) {
+          nextFrontier.push(row.symbolMatch);
+        }
+      }
     }
     frontier = nextFrontier;
   }
   results.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
   return results;
 }
+function getDirectAffectedRows(db, target, scope) {
+  const sourceSites = getSourceReferenceSites(db, target).filter((site) => !db.isIgnored(site.file)).filter((site) => !scope || site.file.includes(scope));
+  if (sourceSites.length > 0) {
+    const rows2 = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const site of sourceSites) {
+      if (!site.enclosingSymbol || site.enclosingSymbol === target.symbol) {
+        const key2 = `${site.file}|(top-level)`;
+        if (seen.has(key2)) continue;
+        seen.add(key2);
+        rows2.push({
+          symbolId: null,
+          symbol: site.file,
+          shortName: "(top-level)",
+          file: site.file,
+          symbolMatch: null
+        });
+        continue;
+      }
+      const enclosing = findExactSymbolMatch(db, site.enclosingSymbol);
+      if (!enclosing || enclosing.symbolId === target.symbolId || db.isIgnored(enclosing.relativePath)) {
+        continue;
+      }
+      const key = `${enclosing.symbolId}|${enclosing.relativePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      rows2.push({
+        symbolId: enclosing.symbolId,
+        symbol: enclosing.symbol,
+        shortName: shortenSymbol(enclosing.symbol),
+        file: enclosing.relativePath,
+        symbolMatch: enclosing
+      });
+    }
+    return rows2;
+  }
+  const rows = db.all(
+    `SELECT DISTINCT
+      enc_gs.id AS symbol_id,
+      enc_gs.symbol AS symbol,
+      enc_d.relative_path AS relative_path
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    JOIN defn_enclosing_ranges enc_der
+      ON enc_der.document_id = ref_d.id
+      AND c.start_line >= enc_der.start_line
+      AND c.end_line <= enc_der.end_line
+    JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+    JOIN documents enc_d ON enc_der.document_id = enc_d.id
+    WHERE m.symbol_id = ?
+      AND m.role != 1
+      AND enc_gs.id != ?
+      ${db.symbolNoiseFor("enc_gs")}
+      ${db.pathExclusionsFor("enc_d")}
+      ${scope ? `AND enc_d.relative_path LIKE '%${scope}%'` : ""}
+    ORDER BY enc_d.relative_path
+    LIMIT 1`,
+    target.symbolId,
+    target.symbolId
+  );
+  return rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
+    symbolId: row.symbol_id,
+    symbol: row.symbol,
+    shortName: shortenSymbol(row.symbol),
+    file: row.relative_path,
+    symbolMatch: findExactSymbolMatch(db, row.symbol)
+  }));
+}
 
 // src/queries/change-surface.ts
 function changeSurface(db, filePattern) {
+  const resolvedFile = resolveIndexedFile(db, filePattern);
+  if (!resolvedFile) return null;
   const doc = db.get(
     `SELECT id, relative_path FROM documents
-     WHERE relative_path LIKE ?
+     WHERE relative_path = ?
        ${db.pathExclusionsFor("documents")}
      LIMIT 1`,
-    `%${filePattern}%`
+    resolvedFile
   );
   if (!doc || db.isIgnored(doc.relative_path)) return null;
   const syms = db.all(
@@ -4172,17 +5146,17 @@ function isLikelyTypeOnlyDep(dep) {
 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;
-  if (basename.includes("worker.") || basename.includes("postinstall.")) return true;
-  if (basename === "health.ts" || basename === "health.js") return true;
+function isStructuralRole(basename2) {
+  if (basename2 === "index.ts" || basename2 === "index.js") return true;
+  if (basename2 === "cli.ts" || basename2 === "main.ts" || basename2 === "main.rs") return true;
+  if (basename2.includes("worker.") || basename2.includes("postinstall.")) return true;
+  if (basename2 === "health.ts" || basename2 === "health.js") return true;
   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);
+  const basename2 = path.basename(normalized);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename2) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename2) || /^test[_-]/.test(basename2) || /^test\./.test(basename2);
 }
 
 // src/queries/wrapper-candidates.ts
@@ -4368,8 +5342,8 @@ function staleAbstractions(db, opts) {
     limit
   );
   return rows.filter((r) => !db.isIgnored(r.file)).filter((r) => {
-    const basename = r.file.split("/").pop() ?? "";
-    const isTypeFile = basename.includes("types") || r.file.includes("/types/");
+    const basename2 = r.file.split("/").pop() ?? "";
+    const isTypeFile = basename2.includes("types") || r.file.includes("/types/");
     if (isTypeFile && r.consumers > 0) return false;
     return true;
   }).map((r) => ({
@@ -4773,9 +5747,11 @@ function code(db, symbolPattern, opts = {}) {
   };
 }
 function readFileRange(db, filePath, startLine, endLine, context) {
+  const resolvedPath = resolveIndexedFile(db, filePath);
+  if (!resolvedPath) return null;
   const doc = db.get(
-    `SELECT relative_path, language FROM documents WHERE relative_path LIKE ?`,
-    `%${filePath}%`
+    `SELECT relative_path, language FROM documents WHERE relative_path = ?`,
+    resolvedPath
   );
   if (!doc) return null;
   const fullPath = join7(db.config.projectRoot, doc.relative_path);
@@ -4902,93 +5878,75 @@ function stripCommentsAndStrings2(source) {
 function dataflow(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
   if (!match) return null;
-  const defSites = db.all(
-    `SELECT d.relative_path AS file, c.start_line AS line
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    WHERE m.symbol_id = ? AND m.role = 1
-    ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const usageSites = db.all(
+  const defSites = [{
+    file: match.relativePath,
+    line: match.startLine
+  }];
+  const sourceUsageSites = getSourceReferenceSites(db, match);
+  const usageSites = sourceUsageSites.length > 0 ? sourceUsageSites.map((site) => ({
+    file: site.file,
+    line: site.line,
+    enclosing_symbol: site.enclosingSymbol
+  })) : db.all(
     `SELECT d.relative_path AS file, c.start_line AS line,
-      (SELECT enc_gs.symbol
-       FROM defn_enclosing_ranges enc_der
-       JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-       WHERE enc_der.document_id = d.id
-         AND enc_der.start_line <= c.start_line
-         AND enc_der.end_line >= c.end_line
-       ORDER BY (enc_der.end_line - enc_der.start_line) ASC
-       LIMIT 1
-      ) AS enclosing_symbol
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    WHERE m.symbol_id = ? AND m.role != 1
-      ${db.pathExclusionsFor("d")}
-    ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const producers = db.all(
-    `SELECT DISTINCT other_gs.symbol, other_d.relative_path AS file
-    FROM mentions other_m
-    JOIN chunks other_c ON other_m.chunk_id = other_c.id
-    JOIN global_symbols other_gs ON other_m.symbol_id = other_gs.id
-    JOIN defn_enclosing_ranges other_der ON other_gs.id = other_der.symbol_id
-    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 != 1
-      AND other_gs.id != ?
-      ${db.symbolNoiseFor("other_gs")}
-      ${db.pathExclusionsFor("other_d")}
-    ORDER BY other_d.relative_path
-    LIMIT 30`,
-    match.documentId,
-    match.startLine,
-    match.endLine,
+        (SELECT enc_gs.symbol
+         FROM defn_enclosing_ranges enc_der
+         JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+         WHERE enc_der.document_id = d.id
+           AND enc_der.start_line <= c.start_line
+           AND enc_der.end_line >= c.end_line
+         ORDER BY (enc_der.end_line - enc_der.start_line) ASC
+         LIMIT 1
+        ) AS enclosing_symbol
+      FROM mentions m
+      JOIN chunks c ON m.chunk_id = c.id
+      JOIN documents d ON c.document_id = d.id
+      WHERE m.symbol_id = ? AND m.role != 1
+        ${db.pathExclusionsFor("d")}
+      ORDER BY d.relative_path, c.start_line`,
     match.symbolId
   );
-  const consumers = db.all(
-    `SELECT DISTINCT consumer_gs.symbol, consumer_d.relative_path AS file
-    FROM mentions ref_m
-    JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-    JOIN documents ref_d ON ref_c.document_id = ref_d.id
-    -- Find the enclosing function at each usage site
-    JOIN defn_enclosing_ranges enc_der
-      ON enc_der.document_id = ref_d.id
-      AND enc_der.start_line <= ref_c.start_line
-      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 != 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 != 1
-      AND consumer_d.id != ref_d.id
-      ${db.symbolNoiseFor("consumer_gs")}
-      ${db.pathExclusionsFor("consumer_d")}
-    ORDER BY consumer_d.relative_path
-    LIMIT 30`,
-    match.symbolId
+  const normalizedUsageSites = usageSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
+    file: site.file,
+    line: site.line,
+    enclosingSymbol: site.enclosing_symbol ?? "(top-level)",
+    enclosingShort: site.enclosing_symbol ? shortenSymbol(site.enclosing_symbol) : "(top-level)"
+  }));
+  const producers = uniqueSymbolRows(getCalleeRowsForSymbol(db, match, { limit: 30 }).map((row) => ({
+    symbol: row.symbol,
+    file: row.file
+  })));
+  const consumers = uniqueSymbolRows(
+    normalizedUsageSites.map((site) => ({
+      symbol: site.enclosingSymbol === "(top-level)" ? site.file : site.enclosingSymbol,
+      file: site.file
+    }))
   );
   return {
     symbol: match.symbol,
     shortName: shortenSymbol(match.symbol),
     relativePath: match.relativePath,
     definitionSites: defSites.filter((s) => !db.isIgnored(s.file)),
-    usageSites: usageSites.filter((s) => !db.isIgnored(s.file)).map((s) => ({
-      file: s.file,
-      line: s.line,
-      enclosingSymbol: s.enclosing_symbol ?? "(top-level)",
-      enclosingShort: s.enclosing_symbol ? shortenSymbol(s.enclosing_symbol) : "(top-level)"
-    })),
+    usageSites: normalizedUsageSites,
     producers: producers.filter((p) => !db.isIgnored(p.file)).map((p) => ({ symbol: p.symbol, shortName: shortenSymbol(p.symbol), file: p.file })),
-    consumers: consumers.filter((c) => !db.isIgnored(c.file)).map((c) => ({ symbol: c.symbol, shortName: shortenSymbol(c.symbol), file: c.file }))
+    consumers: consumers.filter((c) => !db.isIgnored(c.file)).map((c) => ({
+      symbol: c.symbol,
+      shortName: c.symbol === c.file ? "(top-level)" : shortenSymbol(c.symbol),
+      file: c.file
+    }))
   };
 }
+function uniqueSymbolRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
 
 // src/queries/slice.ts
 function slice(db, symbolPattern, opts = {}) {
@@ -5003,21 +5961,6 @@ function slice(db, symbolPattern, opts = {}) {
 }
 function backwardSlice(db, match) {
   const callees = getCalleeRowsForSymbol(db, match);
-  const localPredecessors = db.all(
-    `SELECT DISTINCT gs.symbol, d.relative_path AS file
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE der.document_id = ?
-      AND der.end_line < ?
-      AND gs.id != ?
-      ${db.symbolNoiseFor("gs")}
-    ORDER BY der.start_line DESC
-    LIMIT 15`,
-    match.documentId,
-    match.startLine,
-    match.symbolId
-  );
   const seen = /* @__PURE__ */ new Set();
   const connected = [];
   for (const c of callees) {
@@ -5030,16 +5973,6 @@ function backwardSlice(db, match) {
       relationship: "referenced within definition (callee)"
     });
   }
-  for (const p of localPredecessors) {
-    if (seen.has(p.symbol) || db.isIgnored(p.file)) continue;
-    seen.add(p.symbol);
-    connected.push({
-      symbol: p.symbol,
-      shortName: shortenSymbol(p.symbol),
-      file: p.file,
-      relationship: "defined before target in same file (local predecessor)"
-    });
-  }
   return {
     symbol: match.symbol,
     shortName: shortenSymbol(match.symbol),
@@ -5370,6 +6303,15 @@ function runQuery(query, render) {
     render(query(db));
   });
 }
+function displayLine(line) {
+  return line + 1;
+}
+function displayRange(startLine, endLine) {
+  return `${displayLine(startLine)}-${displayLine(endLine)}`;
+}
+function displayPathRange(relativePath, startLine, endLine) {
+  return `${relativePath}:${displayRange(startLine, endLine)}`;
+}
 var queries = {
   stats,
   files,
@@ -5469,7 +6411,7 @@ program.command("symbols <file>").description("List symbols defined in a file (w
     (results) => {
       for (const r of results) {
         const sig = r.signature ? `  \u2014 ${r.signature}` : "";
-        console.log(`  ${r.startLine}-${r.endLine}  ${r.shortName}${sig}`);
+        console.log(`  ${displayRange(r.startLine, r.endLine)}  ${r.shortName}${sig}`);
       }
     }
   );
@@ -5479,7 +6421,7 @@ program.command("methods <className>").description("List methods of a class (wit
     (db) => queries.methods(db, className),
     (results) => {
       for (const r of results) {
-        console.log(`  ${r.startLine}-${r.endLine}  ${r.name}`);
+        console.log(`  ${displayRange(r.startLine, r.endLine)}  ${r.name}`);
       }
     }
   );
@@ -5495,7 +6437,7 @@ program.command("refs <symbol>").description("Find all files referencing a symbo
           console.log(r.relativePath);
           prevFile = r.relativePath;
         }
-        console.log(`  line ${r.line}`);
+        console.log(`  line ${displayLine(r.line)}`);
       }
     }
   );
@@ -5507,11 +6449,17 @@ program.command("trace <symbol>").description("Trace a symbol: definition + all
       console.log("\u2550\u2550\u2550 DEFINITION \u2550\u2550\u2550");
       for (const d of result.definitions) {
         const sig = d.signature ? `  \u2014 ${d.signature}` : "";
-        console.log(`  ${d.relativePath}:${d.startLine}-${d.endLine}${sig}`);
+        console.log(`  ${displayPathRange(d.relativePath, d.startLine, d.endLine)}${sig}`);
       }
       console.log("\n\u2550\u2550\u2550 REFERENCED BY \u2550\u2550\u2550");
+      let prevFile = "";
       for (const ref of result.referencedBy) {
-        console.log(`  ${ref}`);
+        if (ref.relativePath !== prevFile) {
+          if (prevFile) console.log("");
+          console.log(`  ${ref.relativePath}`);
+          prevFile = ref.relativePath;
+        }
+        console.log(`    line ${displayLine(ref.line)}  in ${ref.enclosingShort}`);
       }
     }
   );
@@ -5540,7 +6488,7 @@ program.command("system <module>").description("Full module map: files, symbols,
       for (const f of result.files) console.log(f);
       console.log("\n\u2550\u2550\u2550 EXPORTED SYMBOLS \u2550\u2550\u2550");
       for (const s of result.symbols) {
-        console.log(`  ${s.startLine}-${s.endLine}  ${s.shortName}`);
+        console.log(`  ${displayRange(s.startLine, s.endLine)}  ${s.shortName}`);
       }
       console.log("\n\u2550\u2550\u2550 DEPENDS ON (internal) \u2550\u2550\u2550");
       for (const d of result.dependsOn) console.log(`  ${d}`);
@@ -5581,7 +6529,7 @@ program.command("dead [scope]").description("Find dead code and file-internal sy
         prevFile = s.relativePath;
       }
       const tag = s.kind === "dead-code" ? "[dead code]" : "[file-internal only]";
-      console.log(`  ${s.startLine}-${s.endLine}  (${s.loc} LOC)  ${s.shortName}  ${tag}`);
+      console.log(`  ${displayRange(s.startLine, s.endLine)}  (${s.loc} LOC)  ${s.shortName}  ${tag}`);
     }
     console.log("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     console.log(
@@ -5647,7 +6595,7 @@ program.command("outline <file>").description("Tree view of symbols in a file (u
       function printTree(nodes, indent) {
         for (const n of nodes) {
           const prefix = "  ".repeat(indent);
-          console.log(`${prefix}${n.startLine}-${n.endLine}  ${n.shortName}`);
+          console.log(`${prefix}${displayRange(n.startLine, n.endLine)}  ${n.shortName}`);
           printTree(n.children, indent + 1);
         }
       }
@@ -5660,7 +6608,7 @@ program.command("members <symbol>").description("All children of a symbol (metho
     (db) => queries.members(db, symbol),
     (results) => {
       for (const r of results) {
-        console.log(`  ${r.startLine}-${r.endLine}  [${r.kind}]  ${r.shortName}`);
+        console.log(`  ${displayRange(r.startLine, r.endLine)}  [${r.kind}]  ${r.shortName}`);
       }
     }
   );
@@ -5770,7 +6718,7 @@ program.command("isolated").description("Find completely orphaned symbols (no re
             console.log(r.relativePath);
             prevFile = r.relativePath;
           }
-          console.log(`  ${r.startLine}-${r.endLine}  (${r.loc} LOC)  ${r.shortName}`);
+          console.log(`  ${displayRange(r.startLine, r.endLine)}  (${r.loc} LOC)  ${r.shortName}`);
         }
         console.log(`
 ${results.length} isolated symbol(s)`);
@@ -5786,7 +6734,7 @@ program.command("by-kind <kind>").description("Find symbols by SCIP kind (class,
         console.log(`No symbols found for kind "${kind}". Use "kind-counts" to see available kinds.`);
       } else {
         for (const r of results) {
-          console.log(`  ${r.relativePath}:${r.startLine}-${r.endLine}  [${r.kindName}]  ${r.shortName}`);
+          console.log(`  ${displayPathRange(r.relativePath, r.startLine, r.endLine)}  [${r.kindName}]  ${r.shortName}`);
         }
         console.log(`
 ${results.length} symbol(s)`);
@@ -5821,7 +6769,7 @@ program.command("doc-coverage").description("Check documentation coverage across
       if (result.undocumentedSymbols.length > 0) {
         console.log("\nUndocumented:");
         for (const s of result.undocumentedSymbols) {
-          console.log(`  ${s.relativePath}:${s.startLine}  ${s.shortName}`);
+          console.log(`  ${s.relativePath}:${displayLine(s.startLine)}  ${s.shortName}`);
         }
       }
     }
@@ -6003,7 +6951,7 @@ program.command("extract-candidates").description("Find functions with natural e
       } else {
         for (const r of results) {
           console.log(`
-${r.relativePath}:${r.startLine}-${r.endLine}  ${r.shortName}  (${r.loc} LOC, ${r.totalCallees} callees)`);
+${displayPathRange(r.relativePath, r.startLine, r.endLine)}  ${r.shortName}  (${r.loc} LOC, ${r.totalCallees} callees)`);
           for (let i = 0; i < r.clusters.length; i++) {
             const c = r.clusters[i];
             console.log(`  Cluster ${i + 1} (${Math.round(c.isolation * 100)}% isolated, ${c.callees.length} callees):`);
@@ -6051,7 +6999,7 @@ program.command("change-surface <file>").description("Pre-change briefing: expor
 `);
   for (const s of result.symbols) {
     const risk = s.riskLevel === "high" ? " *** HIGH RISK ***" : s.riskLevel === "medium" ? " * medium risk *" : "";
-    console.log(`  ${s.startLine}-${s.endLine}  ${s.shortName}  [${s.externalConsumers} consumers]${risk}`);
+    console.log(`  ${displayRange(s.startLine, s.endLine)}  ${s.shortName}  [${s.externalConsumers} consumers]${risk}`);
   }
   db.close();
 });
@@ -6111,7 +7059,7 @@ program.command("wrapper-candidates").description("Find symbols only called by o
     console.log("No wrapper candidates found.");
   } else {
     for (const r of results) {
-      console.log(`  ${r.file}:${r.startLine}-${r.endLine}  ${r.shortName}  (${r.loc} LOC)`);
+      console.log(`  ${displayPathRange(r.file, r.startLine, r.endLine)}  ${r.shortName}  (${r.loc} LOC)`);
       console.log(`    Only called by: ${r.singleCallerShort}  (fan-in: ${r.callerFanIn})`);
     }
     console.log(`
@@ -6126,7 +7074,7 @@ program.command("passthrough-candidates").description("Find functions that just
     console.log("No passthrough candidates found.");
   } else {
     for (const r of results) {
-      console.log(`  ${r.file}:${r.startLine}-${r.endLine}  ${r.shortName}  (${r.loc} LOC)`);
+      console.log(`  ${displayPathRange(r.file, r.startLine, r.endLine)}  ${r.shortName}  (${r.loc} LOC)`);
       console.log(`    Forwards to: ${r.forwardsToShort}  (${r.forwardsToFile})`);
     }
     console.log(`
@@ -6142,7 +7090,7 @@ program.command("stale-abstractions").description("Find types/interfaces with 0-
   } else {
     for (const r of results) {
       const label = r.consumers === 0 ? "unused" : "1 consumer";
-      console.log(`  ${r.file}:${r.startLine}-${r.endLine}  ${r.shortName}  (${r.loc} LOC, ${label})`);
+      console.log(`  ${displayPathRange(r.file, r.startLine, r.endLine)}  ${r.shortName}  (${r.loc} LOC, ${label})`);
     }
     console.log(`
 ${results.length} stale abstraction(s).`);
@@ -6244,11 +7192,11 @@ program.command("code <symbol>").description("Read the source code for a symbol
     db.close();
     return;
   }
-  console.log(`${result.relativePath}:${result.startLine}-${result.endLine}  ${result.shortName}  [${result.language ?? "unknown"}]
+  console.log(`${displayPathRange(result.relativePath, result.startLine, result.endLine)}  ${result.shortName}  [${result.language ?? "unknown"}]
 `);
   const lines = result.source.split("\n");
   for (let i = 0; i < lines.length; i++) {
-    console.log(`  ${String(result.startLine + i).padStart(4)}  ${lines[i]}`);
+    console.log(`  ${String(displayLine(result.startLine + i)).padStart(4)}  ${lines[i]}`);
   }
   db.close();
 });
@@ -6260,7 +7208,7 @@ program.command("complexity <symbol>").description("Per-symbol complexity: branc
     db.close();
     return;
   }
-  console.log(`${result.relativePath}:${result.startLine}-${result.endLine}  ${result.shortName}
+  console.log(`${displayPathRange(result.relativePath, result.startLine, result.endLine)}  ${result.shortName}
 `);
   console.log(`  LOC:                  ${result.loc}`);
   console.log(`  Branches:             ${result.branches}`);
@@ -6283,13 +7231,13 @@ program.command("dataflow <symbol>").description("Reference-level dataflow: defi
   if (result.definitionSites.length > 0) {
     console.log("  \u2550\u2550\u2550 DEFINED AT \u2550\u2550\u2550");
     for (const s of result.definitionSites) {
-      console.log(`    ${s.file}:${s.line}`);
+      console.log(`    ${s.file}:${displayLine(s.line)}`);
     }
   }
   if (result.usageSites.length > 0) {
     console.log("\n  \u2550\u2550\u2550 USED AT \u2550\u2550\u2550");
     for (const s of result.usageSites) {
-      console.log(`    ${s.file}:${s.line}  in ${s.enclosingShort}`);
+      console.log(`    ${s.file}:${displayLine(s.line)}  in ${s.enclosingShort}`);
     }
   }
   if (result.producers.length > 0) {
@@ -6376,7 +7324,7 @@ program.command("similar-signatures").description("Find functions with near-iden
       console.log(`
 Signature: ${g.signature}  (${g.functions.length} functions)`);
       for (const f of g.functions) {
-        console.log(`  ${f.file}:${f.startLine}-${f.endLine}  ${f.shortName}  (${f.loc} LOC)`);
+        console.log(`  ${displayPathRange(f.file, f.startLine, f.endLine)}  ${f.shortName}  (${f.loc} LOC)`);
       }
     }
     console.log(`
@@ -6445,9 +7393,20 @@ program.command("status").description("Show index status for this project").acti
     });
   }
 });
-if (process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1]) {
+if (isCliEntrypoint()) {
   program.parse();
 }
+function isCliEntrypoint() {
+  if (!process.argv[1]) {
+    return false;
+  }
+  const thisFile = fileURLToPath2(import.meta.url);
+  try {
+    return realpathSync(thisFile) === realpathSync(process.argv[1]);
+  } catch {
+    return thisFile === process.argv[1];
+  }
+}
 function collect(value, prev) {
   return prev.concat([value]);
 }