gitnexus 1.6.10-rc.166 → 1.6.10-rc.167

package/dist/core/ingestion/class-extractors/configs/go.js

@@ -2,15 +2,20 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 export const goClassConfig = {
     language: SupportedLanguages.Go,
-    typeDeclarationNodes: ['type_declaration'],
+    // `type_spec`, not the enclosing `type_declaration` (#2837): one node per
+    // DECLARED TYPE, so a grouped `type ( A struct{…}; B struct{…} )` yields one
+    // each instead of one for the whole block. Every Go capture that reaches this
+    // extractor is anchored the same way, so the wrapper is never handed over —
+    // and accepting it would be worse than rejecting it, because picking one spec
+    // out of several with no reference point silently returns the FIRST type's
+    // name. A `null` here is loud; the wrong name is not.
+    typeDeclarationNodes: ['type_spec'],
     fileScopeNodeTypes: ['package_clause'],
     extractName(node) {
-        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
-        return typeSpec?.childForFieldName('name')?.text;
+        return node.childForFieldName('name')?.text;
     },
     extractType(node) {
-        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
-        const typeNode = typeSpec?.childForFieldName('type');
+        const typeNode = node.childForFieldName('type');
         if (typeNode?.type === 'struct_type')
             return 'Struct';
         if (typeNode?.type === 'interface_type')

package/dist/core/ingestion/languages/go/interface-impls.js

@@ -1,5 +1,6 @@
 import { simpleQualifiedName } from '../../scope-resolution/graph-bridge/ids.js';
 import { resolveInheritanceBaseInScope } from '../../scope-resolution/scope/walkers.js';
+import { goPackageDir } from './package-clause.js';
 export function detectGoInterfaceImplementations(parsedFiles, _indexes, _model) {
     return detectGoInterfaceImplementationsFromIndexes(buildDetectionIndexes(parsedFiles, _indexes));
 }
@@ -582,12 +583,13 @@ function signatureContextForFile(parsed, indexes) {
         importQualifiers,
     };
 }
+/** The package directory, or `undefined` for a repo-root file.
+ *
+ *  Shares `goPackageDir` with the package-clause resolver rather than repeating
+ *  its normalize-and-slice (#2837): the two disagree only on how they spell "no
+ *  directory", so the difference stays here, at the one call site that cares. */
 function packageQualifierForFile(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const slash = normalized.lastIndexOf('/');
-    if (slash === -1)
-        return undefined;
-    const packageDir = normalized.slice(0, slash);
+    const packageDir = goPackageDir(filePath);
     return packageDir.length === 0 ? undefined : packageDir;
 }
 const GO_BUILTIN_TYPES = new Set([

package/dist/core/ingestion/languages/go/method-owners.js

@@ -1,4 +1,8 @@
+import { logger } from '../../../logger.js';
 import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { goPackageDir, inferGoPackageName } from './package-clause.js';
+/** Bound on the sample of no-package-clause paths named in the warning. */
+const SKIPPED_SAMPLE_CAP = 5;
 /**
  * Populate `ownerId` on Go Method defs by matching receiver types
  * extracted from `@type-binding.self` captures against struct defs in
@@ -20,15 +24,32 @@ export function populateGoOwners(parsed) {
 }
 export function populateGoWorkspaceOwners(parsedFiles, ctx) {
     const filesByPackage = new Map();
+    // A file with no resolvable package clause is dropped from ownership
+    // resolution entirely — its methods never attach to a struct declared in a
+    // sibling file. That used to be a bare `continue` with no trace, which is the
+    // same false-safe silence #2813 was filed about. Report it once, bounded
+    // (mirrors the fan-out-cap warning in scope-resolution/pipeline/run.ts).
+    let skippedCount = 0;
+    const skippedSample = [];
     for (const parsed of parsedFiles) {
-        const pkgName = inferPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
-        if (pkgName === null)
+        const pkgName = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
+        if (pkgName === null) {
+            // Count everything, retain only the sample — a misrouted vendored tree
+            // would otherwise accumulate one path reference per file to print five.
+            skippedCount += 1;
+            if (skippedSample.length < SKIPPED_SAMPLE_CAP)
+                skippedSample.push(parsed.filePath);
             continue;
-        const key = `${packageDir(parsed.filePath)}\0${pkgName}`;
+        }
+        const key = `${goPackageDir(parsed.filePath)}\0${pkgName}`;
         const bucket = filesByPackage.get(key) ?? [];
         bucket.push(parsed);
         filesByPackage.set(key, bucket);
     }
+    if (skippedCount > 0) {
+        logger.warn({ skippedFiles: skippedCount, sample: skippedSample }, 'go: files with no resolvable package clause were excluded from method-owner ' +
+            'resolution (their methods cannot attach to structs declared in sibling files)');
+    }
     for (const bucket of filesByPackage.values()) {
         populateGoOwnersInPackage(bucket);
     }
@@ -97,12 +118,3 @@ function populateGoOwnersInPackage(parsedFiles) {
         }
     }
 }
-function inferPackageName(sourceText) {
-    const match = sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m);
-    return match?.[1] ?? null;
-}
-function packageDir(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const idx = normalized.lastIndexOf('/');
-    return idx === -1 ? '' : normalized.slice(0, idx);
-}

package/dist/core/ingestion/languages/go/package-clause.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Go package-clause resolution — the single derivation of a file's package
+ * identity (#2837).
+ *
+ * Both Go passes that bucket files by package (`populateGoWorkspaceOwners` and
+ * `populateGoPackageSiblings`) previously carried their own byte-identical copy
+ * of this, spelled as one unanchored multiline regex:
+ *
+ *     sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m)
+ *
+ * With the `m` flag that matches the first line ANYWHERE in the file starting
+ * with `package <ident>` — comment bodies included. Measured against that exact
+ * expression: a header comment containing `package legacy_notes kept for
+ * history` yields `legacy_notes`, and an indented `  package helper old name`
+ * yields `helper`. A file that mis-infers its own package gets a bucket key no
+ * sibling shares, so it is isolated in BOTH passes: its methods never attach to
+ * structs declared in sibling files, and it exchanges no same-package bindings.
+ * Every field-receiver call in it then resolves to nothing, silently — the same
+ * per-file signature #2837 reported.
+ *
+ * The Go spec makes the correct rule exact rather than heuristic: a source
+ * file's first non-comment, non-blank token is `package`. So skip the leading
+ * run of whitespace and comments, then require the very next token to be the
+ * clause. Anything else is `null` — a truncated read, a misrouted non-Go file,
+ * an unparseable header — reported by the caller rather than guessed at.
+ *
+ * ONE rule governs every leniency below (the `\s+` separator, the shebang skip,
+ * CR-only line endings): a file this returns `null` for is dropped from BOTH
+ * passes, so refusing a shape the previous regex accepted is a silent
+ * regression, not a principled tightening. Be no stricter than the grammar.
+ */
+/**
+ * The package name declared by this Go source text, or `null` when its first
+ * real token is not a package clause.
+ *
+ * Only the leading run before the clause is skipped — deliberately NOT a
+ * whole-file comment strip, which would be O(file) on every Go file and would
+ * also have to model string literals to stay correct.
+ */
+export declare function inferGoPackageName(sourceText: string): string | null;
+/**
+ * The directory half of a Go package key. Go package identity is
+ * directory-scoped, so repeated `package main` directories must not see each
+ * other's unqualified names.
+ */
+export declare function goPackageDir(filePath: string): string;

package/dist/core/ingestion/languages/go/package-clause.js

@@ -0,0 +1,75 @@
+/**
+ * Go package-clause resolution — the single derivation of a file's package
+ * identity (#2837).
+ *
+ * Both Go passes that bucket files by package (`populateGoWorkspaceOwners` and
+ * `populateGoPackageSiblings`) previously carried their own byte-identical copy
+ * of this, spelled as one unanchored multiline regex:
+ *
+ *     sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m)
+ *
+ * With the `m` flag that matches the first line ANYWHERE in the file starting
+ * with `package <ident>` — comment bodies included. Measured against that exact
+ * expression: a header comment containing `package legacy_notes kept for
+ * history` yields `legacy_notes`, and an indented `  package helper old name`
+ * yields `helper`. A file that mis-infers its own package gets a bucket key no
+ * sibling shares, so it is isolated in BOTH passes: its methods never attach to
+ * structs declared in sibling files, and it exchanges no same-package bindings.
+ * Every field-receiver call in it then resolves to nothing, silently — the same
+ * per-file signature #2837 reported.
+ *
+ * The Go spec makes the correct rule exact rather than heuristic: a source
+ * file's first non-comment, non-blank token is `package`. So skip the leading
+ * run of whitespace and comments, then require the very next token to be the
+ * clause. Anything else is `null` — a truncated read, a misrouted non-Go file,
+ * an unparseable header — reported by the caller rather than guessed at.
+ *
+ * ONE rule governs every leniency below (the `\s+` separator, the shebang skip,
+ * CR-only line endings): a file this returns `null` for is dropped from BOTH
+ * passes, so refusing a shape the previous regex accepted is a silent
+ * regression, not a principled tightening. Be no stricter than the grammar.
+ */
+/** Leading trivia: whitespace, `//` lines, block comments. Sticky. */
+const LEADING_TRIVIA = /(?:\s+|\/\/[^\n\r]*|\/\*[\s\S]*?\*\/)*/y;
+/** The clause itself, anchored at the first non-trivia byte. `\s+` (not
+ *  `[ \t]+`) because Go separates tokens by any whitespace: `package\nmain` is
+ *  legal and tree-sitter parses it without error. */
+const PACKAGE_CLAUSE = /package\s+([A-Za-z_][A-Za-z0-9_]*)/y;
+/**
+ * The package name declared by this Go source text, or `null` when its first
+ * real token is not a package clause.
+ *
+ * Only the leading run before the clause is skipped — deliberately NOT a
+ * whole-file comment strip, which would be O(file) on every Go file and would
+ * also have to model string literals to stay correct.
+ */
+export function inferGoPackageName(sourceText) {
+    let i = 0;
+    // A leading `#!` line: `gorun`-style scripts carry one. Only a FIRST-line
+    // `#!` is skipped; a `#` anywhere else still ends the scan.
+    if (sourceText.startsWith('#!')) {
+        const eol = sourceText.search(/[\n\r]/);
+        if (eol === -1)
+            return null;
+        i = eol + 1;
+    }
+    // Whitespace (`\s` covers the BOM and every line ending), `//` lines and block
+    // comments — the run a Go file may carry before its clause. Sticky, so the
+    // header is skipped in place without slicing a copy of the file. An
+    // unterminated `/*` or a `//` running to EOF simply leaves `lastIndex` where
+    // the clause cannot match, so neither needs its own early return.
+    LEADING_TRIVIA.lastIndex = i;
+    LEADING_TRIVIA.exec(sourceText);
+    PACKAGE_CLAUSE.lastIndex = LEADING_TRIVIA.lastIndex;
+    return PACKAGE_CLAUSE.exec(sourceText)?.[1] ?? null;
+}
+/**
+ * The directory half of a Go package key. Go package identity is
+ * directory-scoped, so repeated `package main` directories must not see each
+ * other's unqualified names.
+ */
+export function goPackageDir(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const idx = normalized.lastIndexOf('/');
+    return idx === -1 ? '' : normalized.slice(0, idx);
+}

package/dist/core/ingestion/languages/go/package-siblings.js

@@ -1,4 +1,5 @@
 import { expandGoDotImports } from './expand-wildcards.js';
+import { goPackageDir, inferGoPackageName } from './package-clause.js';
 /**
  * O(n²×d) where n = files per package, d = defs per file.
  * Acceptable for V1 since Go packages are typically small (< 20 files).
@@ -17,9 +18,13 @@ export function populateGoPackageSiblings(parsedFiles, indexes, ctx) {
     //    must not see each other's unqualified names.
     const packageByFile = new Map();
     for (const parsed of nonTestFiles) {
-        const pkgName = inferPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
+        // Same derivation as `populateGoWorkspaceOwners` — one shared resolver, so
+        // the two passes cannot disagree about a file's package (#2837). The
+        // no-clause case is reported there; warning twice for one fact would be
+        // noise.
+        const pkgName = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
         if (pkgName !== null) {
-            packageByFile.set(parsed.filePath, `${packageDir(parsed.filePath)}\0${pkgName}`);
+            packageByFile.set(parsed.filePath, `${goPackageDir(parsed.filePath)}\0${pkgName}`);
         }
     }
     const filesByPackage = new Map();
@@ -60,15 +65,6 @@ export function populateGoPackageSiblings(parsedFiles, indexes, ctx) {
         }
     }
 }
-function inferPackageName(sourceText) {
-    const match = sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m);
-    return match?.[1] ?? null;
-}
-function packageDir(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const idx = normalized.lastIndexOf('/');
-    return idx === -1 ? '' : normalized.slice(0, idx);
-}
 function getAugmentationBucket(augmentations, scopeId, name) {
     let scopeBindings = augmentations.get(scopeId);
     if (scopeBindings === undefined) {

package/dist/core/ingestion/languages/go/query.js

@@ -3,9 +3,33 @@ import Go from 'tree-sitter-go';
 const GO_SCOPE_QUERY = `
 ;; Scopes
 (source_file) @scope.module
+;; One Class scope per DECLARED TYPE, not per declaration (#2837).
+;;
+;; Capturing the type_declaration made a grouped declaration
+;;   type (
+;;     Decoy       struct { ... }
+;;     PickService struct { ... }
+;;   )
+;; a SINGLE Class scope owning every struct in the block. Downstream that scope
+;; can name only one owner -- buildWorkspaceResolutionIndex keeps the first
+;; class-like def it finds -- so the block's structs lost their field type
+;; bindings, typeOfMemberOnClass found no scope, the compound-receiver fold
+;; declined, and every s.field.Method() site in the file emitted nothing at
+;; all. Silent, per-file, and independent of file size: exactly the split
+;; reported in #2837 that #2829's global fixes could not explain. Measured on
+;; the go-grouped-type-decl fixture: EVERY struct in a grouped block lost its
+;; edges, the first one included, and grouped interface blocks produced no
+;; IMPLEMENTS edges at all.
+;;
+;; type_spec is the node Go's own grammar gives one declared type, so one
+;; capture per type_spec is the granularity the rest of the pipeline already
+;; assumes. A plain single-type declaration is unaffected in count -- only its
+;; scope range narrows, from the type keyword to the name.
+;;
+;; NOTE: this string is a JS template literal. Backticks are a syntax error.
 (type_declaration
   (type_spec
-    type: [(struct_type) (interface_type)])) @scope.class
+    type: [(struct_type) (interface_type)]) @scope.class)
 (function_declaration) @scope.function
 (method_declaration) @scope.function
 (func_literal) @scope.function
@@ -21,14 +45,24 @@ const GO_SCOPE_QUERY = `
 (communication_case) @scope.block
 
 ;; Declarations — struct
+;;
+;; Anchored on the type_spec, in lockstep with @scope.class above (#2837). Both
+;; captures MUST name the same node: the def node and the class-scope node are
+;; paired by range, so anchoring the def on the enclosing type_declaration while
+;; the scope sits on the type_spec leaves the def strictly larger than its own
+;; scope and NOTHING is owned -- measured as every Go field-receiver edge in the
+;; fixture disappearing, plain declarations included. Keeping both on
+;; type_declaration is the original bug: a grouped block gave both structs the
+;; same capture node, so one silently displaced the other.
 (type_declaration
   (type_spec name: (type_identifier) @declaration.name
-    type: (struct_type))) @declaration.struct
+    type: (struct_type)) @declaration.struct)
 
 ;; Declarations — interface
+;; Same lockstep requirement as @declaration.struct above (#2837).
 (type_declaration
   (type_spec name: (type_identifier) @declaration.name
-    type: (interface_type))) @declaration.interface
+    type: (interface_type)) @declaration.interface)
 
 ;; Declarations — function
 (function_declaration

package/dist/core/ingestion/languages/go.js

@@ -132,6 +132,15 @@ export const goProvider = defineLanguage({
     descriptionExtractor: createLeadingDocDescriptionExtractor({
         lineCommentPrefixes: ['//'],
         lineDirectivePrefixes: ['//go:', '// +build', '//nolint', '//line'],
+        // #2837: Go type declarations anchor on the `type_spec`, whose
+        // `previousNamedSibling` is null for the ordinary `type T struct{…}` form —
+        // the godoc comment is a sibling of the enclosing `type_declaration`, one
+        // level up. Without this the doc silently vanished for EVERY Go struct and
+        // interface (measured: pre-#2837 `desc=YES`, post `none`), taking #2270's
+        // description out of both the embedding header and the FTS column.
+        // Functions/methods are unaffected — they anchor on their own declaration
+        // node, which does carry the comment as a previous sibling.
+        wrapperNodeTypes: ['type_declaration'],
     }),
     builtInNames: GO_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────

package/dist/core/ingestion/scope-resolution/unresolved-receivers.d.ts

@@ -87,3 +87,23 @@ export declare function lookupUnresolvedCallCount(summary: UnresolvedReceiverSum
  * friends would otherwise return a function.
  */
 export declare function lookupExternalCallCount(summary: UnresolvedReceiverSummary | undefined, symName: string): number | undefined;
+/**
+ * Report which FILES lost the most call sites to an untyped receiver (#2837).
+ *
+ * `summarizeUnresolvedReceivers` persists the same drops keyed by member NAME,
+ * capped at 500 distinct names, and discards `filePath` — deliberately, because
+ * its consumer (`impact()`'s exact-vs-lower-bound verdict) asks "is this
+ * symbol's caller count trustworthy", a question about names.
+ *
+ * That leaves "why does THIS file resolve nothing while its sibling resolves
+ * everything" unanswerable from any artifact, which is exactly what #2837 asked
+ * for and could not run: comparing the drop records of two files with identical
+ * declared shapes separates "receiver never typed" from "typed but no edge
+ * emitted", and narrows a per-file split in one run instead of a bisect.
+ *
+ * A log line rather than a persisted field because nothing queries it — a
+ * persisted `byFile` map would be an unread field carrying its own cap and
+ * truncation semantics. When a consumer appears, `UnresolvedReceiverSummary` is
+ * already a `RepoMeta` field and can carry it with no schema change.
+ */
+export declare function logUnresolvedReceiverFiles(outcomes: readonly ResolutionOutcome[]): void;

package/dist/core/ingestion/scope-resolution/unresolved-receivers.js

@@ -12,6 +12,8 @@
  * report its caller count as a lower bound, while a query about an unrelated
  * symbol stays exact.
  */
+import { createLogger } from '../../logger.js';
+import { compareCodeUnits } from '../../../lib/utils.js';
 /** Cap on distinct member names persisted. Well above what a real repo
  *  produces (the whole point of the signal is that drops are the exception),
  *  but bounded so a pathological repo cannot grow the metadata file without
@@ -30,11 +32,42 @@ export const MAX_UNRESOLVED_RECEIVER_MEMBERS = 500;
  * `omitted` is the number of distinct names past the cap, so the caller can
  * report truncation rather than silently losing entries.
  */
-function rankAndCap(counts) {
-    const ranked = [...counts.entries()].sort(([aName, aCount], [bName, bCount]) => bCount - aCount || aName.localeCompare(bName));
-    const kept = ranked.slice(0, MAX_UNRESOLVED_RECEIVER_MEMBERS);
+function rankAndCap(counts, cap = MAX_UNRESOLVED_RECEIVER_MEMBERS) {
+    const ranked = [...counts.entries()].sort(
+    // `compareCodeUnits`, not `localeCompare` (#2787). The tiebreak feeds the
+    // `.slice()` below, so locale-sensitive collation would decide WHICH
+    // entries survive the cap, not merely how they are listed — and ICU order
+    // varies by platform and ICU build, so two runs over one repo could persist
+    // different sets. Key-based lookup is unaffected either way.
+    ([aName, aCount], [bName, bCount]) => bCount - aCount || compareCodeUnits(aName, bName));
+    const kept = ranked.slice(0, cap);
     return { kept, omitted: ranked.length - kept.length };
 }
+/**
+ * A `receiver-unresolved` drop at a CALL site.
+ *
+ * ONE predicate, shared by the persisted summary and the per-file diagnostic —
+ * the same contract `rankAndCap` states for its comparator. If the two ever
+ * disagreed, the diagnostic would rank a different population than the artifact
+ * it exists to explain.
+ *
+ * Call sites only: Case 0's recorder gates on the receiver's punctuation, not on
+ * what the reference IS, so property reads (`d.source.kind`) and writes
+ * (`x.argtypes = [...]`) arrive alongside lost method calls — measured at 25 of
+ * 124 drops on the fixture corpus. Counting them made the consumer's "N call
+ * sites invoking X were dropped" literally false. A missing `siteKind` counts as
+ * a call: the only emitter always sets it, and erring toward `lower-bound` is
+ * the safe direction for an epistemic signal.
+ *
+ * Receiver ORIGIN is deliberately NOT decided here — the summary routes external
+ * drops into their own bucket while the diagnostic excludes them, and collapsing
+ * that choice into this predicate would take it away from both callers.
+ */
+function isUnresolvedReceiverCall(outcome) {
+    return (outcome.kind === 'suppressed' &&
+        outcome.reason === 'receiver-unresolved' &&
+        (outcome.siteKind === undefined || outcome.siteKind === 'call'));
+}
 /**
  * Build the summary, or `undefined` when nothing was dropped — an index with
  * no unresolved receivers stores no key at all, so `epistemic` keeps its
@@ -47,20 +80,12 @@ export function summarizeUnresolvedReceivers(outcomes) {
     let totalSites = 0;
     let externalSites = 0;
     for (const outcome of outcomes) {
-        if (outcome.kind !== 'suppressed' || outcome.reason !== 'receiver-unresolved')
+        // CALL sites only — see `isUnresolvedReceiverCall`, which the per-file
+        // diagnostic shares so the two can never rank different populations.
+        if (!isUnresolvedReceiverCall(outcome))
             continue;
         if (outcome.name.length === 0)
             continue;
-        // CALL sites only. Case 0's recorder gates on the receiver's punctuation, not
-        // on what the reference IS, so property reads (`d.source.kind`) and writes
-        // (`x.argtypes = [...]`) are recorded alongside lost method calls — measured at
-        // 25 of 124 drops on the fixture corpus. Counting them made the consumer's
-        // "N call sites invoking X were dropped" literally false, and flagged symbols
-        // whose CALL count was never short. `siteKind` exists to make this separable.
-        // A missing `siteKind` counts as a call: the only emitter always sets it, and
-        // erring toward `lower-bound` is the safe direction for an epistemic signal.
-        if (outcome.siteKind !== undefined && outcome.siteKind !== 'call')
-            continue;
         // Routed, not discarded. External-rooted drops (`console.log(...)`,
         // `fetch(...)`) reach code this index does not contain, so there is no node
         // an edge could have pointed at and nothing was lost — they must not hedge.
@@ -142,3 +167,69 @@ export function lookupExternalCallCount(summary, symName) {
         return undefined;
     return sites;
 }
+/**
+ * Opt-in, following the repo's established diagnostic pattern
+ * (`createLogger(name, { debugEnvVar })`). Every repository in every language
+ * drops SOME receivers, so emitting this at `info` unconditionally would add a
+ * line to every analyze anyone ever runs — the noise ADV-6 flagged. #2837's
+ * reporter turns it on deliberately:
+ *
+ *     GITNEXUS_DEBUG_RECEIVER_DROPS=1 gitnexus analyze
+ */
+// Built on first use, not at import. `createLogger` is eager where the `logger`
+// singleton is a lazy Proxy — it resolves `pino-pretty`, constructs a SonicBoom
+// destination and registers a `beforeExit` hook. This module is imported by
+// `mcp/local/local-backend.ts` for its lookup helpers, so an eager call would
+// put that on MCP server startup for a diagnostic that is off by default.
+let receiverDropLog;
+const dropLog = () => (receiverDropLog ??= createLogger('receiver-drops', {
+    debugEnvVar: 'GITNEXUS_DEBUG_RECEIVER_DROPS',
+}));
+/** Files named in the per-file receiver-drop line. Bounded: this is a signpost
+ *  pointing at where to look, not an inventory. */
+const UNRESOLVED_RECEIVER_FILE_SAMPLE = 10;
+/**
+ * Report which FILES lost the most call sites to an untyped receiver (#2837).
+ *
+ * `summarizeUnresolvedReceivers` persists the same drops keyed by member NAME,
+ * capped at 500 distinct names, and discards `filePath` — deliberately, because
+ * its consumer (`impact()`'s exact-vs-lower-bound verdict) asks "is this
+ * symbol's caller count trustworthy", a question about names.
+ *
+ * That leaves "why does THIS file resolve nothing while its sibling resolves
+ * everything" unanswerable from any artifact, which is exactly what #2837 asked
+ * for and could not run: comparing the drop records of two files with identical
+ * declared shapes separates "receiver never typed" from "typed but no edge
+ * emitted", and narrows a per-file split in one run instead of a bisect.
+ *
+ * A log line rather than a persisted field because nothing queries it — a
+ * persisted `byFile` map would be an unread field carrying its own cap and
+ * truncation semantics. When a consumer appears, `UnresolvedReceiverSummary` is
+ * already a `RepoMeta` field and can carry it with no schema change.
+ */
+export function logUnresolvedReceiverFiles(outcomes) {
+    // Nothing below is observable unless the diagnostic is switched on, so skip
+    // the whole tally rather than building it and discarding it at the emit.
+    if (!dropLog().isLevelEnabled('debug'))
+        return;
+    const byFile = new Map();
+    let totalSites = 0;
+    for (const outcome of outcomes) {
+        // External-rooted drops (`fmt.Println`) reach code this index does not
+        // contain, so no node existed for an edge to point at and nothing was lost.
+        // Counting them here led the ranking with files that call `fmt` the most.
+        if (!isUnresolvedReceiverCall(outcome) || outcome.receiverOrigin === 'external')
+            continue;
+        totalSites += 1;
+        byFile.set(outcome.filePath, (byFile.get(outcome.filePath) ?? 0) + 1);
+    }
+    if (totalSites === 0)
+        return;
+    const { kept } = rankAndCap(byFile, UNRESOLVED_RECEIVER_FILE_SAMPLE);
+    dropLog().debug({
+        totalSites,
+        filesAffected: byFile.size,
+        topFiles: kept.map(([filePath, sites]) => ({ filePath, sites })),
+    }, 'receiver-unresolved call sites by file (top offenders; a file far above its ' +
+        'siblings usually means its receivers were never typed, not that it has more calls)');
+}

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -3,7 +3,7 @@ export declare const JAVASCRIPT_QUERIES: string;
 export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Lambda bindings: `f = lambda x: x` binds a CALLABLE, so it emits Function\n; rather than Variable, matching what TS/JS already do for `const f = () => {}`.\n; This aligns the LABEL only \u2014 call resolution runs off the scope-resolution\n; query, which still models the binding as a value, so `f()` does not resolve\n; here yet. Overlap with the assignment pattern above is collapsed by the\n; parse-worker dedup (#2687).\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    right: (lambda))) @definition.function\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n; The first positional argument is captured three ways (#2391): a string literal\n; path via @decorator.arg (quote-free, the fast path); a bare constant name or a\n; plus-concatenation via @decorator.arg_expr (resolved cross-file by the constant\n; resolver). The anchored optional alternation pins to the FIRST arg and stays\n; optional, so no-arg decorators (@app.tool(), etc.) and non-path first args still\n; match.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      .\n      [\n        (string (string_content)? @decorator.arg) @decorator.arg_str\n        (identifier) @decorator.arg_expr\n        (binary_operator) @decorator.arg_expr\n      ]?))) @decorator\n";
 export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Records, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(record_declaration name: (identifier) @name) @definition.record\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Anonymous class bodies: new Runnable() { ... } \u2014 no @name capture; the\n; class extractor synthesizes the javac-style Worker$N name (#2550)\n(object_creation_expression (class_body)) @definition.class\n\n; Enum constant bodies: enum E { A { ... } } \u2014 javac's other anonymous\n; shape, synthesized as E$N by the same naming authority (#2555)\n(enum_constant body: (class_body)) @definition.class\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; \u2500\u2500 Closure bindings (#2693) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n; A name bound to a closure literal IS a callable, so it emits Function rather\n; than a value label \u2014 matching TS/JS and the languages #2687 already covered.\n; The callable node is what callable-value-flow joins the binding to (by file,\n; line and name), which is what makes handler.apply(1) resolve. Overlap with the value\n; rules above is collapsed by the parse-worker dedup, which ranks callable\n; highest (#2687).\n; Anchored on field_declaration / local_variable_declaration \u2014 the SAME nodes\n; the value rules above use \u2014 so the parse-worker dedup (keyed by definition\n; node + name) actually collapses the pair. Anchoring on the inner\n; variable_declarator instead produced a Function AND a Property twin, the exact\n; double-indexing #2687 removed.\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name\n    value: (lambda_expression))) @definition.function\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name\n    value: (lambda_expression))) @definition.function\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n\n; Variable declarations: int x = 5; or int x;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n";
-export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec (identifier) @name)) @definition.const\n(var_declaration (var_spec (identifier) @name)) @definition.variable\n(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Closure bindings: `var f = func(){}` / `f := func(){}` bind a CALLABLE, so\n; they emit Function, not Variable \u2014 the same convention TS/JS already use for\n; `const f = () => {}`. This aligns the LABEL only \u2014 call resolution runs off\n; the scope-resolution query, which still models the binding as a value, so\n; `f()` does not resolve here yet. Overlap with the value patterns above is\n; collapsed by the parse-worker dedup (#2687).\n(var_declaration\n  (var_spec\n    name: (identifier) @name\n    value: (expression_list (func_literal)))) @definition.function\n(var_declaration\n  (var_spec_list\n    (var_spec\n      name: (identifier) @name\n      value: (expression_list (func_literal))))) @definition.function\n(short_var_declaration\n  left: (expression_list (identifier) @name)\n  right: (expression_list (func_literal))) @definition.function\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
+export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n;\n; Anchored on the type_spec, NOT the enclosing type_declaration (#2837) \u2014 a\n; grouped type ( A struct{}; B struct{} ) block otherwise gave every match the\n; same capture node, and goClassConfig.extractName resolved all of them to the\n; FIRST spec's name, collapsing the block to one node. Must stay in lockstep\n; with @scope.class / @declaration.struct in languages/go/query.ts, which\n; carries the full rationale. (No backticks here: this is a template literal.)\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type)) @definition.struct)\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type)) @definition.interface)\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec (identifier) @name)) @definition.const\n(var_declaration (var_spec (identifier) @name)) @definition.variable\n(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Closure bindings: `var f = func(){}` / `f := func(){}` bind a CALLABLE, so\n; they emit Function, not Variable \u2014 the same convention TS/JS already use for\n; `const f = () => {}`. This aligns the LABEL only \u2014 call resolution runs off\n; the scope-resolution query, which still models the binding as a value, so\n; `f()` does not resolve here yet. Overlap with the value patterns above is\n; collapsed by the parse-worker dedup (#2687).\n(var_declaration\n  (var_spec\n    name: (identifier) @name\n    value: (expression_list (func_literal)))) @definition.function\n(var_declaration\n  (var_spec_list\n    (var_spec\n      name: (identifier) @name\n      value: (expression_list (func_literal))))) @definition.function\n(short_var_declaration\n  left: (expression_list (identifier) @name)\n  right: (expression_list (func_literal))) @definition.function\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
 export declare const CPP_QUERIES = "\n; Classes, Structs, Namespaces\n(class_specifier name: (type_identifier) @name) @definition.class\n(class_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.class\n; Out-of-line nested definition: class Outer::Inner { ... } / struct Outer::Inner { ... }.\n; Key the node by the full qualified_identifier text so the def materializes a\n; node that matches the HAS_METHOD owner id (also the full qualified text) and\n; stays distinct from a same-tail type in another scope (#1975, #1978).\n(class_specifier name: (qualified_identifier) @name) @definition.class\n(struct_specifier name: (qualified_identifier) @name) @definition.struct\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(struct_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.struct\n(namespace_definition name: (namespace_identifier) @name) @definition.namespace\n(enum_specifier name: (type_identifier) @name) @definition.enum\n\n; Typedefs and unions (common in C-style headers and mixed C/C++ code)\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n(union_specifier name: (type_identifier) @name) @definition.union\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Functions & Methods (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (operator_name) @name))) @definition.method\n\n; Functions/methods returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n\n; Functions/methods returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method\n\n; Functions/methods returning references (reference_declarator wraps function_declarator)\n(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (operator_name) @name)))) @definition.method\n\n; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp)\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method\n\n; Function declarations / prototypes (common in headers)\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n\n; Class/struct data member fields (Address address; int count;)\n; Uses field_identifier to exclude method declarations (which use function_declarator)\n(field_declaration\n  declarator: (field_identifier) @name) @definition.property\n\n; Pointer member fields (Address* address;)\n(field_declaration\n  declarator: (pointer_declarator\n    declarator: (field_identifier) @name)) @definition.property\n\n; Reference member fields (Address& address;)\n(field_declaration\n  declarator: (reference_declarator\n    (field_identifier) @name)) @definition.property\n\n; Inline class method declarations (inside class body, no body: void save();)\n; tree-sitter-cpp uses field_identifier (not identifier) for names inside class bodies\n(field_declaration declarator: (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name)) @definition.method\n\n; Inline class method declarations returning a pointer (User* lookup();)\n(field_declaration declarator: (pointer_declarator declarator: (function_declarator declarator: [(field_identifier) (identifier)] @name))) @definition.method\n\n; Inline class method declarations returning a reference (User& lookup();)\n(field_declaration declarator: (reference_declarator (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method\n\n; Inline class method definitions (inside class body, with body: void Foo() { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (function_declarator\n      declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method)\n\n; Inline class methods returning a pointer type (User* lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (pointer_declarator\n      declarator: (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Inline class methods returning a reference type (User& lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (reference_declarator\n      (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Templates\n(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template\n(template_declaration\n  (class_specifier\n    name: (template_type\n      (type_identifier) @name\n      (template_argument_list) @template-arguments))) @definition.template\n(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call\n(call_expression function: (template_function name: (identifier) @call.name)) @call\n(binary_expression operator: \"+\" @call.name) @call\n(binary_expression operator: \"<<\" @call.name) @call\n\n; Constructor calls: new User()\n(new_expression type: (type_identifier) @call.name) @call\n\n; Variable declarations: int x = 5; or auto x = 5;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n\n; Lambda bindings: `auto f = [](int x){ \u2026 };` binds a CALLABLE, so it emits\n; Function rather than Variable, matching TS/JS. This aligns the LABEL only \u2014\n; call resolution runs off the scope-resolution query, which still models the\n; binding as a value, so `f()` does not resolve here yet. Overlap with the\n; pattern above is collapsed by the parse-worker dedup (#2687).\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name\n    value: (lambda_expression))) @definition.function\n\n; Structured bindings: auto [a, b] = makePair();  (one @name per bound identifier)\n(declaration\n  declarator: (init_declarator\n    declarator: (structured_binding_declarator\n      (identifier) @name))) @definition.variable\n\n; Structured bindings, reference form: auto& [x, y] = tup;\n(declaration\n  declarator: (init_declarator\n    declarator: (reference_declarator\n      (structured_binding_declarator\n        (identifier) @name)))) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    argument: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n";
 export declare const CSHARP_QUERIES = "\n; Types\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(struct_declaration name: (identifier) @name) @definition.struct\n(enum_declaration name: (identifier) @name) @definition.enum\n(record_declaration name: (identifier) @name) @definition.record\n(delegate_declaration name: (identifier) @name) @definition.delegate\n\n; Namespaces (block form and C# 10+ file-scoped form)\n(namespace_declaration name: (identifier) @name) @definition.namespace\n(namespace_declaration name: (qualified_name) @name) @definition.namespace\n(file_scoped_namespace_declaration name: (identifier) @name) @definition.namespace\n(file_scoped_namespace_declaration name: (qualified_name) @name) @definition.namespace\n\n; Methods & Properties\n(method_declaration name: (identifier) @name) @definition.method\n(local_function_statement name: (identifier) @name) @definition.function\n(constructor_declaration name: (identifier) @name) @definition.constructor\n(property_declaration name: (identifier) @name) @definition.property\n\n; Primary constructors (C# 12): class User(string name, int age) { }\n(class_declaration name: (identifier) @name (parameter_list) @definition.constructor)\n(record_declaration name: (identifier) @name (parameter_list) @definition.constructor)\n\n; Using\n(using_directive (qualified_name) @import.source) @import\n(using_directive (identifier) @import.source) @import\n\n; Calls\n(invocation_expression function: (identifier) @call.name) @call\n(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call\n\n; Null-conditional method calls: user?.Save()\n; Parses as: invocation_expression \u2192 conditional_access_expression \u2192 member_binding_expression \u2192 identifier\n(invocation_expression\n  function: (conditional_access_expression\n    (member_binding_expression\n      (identifier) @call.name))) @call\n\n; Constructor calls: new Foo() and new Foo { Props }\n(object_creation_expression type: (identifier) @call.name) @call\n\n; Target-typed new (C# 9): User u = new(\"x\", 5)\n(variable_declaration type: (identifier) @call.name (variable_declarator (implicit_object_creation_expression) @call))\n\n; Local variable declarations\n(local_declaration_statement\n  (variable_declaration\n    (variable_declarator\n      (identifier) @name))) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_access_expression\n    expression: (_) @assignment.receiver\n    name: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; \u2500\u2500 Closure bindings (#2693) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n; A name bound to a closure literal IS a callable, so it emits Function rather\n; than a value label \u2014 matching TS/JS and the languages #2687 already covered.\n; The callable node is what callable-value-flow joins the binding to (by file,\n; line and name), which is what makes handler(1) resolve. Overlap with the value\n; rules above is collapsed by the parse-worker dedup, which ranks callable\n; highest (#2687).\n(variable_declarator\n  (identifier) @name\n  (lambda_expression)) @definition.function\n";
 export declare const RUST_QUERIES = "\n; Functions & Items\n(function_item name: (identifier) @name) @definition.function\n(function_signature_item name: (identifier) @name) @definition.function\n\n; Closure bound to a let: let handler = || target(1);\n; Emits the Function NODE. Without it a Rust closure binding had no graph node\n; at all, so it could be neither a call target nor a call source (#2699), which\n; made Rust the one exception to \"a closure bound to a name is a Function node\n; in every language\" (#2687).\n; Anchor note: this channel puts @definition.function on the OUTER\n; let_declaration, which is the OPPOSITE of the scope-resolution channel in\n; languages/rust/query.ts (inner closure_expression, to align with\n; @scope.function). Both match their own channel's convention -- compare the\n; (lexical_declaration (variable_declarator ... (arrow_function))) rule above.\n(let_declaration\n  pattern: (identifier) @name\n  value: (closure_expression)) @definition.function\n(struct_item name: (type_identifier) @name) @definition.struct\n; A union is materialized as a Struct node (same rationale as the\n; scope-resolution @declaration.struct in languages/rust/query.ts: every\n; registry-primary resolution gate includes Struct but excludes Union, so a\n; Union-labeled node would be an unresolvable orphan). #1934 F71.\n(union_item name: (type_identifier) @name) @definition.struct\n(enum_item name: (type_identifier) @name) @definition.enum\n(trait_item name: (type_identifier) @name) @definition.trait\n(impl_item type: (type_identifier) @name !trait) @definition.impl\n(impl_item type: (generic_type type: (type_identifier) @name) !trait) @definition.impl\n; Scoped inherent impl: impl path::Type { ... }. Key the Impl node by the full\n; scoped_type_identifier text so it matches the owner id (also full text) and\n; stays distinct from a same-tail type in another module (#1975).\n(impl_item type: (scoped_type_identifier) @name !trait) @definition.impl\n(mod_item name: (identifier) @name) @definition.module\n\n; Type aliases, const, static, macros\n(type_item name: (type_identifier) @name) @definition.type\n(const_item name: (identifier) @name) @definition.const\n(static_item name: (identifier) @name) @definition.static\n(macro_definition name: (identifier) @name) @definition.macro\n\n; Use statements\n(use_declaration argument: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call\n(call_expression function: (generic_function function: (identifier) @call.name)) @call\n\n; Struct literal construction: User { name: value }\n(struct_expression name: (type_identifier) @call.name) @call\n\n; Struct fields \u2014 named field declarations inside struct bodies\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    value: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(compound_assignment_expr\n  left: (field_expression\n    value: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -1114,8 +1114,15 @@ export const GO_QUERIES = `
 (method_elem name: (field_identifier) @name) @definition.method
 
 ; Types
-(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct
-(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface
+;
+; Anchored on the type_spec, NOT the enclosing type_declaration (#2837) — a
+; grouped type ( A struct{}; B struct{} ) block otherwise gave every match the
+; same capture node, and goClassConfig.extractName resolved all of them to the
+; FIRST spec's name, collapsing the block to one node. Must stay in lockstep
+; with @scope.class / @declaration.struct in languages/go/query.ts, which
+; carries the full rationale. (No backticks here: this is a template literal.)
+(type_declaration (type_spec name: (type_identifier) @name type: (struct_type)) @definition.struct)
+(type_declaration (type_spec name: (type_identifier) @name type: (interface_type)) @definition.interface)
 
 ; Imports
 (import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import

package/dist/core/ingestion/utils/ast-helpers.js

@@ -775,20 +775,26 @@ getQualifiedOwnerName) => {
                 }
             }
         }
-        // Go: type_declaration wrapping a struct_type (type User struct { ... })
-        if (current.type === 'type_declaration') {
-            const typeSpec = current.children?.find((c) => c.type === 'type_spec');
-            if (typeSpec) {
-                const typeBody = typeSpec.childForFieldName?.('type');
-                if (typeBody?.type === 'struct_type' || typeBody?.type === 'interface_type') {
-                    const nameNode = typeSpec.childForFieldName?.('name');
-                    if (nameNode) {
-                        const label = typeBody.type === 'struct_type' ? 'Struct' : 'Interface';
-                        return {
-                            classId: generateId(label, `${filePath}:${nameNode.text}`),
-                            className: nameNode.text,
-                        };
-                    }
+        // Go: the `type_spec` IS the declared type (`type User struct { ... }`, and
+        // one per member of a grouped `type ( A struct{…}; B struct{…} )` block).
+        //
+        // Matched here rather than on the enclosing `type_declaration` (#2837): this
+        // walk climbs `node.parent`, so it passes THROUGH the containing spec on its
+        // way up from any member, and the structure it already has is the answer.
+        // Keying on the wrapper instead meant picking one spec out of several with
+        // no reference point — which filed every member of a grouped block under its
+        // FIRST struct, so two same-named fields minted one id and first-write-wins
+        // dropped the second.
+        if (current.type === 'type_spec') {
+            const typeBody = current.childForFieldName?.('type');
+            if (typeBody?.type === 'struct_type' || typeBody?.type === 'interface_type') {
+                const nameNode = current.childForFieldName?.('name');
+                if (nameNode) {
+                    const label = typeBody.type === 'struct_type' ? 'Struct' : 'Interface';
+                    return {
+                        classId: generateId(label, `${filePath}:${nameNode.text}`),
+                        className: nameNode.text,
+                    };
                 }
             }
         }

package/dist/core/run-analyze.js

@@ -14,7 +14,7 @@ import { randomUUID } from 'node:crypto';
 import { retryRename } from '../storage/fs-atomic.js';
 import { acquireIndexLock } from '../storage/index-lock.js';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
-import { summarizeUnresolvedReceivers } from './ingestion/scope-resolution/unresolved-receivers.js';
+import { logUnresolvedReceiverFiles, summarizeUnresolvedReceivers, } from './ingestion/scope-resolution/unresolved-receivers.js';
 import { resetDegradedParseCounter } from './tree-sitter/safe-parse.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, ensureEmbeddingRowDmlSafe, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, deleteAllAdvisedBy, deleteSpringAopEvidenceNodes, deleteSpringAutoConfigurationDeclarations, deleteSpringAutoConfigurationSyntheticClasses, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
 import { estimateBufferPool, setBufferPoolSizeHint, resolveNativeSafeStorageDir, } from './lbug/lbug-config.js';
@@ -2218,6 +2218,8 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         const newFileHashesRecord = {};
         for (const [k, v] of newFileHashes)
             newFileHashesRecord[k] = v;
+        const resolutionOutcomes = pipelineResult.resolutionOutcomes ?? [];
+        logUnresolvedReceiverFiles(resolutionOutcomes);
         // Annotated so the capabilities stamp below is compile-checked against
         // RepoMeta's status unions (tri-review 4669518496 P1/U3) — an unannotated
         // literal widens the vectorSearch.status ternary to `string` and the
@@ -2286,7 +2288,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             // Derived digest of the DDL this run created the tables from (#2798).
             // Git-only: non-git repos never take the incremental path.
             schemaFingerprint: hasGitDir(repoPath) ? SCHEMA_FINGERPRINT : undefined,
-            unresolvedReceiverMembers: summarizeUnresolvedReceivers(pipelineResult.resolutionOutcomes ?? []),
+            unresolvedReceiverMembers: summarizeUnresolvedReceivers(resolutionOutcomes),
             analysisFeatures: currentAnalysisFeatures,
             // Always stamped with the live resolved mode (#2331/#2339) — unlike
             // `pdg` below, 'none' is a meaningful value to compare, not an

package/dist/storage/parse-cache.js

@@ -225,7 +225,26 @@ import { fileURLToPath } from 'url';
 // cache would serve entries that are missing those matches entirely — the
 // exact failure a bump exists to prevent. Verified against origin/main at
 // a857f4c5a, which is still on 43, so 44 is free. RE-CHECK BEFORE MERGE.
-const SCHEMA_BUMP = 44;
+// 44 -> 45: #2837 re-anchors Go's struct/interface captures from the
+// `type_declaration` onto the `type_spec` (`languages/go/query.ts`
+// @scope.class/@declaration.struct/@declaration.interface, and GO_QUERIES
+// @definition.struct/@definition.interface in `tree-sitter-queries.ts`). Every
+// Go file declaring a type therefore emits DIFFERENT capture ranges — measured:
+// 70 fixture digests moved with zero change in capture COUNT — and a grouped
+// `type (...)` block emits nodes it previously did not emit at all. Parse-time,
+// so a warm cache would replay pre-fix ParsedFiles and the fix would be a silent
+// no-op on every incremental analyze while still passing every cold-run test.
+//
+// This branch originally took 44 and it COLLIDED: #2842 above merged first and
+// claimed it. The ninth entry in this ledger, and the third EXACT clash. Worth
+// recording HOW it was caught, because the pin test cannot catch it — both PRs
+// asserted `toBe(44)`, which passes even when main is already 44, so the two
+// capture schemas would have shared one PARSE_CACHE_VERSION and the durable
+// ParsedFile store would have replayed pre-fix ParsedFiles verbatim for one of
+// them. Only comparing against origin/main at MERGE time surfaces it.
+// PR #2840 (Objective-C, draft) still claims 44 as well — it must move too.
+// RE-CHECK AGAINST origin/main IMMEDIATELY BEFORE MERGING.
+const SCHEMA_BUMP = 45;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.166",
+  "version": "1.6.10-rc.167",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",