ucn 3.8.26 → 4.0.1

package/core/callers.js

@@ -10,8 +10,9 @@ const path = require('path');
 const crypto = require('crypto');
 const { detectLanguage, getParser, getLanguageModule, langTraits } = require('../languages');
 const { isTestFile } = require('./discovery');
-const { NON_CALLABLE_TYPES } = require('./shared');
-const { scoreEdge } = require('./confidence');
+const { NON_CALLABLE_TYPES, isOverrideMarked } = require('./shared');
+const { scoreEdge, tierForResolution, TIER } = require('./confidence');
+const { findGoModule } = require('./imports');
 
 /** Set.some() helper — like Array.some() but for Sets */
 function setSome(set, predicate) {
@@ -148,6 +149,22 @@ function findCallers(index, name, options = {}) {
     const callers = [];
     const stats = options.stats;
 
+    // Conservation accounting (tiered caller contract): when collectAccount
+    // is set (context/about/impact only — trace/blast/verify paths must stay
+    // byte-identical), candidates that the legacy flags would silently drop are
+    // RETAINED as unverified-tier entries (rendered in their own output
+    // section), and candidates positively excluded (call targets a different
+    // symbol) are recorded with a reason for the account arithmetic.
+    const collectAccount = !!options.collectAccount;
+    const accountRaw = collectAccount ? { unverifiedLines: [], excludedEntries: [] } : null;
+    // Cap on how many unverified entries get full enrichment (content + caller
+    // lookup); the rest stay as shadow-style records. Display caps are handled
+    // by formatters — this only bounds file reads.
+    const unverifiedEnrichLimit = options.unverifiedEnrichLimit ?? 10;
+    const recordExcluded = (filePath, line, reason) => {
+        if (accountRaw) accountRaw.excludedEntries.push({ file: filePath, line, reason });
+    };
+
     // Get definition lines to exclude them
     const definitions = index.symbols.get(name) || [];
     const definitionLines = new Set();
@@ -155,10 +172,183 @@ function findCallers(index, name, options = {}) {
         definitionLines.add(`${def.file}:${def.startLine}`);
     }
 
+    // Possible-dispatch tiering inputs (nominal contract surface) — all fixed
+    // per query, computed lazily once. targetTypes mirrors the receiver-class
+    // disambiguation set (target classes + non-overriding subtypes); owner
+    // keys are the distinct types defining a same-name method project-wide.
+    let _dispatchTargetTypes = null;
+    const dispatchTargetTypes = (targetDefs) => {
+        if (!_dispatchTargetTypes) _dispatchTargetTypes = _buildTargetTypeSet(index, targetDefs, definitions);
+        return _dispatchTargetTypes;
+    };
+    let _methodOwnerKeys = null;
+    const methodOwnerKeys = () => {
+        if (!_methodOwnerKeys) {
+            _methodOwnerKeys = new Set();
+            for (const d of definitions) {
+                if (NON_CALLABLE_TYPES.has(d.type)) {
+                    // Function-typed FIELDS are callable owners (fix #219):
+                    // `effect.transform(...)` may be ZodType.transform OR the
+                    // $ZodTransformDef.transform property — single-method-owner
+                    // confirmation is a lie when an interface declares the same
+                    // name as a callable property. Structural only: Java/Rust
+                    // cannot call a field by name (obj.f() is always a method
+                    // there); Go CAN (func fields) but no measured Go board
+                    // carries the family — deferred until measured.
+                    if (d.type === 'field' && d.className && _callableFieldDef(index, d)) {
+                        _methodOwnerKeys.add(d.className);
+                    }
+                    continue;
+                }
+                const o = d.className || (d.receiver && d.receiver.replace(/^\*/, ''));
+                if (o) _methodOwnerKeys.add(o);
+            }
+        }
+        return _methodOwnerKeys;
+    };
+    const _dispatchCountCache = new Map(); // via type -> candidate count
+    const countDispatchCandidates = (via) => {
+        if (!_dispatchCountCache.has(via)) {
+            _dispatchCountCache.set(via, _countDispatchCandidates(index, via, definitions));
+        }
+        return _dispatchCountCache.get(via);
+    };
+    // External-contract target (fix #210, gson-measured): the pinned method
+    // carries an explicit override marker (@Override / TS `override` / typing
+    // @override / Rust `impl Trait for X`) and has a SINGLE project-wide
+    // owner — so the overridden definition is not in the project (a visible
+    // project supertype defining the method would be a second owner). The
+    // method name provably exists on an external contract (java.lang.Number,
+    // std Iterator, ...): any external-typed receiver satisfies the same
+    // call, and unique project ownership stops being identity evidence.
+    // Receiver-evidence-free calls route possible-dispatch instead of
+    // confirming. Lazily computed once per query; null = not external.
+    let _extContract; // undefined → not yet computed
+    const externalContractTarget = () => {
+        if (_extContract !== undefined) return _extContract;
+        _extContract = null;
+        if (methodOwnerKeys().size === 1) {
+            const tDefs = (options.targetDefinitions || definitions).filter(d =>
+                !NON_CALLABLE_TYPES.has(d.type) && (d.className || d.receiver));
+            // `some`, not `every`: one marked overload proves the NAME exists
+            // on an external contract — receiver identity is then unprovable
+            // for every call shape (external signatures are invisible).
+            const marked = tDefs.find(d => isOverrideMarked(d));
+            if (marked) _extContract = { via: _externalContractVia(index, marked) };
+        }
+        return _extContract;
+    };
+
+    // ---- Rename-alias surfaces (import/export renames) ----
+    // Other surface names that can denote this symbol:
+    //   import-side: `import { _gt as gt }` — fileEntry.importAliases, valid
+    //   only inside the renaming file;
+    //   export-side: `export { _enum as enum }` / Rust `pub use a as b` —
+    //   exportDetails entries carrying an alias, valid in files importing the
+    //   renaming module (or in that module itself).
+    // A renaming file must sit on an import path to the target (or define it)
+    // — otherwise it renames an unrelated same-name symbol. Matched call
+    // sites are beyond-text claims: the line does not contain the target name
+    // (account.js classifies them in the beyondText bucket).
+    const aliasTargetFiles = new Set((options.targetDefinitions || definitions)
+        .map(d => d.file).filter(Boolean));
+    const importAliasLocals = new Map(); // filePath -> Set<localName>
+    const exportAliasRenamers = new Map(); // aliasName -> Set<renamingFilePath>
+    for (const [fp, fe] of index.files) {
+        const hasImportRenames = fe.importAliases &&
+            fe.importAliases.some(a => a && a.original === name && a.local && a.local !== name);
+        const exportRenames = fe.exportDetails
+            ? fe.exportDetails.filter(e => e && e.alias && e.name === name && e.alias !== name)
+            : [];
+        if (!hasImportRenames && exportRenames.length === 0) continue;
+        const fpImports = index.importGraph.get(fp);
+        let linksTarget = aliasTargetFiles.has(fp) ||
+            (fpImports && setSome(fpImports, imp => aliasTargetFiles.has(imp)));
+        // One barrel hop: `export { _gt as gt } from './core/index.js'` where
+        // the barrel re-exports the defining file.
+        if (!linksTarget && fpImports) {
+            for (const imp of fpImports) {
+                const trans = index.importGraph.get(imp);
+                if (trans && setSome(trans, ti => aliasTargetFiles.has(ti))) {
+                    linksTarget = true;
+                    break;
+                }
+            }
+        }
+        if (!linksTarget) continue;
+        if (hasImportRenames) {
+            for (const a of fe.importAliases) {
+                if (a && a.original === name && a.local && a.local !== name) {
+                    if (!importAliasLocals.has(fp)) importAliasLocals.set(fp, new Set());
+                    importAliasLocals.get(fp).add(a.local);
+                }
+            }
+        }
+        for (const e of exportRenames) {
+            // If the renaming file defines the name itself, the rename refers
+            // to that local definition (classic/schemas.ts's `export { _enum
+            // as enum }` renames ITS _enum wrapper, not core's _enum) — only
+            // credit it when the pinned target IS that local definition.
+            if (!aliasTargetFiles.has(fp) && definitions.some(d => d.file === fp)) continue;
+            if (!exportAliasRenamers.has(e.alias)) exportAliasRenamers.set(e.alias, new Set());
+            exportAliasRenamers.get(e.alias).add(fp);
+        }
+    }
+    // Files that can reach each renaming module through imports — re-export
+    // chains run deep (test → mini/index → external → schemas), so a fixed
+    // hop count misses real surfaces. Bounded reverse-import BFS; matching
+    // stays name+path specific, and tiering still demands its own evidence.
+    const aliasReachers = new Map(); // aliasName -> Set<filePath> (renamers + transitive importers)
+    for (const [aliasName, renamers] of exportAliasRenamers) {
+        const reach = new Set(renamers);
+        let frontier = [...renamers];
+        for (let depth = 0; depth < 4 && frontier.length && reach.size <= 5000; depth++) {
+            const next = [];
+            for (const f of frontier) {
+                const importers = index.exportGraph.get(f);
+                if (!importers) continue;
+                for (const importer of importers) {
+                    if (!reach.has(importer)) {
+                        reach.add(importer);
+                        next.push(importer);
+                    }
+                }
+            }
+            frontier = next;
+        }
+        aliasReachers.set(aliasName, reach);
+    }
+    const aliasNames = new Set(exportAliasRenamers.keys());
+    for (const locals of importAliasLocals.values()) {
+        for (const local of locals) aliasNames.add(local);
+    }
+    const hasAliasSurfaces = aliasNames.size > 0;
+
     // Phase 1: Find matching calls without reading file content.
     // Collect pending callers keyed by file — content is read only in Phase 2.
     const pendingByFile = new Map(); // filePath -> [{ call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver }]
     let pendingCount = 0;
+    // Route a would-be-dropped candidate into the pending pipeline as an
+    // unverified-tier entry (tiered caller contract: shown in its own
+    // section, never silently hidden). Does NOT count toward pendingCount —
+    // totals describe the confirmed answer.
+    const routeUnverified = (filePath, fileEntry, call, reason, calledAs, meta) => {
+        if (!collectAccount) return; // non-account paths (trace/blast/verify) keep the plain drop
+        if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
+        pendingByFile.get(filePath).push({
+            call, fileEntry, callerSymbol: null,
+            isMethod: call.isMethod || false,
+            isFunctionReference: !!call.isFunctionReference,
+            receiver: call.receiver, receiverType: call.receiverType,
+            calledAs,
+            _tier: TIER.UNVERIFIED, _reason: reason, _meta: meta,
+            // Dispatch-tiered routes carry their own resolution so JSON output
+            // distinguishes "possible virtual dispatch" from a bare uncertain.
+            _evidence: reason === 'possible-dispatch' ? { possibleDispatch: true }
+                : reason === 'method-ambiguous' ? { methodAmbiguous: true }
+                : { isUncertain: true },
+        });
+    };
     const maxResults = options.maxResults;
     // BUG-H1: when consumers (like `about`) need an accurate truncation header
     // ("showing N of <total>"), they pass needsTotal:true so Phase 1 runs to
@@ -166,9 +356,19 @@ function findCallers(index, name, options = {}) {
     // file reads stay bounded, but the candidate count reflects the true total.
     const needsTotal = !!options.needsTotal;
     const localTypeCache = new Map(); // `${filePath}:${startLine}` -> localTypes Map or null
+    const returnFlowCache = new Map(); // filePath -> return-type-flow map (see _buildReturnTypeFlowMap)
 
     // Use inverted callee index to skip files that don't contain calls to this name
-    const calleeFiles = index.getCalleeFiles(name);
+    let calleeFiles = index.getCalleeFiles(name);
+    if (hasAliasSurfaces) {
+        // Alias surfaces are indexed under their own names — union their files in.
+        const union = new Set(calleeFiles || []);
+        for (const aliasName of aliasNames) {
+            const aliasFiles = index.getCalleeFiles(aliasName);
+            if (aliasFiles) for (const f of aliasFiles) union.add(f);
+        }
+        if (union.size > 0) calleeFiles = union;
+    }
     const fileIterator = calleeFiles
         ? [...calleeFiles].map(fp => [fp, index.files.get(fp)]).filter(([, fe]) => fe)
         : index.files;
@@ -180,50 +380,303 @@ function findCallers(index, name, options = {}) {
             const calls = getCachedCalls(index, filePath);
             if (!calls) continue;
 
-            for (const call of calls) {
+            for (let call of calls) {
                 // Skip if not matching our target name (also check alias resolution)
+                let calledAs = null; // surface name when matched via an import/export rename
                 if (call.name !== name && call.resolvedName !== name &&
-                    !(call.resolvedNames && call.resolvedNames.includes(name))) continue;
+                    !(call.resolvedNames && call.resolvedNames.includes(name))) {
+                    if (!hasAliasSurfaces) continue;
+                    const locals = importAliasLocals.get(filePath);
+                    if (locals && locals.has(call.name)) {
+                        calledAs = call.name;
+                    } else {
+                        const reach = aliasReachers.get(call.name);
+                        if (reach && reach.has(filePath)) calledAs = call.name;
+                    }
+                    if (!calledAs) continue;
+                }
+
+                // Return-type flow: an untyped method receiver may be a
+                // variable assigned from a call with a known return annotation
+                // (response = client.get(...) with Client.get() -> Response).
+                // Structural languages get this everywhere (fix #199). Nominal
+                // languages get it on the account surface only (fix #207):
+                // a flow-typed interface receiver must reroute to visible
+                // possible-dispatch on mismatch, and that routing is
+                // collectAccount-gated — legacy commands would silently drop
+                // the edge instead. Real method calls only — the callback/
+                // reference branch keeps its own #206 routing.
+                // Copy-on-enrich: cached call objects stay parser-pure — the flow
+                // type derives from OTHER files' annotations, so it must never be
+                // persisted with this file's calls.
+                if (call.isMethod && call.receiver && !call.receiverType &&
+                    (langTraits(fileEntry.language)?.typeSystem === 'structural' ||
+                        (collectAccount && !call.isPotentialCallback && !call.isPathCall &&
+                            langTraits(fileEntry.language)?.typeSystem === 'nominal'))) {
+                    let flowMap = returnFlowCache.get(filePath);
+                    if (flowMap === undefined) {
+                        flowMap = _buildReturnTypeFlowMap(index, filePath, calls);
+                        returnFlowCache.set(filePath, flowMap);
+                    }
+                    const flowEntry = flowMap && _lookupReturnTypeFlow(flowMap, call);
+                    if (flowEntry && flowEntry.externalVia) {
+                        // External producer (fix #220) — typed outside the
+                        // project; blocks single-owner confirmation, routes
+                        // possible-dispatch in the gate. Nominal-only entries.
+                        call = { ...call, receiverExternalFlow: flowEntry.externalVia };
+                    } else if (flowEntry) {
+                        call = { ...call, receiverType: flowEntry.type,
+                            ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
+                    }
+                }
+
+                // Chained-receiver typing (fix #219): the receiver IS a call —
+                // `me._def.args.parseAsync(args, params).catch(...)` — so the
+                // producer's DECLARED return annotation types it (Promise →
+                // builtin → exclusion-grade under the trust gate; the target's
+                // own class validates; anything else attributes dispatch).
+                // Method producers must AGREE project-wide (the #207
+                // discipline); plain producers follow #199's unique-def rule.
+                // Structural only: nominal parsers don't capture receiverCall —
+                // their chained calls stay under the #204 dispatch tiering
+                // (visible, honest) until a measured family justifies the
+                // #207 origin-pinning rails there.
+                if (call.isMethod && !call.receiver && !call.receiverType && call.receiverCall &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural') {
+                    const chainedType = _chainedReceiverType(index, call, fileEntry.language);
+                    if (chainedType) call = { ...call, receiverType: chainedType };
+                } else if (call.isMethod && !call.receiver && !call.receiverType && call.receiverCall &&
+                    collectAccount && !call.isPotentialCallback &&
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal') {
+                    // Nominal chained receivers (fix #220, cobra-measured):
+                    // account-gated like the #207 nominal flow — mismatch
+                    // reroutes are account-only; legacy would silently drop.
+                    const flowEntry = _nominalChainedReceiverType(index, call, fileEntry, filePath);
+                    if (flowEntry && flowEntry.externalVia) {
+                        call = { ...call, receiverExternalFlow: flowEntry.externalVia };
+                    } else if (flowEntry) {
+                        call = { ...call, receiverType: flowEntry.type,
+                            ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
+                    }
+                }
 
                 // For potential callbacks (function passed as arg), validate against symbol table
                 // and skip complex binding resolution — just check the name exists
                 if (call.isPotentialCallback) {
+                    // Go closure-entry marker: a composite-field func literal
+                    // records the ENCLOSING function's name at the closure line
+                    // (deadcode reachability for RunE-style closures) — it is a
+                    // self-line artifact, never a caller edge.
+                    if (!call.isFunctionReference && !call.isMethod && call.fieldName &&
+                        call.enclosingFunction && call.enclosingFunction.name === call.name) {
+                        continue;
+                    }
                     const syms = definitions;
                     if (!syms || syms.length === 0) continue;
+                    const cbTargetDefs = options.targetDefinitions || definitions;
 
                     // Go unexported visibility: lowercase functions are package-private.
-                    // Only allow callers from the same package directory.
+                    // Only allow callers from the same package directory. Recorded
+                    // with reason (not a silent drop) — same disposition as the
+                    // plain-call visibility gate below.
                     if (langTraits(fileEntry.language)?.exportVisibility === 'capitalization' && /^[a-z]/.test(name)) {
-                        const targetDefs = options.targetDefinitions || definitions;
                         const targetPkgDirs = new Set(
-                            targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
+                            cbTargetDefs.filter(d => d.file).map(d => path.dirname(d.file))
                         );
                         if (targetPkgDirs.size > 0 && !targetPkgDirs.has(path.dirname(filePath))) {
+                            recordExcluded(filePath, call.line, 'out-of-scope-package');
                             continue;
                         }
                     }
 
-                    // Nominal type receiver disambiguation for callbacks (e.g. dc.worker)
+                    // Package-qualified reference (Go): `pkg.Name` passed as a
+                    // value denotes a symbol IN package pkg — never the current
+                    // package (Go cannot self-import), never an unrelated
+                    // same-name target. grpc-go-measured: `balancer.Get(priority.Name)`
+                    // references the CONST priority.Name, not a pinned method
+                    // `Name` — the target's own same-file/same-package evidence
+                    // says nothing about what a qualified name resolves to.
                     if (call.isMethod && call.receiver &&
+                        langTraits(fileEntry.language)?.hasReceiverPackageCalls) {
+                        const cbPkgRes = _receiverPackageResolution(index, fileEntry, call.receiver, cbTargetDefs);
+                        if (cbPkgRes) {
+                            if (cbPkgRes.singleSegment) {
+                                // Single-segment import — Go stdlib, always external
+                                recordExcluded(filePath, call.line, 'external-package');
+                                continue;
+                            }
+                            if (!cbPkgRes.targetInPkg) {
+                                recordExcluded(filePath, call.line, 'other-definition');
+                                continue;
+                            }
+                        }
+                    }
+
+                    // A bare identifier can never denote a METHOD where bare
+                    // names don't reach methods (fix #220, grpc-go-measured:
+                    // `balancer.Get(Name)` references each package's const
+                    // Name, never the pinned method Name() — Go method values
+                    // require receivers, Rust `use` cannot import associated
+                    // functions). Java exempt (static imports). Compiler-grade
+                    // kind evidence — excluded with reason, all surfaces.
+                    if (!call.isMethod && !call.receiver &&
+                        langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                        !langTraits(fileEntry.language)?.bareCallReachesMethods) {
+                        const allMethodTargets = cbTargetDefs.length > 0 && cbTargetDefs.every(d =>
+                            !NON_CALLABLE_TYPES.has(d.type) && (d.className || d.receiver));
+                        if (allMethodTargets) {
+                            recordExcluded(filePath, call.line, 'method-kind-mismatch');
+                            continue;
+                        }
+                    }
+
+                    // A paren-less member access is ALWAYS a field in Rust —
+                    // method values are path-only (Type::method), so
+                    // `self.paths.has_implicit_path` provably denotes the bool
+                    // FIELD, never the method (fix #220, ripgrep-measured).
+                    if (call.isMethod && call.isFunctionReference &&
+                        langTraits(fileEntry.language)?.memberAccessNeverMethod) {
+                        const allMethodTargets = cbTargetDefs.length > 0 && cbTargetDefs.every(d =>
+                            !NON_CALLABLE_TYPES.has(d.type) && (d.className || d.receiver));
+                        if (allMethodTargets) {
+                            recordExcluded(filePath, call.line, 'method-kind-mismatch');
+                            continue;
+                        }
+                    }
+
+                    // Nominal type receiver disambiguation for callbacks (e.g. dc.worker)
+                    if (call.isMethod &&
                         langTraits(fileEntry.language)?.typeSystem === 'nominal') {
-                        const targetDefs = options.targetDefinitions || definitions;
                         const targetTypes = new Set();
-                        for (const td of targetDefs) {
+                        for (const td of cbTargetDefs) {
                             if (td.className) targetTypes.add(td.className);
                             if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
                         }
-                        if (targetTypes.size > 0 && call.receiverType) {
-                            if (!targetTypes.has(call.receiverType)) continue;
+                        if (targetTypes.size > 0 && call.receiver && call.receiverType &&
+                            !targetTypes.has(call.receiverType)) {
+                            // Raw-set mismatch — check the CLOSED set (aliases +
+                            // non-overriding subtypes incl. Go embedding) before
+                            // disposing: a reference through a promoting outer
+                            // type or a type alias IS the target's method.
+                            if (!dispatchTargetTypes(cbTargetDefs).has(call.receiverType)) {
+                                // A method VALUE binds at the receiver's static
+                                // type: a typed receiver that is neither the
+                                // target type nor below it denotes ANOTHER
+                                // type's method — excluded with reason, unless
+                                // the type can virtually dispatch into the
+                                // target (interface receiver), which routes
+                                // visible possible-dispatch. Was a silent drop:
+                                // the ground line surfaced as call-not-resolved
+                                // (grpc-go/cursive-measured).
+                                if (collectAccount) {
+                                    if (_dispatchCapableSupertype(index, fileEntry.language, call.receiverType, cbTargetDefs, definitions)) {
+                                        routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                            dispatchVia: call.receiverType,
+                                            dispatchCandidates: countDispatchCandidates(call.receiverType),
+                                        });
+                                    } else {
+                                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                        // Under the account contract, a qualified reference
+                        // whose receiver is neither an imported package
+                        // (resolved above), the target type itself
+                        // (type-qualified method reference), nor a validated
+                        // type is a name match through an UNKNOWN owner — that
+                        // includes receivers the parser could not capture at
+                        // all (indexed/chained selectors: `xs[0].Name`).
+                        // Mirrors the #204 method-call gate: a unique
+                        // project-wide owner still confirms; multiple owners
+                        // route to visible 'method-ambiguous' — never confirmed
+                        // via the target's bare-identifier scope evidence below.
+                        // A pinned TYPE target additionally routes regardless
+                        // of owner count: `m.ResourceType` is a member access
+                        // on a value — it cannot denote the type itself (only
+                        // a package-qualified name can, and that resolved
+                        // above; an alias-imported package receiver stays
+                        // visible here rather than excluded).
+                        if (collectAccount) {
+                            const cbTypes = dispatchTargetTypes(cbTargetDefs);
+                            const cbTypeQualified = call.receiver && cbTypes.has(call.receiver);
+                            const cbTypedMatch = call.receiverType && cbTypes.has(call.receiverType);
+                            const cbAllTypeTargets = cbTargetDefs.length > 0 &&
+                                cbTargetDefs.every(d => IDENTITY_TYPE_KINDS.has(d.type));
+                            if (!cbTypeQualified && !cbTypedMatch &&
+                                (methodOwnerKeys().size > 1 || cbAllTypeTargets)) {
+                                routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs,
+                                    { dispatchCandidates: methodOwnerKeys().size });
+                                continue;
+                            }
+                        }
+                    }
+
+                    // Resolution evidence for a bare-identifier function reference:
+                    // the name reaches the target via module scope (same file),
+                    // same-package scope (nominal languages), or an import edge
+                    // (direct or one barrel hop). Argument position alone is a name
+                    // match, not evidence — a local variable or an unrelated
+                    // same-name symbol shadows it invisibly.
+                    const cbTargetFiles = new Set(cbTargetDefs.map(d => d.file).filter(Boolean));
+                    const cbSameFile = cbTargetFiles.has(filePath);
+                    const cbSamePackage = !cbSameFile &&
+                        langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                        cbTargetDefs.some(d => d.file && path.dirname(d.file) === path.dirname(filePath));
+                    let cbImportLink = false;
+                    if (!cbSameFile && !cbSamePackage) {
+                        const cbImports = index.importGraph.get(filePath);
+                        cbImportLink = !!(cbImports && setSome(cbImports, imp => cbTargetFiles.has(imp)));
+                        if (!cbImportLink && cbImports) {
+                            for (const imp of cbImports) {
+                                const trans = index.importGraph.get(imp);
+                                if (trans && setSome(trans, ti => cbTargetFiles.has(ti))) {
+                                    cbImportLink = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!cbImportLink) {
+                            // Positive mis-link evidence: the name resolves to a
+                            // same-name definition in this file (or one this file
+                            // imports) that is NOT the target — same disposition
+                            // as the import-graph disambiguation for plain calls.
+                            const cbOtherDefFiles = new Set(definitions
+                                .map(d => d.file).filter(f => f && !cbTargetFiles.has(f)));
+                            if (cbOtherDefFiles.has(filePath) ||
+                                (cbImports && setSome(cbImports, imp => cbOtherDefFiles.has(imp)))) {
+                                recordExcluded(filePath, call.line, 'other-definition-import');
+                                continue;
+                            }
                         }
                     }
 
                     // Find the enclosing function
                     const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
+                    // A parameter of the enclosing function with the same name
+                    // shadows the target: `disposeEffect(effect)` inside
+                    // `function disposeEffect(effect)` references the parameter,
+                    // not a same-name module-scope symbol. Same for let/const
+                    // locals and inner-arrow params (fix #203 — parser-side
+                    // lexical scope walk sets call.localShadow; JS block-accurate,
+                    // Python function-wide assignment semantics).
+                    if (call.localShadow ||
+                        (callerSymbol && Array.isArray(callerSymbol.paramsStructured) &&
+                            callerSymbol.paramsStructured.some(p => p && p.name === call.name))) {
+                        recordExcluded(filePath, call.line, 'local-shadow');
+                        continue;
+                    }
                     if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
                     pendingByFile.get(filePath).push({
                         call, fileEntry, callerSymbol,
                         isMethod: false, isFunctionReference: true, receiver: undefined,
-                        _evidence: { isFunctionReference: true }
+                        calledAs,
+                        _evidence: {
+                            isFunctionReference: true,
+                            hasImportEvidence: cbSameFile || cbImportLink,
+                            hasSamePackageEvidence: cbSamePackage,
+                        }
                     });
                     pendingCount++;
                     continue;
@@ -232,6 +685,18 @@ function findCallers(index, name, options = {}) {
                 // Resolve binding within this file (without mutating cached call objects)
                 let bindingId = call.bindingId;
                 let isUncertain = call.uncertain;
+                // Parser-detected lexical shadow (fix #203, hoisted by #222 —
+                // express-measured): a local let/var/param of the same name
+                // shadows the target at this reference, whatever record shape
+                // carried it. The callback fast path already excluded its own;
+                // an isFunctionReference-only argument ref (`router.use(path,
+                // f)` inside `use(fn)`'s forEach closure) used to slip past to
+                // binding resolution and exact-confirm on the shadowed name.
+                if (call.localShadow && !call.isPotentialCallback) {
+                    recordExcluded(filePath, call.line, 'local-shadow');
+                    continue;
+                }
+
                 // Skip binding resolution for calls with non-self/this/cls receivers:
                 // e.g., analyzer.analyze_instrument() should NOT resolve to a local
                 // standalone function def `analyze_instrument` — they're different symbols.
@@ -240,6 +705,27 @@ function findCallers(index, name, options = {}) {
                 const skipLocalBinding = call.receiver && !selfReceivers.has(call.receiver);
                 if (!bindingId && !skipLocalBinding) {
                     let bindings = (fileEntry.bindings || []).filter(b => b.name === call.name);
+                    // A bare call cannot bind to a METHOD def where bare names
+                    // never reach methods (fix #220, cobra-measured): Go's
+                    // func (c *Command) MarkFlagDirname and func MarkFlagDirname
+                    // coexist in one package — the bare call denotes the
+                    // FUNCTION. Java keeps both (implicit this-calls). Fix
+                    // #222 (rich-measured) extends this to structural: the
+                    // bindings table lists class members, but Python bare-name
+                    // lookup never enters class scope (`cell_len(self.plain)`
+                    // inside Text binds the module-level import of
+                    // cells.cell_len, not Text.cell_len) and a JS class
+                    // member is not a file binding either — the structural
+                    // dispatch gates can't own this case because a matched
+                    // bindingId bypasses them.
+                    if (!call.isMethod && bindings.length > 0 &&
+                        !langTraits(fileEntry.language)?.bareCallReachesMethods) {
+                        const defsOfName = index.symbols.get(call.name) || [];
+                        bindings = bindings.filter(b => {
+                            const sym = defsOfName.find(s => s.file === filePath && s.startLine === b.startLine);
+                            return !(sym && (sym.className || sym.receiver));
+                        });
+                    }
                     // For Go, also check sibling files in same directory (same package scope)
                     if (bindings.length === 0 && langTraits(fileEntry.language)?.packageScope === 'directory') {
                         const dir = path.dirname(filePath);
@@ -256,6 +742,15 @@ function findCallers(index, name, options = {}) {
                     }
                     if (bindings.length === 1) {
                         bindingId = bindings[0].id;
+                    } else if (bindings.length > 1 && !call.isMethod &&
+                        call.isConstructor &&
+                        bindings.filter(b => b.type === 'class' || b.type === 'function').length === 1) {
+                        // Constructor calls bind to constructable symbols: `new ZodArray()`
+                        // must resolve to the class binding, not a same-name field/const
+                        // elsewhere in the file (TS declaration merging, bottom-of-file
+                        // namespace aliases). All `new`-style languages mark these
+                        // (JS/TS `new`, Java `new`, Go/Rust composite/struct literals).
+                        bindingId = bindings.find(b => b.type === 'class' || b.type === 'function').id;
                     } else if (bindings.length > 1 && !call.isMethod) {
                         // For implicit same-class calls (Java: execute() means this.execute()),
                         // try to resolve via caller's className before marking uncertain
@@ -325,19 +820,64 @@ function findCallers(index, name, options = {}) {
                 // self/this.method() calls can be resolved by same-class matching
                 // even when binding is ambiguous (e.g. method exists in multiple classes)
                 let resolvedBySameClass = false;
+                // Receiver/path type known to mismatch the target: such an edge can
+                // never tier as confirmed even when legacy includeUncertain keeps it
+                // visible (scoreEdge checks hasReceiverType before isUncertain, so
+                // without this flag a known mismatch would score receiver-hint 0.80).
+                let typeMismatch = false;
+                // Structural languages: receiver-hint requires a VALIDATED match
+                // (receiverType ∈ target class + subtypes). Ancestor-kept and
+                // trust-gate-passed types fall back to import/scope evidence —
+                // an unvalidated annotation must not upgrade the tier.
+                let receiverTypeValidated = false;
+                // Nominal local-inference match (receiver typed via
+                // _buildTypedLocalTypeMap ∈ target types) — receiver evidence
+                // for the dispatch tiering below.
+                let nominalInferredMatch = false;
+                // Identity discipline (fix #206): the receiver's type NAME
+                // matches the target's type, but several distinct types share
+                // that name and none is resolvable from this file's scope —
+                // not confirmation evidence, not exclusion evidence. Routed
+                // method-ambiguous under the account contract.
+                let receiverTypeUnresolved = false;
                 if (call.isMethod) {
                     if (call.selfAttribute && fileEntry.language === 'python') {
                         // self.attr.method() — resolve via attribute type inference
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
                         if (!callerSymbol?.className) {
                             // Can't resolve — include only if includeMethods requested
-                            if (!options.includeMethods) continue;
+                            if (!options.includeMethods) {
+                                routeUnverified(filePath, fileEntry, call, 'method-no-evidence', calledAs);
+                                continue;
+                            }
                         } else {
                             const attrTypes = getInstanceAttributeTypes(index, filePath, callerSymbol.className);
                             const targetClass = attrTypes?.get(call.selfAttribute);
                             if (targetClass && definitions.some(d => d.className === targetClass)) {
+                                // fix #202b: the resolved class must be the
+                                // TARGET's class (or an ancestor — dynamic
+                                // dispatch). self.attr.m() resolving to class X
+                                // is not a caller of a pinned target Y.m.
+                                const tDefs = options.targetDefinitions || definitions;
+                                const targetClasses = new Set(tDefs.map(d => d.className).filter(Boolean));
+                                if (!targetClasses.has(targetClass) &&
+                                    !_isAncestorOfTargetClass(index, targetClass, tDefs)) {
+                                    recordExcluded(filePath, call.line, 'other-definition');
+                                    continue;
+                                }
+                                // fix #218: attribute typed as a STRICT ancestor
+                                // of the pinned target's class — reaching the
+                                // subclass override is dynamic dispatch (#204
+                                // physics). Demote-only, account-gated.
+                                if (collectAccount && !targetClasses.has(targetClass)) {
+                                    routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                        dispatchVia: targetClass,
+                                    });
+                                    continue;
+                                }
                                 resolvedBySameClass = true;
                             } else if (!options.includeMethods) {
+                                routeUnverified(filePath, fileEntry, call, 'method-no-evidence', calledAs);
                                 continue;
                             }
                         }
@@ -345,24 +885,27 @@ function findCallers(index, name, options = {}) {
                         // self/this/super.method() — resolve to same-class or parent method
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
                         if (!callerSymbol?.className) {
-                            if (!options.includeMethods) continue;
+                            if (!options.includeMethods) {
+                                routeUnverified(filePath, fileEntry, call, 'method-no-evidence', calledAs);
+                                continue;
+                            }
                         } else {
                             // For super(), skip same-class — only check parent chain
-                            let matchesDef = call.receiver === 'super'
-                                ? false
-                                : definitions.some(d => d.className === callerSymbol.className);
+                            let matchedClass = call.receiver !== 'super' &&
+                                definitions.some(d => d.className === callerSymbol.className)
+                                ? callerSymbol.className : null;
                             // Walk inheritance chain using BFS if not found in same class
-                            if (!matchesDef) {
+                            if (!matchedClass) {
                                 const visited = new Set([callerSymbol.className]);
                                 const callerFile = callerSymbol.file || filePath;
                                 const startParents = index._getInheritanceParents(callerSymbol.className, callerFile) || [];
                                 const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
-                                while (queue.length > 0 && !matchesDef) {
+                                while (queue.length > 0 && !matchedClass) {
                                     const { name: current, contextFile } = queue.shift();
                                     if (visited.has(current)) continue;
                                     visited.add(current);
-                                    matchesDef = definitions.some(d => d.className === current);
-                                    if (!matchesDef) {
+                                    if (definitions.some(d => d.className === current)) matchedClass = current;
+                                    if (!matchedClass) {
                                         const resolvedFile = index._resolveClassFile(current, contextFile);
                                         const grandparents = index._getInheritanceParents(current, resolvedFile) || [];
                                         for (const gp of grandparents) {
@@ -371,9 +914,75 @@ function findCallers(index, name, options = {}) {
                                     }
                                 }
                             }
-                            if (matchesDef) {
+                            if (matchedClass) {
+                                // fix #202b: same-class resolution must land on the
+                                // TARGET's class (or an ancestor — dynamic dispatch
+                                // may run the target override). self.path() inside
+                                // StandardImpl resolves to StandardImpl::path — not
+                                // a caller of a pinned target Haystack::path.
+                                // NOMINAL languages + Python: the exclusion is sound
+                                // only when the inheritance graph is complete; TS
+                                // hierarchies hide edges UCN can't see (zod's
+                                // `declare class` merging — measured: the structural
+                                // guard excluded true callers). Python's recorded
+                                // bases are reliable, but MRO adds a trap nominal
+                                // languages lack: `self.method()` inside Mixin can
+                                // dispatch to a CO-PARENT's method through a common
+                                // subclass (class C(Target, Mixin) — C's MRO finds
+                                // Target.method before Mixin's). Exclusion therefore
+                                // also requires that the matched class and the
+                                // target's class share no project descendant.
+                                const sameClassTraits = langTraits(fileEntry.language);
+                                if (sameClassTraits?.typeSystem === 'nominal' ||
+                                    fileEntry.language === 'python') {
+                                    const tDefs = options.targetDefinitions || definitions;
+                                    const targetClasses = new Set(tDefs.map(d => d.className).filter(Boolean));
+                                    if (!targetClasses.has(matchedClass) &&
+                                        !_isAncestorOfTargetClass(index, matchedClass, tDefs) &&
+                                        !(fileEntry.language === 'python' &&
+                                            _shareProjectDescendant(index, matchedClass, targetClasses))) {
+                                        recordExcluded(filePath, call.line, 'other-definition');
+                                        continue;
+                                    }
+                                    // fix #218 (rich-measured): the match landed on
+                                    // a STRICT ancestor of the pinned target's class
+                                    // (or a Python co-parent via shared descendant) —
+                                    // `self.render()` inside abstract ProgressColumn
+                                    // lexically binds the ancestor's def; reaching the
+                                    // pinned SUBCLASS override is dynamic dispatch,
+                                    // possible but not confirmable (#204 physics).
+                                    // Demote-only, account-gated; when the pinned
+                                    // target IS the declaring class, matchedClass ∈
+                                    // targetClasses and confirmation stands.
+                                    if (collectAccount && !targetClasses.has(matchedClass)) {
+                                        routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                            dispatchVia: matchedClass,
+                                        });
+                                        continue;
+                                    }
+                                } else if (collectAccount) {
+                                    // fix #213 (JS/TS, zod seed-B-measured): the same
+                                    // pinning check, but ROUTED visible instead of
+                                    // excluded — `this.min()` inside ZodString lexically
+                                    // binds ZodString.min or a subclass override, never
+                                    // a pinned sibling ZodNumber.min (cross-sibling
+                                    // spray was ~23 of 38 FP edges). Exclusion stays
+                                    // off: TS `declare class` merging hides extends
+                                    // edges, so an unrelated-looking class may still be
+                                    // an ancestor (the original #202b structural revert).
+                                    // Legacy keeps confirming (drop-vs-route asymmetry).
+                                    const tDefs = options.targetDefinitions || definitions;
+                                    const targetClasses = new Set(tDefs.map(d => d.className).filter(Boolean));
+                                    if (!targetClasses.has(matchedClass) &&
+                                        !_isAncestorOfTargetClass(index, matchedClass, tDefs) &&
+                                        !_shareProjectDescendant(index, matchedClass, targetClasses)) {
+                                        routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs);
+                                        continue;
+                                    }
+                                }
                                 resolvedBySameClass = true;
                             } else if (!options.includeMethods) {
+                                routeUnverified(filePath, fileEntry, call, 'method-no-evidence', calledAs);
                                 continue;
                             }
                         }
@@ -381,14 +990,58 @@ function findCallers(index, name, options = {}) {
                         // Go doesn't use this/self/cls - always include Go method calls
                         // Java method calls are always obj.method() - include by default
                         // Rust Type::method() calls - include by default (associated functions)
-                        // For other languages, skip method calls unless explicitly requested
-                        if (langTraits(fileEntry.language)?.methodCallInclusion === 'explicit' && !options.includeMethods) continue;
+                        // For other languages, skip method calls unless explicitly requested.
+                        // Under collectAccount the gate falls through instead: receiver
+                        // evidence computed at the push site decides the tier (a require'd
+                        // module receiver earns scope-match/confirmed; an unknown receiver
+                        // is marked uncertain in the binding block and routes below).
+                        if (langTraits(fileEntry.language)?.methodCallInclusion === 'explicit' && !options.includeMethods) {
+                            if (!collectAccount) continue;
+                        }
                     }
                 }
 
+                // Declared-field receiver typing (fix #202, extended to
+                // structural by fix #219): one-hop field receivers
+                // (self.dent.path() / h.inner.Run() / this._map.has()) resolve
+                // through the field's DECLARED type. Computed before binding
+                // checks — name-bindings don't model receivers, so a same-file
+                // `path` binding must not claim a call whose receiver field is
+                // typed elsewhere. JS/TS `this`-rooted hops resolve their root
+                // type here (the enclosing class — the parser's walk does not
+                // track class context; arrows keep lexical `this`, and nested
+                // function declarations are their own symbols WITHOUT
+                // className, so dynamic-this shapes resolve to nothing).
+                let fieldHopType = null;
+                let fieldHopRootType = call.receiverRootType;
+                if (!fieldHopRootType && call.receiverField && call.receiverRoot === 'this' &&
+                    !resolvedBySameClass &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural') {
+                    const hopEnclosing = index.findEnclosingFunction(filePath, call.line, true);
+                    if (hopEnclosing?.className) fieldHopRootType = hopEnclosing.className;
+                }
+                if (call.isMethod && !call.receiverType && call.receiverField && fieldHopRootType &&
+                    !resolvedBySameClass) {
+                    fieldHopType = _declaredFieldType(index, fieldHopRootType, call.receiverField, fileEntry.language);
+                }
+                // Dispatch attribution (contract surface only): a field DECLARED
+                // as a project interface/trait carries no exclusion evidence
+                // (_declaredFieldType returns null — any implementor may receive
+                // the call), but it IS positive evidence of possible dispatch.
+                // Resolved separately so the unverified tier can attribute the
+                // edge: "possible-dispatch via <Interface> — 1 of N impls".
+                let fieldDispatchType = null;
+                if (collectAccount && fieldHopType === null &&
+                    call.isMethod && !call.receiverType && call.receiverField && fieldHopRootType &&
+                    !resolvedBySameClass) {
+                    fieldDispatchType = _declaredFieldInterfaceType(index, fieldHopRootType, call.receiverField, fileEntry.language);
+                }
+
                 // Skip uncertain calls unless resolved by same-class matching or explicitly requested
                 if (isUncertain && !resolvedBySameClass && !options.includeUncertain) {
                     if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                    routeUnverified(filePath, fileEntry, call,
+                        call.isMethod ? 'method-no-evidence' : 'ambiguous-binding', calledAs);
                     continue;
                 }
 
@@ -400,7 +1053,110 @@ function findCallers(index, name, options = {}) {
                 const targetDefs = options.targetDefinitions || definitions;
                 const targetBindingIds = new Set(targetDefs.map(d => d.bindingId).filter(Boolean));
                 if (targetBindingIds.size > 0 && bindingId && !targetBindingIds.has(bindingId)) {
-                    continue;
+                    // fix #202: a declared-field receiver type that VALIDATES
+                    // against the target overrides name-binding evidence —
+                    // self.dent.path() name-binds to a same-file `path` def,
+                    // but the field's declared type says the call is the
+                    // target's (receiver-typed edges fall through to the
+                    // receiver-class disambiguation below).
+                    const fieldHopMatchesTarget = fieldHopType && targetDefs.some(d =>
+                        (d.className || (d.receiver || '').replace(/^\*/, '')) === fieldHopType);
+                    if (!fieldHopMatchesTarget) {
+                        recordExcluded(filePath, call.line, 'other-definition');
+                        continue;
+                    }
+                }
+
+                // Name-level import shadowing (fix #209, httpx-measured): an
+                // explicit import binding of the NAME rebinds it for the whole
+                // file — `from urllib.parse import unquote` makes every bare
+                // `unquote(...)` urllib's, regardless of which project files
+                // this file also imports (file-level import edges are not
+                // name-level evidence; httpx/_urls.py imports ._utils for
+                // OTHER names while unquote comes from urllib). A bare call
+                // only reaches the project def when SOME import binding of the
+                // name resolves to a target file (directly or one barrel hop),
+                // or the target is defined in this file. Mis-resolved project
+                // modules must not exclude: a binding to an unresolved module
+                // whose first segment matches a project directory routes
+                // visible instead.
+                if (!bindingId && !call.isMethod && !calledAs &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural' &&
+                    (fileEntry.importBindings || []).length > 0) {
+                    const nameBindings = fileEntry.importBindings.filter(b => b.name === call.name);
+                    const tFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
+                    // fix #215 (rich-measured: 225 builtin `print(...)` calls
+                    // confirmed against rich's def via file-level import edges):
+                    // a bare name in a module file resolves to a local binding,
+                    // an import binding of THAT name, or a builtin/global — it
+                    // can never reach an unimported project def. No local
+                    // binding (bindingId), no import binding of the name, no
+                    // star import that could inject it → the call provably
+                    // does not denote the target. Same correctness family as
+                    // the all-external shadow exclusion below; the
+                    // importBindings.length precondition keeps script files
+                    // (no module discipline) out.
+                    // `resolvedName` means the parser already resolved a local
+                    // alias to the original through a real import binding
+                    // (`const { parse: csvParse } = require(...)`) — name-level
+                    // evidence by construction; importBindings store the
+                    // ORIGINAL name, so the local alias must not look unbound.
+                    if (nameBindings.length === 0 && !call.resolvedName &&
+                        tFiles.size > 0 && !tFiles.has(filePath) &&
+                        !(fileEntry.importNames || []).includes('*')) {
+                        recordExcluded(filePath, call.line, 'name-not-in-scope');
+                        continue;
+                    }
+                    // A same-file pin does not put a bare name in scope when
+                    // every pinned def is class-scoped (fix #222, rich-measured):
+                    // the class member is outside the bare-name lookup chain,
+                    // so the file's import bindings own the name.
+                    const samefilePinsOutOfScope = targetDefs.length > 0 &&
+                        targetDefs.every(d => d.className);
+                    if (nameBindings.length > 0 && (!tFiles.has(filePath) || samefilePinsOutOfScope)) {
+                        // Name-level export-chain ownership (fix #217): each
+                        // binding is chased by NAME, not by file — `from
+                        // .render import render` pins to tests/render.py's own
+                        // def and cannot denote markup.render no matter what
+                        // tests/render.py imports (file-level reach said yes
+                        // through console.py — 24 rich FP edges). Exclusion
+                        // requires EVERY binding to be a definitive dead end:
+                        // external pins (#209c) or chains that provably
+                        // terminate away from the targets; any un-modelable
+                        // surface (CJS, star imports, module assignments,
+                        // resolver gaps) routes 'unknown' and blocks exclusion.
+                        let reaches = false;
+                        let undetermined = false;
+                        for (const b of nameBindings) {
+                            const rel = fileEntry.moduleResolved && fileEntry.moduleResolved[b.module];
+                            if (!rel) {
+                                // Unresolved module: external — unless it is
+                                // relative (project-internal by construction)
+                                // or its first segment names a project path
+                                // (resolution gap, not externality evidence)
+                                const mod = String(b.module);
+                                const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                                if (mod.startsWith('.') ||
+                                    (firstSeg && _projectTopLevelNames(index).has(firstSeg))) {
+                                    undetermined = true;
+                                }
+                                continue;
+                            }
+                            const resolvedAbs = path.join(index.root, rel);
+                            const verdict = _nameBindingReaches(index, resolvedAbs, b.name, tFiles);
+                            if (verdict === 'yes') { reaches = true; break; }
+                            if (verdict === 'unknown') undetermined = true;
+                        }
+                        if (!reaches && !undetermined) {
+                            // Every import binding of this name pins away from
+                            // the pinned targets (external module, or a project
+                            // def the name-chase resolved with certainty) — the
+                            // bare name is rebound away from the target
+                            // (compiler-checked module semantics).
+                            recordExcluded(filePath, call.line, 'other-definition-import');
+                            continue;
+                        }
+                    }
                 }
 
                 // Import-graph disambiguation for JS/TS/Python: when multiple definitions of
@@ -424,7 +1180,25 @@ function findCallers(index, name, options = {}) {
                                     break;
                                 }
                             }
-                            if (!foundViaReexport) continue;
+                            if (!foundViaReexport) {
+                                // Disposition depends on what the caller DOES import:
+                                //  - imports a DIFFERENT same-name def's file → positive
+                                //    mis-link evidence → excluded other-definition-import
+                                //  - imports neither def → pure ambiguity, no positive
+                                //    evidence → unverified tier (visible), per the contract
+                                const otherDefFiles = new Set((index.symbols.get(name) || [])
+                                    .map(d => d.file).filter(f => f && !targetFiles.has(f)));
+                                const importsOtherDef = imports && setSome(imports, imp => otherDefFiles.has(imp));
+                                if (importsOtherDef || otherDefFiles.has(filePath)) {
+                                    recordExcluded(filePath, call.line, 'other-definition-import');
+                                    continue;
+                                }
+                                if (collectAccount) {
+                                    routeUnverified(filePath, fileEntry, call, 'no-import-link', calledAs);
+                                    continue;
+                                }
+                                continue;
+                            }
                         }
                     }
                 }
@@ -436,6 +1210,7 @@ function findCallers(index, name, options = {}) {
                         targetDefs.filter(d => d.file).map(d => path.dirname(d.file))
                     );
                     if (targetPkgDirs.size > 0 && !targetPkgDirs.has(path.dirname(filePath))) {
+                        recordExcluded(filePath, call.line, 'out-of-scope-package');
                         continue;
                     }
                 }
@@ -445,15 +1220,131 @@ function findCallers(index, name, options = {}) {
                 // and cli.Run() (package call, isMethod:false) from matching DeploymentController.Run.
                 // Rust path calls (module::func(), Type::new()) bypass this filter — they're
                 // scoped_identifier calls that can target both standalone functions and impl methods.
-                if (!bindingId && !resolvedBySameClass && !call.isPathCall &&
+                // The binding guard is per-direction (fix #220): a name binding
+                // is receiver-blind, so it cannot make x.f() reach a standalone
+                // function in languages whose dot-calls provably never do (Rust
+                // needs (s.f)() parens — ripgrep's `.preprocessor_globs(...)`
+                // bound the same-file FUNCTION def). Go keeps !bindingId there:
+                // func-typed fields ARE name-callable. The bare-call direction
+                // keeps !bindingId — the upstream binding filter already
+                // re-resolves those to function defs where methods are
+                // unreachable.
+                if ((!bindingId || (call.isMethod &&
+                        !langTraits(fileEntry.language)?.methodCallReachesFunctions)) &&
+                    !resolvedBySameClass && !call.isPathCall &&
                     langTraits(fileEntry.language)?.typeSystem === 'nominal') {
                     const targetHasClass = targetDefs.some(d => d.className);
                     if (call.isMethod && !targetHasClass) {
                         // Method call but target is a standalone function — skip
+                        recordExcluded(filePath, call.line, 'method-kind-mismatch');
                         continue;
                     }
                     if (!call.isMethod && targetHasClass) {
                         // Non-method call but target is a class method — skip
+                        recordExcluded(filePath, call.line, 'method-kind-mismatch');
+                        continue;
+                    }
+                }
+
+                // Module receiver: httpx.get() / ns.helper() dispatches to a
+                // module export — it can never be a CLASS METHOD call. Applies
+                // only when every target is a class method; standalone-function
+                // and class (constructor) targets keep flowing on import evidence.
+                if (!bindingId && !resolvedBySameClass && call.isMethod && call.receiverIsModule &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural' &&
+                    targetDefs.length > 0 && targetDefs.every(d => d.className)) {
+                    isUncertain = true;
+                    typeMismatch = true;
+                    if (collectAccount) {
+                        recordExcluded(filePath, call.line, 'module-receiver');
+                        continue;
+                    }
+                    if (!options.includeUncertain) {
+                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                        continue;
+                    }
+                }
+
+                // Module-qualified ownership, structural (fix #209 — the #206
+                // Go rule transferred): `httpcore.URL(...)` denotes URL IN the
+                // httpcore module — an EXTERNAL module's attribute can never be
+                // the project's URL class. Resolve the receiver's own import
+                // binding (name-level — the file importing the target for
+                // other names proves nothing): binding module external →
+                // excluded; resolves to a project file that doesn't reach a
+                // target (directly or one re-export hop) → visible, not
+                // excluded (deep barrel chains exceed the hop budget);
+                // unresolved-but-project-looking → visible (resolver gap).
+                if (!bindingId && !resolvedBySameClass && call.isMethod && call.receiverIsModule &&
+                    call.receiver && langTraits(fileEntry.language)?.typeSystem === 'structural' &&
+                    (fileEntry.importBindings || []).length > 0) {
+                    const recvBindings = fileEntry.importBindings.filter(b => b.name === call.receiver);
+                    const tFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
+                    if (recvBindings.length > 0 && !tFiles.has(filePath)) {
+                        let reaches = false;
+                        let projectish = false;
+                        for (const b of recvBindings) {
+                            const rel = fileEntry.moduleResolved && fileEntry.moduleResolved[b.module];
+                            if (!rel) {
+                                const mod = String(b.module);
+                                const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                                if (mod.startsWith('.') ||
+                                    (firstSeg && _projectTopLevelNames(index).has(firstSeg))) {
+                                    projectish = true;
+                                }
+                                continue;
+                            }
+                            projectish = true;
+                            const resolvedAbs = path.join(index.root, rel);
+                            // Name-level ownership (fix #217 applied to module
+                            // receivers — zod family D): `z._default(...)` asks
+                            // for the MODULE's `_default` attribute; with three
+                            // project defs of the name, only the one the export
+                            // chain actually exposes can be the callee. The
+                            // chase is definitive only on fully-modeled ESM/
+                            // Python surfaces — 'unknown' (CJS, stars, module
+                            // assignments) falls back to file-level reach.
+                            const verdict = _nameBindingReaches(index, resolvedAbs, call.name, tFiles);
+                            if (verdict === 'yes' ||
+                                (verdict === 'unknown' && _importReaches(index, resolvedAbs, tFiles))) {
+                                reaches = true; break;
+                            }
+                        }
+                        if (!reaches) {
+                            if (!projectish) {
+                                recordExcluded(filePath, call.line, 'external-package');
+                                continue;
+                            }
+                            if (collectAccount) {
+                                routeUnverified(filePath, fileEntry, call, 'no-import-link', calledAs);
+                                continue;
+                            }
+                        }
+                    }
+                }
+
+                // Structural typed-receiver kind filter: a method call on a
+                // receiver with a known class type can only target that class's
+                // methods — never a standalone function. Module receivers are
+                // never typed (localVarTypes only types constructor results,
+                // annotations, and literals), so module-qualified calls to
+                // standalone functions keep flowing on import evidence. Class
+                // targets are exempt: their own type matching runs below.
+                // Trust gate: only builtin/project-class types are positive
+                // evidence — an alias/interface annotation can wrap the target
+                // (`const x: Fetcher = { fetch }`), so it must not exclude.
+                if (!bindingId && !resolvedBySameClass && call.isMethod && call.receiverType &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural' &&
+                    _receiverTypeTrustedForExclusion(index, call.receiverType) &&
+                    !targetDefs.some(d => d.className || d.receiver || NON_CALLABLE_TYPES.has(d.type))) {
+                    isUncertain = true;
+                    typeMismatch = true;
+                    if (collectAccount) {
+                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                        continue;
+                    }
+                    if (!options.includeUncertain) {
+                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                         continue;
                     }
                 }
@@ -464,16 +1355,36 @@ function findCallers(index, name, options = {}) {
                 // like "fmt", "os") and third-party calls (import graph has no edge to target).
                 if (!call.isMethod && call.receiver && !bindingId &&
                     langTraits(fileEntry.language)?.hasReceiverPackageCalls) {
-                    const callerFileImports = fileEntry.imports || [];
-                    const importModule = callerFileImports.find(mod => {
-                        const parts = mod.split('/');
-                        const last = parts[parts.length - 1];
-                        const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
-                        return pkgName === call.receiver;
-                    });
-                    if (importModule) {
-                        if (!importModule.includes('/')) {
+                    const pkgRes = _receiverPackageResolution(index, fileEntry, call.receiver, targetDefs);
+                    if (pkgRes) {
+                        if (pkgRes.singleSegment) {
                             // Single-segment import — Go stdlib, always external
+                            recordExcluded(filePath, call.line, 'external-package');
+                            continue;
+                        }
+                        // A package-qualified name can never denote the
+                        // caller's own FILE's package (Go cannot self-import):
+                        // a pinned target defined only in this very file is
+                        // positively a different symbol — measured:
+                        // &certprovider.KeyMaterial{...} inside KeyMaterial()
+                        // claiming a self-edge through a local binding.
+                        if (targetDefs.length > 0 && targetDefs.every(d => d.file === filePath)) {
+                            recordExcluded(filePath, call.line, 'other-definition');
+                            continue;
+                        }
+                        // Receiver-package identity (fix #206b): an import edge
+                        // to the target's file proves the caller USES the
+                        // target's package, not that THIS qualified name
+                        // resolves there. The qualified name denotes a symbol
+                        // in the RECEIVER's module — the target must live in
+                        // that module's package (project-relative module-path
+                        // suffix, or conventional package-segment match).
+                        // grpc-go measured: `&v3corepb.Locality{...}` (aliased
+                        // EXTERNAL envoy proto) and `xdsresource.Locality{...}`
+                        // confirmed for clients.Locality because the caller
+                        // also imported clients/config.go.
+                        if (!pkgRes.targetInPkg) {
+                            recordExcluded(filePath, call.line, 'other-definition');
                             continue;
                         }
                         // Multi-segment import — verify via import graph
@@ -485,46 +1396,162 @@ function findCallers(index, name, options = {}) {
                                 // No import edge — allow same-package (same directory) calls
                                 const callerDir = path.dirname(filePath);
                                 const samePackage = targetDefs.some(d => d.file && path.dirname(d.file) === callerDir);
-                                if (!samePackage) continue;
+                                if (!samePackage) {
+                                    recordExcluded(filePath, call.line, 'external-package');
+                                    continue;
+                                }
                             }
                         }
                     }
                 }
 
+                // Alias-matched method call on a TYPED receiver: the receiver's
+                // class owns the method dispatch — it cannot be a renamed
+                // standalone function (`numberSchema.gt()` is ZodNumber.gt, not
+                // `export { _gt as gt }`). Namespace receivers (`import * as
+                // checks; checks.gt()`) carry no receiverType and keep flowing
+                // on import evidence.
+                if (calledAs && call.isMethod && call.receiverType &&
+                    !targetDefs.some(td => td.className || td.receiver)) {
+                    isUncertain = true;
+                    typeMismatch = true;
+                    if (collectAccount) {
+                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                        continue;
+                    }
+                    if (!options.includeUncertain) {
+                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                        continue;
+                    }
+                }
+
                 // Receiver-class disambiguation:
                 // When the target definition has a class/receiver type, filter callers
                 // whose receiverType is known to be a different type.
                 // All languages use receiverType when available (constructor/annotation inference).
                 // Go/Java/Rust additionally fall back to variable name matching.
-                if (call.isMethod && call.receiver && !resolvedBySameClass && !bindingId &&
-                    (call.receiverType || langTraits(fileEntry.language)?.typeSystem === 'nominal')) {
-                    // Build target type set from both className (Java) and receiver (Go/Rust)
-                    const targetTypes = new Set();
-                    for (const td of targetDefs) {
-                        if (td.className) targetTypes.add(td.className);
-                        if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
-                    }
-                    // Expand targetTypes with types that embed the target (Go/Java/Rust)
-                    // e.g., if target is Base.Start() and Child embeds Base, accept Child.Start() callers
-                    if (targetTypes.size > 0 && langTraits(fileEntry.language)?.typeSystem === 'nominal') {
-                        for (const tt of [...targetTypes]) {
-                            const children = index.extendedByGraph?.get(tt);
-                            if (children) {
-                                for (const child of children) {
-                                    const cName = typeof child === 'string' ? child : child.name;
-                                    if (cName) targetTypes.add(cName);
-                                }
-                            }
-                        }
-                    }
+                // A declared-field receiver type (fix #202) enters even when a
+                // name-binding matched — bindings don't model receivers. Same
+                // for a BUILTIN-typed receiver (fix #209): `"".join(...)` in
+                // the file that defines URL.join name-binds to the method def,
+                // but the receiver IS a str — the literal type outranks the
+                // name binding (str/dict/Array are never project classes).
+                const builtinReceiverOverride = !!(call.receiverType &&
+                    BUILTIN_RECEIVER_TYPES.has(call.receiverType) &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural');
+                if (call.isMethod && (call.receiver || call.receiverType || fieldHopType) && !resolvedBySameClass &&
+                    (!bindingId || fieldHopType || builtinReceiverOverride) &&
+                    (call.receiverType || fieldHopType || langTraits(fileEntry.language)?.typeSystem === 'nominal')) {
+                    // Target type set: target classes + non-overriding subtypes
+                    // (a Child receiver calling an inherited Base method IS a
+                    // caller of Base.method). Memoized — fixed per query.
+                    const targetTypes = dispatchTargetTypes(targetDefs);
                     if (targetTypes.size > 0) {
                         // Use inferred receiverType when available (Go/Java/Rust parameter type tracking)
-                        const knownType = call.receiverType;
+                        // Generic type parameters by convention are not type
+                        // identity in EITHER direction (fix #220): a receiver
+                        // typed 'T' neither validates against a blanket-impl
+                        // target named 'T' nor excludes a concrete target —
+                        // T may be instantiated with anything. A short-caps
+                        // name with a real project type def is a class.
+                        let knownType = call.receiverType || fieldHopType;
+                        if (knownType && /^[A-Z][A-Z0-9]?$/.test(knownType) &&
+                            !(index.symbols.get(knownType) || []).some(d => IDENTITY_TYPE_KINDS.has(d.type))) knownType = null;
                         if (knownType) {
-                            const matchesTarget = targetTypes.has(knownType);
-                            if (!matchesTarget) {
-                                // Known type doesn't match target — skip directly
+                            const viaFieldHop = !call.receiverType; // declared-field hop (fix #202)
+                            // Exclusion requires an UNRELATED type. A receiver typed
+                            // as an ANCESTOR of the target's class may dynamically
+                            // dispatch to the target override (x: Base; x.parse()
+                            // can run Child.parse) — structural languages only;
+                            // Go embedding has no virtual dispatch. Field-hop types
+                            // get the ancestor guard too (Java virtual dispatch).
+                            const structural = langTraits(fileEntry.language)?.typeSystem === 'structural';
+                            if (targetTypes.has(knownType)) {
+                                receiverTypeValidated = true;
+                                // Identity discipline (nominal, fix #206): a
+                                // NAME match is only identity when the
+                                // unqualified type name resolves (same file →
+                                // same package directory → import edge) to the
+                                // target's package. grpc-go defines ~20 structs
+                                // all named `bb` — leastrequest's `parser :=
+                                // bb{}` validating against cdsbalancer's
+                                // bb.ParseConfig is name conflation, not
+                                // receiver evidence. Only DIRECT target type
+                                // names are disciplined — subtype names entered
+                                // targetTypes via the inheritance walk, whose
+                                // edges already carry package context.
+                                if (!structural &&
+                                    targetDefs.some(d => (d.className || (d.receiver || '').replace(/^\*/, '')) === knownType)) {
+                                    // Flow-typed receivers (fix #207) resolve identity
+                                    // from the producing annotation's scope — the name
+                                    // was written THERE, not in the consuming file.
+                                    const identity = _resolveReceiverTypeIdentity(
+                                        index, call.receiverTypeFlowFile || filePath, knownType, targetDefs);
+                                    if (identity === 'other') {
+                                        receiverTypeValidated = false;
+                                    } else if (identity === 'unknown') {
+                                        receiverTypeValidated = false;
+                                        receiverTypeUnresolved = true;
+                                    }
+                                }
+                            }
+                            const matchesTarget = receiverTypeValidated ||
+                                ((structural || viaFieldHop) && _isAncestorOfTargetClass(index, knownType, targetDefs));
+                            // Structural trust gate: a name that is neither a
+                            // builtin nor a project class (type alias, interface,
+                            // external type) tracks no hierarchy UCN can check —
+                            // not positive evidence against the target.
+                            // Field-hop exclusion additionally demands the field's
+                            // type DEFINE the method itself — otherwise Go
+                            // promotion, Rust Deref, or Java inheritance could
+                            // still route the call to the target. Exception: an
+                            // EXTERNAL field type (no project class/struct def,
+                            // e.g. Map/StringBuilder) excludes without that —
+                            // external code cannot Deref/promote/inherit INTO
+                            // project types, so the only dispatch path back is a
+                            // project subtype of the external type, which the
+                            // ancestor guard above already keeps.
+                            // (1-2 char ALL-CAPS names are generic type params by
+                            // convention — T, K, V, T1 — never external evidence:
+                            // T may be instantiated WITH the target class. And the
+                            // external rule needs the target's ancestor chain to be
+                            // FULLY project-resolvable: a chain that dead-ends at an
+                            // external ancestor (LinkedTreeMap extends AbstractMap)
+                            // may reach knownType through ancestry UCN can't see —
+                            // measured on gson: 6 true edges lost without this.)
+                            const fieldHopDefinesMethod = !viaFieldHop || definitions.some(d =>
+                                (d.className || (d.receiver || '').replace(/^\*/, '')) === knownType) ||
+                                (!/^[A-Z][A-Z0-9]?$/.test(knownType) &&
+                                    !(index.symbols.get(knownType) || []).some(d =>
+                                        d.type === 'class' || d.type === 'struct' || d.type === 'interface' || d.type === 'trait') &&
+                                    _targetAncestryFullyResolved(index, targetDefs));
+                            const exclusionTrusted = (!structural ||
+                                _receiverTypeTrustedForExclusion(index, knownType)) && fieldHopDefinesMethod &&
+                                !receiverTypeUnresolved; // unresolvable identity is not positive evidence either way
+                            if (!matchesTarget && exclusionTrusted) {
+                                // Known type doesn't match target — positive evidence the
+                                // call targets a DIFFERENT symbol. Under the account contract
+                                // this is excluded-with-reason, not a revealable uncertain.
                                 isUncertain = true;
+                                typeMismatch = true;
+                                if (collectAccount) {
+                                    // ...unless the type can VIRTUALLY dispatch into
+                                    // the target: an interface/trait receiver that
+                                    // declares the method, or (Java — all instance
+                                    // methods virtual) a superclass of the target.
+                                    // Not evidence against — visible possible-dispatch.
+                                    // Go struct embedding binds statically and stays
+                                    // excluded.
+                                    if (_dispatchCapableSupertype(index, fileEntry.language, knownType, targetDefs, definitions)) {
+                                        routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                            dispatchVia: knownType,
+                                            dispatchCandidates: countDispatchCandidates(knownType),
+                                        });
+                                        continue;
+                                    }
+                                    recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    continue;
+                                }
                                 if (!options.includeUncertain) {
                                     if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                                     continue;
@@ -551,7 +1578,22 @@ function findCallers(index, name, options = {}) {
                                         const inferredType = localTypes.get(call.receiver);
                                         if (inferredType) {
                                             if (targetTypes.has(inferredType)) {
-                                                inferredMatch = true;
+                                                // Identity discipline (fix #206) — same as the
+                                                // parser-typed branch above: a name match on a
+                                                // DIRECT target type must resolve to the
+                                                // target's package, not a same-named foreign type.
+                                                let identity = 'target';
+                                                if (targetDefs.some(d => (d.className || (d.receiver || '').replace(/^\*/, '')) === inferredType)) {
+                                                    identity = _resolveReceiverTypeIdentity(index, filePath, inferredType, targetDefs);
+                                                }
+                                                if (identity === 'target') {
+                                                    inferredMatch = true;
+                                                    nominalInferredMatch = true;
+                                                } else if (identity === 'other') {
+                                                    inferredMismatch = true;
+                                                } else {
+                                                    receiverTypeUnresolved = true;
+                                                }
                                             } else {
                                                 inferredMismatch = true;
                                             }
@@ -561,20 +1603,72 @@ function findCallers(index, name, options = {}) {
                             }
                             if (inferredMismatch) {
                                 isUncertain = true;
+                                typeMismatch = true;
+                                if (collectAccount) {
+                                    recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    continue;
+                                }
                                 if (!options.includeUncertain) {
                                     if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                                     continue;
                                 }
                             }
-                            // Still no type — fall back to receiver name matching when multiple defs exist
-                            if (!inferredMatch && !inferredMismatch && definitions.length > 1) {
+                            // Still no type — fall back to receiver name matching when
+                            // multiple defs exist. A field-declared interface/trait type
+                            // (fieldDispatchType, contract surface only) outranks the name
+                            // heuristic: `storage.save()` on a field declared `Storage`
+                            // is a dispatch edge, not a case-insensitive name accident —
+                            // skip the fallback and let the dispatch tiering route it.
+                            // call.receiver guard: a generic-param knownType
+                            // (fix #220) reaches here receiver-less — there is
+                            // no receiver NAME to match against.
+                            if (call.receiver && !inferredMatch && !inferredMismatch && definitions.length > 1 && !fieldDispatchType) {
                                 const receiverLower = call.receiver.toLowerCase();
                                 const matchesTarget = [...targetTypes].some(cn => cn.toLowerCase() === receiverLower);
+                                // Type-qualified identity discipline (fix #220,
+                                // ripgrep-measured): a path-call receiver that
+                                // matches the target type's NAME must also
+                                // resolve (same file → same dir → import edge)
+                                // to the target's package — every ripgrep crate
+                                // defines its own `Config`, and printer's
+                                // Config::default() name-matches core's Config
+                                // while provably denoting the same-file struct.
+                                // Path style only: a Go/Java receiver named
+                                // like the type may be a VARIABLE (#206b) —
+                                // its type is unknown, identity proves nothing.
+                                if (matchesTarget && call.isPathCall &&
+                                    langTraits(fileEntry.language)?.typeQualifiedCallStyle === 'path') {
+                                    const identity = _resolveReceiverTypeIdentity(index, filePath, call.receiver, targetDefs);
+                                    if (identity === 'other') {
+                                        isUncertain = true;
+                                        typeMismatch = true;
+                                        if (collectAccount) {
+                                            recordExcluded(filePath, call.line, 'path-type-mismatch');
+                                            continue;
+                                        }
+                                        if (!options.includeUncertain) {
+                                            if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                            continue;
+                                        }
+                                    } else if (identity === 'unknown' && collectAccount) {
+                                        // Unresolvable identity never confirms,
+                                        // never excludes (#206).
+                                        routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                            dispatchCandidates: methodOwnerKeys().size,
+                                        });
+                                        continue;
+                                    }
+                                }
                                 if (!matchesTarget) {
                                     // Rust/Go path calls (Type::method() / pkg.Method()): receiver IS the type name
                                     // If it doesn't match target, it's definitely a different type — filter it
                                     if (call.isPathCall && /^[A-Z]/.test(call.receiver)) {
                                         isUncertain = true;
+                                        typeMismatch = true;
+                                        if (collectAccount) {
+                                            recordExcluded(filePath, call.line, 'path-type-mismatch');
+                                            continue;
+                                        }
                                         if (!options.includeUncertain) {
                                             if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                                             continue;
@@ -588,6 +1682,26 @@ function findCallers(index, name, options = {}) {
                                     const matchesOther = [...nonTargetClasses].some(cn => cn.toLowerCase() === receiverLower);
                                     if (matchesOther) {
                                         isUncertain = true;
+                                        typeMismatch = true;
+                                        if (collectAccount) {
+                                            // The matched class may be a dispatch-capable
+                                            // supertype of the target (a receiver named
+                                            // after the interface it is typed as) — that
+                                            // is a possible dispatch edge, not evidence
+                                            // against the target.
+                                            const dispatchSuper = [...nonTargetClasses]
+                                                .filter(cn => cn.toLowerCase() === receiverLower)
+                                                .find(cn => _dispatchCapableSupertype(index, fileEntry.language, cn, targetDefs, definitions));
+                                            if (dispatchSuper) {
+                                                routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                                    dispatchVia: dispatchSuper,
+                                                    dispatchCandidates: countDispatchCandidates(dispatchSuper),
+                                                });
+                                                continue;
+                                            }
+                                            recordExcluded(filePath, call.line, 'receiver-other-class');
+                                            continue;
+                                        }
                                         if (!options.includeUncertain) {
                                             if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
                                             continue;
@@ -599,90 +1713,543 @@ function findCallers(index, name, options = {}) {
                     }
                 }
 
+                // Arity pruning (nominal contract surface, fix #205): a call
+                // whose argument count cannot fit ANY pinned definition's
+                // parameter range is positive evidence the call binds a
+                // different symbol — excluded-with-reason. Static-arity
+                // languages only: their compilers enforce arity, so a mismatch
+                // IS evidence. JS pads/ignores extra args legally and Python
+                // decorators reshape signatures invisibly — never prune there.
+                // Go tuple expansion (f(g()) filling two params) means too-FEW
+                // syntactic args is not evidence in Go — only too-many prunes.
+                // Binding/same-class evidence outranks the count (then a
+                // mismatch more likely means our param parse is wrong).
+                if (collectAccount && !bindingId && !resolvedBySameClass &&
+                    call.argCount != null && !call.argSpread &&
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                    !_callArityCompatible(call, targetDefs, fileEntry.language)) {
+                    recordExcluded(filePath, call.line, 'arity-mismatch');
+                    continue;
+                }
+
+                // Overload discipline (fix #205, languages with arity/type
+                // overloading — Java): when the pinned target shares its name
+                // with sibling overloads in the same class, a call site only
+                // CONFIRMS the pinned overload if its static argument shape
+                // (count + literal kinds) binds it:
+                //   - kinds prove a DIFFERENT overload → excluded 'overload-mismatch'
+                //   - kinds prove the pinned one uniquely → flows on (confirmable)
+                //   - undecidable (variable args) → visible 'overload-ambiguous'
+                // jdtls-measured: class-level receiver evidence said "some add()
+                // overload", which is not evidence for THIS add(Number).
+                if (collectAccount && options.targetDefinitions &&
+                    langTraits(fileEntry.language)?.hasArityOverloads &&
+                    call.argCount != null && !call.argSpread && !call.isConstructor) {
+                    const overloadVerdict = _overloadDiscipline(index, call, targetDefs, definitions);
+                    if (overloadVerdict === 'other-overload') {
+                        recordExcluded(filePath, call.line, 'overload-mismatch');
+                        continue;
+                    }
+                    if (overloadVerdict && overloadVerdict.ambiguous) {
+                        routeUnverified(filePath, fileEntry, call, 'overload-ambiguous', calledAs, {
+                            dispatchCandidates: overloadVerdict.candidates,
+                        });
+                        continue;
+                    }
+                }
+
                 // Find the enclosing function (get full symbol info)
                 const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
 
+                // Method call whose receiver has no binding evidence in this file's
+                // scope (structural languages only) — receiver-evidence-free.
+                // Hoisted because it also limits what counts as import evidence.
+                const uncertainMethodReceiver = skipLocalBinding && call.isMethod && !resolvedBySameClass &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural' &&
+                    !(call.receiver && (fileEntry.bindings || []).some(b => b.name === call.receiver));
+
                 // Check import graph evidence: does this file import from the target definition's file?
                 const targetDefs2 = options.targetDefinitions || definitions;
                 const targetFiles2 = new Set(targetDefs2.map(d => d.file).filter(Boolean));
                 const callerImports = index.importGraph.get(filePath);
-                let hasImportLink = targetFiles2.has(filePath) || (callerImports && setSome(callerImports, imp => targetFiles2.has(imp)));
+                let importEdgeLink = !!(callerImports && setSome(callerImports, imp => targetFiles2.has(imp)));
                 // Check one level of re-exports (barrel files) for import evidence
-                if (!hasImportLink && callerImports) {
+                if (!importEdgeLink && callerImports) {
                     for (const imp of callerImports) {
                         const transImports = index.importGraph.get(imp);
                         if (transImports && setSome(transImports, ti => targetFiles2.has(ti))) {
-                            hasImportLink = true;
+                            importEdgeLink = true;
                             break;
                         }
                     }
                 }
+                // Same-file membership is module-scope evidence for plain calls,
+                // but says nothing about a method receiver: `foo.map()` sharing a
+                // file with `function map()` must not confirm while foo's type is
+                // unknown. Real import edges keep counting — importing the
+                // defining module is evidence the file uses its API.
+                const hasImportLink = importEdgeLink ||
+                    (targetFiles2.has(filePath) && !uncertainMethodReceiver);
 
-                if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
-                pendingByFile.get(filePath).push({
-                    call, fileEntry, callerSymbol,
-                    isMethod: call.isMethod || false, isFunctionReference: false,
-                    receiver: call.receiver,
-                    receiverType: call.receiverType,
-                    _evidence: {
-                        hasBindingId: !!bindingId,
-                        resolvedBySameClass: !!resolvedBySameClass,
-                        isUncertain: !!isUncertain || (
-                            // Method calls where binding resolution was skipped (non-self receiver)
-                            // and the receiver has no binding evidence → uncertain (JS/TS/Python only)
-                            skipLocalBinding && call.isMethod && !resolvedBySameClass &&
-                            langTraits(fileEntry.language)?.typeSystem === 'structural' &&
-                            !(call.receiver && (fileEntry.bindings || []).some(b => b.name === call.receiver))
-                        ),
-                        hasReceiverType: !!call.receiverType,
-                        hasReceiverEvidence: !!(call.receiver &&
-                            (fileEntry.bindings || []).some(b => b.name === call.receiver)),
-                        hasImportEvidence: !!bindingId || hasImportLink,
-                    }
-                });
-                pendingCount++;
-            }
-        } catch (e) {
-            // Expected: minified files exceed tree-sitter buffer, binary files fail to parse.
-            // These are not actionable errors — silently skip.
-        }
-    }
-
-    // True total candidate count from Phase 1 (before any Phase 2 truncation).
-    // Used by callers that need accurate "showing N of <total>" headers.
-    const totalCount = pendingCount;
-    // When needsTotal is set with a maxResults cap, only enrich the first
-    // `maxResults` candidates in Phase 2 — file reads stay bounded.
-    const enrichLimit = (needsTotal && maxResults) ? maxResults : Infinity;
-    let enrichedCount = 0;
+                // Same-package evidence (nominal type systems): Java/Rust/Go
+                // resolve same-package/module names without import statements,
+                // so a target defined in the caller's directory is real scope
+                // evidence, not a bare name match.
+                const hasSamePackageEvidence = !hasImportLink &&
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                    targetDefs2.some(d => d.file && path.dirname(d.file) === path.dirname(filePath));
 
-    // BUG-H1: shadow records for un-enriched candidates so post-call filters
-    // (exclude / minConfidence) can produce an accurate total without forcing
-    // a Phase-2 file read for every candidate. Each shadow has just enough
-    // info to drive the filter predicates: relativePath + confidence.
-    const shadowEntries = [];
+                // Possible-dispatch tiering (nominal languages, contract surface
+                // only): methodCallInclusion='auto' confirms method calls with
+                // ZERO receiver evidence — right when the name is unique
+                // project-wide (cobra), a lie when dozens of types implement it
+                // (gson TypeAdapter.read). The confirmed tier keeps only
+                // evidence-backed edges: validated/inferred receiver type,
+                // same-class resolution, binding, a type-qualified receiver
+                // (Type::method / Type.method), or a name with a single
+                // project-wide owner. The rest stay VISIBLE as unverified — a
+                // known-but-unvalidated receiver type is 'possible-dispatch'
+                // (attributed via the declared supertype), an untyped receiver
+                // against multiple owners is 'method-ambiguous'. Nothing is
+                // dropped: conservation holds, the entries move tiers.
+                // A binding matched from a bare-name lookup is receiver-blind:
+                // method calls resolve through their RECEIVER in every supported
+                // language, never through file scope — a same-file def or import
+                // of the name says nothing about what `parse_hex(v).map(...)` or
+                // `self.inner.next()` dispatches to (cursive-measured: 9 of 11
+                // method FPs were chained/field-rooted calls confirmed
+                // exact-binding against Rgb::map / Iterator-impl next / V::draw).
+                // Such calls must earn the confirmed tier through receiver
+                // evidence — route them through the dispatch tiering below.
+                // Self-receiver calls are not affected (same-class resolution
+                // owns them); captured-receiver calls never bound (skipLocalBinding).
+                // Local-alias calls (fix #218): `get_style = console.get_style;
+                // get_style(x)` is a TRUE edge with compiler-grade evidence,
+                // but it reaches the target through a local variable — the
+                // line's name resolves to the alias, not the def, so reference
+                // oracles place nothing here and grep-parity verification is
+                // impossible. Visible unverified, never confirmed (not even by
+                // same-class/type-qualified/single-owner evidence); the
+                // exclusion-grade checks (typed-receiver mismatch, same-class
+                // pinning, arity) already fired above and win.
+                if (collectAccount && call.aliasCall) {
+                    routeUnverified(filePath, fileEntry, call, 'alias-call', calledAs, {
+                        ...(call.receiver && { dispatchVia: call.receiver }),
+                    });
+                    continue;
+                }
 
-    // Phase 2: Read content only for files with matching calls (eliminates ~98% of file reads)
-    outer: for (const [filePath, pending] of pendingByFile) {
-        let content = null;
-        for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver, receiverType, _evidence } of pending) {
-            const scored = scoreEdge(_evidence || {});
-            if (enrichedCount >= enrichLimit) {
-                // Push shadow only — no file read needed.
-                shadowEntries.push({
-                    file: filePath,
-                    relativePath: fileEntry.relativePath,
-                    line: call.line,
-                    confidence: scored.confidence,
-                    resolution: scored.resolution,
-                    isMethod: call.isMethod || false,
-                    ...(isFunctionReference && { isFunctionReference: true }),
-                    ...(receiver !== undefined && { receiver }),
-                    ...(receiverType && { receiverType }),
-                });
-                continue;
-            }
-            // First time we hit this file's enrichment loop — read the file once.
+                const receiverBlindBinding = !!bindingId && call.isMethod && !call.receiver;
+                if (collectAccount && call.isMethod && (!bindingId || receiverBlindBinding) && !resolvedBySameClass &&
+                    !receiverTypeValidated && !nominalInferredMatch &&
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal') {
+                    const tTypes = dispatchTargetTypes(targetDefs2);
+                    // `use X as Y` import rename (fix #222b, ripgrep-measured:
+                    // `use ContextSeparator as Separator; Separator::disabled()`
+                    // — the alias names the TARGET type locally): judge path
+                    // receivers by the ORIGINAL name. Only fires when the
+                    // import's last path segment IS a target type — package
+                    // aliases and unrelated imports stay untouched.
+                    let receiverName = call.receiver;
+                    if (receiverName && !tTypes.has(receiverName)) {
+                        for (const im of (fileEntry.importBindings || [])) {
+                            if (im.name !== receiverName) continue;
+                            const orig = String(im.module || '').split('::').pop();
+                            if (orig && orig !== receiverName && tTypes.has(orig)) {
+                                receiverName = orig;
+                                break;
+                            }
+                        }
+                    }
+                    // A receiver that shares the target type's NAME is only
+                    // type-qualified when the call matches the language's
+                    // qualified-call syntax (typeQualifiedCallStyle trait):
+                    // Rust requires Type::method (a dot-call receiver matching
+                    // a type name is a variable); Go method expressions
+                    // T.M(recv, ...) pass the receiver as the first argument,
+                    // so a zero-arg call on a type-named receiver is a
+                    // variable, not the type (grpc-go's `bb` collision).
+                    let typeQualifiedReceiver = !!(receiverName && tTypes.has(receiverName));
+                    if (typeQualifiedReceiver) {
+                        const qualStyle = langTraits(fileEntry.language)?.typeQualifiedCallStyle;
+                        if (qualStyle === 'path') typeQualifiedReceiver = !!call.isPathCall;
+                        else if (qualStyle === 'method-expr') typeQualifiedReceiver = call.argCount == null || call.argCount >= 1;
+                    }
+                    // Identity discipline on the qualified shape itself (fix
+                    // #220): a genuinely type-qualified call still only NAMES
+                    // the type — the name must resolve to the target's package
+                    // (every ripgrep crate defines a `Config`). 'other' is
+                    // compiler-grade evidence for a different type; 'unknown'
+                    // never confirms and never excludes (#206). The receiver-
+                    // name fallback above handles multi-definition names; this
+                    // covers single-definition targets that skip it.
+                    if (typeQualifiedReceiver) {
+                        const identity = _resolveReceiverTypeIdentity(index, filePath, receiverName, targetDefs2);
+                        if (identity === 'other') {
+                            recordExcluded(filePath, call.line, 'path-type-mismatch');
+                            continue;
+                        }
+                        if (identity === 'unknown') {
+                            routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                dispatchCandidates: methodOwnerKeys().size,
+                            });
+                            continue;
+                        }
+                    }
+                    if (!typeQualifiedReceiver) {
+                        // External-producer receiver (fix #220): the variable
+                        // was assigned from a call into an external package
+                        // (av := reflect.ValueOf(a)) — its type was decided
+                        // outside the project, so unique project ownership is
+                        // not identity evidence. Visible, never excluded
+                        // (external generic identity functions can return
+                        // project values).
+                        if (call.receiverExternalFlow) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                dispatchVia: call.receiverExternalFlow,
+                                externalContract: true,
+                            });
+                            continue;
+                        }
+                        // Unresolvable type-name identity (fix #206): the
+                        // receiver is typed with a name several distinct types
+                        // share, and none resolves from this file's scope —
+                        // visible ambiguous, not confirmable receiver evidence.
+                        if (receiverTypeUnresolved) {
+                            routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                dispatchCandidates: methodOwnerKeys().size,
+                            });
+                            continue;
+                        }
+                        // Type-qualified path calls naming a NON-target type
+                        // (fix #222, seed-C-measured — the #220(2) fallback
+                        // only ran with multiple same-name definitions, so
+                        // single-owner names bypassed the whole discipline):
+                        // `Vec::<String>::new()` inside assert_eq! names std's
+                        // Vec — same-package scope cannot make it the project
+                        // `new`. Generic-param receivers (`T::zero()` — T is
+                        // instantiable with ANY type satisfying its bound)
+                        // route VISIBLE, never excluded; concrete non-target
+                        // type names are compiler-grade evidence for a
+                        // different type. `Self` keeps its current scope
+                        // resolution (a true same-impl call). Alias-qualified
+                        // receivers are in the #208-closed tTypes and never
+                        // reach here.
+                        if (call.isPathCall && call.receiver &&
+                            /^[A-Z]/.test(call.receiver) && call.receiver !== 'Self') {
+                            if (/^[A-Z][A-Z0-9]?$/.test(call.receiver) &&
+                                !(index.symbols.get(call.receiver) || []).some(d => IDENTITY_TYPE_KINDS.has(d.type))) {
+                                routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                    dispatchCandidates: methodOwnerKeys().size,
+                                });
+                                continue;
+                            }
+                            recordExcluded(filePath, call.line, 'path-type-mismatch');
+                            continue;
+                        }
+                        const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
+                        if (knownDispatchType && !tTypes.has(knownDispatchType)) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                dispatchVia: knownDispatchType,
+                                dispatchCandidates: countDispatchCandidates(knownDispatchType),
+                            });
+                            continue;
+                        }
+                        if (!knownDispatchType && methodOwnerKeys().size > 1) {
+                            routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                dispatchCandidates: methodOwnerKeys().size,
+                            });
+                            continue;
+                        }
+                        // Single project-wide owner, but the method provably
+                        // implements an EXTERNAL contract (fix #210): the
+                        // receiver could be any external subtype
+                        // (((Long) obj).intValue() vs LazilyParsedNumber's
+                        // @Override intValue) — unique ownership is not
+                        // identity evidence here. Visible, never excluded.
+                        const extContract = !knownDispatchType && externalContractTarget();
+                        if (extContract) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                ...(extContract.via && { dispatchVia: extContract.via }),
+                                externalContract: true,
+                            });
+                            continue;
+                        }
+                    }
+                }
+
+                // Sibling-impl overload ambiguity (fix #220, cursive-measured —
+                // the #205 jdtls insight for languages WITHOUT arity-overload
+                // discipline): Rust defines same-name methods on the SAME type
+                // across impl blocks (`impl From<Color> for ColorStyle` ×4;
+                // `impl Rgb<f32>` vs `impl Rgb<u8>` both with as_color).
+                // Class-level receiver evidence — type-qualified path calls,
+                // name-validated receiver types — proves "some ColorStyle::from",
+                // never the pinned one; with an arity-indistinguishable
+                // same-class sibling the call routes visible. Alias-qualified
+                // receivers are exempt: `StyledString::plain` names ONE
+                // instantiation by construction (#208 — the alias carries the
+                // type argument even though UCN's closure is name-level).
+                // Go cannot compile same-class same-name siblings; Java runs
+                // its own #205 argKinds discipline (hasArityOverloads).
+                if (collectAccount && call.isMethod && !resolvedBySameClass &&
+                    (!bindingId || receiverBlindBinding) &&
+                    langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                    !langTraits(fileEntry.language)?.hasArityOverloads &&
+                    options.targetDefinitions && options.targetDefinitions.length > 0 &&
+                    !(call.receiver && (index.symbols.get(call.receiver) || []).some(d => d.aliasOf))) {
+                    const pinnedCallable = options.targetDefinitions.filter(d => !NON_CALLABLE_TYPES.has(d.type));
+                    const pinnedClasses = new Set(pinnedCallable
+                        .map(d => d.className || (d.receiver || '').replace(/^\*/, ''))
+                        .filter(Boolean));
+                    if (pinnedClasses.size > 0) {
+                        const pinnedKeys = new Set(pinnedCallable.map(d => `${d.file}:${d.startLine}`));
+                        // Same-FILE constraint: a same-name class in another
+                        // package is a DIFFERENT type, not a sibling impl
+                        // (Go's per-package `bb` structs). The measured Rust
+                        // families (From impls, generic instantiations) live
+                        // in the type's own file.
+                        const pinnedFiles = new Set(pinnedCallable.map(d => d.file).filter(Boolean));
+                        const sibling = definitions.find(d =>
+                            !NON_CALLABLE_TYPES.has(d.type) &&
+                            pinnedClasses.has(d.className || (d.receiver || '').replace(/^\*/, '')) &&
+                            pinnedFiles.has(d.file) &&
+                            !pinnedKeys.has(`${d.file}:${d.startLine}`) &&
+                            _callArityCompatible(call, [d], fileEntry.language));
+                        if (sibling) {
+                            routeUnverified(filePath, fileEntry, call, 'overload-ambiguous', calledAs, {
+                                dispatchCandidates: definitions.filter(d =>
+                                    !NON_CALLABLE_TYPES.has(d.type) &&
+                                    pinnedClasses.has(d.className || (d.receiver || '').replace(/^\*/, ''))).length,
+                            });
+                            continue;
+                        }
+                    }
+                }
+
+                // Structural dispatch tiering (fix #209, httpx-measured — the
+                // #204 discipline applied to structural languages): file-level
+                // import/scope evidence speaks for a bare NAME reaching this
+                // file, not for a method call's receiver — `key.decode(enc)`
+                // in a file that imports _decoders.py is bytes.decode, not
+                // ContentDecoder.decode. An untyped-receiver method call
+                // confirms only via binding, same-class, a validated receiver
+                // type, a type-qualified receiver (Class.method static style),
+                // or a single project-wide owner. Multi-owner name matches
+                // route VISIBLE method-ambiguous — never dropped. Same for a
+                // bare call against pure method targets (a bare name cannot
+                // denote a method in JS/TS/Python — only a rebound alias can,
+                // which has no evidence here either).
+                if (collectAccount && (!bindingId || receiverBlindBinding) && !resolvedBySameClass &&
+                    !receiverTypeValidated &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural') {
+                    // Module-qualified calls (z.string(), ns.helper()) are
+                    // exempt: the module IS name-level evidence, and the
+                    // module-ownership block above already routed the ones
+                    // whose module doesn't reach the target.
+                    if (call.isMethod && !call.receiverIsModule) {
+                        const tTypes = dispatchTargetTypes(targetDefs2);
+                        const typeQualifiedReceiver = !!(call.receiver && tTypes.has(call.receiver));
+                        // External-producer receiver (fix #222, httpx-measured
+                        // — the #220 Go rule for structural languages): the
+                        // variable was assigned from a call into an external
+                        // module (logger = logging.getLogger(...)), so its
+                        // type was decided outside the project and unique
+                        // project ownership is not identity evidence.
+                        // Visible, never excluded.
+                        if (!typeQualifiedReceiver && call.receiverExternalFlow) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                dispatchVia: call.receiverExternalFlow,
+                                externalContract: true,
+                            });
+                            continue;
+                        }
+                        // A method call cannot denote a standalone function
+                        // (fix #218, rich-measured: `console.print(...)`
+                        // confirmed scope-match against module-level print):
+                        // only an attribute assignment could rebind one onto a
+                        // receiver, which is beyond name-level evidence. Typed
+                        // receivers are excluded above (#198); untyped ones
+                        // route visible. Module receivers stay exempt
+                        // (rich.print(...) IS the module function).
+                        if (!typeQualifiedReceiver && targetDefs2.length > 0 &&
+                            targetDefs2.every(d => !d.className && !d.receiver)) {
+                            routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                dispatchCandidates: methodOwnerKeys().size,
+                            });
+                            continue;
+                        }
+                        // External-contract single owner (fix #210): same
+                        // physics as the nominal gate above — an override
+                        // marker proves the name exists on a contract UCN
+                        // cannot see, so the receiver could be any external
+                        // subtype. Checked before the multi-owner branch
+                        // only via owner count (===1) being its precondition.
+                        const extContract = !typeQualifiedReceiver &&
+                            externalContractTarget();
+                        if (extContract) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                ...(extContract.via && { dispatchVia: extContract.via }),
+                                externalContract: true,
+                            });
+                            continue;
+                        }
+                        if (!typeQualifiedReceiver && methodOwnerKeys().size > 1) {
+                            const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
+                            if (knownDispatchType) {
+                                // Known-but-unvalidated type (supertype of the
+                                // target — dynamic dispatch — or an alias/
+                                // interface name UCN can't validate, or a
+                                // declared-field hop type, fix #219): a
+                                // possible dispatch edge, attributed via the
+                                // receiver's declared type (#204 physics).
+                                routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                    dispatchVia: knownDispatchType,
+                                    dispatchCandidates: countDispatchCandidates(knownDispatchType),
+                                });
+                            } else {
+                                routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                    dispatchCandidates: methodOwnerKeys().size,
+                                });
+                            }
+                            continue;
+                        }
+                    } else if (!calledAs && !call.isConstructor &&
+                        targetDefs2.length > 0 && targetDefs2.every(d => d.className)) {
+                        routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                            dispatchCandidates: methodOwnerKeys().size,
+                        });
+                        continue;
+                    }
+                }
+
+                if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
+                pendingByFile.get(filePath).push({
+                    call, fileEntry, callerSymbol,
+                    isMethod: call.isMethod || false,
+                    // Function references can resolve through the plain binding
+                    // path too (e.g. JS `arr.map(helper)` with a local binding) —
+                    // surface the parser's marker on the edge (fix #221).
+                    isFunctionReference: !!call.isFunctionReference,
+                    receiver: call.receiver,
+                    receiverType: call.receiverType,
+                    calledAs,
+                    _evidence: {
+                        hasBindingId: !!bindingId,
+                        resolvedBySameClass: !!resolvedBySameClass,
+                        hasSamePackageEvidence,
+                        // Method calls where binding resolution was skipped (non-self receiver)
+                        // and the receiver has no binding evidence → uncertain (JS/TS/Python only)
+                        isUncertain: !!isUncertain || uncertainMethodReceiver,
+                        hasReceiverType: langTraits(fileEntry.language)?.typeSystem === 'structural'
+                            ? receiverTypeValidated
+                            : !!call.receiverType,
+                        hasReceiverEvidence: !!(call.receiver &&
+                            (fileEntry.bindings || []).some(b => b.name === call.receiver)),
+                        hasImportEvidence: !!bindingId || hasImportLink,
+                        ...(typeMismatch && { typeMismatch: true }),
+                    }
+                });
+                pendingCount++;
+            }
+        } catch (e) {
+            // Expected: minified files exceed tree-sitter buffer, binary files fail to parse.
+            // These are not actionable errors — silently skip.
+        }
+    }
+
+    // True total candidate count from Phase 1 (before any Phase 2 truncation).
+    // Used by callers that need accurate "showing N of <total>" headers.
+    const totalCount = pendingCount;
+    // When needsTotal is set with a maxResults cap, only enrich the first
+    // `maxResults` candidates in Phase 2 — file reads stay bounded.
+    const enrichLimit = (needsTotal && maxResults) ? maxResults : Infinity;
+    let enrichedCount = 0;
+
+    // BUG-H1: shadow records for un-enriched candidates so post-call filters
+    // (exclude / minConfidence) can produce an accurate total without forcing
+    // a Phase-2 file read for every candidate. Each shadow has just enough
+    // info to drive the filter predicates: relativePath + confidence.
+    const shadowEntries = [];
+    // Unverified-tier entries (collectAccount only): retained drops, rendered
+    // in their own section. First `unverifiedEnrichLimit` get content + caller
+    // lookup; the rest stay shadow-style (file/line/reason only).
+    const unverifiedEntries = [];
+    let unverifiedEnriched = 0;
+
+    // Phase 2: Read content only for files with matching calls (eliminates ~98% of file reads)
+    outer: for (const [filePath, pending] of pendingByFile) {
+        let content = null;
+        for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver, receiverType, calledAs, _evidence, _tier, _reason, _meta } of pending) {
+            const scored = scoreEdge(_evidence || {});
+            // Family B contract field (fix #221): a bind/call/apply site reaches
+            // the target through Function.prototype indirection, not direct call
+            // syntax — label the edge calledAs:'bound'. Rename aliases keep their
+            // surface name (they describe the same slot and are rarer). Label
+            // only, computed at edge construction: routing logic never sees it.
+            const edgeCalledAs = calledAs || (call.boundCall ? 'bound' : undefined);
+            if (_tier) {
+                // Routed unverified entry — never competes with the main
+                // answer for maxResults/enrichLimit slots.
+                const base = {
+                    file: filePath,
+                    relativePath: fileEntry.relativePath,
+                    line: call.line,
+                    confidence: scored.confidence,
+                    resolution: scored.resolution,
+                    tier: _tier,
+                    reason: _reason,
+                    ...(_meta || {}),
+                    isMethod: call.isMethod || false,
+                    ...(isFunctionReference && { isFunctionReference: true }),
+                    ...(receiver !== undefined && { receiver }),
+                    ...(receiverType && { receiverType }),
+                    ...(edgeCalledAs && { calledAs: edgeCalledAs }),
+                };
+                if (unverifiedEnriched < unverifiedEnrichLimit) {
+                    if (content === null) {
+                        try { content = fs.readFileSync(filePath, 'utf-8'); }
+                        catch (e) { content = ''; }
+                    }
+                    const enclosing = index.findEnclosingFunction(filePath, call.line, true);
+                    unverifiedEntries.push({
+                        ...base,
+                        content: getLine(content, call.line),
+                        callerName: enclosing ? enclosing.name : null,
+                        callerFile: enclosing ? filePath : null,
+                        callerStartLine: enclosing ? enclosing.startLine : null,
+                        callerEndLine: enclosing ? enclosing.endLine : null,
+                    });
+                    unverifiedEnriched++;
+                } else {
+                    unverifiedEntries.push(base);
+                }
+                continue;
+            }
+            // Tier stamped ONLY under collectAccount so trace/blast/verify
+            // results stay byte-identical. A known type mismatch can never
+            // tier as confirmed, whatever its resolution score says.
+            const tier = collectAccount
+                ? (_evidence && _evidence.typeMismatch ? TIER.UNVERIFIED : tierForResolution(scored.resolution))
+                : undefined;
+            if (enrichedCount >= enrichLimit) {
+                // Push shadow only — no file read needed.
+                shadowEntries.push({
+                    file: filePath,
+                    relativePath: fileEntry.relativePath,
+                    line: call.line,
+                    confidence: scored.confidence,
+                    resolution: scored.resolution,
+                    ...(tier && { tier }),
+                    isMethod: call.isMethod || false,
+                    ...(isFunctionReference && { isFunctionReference: true }),
+                    ...(receiver !== undefined && { receiver }),
+                    ...(receiverType && { receiverType }),
+                    ...(edgeCalledAs && { calledAs: edgeCalledAs }),
+                });
+                continue;
+            }
+            // First time we hit this file's enrichment loop — read the file once.
             if (content === null) {
                 try { content = fs.readFileSync(filePath, 'utf-8'); }
                 catch (e) { content = ''; /* deleted/unreadable; skip enrichment for rest */ break; }
@@ -700,8 +2267,10 @@ function findCallers(index, name, options = {}) {
                 ...(isFunctionReference && { isFunctionReference: true }),
                 ...(receiver !== undefined && { receiver }),
                 ...(receiverType && { receiverType }),
+                ...(edgeCalledAs && { calledAs: edgeCalledAs }),
                 confidence: scored.confidence,
                 resolution: scored.resolution,
+                ...(tier && { tier }),
             });
             enrichedCount++;
         }
