graph-indexer 2.1.1 → 3.0.0

package/layout.mjs

@@ -1,123 +0,0 @@
-/**
- * @file layout.mjs
- * @description Single source of truth for graph-indexer's on-disk layout. All
- *              machine-generated runtime state lives in one tidy `.graph-indexer/`
- *              directory at the project root (index, vectors, SQLite db, enrichment
- *              cache, daemon pid/log, resolved config) instead of littering the
- *              root. Earlier versions wrote these artifacts straight into the root;
- *              `migrateLegacyLayout` relocates them transparently on the next run.
- *
- *              Files that other tools must discover at conventional paths — the
- *              agent prompt suite (CLAUDE.md, GRAPH_INDEXER_PROMPT.md, Cursor
- *              rules) and IDE MCP configs (.vscode/mcp.json, .cursor/mcp.json, …) —
- *              intentionally stay where those tools expect them.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-import fs from 'fs';
-import path from 'path';
-
-export const DATA_DIR_NAME = '.graph-indexer';
-
-export const CONFIG_FILE_NAME = 'config.json';
-
-export function dataDir(root) {
-    return path.join(root, DATA_DIR_NAME);
-}
-
-export function ensureDataDir(root) {
-    const dir = dataDir(root);
-    fs.mkdirSync(dir, { recursive: true });
-    return dir;
-}
-
-/**
- * All generated artifact paths for a project root, derived from one stem so the
- * indexer, daemon, MCP server and test harness can never drift apart.
- * @returns {{dataDir,indexPath,embeddingPath,sqlitePath,enrichmentCachePath,pidFile,logFile,configPath}}
- */
-export function artifactPaths(root) {
-    const dir = dataDir(root);
-    return {
-        dataDir: dir,
-        indexPath: path.join(dir, 'code-index.json'),
-        embeddingPath: path.join(dir, 'code-index.embeddings.bin'),
-        sqlitePath: path.join(dir, 'code-index.db'),
-        enrichmentCachePath: path.join(dir, 'code-index.enrichment.json'),
-        gitSignalsPath: path.join(dir, 'code-index.git.json'),
-        pidFile: path.join(dir, 'daemon.pid'),
-        logFile: path.join(dir, 'daemon.log'),
-        configPath: path.join(dir, CONFIG_FILE_NAME),
-    };
-}
-
-// ─── Legacy → current migration ─────────────────────────────────────────────────
-
-// Regenerable runtime artifacts that lived at the project root before v1.4.
-// Each [legacy-root-name, new-name-inside-data-dir]. When both copies exist the
-// stale root one is safe to drop — it is a derived cache, not user data.
-const LEGACY_ARTIFACTS = [
-    ['code-index.json', 'code-index.json'],
-    ['code-index.json.tmp', 'code-index.json.tmp'],
-    ['code-index.embeddings.bin', 'code-index.embeddings.bin'],
-    ['code-index.embeddings.bin.tmp', 'code-index.embeddings.bin.tmp'],
-    ['code-index.db', 'code-index.db'],
-    ['code-index.db-wal', 'code-index.db-wal'],
-    ['code-index.db-shm', 'code-index.db-shm'],
-    ['code-index.enrichment.json', 'code-index.enrichment.json'],
-    ['.idx-daemon.pid', 'daemon.pid'],
-    ['.idx-daemon.log', 'daemon.log'],
-];
-
-function relocate(src, dst) {
-    try { fs.renameSync(src, dst); return true; }
-    catch {
-        try { fs.copyFileSync(src, dst); fs.unlinkSync(src); return true; }
-        catch { return false; }
-    }
-}
-
-/**
- * Relocate pre-v1.4 root artifacts into `.graph-indexer/`. Idempotent and
- * non-destructive to live data: an artifact is only *moved* when the destination
- * is absent; when a fresh copy already exists in the data dir, the orphaned root
- * copy (a regenerable cache) is removed to declutter. The user-editable config
- * (`.graph-indexer.json`) is only ever moved when no new config exists yet —
- * never overwritten or deleted out from under the user.
- *
- * @returns {{moved:Array<{from:string,to:string}>, removed:string[], stoppedDaemon:boolean}}
- */
-export function migrateLegacyLayout(root) {
-    const moved = [];
-    const removed = [];
-    const dir = dataDir(root);
-
-    for (const [legacyName, newName] of LEGACY_ARTIFACTS) {
-        const src = path.join(root, legacyName);
-        if (!fs.existsSync(src)) continue;
-        const dst = path.join(dir, newName);
-        if (fs.existsSync(dst)) {
-            try { fs.unlinkSync(src); removed.push(legacyName); } catch { /* keep on failure */ }
-        } else {
-            ensureDataDir(root);
-            if (relocate(src, dst)) moved.push({ from: legacyName, to: path.join(DATA_DIR_NAME, newName) });
-        }
-    }
-
-    const legacyCfg = path.join(root, '.graph-indexer.json');
-    const newCfg = path.join(dir, CONFIG_FILE_NAME);
-    if (fs.existsSync(legacyCfg) && !fs.existsSync(newCfg)) {
-        ensureDataDir(root);
-        if (relocate(legacyCfg, newCfg)) {
-            moved.push({ from: '.graph-indexer.json', to: path.join(DATA_DIR_NAME, CONFIG_FILE_NAME) });
-        }
-    }
-
-    return { moved, removed, stoppedDaemon: false };
-}
-
-export function hasLegacyLayout(root) {
-    if (fs.existsSync(path.join(root, '.graph-indexer.json'))) return true;
-    return LEGACY_ARTIFACTS.some(([legacyName]) => fs.existsSync(path.join(root, legacyName)));
-}

