grepmax 0.17.1 → 0.17.3

package/README.md

@@ -64,6 +64,7 @@ gmax log src/lib/auth.ts                 # Git commit history for a path or symb
 gmax test handleAuth                     # Find tests via reverse call graph
 gmax impact handleAuth                   # Dependents + affected tests
 gmax similar handleAuth                  # Find similar code patterns
+gmax dead handleAuth                     # Unused-symbol check via call graph (DEAD / PUBLIC EXPORT / LIVE)
 gmax context "auth system" --budget 4000 # Token-budgeted topic summary
 ```
 
@@ -121,6 +122,7 @@ Plugins auto-update when you run `npm install -g grepmax@latest` — no need to
 | `trace_calls` | Call graph: importers, callers (multi-hop), callees with file:line. |
 | `extract_symbol` | Complete function/class body by symbol name. |
 | `peek_symbol` | Compact overview: signature + callers + callees. |
+| `dead` | Unused-symbol check via call graph. Returns `DEAD`, `PUBLIC EXPORT`, or `LIVE` with caller count. |
 | `list_symbols` | Indexed symbols with role and export status. |
 | `index_status` | Index health: chunks, files, projects, watcher status. |
 | `summarize_project` | Project overview: languages, structure, key symbols, entry points. |
@@ -277,6 +279,7 @@ fixtures/
 | `GMAX_WORKER_THREADS` | Worker threads for embedding | 50% of cores |
 | `GMAX_DEBUG` | Debug logging | Off |
 | `GMAX_SUMMARIZER` | Enable summarizer auto-start (`1`) | Off |
+| `GMAX_RERANK` | Enable ColBERT rerank (`1`) — off by default since v0.17.1 ([why](docs/known-limitations.md)) | Off |
 
 ## Troubleshooting
 
@@ -293,6 +296,20 @@ gmax watch stop && gmax watch --daemon -b  # Restart daemon
 
 See [CLAUDE.md](CLAUDE.md) for development setup, commands, and architecture details.
 
+### Benchmarks
+
+Two evaluation harnesses live in the repo. Both emit stable JSON via `:json` variants.
+
+```bash
+pnpm bench:recall          # 97-case internal eval against gmax's own repo
+pnpm bench:recall:json
+pnpm bench:oss             # P1 definition-lookup across express, lodash, platform (sverklo-bench fixtures)
+pnpm bench:oss:json
+GMAX_EVAL_RERANK=1 pnpm bench:oss   # toggle ColBERT rerank
+```
+
+The OSS bench requires the fixture repos to be indexed first — see [`docs/known-limitations.md`](docs/known-limitations.md) for the most recent rerank-on-vs-off comparison across 4 datasets / 131 cases.
+
 ## Attribution
 
 grepmax is built upon the foundation of [mgrep](https://github.com/mixedbread-ai/mgrep) by MixedBread. See the [NOTICE](NOTICE) file for details.

package/dist/commands/dead.js

@@ -0,0 +1,183 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dead = void 0;
+const commander_1 = require("commander");
+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 project_registry_1 = require("../lib/utils/project-registry");
+const project_root_1 = require("../lib/utils/project-root");
+const useColors = process.stdout.isTTY && !process.env.NO_COLOR;
+const style = {
+    bold: (s) => (useColors ? `\x1b[1m${s}\x1b[22m` : s),
+    dim: (s) => (useColors ? `\x1b[2m${s}\x1b[22m` : s),
+    red: (s) => (useColors ? `\x1b[31m${s}\x1b[39m` : s),
+    yellow: (s) => (useColors ? `\x1b[33m${s}\x1b[39m` : s),
+    green: (s) => (useColors ? `\x1b[32m${s}\x1b[39m` : s),
+};
+const TOP_CALLERS = 3;
+function statusLabel(status) {
+    switch (status) {
+        case "DEAD":
+            return "DEAD";
+        case "PUBLIC_EXPORT":
+            return "PUBLIC EXPORT";
+        case "LIVE":
+            return "LIVE";
+    }
+}
+function formatHuman(r, projectRoot) {
+    const rel = (p) => p.startsWith(projectRoot) ? p.slice(projectRoot.length + 1) : p;
+    const defLoc = `${rel(r.defPath)}:${r.defLine + 1}`;
+    if (r.status === "DEAD") {
+        return `${style.red(style.bold("DEAD"))}  ${defLoc} defines ${style.bold(r.symbol)}`;
+    }
+    if (r.status === "PUBLIC_EXPORT") {
+        return `${style.yellow(style.bold("PUBLIC EXPORT"))}  ${defLoc} defines ${style.bold(r.symbol)} ${style.dim("— no internal callers found; check external usage")}`;
+    }
+    const header = `${style.green(style.bold("LIVE"))}  ${defLoc} defines ${style.bold(r.symbol)} ${style.dim(`— ${r.callerCount} inbound caller${r.callerCount === 1 ? "" : "s"} (top ${Math.min(TOP_CALLERS, r.topCallers.length)}):`)}`;
+    const lines = [header];
+    for (const c of r.topCallers) {
+        lines.push(`  ${rel(c.file)}:${c.line + 1}`);
+    }
+    return lines.join("\n");
+}
+function formatAgent(r, projectRoot) {
+    const rel = (p) => p.startsWith(projectRoot) ? p.slice(projectRoot.length + 1) : p;
+    const defLoc = `${rel(r.defPath)}:${r.defLine + 1}`;
+    const callerLocs = r.topCallers
+        .map((c) => `${rel(c.file)}:${c.line + 1}`)
+        .join(",");
+    return [
+        statusLabel(r.status),
+        defLoc,
+        String(r.callerCount),
+        callerLocs,
+    ].join("\t");
+}
+exports.dead = new commander_1.Command("dead")
+    .description("Report whether a symbol has zero inbound callers in the indexed call graph. " +
+    "The call graph reflects what tree-sitter chunked — dynamic dispatch, " +
+    "reflection, eval, and string-built call sites won't show up, so a 'DEAD' " +
+    "result is a hypothesis, not a proof. Exported public-API symbols " +
+    "legitimately have no in-project callers (reported as PUBLIC EXPORT).")
+    .argument("<symbol>", "The symbol to check")
+    .option("--root <dir>", "Project root directory")
+    .option("--in <subpath>", "Restrict to a sub-path of the project (repeatable)", (value, prev) => prev ? [...prev, value] : [value])
+    .option("--exclude <subpath>", "Exclude a sub-path of the project (repeatable)", (value, prev) => prev ? [...prev, value] : [value])
+    .option("--agent", "Compact TSV output for AI agents", false)
+    .action((symbol, opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const root = (0, project_registry_1.resolveRootOrExit)(opts.root);
+    if (root === null)
+        return;
+    let vectorDb = null;
+    try {
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const { resolveScope, buildScopeWhere } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/scope-filter")));
+        const scope = resolveScope({
+            projectRoot,
+            in: opts.in,
+            exclude: opts.exclude,
+        });
+        // Resolve the defining chunk to get path, line, and is_exported.
+        const table = yield vectorDb.ensureTable();
+        const defRows = yield table
+            .query()
+            .select(["path", "start_line", "is_exported"])
+            .where(buildScopeWhere(scope, `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}')`))
+            .limit(1)
+            .toArray();
+        if (defRows.length === 0) {
+            console.log(opts.agent ? "(not found)" : `Symbol not found: ${symbol}`);
+            process.exitCode = 1;
+            return;
+        }
+        const defRow = defRows[0];
+        const defPath = String(defRow.path || "");
+        const defLine = Number(defRow.start_line || 0);
+        const isExported = Boolean(defRow.is_exported);
+        const builder = new graph_builder_1.GraphBuilder(vectorDb, scope.pathPrefix, scope.excludePrefixes);
+        const callers = yield builder.getCallers(symbol);
+        const status = callers.length === 0
+            ? isExported
+                ? "PUBLIC_EXPORT"
+                : "DEAD"
+            : "LIVE";
+        const topCallers = callers
+            .slice(0, TOP_CALLERS)
+            .map((c) => ({ file: c.file, line: c.line }));
+        const result = {
+            status,
+            symbol,
+            defPath,
+            defLine,
+            callerCount: callers.length,
+            topCallers,
+        };
+        console.log(opts.agent
+            ? formatAgent(result, projectRoot)
+            : formatHuman(result, projectRoot));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Dead check failed:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (err) {
+                console.error("Failed to close VectorDB:", err);
+            }
+        }
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/commands/mcp.js

@@ -161,6 +161,18 @@ const TOOLS = [
             required: ["symbol"],
         },
     },
+    {
+        name: "dead",
+        description: "Report whether a symbol has zero inbound callers in the indexed call graph. Returns DEAD, PUBLIC EXPORT (exported with no internal callers), or LIVE with caller count. Hypothesis, not proof: dynamic dispatch, reflection, and string-built call sites won't show up.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: { type: "string", description: "Symbol name to check" },
+                root: { type: "string", description: "Project root (absolute path)" },
+            },
+            required: ["symbol"],
+        },
+    },
     {
         name: "list_symbols",
         description: "List indexed symbols with role and export status.",
@@ -1113,6 +1125,57 @@ exports.mcp = new commander_1.Command("mcp")
             }
         });
     }
+    function handleDead(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            try {
+                const root = typeof args.root === "string" && args.root
+                    ? args.root
+                    : projectRoot;
+                const db = getVectorDb();
+                const table = yield db.ensureTable();
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                const defRows = yield table
+                    .query()
+                    .select(["path", "start_line", "is_exported"])
+                    .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                    .limit(1)
+                    .toArray();
+                if (defRows.length === 0) {
+                    return ok(`Symbol '${symbol}' not found in the index. Check \`gmax status\` to see which projects are indexed, or try \`gmax search ${symbol}\` to find similar symbols.`);
+                }
+                const defRow = defRows[0];
+                const defPath = String(defRow.path || "");
+                const defLine = Number(defRow.start_line || 0);
+                const isExported = Boolean(defRow.is_exported);
+                const builder = new graph_builder_1.GraphBuilder(db, root);
+                const callers = yield builder.getCallers(symbol);
+                const rel = (p) => p.startsWith(root) ? p.slice(root.length + 1) : p;
+                const defLoc = `${rel(defPath)}:${defLine + 1}`;
+                if (callers.length === 0) {
+                    if (isExported) {
+                        return ok(`PUBLIC EXPORT  ${defLoc} defines ${symbol} — no internal callers found; check external usage`);
+                    }
+                    return ok(`DEAD  ${defLoc} defines ${symbol}`);
+                }
+                const top = callers.slice(0, 3);
+                const lines = [
+                    `LIVE  ${defLoc} defines ${symbol} — ${callers.length} inbound caller${callers.length === 1 ? "" : "s"} (top ${top.length}):`,
+                ];
+                for (const c of top) {
+                    lines.push(`  ${rel(c.file)}:${c.line + 1}`);
+                }
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Dead check failed: ${msg}`);
+            }
+        });
+    }
     function handleListSymbols(args) {
         return __awaiter(this, void 0, void 0, function* () {
             ensureWatcher();
@@ -1831,6 +1894,9 @@ exports.mcp = new commander_1.Command("mcp")
             case "peek_symbol":
                 result = yield handlePeekSymbol(toolArgs);
                 break;
+            case "dead":
+                result = yield handleDead(toolArgs);
+                break;
             case "list_symbols":
                 result = yield handleListSymbols(toolArgs);
                 break;

package/dist/eval-graph-sanity.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Phase 0 sanity check 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 produce
+ * the post-fusion top-200 candidate pool, then count how many of those
+ * 200 chunks have `referenced_symbols` containing the target symbol.
+ *
+ * ≥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.
+ *
+ * 0 hits across all 4 = the signal isn't in the graph at this seed
+ * depth → stop and report the negative result.
+ *
+ * Run: `npx tsx src/eval-graph-sanity.ts`
+ */
+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, _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 path = __importStar(require("node:path"));
+const config_1 = require("./config");
+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 PLATFORM_ROOT = path.join((_b = process.env.HOME) !== null && _b !== void 0 ? _b : "", "Development/beyond/platform");
+const HARD_MISS_TARGETS = [
+    "BeyondError",
+    "ErrorCodes",
+    "resolveActor",
+    "errorHandler",
+];
+const PRE_K = 500;
+const STAGE1_K = 200;
+const RRF_K = 60;
+function toStringArray(val) {
+    if (!val)
+        return [];
+    if (Array.isArray(val)) {
+        return val.filter((v) => typeof v === "string");
+    }
+    const maybe = val;
+    if (typeof maybe.toArray === "function") {
+        try {
+            const arr = maybe.toArray();
+            return Array.isArray(arr)
+                ? arr.filter((v) => typeof v === "string")
+                : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return [];
+}
+function probe(target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        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 where = `path LIKE '${(0, filter_builder_1.escapeSqlString)(pathPrefix)}%'`;
+        const columns = [
+            "id",
+            "path",
+            "chunk_index",
+            "start_line",
+            "end_line",
+            "defined_symbols",
+            "referenced_symbols",
+        ];
+        const vectorRows = (yield table
+            .vectorSearch(dense)
+            .select([...columns, "_distance"])
+            .where(where)
+            .limit(PRE_K)
+            .toArray());
+        let ftsRows = [];
+        try {
+            ftsRows = (yield table
+                .search(target)
+                .select([...columns, "_score"])
+                .where(where)
+                .limit(PRE_K)
+                .toArray());
+        }
+        catch (e) {
+            console.warn(`[sanity] FTS unavailable for "${target}": ${e.message}`);
+        }
+        const candidateScores = new Map();
+        const docMap = new Map();
+        vectorRows.forEach((doc, rank) => {
+            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}`;
+            if (!docMap.has(key))
+                docMap.set(key, doc);
+            candidateScores.set(key, (candidateScores.get(key) || 0) + 1.0 / (RRF_K + rank + 1));
+        });
+        const fused = Array.from(candidateScores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, STAGE1_K)
+            .map(([key]) => docMap.get(key))
+            .filter(Boolean);
+        let withRef = 0;
+        let withDef = 0;
+        let rankOfFirstRef = -1;
+        let rankOfFirstDef = -1;
+        const sampleRefHits = [];
+        fused.forEach((doc, i) => {
+            const refs = toStringArray(doc.referenced_symbols);
+            const defs = toStringArray(doc.defined_symbols);
+            if (refs.includes(target)) {
+                withRef++;
+                if (rankOfFirstRef < 0)
+                    rankOfFirstRef = i + 1;
+                if (sampleRefHits.length < 3) {
+                    sampleRefHits.push({ rank: i + 1, path: String(doc.path) });
+                }
+            }
+            if (defs.includes(target)) {
+                withDef++;
+                if (rankOfFirstDef < 0)
+                    rankOfFirstDef = i + 1;
+            }
+        });
+        yield db.close();
+        return {
+            target,
+            poolSize: fused.length,
+            vectorRows: vectorRows.length,
+            ftsRows: ftsRows.length,
+            withRef,
+            withDef,
+            rankOfFirstRef,
+            rankOfFirstDef,
+            sampleRefHits,
+        };
+    });
+}
+function main() {
+    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}`);
+        console.log(`STAGE1_K=${STAGE1_K}, PRE_K=${PRE_K}\n`);
+        let anyReachable = false;
+        const summary = [];
+        for (const target of HARD_MISS_TARGETS) {
+            const res = yield probe(target);
+            summary.push(res);
+            const refOK = res.withRef > 0 ? "✓" : "✗";
+            const defOK = res.withDef > 0 ? "✓" : "✗";
+            console.log(`${refOK} ${target.padEnd(16)} pool=${String(res.poolSize).padStart(3)}  ` +
+                `refs=${String(res.withRef).padStart(3)}/200  defs=${defOK} (${res.withDef})  ` +
+                `1st-ref@${res.rankOfFirstRef > 0 ? res.rankOfFirstRef : "—"}  ` +
+                `1st-def@${res.rankOfFirstDef > 0 ? res.rankOfFirstDef : "—"}`);
+            for (const s of res.sampleRefHits) {
+                console.log(`    ↳ rank ${s.rank}: ${s.path}`);
+            }
+            if (res.withRef > 0)
+                anyReachable = true;
+        }
+        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);
+    });
+}
+if (require.main === module) {
+    main().catch((e) => {
+        console.error(e);
+        process.exit(1);
+    });
+}

package/dist/eval-graph-spotcheck.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Pulls the chunks for a known BeyondError-using file out of the index
+ * and prints their `referenced_symbols` arrays. Lets us see what the
+ * chunker actually extracts vs what's missing — whether BeyondError is
+ * absent due to chunker scope (e.g., only same-function refs are tagged)
+ * or whether the tagging is just sparse.
+ */
+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 config_1 = require("./config");
+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 CANDIDATES = [
+    "/Users/reoiv/Development/beyond/platform/packages/api/src/middleware/error.ts",
+    "/Users/reoiv/Development/beyond/platform/packages/api/src/graphql/shared/error-mapping.ts",
+    "/Users/reoiv/Development/beyond/platform/packages/api/src/lib/service-errors.ts",
+];
+function toStrArr(v) {
+    if (!v)
+        return [];
+    if (Array.isArray(v))
+        return v.filter((x) => typeof x === "string");
+    const m = v;
+    if (typeof m.toArray === "function") {
+        try {
+            const a = m.toArray();
+            return Array.isArray(a) ? a.filter((x) => typeof x === "string") : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return [];
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        const table = yield db.ensureTable();
+        for (const file of CANDIDATES) {
+            console.log(`\n── ${file}`);
+            const rows = (yield table
+                .query()
+                .select(["start_line", "end_line", "chunk_type", "defined_symbols", "referenced_symbols"])
+                .where(`path = '${(0, filter_builder_1.escapeSqlString)(file)}'`)
+                .limit(20)
+                .toArray());
+            if (rows.length === 0) {
+                console.log("  (no chunks indexed for this path)");
+                continue;
+            }
+            for (const r of rows) {
+                const defs = toStrArr(r.defined_symbols);
+                const refs = toStrArr(r.referenced_symbols);
+                const hasBE = refs.includes("BeyondError");
+                console.log(`  lines ${r.start_line}-${r.end_line} (${r.chunk_type})  ` +
+                    `defs=[${defs.slice(0, 4).join(",")}${defs.length > 4 ? "…" : ""}]  ` +
+                    `refs(${refs.length})=[${refs.slice(0, 8).join(",")}${refs.length > 8 ? "…" : ""}]  ` +
+                    `BeyondError-ref=${hasBE ? "✓" : "✗"}`);
+            }
+        }
+        yield db.close();
+        yield (0, exit_1.gracefulExit)(0);
+    });
+}
+if (require.main === module) {
+    main().catch((e) => {
+        console.error(e);
+        process.exit(1);
+    });
+}