@@ -724,6 +2293,29 @@ function findCallers(index, name, options = {}) {
         writable: true,
         configurable: true,
     });
+    // Conservation raw data (collectAccount only): dropped-candidate lines with
+    // reasons, consumed by composeAccount in analysis.js. Non-enumerable so
+    // JSON.stringify of results is unaffected.
+    if (accountRaw) {
+        Object.defineProperty(callers, 'accountRaw', {
+            value: accountRaw,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        // Retained unverified-tier entries, sorted (relativePath, line) per the
+        // output ordering contract.
+        unverifiedEntries.sort((a, b) => {
+            if (a.relativePath !== b.relativePath) return a.relativePath.localeCompare(b.relativePath);
+            return (a.line || 0) - (b.line || 0);
+        });
+        Object.defineProperty(callers, 'unverifiedEntries', {
+            value: unverifiedEntries,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+    }
 
     return callers;
     } finally { index._endOp(); }
@@ -774,6 +2366,66 @@ function findCallees(index, def, options = {}) {
         let selfAttrCalls = null;   // collected for Python self.attr.method() resolution
         let selfMethodCalls = null; // collected for Python self.method() resolution
 
+        // Callee conservation account (trace-down contract): every call record
+        // in the def's scope lands in exactly one bucket — confirmed callee
+        // edge, retained unverified entry (visible, with reason), external/
+        // builtin, excluded-with-reason, or display-filtered. The unit is the
+        // call RECORD (a line may hold several); siteIds (record ordinals)
+        // keep the arithmetic exact when one record yields multiple edges
+        // (same-name overload fan-out). collectAccount-gated: legacy callers
+        // of findCallees (context/about/smart) see byte-identical results.
+        const collectAccount = !!options.collectAccount;
+        const calleeAccount = collectAccount ? {
+            totalSites: 0,
+            confirmed: 0,
+            unverified: 0,
+            external: { count: 0, sample: [] },
+            excluded: { total: 0, byReason: {} },
+            filtered: { count: 0, byReason: {} },
+        } : null;
+        const claimedSiteIds = collectAccount ? new Set() : null;
+        const unverifiedCallees = collectAccount ? new Map() : null; // name|reason -> entry
+        const noteSite = (siteId, bucket, reason, call) => {
+            if (!calleeAccount || claimedSiteIds.has(siteId)) return;
+            claimedSiteIds.add(siteId);
+            if (bucket === 'confirmed') {
+                calleeAccount.confirmed++;
+            } else if (bucket === 'unverified') {
+                calleeAccount.unverified++;
+            } else if (bucket === 'external') {
+                calleeAccount.external.count++;
+                if (call && calleeAccount.external.sample.length < 3) {
+                    calleeAccount.external.sample.push({ name: call.name, line: call.line });
+                }
+            } else if (bucket === 'excluded') {
+                const r = reason || 'excluded';
+                calleeAccount.excluded.total++;
+                if (!calleeAccount.excluded.byReason[r]) calleeAccount.excluded.byReason[r] = 0;
+                calleeAccount.excluded.byReason[r]++;
+            } else if (bucket === 'filtered') {
+                const r = reason || 'filtered';
+                calleeAccount.filtered.count++;
+                if (!calleeAccount.filtered.byReason[r]) calleeAccount.filtered.byReason[r] = 0;
+                calleeAccount.filtered.byReason[r]++;
+            }
+        };
+        // Retain an uncertain/unresolved call as a visible unverified callee
+        // entry (aggregated by name+reason) and claim its site.
+        const noteUnverified = (siteId, call, reason) => {
+            if (!collectAccount || claimedSiteIds.has(siteId)) return;
+            noteSite(siteId, 'unverified', reason, call);
+            const key = `${call.name}|${reason}`;
+            let entry = unverifiedCallees.get(key);
+            if (!entry) {
+                const defs = index.symbols.get(call.name) || [];
+                const owners = defs.filter(s => !NON_CALLABLE_TYPES.has(s.type)).length;
+                entry = { name: call.name, reason, callCount: 0, sites: [], ownerCount: owners };
+                unverifiedCallees.set(key, entry);
+            }
+            entry.callCount++;
+            entry.sites.push(call.line);
+        };
+
         // Build local variable type map for receiver resolution
         // Scans for patterns like: bt = Backtester(...) → bt maps to Backtester
         let localTypes = null;
@@ -783,7 +2435,10 @@ function findCallees(index, def, options = {}) {
             localTypes = _buildTypedLocalTypeMap(index, def, calls);
         }
 
+        let siteOrdinal = -1;
         for (const call of calls) {
+            siteOrdinal++;
+            const siteId = siteOrdinal;
             // Filter to calls within this function's scope
             // Method 1: Direct match via enclosingFunction (fast path for direct calls)
             const isDirectMatch = call.enclosingFunction &&
@@ -796,6 +2451,7 @@ function findCallees(index, def, options = {}) {
             const isNestedCallback = isInRange && !isInInnerSymbol && !isDirectMatch;
 
             if (!isDirectMatch && !isNestedCallback) continue;
+            if (calleeAccount) calleeAccount.totalSites++;
 
             // Smart method call handling:
             // - Go: include all method calls (Go doesn't use this/self/cls)
@@ -839,9 +2495,15 @@ function findCallees(index, def, options = {}) {
                         const existing = callees.get(key);
                         if (existing) {
                             existing.count += 1;
+                            if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                         } else {
-                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                                ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
                         }
+                    } else if (collectAccount) {
+                        // Locally-typed receiver, but the type defines no such
+                        // method in the index — visible, never silently dropped.
+                        noteUnverified(siteId, call, 'uncertain-receiver');
                     }
                     continue;
                 } else if (call.receiverType) {
@@ -875,8 +2537,10 @@ function findCallees(index, def, options = {}) {
                         const existing = callees.get(key);
                         if (existing) {
                             existing.count += 1;
+                            if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                         } else {
-                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                                ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
                         }
                         continue;
                     }
@@ -924,22 +2588,29 @@ function findCallees(index, def, options = {}) {
                                 const existing = callees.get(key);
                                 if (existing) {
                                     existing.count += 1;
+                                    if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                                 } else {
-                                    callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                                    callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                                        ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
                                 }
                                 continue;
                             }
                         }
                         // Import resolved but no project definition matches — external call, skip
+                        noteSite(siteId, 'external', null, call);
                         continue;
                     }
                 } else if (langTraits(language)?.methodCallInclusion === 'explicit' && !options.includeMethods) {
+                    noteSite(siteId, 'filtered', 'method-calls-excluded', call);
                     continue;
                 }
             }
 
             // Skip keywords and built-ins
-            if (index.isKeyword(call.name, language)) continue;
+            if (index.isKeyword(call.name, language)) {
+                noteSite(siteId, 'external', null, call);
+                continue;
+            }
 
             // Use resolved name (from alias tracking) if available
             // For multi-target aliases (ternary), pick the first that exists in symbol table
@@ -959,11 +2630,15 @@ function findCallees(index, def, options = {}) {
                 const syms = index.symbols.get(effectiveName);
                 if (!syms || !syms.some(s =>
                     ['function', 'method', 'constructor', 'static', 'public', 'abstract'].includes(s.type))) {
+                    // Argument-position name with no function definition — a
+                    // local variable or data, positively not a callee edge.
+                    noteSite(siteId, 'excluded', 'callback-no-evidence', call);
                     continue;
                 }
                 const hasBinding = fileEntry?.bindings?.some(b => b.name === call.name);
                 const inSameFile = syms.some(s => s.file === def.file);
                 if (!hasBinding && !inSameFile) {
+                    noteSite(siteId, 'excluded', 'callback-no-evidence', call);
                     continue;
                 }
             }
@@ -971,21 +2646,21 @@ function findCallees(index, def, options = {}) {
             // Collect selfAttribute calls for second-pass resolution
             if (call.selfAttribute && language === 'python') {
                 if (!selfAttrCalls) selfAttrCalls = [];
-                selfAttrCalls.push(call);
+                selfAttrCalls.push({ call, siteId });
                 continue;
             }
 
             // Collect self/this.method() calls for same-class resolution
             if (call.isMethod && ['self', 'cls', 'this'].includes(call.receiver)) {
                 if (!selfMethodCalls) selfMethodCalls = [];
-                selfMethodCalls.push(call);
+                selfMethodCalls.push({ call, siteId });
                 continue;
             }
 
             // Collect super().method() calls for parent-class resolution
             if (call.isMethod && call.receiver === 'super') {
                 if (!selfMethodCalls) selfMethodCalls = [];
-                selfMethodCalls.push(call);
+                selfMethodCalls.push({ call, siteId });
                 continue;
             }
 
@@ -993,6 +2668,7 @@ function findCallees(index, def, options = {}) {
             let calleeKey = call.bindingId || effectiveName;
             let bindingResolved = call.bindingId;
             let isUncertain = call.uncertain;
+            let uncertainReason = null; // account-mode reason for the unverified bucket
             if (!call.bindingId && fileEntry?.bindings) {
                 let bindings = fileEntry.bindings.filter(b => b.name === call.name);
                 // For Go, also check sibling files in same directory (same package scope)
@@ -1043,9 +2719,11 @@ function findCallees(index, def, options = {}) {
                                     bindingResolved = matchingDef.bindingId;
                                 } else {
                                     isUncertain = true;
+                                    uncertainReason = 'method-ambiguous';
                                 }
                             } else {
                                 isUncertain = true;
+                                uncertainReason = 'method-ambiguous';
                             }
                         }
                     }
@@ -1072,22 +2750,49 @@ function findCallees(index, def, options = {}) {
                 } else if (bindings.length > 1) {
                     if (call.name === def.name) {
                         // Calling same-name function (e.g., Java overloads)
-                        // Add ALL other overloads as potential callees
-                        const otherBindings = bindings.filter(b =>
+                        // Add ALL other overloads as potential callees.
+                        // A RECEIVER-QUALIFIED same-name call names its type
+                        // (Rust `Patterns::from_low_args(...)`, Go `T.M(...)`)
+                        // — resolve to the matching class's binding instead of
+                        // spraying every same-name def (#223, ripgrep-measured
+                        // on the callee eval arm: HiArgs::from_low_args calls
+                        // three sibling types' from_low_args — every def was
+                        // claimed at all three sites). Variable receivers match
+                        // no class → unchanged full fan-out; bare calls (Java
+                        // implicit-this overloads) keep fanning out.
+                        let otherBindings = bindings.filter(b =>
                             b.startLine !== def.startLine
                         );
+                        const fanReceiver = call.receiver || call.receiverType;
+                        if (fanReceiver && otherBindings.length > 1) {
+                            const symsForName = index.symbols.get(call.name) || [];
+                            const classMatched = otherBindings.filter(b => {
+                                const bSym = symsForName.find(s => s.bindingId === b.id);
+                                const cls = bSym && (bSym.className ||
+                                    (bSym.receiver && bSym.receiver.replace(/^\*/, '')));
+                                return cls === fanReceiver;
+                            });
+                            if (classMatched.length > 0) otherBindings = classMatched;
+                        }
                         for (const ob of otherBindings) {
                             const existing = callees.get(ob.id);
                             if (existing) {
                                 existing.count += 1;
+                                if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                             } else {
                                 callees.set(ob.id, {
                                     name: effectiveName,
                                     bindingId: ob.id,
-                                    count: 1
+                                    count: 1,
+                                    ...(collectAccount && { sites: [call.line], siteIds: [siteId] })
                                 });
                             }
                         }
+                        if (otherBindings.length === 0) {
+                            // All same-name bindings are the def itself — a
+                            // recursive self-call, never a callee edge.
+                            noteSite(siteId, 'excluded', 'self-recursion', call);
+                        }
                         continue; // Already added all overloads, skip normal add
                     } else if (def.className && !call.isMethod) {
                         // Implicit same-class call (Java: execute() means this.execute())
@@ -1107,9 +2812,11 @@ function findCallees(index, def, options = {}) {
                                 }
                             } else {
                                 isUncertain = true;
+                                uncertainReason = 'binding-ambiguous';
                             }
                         } else {
                             isUncertain = true;
+                            uncertainReason = 'binding-ambiguous';
                         }
                     } else {
                         // Try to resolve to a binding defined within the parent function's
@@ -1122,25 +2829,47 @@ function findCallees(index, def, options = {}) {
                             calleeKey = bindingResolved;
                         } else {
                             isUncertain = true;
+                            uncertainReason = 'binding-ambiguous';
                         }
                     }
                 }
             }
 
