fix(ingestion): #1981 stack follow-ups — Rust method-id collision (F3) + C++ sidecar typing (F4) + Ruby Trait predicate (F5)

[magyargergo]

Addresses the deferred §5 follow-ups from the #1981 stack tri-review (docs/plans/2026-06-03-006-pr-1981-stack-tri-review-action-plan.md). Stacked on top of #2007 (fix/1994-shared-marker-codec) on purpose: the action plan parked these as post-merge tickets because applying them to the lower lanes (#2003/#2005/#2006) would cascade a re-rebase of every PR above them. Landing them here touches none of the stacked PRs.

Merge order: this sits at the very top of the chain — merge after #2003→#2004→#2005→#2006→#2007. As #2007 merges, GitHub auto-retargets this PR's base to main.

F3 (#1992) — latent same-tail Rust method-node collision · the one real bug

Two same-tail generic inherent impls under sibling mods that also share a method name collapsed onto one graph node:

mod a { pub struct Inner<T>{v:T} impl<T> Inner<T>{ pub fn m(&self){} } }
mod b { pub struct Inner<T>{v:T} impl<T> Inner<T>{ pub fn m(&self){} } }

The method node id keys ${className}.${name}; the bare inherent-impl arm set className to the bare tail (Inner), so both ms keyed Function:lib.rs:Inner.m#0 and the second was silently dropped (graph.addNode is first-write-wins). The owner Impl classId was already mod-qualified, so the two HAS_METHOD sources stayed distinct — which is exactly what masked the collision (sourceId-only assertions passed while both edges pointed at the same surviving target node).

Fix: qualify className (a.Inner / b.Inner) in the bare type_identifier impl arm so the method node id inherits the mod scope (a.Inner.m / b.Inner.m). Symmetric by construction — the call-resolution fallback (call-processor.ts, parse-worker.ts) rebuilds ${className}.${name} from the same enclosing-impl walk, so definition and call ids still agree, and HAS_METHOD anchors on the unchanged qualified classId. The for-target and scoped arms are deliberately untouched (their className must stay bare/raw to match their node ids).

Scope note: this is graph-view-only — registry-primary call resolution was already correct (it keys by mod-qualified ownerId + simple name), so no call was ever mis-resolved. New rust-generic-impl-same-method-name fixture + sequential & worker-parity tests assert two distinct nodes survive.

F4 (#1993) — type the namespacePrefix sidecar, drop the casts

Declared namespacePrefix?: string on SymbolDefinition (gitnexus-shared) and removed the six as { namespacePrefix?: string } casts in walkers.ts / graph-bridge/ids.ts. Pure type-level — the as assertions erase at compile time, emitted JS is byte-identical, and the field remains a sidecar (no graph-node identity; the qualifiedName-keyed index is untouched).

F5 (#1991) — single-source the Ruby Trait scope-label predicate

Replaced the four hardcoded nodeLabel === 'Trait' checks (two each in the sequential parsing-processor.ts and worker parse-worker.ts definition paths) with one isQualifiableScopeLabel() in ast-helpers.ts, so the lockstep paths can't drift. Value-identical predicate.

Not in this PR

• F1 (fix(ingestion): qualify Rust GENERIC inherent-impl target by mod scope (same-tail impl Inner<T> collapse) #1992 language-neutrality) — moving the Rust impl_item owner walk behind a provider hook is not a clean move (the existing resolveEnclosingOwner is a SyntaxNode remapper that can't carry EnclosingClassInfo; a correct version needs a new resolveEnclosingClassInfo hook threaded through 8 call sites — 2 of which have no provider in scope — plus Go, which is hardcoded in the same function). Split out as Extract Rust/Go inherent-impl enclosing-owner resolution behind a LanguageProvider hook (#1992 follow-up, tri-review F1) #2021 for a dedicated, parity-tested refactor.
• F2 (Rust worker-path parity) — investigated; already present (rust.test.ts fix(ingestion): qualify Rust GENERIC inherent-impl target by mod scope (same-tail impl Inner<T> collapse) #1992 worker block). No gap, no change needed.

Verification

• gitnexus-shared build + gitnexus src tsc — clean (0 errors)
• Rust resolver suite both legs + worker parity: 178/178 default, 176 + 2-skip legacy (the 2 are the pre-registered macro parity exceptions), incl. the new F3 tests
• Ruby + C++ registry-primary: 446/446
• rust-coverage + rust-scope: 42/42
• eslint 0 errors (pre-existing ! style warnings only); prettier clean

Post-merge

F3 changes Rust inherent-impl method node ids (Inner.m → a.Inner.m), so the embeddings re-key note from the action plan applies — fold into the same clean re-analyze the stack already calls for.

---

🤖 Generated with Claude Code

[vercel]

@magyargergo is attempting to deploy a commit to the NexusCore Team on Vercel.

A member of the Team first needs to authorize it.

[magyargergo]

Closed as superseded — the three findings here were folded into their home PRs and merged via the stack: F3 (Rust same-tail method-id collision) → #2003, F4 (namespacePrefix typing) → #2005, F5 (Trait predicate single-sourcing) → #2006. Each shipped with its bench-baseline / captures-golden regeneration and survived the #2023 (#942 legacy-DAG removal) merge. F1 (Rust/Go enclosing-owner provider hook) remains tracked in #2021. All three are now on main.