grepmax 0.17.23 → 0.17.24

package/dist/eval-graph-nav.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * Navigation-precision fixture — the measurement gate for the type-position
+ * reference cluster (chunker type-position edges, Phase 10 graph-distance,
+ * `gmax dead` precision). Both standing plans defer that cluster behind one
+ * unmet condition: a `trace --inbound` / `dead` truth set that EXISTS and
+ * MOVES. This is that instrument.
+ *
+ * WHAT IT MEASURES. The call graph is built from tree-sitter call-expression
+ * captures, so `referenced_symbols` holds call/construct sites (`foo()`,
+ * `new Foo()`) but NOT type-position uses (`: Foo`, `<Foo>`, `extends Foo`,
+ * `x as Foo`). `gmax trace --inbound Foo` and `gmax dead Foo` both read that
+ * graph, so a type used purely in annotations looks like it has no callers —
+ * trace under-reports, dead false-positives. This harness quantifies the gap by
+ * contrast: call-position recall (the baseline the graph achieves on the shapes
+ * it does capture) vs type-position recall (≈0 today).
+ *
+ * IT IS A GAUGE, NOT A PASS/FAIL GATE. Call-position recall is already <100%
+ * (chunk rollup, uncaptured shapes) — that is the status quo, not a regression,
+ * so the run always exits 0. The load-bearing number is type-position recall:
+ * low today = standing evidence to build chunker type-position edges; re-run
+ * after building them to confirm it moved. (For a true regression gate on the
+ * call graph, see the caller-count guard in eval-graph-sanity.ts.)
+ *
+ * HOW IT STAYS HONEST (no rot). Ground truth is derived live: for each symbol,
+ * `git grep` every reference and classify each file as a call-position caller or
+ * a type-position-only caller; `getCallers` is the measured set. The only
+ * hand-annotation is each symbol's character (callable vs type-only). The
+ * harness excludes its own file from both grep and the graph so listing the
+ * fixture symbols here can't contaminate the measurement. Run after a reindex.
+ *
+ * Usage:
+ *   npx tsx src/eval-graph-nav.ts            # table output
+ *   npx tsx src/eval-graph-nav.ts --json     # machine-readable
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+var _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+(_a = (_b = process.env).GMAX_WORKER_COUNT) !== null && _a !== void 0 ? _a : (_b.GMAX_WORKER_COUNT = "1");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+const graph_builder_1 = require("./lib/graph/graph-builder");
+const vector_db_1 = require("./lib/store/vector-db");
+const exit_1 = require("./lib/utils/exit");
+const filter_builder_1 = require("./lib/utils/filter-builder");
+const GMAX_ROOT = path.resolve(__dirname, "..");
+const SELF = "src/eval-graph-nav.ts"; // exclude from grep + graph (self-reference)
+// Files that embed the fixture symbols as *string* data (template-literal
+// source, `.toContain("…")` assertions) rather than real type/call references.
+// grep can't tell those apart from genuine uses, so they would manufacture
+// phantom "expected callers" that no correct graph ever surfaces. Excluded from
+// both the grep truth and the getCallers set so the exclusion stays symmetric.
+const FIXTURE_FILES = new Set([SELF, "tests/graph-edges.type-position.test.ts"]);
+const rel = (p) => p.replace(`${GMAX_ROOT}/`, "");
+const INBOUND_SYMBOLS = [
+    // ── Baselines: called/constructed, so the graph captures them. ──────────────
+    {
+        symbol: "getWorkerPool",
+        character: "callable",
+        note: "plain function call sites",
+    },
+    {
+        symbol: "GraphBuilder",
+        character: "callable",
+        note: "class via `new GraphBuilder(...)`",
+    },
+    {
+        symbol: "withQueryTimeout",
+        character: "callable",
+        note: "wrapper function call sites",
+    },
+    {
+        symbol: "isFileCached",
+        character: "callable",
+        note: "predicate function call sites",
+    },
+    // ── The gap: interfaces / type aliases used only in `: T` / `<T>` position. ──
+    {
+        symbol: "SearchResponse",
+        character: "type-only",
+        note: "return/param annotation across search + eval",
+    },
+    {
+        symbol: "VectorRecord",
+        character: "type-only",
+        note: "row interface annotated across index/store/worker",
+    },
+    {
+        symbol: "GraphNode",
+        character: "type-only",
+        note: "graph row interface in dead/formatter consumers",
+    },
+    {
+        symbol: "NeighborHit",
+        character: "type-only",
+        note: "traversal interface, type position only",
+    },
+    {
+        symbol: "CallerTree",
+        character: "type-only",
+        note: "recursive caller interface, type position only",
+    },
+    {
+        symbol: "EdgeDirection",
+        character: "type-only",
+        note: "string-literal type alias, pure type position",
+    },
+    // ── Python (mlx-embed-server/server.py): proves Shape 6 closes the gap in a
+    //    grammar with no `type_identifier` node. ─────────────────────────────────
+    {
+        symbol: "EmbedResponse",
+        character: "callable",
+        note: "Python: Pydantic model via `EmbedResponse(...)` construct site",
+    },
+    {
+        symbol: "EmbedRequest",
+        character: "type-only",
+        note: "Python: Pydantic model in `request: EmbedRequest` annotation only",
+    },
+];
+// Dead-precision truth is derived (LIVE iff grep finds any use beyond def/import).
+const DEAD_SYMBOLS = [
+    "getWorkerPool", // LIVE baseline (call users) — dead must read LIVE
+    "GraphBuilder", // LIVE baseline (construct users)
+    "DeadResult", // non-exported, type-only users → today DEAD (false positive)
+    "EdgeDirection", // exported, type-only users → today PUBLIC_EXPORT (masked)
+    "ResolvedCaller", // exported, type-only users → today PUBLIC_EXPORT (masked)
+    "EmbedRequest", // Python: annotation-only Pydantic model — the canonical false-dead, now LIVE via Shape 6
+];
+function classify(symbol, text) {
+    const s = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (/\bimport\b/.test(text))
+        return "import";
+    if (new RegExp(`\\b(interface|type|class|function|enum)\\s+${s}\\b`).test(text))
+        return "def";
+    if (new RegExp(`\\b(const|let|var)\\s+${s}\\b\\s*[:=]`).test(text))
+        return "def";
+    if (new RegExp(`(\\bnew\\s+${s}\\b|\\b${s}\\s*\\()`).test(text))
+        return "call";
+    if (new RegExp(`([:<,|&(]\\s*${s}\\b|\\bextends\\s+${s}\\b|\\bimplements\\s+${s}\\b|\\bas\\s+${s}\\b|\\b${s}\\s*[[<])`).test(text))
+        return "type";
+    return "other";
+}
+/**
+ * Live ground truth for `symbol`: files that reference it from a call position
+ * vs a type-only position. Definition-only / import-only files are not callers.
+ * A file with any call site counts as a call caller even if it also uses the
+ * symbol as a type (the graph should find it via the call). The harness's own
+ * file is excluded so the fixture list can't contaminate the truth.
+ */
+function referenceTruth(symbol) {
+    let raw;
+    try {
+        raw = (0, node_child_process_1.execFileSync)("git", [
+            "grep",
+            "-nwF",
+            symbol,
+            "--",
+            "*.ts",
+            "*.py",
+            ...[...FIXTURE_FILES].map((f) => `:!${f}`),
+        ], { cwd: GMAX_ROOT, encoding: "utf-8" });
+    }
+    catch (_a) {
+        return { callFiles: new Set(), typeOnlyFiles: new Set() };
+    }
+    const callFiles = new Set();
+    const typeFiles = new Set();
+    for (const line of raw.split("\n")) {
+        if (!line)
+            continue;
+        const parts = line.split(":");
+        const file = parts[0];
+        const text = parts.slice(2).join(":");
+        const kind = classify(symbol, text);
+        if (kind === "call")
+            callFiles.add(file);
+        else if (kind === "type")
+            typeFiles.add(file);
+    }
+    const typeOnlyFiles = new Set([...typeFiles].filter((f) => !callFiles.has(f)));
+    return { callFiles, typeOnlyFiles };
+}
+/** getCallers file set, excluding the harness's own (possibly stale) chunks. */
+function callerFiles(builder, symbol) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const callers = yield builder.getCallers(symbol);
+        return new Set(callers.map((g) => rel(g.file)).filter((f) => !FIXTURE_FILES.has(f)));
+    });
+}
+function recall(found, expected) {
+    let hit = 0;
+    for (const f of expected)
+        if (found.has(f))
+            hit++;
+    return { hit, total: expected.size };
+}
+function runInbound(builder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const out = [];
+        for (const c of INBOUND_SYMBOLS) {
+            const { callFiles, typeOnlyFiles } = referenceTruth(c.symbol);
+            const found = yield callerFiles(builder, c.symbol);
+            out.push({
+                symbol: c.symbol,
+                character: c.character,
+                call: recall(found, callFiles),
+                type: recall(found, typeOnlyFiles),
+                missedType: [...typeOnlyFiles].filter((f) => !found.has(f)),
+                note: c.note,
+            });
+        }
+        return out;
+    });
+}
+function runDead(db, builder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield db.ensureTable();
+        const out = [];
+        for (const symbol of DEAD_SYMBOLS) {
+            const { callFiles, typeOnlyFiles } = referenceTruth(symbol);
+            const trueLive = callFiles.size + typeOnlyFiles.size > 0;
+            const defRows = yield table
+                .query()
+                .select(["is_exported"])
+                .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}')`)
+                .limit(1)
+                .toArray();
+            const found = yield callerFiles(builder, symbol);
+            let status;
+            if (defRows.length === 0)
+                status = "NO_DEF";
+            else if (found.size > 0)
+                status = "LIVE";
+            else
+                status = defRows[0].is_exported ? "PUBLIC_EXPORT" : "DEAD";
+            let verdict;
+            if (trueLive && status === "LIVE")
+                verdict = "correct";
+            else if (!trueLive && status === "DEAD")
+                verdict = "correct";
+            else if (trueLive && status === "DEAD")
+                verdict = "false-dead";
+            else if (trueLive && status === "PUBLIC_EXPORT")
+                verdict = "masked-by-export";
+            else
+                verdict = "over-live";
+            out.push({ symbol, trueLive, status, verdict });
+        }
+        return out;
+    });
+}
+function pool(rows) {
+    const hit = rows.reduce((a, r) => a + r.hit, 0);
+    const total = rows.reduce((a, r) => a + r.total, 0);
+    return { hit, total, pct: total === 0 ? 0 : (100 * hit) / total };
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const jsonMode = process.argv.includes("--json") || process.env.GMAX_EVAL_JSON === "1";
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        const builder = new graph_builder_1.GraphBuilder(db, GMAX_ROOT);
+        const inbound = yield runInbound(builder);
+        const dead = yield runDead(db, builder);
+        yield db.close();
+        const callBaseline = pool(inbound.filter((r) => r.character === "callable").map((r) => r.call));
+        const typeGap = pool(inbound.filter((r) => r.character === "type-only").map((r) => r.type));
+        const falseDead = dead.filter((r) => r.verdict === "false-dead").length;
+        const maskedByExport = dead.filter((r) => r.verdict === "masked-by-export").length;
+        const summary = {
+            callPositionRecall: callBaseline,
+            typePositionRecall: typeGap,
+            deadFalsePositives: falseDead,
+            deadMaskedByExport: maskedByExport,
+        };
+        if (jsonMode) {
+            process.stdout.write(`${JSON.stringify({ summary, inbound, dead }, null, 2)}\n`);
+            yield (0, exit_1.gracefulExit)(0);
+            return;
+        }
+        const pct = (r) => r.total === 0
+            ? "  n/a"
+            : `${Math.round((100 * r.hit) / r.total)}%`.padStart(4);
+        console.log(`Navigation-precision fixture (trace --inbound / dead)`);
+        console.log(`root: ${GMAX_ROOT}\n`);
+        console.log(`Inbound caller recall (getCallers vs grep truth, by reference position):`);
+        for (const r of inbound) {
+            const tag = r.character === "callable" ? "callable " : "type-only";
+            console.log(`  ${r.symbol.padEnd(16)} [${tag}] ` +
+                `call ${pct(r.call)} (${String(r.call.hit).padStart(2)}/${String(r.call.total).padStart(2)})  ` +
+                `type ${pct(r.type)} (${String(r.type.hit).padStart(2)}/${String(r.type.total).padStart(2)})` +
+                (r.character === "type-only" && r.missedType.length
+                    ? `  misses: ${r.missedType.slice(0, 3).join(", ")}${r.missedType.length > 3 ? ", …" : ""}`
+                    : ""));
+        }
+        console.log(`\nDead-code precision (truth derived from grep):`);
+        for (const r of dead) {
+            const flag = r.verdict === "false-dead"
+                ? "  ← FALSE POSITIVE (really LIVE)"
+                : r.verdict === "masked-by-export"
+                    ? "  ← type-only users hidden behind PUBLIC EXPORT"
+                    : "";
+            console.log(`  ${r.symbol.padEnd(16)} truth=${(r.trueLive ? "LIVE" : "DEAD").padEnd(4)}  reported=${r.status.padEnd(13)}${flag}`);
+        }
+        console.log(`\nHeadline` +
+            `\n  call-position recall (baseline): ${callBaseline.hit}/${callBaseline.total} (${Math.round(callBaseline.pct)}%)` +
+            `\n  type-position recall (the gap):  ${typeGap.hit}/${typeGap.total} (${Math.round(typeGap.pct)}%)` +
+            `\n  dead false-positives: ${falseDead}   ·   dead masked-by-export: ${maskedByExport}`);
+        const delta = Math.round(callBaseline.pct - typeGap.pct);
+        if (callBaseline.pct < 40) {
+            console.log(`\nVerdict: INCONCLUSIVE — call-position baseline is unexpectedly low (${Math.round(callBaseline.pct)}%); ` +
+                `the index may be stale. Reindex (gmax index) and re-run.`);
+        }
+        else if (typeGap.pct < 50) {
+            console.log(`\nVerdict: GAP OPEN (${delta} pts) — navigation recovers call sites at ${Math.round(callBaseline.pct)}% ` +
+                `but type-position references at only ${Math.round(typeGap.pct)}%. Standing evidence to build chunker ` +
+                `type-position edges; re-run after to confirm the gap closes.`);
+        }
+        else {
+            console.log(`\nVerdict: GAP CLOSING — type-position recall is up to ${Math.round(typeGap.pct)}% ` +
+                `(call baseline ${Math.round(callBaseline.pct)}%).`);
+        }
+        yield (0, exit_1.gracefulExit)(0);
+    });
+}
+if (require.main === module) {
+    main().catch((e) => {
+        console.error(e);
+        process.exit(1);
+    });
+}