package/mcp/centrality.mjs

@@ -1,117 +0,0 @@
-/**
- * @file mcp/centrality.mjs
- * @description Symbol-level centrality (A5): confidence-weighted PageRank over the A4
- *              resolved chunk→chunk symbol graph. A definition referenced (called / extended /
- *              used as a type) by many *other central* symbols scores high — it is a hub the
- *              rest of the program leans on.
- *
- *              This is DISTINCT from `computePageRank` in search-core.mjs, which ranks FILES
- *              over the import graph (and drives enrichment selection + get_repo_map file
- *              ordering). A5 is symbol-granular and call/type-aware, not import-aware.
- *
- *              Like the edges themselves, it is computed ONCE at index time and serialized into
- *              the index, so both backends serve byte-identical scores/ranks — parity is free,
- *              and it never touches search ranking. Opt-in: only built when --symbol-graph is on.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-
-/**
- * Per-confidence edge weight. A `name_only` edge is a heuristic name match (no receiver type
- * / no import evidence) and is noisier than a `high` edge, so it contributes half the flow.
- * The A1 `resolved` tier is a *precision* refinement of `high` (a provably-unambiguous binding),
- * so it carries the SAME weight — enabling the precise resolver does not perturb centrality.
- * All deterministic constants — no tuning knob, no config surface.
- */
-const CONFIDENCE_WEIGHT = { resolved: 1.0, high: 1.0, name_only: 0.5 };
-
-const DAMPING = 0.85;
-const MAX_ITERS = 100;          // hard safety net; sparse symbol graphs converge in ~20–40
-const TOLERANCE = 1e-12;        // L1 delta convergence
-const SCORE_DECIMALS = 8;       // round before serialization → identical bytes both backends
-
-/**
- * Confidence-weighted PageRank over the resolved symbol graph.
- *
- * Deterministic: nodes are the sorted set of edge endpoints, multi-edges between the same
- * (from→to) pair sum their confidence weights, iteration walks nodes/adjacency in fixed order,
- * and scores are rounded to a fixed precision. Ranks are a dense ordering by score DESC, then
- * chunk-id ASC (the same tie-break the rest of the engine uses). The result is serialized, so
- * cross-backend parity is by construction — both engines read these exact numbers.
- *
- * @param {Array<{from_chunk_id:string,to_chunk_id:string,kind:string,confidence:string}>} edges
- * @param {object} [opts]
- * @param {number} [opts.damping]
- * @param {number} [opts.maxIters]
- * @param {number} [opts.tolerance]
- * @returns {{ centrality: Record<string,{score:number,rank:number}>, total:number, iters:number }}
- *          `centrality` is keyed by chunk id; `total` is the number of ranked (connected) chunks.
- */
-export function computeSymbolCentrality(edges, {
-    damping = DAMPING, maxIters = MAX_ITERS, tolerance = TOLERANCE,
-} = {}) {
-    // ── Node set = every chunk that appears in ANY edge (the connected sub-graph). Isolated
-    //    chunks are not ranked — "rank N of M connected symbols" stays meaningful. ──────────
-    const nodeSet = new Set();
-    for (const e of (edges || [])) { nodeSet.add(e.from_chunk_id); nodeSet.add(e.to_chunk_id); }
-    const nodes = [...nodeSet].sort();
-    const N = nodes.length;
-    if (N === 0) return { centrality: {}, total: 0, iters: 0 };
-
-    const index = new Map();
-    nodes.forEach((id, i) => index.set(id, i));
-
-    // ── Aggregate edge weights by (from → to), summing confidence weights for multi-edges
-    //    (a chunk that both calls AND extends a target flows more) → adjacency sorted by `to`
-    //    index for deterministic float accumulation. ────────────────────────────────────────
-    const outMaps = nodes.map(() => new Map());     // i → Map(j → summed weight)
-    for (const e of (edges || [])) {
-        const i = index.get(e.from_chunk_id);
-        const j = index.get(e.to_chunk_id);
-        const w = CONFIDENCE_WEIGHT[e.confidence] ?? CONFIDENCE_WEIGHT.name_only;
-        outMaps[i].set(j, (outMaps[i].get(j) || 0) + w);
-    }
-    const adj = new Array(N);                        // i → [[j, weight], …] sorted by j
-    const outWeight = new Float64Array(N);
-    for (let i = 0; i < N; i++) {
-        const arr = [...outMaps[i].entries()].sort((a, b) => a[0] - b[0]);
-        let tot = 0;
-        for (const [, w] of arr) tot += w;
-        adj[i] = arr;
-        outWeight[i] = tot;
-    }
-
-    // ── Power iteration. Dangling nodes (no out-edges) redistribute their mass uniformly so
-    //    the rank vector stays a probability distribution. ────────────────────────────────────
-    let rank = new Float64Array(N).fill(1 / N);
-    const teleport = (1 - damping) / N;
-    let iters = 0;
-    for (; iters < maxIters; iters++) {
-        let dangling = 0;
-        for (let i = 0; i < N; i++) if (outWeight[i] === 0) dangling += rank[i];
-        const danglingShare = damping * dangling / N;
-
-        const next = new Float64Array(N);
-        for (let i = 0; i < N; i++) next[i] = teleport + danglingShare;
-        for (let i = 0; i < N; i++) {
-            if (outWeight[i] === 0) continue;
-            const share = damping * rank[i] / outWeight[i];
-            for (const [j, w] of adj[i]) next[j] += share * w;
-        }
-
-        let delta = 0;
-        for (let i = 0; i < N; i++) delta += Math.abs(next[i] - rank[i]);
-        rank = next;
-        if (delta < tolerance) { iters++; break; }
-    }
-
-    // ── Round, then assign dense ranks by score DESC / id ASC. ───────────────────────────────
-    const round = 10 ** SCORE_DECIMALS;
-    const scored = nodes.map((id, i) => ({ id, score: Math.round(rank[i] * round) / round }));
-    scored.sort((a, b) => (b.score - a.score) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-
-    const centrality = {};
-    scored.forEach((s, i) => { centrality[s.id] = { score: s.score, rank: i + 1 }; });
-    return { centrality, total: N, iters };
-}

package/mcp/format.mjs

@@ -1,61 +0,0 @@
-/**
- * @file mcp/format.mjs
- * @description MCP rendering helpers: signature extraction, body pruning.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-
-// ─── Rendering helpers ──────────────────────────────────────────────────────────
-
-export function extractSignatureLine(codeSnippet) {
-    if (!codeSnippet) return '';
-    const lines = codeSnippet.split('\n');
-    const sigLines = [];
-    for (let i = 0; i < Math.min(lines.length, 10); i++) {
-        sigLines.push(lines[i]);
-        const l = lines[i];
-        if (i > 0 && (l.trimEnd().endsWith('{') || l.includes('=>') || l.trimEnd().endsWith(':'))) break;
-    }
-    return sigLines.join('\n');
-}
-
-/**
- * When no lexical token matches (e.g. the agent used a high-level description
- * like "authentication bottleneck" that isn't in the code verbatim), fall back
- * to preserving structural skeleton — control-flow lines and calls — rather than
- * blindly truncating, so the caller still gets meaningful context.
- */
-export function pruneBodyByQuery(codeSnippet, queryTokens, maxLines = 40) {
-    if (!codeSnippet) return '';
-    const lines = codeSnippet.split('\n');
-    if (lines.length <= maxLines) return codeSnippet;
-
-    const querySet = new Set(queryTokens.filter(t => t.length >= 3).map(t => t.toLowerCase()));
-    if (querySet.size === 0) return lines.slice(0, maxLines).join('\n') + '\n// …';
-
-    const SIG_LINES = Math.min(5, lines.length);
-    const TAIL_LINES = Math.min(3, lines.length);
-    const sigBlock = lines.slice(0, SIG_LINES);
-    const tailBlock = lines.slice(Math.max(lines.length - TAIL_LINES, SIG_LINES));
-
-    const bodyLines = lines.slice(SIG_LINES, lines.length - TAIL_LINES);
-    const relevant = bodyLines.filter(line => {
-        const ll = line.toLowerCase();
-        if (/^\s*(return|throw|raise|yield)\b/.test(ll)) return true;
-        return [...querySet].some(token => ll.includes(token));
-    });
-
-    if (relevant.length === 0) {
-        const budget = Math.max(4, maxLines - SIG_LINES - TAIL_LINES);
-        const structural = bodyLines.filter(line => {
-            const ll = line.trimStart().toLowerCase();
-            if (/^(if |else |for |while |switch |try |catch |finally |return |throw |raise |yield |await )/.test(ll)) return true;
-            if (/[a-zA-Z_]\w*\s*\(/.test(line) && line.trim().length > 4) return true;
-            return false;
-        }).slice(0, budget);
-        if (structural.length > 0) return [...sigBlock, ...structural, ...tailBlock].join('\n');
-        return lines.slice(0, maxLines).join('\n') + '\n// …';
-    }
-    return [...sigBlock, ...relevant, ...tailBlock].join('\n');
-}

package/mcp/resolver.mjs

@@ -1,116 +0,0 @@
-/**
- * @file mcp/resolver.mjs
- * @description Resolver providers (A1): pluggable confidence assignment for the A4 symbol
- *              graph. The DEFAULT `heuristic` provider preserves today's two-tier confidence
- *              ({ high, name_only }) exactly. The opt-in `precise` provider lifts the subset of
- *              edges whose binding is provably UNAMBIGUOUS into a third, stronger tier,
- *              `resolved` — a reference is `resolved` when there is no question *which*
- *              definition it binds to:
- *                • the symbol has a single definition in the repo (no same-named rival), or
- *                • the receiver's TYPE matches the defining class (typed receiver, the A3
- *                  inter-procedural fixpoint result, `this.m()` inside the class, or an explicit
- *                  target class) — type-resolved, so immune to name shadowing.
- *              `high` then means "ambiguous name, disambiguated by import/proximity" and
- *              `name_only` means "ambiguous name, no evidence."
- *
- *              The provider only changes the `confidence` STRING on edges that already exist —
- *              it never adds, drops, or reorders edges — so it is parity-free (confidence is
- *              already serialized) and `findCallers`/`findReferers` set-equivalence is preserved.
- *              It runs at index time inside buildSymbolGraph and is inert without --symbol-graph.
- *
- *              SCOPE (honest): v1 exposes the unambiguous-binding tier the engine can already
- *              prove from index-time signals. Detecting a LOCAL variable that *shadows* an import
- *              (and refuting that edge), and cross-file precise resolution via stack-graphs, are
- *              the documented next layers — both require per-language AST/scope analysis.
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-
-/** Total order on confidence — strongest first. Used by the symbol-graph dedupe. */
-export const CONFIDENCE_RANK = { resolved: 3, high: 2, name_only: 1 };
-
-/** The stronger of two confidence strings (ties → `a`). */
-export function strongerConfidence(a, b) {
-    return (CONFIDENCE_RANK[b] || 0) > (CONFIDENCE_RANK[a] || 0) ? b : a;
-}
-
-/**
- * Default provider: identity. Edge confidence stays exactly { high, name_only } — the index is
- * byte-identical to a pre-A1 build.
- */
-const HEURISTIC = {
-    name: 'heuristic',
-    /** @param {string} base 'high' | 'name_only' @param {boolean} _proven */
-    confidenceFor(base /* , proven */) { return base; },
-};
-
-/**
- * Precise provider: promote a `high` edge to `resolved` when its binding is provably
- * unambiguous (the `proven` flag set by classifyCallers / findReferences). Never touches
- * `name_only` (no evidence stays no evidence) and never downgrades.
- */
-const PRECISE = {
-    name: 'precise',
-    /** @param {string} base @param {boolean} proven */
-    confidenceFor(base, proven) { return base === 'high' && proven ? 'resolved' : base; },
-};
-
-const PROVIDERS = { heuristic: HEURISTIC, precise: PRECISE };
-
-/** Resolve a provider by name; unknown names fall back to the default heuristic. */
-export function getResolver(name) { return PROVIDERS[name] || HEURISTIC; }
-
-/**
- * SCIP provider (A2): a DATA-BACKED resolver built from a cross-file binding relation
- * (`bindings: Map<fromChunkId, Set<defChunkId>>`) and the set of defs SCIP actually saw
- * (`definedChunks`), both produced from a locally-generated SCIP index (see parse/scip.mjs
- * `buildScipBindings`). Unlike heuristic/precise — which only RELABEL a fixed edge set — the SCIP
- * provider can also SUPPRESS edges, because SCIP knows the *exact* binding among several same-named
- * definitions. For a caller `fromId` and the candidate defs `defIds` of one name:
- *
- *   • no SCIP target for `fromId` at all, OR none of `defIds` is a target → return null: the
- *     builder falls through to the heuristic confidence (absence ≠ refutation for this name).
- *   • SCIP confirms `fromId` binds to ≥1 of `defIds` → `resolved` = those confirmed def(s);
- *     `suppressed` = the OTHER candidate defs **that SCIP actually saw as definitions**
- *     (`def ∈ definedChunks`). A candidate def SCIP NEVER recorded — an uncovered file in a
- *     polyglot / partial run, a stale `.scip`, a missed occurrence — is neither resolved nor
- *     suppressed: it falls through to heuristic, so a covered caller referencing an *uncovered* def
- *     is never wrongly dropped. This is the soundness gate the partial-coverage case needs.
- *
- * It refines the heuristic's CANDIDATE edges (promote + suppress); it does not synthesize edges the
- * AST call-extraction missed (a v2 recall concern). The symbol-graph builder applies this to `calls`
- * edges only — the binding relation is kind-agnostic, so `extends`/`type` edges stay heuristic.
- * `confidenceFor` is identity, so any edge SCIP does not cover keeps its base confidence.
- *
- * @param {Map<string, Set<string>>} bindings  fromChunkId → set of def chunk ids SCIP confirms.
- * @param {Set<string>} [definedChunks]  every chunk SCIP recorded as a definition (suppression gate).
- * @returns {{ name:string, confidenceFor:Function, resolveEdges:Function }}
- */
-export function createScipResolver(bindings, definedChunks) {
-    const rel = bindings instanceof Map ? bindings : new Map();
-    const defined = definedChunks instanceof Set ? definedChunks : new Set();
-    return {
-        name: 'scip',
-        /** Uncovered edges keep their base confidence (no promotion without SCIP evidence). */
-        confidenceFor(base /* , proven */) { return base; },
-        /**
-         * @param {{ fromId:string, defIds:string[] }} q
-         * @returns {{ resolved: Set<string>, suppressed: Set<string> } | null}  null → no SCIP info.
-         */
-        resolveEdges({ fromId, defIds }) {
-            const targets = rel.get(fromId);
-            if (!targets || !targets.size) return null;          // caller uncovered → no opinion
-            const resolved = new Set();
-            for (const id of defIds) if (targets.has(id)) resolved.add(id);
-            if (!resolved.size) return null;                     // binds none of THIS name's defs → fall through
-            const suppressed = new Set();
-            for (const id of defIds) {
-                if (resolved.has(id)) continue;
-                if (defined.has(id)) suppressed.add(id);          // SCIP saw this def but bound elsewhere → wrong-target
-                // else: def uncovered by SCIP → keep heuristic (sound under partial coverage)
-            }
-            return { resolved, suppressed };
-        },
-    };
-}

package/mcp/symbolgraph.mjs

@@ -1,137 +0,0 @@
-/**
- * @file mcp/symbolgraph.mjs
- * @description Builds the persistent RESOLVED symbol graph (A4): one edge per resolved
- *              (referencing-chunk → definition-chunk) pair, tagged with `kind`
- *              ('calls' | 'extends' | 'type') and `confidence`. Confidence is `high` | `name_only`
- *              on the default `heuristic` path; the opt-in resolvers add a `resolved` tier — A1
- *              (`precise`) promotes provably-unambiguous edges, A2 (`scip`) confirms a cross-file
- *              binding AND suppresses the wrong-target fan-out a same-name ambiguity would emit.
- *
- *              It REUSES the query-time resolvers (classifyCallers / findReferences) over
- *              every defined symbol, so an edge's confidence is identical to what
- *              get_call_graph / find_references would report — no logic duplication, no
- *              drift. The result is serialized into the index so both backends expose the
- *              same graph through getEdges() (deterministically ordered → parity-free), and
- *              findCallers / findReferers can read it instead of scanning.
- *
- *              Opt-in and index-time only (see config.symbolGraph / indexer.mjs). It does
- *              not touch search ranking. This is the structural foundation for impact_of_edit
- *              (transitive getEdges), symbol-level PageRank (A5), and precise resolution (A1,
- *              which upgrades 'high' → 'resolved').
- * @author MaquinaTech <https://github.com/MaquinaTech>
- * @copyright (c) 2026 MaquinaTech. All rights reserved.
- * @license MIT
- */
-import { classifyCallers, findReferences } from './topology.mjs';
-import { getResolver, strongerConfidence } from './resolver.mjs';
-
-/** Deterministic total order on edges — required for memory↔sqlite parity. */
-export function edgeOrder(a, b) {
-    return (a.from_chunk_id < b.from_chunk_id ? -1 : a.from_chunk_id > b.from_chunk_id ? 1 : 0)
-        || (a.to_chunk_id < b.to_chunk_id ? -1 : a.to_chunk_id > b.to_chunk_id ? 1 : 0)
-        || (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0)
-        || (a.confidence < b.confidence ? -1 : a.confidence > b.confidence ? 1 : 0);
-}
-
-const normConfidence = (c) => (c === 'high' ? 'high' : 'name_only');
-
-/**
- * Build the resolved edge list from a loaded store.
- *
- * @param {object} db  A loaded store (iterateChunks, resolveSymbol, findCallers,
- *                     findReferers, getDependencies — the same contract the resolvers use).
- * @param {object} [opts]
- * @param {number} [opts.maxPerName]  Safety cap on edges emitted for one symbol name
- *                                    (pathological ambiguous names). Excess is logged, not
- *                                    silently dropped.
- * @param {object} [opts.resolver]  A1 resolver provider (default `heuristic` → byte-identical
- *                                  { high, name_only }; `precise` → adds the `resolved` tier).
- * @returns {{ edges: Array<{from_chunk_id:string,to_chunk_id:string,kind:string,confidence:string}>,
- *             cappedNames: string[] }}
- */
-export function buildSymbolGraph(db, { maxPerName = 20000, resolver = getResolver('heuristic') } = {}) {
-    const edges = [];
-    const cappedNames = [];
-
-    const calleeNames = new Set();
-    const refNames = new Set();
-    for (const c of db.iterateChunks()) {
-        for (const n of (c.calls || [])) calleeNames.add(n);
-        for (const t of (c.extends || [])) refNames.add(t);
-        for (const t of (c.type_refs || [])) refNames.add(t);
-    }
-
-    // ── 'calls' edges: every name-match caller → each definition of the callee name,
-    //    bucketed high / name_only exactly as classifyCallers reports. ──────────────
-    for (const name of [...calleeNames].sort()) {
-        const defs = db.resolveSymbol(name);
-        if (!defs.length) continue;            // undefined name → no edge (findCallers falls back to scan)
-        const defIds = defs.map(d => d.id);
-        const { high, nameOnly } = classifyCallers(db, name);
-        let n = 0; let capped = false;
-        const emit = (callers, baseConf) => {
-            for (const { chunk, proven } of callers) {
-                // A2 (calls edges only): a data-backed resolver (scip) may CONFIRM the exact binding
-                // (→ `resolved`) and SUPPRESS the SCIP-known wrong-target siblings. A def SCIP never
-                // saw is neither — it falls through to the heuristic confidence (sound under partial
-                // coverage). No resolveEdges (heuristic/precise) → decision null → byte-identical.
-                const decision = resolver.resolveEdges
-                    ? resolver.resolveEdges({ fromId: chunk.id, defIds })
-                    : null;
-                const fallbackConf = resolver.confidenceFor(baseConf, Boolean(proven));
-                for (const def of defs) {
-                    if (n >= maxPerName) { capped = true; return; }
-                    if (decision && decision.resolved.has(def.id)) {
-                        edges.push({ from_chunk_id: chunk.id, to_chunk_id: def.id, kind: 'calls', confidence: 'resolved' });
-                    } else if (decision && decision.suppressed.has(def.id)) {
-                        continue;                                  // SCIP-confirmed wrong-target → suppress
-                    } else {
-                        edges.push({ from_chunk_id: chunk.id, to_chunk_id: def.id, kind: 'calls', confidence: fallbackConf });
-                    }
-                    n++;
-                }
-            }
-        };
-        emit(high, 'high');
-        if (!capped) emit(nameOnly, 'name_only');
-        if (capped) cappedNames.push(name);
-    }
-
-    // ── 'extends' / 'type' edges: subclasses/implementers and type users → each
-    //    definition, with the per-reference confidence findReferences assigns. ──────
-    for (const name of [...refNames].sort()) {
-        const defs = db.resolveSymbol(name);
-        if (!defs.length) continue;
-        const { inherits, types } = findReferences(db, name);
-        let n = 0; let capped = false;
-        // A2 scopes SCIP resolution to `calls` edges only: the binding relation is kind-agnostic, so
-        // applying it here would let a call-site binding suppress/relabel `extends`/`type` siblings of
-        // a different kind. These edges therefore stay heuristic under every resolver (byte-identical).
-        const emit = (refs, kind) => {
-            for (const r of refs) {
-                const confidence = resolver.confidenceFor(normConfidence(r.confidence), Boolean(r.proven));
-                for (const def of defs) {
-                    if (n >= maxPerName) { capped = true; return; }
-                    edges.push({ from_chunk_id: r.chunk.id, to_chunk_id: def.id, kind, confidence });
-                    n++;
-                }
-            }
-        };
-        emit(inherits, 'extends');
-        if (!capped) emit(types, 'type');
-        if (capped && !cappedNames.includes(name)) cappedNames.push(name);
-    }
-
-    // Dedupe by (from, to, kind) keeping the STRONGEST confidence (resolved > high > name_only),
-    // then return in the deterministic parity order. (On the default `heuristic` path the only
-    // values are high/name_only and high is strongest → identical to the prior keep-first dedupe.)
-    const rep = new Map();
-    for (const e of edges) {
-        const k = `${e.from_chunk_id}|${e.to_chunk_id}|${e.kind}`;
-        const cur = rep.get(k);
-        if (!cur) rep.set(k, { from_chunk_id: e.from_chunk_id, to_chunk_id: e.to_chunk_id, kind: e.kind, confidence: e.confidence });
-        else cur.confidence = strongerConfidence(cur.confidence, e.confidence);
-    }
-    const out = [...rep.values()].sort(edgeOrder);
-    return { edges: out, cappedNames };
-}