grepmax 0.21.3 → 0.23.0

package/dist/commands/trace.js

@@ -56,6 +56,10 @@ const stale_hint_1 = require("../lib/utils/stale-hint");
 const useColors = process.stdout.isTTY && !process.env.NO_COLOR;
 const dim = (s) => (useColors ? `\x1b[2m${s}\x1b[22m` : s);
 const bold = (s) => (useColors ? `\x1b[1m${s}\x1b[22m` : s);
+// Inferred-edge marker for caller rows: `member` = receiver-unverified `x.T()`,
+// `type` = a type-position reference (not a call). Free calls stay unmarked —
+// the trustworthy default — so only guesses carry a tag.
+const kindTag = (k) => k === "member" || k === "type" ? ` (${k})` : "";
 function formatTraceAgent(graph, projectRoot, raw = false) {
     if (!graph.center)
         return "(not found)";
@@ -71,7 +75,7 @@ function formatTraceAgent(graph, projectRoot, raw = false) {
     function walkCallers(tree, depth) {
         if (raw) {
             for (const t of tree) {
-                lines.push(`${"  ".repeat(depth)}<- ${t.node.symbol}\t${rel(t.node.file)}:${t.node.line}`);
+                lines.push(`${"  ".repeat(depth)}<- ${t.node.symbol}\t${rel(t.node.file)}:${t.node.line}${kindTag(t.node.edgeKind)}`);
                 walkCallers(t.callers, depth + 1);
             }
             return;
@@ -92,6 +96,9 @@ function formatTraceAgent(graph, projectRoot, raw = false) {
                     file: t.node.file,
                     lineSet: new Set(),
                     sub: [],
+                    // Callers arrive free-first (getCallers sorts), so the first edgeKind
+                    // seen for this group is its highest-confidence one.
+                    edgeKind: t.node.edgeKind,
                 };
                 groups.set(key, g);
                 order.push(key);
@@ -103,7 +110,7 @@ function formatTraceAgent(graph, projectRoot, raw = false) {
             const g = groups.get(key);
             const locs = [...g.lineSet].sort((a, b) => a - b).join(",");
             const loc = g.file ? `${rel(g.file)}:${locs}` : "(not indexed)";
-            lines.push(`${"  ".repeat(depth)}<- ${g.symbol}\t${loc}`);
+            lines.push(`${"  ".repeat(depth)}<- ${g.symbol}\t${loc}${kindTag(g.edgeKind)}`);
             walkCallers(g.sub, depth + 1);
         }
     }
@@ -139,6 +146,7 @@ function buildInboundTree(callerTree, targetSymbol, fileCache, withSnippets, lim
             line: t.node.line,
             snippet: (_b = snippet === null || snippet === void 0 ? void 0 : snippet.snippet) !== null && _b !== void 0 ? _b : null,
             snippetLine: (_c = snippet === null || snippet === void 0 ? void 0 : snippet.snippetLine) !== null && _c !== void 0 ? _c : null,
+            edgeKind: t.node.edgeKind,
             callers: buildInboundTree(t.callers, t.node.symbol, fileCache, withSnippets, limit),
         });
         if (out.length >= limit)
@@ -158,8 +166,8 @@ function formatInboundAgent(center, tree, projectRoot, withSnippets) {
                 ? `${rel(n.file)}:${((_a = n.snippetLine) !== null && _a !== void 0 ? _a : n.line) + 1}`
                 : "(not indexed)";
             const cols = withSnippets
-                ? `${loc}\t${n.symbol}\t${(_b = n.snippet) !== null && _b !== void 0 ? _b : ""}`
-                : `${loc}\t${n.symbol}`;
+                ? `${loc}\t${n.symbol}${kindTag(n.edgeKind)}\t${(_b = n.snippet) !== null && _b !== void 0 ? _b : ""}`
+                : `${loc}\t${n.symbol}${kindTag(n.edgeKind)}`;
             lines.push(`${prefix}${cols}`);
             walk(n.callers, depth + 1);
         }
@@ -194,7 +202,7 @@ function formatInboundHuman(center, tree, projectRoot, withSnippets) {
             const loc = n.file
                 ? `${rel(n.file)}:${((_a = n.snippetLine) !== null && _a !== void 0 ? _a : n.line) + 1}`
                 : "(not indexed)";
-            lines.push(`${indent}${n.symbol}  ${dim(loc)}`);
+            lines.push(`${indent}${n.symbol}  ${dim(loc)}${dim(kindTag(n.edgeKind))}`);
             if (withSnippets && n.snippet) {
                 lines.push(`${indent}  ${dim(n.snippet)}`);
             }

package/dist/lib/daemon/ipc-handler.js

@@ -115,6 +115,7 @@ function handleCommand(daemon, cmd, conn) {
                 case "ping":
                     return {
                         ok: true,
+                        ready: daemon.isReady(),
                         pid: process.pid,
                         uptime: daemon.uptime(),
                         version: DAEMON_VERSION,

package/dist/lib/daemon/mlx-server-manager.js

@@ -147,22 +147,66 @@ class MlxServerManager {
             const env = Object.assign({}, process.env);
             if (mlxModel)
                 env.MLX_EMBED_MODEL = mlxModel;
-            this.mlxChild = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
-                cwd: serverDir,
-                detached: true,
-                stdio: ["ignore", logFd, logFd],
-                env,
+            const closeLogFd = () => {
+                try {
+                    fs.closeSync(logFd);
+                }
+                catch (_a) { }
+            };
+            try {
+                this.mlxChild = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
+                    cwd: serverDir,
+                    detached: true,
+                    stdio: ["ignore", logFd, logFd],
+                    env,
+                });
+            }
+            catch (err) {
+                closeLogFd();
+                console.error(`[daemon] MLX embed server failed to spawn: ${err instanceof Error ? err.message : String(err)} — falling back to CPU embeddings`);
+                this.mlxChild = null;
+                return;
+            }
+            const child = this.mlxChild;
+            let startupSettled = false;
+            let resolveStartupError;
+            const startupError = new Promise((resolve) => {
+                resolveStartupError = resolve;
             });
-            this.mlxChild.unref();
-            console.log(`[daemon] Starting MLX embed server (PID: ${this.mlxChild.pid})`);
+            const onChildError = (err) => {
+                if (!startupSettled) {
+                    resolveStartupError(err);
+                    return;
+                }
+                console.error(`[daemon] MLX embed server process error: ${err.message}`);
+                if (this.mlxChild === child)
+                    this.mlxChild = null;
+            };
+            child.on("error", onChildError);
+            child.unref();
+            console.log(`[daemon] Starting MLX embed server (PID: ${child.pid})`);
             // Poll for readiness (up to 30s)
             for (let i = 0; i < 30; i++) {
-                yield new Promise((r) => setTimeout(r, 1000));
+                const spawnError = yield Promise.race([
+                    startupError,
+                    new Promise((r) => setTimeout(() => r(null), 1000)),
+                ]);
+                if (spawnError) {
+                    startupSettled = true;
+                    child.off("error", onChildError);
+                    closeLogFd();
+                    console.error(`[daemon] MLX embed server failed to spawn: ${spawnError.message} — falling back to CPU embeddings`);
+                    if (this.mlxChild === child)
+                        this.mlxChild = null;
+                    return;
+                }
                 if (yield this.isMlxServerUp()) {
+                    startupSettled = true;
                     console.log("[daemon] MLX embed server ready");
                     return;
                 }
             }
+            startupSettled = true;
             console.error("[daemon] MLX embed server failed to start within 30s — falling back to CPU embeddings");
             this.mlxChild = null;
         });

package/dist/lib/daemon/process-manager.js

@@ -84,7 +84,7 @@ class ProcessManager {
         return __awaiter(this, void 0, void 0, function* () {
             // 1. Check for other daemon processes
             const daemonPids = this.findProcessesByTitle("gmax-daemon").filter((pid) => pid !== process.pid);
-            const workerPids = this.findProcessesByTitle("gmax-worker");
+            let workerPids = this.findProcessesByTitle("gmax-worker");
             if (daemonPids.length === 0 && workerPids.length === 0) {
                 (0, logger_1.log)("daemon", "No stale processes found");
                 return;
@@ -92,15 +92,21 @@ class ProcessManager {
             // A peer that's gracefully shutting down has already dropped its
             // socket/PID/lock (so the liveness probes below read "stale") yet is still
             // mid-cleanup — destroying workers, closing LanceDB. Killing it now corrupts
-            // that teardown. Defer to its draining marker: don't kill it, and don't
-            // sweep its workers (it's reaping them itself); just take over the free lock.
-            let anyDraining = false;
+            // that teardown. Defer to its draining marker until the process exits; only
+            // after the marker grace elapses do we treat it like any other stale daemon.
             for (const pid of daemonPids) {
                 (0, logger_1.log)("daemon", `found daemon PID:${pid}, checking liveness...`);
                 if ((0, daemon_client_1.isDaemonDraining)(pid)) {
-                    anyDraining = true;
-                    (0, logger_1.log)("daemon", `daemon PID:${pid} is gracefully draining — leaving it to exit, taking over`);
-                    continue;
+                    (0, logger_1.log)("daemon", `daemon PID:${pid} is gracefully draining — waiting for it to exit`);
+                    const exited = yield (0, daemon_client_1.waitForDaemonDrain)(pid);
+                    if (exited) {
+                        (0, logger_1.log)("daemon", `daemon PID:${pid} finished draining`);
+                        // The peer may have reaped its workers while we waited. Rescan before
+                        // sweeping so we don't act on a stale process snapshot.
+                        workerPids = this.findProcessesByTitle("gmax-worker");
+                        continue;
+                    }
+                    (0, logger_1.log)("daemon", `daemon PID:${pid} still exists after drain grace — checking stale probes`);
                 }
                 // A busy daemon (mid-index, compaction, big LMDB write) can block the
                 // event loop long enough to miss a ping. Two independent liveness
@@ -120,16 +126,9 @@ class ProcessManager {
             }
             // 2. Kill orphaned workers from previous daemon instances.
             // Safe because this runs before the new daemon's worker pool is initialized.
-            // Skipped while a peer is draining — those workers belong to it and it's
-            // tearing them down; sweeping them here would race its own cleanup.
-            if (anyDraining) {
-                (0, logger_1.log)("daemon", "skipping orphan-worker sweep — a peer is draining its own workers");
-            }
-            else {
-                for (const pid of workerPids) {
-                    (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
-                    yield (0, process_1.killProcess)(pid);
-                }
+            for (const pid of workerPids) {
+                (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
+                yield (0, process_1.killProcess)(pid);
             }
             (0, logger_1.log)("daemon", `Cleaned up ${daemonPids.length} stale daemon(s), ${workerPids.length} orphaned worker(s)`);
         });

package/dist/lib/graph/graph-builder.js

@@ -15,6 +15,19 @@ const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
 const callsites_1 = require("./callsites");
 const graph_traversal_1 = require("./graph-traversal");
+/** Sort key for the caller confidence tier: free call < member call < type ref. */
+function edgeRank(node) {
+    switch (node.edgeKind) {
+        case "free":
+            return 0;
+        case "member":
+            return 1;
+        case "type":
+            return 2;
+        default:
+            return 3;
+    }
+}
 class GraphBuilder {
     constructor(db, pathPrefix, excludePrefixes) {
         this.db = db;
@@ -59,6 +72,10 @@ class GraphBuilder {
                 "start_line",
                 "defined_symbols",
                 "referenced_symbols",
+                // member_/type_ are needed so each caller edge can be tagged free vs
+                // member vs type (the confidence tier + builtin-member suppression).
+                "member_referenced_symbols",
+                "type_referenced_symbols",
                 "role",
                 "parent_symbol",
                 "complexity",
@@ -76,7 +93,23 @@ class GraphBuilder {
                     const fam = (0, languages_1.languageFamilyForPath)(String((_a = row.path) !== null && _a !== void 0 ? _a : ""));
                     return fam == null || fam === anchorFamily;
                 });
-            return guarded.map((row) => this.mapRowToNode(row, symbol, "caller"));
+            const nodes = guarded.map((row) => this.mapRowToNode(row, symbol, "caller"));
+            // Caller-side builtin-member suppression. A member call `x.T()` to a builtin
+            // name T (`.get`/`.map`/`.forEach`) is almost always an unrelated stdlib
+            // method, not a real caller of the project symbol T — mirrors the callee-side
+            // guard in buildGraph. Only fires when T itself is a builtin name, so a normal
+            // symbol that merely has member callers is untouched.
+            const filtered = (0, callsites_1.isBuiltinCallee)(symbol)
+                ? nodes.filter((n) => n.edgeKind !== "member")
+                : nodes;
+            // Confidence sort: free calls (EXTRACTED) first, then member, then type,
+            // preserving scan order within a tier (Array.sort is stable). Keeps the
+            // trustworthy callers above the display caps (peek MAX_CALLERS, MCP limits)
+            // so guesses don't read as facts.
+            return filtered
+                .map((n, i) => ({ n, i }))
+                .sort((a, b) => edgeRank(a.n) - edgeRank(b.n) || a.i - b.i)
+                .map(({ n }) => n);
         });
     }
     /**
@@ -105,6 +138,7 @@ class GraphBuilder {
      */
     buildGraph(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
             // 1. Get Center (Definition)
@@ -127,8 +161,8 @@ class GraphBuilder {
                 : null;
             // 2. Get Callers — anchored to the center definition's language family so a
             // bare name shared across languages doesn't pull in cross-language callers.
-            const anchorFamily = center ? (0, languages_1.languageFamilyForPath)(center.file) : null;
-            const callers = yield this.getCallers(symbol, anchorFamily);
+            const centerFamily = center ? (0, languages_1.languageFamilyForPath)(center.file) : null;
+            const callers = yield this.getCallers(symbol, centerFamily);
             // 3. Get Callees — resolve each to a GraphNode with file:line
             const calleeNames = center ? center.calls.slice(0, 15) : [];
             const centerFile = center ? center.file : "";
@@ -154,11 +188,17 @@ class GraphBuilder {
                     .limit(25)
                     .toArray();
                 if (rows.length > 0) {
-                    // Prefer-self-file: a callee the center also defines locally is almost
-                    // certainly that local definition. Falls back to the first row when no
-                    // candidate is in the center's file (unchanged behaviour then).
+                    // Prefer-self-file, then same-language-family. Only fall back to the
+                    // first row when no candidate shares the center's file or family.
                     const selfRow = rows.find((r) => { var _a; return String((_a = r.path) !== null && _a !== void 0 ? _a : "") === centerFile; });
-                    calleeNodes.push(this.mapRowToNode((selfRow !== null && selfRow !== void 0 ? selfRow : rows[0]), name, "center"));
+                    const familyRow = centerFamily
+                        ? rows.find((r) => {
+                            var _a;
+                            return (0, languages_1.languageFamilyForPath)(String((_a = r.path) !== null && _a !== void 0 ? _a : "")) ===
+                                centerFamily;
+                        })
+                        : undefined;
+                    calleeNodes.push(this.mapRowToNode(((_a = selfRow !== null && selfRow !== void 0 ? selfRow : familyRow) !== null && _a !== void 0 ? _a : rows[0]), name, "center"));
                 }
                 else if (!(0, callsites_1.isBuiltinCallee)(name)) {
                     // Unresolved + a known builtin (.map/.get/forEach) → suppress the
@@ -255,10 +295,7 @@ class GraphBuilder {
     /** Distinct symbols that reference the given symbol (inbound edges). */
     callersOf(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Anchor the guard to this symbol's own definition language family so the
-            // bare name doesn't pull in callers from an unrelated language.
-            const loc = yield this.resolveLocation(symbol);
-            const nodes = yield this.getCallers(symbol, loc ? (0, languages_1.languageFamilyForPath)(loc.file) : null);
+            const nodes = yield this.getAnchoredCallers(symbol);
             const out = [];
             for (const n of nodes) {
                 if (n.symbol && n.symbol !== "unknown" && !out.includes(n.symbol)) {
@@ -312,12 +349,19 @@ class GraphBuilder {
      * several languages); falls back to the first definition when none match.
      */
     resolveLocation(symbol, anchorFamily) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const def = yield this.resolveDefinition(symbol, anchorFamily);
+            return def ? { file: def.file, line: def.line } : null;
+        });
+    }
+    /** Resolve a symbol to its defining chunk plus language family metadata. */
+    resolveDefinition(symbol, anchorFamily) {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
             const rows = yield table
                 .query()
-                .select(["path", "start_line"])
+                .select(["path", "start_line", "is_exported"])
                 .where(this.scopeWhere(`array_contains(defined_symbols, '${escaped}')`))
                 // No anchor → keep the cheap single-row fetch. With one, pull a few
                 // candidates so we can pick the same-family definition instead of guessing.
@@ -335,7 +379,20 @@ class GraphBuilder {
                 if (match)
                     r = match;
             }
-            return { file: String(r.path || ""), line: Number(r.start_line || 0) };
+            const file = String(r.path || "");
+            return {
+                file,
+                line: Number(r.start_line || 0),
+                family: (0, languages_1.languageFamilyForPath)(file),
+                isExported: Boolean(r.is_exported),
+            };
+        });
+    }
+    getAnchoredCallers(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const def = yield this.resolveDefinition(symbol);
+            return this.getCallers(symbol, (_a = def === null || def === void 0 ? void 0 : def.family) !== null && _a !== void 0 ? _a : null);
         });
     }
     /**
@@ -386,6 +443,26 @@ class GraphBuilder {
         if (type === "center") {
             symbol = targetSymbol;
         }
+        // Classify HOW a caller references the target, for the confidence tier. Check
+        // member first: member names are ALSO in referenced_symbols (additive column),
+        // so a plain `referencedSymbols.includes` can't tell the two apart. Center and
+        // callee nodes get no edgeKind (not applicable).
+        let edgeKind;
+        let confidence;
+        if (type === "caller") {
+            if (toArray(row.member_referenced_symbols).includes(targetSymbol)) {
+                edgeKind = "member";
+                confidence = "INFERRED";
+            }
+            else if (referencedSymbols.includes(targetSymbol)) {
+                edgeKind = "free";
+                confidence = "EXTRACTED";
+            }
+            else if (toArray(row.type_referenced_symbols).includes(targetSymbol)) {
+                edgeKind = "type";
+                confidence = "INFERRED";
+            }
+        }
         return {
             symbol,
             file: row.path,
@@ -394,6 +471,8 @@ class GraphBuilder {
             calls: referencedSymbols,
             calledBy: [], // To be filled if we do reverse lookup
             complexity: row.complexity,
+            edgeKind,
+            confidence,
         };
     }
 }

package/dist/lib/graph/impact.js

@@ -13,6 +13,7 @@ exports.isTestPath = isTestPath;
 exports.resolveTargetSymbols = resolveTargetSymbols;
 exports.findTests = findTests;
 exports.findDependents = findDependents;
+const languages_1 = require("../core/languages");
 const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
 const graph_builder_1 = require("./graph-builder");
@@ -50,11 +51,49 @@ function resolveTargetSymbols(target, vectorDb, projectRoot) {
                     symbols.add(s);
                 }
             }
-            return { symbols: [...symbols], resolvedAsFile: true };
+            const family = (0, languages_1.languageFamilyForPath)(absPath);
+            return {
+                symbols: [...symbols],
+                resolvedAsFile: true,
+                symbolFamilies: new Map([...symbols].map((s) => [s, family])),
+            };
         }
         return { symbols: [target], resolvedAsFile: false };
     });
 }
+function familyMatchesPath(anchorFamily, filePath) {
+    if (anchorFamily == null)
+        return true;
+    const family = (0, languages_1.languageFamilyForPath)(filePath);
+    return family == null || family === anchorFamily;
+}
+function resolveSymbolFamilies(symbols, vectorDb, projectRoot, excludePrefixes, seed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const families = new Map(seed);
+        const missing = symbols.filter((s) => !families.has(s));
+        if (missing.length === 0)
+            return families;
+        const table = yield vectorDb.ensureTable();
+        const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+        let pathScope = (0, filter_builder_1.pathStartsWith)(prefix);
+        for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
+            const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
+            pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
+        }
+        for (const sym of missing) {
+            const rows = yield table
+                .query()
+                .select(["path"])
+                .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}') AND ${pathScope}`)
+                .limit(25)
+                .toArray();
+            const file = String(((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.path) || "");
+            families.set(sym, file ? (0, languages_1.languageFamilyForPath)(file) : null);
+        }
+        return families;
+    });
+}
 /**
  * For a single symbol, expand to include all symbols defined in the same file.
  * This catches cases where tests call methods of a class rather than the class name itself
@@ -109,16 +148,18 @@ function expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes) {
  * Fallback hits are tagged with hops = -1.
  */
 function findTests(symbols_1, vectorDb_1, projectRoot_1) {
-    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, depth = 1, excludePrefixes) {
+    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, depth = 1, excludePrefixes, symbolFamilies) {
+        var _a;
         const graphBuilder = new graph_builder_1.GraphBuilder(vectorDb, projectRoot, excludePrefixes);
         const testHits = new Map(); // key: file+symbol
         // Expand single-symbol targets to include all symbols from the same file
         const expanded = yield expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes);
+        const families = yield resolveSymbolFamilies(expanded, vectorDb, projectRoot, excludePrefixes, symbolFamilies);
         for (const symbol of expanded) {
-            yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set());
+            yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set(), (_a = families.get(symbol)) !== null && _a !== void 0 ? _a : null);
         }
         if (testHits.size === 0) {
-            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes);
+            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes, families);
             for (const file of importFiles) {
                 testHits.set(`${file}:(referenced)`, {
                     file,
@@ -131,13 +172,14 @@ function findTests(symbols_1, vectorDb_1, projectRoot_1) {
         return [...testHits.values()].sort((a, b) => a.hops - b.hops || a.file.localeCompare(b.file));
     });
 }
-function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes) {
+function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const files = new Set();
         // Signal 1: referenced_symbols match (precise; works when the chunker
         // captured call references in test bodies). Uses the expanded set so tests
         // that call a method of the target class still match.
-        const dependents = yield findDependents(expandedSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes);
+        const dependents = yield findDependents(expandedSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes, symbolFamilies);
         for (const d of dependents) {
             if (isTestPath(d.file))
                 files.add(d.file);
@@ -155,6 +197,7 @@ function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, pro
         // file symbols (helpers like `log`) textually drags in every test file
         // that mentions them, drowning the answer in false positives.
         for (const sym of originalSymbols) {
+            const family = (_a = symbolFamilies === null || symbolFamilies === void 0 ? void 0 : symbolFamilies.get(sym)) !== null && _a !== void 0 ? _a : null;
             // No .limit() here: LIKE + limit deadlocks in @lancedb 0.27.x when more
             // rows match than the limit (verified). Unlimited scan is fast; cap in JS.
             const rows = yield (0, query_timeout_1.withQueryTimeout)(table
@@ -164,19 +207,19 @@ function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, pro
                 .toArray(), `content LIKE %${sym}% (test fallback)`);
             for (const row of rows.slice(0, 500)) {
                 const p = String(row.path || "");
-                if (isTestPath(p))
+                if (isTestPath(p) && familyMatchesPath(family, p))
                     files.add(p);
             }
         }
         return files;
     });
 }
-function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visited) {
+function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visited, anchorFamily) {
     return __awaiter(this, void 0, void 0, function* () {
         if (visited.has(symbol))
             return;
         visited.add(symbol);
-        const callers = yield graphBuilder.getCallers(symbol);
+        const callers = yield graphBuilder.getCallers(symbol, anchorFamily);
         for (const caller of callers) {
             if (isTestPath(caller.file)) {
                 const key = `${caller.file}:${caller.symbol}`;
@@ -191,7 +234,7 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
             }
             // Continue walking callers if within depth
             if (currentHop < maxDepth - 1) {
-                yield walkCallers(caller.symbol, graphBuilder, testHits, currentHop + 1, maxDepth, visited);
+                yield walkCallers(caller.symbol, graphBuilder, testHits, currentHop + 1, maxDepth, visited, (0, languages_1.languageFamilyForPath)(caller.file));
             }
         }
     });
@@ -201,15 +244,18 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
  * Returns files sorted by number of shared symbols (descending).
  */
 function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
-    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes) {
+    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes, symbolFamilies) {
+        var _a, _b;
         const table = yield vectorDb.ensureTable();
         let pathScope = (0, filter_builder_1.pathStartsWith)(`${projectRoot}/`);
         for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
             pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
         }
-        const counts = new Map();
+        const symbolsByFile = new Map();
+        const families = yield resolveSymbolFamilies(symbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies);
         for (const sym of symbols) {
+            const family = (_a = families.get(sym)) !== null && _a !== void 0 ? _a : null;
             // 200, not 20: with per-chunk rows a popular symbol easily exceeds 20
             // chunks, and truncation here silently drops whole dependent files.
             // (array_contains + limit does not hit the LIKE+limit native hang.)
@@ -223,12 +269,16 @@ function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
                 const p = String(row.path || "");
                 if (excludePaths === null || excludePaths === void 0 ? void 0 : excludePaths.has(p))
                     continue;
-                counts.set(p, (counts.get(p) || 0) + 1);
+                if (!familyMatchesPath(family, p))
+                    continue;
+                const set = (_b = symbolsByFile.get(p)) !== null && _b !== void 0 ? _b : new Set();
+                set.add(sym);
+                symbolsByFile.set(p, set);
             }
         }
-        return Array.from(counts.entries())
-            .sort((a, b) => b[1] - a[1])
+        return Array.from(symbolsByFile.entries())
+            .sort((a, b) => b[1].size - a[1].size)
             .slice(0, limit)
-            .map(([file, sharedSymbols]) => ({ file, sharedSymbols }));
+            .map(([file, symbols]) => ({ file, sharedSymbols: symbols.size }));
     });
 }