package/dist/eval-graph-sanity.js

@@ -1,20 +1,28 @@
 "use strict";
 /**
- * Phase 0 sanity check for Bundle B G1' (graph-as-recall-recovery).
+ * Graph sanity checks.
  *
- * For each platform hard-miss case (BeyondError, ErrorCodes, resolveActor,
- * errorHandler), mirror the searcher's dense+FTS+RRF pipeline to produce
- * the post-fusion top-200 candidate pool, then count how many of those
- * 200 chunks have `referenced_symbols` containing the target symbol.
+ * Default mode — caller-count guard (regression net for the chunker-v2 /
+ * call-site-dedup fix). Before that fix, `splitIfTooBig` copied a parent
+ * chunk's full `referenced_symbols` onto every sub-chunk, so `getCallers`
+ * multiplied chunk rows: a symbol with 3 real call sites reported 66 callers
+ * (22x). For a set of known gmax symbols this asserts `getCallers`' raw count
+ * stays within a small multiple of grep-truth (word-boundary line matches
+ * across tracked source). Exits nonzero if any symbol blows past the ceiling.
+ * Run after a reindex so the index matches the working tree.
  *
- * ≥1 hit per case = 1-hop outbound graph walk can recover the target
- * (the seed chunk's defined symbol points at the target via the call
- * graph) → worth building the recovery layer.
+ *   npx tsx src/eval-graph-sanity.ts
  *
- * 0 hits across all 4 = the signal isn't in the graph at this seed
- * depth → stop and report the negative result.
+ * Platform mode (--platform) — the original Phase 0 probe for Bundle B G1'
+ * (graph-as-recall-recovery). For each platform hard-miss case (BeyondError,
+ * ErrorCodes, resolveActor, errorHandler), mirror the searcher's dense+FTS+RRF
+ * pipeline to the post-fusion top-200 pool, then count how many of those chunks
+ * carry the target in `referenced_symbols`. ≥1 hit = a 1-hop outbound graph
+ * walk can recover the target → worth building the recovery layer; 0 across all
+ * 4 = the signal isn't in the graph at this depth. Requires
+ * ~/Development/beyond/platform to be indexed.
  *
- * Run: `npx tsx src/eval-graph-sanity.ts`
+ *   npx tsx src/eval-graph-sanity.ts --platform
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -62,12 +70,15 @@ var _a, _b;
 var _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 (_a = (_c = process.env).GMAX_WORKER_COUNT) !== null && _a !== void 0 ? _a : (_c.GMAX_WORKER_COUNT = "1");
+const node_child_process_1 = require("node:child_process");
 const path = __importStar(require("node:path"));
 const config_1 = require("./config");
+const callsites_1 = require("./lib/graph/callsites");
+const graph_builder_1 = require("./lib/graph/graph-builder");
 const vector_db_1 = require("./lib/store/vector-db");
 const exit_1 = require("./lib/utils/exit");
-const pool_1 = require("./lib/workers/pool");
 const filter_builder_1 = require("./lib/utils/filter-builder");
+const pool_1 = require("./lib/workers/pool");
 const PLATFORM_ROOT = path.join((_b = process.env.HOME) !== null && _b !== void 0 ? _b : "", "Development/beyond/platform");
 const HARD_MISS_TARGETS = [
     "BeyondError",
@@ -104,7 +115,9 @@ function probe(target) {
         const table = yield db.ensureTable();
         const pool = (0, pool_1.getWorkerPool)();
         const { dense } = yield pool.encodeQuery(target);
-        const pathPrefix = PLATFORM_ROOT.endsWith("/") ? PLATFORM_ROOT : `${PLATFORM_ROOT}/`;
+        const pathPrefix = PLATFORM_ROOT.endsWith("/")
+            ? PLATFORM_ROOT
+            : `${PLATFORM_ROOT}/`;
         const where = `path LIKE '${(0, filter_builder_1.escapeSqlString)(pathPrefix)}%'`;
         const columns = [
             "id",
@@ -136,14 +149,12 @@ function probe(target) {
         const candidateScores = new Map();
         const docMap = new Map();
         vectorRows.forEach((doc, rank) => {
-            const key = doc.id ||
-                `${doc.path}:${doc.chunk_index}`;
+            const key = doc.id || `${doc.path}:${doc.chunk_index}`;
             docMap.set(key, doc);
             candidateScores.set(key, (candidateScores.get(key) || 0) + 1.0 / (RRF_K + rank + 1));
         });
         ftsRows.forEach((doc, rank) => {
-            const key = doc.id ||
-                `${doc.path}:${doc.chunk_index}`;
+            const key = doc.id || `${doc.path}:${doc.chunk_index}`;
             if (!docMap.has(key))
                 docMap.set(key, doc);
             candidateScores.set(key, (candidateScores.get(key) || 0) + 1.0 / (RRF_K + rank + 1));
@@ -189,7 +200,7 @@ function probe(target) {
         };
     });
 }
-function main() {
+function platformProbe() {
     return __awaiter(this, void 0, void 0, function* () {
         console.log(`Phase 0 sanity check — graph reachability on platform hard-miss cases`);
         console.log(`pathPrefix: ${PLATFORM_ROOT}`);
@@ -214,7 +225,115 @@ function main() {
         console.log(`\nVerdict: ${anyReachable ? "BUILD (≥1 case has graph signal in top-200)" : "ABORT (graph is empty at this depth — pick a different mechanism)"}`);
         console.log(`\nJSON:`);
         console.log(JSON.stringify(summary, null, 2));
-        yield (0, exit_1.gracefulExit)(0);
+    });
+}
+// ---------------------------------------------------------------------------
+// Caller-count guard (default mode)
+// ---------------------------------------------------------------------------
+const GMAX_ROOT = path.resolve(__dirname, "..");
+/**
+ * Distinctive gmax symbols with a spread of real usage. All sit comfortably
+ * below getCallers' internal `.limit(100)`, so the cap can never silently mask
+ * an explosion — if the chunker regresses, the raw count blows past the
+ * ceiling rather than getting clamped to 100. Names are intentionally unusual
+ * (no bare words) so `git grep -w` truth isn't polluted by unrelated matches.
+ */
+const GUARD_SYMBOLS = [
+    "resolveCallSites",
+    "findCallSiteSnippet",
+    "withQueryTimeout",
+    "isFileCached",
+    "getWorkerPool",
+    "isBuiltinCallee",
+    "findDependents",
+    "buildFileSubgraph",
+];
+/**
+ * getCallers returns one chunk-row per referencing chunk. Healthy, that count
+ * is ≤ the number of source lines mentioning the symbol (several mentions in
+ * one chunk collapse to one row; def/import lines aren't call references). So
+ * the healthy ratio is ≤ ~1. A small multiple absorbs index-vs-worktree skew
+ * and chunk-boundary splits while still catching the 22x chunker-v2 blowup.
+ */
+const CEILING_MULTIPLE = 3;
+/** Mirror of getCallers' internal `.limit(100)` — at the cap the guard is blind. */
+const CALLER_LIMIT = 100;
+/**
+ * grep-truth: word-boundary line + file counts for `symbol` across tracked
+ * `.ts` (repo-wide, so experiments/ and scripts/ count too — they're indexed).
+ * `git grep` skips gitignored paths (dist/), matching the indexed corpus.
+ */
+function grepTruth(symbol) {
+    let out;
+    try {
+        out = (0, node_child_process_1.execFileSync)("git", ["grep", "-Fwc", symbol, "--", "*.ts"], {
+            cwd: GMAX_ROOT,
+            encoding: "utf-8",
+        });
+    }
+    catch (_a) {
+        // git grep exits 1 when there are zero matches.
+        return { lines: 0, files: 0 };
+    }
+    let lines = 0;
+    let files = 0;
+    for (const row of out.split("\n")) {
+        const idx = row.lastIndexOf(":");
+        if (idx < 0)
+            continue;
+        const n = Number(row.slice(idx + 1));
+        if (Number.isFinite(n) && n > 0) {
+            lines += n;
+            files++;
+        }
+    }
+    return { lines, files };
+}
+function callerCountGuard() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        yield db.ensureTable();
+        const builder = new graph_builder_1.GraphBuilder(db, GMAX_ROOT);
+        const fileCache = new Map();
+        console.log(`Caller-count guard — getCallers vs grep-truth call sites`);
+        console.log(`root: ${GMAX_ROOT}`);
+        console.log(`ceiling = ${CEILING_MULTIPLE}x grep lines · getCallers cap = ${CALLER_LIMIT}`);
+        console.log(`(run after a reindex so the index matches the working tree)\n`);
+        let allOK = true;
+        for (const sym of GUARD_SYMBOLS) {
+            const { lines: grepLines, files: grepFiles } = grepTruth(sym);
+            const callers = yield builder.getCallers(sym);
+            const raw = callers.length;
+            const deduped = (0, callsites_1.resolveCallSites)(callers.map((c) => ({ symbol: c.symbol, file: c.file, line: c.line })), sym, fileCache).length;
+            const ceiling = CEILING_MULTIPLE * Math.max(1, grepLines);
+            const capped = raw >= CALLER_LIMIT;
+            const ratio = grepLines > 0 ? raw / grepLines : raw;
+            // capped is a failure too: the fixture grew too common, so the cap now
+            // hides explosions — swap it for a lower-usage symbol.
+            const ok = !capped && raw <= ceiling;
+            if (!ok)
+                allOK = false;
+            console.log(`${ok ? "✓" : "✗"} ${sym.padEnd(20)} ` +
+                `callers=${String(raw).padStart(3)} (dedup ${String(deduped).padStart(3)})  ` +
+                `grep=${String(grepLines).padStart(3)}L/${String(grepFiles).padStart(2)}f  ` +
+                `ratio=${ratio.toFixed(2)}  ceiling=${ceiling}` +
+                (capped ? "  [CAPPED — fixture too common]" : ""));
+        }
+        console.log(`\nVerdict: ${allOK ? "PASS (no caller-count explosion)" : "FAIL (getCallers exceeds grep-truth ceiling — chunker symbol dedup regressed)"}`);
+        yield db.close();
+        return allOK;
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = process.argv.includes("--platform");
+        if (platform) {
+            yield platformProbe();
+            yield (0, exit_1.gracefulExit)(0);
+            return;
+        }
+        const ok = yield callerCountGuard();
+        yield (0, exit_1.gracefulExit)(ok ? 0 : 1);
     });
 }
 if (require.main === module) {

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

@@ -17,7 +17,11 @@ class GraphBuilder {
     constructor(db, pathPrefix, excludePrefixes) {
         this.db = db;
         // Normalize to ensure trailing slash for LIKE queries
-        this.pathPrefix = pathPrefix ? (pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`) : undefined;
+        this.pathPrefix = pathPrefix
+            ? pathPrefix.endsWith("/")
+                ? pathPrefix
+                : `${pathPrefix}/`
+            : undefined;
         this.excludePrefixes = (excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []).map((p) => p.endsWith("/") ? p : `${p}/`);
     }
     scopeWhere(condition) {
@@ -37,14 +41,22 @@ class GraphBuilder {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
-            // Find chunks where referenced_symbols contains the symbol
+            // Find chunks that reference the symbol from a call position
+            // (referenced_symbols) OR a type position (type_referenced_symbols). The
+            // two are stored separately so type edges never inflate the call-edge count
+            // used for ranking; navigation unions them.
             const rows = yield table
                 .query()
                 .select([
-                "path", "start_line", "defined_symbols", "referenced_symbols",
-                "role", "parent_symbol", "complexity",
+                "path",
+                "start_line",
+                "defined_symbols",
+                "referenced_symbols",
+                "role",
+                "parent_symbol",
+                "complexity",
             ])
-                .where(this.scopeWhere(`array_contains(referenced_symbols, '${escaped}')`))
+                .where(this.scopeWhere(`(array_contains(referenced_symbols, '${escaped}') OR array_contains(type_referenced_symbols, '${escaped}'))`))
                 .limit(100)
                 .toArray();
             return rows.map((row) => this.mapRowToNode(row, symbol, "caller"));
@@ -82,8 +94,13 @@ class GraphBuilder {
             const centerRows = yield table
                 .query()
                 .select([
-                "path", "start_line", "defined_symbols", "referenced_symbols",
-                "role", "parent_symbol", "complexity",
+                "path",
+                "start_line",
+                "defined_symbols",
+                "referenced_symbols",
+                "role",
+                "parent_symbol",
+                "complexity",
             ])
                 .where(this.scopeWhere(`array_contains(defined_symbols, '${escaped}')`))
                 .limit(1)
@@ -165,7 +182,12 @@ class GraphBuilder {
             }
             const visited = new Set([symbol]);
             const callerTree = yield this.expandCallers(graph.callers, depth - 1, visited);
-            return { center: graph.center, callerTree, callees: graph.callees, importers };
+            return {
+                center: graph.center,
+                callerTree,
+                callees: graph.callees,
+                importers,
+            };
         });
     }
     expandCallers(callers, remainingDepth, visited) {

package/dist/lib/graph/impact.js

@@ -22,8 +22,10 @@ const TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
 const NATIVE_TEST_DIR_RE = /(^|\/)\w+Tests?(\/|$)/;
 const NATIVE_TEST_FILE_RE = /Tests?\.(swift|kt|java)$/;
 function isTestPath(filePath) {
-    return TEST_DIR_RE.test(filePath) || TEST_FILE_RE.test(filePath)
-        || NATIVE_TEST_DIR_RE.test(filePath) || NATIVE_TEST_FILE_RE.test(filePath);
+    return (TEST_DIR_RE.test(filePath) ||
+        TEST_FILE_RE.test(filePath) ||
+        NATIVE_TEST_DIR_RE.test(filePath) ||
+        NATIVE_TEST_FILE_RE.test(filePath));
 }
 const arrow_1 = require("../utils/arrow");
 /**
@@ -214,7 +216,7 @@ function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
             const rows = yield table
                 .query()
                 .select(["path"])
-                .where(`array_contains(referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}') AND ${pathScope}`)
+                .where(`(array_contains(referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}') OR array_contains(type_referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}')) AND ${pathScope}`)
                 .limit(200)
                 .toArray();
             for (const row of rows) {