-            if (isUncertain && !options.includeUncertain) {
-                if (options.stats) options.stats.uncertain = (options.stats.uncertain || 0) + 1;
-                continue;
+            if (isUncertain) {
+                if (collectAccount) {
+                    // Contract mode: uncertain callee edges are never silently
+                    // dropped NOR silently confirmed — visible unverified
+                    // entries with a reason. --include-uncertain is an implied
+                    // no-op here (the caller-contract precedent).
+                    if (options.stats) options.stats.uncertain = (options.stats.uncertain || 0) + 1;
+                    noteUnverified(siteId, call, uncertainReason || 'uncertain-receiver');
+                    continue;
+                }
+                if (!options.includeUncertain) {
+                    if (options.stats) options.stats.uncertain = (options.stats.uncertain || 0) + 1;
+                    continue;
+                }
             }
 
             const existing = callees.get(calleeKey);
             if (existing) {
                 existing.count += 1;
+                if (collectAccount) {
+                    existing.sites.push(call.line);
+                    existing.siteIds.push(siteId);
+                    if (call.isPotentialCallback || call.isFunctionReference) existing.isFunctionReference = true;
+                }
             } else {
                 callees.set(calleeKey, {
                     name: effectiveName,
                     bindingId: bindingResolved,
                     count: 1,
-                    ...(call.isConstructor && { isConstructor: true })
+                    ...(call.isConstructor && { isConstructor: true }),
+                    ...(collectAccount && {
+                        sites: [call.line],
+                        siteIds: [siteId],
+                        ...((call.isPotentialCallback || call.isFunctionReference) && { isFunctionReference: true }),
+                    })
                 });
             }
         }
@@ -1149,7 +2878,7 @@ function findCallees(index, def, options = {}) {
         // Respect includeMethods=false — skip self/this method resolution entirely
         if (selfAttrCalls && def.className && options.includeMethods !== false) {
             const attrTypes = getInstanceAttributeTypes(index, def.file, def.className);
-            for (const call of selfAttrCalls) {
+            for (const { call, siteId } of selfAttrCalls) {
                     let targetClass = attrTypes ? attrTypes.get(call.selfAttribute) : null;
                     // Unique method heuristic: if attr type unknown but method exists on exactly one class
                     if (!targetClass) {
@@ -1164,36 +2893,45 @@ function findCallees(index, def, options = {}) {
                             }
                         }
                     }
-                    if (!targetClass) continue;
+                    if (!targetClass) { noteUnverified(siteId, call, 'self-attr-unresolved'); continue; }
 
                     // Find method in symbol table where className matches
                     const symbols = index.symbols.get(call.name);
-                    if (!symbols) continue;
+                    if (!symbols) { noteUnverified(siteId, call, 'self-attr-unresolved'); continue; }
 
                     const match = symbols.find(s => s.className === targetClass);
-                    if (!match) continue;
+                    if (!match) { noteUnverified(siteId, call, 'self-attr-unresolved'); continue; }
 
                     const key = match.bindingId || `${targetClass}.${call.name}`;
                     const existing = callees.get(key);
                     if (existing) {
                         existing.count += 1;
+                        if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                     } else {
                         callees.set(key, {
                             name: call.name,
                             bindingId: match.bindingId,
-                            count: 1
+                            count: 1,
+                            ...(collectAccount && { sites: [call.line], siteIds: [siteId] })
                         });
                     }
                 }
+        } else if (selfAttrCalls && collectAccount) {
+            // Pass skipped (no class context, or methods display-filtered):
+            // claim the sites so the account stays conserved.
+            for (const { call, siteId } of selfAttrCalls) {
+                if (options.includeMethods === false) noteSite(siteId, 'filtered', 'method-calls-excluded', call);
+                else noteUnverified(siteId, call, 'self-attr-unresolved');
+            }
         }
 
         // Third pass: resolve self/this/super.method() calls to same-class or parent methods
         // Falls back to walking the inheritance chain if not found in same class
         // Respect includeMethods=false — skip self/this method resolution entirely
         if (selfMethodCalls && def.className && options.includeMethods !== false) {
-            for (const call of selfMethodCalls) {
+            for (const { call, siteId } of selfMethodCalls) {
                 const symbols = index.symbols.get(call.name);
-                if (!symbols) continue;
+                if (!symbols) { noteUnverified(siteId, call, 'inherited-unresolved'); continue; }
 
                 // For super().method(), skip same-class — start from parent
                 let match = call.receiver === 'super'
@@ -1221,20 +2959,27 @@ function findCallees(index, def, options = {}) {
                     }
                 }
 
-                if (!match) continue;
+                if (!match) { noteUnverified(siteId, call, 'inherited-unresolved'); continue; }
 
                 const key = match.bindingId || `${match.className}.${call.name}`;
                 const existing = callees.get(key);
                 if (existing) {
                     existing.count += 1;
+                    if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
                 } else {
                     callees.set(key, {
                         name: call.name,
                         bindingId: match.bindingId,
-                        count: 1
+                        count: 1,
+                        ...(collectAccount && { sites: [call.line], siteIds: [siteId] })
                     });
                 }
             }
+        } else if (selfMethodCalls && collectAccount) {
+            for (const { call, siteId } of selfMethodCalls) {
+                if (options.includeMethods === false) noteSite(siteId, 'filtered', 'method-calls-excluded', call);
+                else noteUnverified(siteId, call, 'inherited-unresolved');
+            }
         }
 
         // Look up each callee in the symbol table
@@ -1248,9 +2993,21 @@ function findCallees(index, def, options = {}) {
         // Pre-compute import graph for callee confidence scoring
         const callerImportSet = index.importGraph.get(def.file) || new Set();
 
-        for (const { name: calleeName, bindingId, count, isConstructor } of callees.values()) {
+        for (const { name: calleeName, bindingId, count, isConstructor, sites, siteIds, isFunctionReference } of callees.values()) {
+            const claimSites = (bucket, reason) => {
+                if (!collectAccount || !siteIds) return;
+                for (let i = 0; i < siteIds.length; i++) {
+                    noteSite(siteIds[i], bucket, reason, { name: calleeName, line: sites[i] });
+                }
+            };
             const symbols = index.symbols.get(calleeName);
-            if (symbols && symbols.length > 0) {
+            if (!symbols || symbols.length === 0) {
+                // Name not in the symbol table — external library, builtin, or
+                // unindexed code. Visible in the callee account, not an edge.
+                claimSites('external', null);
+                continue;
+            }
+            if (symbols.length > 0) {
                 let callee = symbols[0];
 
                 // If we have a binding ID, find the exact matching symbol
@@ -1348,7 +3105,10 @@ function findCallees(index, def, options = {}) {
                     const isFuncField = callee.type === 'field' && callee.fieldType &&
                         /^func\b/.test(callee.fieldType);
                     // Constructor calls (new Foo()) are always callable regardless of type
-                    if (!isFuncField && !isConstructor) continue;
+                    if (!isFuncField && !isConstructor) {
+                        claimSites('excluded', 'non-callable-shadow');
+                        continue;
+                    }
                 }
 
                 // Skip test-file callees when caller is production code and
@@ -1356,6 +3116,7 @@ function findCallees(index, def, options = {}) {
                 if (!callerIsTest && !bindingId) {
                     const calleeFileEntry = index.files.get(callee.file);
                     if (calleeFileEntry && isTestFile(calleeFileEntry.relativePath, calleeFileEntry.language)) {
+                        claimSites('excluded', 'test-file-no-import-link');
                         continue;
                     }
                 }
@@ -1366,12 +3127,18 @@ function findCallees(index, def, options = {}) {
                         (callee.file === def.file) || callerImportSet.has(callee.file),
                     isUncertain: false, // uncertain callees already filtered above
                 });
+                claimSites('confirmed', null);
                 result.push({
                     ...callee,
                     callCount: count,
                     weight: index.calculateWeight(count),
                     confidence: calleeScored.confidence,
                     resolution: calleeScored.resolution,
+                    ...(collectAccount && {
+                        tier: TIER.CONFIRMED,
+                        sites: [...sites].sort((a, b) => a - b),
+                        ...(isFunctionReference && { functionReference: true }),
+                    }),
                 });
             }
         }
@@ -1379,6 +3146,24 @@ function findCallees(index, def, options = {}) {
         // Sort by call count (core dependencies first)
         result.sort((a, b) => b.callCount - a.callCount);
 
+        if (calleeAccount) {
+            const claimed = calleeAccount.confirmed + calleeAccount.unverified +
+                calleeAccount.external.count + calleeAccount.excluded.total +
+                calleeAccount.filtered.count;
+            calleeAccount.unaccounted = calleeAccount.totalSites - claimed;
+            calleeAccount.conserved = calleeAccount.unaccounted === 0;
+            // Stable ordering (output contract): by name, then reason.
+            const unverifiedList = [...unverifiedCallees.values()]
+                .map(e => ({ ...e, sites: [...e.sites].sort((a, b) => a - b) }))
+                .sort((a, b) => a.name.localeCompare(b.name) || a.reason.localeCompare(b.reason));
+            Object.defineProperty(result, 'calleeAccount', {
+                value: calleeAccount, enumerable: false, writable: true, configurable: true,
+            });
+            Object.defineProperty(result, 'unverifiedCallees', {
+                value: unverifiedList, enumerable: false, writable: true, configurable: true,
+            });
+        }
+
         return result;
     } catch (e) {
         // Expected: file read/parse failures (minified, binary, buffer exceeded).
@@ -1491,6 +3276,1483 @@ function _buildLocalTypeMap(index, def, calls) {
  * variable types for method resolution. Not used by JS/TS/Python -- structural
  * languages use import evidence via _buildLocalTypeMap instead.
  */
+/**
+ * Single concrete type name from a return-annotation STRING (symbols store
+ * returnType as text). Conservative: ambiguous shapes return undefined.
+ * Handles: Foo · pkg.Foo · "Foo" · Foo | None · Optional[Foo] · Promise<Foo> ·
+ * list[Item] (→ list — the value IS a list) · Foo<T> / Foo[T] (→ Foo).
+ */
+function _typeNameFromReturnAnnotation(text) {
+    if (!text || typeof text !== 'string') return undefined;
+    let t = text.trim().replace(/^["']|["']$/g, '').trim();
+    // X | None / X | null / X | undefined → X (single real member only)
+    if (t.includes('|')) {
+        const parts = t.split('|').map(s => s.trim())
+            .filter(s => !['None', 'null', 'undefined'].includes(s));
+        if (parts.length !== 1) return undefined;
+        t = parts[0];
+    }
+    // unwrap value-transparent wrappers: Optional[X], Promise<X>, Awaitable[X]
+    let m;
+    while ((m = t.match(/^(?:typing\.)?(Optional|Annotated|Final|Promise|Awaitable)\s*[[<]\s*([^,]+?)\s*[\]>]$/))) {
+        t = m[2].trim();
+    }
+    // generic base: Foo[...] / Foo<...> → Foo (the value is a Foo)
+    m = t.match(/^([\w.]+)\s*[[<]/);
+    if (m) t = m[1];
+    // dotted → last segment; validate a bare identifier remains
+    const last = t.split('.').pop();
+    return /^[A-Za-z_]\w*$/.test(last) ? last : undefined;
+}
+
+/**
+ * Per-file return-type-flow map: variables typed by what the assigned call
+ * returns. Key `${enclosingFnStartLine||''}:${varName}` → [{ line, type,
+ * fromFile? }] (all assignments, so lookups can pick the nearest preceding
+ * one). All producer resolutions are conservative.
+ *
+ * Structural shapes (fix #199 — unchanged):
+ *  - typed-receiver method call: receiverType class (or an ancestor walk is
+ *    NOT attempted — exact className match only) defines the method with a
+ *    return annotation
+ *  - self/this/cls method call: the enclosing class (walking up its
+ *    inheritance chain for inherited methods) defines the method with a
+ *    return annotation
+ *  - plain call with exactly ONE project definition carrying a return annotation
+ *
+ * Nominal shapes (fix #207 — compiler-checked annotations, so resolution
+ * confidence carries; same-named owners must AGREE on the return type):
+ *  - Go package-qualified producer: bb := balancer.Get(n) — defs resolved
+ *    strictly into the imported package (no root-package trust)
+ *  - Rust path producer: let c = Config::load()? — last path segment as the
+ *    impl type; Result/Option unwrap via assignedUnwrap; Self → the impl type
+ *  - Java static producer (typeQualifiedCallStyle 'static'): var c =
+ *    Config.parse(...) — receiver as className
+ *  - plain producer: Go resolves same-package ONLY (an unqualified Go call
+ *    cannot reach another package); Rust/Java add a same-file narrowing on
+ *    top of the global-unique rule
+ * Nominal entries carry fromFile — the TYPE's defining file resolved from
+ * the PRODUCER's scope (_resolveFlowTypeOrigin) — so the #206 identity
+ * discipline resolves the name where the annotation lives, not where the
+ * consuming call happens to be.
+ */
+function _buildReturnTypeFlowMap(index, filePath, calls) {
+    const fileEntry = index.files.get(filePath);
+    const language = fileEntry?.language;
+    const nominal = langTraits(language)?.typeSystem === 'nominal';
+    let map = null;
+    for (const call of calls) {
+        if (!call.assignedTo) continue;
+        let returnType, fromFile, selfClass;
+        if (call.isMethod && call.receiverType) {
+            const defs = index.symbols.get(call.name) || [];
+            if (nominal) {
+                const matches = defs.filter(d => d.className === call.receiverType && d.returnType);
+                if (matches.length > 0 && new Set(matches.map(d => d.returnType)).size === 1) {
+                    returnType = matches[0].returnType;
+                    fromFile = matches[0].file;
+                    selfClass = matches[0].className;
+                }
+            } else {
+                const def = defs.find(d => d.className === call.receiverType && d.returnType);
+                returnType = def && def.returnType;
+            }
+        } else if (call.isMethod && ['self', 'this', 'cls'].includes(call.receiver)) {
+            const enclosing = index.findEnclosingFunction(filePath, call.line, true);
+            let cls = enclosing && enclosing.className;
+            let ctxFile = filePath;
+            const visited = new Set();
+            while (cls && !visited.has(cls)) {
+                visited.add(cls);
+                const def = (index.symbols.get(call.name) || [])
+                    .find(d => d.className === cls && d.returnType);
+                if (def) { returnType = def.returnType; fromFile = def.file; selfClass = cls; break; }
+                const parents = index._getInheritanceParents(cls, ctxFile) || [];
+                const next = parents[0]; // single chain; diamond bases stay untyped
+                if (next && index._resolveClassFile) {
+                    ctxFile = index._resolveClassFile(next, ctxFile) || ctxFile;
+                }
+                cls = next;
+            }
+        } else if (nominal && call.isMethod && call.isPathCall && call.receiver) {
+            // Rust: let c = config::Config::load()? — the last path segment
+            // names the impl type (module-path producers stay untyped)
+            const seg = call.receiver.split('::').pop();
+            const matches = (index.symbols.get(call.name) || [])
+                .filter(d => d.className === seg && d.returnType);
+            if (matches.length > 0 && new Set(matches.map(d => d.returnType)).size === 1) {
+                returnType = matches[0].returnType;
+                fromFile = matches[0].file;
+                selfClass = seg;
+            }
+        } else if (nominal && call.isMethod && call.receiver &&
+            langTraits(language)?.typeQualifiedCallStyle === 'static') {
+            // Java static factory: var c = Config.parse(...) — only sound for
+            // the static call style; a Go receiver named like a type is a
+            // VARIABLE (fix #206 typeQualifiedCallStyle discipline)
+            const matches = (index.symbols.get(call.name) || [])
+                .filter(d => d.className === call.receiver && d.returnType);
+            if (matches.length > 0 && new Set(matches.map(d => d.returnType)).size === 1) {
+                returnType = matches[0].returnType;
+                fromFile = matches[0].file;
+                selfClass = call.receiver;
+            }
+        } else if (nominal && !call.isMethod && call.receiver &&
+            langTraits(language)?.hasReceiverPackageCalls) {
+            // Go package-qualified producer: bb := balancer.Get(n) — Get
+            // resolves IN the imported package (fix #206 name ownership)
+            const cands = (index.symbols.get(call.name) || [])
+                .filter(d => !NON_CALLABLE_TYPES.has(d.type) && d.returnType);
+            const inPkg = fileEntry && _qualifiedProducerDefs(index, fileEntry, call.receiver, cands);
+            if (inPkg && inPkg.length > 0 && new Set(inPkg.map(d => d.returnType)).size === 1) {
+                returnType = inPkg[0].returnType;
+                fromFile = inPkg[0].file;
+            } else {
+                // External producer (fix #220, cobra-measured): the parser
+                // marked this call package-qualified (receiver ∈ imports),
+                // and the package resolves to no project def — the variable's
+                // type was decided OUTSIDE the project (av := reflect.ValueOf).
+                // Not positive evidence for any type, but compiler-grade
+                // evidence AGAINST single-owner confirmation: route visible.
+                // EVERY tuple element is external-decided (tmpFile, err := …),
+                // unlike typed flow which pairs only element 0 (#207).
+                const scope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+                if (!map) map = new Map();
+                for (const lhs of [call.assignedTo, ...(call.assignedTupleRest || [])]) {
+                    const key = `${scope}:${lhs}`;
+                    if (!map.has(key)) map.set(key, []);
+                    map.get(key).push({ line: call.line, externalVia: `${call.receiver}.${call.name}` });
+                }
+                continue;
+            }
+        } else if (!nominal && call.isMethod && call.receiver && call.receiverIsModule) {
+            // Structural module-qualified producer (fix #209): schema =
+            // z.string() — the module alias resolves through the file's
+            // import bindings to its file (one re-export hop for barrels),
+            // and the producer's return annotation types the variable.
+            // Standalone exports only (className-less): a module attr is
+            // never a class method.
+            const binding = (fileEntry?.importBindings || []).find(b => b.name === call.receiver);
+            const rel = binding && fileEntry.moduleResolved && fileEntry.moduleResolved[binding.module];
+            if (binding && !rel) {
+                // External module producer (fix #222, httpx-measured — the
+                // #220 Go external-producer rule for structural languages):
+                // logger = logging.getLogger(...) / thread = threading.Thread()
+                // types the variable OUTSIDE the project, so unique project
+                // ownership of a later method name (logger.info vs the only
+                // project `info`) is not identity evidence. Same externality
+                // test as #209 module ownership: relative or project-ish
+                // modules are resolver gaps, never externality evidence.
+                const mod = String(binding.module);
+                const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                if (!mod.startsWith('.') &&
+                    !(firstSeg && _projectTopLevelNames(index).has(firstSeg))) {
+                    const scope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+                    if (!map) map = new Map();
+                    const key = `${scope}:${call.assignedTo}`;
+                    if (!map.has(key)) map.set(key, []);
+                    map.get(key).push({ line: call.line, externalVia: `${call.receiver}.${call.name}` });
+                }
+                continue;
+            }
+            if (rel) {
+                const modFile = path.join(index.root, rel);
+                const cands = (index.symbols.get(call.name) || [])
+                    .filter(d => !NON_CALLABLE_TYPES.has(d.type) && d.returnType && !d.className);
+                let matches = cands.filter(d => d.file === modFile);
+                if (matches.length === 0) {
+                    const hop = index.importGraph.get(modFile);
+                    if (hop) matches = cands.filter(d => hop.has(d.file));
+                }
+                if (matches.length > 0 && new Set(matches.map(d => d.returnType)).size === 1) {
+                    returnType = matches[0].returnType;
+                }
+            }
+        } else if (!call.isMethod && !call.receiver) {
+            const defs = (index.symbols.get(call.name) || [])
+                .filter(d => !NON_CALLABLE_TYPES.has(d.type));
+            let chosen = null;
+            if (nominal && langTraits(language)?.packageScope === 'directory') {
+                // Go: an unqualified call resolves within the package — a
+                // globally-unique def in ANOTHER package is unreachable
+                const dir = path.dirname(filePath);
+                const samePkg = defs.filter(d => d.file && path.dirname(d.file) === dir);
+                if (samePkg.length === 1) chosen = samePkg[0];
+            } else if (defs.length === 1) {
+                chosen = defs[0];
+            } else if (nominal && defs.length > 1) {
+                const sameFile = defs.filter(d => d.file === filePath);
+                if (sameFile.length === 1) chosen = sameFile[0];
+            }
+            if (chosen) { returnType = chosen.returnType; fromFile = chosen.file; }
+        }
+        if (!returnType) continue;
+        let typeName, entryFromFile;
+        if (nominal) {
+            const parsed = _returnTypeNameNominal(returnType, language, {
+                unwrapped: call.assignedUnwrap, tuple: call.assignedTuple, selfClass,
+            });
+            if (!parsed) continue;
+            const origin = _resolveFlowTypeOrigin(index, fromFile || filePath, parsed.name, parsed.qualifier);
+            if (!origin) continue; // identity unpinnable — don't type at all
+            typeName = parsed.name;
+            entryFromFile = origin.fromFile;
+        } else {
+            typeName = _typeNameFromReturnAnnotation(returnType);
+        }
+        if (!typeName) continue;
+        const scope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+        const key = `${scope}:${call.assignedTo}`;
+        if (!map) map = new Map();
+        if (!map.has(key)) map.set(key, []);
+        map.get(key).push({ line: call.line, type: typeName,
+            ...(entryFromFile && { fromFile: entryFromFile }) });
+    }
+    return map;
+}
+
+/** Nearest preceding flow assignment for this call's receiver (fn scope, then module). */
+function _lookupReturnTypeFlow(map, call) {
+    const fnScope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+    for (const scope of fnScope === '' ? [''] : [fnScope, '']) {
+        const entries = map.get(`${scope}:${call.receiver}`);
+        if (!entries) continue;
+        let best = null;
+        for (const e of entries) {
+            if (e.line < call.line && (!best || e.line > best.line)) best = e;
+        }
+        if (best) return best;
+    }
+    return undefined;
+}
+
+// Return-annotation names that must never type a receiver in nominal flow:
+// builtin interfaces/primitives whose project implementors UCN cannot see —
+// a receiver typed `error` CAN dispatch into a project type's Error() method,
+// so excluding on it would lose true edges. (Rust primitives are safe: project
+// extension impls put the primitive name in dispatchTargetTypes.)
+const _GO_FLOW_REJECT = new Set([
+    'error', 'any', 'string', 'bool', 'byte', 'rune', 'uintptr',
+    'int', 'int8', 'int16', 'int32', 'int64',
+    'uint', 'uint8', 'uint16', 'uint32', 'uint64',
+    'float32', 'float64', 'complex64', 'complex128',
+]);
+const _JAVA_FLOW_REJECT = new Set([
+    'Object', 'void', 'int', 'long', 'short', 'byte', 'char',
+    'boolean', 'float', 'double', 'var',
+]);
+
+/** Split generic-argument text on commas at angle/paren/bracket depth 0. */
+function _splitTopLevelGenericArgs(s) {
+    const out = [];
+    let depth = 0, cur = '';
+    for (const ch of s) {
+        if (ch === '<' || ch === '(' || ch === '[') depth++;
+        else if (ch === '>' || ch === ')' || ch === ']') depth--;
+        if (ch === ',' && depth === 0) { out.push(cur); cur = ''; }
+        else cur += ch;
+    }
+    out.push(cur);
+    return out;
+}
+
+/**
+ * Single concrete type name from a NOMINAL return annotation (fix #207).
+ * Returns { name, qualifier } or undefined. Conservative: ambiguous or
+ * non-nominal shapes (slices, maps, chans, fn types, dyn/impl traits,
+ * generic type params, builtin interfaces) return undefined.
+ *  - Go: `*Builder` → Builder; tuple `(T, error)` pairs its FIRST element
+ *    with a tuple-unpacking assignment (`v, err := f()`) — tuple/assignment
+ *    shapes must agree or the parse is wrong; `pkg.Type` keeps the qualifier
+ *  - Rust: Self → the impl type; Result<T,_>/Option<T> unwrap ONLY under
+ *    assignedUnwrap (`?` / .unwrap() / .expect()); Box/Rc/Arc auto-deref via
+ *    _normalizeFieldTypeName
+ *  - Java: plain names and generic bases via _normalizeFieldTypeName
+ */
+function _returnTypeNameNominal(text, language, opts = {}) {
+    if (!text || typeof text !== 'string') return undefined;
+    let t = text.trim();
+    if (language === 'go') {
+        if (t.startsWith('(')) {
+            if (!opts.tuple) return undefined;
+            const inner = t.slice(1, -1);
+            if (inner.includes('func(') || inner.includes('func (')) return undefined;
+            const first = inner.split(',')[0].trim();
+            const parts = first.split(/\s+/);
+            t = parts[parts.length - 1]; // named return `n int` → int
+        } else if (opts.tuple) {
+            return undefined; // v, err := f() needs a multi-return producer
+        }
+    } else if (opts.tuple) {
+        return undefined;
+    }
+    if (language === 'rust') {
+        if (/^&?\s*(mut\s+)?Self$/.test(t)) {
+            return opts.selfClass ? { name: opts.selfClass } : undefined;
+        }
+        if (opts.unwrapped) {
+            const m = t.match(/^(?:[A-Za-z_][A-Za-z0-9_]*\s*::\s*)*(Result|Option)\s*<(.*)>$/s);
+            if (!m) return undefined; // unwrap on a non-Result/Option annotation — alias or parse gap
+            t = (_splitTopLevelGenericArgs(m[2])[0] || '').trim();
+            if (/^&?\s*(mut\s+)?Self$/.test(t)) {
+                return opts.selfClass ? { name: opts.selfClass } : undefined;
+            }
+        }
+    } else if (opts.unwrapped) {
+        return undefined;
+    }
+    // Qualifier survives only the Go shape (`pkg.Type`); Rust paths and Java
+    // dotted names lose theirs in normalization — capture it first.
+    let qualifier;
+    if (language === 'go') {
+        const qm = t.replace(/^\*+/, '').match(/^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/);
+        if (qm) qualifier = qm[1];
+    } else {
+        const stripped = t.replace(/^&+\s*/, '').replace(/^mut\s+/, '');
+        if (/^[A-Za-z_$][\w$]*\s*(::|\.)/.test(stripped)) qualifier = '<unresolvable>';
+    }
+    const norm = _normalizeFieldTypeName(t, language);
+    if (!norm) return undefined;
+    if (/^[A-Z][A-Z0-9]?$/.test(norm)) return undefined; // generic type param (T, K, V1)
+    if (language === 'go' && _GO_FLOW_REJECT.has(norm)) return undefined;
+    if (language === 'java' && _JAVA_FLOW_REJECT.has(norm)) return undefined;
+    return { name: norm, qualifier };
+}
+
+/**
+ * Pin a flow type name to its defining file from the PRODUCER's scope
+ * (fix #207 — the #206 identity lesson applied to annotations: `Builder` in
+ * balancer/base.go means balancer.Builder; resolving it from the consuming
+ * file's scope could hit an unrelated same-name type). Returns { fromFile }
+ * or null when identity cannot be pinned:
+ *  - Go-qualified (`pkg.Type`): the qualifier must resolve through the
+ *    producer's imports to exactly one project package — else null
+ *  - Rust/Java-qualified annotations: external paths — only acceptable when
+ *    NO project type shares the name (the name then can't conflate)
+ *  - unqualified: same file → same dir → import edge; unique-anywhere is NOT
+ *    trusted (a use/import of an external type can shadow it invisibly)
+ *  - no project type def at all: external name — safe, can't conflate
+ */
+function _resolveFlowTypeOrigin(index, producerFile, typeName, qualifier) {
+    const typeDefs = (index.symbols.get(typeName) || [])
+        .filter(d => IDENTITY_TYPE_KINDS.has(d.type) && d.file);
+    if (typeDefs.length === 0) return { fromFile: producerFile };
+    if (qualifier === '<unresolvable>') return null;
+    if (qualifier) {
+        const fe = index.files.get(producerFile);
+        const inPkg = fe && _qualifiedProducerDefs(index, fe, qualifier, typeDefs);
+        if (inPkg && inPkg.length > 0 && new Set(inPkg.map(d => d.file)).size === 1) {
+            return { fromFile: inPkg[0].file };
+        }
+        return null;
+    }
+    const sameFile = typeDefs.find(d => d.file === producerFile);
+    if (sameFile) return { fromFile: sameFile.file };
+    const dir = path.dirname(producerFile);
+    const sameDir = typeDefs.filter(d => path.dirname(d.file) === dir);
+    if (sameDir.length === 1) return { fromFile: sameDir[0].file };
+    if (sameDir.length > 1) return null;
+    const imports = index.importGraph.get(producerFile);
+    if (imports) {
+        const imported = typeDefs.filter(d => imports.has(d.file));
+        if (imported.length === 1) return { fromFile: imported[0].file };
+    }
+    return null;
+}
+
+/**
+ * Defs that live in the package an import-qualified receiver names, resolved
+ * through the producer file's imports (alias-aware — importNames pairs 1:1
+ * with imports for Go). STRICT counterpart of _receiverPackageResolution:
+ * used for POSITIVE typing (fix #207), so root-package defs ("." — package
+ * identity unverifiable from paths) never match here, while over there they
+ * must never be excluded. Returns null when the receiver names no import.
+ */
+function _qualifiedProducerDefs(index, fileEntry, receiver, defs) {
+    const modules = fileEntry.imports || [];
+    const names = fileEntry.importNames || [];
+    let importModule = null;
+    if (names.length === modules.length) {
+        const i = names.indexOf(receiver);
+        if (i >= 0) importModule = modules[i];
+    }
+    if (!importModule) {
+        importModule = modules.find(mod => {
+            const parts = mod.split('/');
+            const last = parts[parts.length - 1];
+            const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+            return pkgName === receiver;
+        }) || null;
+    }
+    if (!importModule || !importModule.includes('/')) return null;
+    const parts = importModule.split('/');
+    const last = parts[parts.length - 1];
+    const pkgSeg = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+    return defs.filter(d => {
+        if (!d.file) return false;
+        const dir = path.dirname(d.file);
+        const relDir = index.root ? path.relative(index.root, dir) : '';
+        if (!relDir || relDir === '.' || relDir.startsWith('..')) return false;
+        if (importModule === relDir || importModule.endsWith('/' + relDir)) return true;
+        const base = path.basename(dir);
+        return base === pkgSeg || base === receiver;
+    });
+}
+
+// Builtin receiver types from literal/annotation inference (Python builtins,
+// JS globals, TS predefined types). Definitionally not project classes, so a
+// mismatch against a project class target is always positive evidence.
+const BUILTIN_RECEIVER_TYPES = new Set([
+    'dict', 'list', 'set', 'tuple', 'str', 'int', 'float', 'bool', 'bytes', 'frozenset',
+    'Array', 'String', 'Object', 'RegExp', 'Number', 'Boolean', 'Map', 'Set', 'Promise',
+    'WeakMap', 'WeakSet',
+    'string', 'number', 'boolean', 'bigint', 'symbol',
+]);
+
+/**
+ * Can this receiverType justify EXCLUDING a caller (structural languages)?
+ * True for builtins and names that resolve to a project class/struct — types
+ * whose identity and hierarchy UCN tracks. False for type aliases, interfaces,
+ * and external types: those can wrap or alias the target, so a name mismatch
+ * is not evidence against it.
+ */
+function _receiverTypeTrustedForExclusion(index, typeName) {
+    if (BUILTIN_RECEIVER_TYPES.has(typeName)) return true;
+    const defs = index.symbols.get(typeName);
+    return !!defs && defs.some(d => d.type === 'class' || d.type === 'struct');
+}
+
+/**
+ * Resolve which same-name TYPE an unqualified receiver-type name denotes from
+ * a caller file's scope, and compare it against the pinned target's package
+ * (fix #206 — cross-package type-name conflation: grpc-go defines ~20 structs
+ * all named `bb`; a receiver typed `bb` in package leastrequest is not
+ * evidence for cdsbalancer's bb.ParseConfig).
+ *
+ * Nearest-scope resolution: same file → same directory (Go packages, Java
+ * packages, Rust sibling modules) → an import edge to the defining file.
+ *
+ * Returns:
+ *   'target'  — the name resolves to the target's package, or only one type
+ *               definition exists project-wide (name IS identity)
+ *   'other'   — positive evidence it denotes a DIFFERENT same-name type
+ *   'unknown' — several same-name types exist and none is resolvable from
+ *               this file's scope (not evidence either way)
+ */
+/**
+ * Resolve a Go package-qualified receiver to its import module and decide
+ * whether the pinned targets can live in that module's package (fix #206b).
+ * Alias-aware: importNames[i] pairs 1:1 with imports[i] for Go (one package
+ * name per import), so `v3corepb "github.com/.../core/v3"` resolves from the
+ * alias, not the path segment.
+ *
+ * targetInPkg accepts a target whose project-relative directory is a SUFFIX
+ * of the module path (robust when dir names diverge), or whose directory
+ * basename matches the module's package segment / the receiver (conventional
+ * fallback — also covers root-package projects, where relative dir is '').
+ *
+ * Returns null when the receiver names no import (likely a variable).
+ */
+function _receiverPackageResolution(index, fileEntry, receiver, targetDefs) {
+    const modules = fileEntry.imports || [];
+    const names = fileEntry.importNames || [];
+    let importModule = null;
+    if (names.length === modules.length) {
+        const i = names.indexOf(receiver);
+        if (i >= 0) importModule = modules[i];
+    }
+    if (!importModule) {
+        importModule = modules.find(mod => {
+            const parts = mod.split('/');
+            const last = parts[parts.length - 1];
+            const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+            return pkgName === receiver;
+        }) || null;
+    }
+    if (!importModule) return null;
+    if (!importModule.includes('/')) return { importModule, singleSegment: true, targetInPkg: false };
+    const parts = importModule.split('/');
+    const last = parts[parts.length - 1];
+    const pkgSeg = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+    const targetInPkg = targetDefs.some(d => {
+        if (!d.file) return false;
+        const dir = path.dirname(d.file);
+        const relDir = index.root ? path.relative(index.root, dir) : '';
+        // Root-package target: its directory is the clone dir — package
+        // identity is unverifiable from PATHS, and exclusion requires
+        // POSITIVE evidence. go.mod's module line IS that identity (fix
+        // #220, cobra-measured): `exec.Command(...)` on import "os/exec"
+        // can never denote the root package's Command, while the root
+        // self-import `cobra "github.com/spf13/cobra"` matches exactly.
+        // Without a go.mod, never exclude (checkout-dir-name luck).
+        if (!relDir || relDir === '.') {
+            const goMod = findGoModule(index.root);
+            if (goMod && goMod.modulePath) {
+                // index.root may be a subtree of the go.mod root (grpc-go's
+                // internal/xds target): the root package's import path is
+                // modulePath + the subtree's relative path.
+                let effective = goMod.modulePath;
+                const sub = goMod.root && path.relative(goMod.root, index.root);
+                if (sub && sub !== '.' && !sub.startsWith('..')) {
+                    effective = effective + '/' + sub.split(path.sep).join('/');
+                }
+                return importModule === effective;
+            }
+            return true;
+        }
+        if (!relDir.startsWith('..') &&
+            (importModule === relDir || importModule.endsWith('/' + relDir))) return true;
+        const base = path.basename(dir);
+        return base === pkgSeg || base === receiver;
+    });
+    return { importModule, singleSegment: false, targetInPkg };
+}
+
+/**
+ * Name-level export-chain reachability (fix #217, rich-measured: 24 test-file
+ * `render(bar)` calls confirmed against markup.render although the binding
+ * `from .render import render` pins to tests/render.py's OWN def — file-level
+ * _importReaches chased on through console.py's imports).
+ *
+ * A binding of NAME resolved to a module file can only denote a def in a
+ * target file if the NAME itself flows there: through the file being a target
+ * file, a re-export of the name (`export {x} from` / `export * from` /
+ * Python `from .x import name`), or surfaces the chase cannot model. Verdicts:
+ *   'yes'     — some chain reaches a target file (confirmable, as before)
+ *   'no'      — every chain terminates away from the targets (exclusion-grade:
+ *               the bare name provably denotes a different def)
+ *   'unknown' — un-modelable surface on a live path: CJS exports (assignment-
+ *               based, attribute re-exports indistinguishable from local
+ *               values), star imports, module-scope assignments of the name,
+ *               module-level __getattr__ (PEP 562), unresolved project-ish
+ *               modules, depth exhaustion. Never exclusion evidence.
+ * Pinned targets are defs NAMED `name`, so single renames along the chain
+ * cannot fool a 'no' (a rename changes the exposed attribute name; re-renames
+ * back to the original route through records this chase follows or flags).
+ */
+function _nameBindingReaches(index, startAbs, name, targetFiles, maxDepth = 4) {
+    let unknown = false;
+    const visited = new Set();
+    let frontier = [[startAbs, name]];
+    for (let d = 0; d <= maxDepth && frontier.length > 0; d++) {
+        const next = [];
+        for (const [abs, attr] of frontier) {
+            if (targetFiles.has(abs)) return 'yes';
+            const stateKey = `${abs}\x00${attr}`;
+            if (visited.has(stateKey)) continue;
+            visited.add(stateKey);
+            const fe = index.files.get(abs);
+            if (!fe) { unknown = true; continue; }
+
+            const enqueue = (module, nextAttr) => {
+                const rel = fe.moduleResolved && fe.moduleResolved[module];
+                if (!rel) {
+                    // Unresolved: relative or project-ish → resolver gap, not
+                    // a terminal; clearly external → that path pins outside
+                    // the project (dead end, consistent with #209c).
+                    const mod = String(module);
+                    const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                    if (mod.startsWith('.') ||
+                        (firstSeg && _projectTopLevelNames(index).has(firstSeg))) unknown = true;
+                    return;
+                }
+                next.push([path.join(index.root, rel), nextAttr]);
+            };
+
+            // CJS export surface is assignment-based (`exports.x = require(..).x`,
+            // `module.exports = require(..)`) and recorded indistinguishably from
+            // local values — a CJS file can never produce a definitive dead end.
+            if ((fe.exportDetails || []).some(e => e.type === 'exports' || e.type === 'module.exports')) {
+                unknown = true;
+            }
+            // JS/TS re-export records: `export {x as y} from './src'` exposes y,
+            // chase continues under the SOURCE-side name; `export * from`
+            // exposes everything the source does. `export * as ns from`
+            // (alias on the re-export-all) exposes ONLY `ns` — a module
+            // namespace object, unmodelable when asked for — never the
+            // source's flattened names.
+            for (const e of (fe.exportDetails || [])) {
+                if (!e.source) continue;
+                if (e.type === 're-export' && (e.alias || e.name) === attr) enqueue(e.source, e.name);
+                else if (e.type === 're-export-all') {
+                    if (e.alias) { if (e.alias === attr) unknown = true; }
+                    else enqueue(e.source, attr);
+                }
+            }
+            // Import bindings of the attr (Python re-export idiom `from .x import
+            // name`, JS import-then-export). importBindings store ORIGINAL names;
+            // importAliases is a flat list (pairing to its import lost), so a
+            // renamed import is followed under BOTH its original and local names —
+            // over-following errs toward 'yes'/'unknown', never toward exclusion.
+            const aliases = fe.importAliases || [];
+            for (const b of (fe.importBindings || [])) {
+                const exposed = [b.name, ...aliases.filter(a => a.original === b.name).map(a => a.local)];
+                if (exposed.includes(attr)) enqueue(b.module, b.name);
+            }
+            // Un-modelable name sources on this file:
+            if ((fe.importNames || []).includes('*')) unknown = true;            // star import
+            if ((fe.moduleAssignedNames || []).includes(attr)) unknown = true;   // module-scope `attr = ...`
+            if ((index.symbols.get('__getattr__') || []).some(s => s.file === abs && !s.className)) {
+                unknown = true;                                                  // PEP 562 dynamic attrs
+            }
+        }
+        frontier = next;
+    }
+    if (frontier.length > 0) unknown = true; // depth exhausted with live paths
+    return unknown ? 'unknown' : 'no';
+}
+
+/**
+ * Bounded-depth reachability over the import graph: can `fromAbs` reach any
+ * target file through re-export/import chains? Barrel hierarchies routinely
+ * run 2-3 hops (zod: v4/index → classic/index → schemas), so name-level
+ * module checks must not use a 1-hop budget (fix #209).
+ */
+function _importReaches(index, fromAbs, targetFiles, maxDepth = 4) {
+    if (targetFiles.has(fromAbs)) return true;
+    const visited = new Set([fromAbs]);
+    let frontier = [fromAbs];
+    for (let d = 0; d < maxDepth; d++) {
+        const next = [];
+        for (const f of frontier) {
+            const edges = index.importGraph.get(f);
+            if (!edges) continue;
+            for (const e of edges) {
+                if (visited.has(e)) continue;
+                if (targetFiles.has(e)) return true;
+                visited.add(e);
+                next.push(e);
+            }
+        }
+        if (next.length === 0) break;
+        frontier = next;
+    }
+    return false;
+}
+
+/**
+ * Top-level path segments of the project (dir names + module names of root
+ * files). Used to tell "module failed to resolve because it is EXTERNAL"
+ * from "module failed to resolve because our resolver has a gap" — only the
+ * former is exclusion evidence (fix #209). Memoized on the index.
+ */
+function _projectTopLevelNames(index) {
+    if (index._projectTopLevelNames) return index._projectTopLevelNames;
+    const names = new Set();
+    for (const [, fe] of index.files) {
+        const seg = (fe.relativePath || '').split(/[\\/]/)[0];
+        if (!seg) continue;
+        names.add(seg);
+        const dot = seg.lastIndexOf('.');
+        if (dot > 0) names.add(seg.slice(0, dot)); // utils.py → utils
+    }
+    index._projectTopLevelNames = names;
+    return names;
+}
+
+const IDENTITY_TYPE_KINDS = new Set(['class', 'struct', 'interface', 'trait', 'enum']);
+function _resolveReceiverTypeIdentity(index, filePath, knownType, targetDefs) {
+    const typeDefs = (index.symbols.get(knownType) || []).filter(d => IDENTITY_TYPE_KINDS.has(d.type));
+    if (typeDefs.length <= 1) return 'target';
+    const targetDirs = new Set(targetDefs.map(d => d.file && path.dirname(d.file)).filter(Boolean));
+    const inTargetPkg = (d) => d.file && targetDirs.has(path.dirname(d.file));
+    const sameFile = typeDefs.filter(d => d.file === filePath);
+    if (sameFile.length > 0) return sameFile.some(inTargetPkg) ? 'target' : 'other';
+    const callerDir = path.dirname(filePath);
+    const sameDir = typeDefs.filter(d => d.file && path.dirname(d.file) === callerDir);
+    if (sameDir.length > 0) return sameDir.some(inTargetPkg) ? 'target' : 'other';
+    const imports = index.importGraph.get(filePath);
+    if (imports) {
+        const imported = typeDefs.filter(d => d.file && imports.has(d.file));
+        if (imported.length > 0) return imported.some(inTargetPkg) ? 'target' : 'other';
+    }
+    return 'unknown';
+}
+
+/**
+ * Is typeName an ancestor (transitively) of any target definition's class?
+ * Used by receiver-class disambiguation: a receiver typed as a SUPERTYPE of
+ * the target's class is not evidence against the target — dynamic dispatch
+ * may run the target override at that site.
+ */
+function _isAncestorOfTargetClass(index, typeName, targetDefs) {
+    const visited = new Set();
+    const queue = [];
+    for (const td of targetDefs) {
+        const cls = td.className || (td.receiver && td.receiver.replace(/^\*/, ''));
+        if (cls) queue.push({ name: cls, file: td.file });
+    }
+    while (queue.length > 0) {
+        const { name, file } = queue.shift();
+        if (visited.has(name)) continue;
+        visited.add(name);
+        const parents = index._getInheritanceParents(name, file) || [];
+        for (const parent of parents) {
+            if (parent === typeName) return true;
+            if (!visited.has(parent)) {
+                const parentFile = index._resolveClassFile ? index._resolveClassFile(parent, file) : file;
+                queue.push({ name: parent, file: parentFile });
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Do two classes share a project descendant (Python #202b guard)? With
+ * multiple inheritance, `self.method()` inside Mixin dispatches through
+ * type(self).__mro__ — a class C(Target, Mixin) looks the method up on
+ * Target BEFORE Mixin, so a sibling-class exclusion is only sound when no
+ * project class inherits from both sides. Conservative: any common
+ * descendant keeps the edge regardless of MRO order.
+ */
+function _collectDescendants(index, className, cap = 256) {
+    const out = new Set([className]);
+    const queue = [className];
+    while (queue.length > 0 && out.size < cap) {
+        const children = index.extendedByGraph?.get(queue.pop());
+        if (!children) continue;
+        for (const child of children) {
+            const cName = typeof child === 'string' ? child : child.name;
+            if (!cName || out.has(cName)) continue;
+            out.add(cName);
+            queue.push(cName);
+        }
+    }
+    return out;
+}
+
+function _shareProjectDescendant(index, className, targetClasses) {
+    if (!targetClasses || targetClasses.size === 0) return false;
+    const mine = _collectDescendants(index, className);
+    for (const t of targetClasses) {
+        const theirs = _collectDescendants(index, t);
+        // matchedClass BELOW the target: every descendant's MRO finds the
+        // matched override before the target (subclass precedes superclass
+        // in C3) — the target def is unreachable from this site, exclusion
+        // stands. Not an MRO trap.
+        if (theirs.has(className)) continue;
+        for (const d of theirs) {
+            if (mine.has(d)) return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Resolve a one-hop field receiver to the field's DECLARED type (fix #202):
+ * rootType.fieldName → the field's declared type from the struct/class body
+ * (Rust/Go/Java parsers emit field members with fieldType). Returns null —
+ * never a wrong type — when: no such field, the declared type doesn't
+ * normalize to a plain nominal name (slices, fn types, wrappers), same-named
+ * classes disagree, or the type is a trait/interface (dynamic dispatch —
+ * a trait-typed field is not evidence against any implementor).
+ */
+function _declaredFieldType(index, rootType, fieldName, language) {
+    const defs = index.symbols.get(fieldName);
+    if (!defs) return null;
+    // 'private field' (JS #-fields, fix #219): equally compiler-true, and
+    // safer — nothing outside the class can rebind them.
+    const fields = defs.filter(d =>
+        (d.type === 'field' || d.memberType === 'field' || d.memberType === 'private field') &&
+        d.className === rootType && d.fieldType);
+    if (fields.length === 0) return null;
+    const normalized = new Set();
+    for (const f of fields) {
+        const t = _normalizeFieldTypeName(f.fieldType, language);
+        if (t) normalized.add(t);
+        else return null; // any un-normalizable declaration → no evidence
+    }
+    if (normalized.size !== 1) return null; // same-named classes disagree
+    const typeName = [...normalized][0];
+    // Generic type parameters by convention (T, K, V1 — fix #220,
+    // cursive-measured): `view: T` declares the field as WHATEVER the
+    // instantiation chose — not a type identity. Without this, the hop
+    // "validated" against Rust blanket impls (`impl<T: ViewWrapper> View
+    // for T` records className 'T'), confirming self.view.layout() for
+    // every wrapper view. A short-caps name with a real project type def
+    // (class A in a fixture) is a class, not a generic param.
+    if (/^[A-Z][A-Z0-9]?$/.test(typeName) &&
+        !(index.symbols.get(typeName) || []).some(d => IDENTITY_TYPE_KINDS.has(d.type))) return null;
+    const typeDefs = index.symbols.get(typeName);
+    if (typeDefs && typeDefs.some(d => d.type === 'trait' || d.type === 'interface')) return null;
+    return typeName;
+}
+
+/**
+ * Can this call's argument count fit any target definition's parameter
+ * range? (Nominal languages only — their compilers enforce arity, so a
+ * mismatch is positive evidence the call binds a different symbol.)
+ * Accepts both the bound form (obj.m(a)) and the unbound/UFCS form
+ * (Type::m(&obj, a) / Class.m(obj, a)) for method targets. Returns true
+ * whenever the signature is unknown, variadic, or the target is not a
+ * plain callable — unknown never excludes.
+ */
+function _callArityCompatible(call, targetDefs, language) {
+    const traits = langTraits(language);
+    const selfNames = new Set((traits?.selfParam || [])
+        .map(s => String(s).replace(/&|mut\s*/g, '').trim()));
+    let sawComparable = false;
+    for (const def of targetDefs) {
+        if (NON_CALLABLE_TYPES.has(def.type)) return true;
+        const ps = def.paramsStructured;
+        if (!Array.isArray(ps)) return true;
+        if (ps.some(p => p && p.rest)) return true;
+        const params = ps.filter((p, i) => !(i === 0 && p &&
+            selfNames.has(String(p.name || '').replace(/&|mut\s*/g, '').trim())));
+        const isMethodDef = !!(def.className || def.receiver);
+        // The receiver-as-first-arg shift applies only to call shapes that
+        // can actually be unbound: Rust UFCS (Type::method(&x)) and Go
+        // method expressions (Type.Method(recv)) — the receiver text IS the
+        // type. Java has no unbound instance-call form.
+        const defType = def.className || (def.receiver || '').replace(/^\*/, '');
+        const unboundForm = call.isPathCall || (!!call.receiver && call.receiver === defType);
+        const max = params.length + (isMethodDef && unboundForm ? 1 : 0);
+        const min = params.filter(p => p && !p.optional && p.default === undefined).length;
+        sawComparable = true;
+        if (langTraits(language)?.packageScope === 'directory') {
+            // Go: f(g()) tuple expansion can fill several params with one
+            // syntactic arg — too-few never excludes, only too-many.
+            if (call.argCount <= max) return true;
+        } else if (call.argCount >= min && call.argCount <= max) {
+            return true;
+        }
+    }
+    return sawComparable ? false : true;
+}
+
+const JAVA_PRIMITIVES = new Set(['int', 'long', 'short', 'byte', 'char', 'float', 'double', 'boolean']);
+
+// Which parameter types a call-site literal kind can bind (Java overload
+// resolution: identity, widening, boxing — plus the boxed types' interfaces).
+// Anything not provably incompatible MATCHES: only certainty excludes.
+const JAVA_KIND_TYPES = {
+    string: ['String', 'CharSequence', 'Comparable', 'Serializable'],
+    char: ['char', 'Character', 'int', 'long', 'float', 'double', 'Comparable', 'Serializable'],
+    int: ['int', 'long', 'float', 'double', 'Integer', 'Number', 'Comparable', 'Serializable'],
+    long: ['long', 'float', 'double', 'Long', 'Number', 'Comparable', 'Serializable'],
+    float: ['float', 'double', 'Float', 'Number', 'Comparable', 'Serializable'],
+    double: ['double', 'Double', 'Number', 'Comparable', 'Serializable'],
+    boolean: ['boolean', 'Boolean', 'Comparable', 'Serializable'],
+};
+
+/**
+ * Can an argument of static kind `kind` (from the Java parser's argKinds)
+ * bind a parameter declared as `paramType`? Unknown kinds ('expr',
+ * 'lambda'), unknown/generic param types, and unresolvable hierarchies all
+ * match — a mismatch must be provable to count.
+ */
+function _javaArgKindMatches(index, kind, paramType) {
+    if (!kind || kind === 'expr' || kind === 'lambda') return true;
+    if (!paramType) return true;
+    const bare = String(paramType).replace(/<.*$/s, '').trim()
+        .replace(/\.\.\.$/, '').replace(/\[\]$/, '').split('.').pop();
+    if (!bare || bare === 'Object') return true;
+    if (/^[A-Z][0-9]?$/.test(bare)) return true; // generic type variable (T, E, K1...)
+    if (kind === 'null') return !JAVA_PRIMITIVES.has(bare);
+    if (kind.startsWith('new:') || kind.startsWith('cast:')) {
+        const t = kind.slice(kind.indexOf(':') + 1);
+        if (t === bare) return true;
+        const tDefs = (index.symbols.get(t) || [])
+            .filter(d => d.type === 'class' || d.type === 'interface');
+        if (tDefs.length === 0) return true; // external arg type — unknowable
+        const asTarget = [{ className: t, file: tDefs[0].file }];
+        if (_isDispatchAncestor(index, bare, asTarget)) return true;
+        // Deny only when t's ancestry is fully project-visible — a chain
+        // that dead-ends external may still reach paramType.
+        return !_targetAncestryFullyResolved(index, asTarget);
+    }
+    const allowed = JAVA_KIND_TYPES[kind];
+    if (!allowed) return true;
+    return allowed.includes(bare);
+}
+
+/** Is overload `def` applicable to this call's static argument shape? */
+function _overloadApplicable(index, call, def) {
+    const ps = def.paramsStructured;
+    if (!Array.isArray(ps)) return true;
+    const hasRest = ps.some(p => p && p.rest);
+    const min = ps.filter(p => p && !p.optional && p.default === undefined && !p.rest).length;
+    if (call.argCount < min) return false;
+    if (!hasRest && call.argCount > ps.length) return false;
+    const kinds = call.argKinds;
+    if (!Array.isArray(kinds)) return true;
+    for (let i = 0; i < kinds.length && i < ps.length; i++) {
+        const p = ps[i];
+        if (!p || p.rest) break;
+        if (!_javaArgKindMatches(index, kinds[i], p.type)) return false;
+    }
+    return true;
+}
+
+/**
+ * Overload discipline (Java): when the pinned target has same-class sibling
+ * overloads, decide what the call site's static argument shape proves.
+ * Returns 'other-overload' (binds a sibling — exclusion evidence),
+ * {ambiguous, candidates} (cannot tell — visible unverified), or null
+ * (no siblings / uniquely the pinned one / model has no opinion).
+ */
+function _overloadDiscipline(index, call, targetDefs, definitions) {
+    const targetOwners = new Set(targetDefs.map(d => d.className).filter(Boolean));
+    if (targetOwners.size === 0) return null;
+    const family = definitions.filter(d => !NON_CALLABLE_TYPES.has(d.type) &&
+        d.className && targetOwners.has(d.className));
+    if (family.length <= 1) return null;
+    const pinnedKeys = new Set(targetDefs.map(d => `${d.file}:${d.startLine}`));
+    if (family.every(d => pinnedKeys.has(`${d.file}:${d.startLine}`))) return null;
+    const applicable = family.filter(d => _overloadApplicable(index, call, d));
+    if (applicable.length === 0) return null; // shape fits nothing we model — no claim
+    const pinnedApplicable = applicable.some(d => pinnedKeys.has(`${d.file}:${d.startLine}`));
+    if (!pinnedApplicable) return 'other-overload';
+    if (applicable.length === 1) return null; // uniquely the pinned overload
+    return { ambiguous: true, candidates: applicable.length };
+}
+
+/**
+ * Build the target type set for receiver-class disambiguation: target
+ * classes/receivers + their non-overriding subtypes (transitively). A Child
+ * receiver calling an inherited Base method IS a caller of Base.method;
+ * children that define the method themselves dispatch to the override.
+ */
+function _buildTargetTypeSet(index, targetDefs, definitions) {
+    const targetTypes = new Set();
+    for (const td of targetDefs) {
+        if (td.className) targetTypes.add(td.className);
+        if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
+    }
+    if (targetTypes.size > 0) {
+        const queue = [...targetTypes];
+        while (queue.length > 0) {
+            const children = index.extendedByGraph?.get(queue.pop());
+            if (!children) continue;
+            for (const child of children) {
+                const cName = typeof child === 'string' ? child : child.name;
+                if (!cName || targetTypes.has(cName)) continue;
+                const overrides = definitions.some(d => d.className === cName);
+                if (overrides) continue;
+                targetTypes.add(cName);
+                queue.push(cName);
+            }
+        }
+    }
+    // Type aliases are the SAME type (Rust `pub type StyledString =
+    // SpannedString<Style>`, Go `type A = B`) — compiler-checked identity,
+    // not a subtype edge. Close over them in BOTH directions: a method on
+    // the base must accept alias-qualified receivers (cursive-measured: 24
+    // StyledString::plain edges wrongly excluded as path-type-mismatch),
+    // and a method on an inherent alias impl must accept base receivers.
+    // Sound only when EVERY type-kind def of the name is an alias agreeing
+    // on one base — a same-name alias to a different type in another
+    // package must not confirm foreign receivers (#206 discipline). The
+    // parser records aliasOf for Rust/Go; names without it never close.
+    if (targetTypes.size > 0) {
+        const aliasPairs = [];
+        for (const [aliasName, defs] of index.symbols) {
+            let base = null;
+            let pure = true;
+            for (const d of defs) {
+                if (d.type !== 'type' && !IDENTITY_TYPE_KINDS.has(d.type)) continue;
+                if (d.type === 'type' && d.aliasOf) {
+                    if (base === null) base = d.aliasOf;
+                    else if (base !== d.aliasOf) { pure = false; break; }
+                } else { pure = false; break; }
+            }
+            if (pure && base) aliasPairs.push([aliasName, base]);
+        }
+        let changed = aliasPairs.length > 0;
+        while (changed) {
+            changed = false;
+            for (const [a, b] of aliasPairs) {
+                if (targetTypes.has(b) && !targetTypes.has(a)) { targetTypes.add(a); changed = true; }
+                if (targetTypes.has(a) && !targetTypes.has(b)) { targetTypes.add(b); changed = true; }
+            }
+        }
+    }
+    return targetTypes;
+}
+
+/**
+ * Can a receiver typed as `typeName` VIRTUALLY dispatch into the target
+ * definition? True when typeName is a project interface/trait that declares
+ * the method or sits above the target's class, or — in languages where every
+ * instance method is virtual (Java) — any supertype of the target. Go struct
+ * embedding binds statically and never qualifies; Go interfaces qualify via
+ * the declares-the-method check (satisfaction is implicit — there is no
+ * recorded edge to walk). Used only to decide possible-dispatch ROUTING
+ * (visible unverified), never to exclude.
+ */
+function _dispatchCapableSupertype(index, language, typeName, targetDefs, definitions) {
+    const traits = langTraits(language);
+    if (traits?.typeSystem !== 'nominal') return false;
+    // The implicit root supertype (Java `Object`) sits above EVERY class
+    // without a declared extends edge — `void show(Object o) { o.size() }`
+    // can dispatch into any project override, but the ancestry walk below
+    // cannot see the implicit edge (fix #212). Bare-name compare on the last
+    // segment covers `java.lang.Object` annotations; a project class that
+    // shadows the root name only ever gains routing (demote-only), never
+    // loses an exclusion it was entitled to.
+    if (traits.universalSupertype &&
+        String(typeName).split('.').pop() === traits.universalSupertype) {
+        return true;
+    }
+    const typeDefs = index.symbols.get(typeName) || [];
+    const isIface = typeDefs.some(d => d.type === 'interface' || d.type === 'trait');
+    if (isIface) {
+        // The interface/trait declares this method → any implementor
+        // (recorded or implicit) may receive the call.
+        if (definitions.some(d => d.className === typeName)) return true;
+        return _isDispatchAncestor(index, typeName, targetDefs);
+    }
+    if (traits.allMethodsVirtual) {
+        return _isDispatchAncestor(index, typeName, targetDefs);
+    }
+    return false;
+}
+
+/**
+ * Like _isAncestorOfTargetClass, but walks `implements` records (Java
+ * implements clauses, Rust `impl Trait for Type` surfaced as implements)
+ * in addition to extends edges — the inheritance graph only stores extends,
+ * yet virtual dispatch flows through interface/trait edges too. Routing
+ * decision only (possible-dispatch vs excluded), never exclusion evidence.
+ */
+function _isDispatchAncestor(index, typeName, targetDefs) {
+    const visited = new Set();
+    const queue = [];
+    for (const td of targetDefs) {
+        const cls = td.className || (td.receiver && td.receiver.replace(/^\*/, ''));
+        if (cls) queue.push({ name: cls, file: td.file });
+    }
+    while (queue.length > 0) {
+        const { name, file } = queue.shift();
+        if (visited.has(name)) continue;
+        visited.add(name);
+        const parents = [
+            ...(index._getInheritanceParents(name, file) || []),
+            ..._implementsParents(index, name),
+        ];
+        for (const parent of parents) {
+            if (parent === typeName) return true;
+            if (!visited.has(parent)) {
+                const parentFile = index._resolveClassFile ? index._resolveClassFile(parent, file) : file;
+                queue.push({ name: parent, file: parentFile });
+            }
+        }
+    }
+    return false;
+}
+
+/** Interface/trait names a class declares it implements (generics stripped). */
+function _implementsParents(index, className) {
+    const defs = index.symbols.get(className);
+    if (!defs) return [];
+    const out = [];
+    for (const d of defs) {
+        if (!Array.isArray(d.implements)) continue;
+        for (const p of d.implements) {
+            const bare = String(p).replace(/<.*$/s, '').trim().split(/[.:]+/).pop();
+            if (bare) out.push(bare);
+        }
+    }
+    return out;
+}
+
+/**
+ * How many same-name method definitions could a call through `via` dispatch
+ * to? Counts distinct owner types among the definitions that sit at or below
+ * `via` (extends edges + implements records). Languages with implicit
+ * interface satisfaction (Go) record no edges at all — fall back to the full
+ * owner count. Display/routing enrichment only ("1 of N implementations").
+ */
+function _countDispatchCandidates(index, via, definitions) {
+    const ownerFiles = new Map(); // owner type -> defining file
+    for (const d of definitions) {
+        if (NON_CALLABLE_TYPES.has(d.type)) continue;
+        const o = d.className || (d.receiver && d.receiver.replace(/^\*/, ''));
+        if (o && !ownerFiles.has(o)) ownerFiles.set(o, d.file);
+    }
+    if (ownerFiles.size === 0) return 0;
+    // Interface/trait owners hold the abstract declaration, not a landing
+    // site — "implementations" counts the concrete methods dispatch can run.
+    const isIface = (o) => (index.symbols.get(o) || [])
+        .some(d => d.type === 'interface' || d.type === 'trait');
+    let count = 0;
+    let concrete = 0;
+    for (const [owner, file] of ownerFiles) {
+        if (isIface(owner)) continue;
+        concrete++;
+        if (owner === via || _isDispatchAncestor(index, via, [{ className: owner, file }])) count++;
+    }
+    // No recorded edges below `via` (Go interfaces are satisfied implicitly)
+    // → any concrete owner is a candidate.
+    return count > 0 ? count : (concrete > 0 ? concrete : ownerFiles.size);
+}
+
+/**
+ * Resolve a one-hop field receiver to a declared project INTERFACE/TRAIT
+ * type — exactly the case _declaredFieldType refuses (a trait-typed field is
+ * not exclusion evidence against any implementor). Dispatch attribution
+ * only: lets the unverified tier say "possible-dispatch via <Interface>".
+ * Rust `dyn Trait` / `Box<dyn Trait>` / `&dyn Trait` resolve to Trait here.
+ */
+function _declaredFieldInterfaceType(index, rootType, fieldName, language) {
+    const defs = index.symbols.get(fieldName);
+    if (!defs) return null;
+    const fields = defs.filter(d =>
+        (d.type === 'field' || d.memberType === 'field') &&
+        d.className === rootType && d.fieldType);
+    if (fields.length === 0) return null;
+    const normalized = new Set();
+    for (const f of fields) {
+        const t = _normalizeFieldTypeName(f.fieldType, language) ||
+            (language === 'rust' ? _normalizeRustDynTypeName(f.fieldType) : null);
+        if (t) normalized.add(t);
+        else return null; // un-normalizable declaration → no attribution
+    }
+    if (normalized.size !== 1) return null; // same-named classes disagree
+    const typeName = [...normalized][0];
+    const typeDefs = index.symbols.get(typeName);
+    if (!typeDefs || !typeDefs.some(d => d.type === 'trait' || d.type === 'interface')) return null;
+    return typeName;
+}
+
+/** Rust dyn-trait declarations: `dyn Flag`, `&dyn Flag`, `Box<dyn Flag>` → Flag. */
+function _normalizeRustDynTypeName(raw) {
+    let t = String(raw).trim();
+    let prev;
+    do {
+        prev = t;
+        t = t.replace(/^&+\s*/, '').replace(/^'[A-Za-z_][A-Za-z0-9_]*\s*/, '').replace(/^mut\s+/, '');
+        const wrap = t.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*<(.*)>$/s);
+        if (wrap && _RUST_DEREF_WRAPPERS.has(wrap[1])) t = wrap[2].trim();
+    } while (t !== prev);
+    const m = t.match(/^dyn\s+([A-Za-z_][A-Za-z0-9_]*(?:\s*::\s*[A-Za-z_][A-Za-z0-9_]*)*)$/s);
+    if (!m) return null;
+    return m[1].split('::').pop().trim();
+}
+
+/**
+ * Is every ancestor in the targets' inheritance closure a project-resolvable
+ * class? A chain that dead-ends at an EXTERNAL ancestor may continue into
+ * supertypes UCN can't see, so absence-of-knownType in the visible chain is
+ * not evidence (fix #202: external-type exclusion gate).
+ */
+function _targetAncestryFullyResolved(index, targetDefs) {
+    const visited = new Set();
+    const queue = [];
+    for (const td of targetDefs) {
+        const cls = td.className || (td.receiver && td.receiver.replace(/^\*/, ''));
+        if (cls) queue.push({ name: cls, file: td.file });
+    }
+    while (queue.length > 0) {
+        const { name, file } = queue.shift();
+        if (visited.has(name)) continue;
+        visited.add(name);
+        const parents = index._getInheritanceParents(name, file) || [];
+        for (const parent of parents) {
+            const defs = index.symbols.get(parent);
+            const isProject = !!defs && defs.some(d =>
+                d.type === 'class' || d.type === 'struct' || d.type === 'interface' || d.type === 'trait');
+            if (!isProject) return false; // external ancestor — chain invisible beyond here
+            if (!visited.has(parent)) {
+                const parentFile = index._resolveClassFile ? index._resolveClassFile(parent, file) : file;
+                queue.push({ name: parent, file: parentFile });
+            }
+        }
+    }
+    return true;
+}
+
+// _externalContractMarker moved to core/shared.js as isOverrideMarked (shared
+// with deadcode's out-of-tree override suppression — one source of truth).
+
+/**
+ * Name of the external contract a marked method implements, for dispatch
+ * attribution ("possible-dispatch via Number — external contract"). Rust
+ * impls name the trait directly; Java/TS/Python derive it from the class's
+ * own extends/implements entries that do NOT resolve to project types.
+ * Returns null when the contract type is not uniquely attributable —
+ * the demotion still applies, only the label loses its `via`.
+ */
+function _externalContractVia(index, def) {
+    if (def.traitName) {
+        // rust `impl fmt::Display for X` → Display (strip path + generics)
+        const bare = String(def.traitName).replace(/<.*$/, '').split('::').pop().trim();
+        return bare || null;
+    }
+    const cls = def.className;
+    if (!cls) return null;
+    const classDefs = (index.symbols.get(cls) || []).filter(d =>
+        d.file === def.file &&
+        (d.type === 'class' || d.type === 'struct' || d.type === 'interface' || d.type === 'trait'));
+    const supers = [];
+    for (const cd of classDefs) {
+        if (cd.extends) supers.push(...(Array.isArray(cd.extends) ? cd.extends : [cd.extends]));
+        if (cd.implements) supers.push(...cd.implements);
+    }
+    const externals = [];
+    for (const raw of supers) {
+        const bare = String(raw).replace(/<.*$/, '').split('.').pop().trim();
+        if (!bare) continue;
+        const defs = index.symbols.get(bare);
+        const isProject = !!defs && defs.some(d =>
+            d.type === 'class' || d.type === 'struct' || d.type === 'interface' || d.type === 'trait');
+        if (!isProject && !externals.includes(bare)) externals.push(bare);
+    }
+    if (externals.length === 1) return externals[0];
+    if (externals.length === 0 && supers.length === 0 &&
+        def.modifiers && def.modifiers.includes('override')) {
+        // java: @Override with no explicit supertypes can only override
+        // java.lang.Object (toString/equals/hashCode) — in compiling code.
+        return 'Object';
+    }
+    return null; // several external candidates — attribution unknowable
+}
+
+/** Rust deref-transparent wrappers: Box<X>/Rc<X>/Arc<X> auto-deref to X for method calls. */
+const _RUST_DEREF_WRAPPERS = new Set(['Box', 'Rc', 'Arc']);
+
+/**
+ * Normalize a declared field type to a bare nominal type name, or null when
+ * the declaration carries no usable single-type evidence.
+ *   rust: `&'a mut ignore::DirEntry` → DirEntry; `Box<DirEntry>` → DirEntry;
+ *         `Box<dyn Flag>`/`dyn Flag`/`impl Trait` → null; tuples/fns → null
+ *   go:   `*ignore.Ig` → Ig; slices/maps/chans/funcs → null
+ *   java: `java.util.List<Foo>` → List; arrays → null
+ */
+function _normalizeFieldTypeName(raw, language) {
+    let t = String(raw).trim();
+    if (language === 'rust') {
+        let prev;
+        do {
+            prev = t;
+            t = t.replace(/^&+\s*/, '').replace(/^'[A-Za-z_][A-Za-z0-9_]*\s*/, '').replace(/^mut\s+/, '');
+        } while (t !== prev);
+        if (/^(dyn|impl)\b/.test(t)) return null;
+        const m = t.match(/^([A-Za-z_][A-Za-z0-9_]*(?:\s*::\s*[A-Za-z_][A-Za-z0-9_]*)*)\s*(?:<(.*)>)?$/s);
+        if (!m) return null;
+        const base = m[1].split('::').pop().trim();
+        if (m[2] !== undefined && _RUST_DEREF_WRAPPERS.has(base)) {
+            return _normalizeFieldTypeName(m[2], 'rust');
+        }
+        return base;
+    }
+    if (language === 'go') {
+        t = t.replace(/^\*+/, '');
+        const m = t.match(/^([A-Za-z_][A-Za-z0-9_]*)(?:\.([A-Za-z_][A-Za-z0-9_]*))?$/);
+        if (!m) return null;
+        return m[2] || m[1];
+    }
+    if (language === 'java') {
+        const m = t.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:<.*>)?$/s);
+        if (!m) return null;
+        return m[1].split('.').pop();
+    }
+    if (langTraits(language)?.typeSystem === 'structural') {
+        // JS/TS/Python (fix #219): compiler-true annotation heads, value-
+        // position semantics — a field declared Promise<X> HOLDS a Promise.
+        return _structuralTypeHead(t);
+    }
+    return null;
+}
+
+// typing-module aliases for builtin containers — normalized to the runtime
+// type so BUILTIN_RECEIVER_TYPES and the trust gate see one name.
+const _PY_TYPING_BUILTINS = {
+    Dict: 'dict', List: 'list', Set: 'set', Tuple: 'tuple',
+    FrozenSet: 'frozenset', Text: 'str',
+};
+
+/**
+ * Single concrete type name from a STRUCTURAL annotation in value position
+ * (fix #219): field declarations and chained-receiver producer returns.
+ * Unlike _typeNameFromReturnAnnotation, Promise/Awaitable are NOT unwrapped
+ * by default — the value IS the promise (`parseAsync(...).catch` dispatches
+ * on Promise). opts.unwrapAsync handles `(await f()).m()`: TS annotations
+ * unwrap their Promise/Awaitable head; a Python async producer's annotation
+ * already names the awaited value, so it passes through unchanged.
+ * Conservative: unions of two real types, function types, object literals,
+ * and tuples return null — a wrong head would exclude true callers.
+ */
+function _structuralTypeHead(text, opts = {}) {
+    if (!text || typeof text !== 'string') return null;
+    let t = text.trim().replace(/^readonly\s+/, '').replace(/^["']|["']$/g, '').trim();
+    if (t.includes('|')) {
+        const parts = t.split('|').map(s => s.trim())
+            .filter(s => s && !['None', 'null', 'undefined'].includes(s));
+        if (parts.length !== 1) return null;
+        t = parts[0];
+    }
+    let m;
+    // type-transparent wrappers (the value's runtime type is the argument)
+    while ((m = t.match(/^(?:typing\.)?(Optional|Annotated|Final)\s*[[<]\s*(.+)\s*[\]>]$/s))) {
+        t = (_splitTopLevelGenericArgs(m[2])[0] || '').trim(); // Annotated[X, meta] → X
+    }
+    if (opts.unwrapAsync) {
+        m = t.match(/^(?:typing\.)?(Promise|Awaitable|Coroutine)\s*[[<]\s*(.*)\s*[\]>]$/s);
+        if (m) {
+            const args = _splitTopLevelGenericArgs(m[2]).map(s => s.trim());
+            // Coroutine[Y, S, R] resolves to its RETURN (last) argument
+            t = (m[1] === 'Coroutine' ? args[args.length - 1] : args[0]) || '';
+        }
+    }
+    if (/\[\]$/.test(t)) return 'Array'; // TS Foo[] — the value is an array
+    m = t.match(/^([\w$.]+)\s*[[<]/s);   // generic head: Foo<...> / dict[...]
+    if (m) t = m[1];
+    const last = t.split('.').pop();
+    if (!/^[A-Za-z_$][\w$]*$/.test(last)) return null; // fn types, object literals, tuples
+    return _PY_TYPING_BUILTINS[last] || last;
+}
+
+// Structural annotation heads that carry no receiver identity: TS escape
+// hatches, the receiver-polymorphic `this`/`Self`, and Python's object root.
+const _STRUCTURAL_FLOW_REJECT = new Set([
+    'any', 'unknown', 'object', 'void', 'never', 'undefined', 'null',
+    'this', 'Self', 'Object', 'None',
+]);
+
+/**
+ * Type a chained receiver from its producer's declared return annotation
+ * (fix #219): `parseAsync(args).catch(...)` — the receiver of .catch IS the
+ * parseAsync(...) call, so its return annotation is compiler-true receiver
+ * evidence. Method producers follow the #207 agreement discipline: EVERY
+ * same-name method def project-wide must carry a return annotation and all
+ * heads must agree (whichever class the producer dispatches to, the type is
+ * the same). Plain producers follow #199's unique-project-def rule. Python
+ * async producers type only AWAITED chains — the bare value is a coroutine,
+ * not the annotation's type (TS annotations already SAY Promise, so they
+ * type either way).
+ */
+/**
+ * Nominal chained-receiver typing (fix #220, cobra-measured — #219's part 2
+ * extended past the structural gate now that a family is measured):
+ * `rootCmd.Flags().String(...)` — the producer's compiler-checked return
+ * annotation types the receiver. Reuses the #207 rails verbatim: method
+ * producers must AGREE project-wide, plain producers are same-package-only
+ * for Go (an unqualified call cannot cross packages), package-qualified
+ * producers resolve strictly through the file's imports
+ * (_qualifiedProducerDefs), and the type NAME pins to its defining file from
+ * the PRODUCER's scope (_resolveFlowTypeOrigin). External producer packages
+ * and reject-set returns stay untyped — no evidence either way.
+ */
+function _nominalChainedReceiverType(index, call, fileEntry, filePath) {
+    const language = fileEntry.language;
+    const defs = (index.symbols.get(call.receiverCall) || [])
+        .filter(d => !NON_CALLABLE_TYPES.has(d.type));
+    let producer = null;
+    let selfClass;
+    if (call.receiverCallReceiver) {
+        // Package-qualified producer: os.CreateTemp().Name(). A package that
+        // resolves to no project def decided the type OUTSIDE the project —
+        // external-flow marker (blocks single-owner confirmation, routes
+        // possible-dispatch; never excludes).
+        const cands = defs.filter(d => d.returnType);
+        const inPkg = _qualifiedProducerDefs(index, fileEntry, call.receiverCallReceiver, cands);
+        if (!inPkg || inPkg.length === 0 ||
+            new Set(inPkg.map(d => d.returnType)).size !== 1) {
+            return { externalVia: `${call.receiverCallReceiver}.${call.receiverCall}` };
+        }
+        producer = inPkg[0];
+    } else if (call.receiverCallIsMethod) {
+        // Method producer: every same-name method def project-wide must carry
+        // an annotation and agree (#219 discipline — whichever class
+        // dispatches, the type is the same).
+        const methodDefs = defs.filter(d => d.className || d.receiver);
+        if (methodDefs.length === 0) return null;
+        if (!methodDefs.every(d => d.returnType)) return null;
+        if (new Set(methodDefs.map(d => d.returnType)).size !== 1) return null;
+        producer = methodDefs[0];
+        const classes = new Set(methodDefs.map(d =>
+            d.className || (d.receiver || '').replace(/^\*/, '')));
+        selfClass = classes.size === 1 ? [...classes][0] : undefined;
+    } else {
+        // Plain producer: Go resolves within the package; others same-file
+        // narrowing, then global-unique (#199/#207 rules). Where bare calls
+        // reach methods (Java), a bare producer is this.getConfig() — the
+        // enclosing class's own method wins.
+        if (langTraits(language)?.bareCallReachesMethods) {
+            const enclosing = index.findEnclosingFunction(filePath, call.line, true);
+            if (enclosing?.className) {
+                const sameClass = defs.find(d => d.className === enclosing.className && d.returnType);
+                if (sameClass) {
+                    const parsedSC = _returnTypeNameNominal(sameClass.returnType, language, {
+                        selfClass: enclosing.className,
+                    });
+                    if (!parsedSC) return null;
+                    const originSC = _resolveFlowTypeOrigin(index, sameClass.file || filePath, parsedSC.name, parsedSC.qualifier);
+                    if (!originSC) return null;
+                    return { type: parsedSC.name, ...(originSC.fromFile && { fromFile: originSC.fromFile }) };
+                }
+            }
+        }
+        const cands = defs.filter(d => !(d.className || d.receiver));
+        let chosen = null;
+        if (langTraits(language)?.packageScope === 'directory') {
+            const dir = path.dirname(filePath);
+            const samePkg = cands.filter(d => d.file && path.dirname(d.file) === dir);
+            if (samePkg.length === 1) chosen = samePkg[0];
+        } else if (cands.length === 1) {
+            chosen = cands[0];
+        } else {
+            const sameFile = cands.filter(d => d.file === filePath);
+            if (sameFile.length === 1) chosen = sameFile[0];
+        }
+        if (!chosen || !chosen.returnType) return null;
+        producer = chosen;
+    }
+    const parsed = _returnTypeNameNominal(producer.returnType, language, { selfClass });
+    if (!parsed) return null;
+    const origin = _resolveFlowTypeOrigin(index, producer.file || filePath, parsed.name, parsed.qualifier);
+    if (!origin) return null;
+    return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+}
+
+function _chainedReceiverType(index, call, language) {
+    const defs = (index.symbols.get(call.receiverCall) || [])
+        .filter(d => !NON_CALLABLE_TYPES.has(d.type));
+    let producers;
+    if (call.receiverCallIsMethod) {
+        producers = defs.filter(d => d.className);
+        if (producers.length === 0) return null;
+        if (!producers.every(d => d.returnType)) return null;
+    } else {
+        if (defs.length !== 1 || !defs[0].returnType) return null;
+        producers = defs;
+    }
+    if (language === 'python' && !call.receiverCallAwaited &&
+        producers.some(d => d.isAsync)) return null;
+    const heads = new Set();
+    for (const d of producers) {
+        const h = _structuralTypeHead(d.returnType, { unwrapAsync: call.receiverCallAwaited });
+        if (!h) return null;
+        heads.add(h);
+        if (heads.size > 1) return null;
+    }
+    const head = [...heads][0];
+    if (/^[A-Z][A-Z0-9]?$/.test(head)) return null; // generic type param (T, K, V1)
+    if (_STRUCTURAL_FLOW_REJECT.has(head)) return null;
+    return head;
+}
+
+/**
+ * Is this field symbol callable by its own name (obj.f(...) reaches the
+ * field's function value)? Arrow-function class fields are callable by
+ * construction; annotation-typed fields qualify via a function-type shape.
+ * Structural languages only — Java needs .apply()/.run() on a functional
+ * field and Rust needs (s.f)(…) parens, so their fields never own a
+ * method-call name; Go func fields DO but stay under the existing owner
+ * rules until a measured family justifies the churn.
+ */
+function _callableFieldDef(index, d) {
+    const lang = index.files.get(d.file)?.language;
+    if (langTraits(lang)?.typeSystem !== 'structural') return false;
+    if (d.isMethod) return true; // arrow-function class fields
+    if (!d.fieldType) return false;
+    return /=>/.test(d.fieldType) ||
+        /^(?:typing\.)?Callable\b/.test(d.fieldType.trim()) ||
+        /^Function\b/.test(d.fieldType.trim());
+}
+
 function _buildTypedLocalTypeMap(index, def, calls) {
     const localTypes = new Map();
     let _cachedLines = null;