gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/ruby/captures.js

@@ -1,9 +1,11 @@
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { findChild, nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { getRubyParser, getRubyScopeQuery } from './query.js';
 import { recordRubyCacheHit, recordRubyCacheMiss } from './cache-stats.js';
 import { synthesizeRubyReceiverBinding, findEnclosingClassOrModule } from './receiver-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { splitQualifiedName } from '../../utils/qualified-name.js';
+import { encodeMarker } from '../../utils/heritage-marker.js';
 const FUNCTION_NODE_TYPES = ['method', 'singleton_method'];
 const HERITAGE_CALL_NAMES = new Set(['include', 'extend', 'prepend']);
 const ATTR_CALL_NAMES = new Set([
@@ -11,6 +13,35 @@ const ATTR_CALL_NAMES = new Set([
     'attr_reader',
     'attr_writer',
 ]);
+/**
+ * Build the full `.`-joined qualified owner name for a heritage/attr call by
+ * walking ALL enclosing class/module ancestors (not just the immediate one),
+ * so a same-tail nested owner (`module Outer; class Inner`) is keyed by its
+ * full path `Outer.Inner` instead of the bare tail `Inner` — which otherwise
+ * collapses both same-tail owners onto one `__heritage__`/`__property__` marker
+ * key (last-wins) and cross-wires their mixin / attr_accessor edges (#1982).
+ * Handles the compact `class Outer::Inner` form (name is a `scope_resolution`)
+ * via the shared normalizer, so the marker owner byte-matches the resolution
+ * def's `qualifiedName`. Returns undefined when there is no enclosing class/module.
+ */
+function buildEnclosingQualifiedName(callNode) {
+    const segments = [];
+    let current = callNode.parent;
+    while (current !== null) {
+        if (current.type === 'class' || current.type === 'module') {
+            const nameNode = current.childForFieldName('name');
+            if (nameNode !== null)
+                segments.unshift(...splitQualifiedName(nameNode.text));
+        }
+        // Stop at the file root — nothing above `program` contributes a Ruby
+        // class/module scope segment (#1982 perf; avoids walking to the very top
+        // for every heritage/attr call).
+        if (current.type === 'program')
+            break;
+        current = current.parent;
+    }
+    return segments.length > 0 ? segments.join('.') : undefined;
+}
 export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -37,18 +68,25 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     const out = [];
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The query already hands us each
+        // matched node as c.node, so anchors are used directly (via nodeIfType)
+        // instead of re-deriving them with findNodeAtRange(tree.rootNode, ...) per
+        // match — the O(matches x rootChildren) root-walk fixed for go #1915 /
+        // python #1918, mirrored here.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             if (tag.startsWith('@_'))
                 continue;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
         // Decompose require/require_relative/load into import captures
         if (grouped['@import.statement'] !== undefined) {
             const anchor = grouped['@import.statement'];
-            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'call');
+            const callNode = nodeIfType(nodeMap['@import.statement'], 'call');
             if (callNode !== null) {
                 const decomposed = decomposeRubyImport(callNode, anchor);
                 if (decomposed !== null) {
@@ -61,8 +99,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         // Synthesize self receiver bindings for methods inside class/module
         if (grouped['@scope.function'] !== undefined) {
-            const scopeCap = grouped['@scope.function'];
-            const fnNode = findFunctionNode(tree.rootNode, scopeCap.range);
+            const fnNode = nodeIfType(nodeMap['@scope.function'], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 const enclosingNode = findEnclosingClassOrModule(fnNode);
                 const receiver = synthesizeRubyReceiverBinding(fnNode, enclosingNode);
@@ -74,8 +111,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         // Reclassify declaration.function as declaration.method + attach arity
         if (grouped['@declaration.function'] !== undefined) {
-            const anchorCap = grouped['@declaration.function'];
-            const fnNode = findFunctionNode(tree.rootNode, anchorCap.range);
+            const fnNode = nodeIfType(nodeMap['@declaration.function'], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 const enclosingNode = findEnclosingClassOrModule(fnNode);
                 if (enclosingNode !== null) {
@@ -105,21 +141,27 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         if (grouped['@reference.call.free'] !== undefined && grouped['@reference.name'] !== undefined) {
             const callName = grouped['@reference.name'].text;
             if (HERITAGE_CALL_NAMES.has(callName)) {
-                const callNode = findNodeAtRange(tree.rootNode, grouped['@reference.call.free'].range, 'call');
+                const callNode = nodeIfType(nodeMap['@reference.call.free'], 'call');
                 if (callNode !== null) {
-                    const enclosing = findEnclosingClassOrModule(callNode);
-                    const ownerName = enclosing?.childForFieldName('name')?.text;
+                    const ownerName = buildEnclosingQualifiedName(callNode);
                     if (ownerName) {
                         const argList = callNode.childForFieldName('arguments');
                         if (argList !== null) {
                             for (let ai = 0; ai < argList.namedChildCount; ai++) {
                                 const arg = argList.namedChild(ai);
                                 if (arg !== null && (arg.type === 'constant' || arg.type === 'scope_resolution')) {
+                                    // Normalize a qualified mixin arg (`Outer::Mixin`) to its dotted
+                                    // form (`Outer.Mixin`) BEFORE embedding it in the ':'-delimited
+                                    // __heritage__ marker: the raw `::` collides with the marker's `:`
+                                    // field separator and emitRubyMixinEdges mis-splits it, dropping
+                                    // the edge (#1982). The dotted form also matches the mixin def's
+                                    // qualifiedName key for resolution. Simple names are unchanged.
+                                    const mixinName = splitQualifiedName(arg.text).join('.');
                                     out.push({
                                         '@import.statement': grouped['@reference.call.free'],
                                         '@import.kind': syntheticCapture('@import.kind', callNode, 'namespace'),
-                                        '@import.source': syntheticCapture('@import.source', callNode, `__heritage__:${callName}:${arg.text}:${ownerName}`),
-                                        '@import.name': syntheticCapture('@import.name', callNode, arg.text),
+                                        '@import.source': syntheticCapture('@import.source', callNode, encodeMarker('heritage', [callName, mixinName, ownerName])),
+                                        '@import.name': syntheticCapture('@import.name', callNode, mixinName),
                                     });
                                 }
                             }
@@ -134,21 +176,20 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
             // localDefs and gets reconciled into model.fields, enabling write-access
             // resolution via receiver-bound-calls (Case 4 → findOwnedMember).
             if (ATTR_CALL_NAMES.has(callName)) {
-                const callNode = findNodeAtRange(tree.rootNode, grouped['@reference.call.free'].range, 'call');
+                const callNode = nodeIfType(nodeMap['@reference.call.free'], 'call');
                 if (callNode !== null) {
-                    const enclosing = findEnclosingClassOrModule(callNode);
-                    const ownerName = enclosing?.childForFieldName('name')?.text;
+                    const ownerName = buildEnclosingQualifiedName(callNode);
                     if (ownerName) {
                         const argList = callNode.childForFieldName('arguments');
                         if (argList !== null) {
                             for (let ai = 0; ai < argList.namedChildCount; ai++) {
                                 const arg = argList.namedChild(ai);
-                                if (arg !== null && (arg.type === 'simple_symbol' || arg.type === 'symbol')) {
+                                if (arg !== null && arg.type === 'simple_symbol') {
                                     const propName = arg.text.replace(/^:/, '');
                                     out.push({
                                         '@import.statement': grouped['@reference.call.free'],
                                         '@import.kind': syntheticCapture('@import.kind', callNode, 'namespace'),
-                                        '@import.source': syntheticCapture('@import.source', callNode, `__property__:${callName}:${propName}:${ownerName}`),
+                                        '@import.source': syntheticCapture('@import.source', callNode, encodeMarker('property', [callName, propName, ownerName])),
                                         '@import.name': syntheticCapture('@import.name', callNode, propName),
                                     });
                                     // Emit a property declaration so the property flows into
@@ -168,8 +209,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         // Attach call arity for call expressions
         const callTag = ['@reference.call.free', '@reference.call.member'].find((t) => grouped[t] !== undefined);
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
-            const anchor = grouped[callTag];
-            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'call');
+            const callNode = nodeIfType(nodeMap[callTag], 'call');
             if (callNode !== null) {
                 const arity = computeRubyCallArity(callNode);
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(arity));
@@ -261,7 +301,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                     if (argList !== null) {
                         for (let ai = 0; ai < argList.namedChildCount; ai++) {
                             const arg = argList.namedChild(ai);
-                            if (arg !== null && (arg.type === 'simple_symbol' || arg.type === 'symbol')) {
+                            if (arg !== null && arg.type === 'simple_symbol') {
                                 const propName = arg.text.replace(/^:/, '');
                                 out.push({
                                     '@type-binding.return': syntheticCapture('@type-binding.return', attrNode, text),
@@ -293,6 +333,29 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     // return-type binding `methodName → ClassName` on the method node.
     // This enables cross-file return-type propagation for factory methods
     // like `def self.get_user; User.new; end` → `get_user → User`.
+    // Keys of methods that already got a return binding from the YARD pass above,
+    // precomputed once. The previous `out.some(...)` per method was
+    // O(methods x out.length) ~ O(n^2); this makes the dedup O(1) per method.
+    // Key = `<name>:<return-binding startLine>`, matching the old AND condition.
+    //
+    // Snapshot-vs-live note (PR #1918 tri-review P3): the old `out.some` was
+    // evaluated LIVE, so it also saw constructor-return bindings this very loop
+    // pushed in earlier iterations. That made the old code suppress the 2nd of
+    // two same-named methods one source row apart whose bodies both end in
+    // `Const.new` (the 1st's pushed binding startLine == the 2nd's row via the
+    // 1-based/0-based offset below). The snapshot is built from the YARD pass
+    // only, so it no longer cross-suppresses — both bindings are emitted, which
+    // is the intended behavior (the cross-suppression was unintended). This
+    // corner is absent from fixtures, so the capture fingerprint is unchanged;
+    // ruby-captures-golden.test.ts pins it explicitly.
+    const yardReturnKeys = new Set();
+    for (const m of out) {
+        const ret = m['@type-binding.return'];
+        const name = m['@type-binding.name'];
+        if (ret !== undefined && name !== undefined) {
+            yardReturnKeys.add(`${name.text}:${ret.range.startLine}`);
+        }
+    }
     for (const methodNode of [
         ...tree.rootNode.descendantsOfType('method'),
         ...tree.rootNode.descendantsOfType('singleton_method'),
@@ -300,10 +363,8 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
         const methodName = methodNode.childForFieldName('name')?.text;
         if (methodName === undefined)
             continue;
-        // Skip if a YARD @return already created a return binding for this method
-        if (out.some((m) => m['@type-binding.return'] !== undefined &&
-            m['@type-binding.name']?.text === methodName &&
-            m['@type-binding.return']?.range.startLine === methodNode.startPosition.row)) {
+        // Skip if a YARD @return already created a return binding for this method.
+        if (yardReturnKeys.has(`${methodName}:${methodNode.startPosition.row}`)) {
             continue;
         }
         const body = methodNode.childForFieldName('body');
@@ -329,8 +390,98 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
             }
         }
     }
+    // Fifth pass: superclass inheritance (`class Foo < Bar`).
+    // Emit `@reference.inherits` captures so the registry-primary scope-
+    // resolution path produces EXTENDS edges (issue #1951). This mirrors the
+    // C#/C++ inheritance synthesis: Ruby's superclass edges previously came
+    // only from the legacy heritage-capture query (removed in #942), which the
+    // worker pipeline drops for registry-primary languages → 0 inheritance edges
+    // in worker mode. Mixins (include/extend/prepend) are NOT touched here — they
+    // flow through `emitHeritageEdges` (the `__heritage__:` import path above),
+    // an independent lane that stays intact when the legacy heritage leg is gated off.
+    out.push(...synthesizeRubySuperclassReferences(tree.rootNode));
+    return out;
+}
+/**
+ * Synthesize `@reference.inherits` captures from Ruby `class Foo < Bar`
+ * superclass declarations so the shared `preEmitInheritanceEdges` pass can
+ * resolve the base to a Class def and emit an EXTENDS edge.
+ *
+ * Scope is `class` nodes whose `superclass` field holds either a bare
+ * `constant` base (`class D < Super`) or a qualified/scoped
+ * `scope_resolution` base (`class C < Outer::Super`, `class E < A::B::C`) —
+ * exactly the two shapes the config-driven legacy heritage alternation
+ * captured (heritage-extractors/configs/ruby.ts
+ * `rubyHeritageShapes: ['constant', 'scope_resolution']`). In prose: the
+ * legacy query matched a `class` whose name is a `constant` and whose
+ * `superclass` is either a `constant` or a `scope_resolution`, capturing the
+ * superclass constant as the inherited base.
+ *
+ * Previously this pass emitted only for a direct `(constant)` child, so the
+ * production registry-primary path silently dropped `Outer::Super`
+ * superclasses while the legacy heritage leg captured them — the exact
+ * EXTENDS/IMPLEMENTS-drop bug of #1951.
+ *
+ * THE PARITY CONTRACT: the `@reference.name` bare text must equal the legacy
+ * leg's `normalizeSupertypeName(baseNode)` reduction. For a `scope_resolution`
+ * (`Outer::Super`, `A::B::C`) the normalizer recurses into the `name:` field
+ * and returns the trailing `constant` (`Super` / `C`); this synth mirrors that
+ * by reading the same `name:` tail. A bare `constant` is unchanged
+ * (byte-identical to the prior emission). `module` nodes are excluded (no
+ * superclass field). Mixins (include/extend/prepend) are untouched — they flow
+ * through the `__heritage__:` import lane above.
+ *
+ * Edge type (EXTENDS vs IMPLEMENTS) is decided downstream from the resolved
+ * target's symbol kind — this pass only emits `@reference.inherits`.
+ */
+function synthesizeRubySuperclassReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type !== 'class')
+            return;
+        const superclass = node.childForFieldName('superclass');
+        if (superclass === null)
+            return;
+        const baseNode = extractRubySuperclassBaseNode(superclass);
+        if (baseNode === null)
+            return;
+        out.push({
+            '@reference.inherits': nodeToCapture('@reference.inherits', baseNode),
+            '@reference.name': nodeToCapture('@reference.name', baseNode),
+        });
+    });
     return out;
 }
+/**
+ * Reduce a Ruby `superclass` node to the bare `constant` the resolver should
+ * look up, at parity with the legacy heritage leg's
+ * `normalizeSupertypeName(baseNode)`:
+ *
+ *   - direct `(constant)` child (`class D < Super`)       → that constant
+ *     (unchanged from the original emission — kept byte-identical)
+ *   - `(scope_resolution)` child (`class C < Outer::Super`,
+ *     `class E < A::B::C`)                                → the trailing
+ *     `name:` constant (`Super` / `C`)
+ *
+ * A `scope_resolution` nests qualifier-first, name-last
+ * (`scope: (...) name: (constant)`), so the `name:` field is always the
+ * trailing simple identifier — the same tail `normalizeSupertypeName` reaches
+ * by recursing through its `name` field. Any other shape returns null (no
+ * edge), keeping this emitter at parity with the legacy alternation
+ * (`['constant', 'scope_resolution']`).
+ */
+function extractRubySuperclassBaseNode(superclass) {
+    const directConstant = findChild(superclass, 'constant');
+    if (directConstant !== null)
+        return directConstant;
+    const scoped = findChild(superclass, 'scope_resolution');
+    if (scoped !== null) {
+        const tail = scoped.childForFieldName('name');
+        if (tail !== null && tail.type === 'constant')
+            return tail;
+    }
+    return null;
+}
 function decomposeRubyImport(callNode, anchor) {
     const methodNode = callNode.childForFieldName('method');
     if (methodNode === null)
@@ -431,14 +582,6 @@ function computeRubyCallArity(callNode) {
     }
     return count;
 }
-function findFunctionNode(rootNode, range) {
-    for (const nodeType of FUNCTION_NODE_TYPES) {
-        const n = findNodeAtRange(rootNode, range, nodeType);
-        if (n !== null)
-            return n;
-    }
-    return null;
-}
 function scopeExtractionError(stage, filePath, err) {
     const reason = err instanceof Error ? err.message : String(err);
     return new Error(`[ruby] tree-sitter ${stage} failed for ${filePath}: ${reason}; skipping scope extraction for this file`);

package/dist/core/ingestion/languages/ruby/import-target.js

@@ -8,6 +8,7 @@
  */
 import { resolveRubyImportInternal } from '../../import-resolvers/ruby.js';
 import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+import { isHeritageMarker } from '../../utils/heritage-marker.js';
 // ─── resolveRubyImportTarget ──────────────────────────────────────────────
 /**
  * ScopeResolver-shaped adapter:
@@ -25,7 +26,7 @@ import { buildSuffixIndex } from '../../import-resolvers/utils.js';
 export function resolveRubyImportTarget(targetRaw, fromFile, allFilePaths, _resolutionConfig) {
     if (!targetRaw)
         return null;
-    if (targetRaw.startsWith('__heritage__:') || targetRaw.startsWith('__property__:'))
+    if (isHeritageMarker(targetRaw))
         return null;
     const fromNormalized = fromFile.replace(/\\/g, '/');
     const fromDir = fromNormalized.includes('/')

package/dist/core/ingestion/languages/ruby/interpret.js

@@ -1,3 +1,4 @@
+import { isHeritageMarker } from '../../utils/heritage-marker.js';
 // ─── interpretImport ──────────────────────────────────────────────────────
 /**
  * Interpret a pre-decomposed Ruby import capture into a `ParsedImport`.
@@ -18,7 +19,7 @@ export function interpretRubyImport(captures) {
         return null;
     // Heritage-encoded imports (__heritage__:include:Serializable:User)
     // are stored as namespace imports so emitHeritageEdges can read them.
-    if (source.startsWith('__heritage__:') || source.startsWith('__property__:')) {
+    if (isHeritageMarker(source)) {
         const name = captures['@import.name']?.text ?? source;
         return { kind: 'namespace', localName: name, importedName: name, targetRaw: source };
     }

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

@@ -52,11 +52,21 @@ const RUBY_SCOPE_QUERY = `
 (class
   name: (constant) @declaration.name) @declaration.class
 
+;; class Foo::Bar — namespaced class definition
+(class
+  name: (scope_resolution
+    name: (constant) @declaration.name)) @declaration.class
+
 ;; ── Declarations — module (labeled Trait for class-like registry lookup) ─
 
 (module
   name: (constant) @declaration.name) @declaration.trait
 
+;; module Baz::Qux — namespaced module definition
+(module
+  name: (scope_resolution
+    name: (constant) @declaration.name)) @declaration.trait
+
 ;; ── Declarations — method (instance) ─────────────────────────────────────
 
 (method

package/dist/core/ingestion/languages/ruby/scope-resolver.js

@@ -5,17 +5,59 @@ import { rubyArityCompatibility, rubyMergeBindings, resolveRubyImportTarget } fr
 import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { generateId } from '../../../../lib/utils.js';
-const HERITAGE_PREFIX = '__heritage__:';
+import { decodeMarker } from '../../utils/heritage-marker.js';
+/**
+ * #1991: resolve a BARE mixin reference (`include Loggable`) to a nested module by
+ * the INCLUDING class's lexical scope — Ruby looks up a constant in the innermost
+ * enclosing scope first. For owner `App.S`, try `App.Loggable`, then walk outward.
+ * Returns undefined if no enclosing-scope-qualified module exists.
+ */
+function qualifyMixinByOwnerScope(mixinName, ownerName, graphIdByName) {
+    let prefix = ownerName;
+    let dot = prefix.lastIndexOf('.');
+    while (dot !== -1) {
+        prefix = prefix.slice(0, dot);
+        const g = graphIdByName.get(`${prefix}.${mixinName}`);
+        if (g !== undefined)
+            return g;
+        dot = prefix.lastIndexOf('.');
+    }
+    return undefined;
+}
 function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     const graphIdByName = new Map();
+    // Secondary tail -> graphId map. The `__heritage__` marker carries the mixin
+    // TARGET as the bare written name (`arg.text`, e.g. `Loggable`), not its full
+    // qualifiedName, so a nested mixin module included by its short name misses the
+    // full-qn map. We first resolve it lexically by the including class's enclosing
+    // scope (`qualifyMixinByOwnerScope`); this tail map is the last resort. A genuine
+    // same-tail collision is mapped to `null` so we REFUSE to guess (#1991) rather
+    // than the old first-wins, which cross-wired App::Loggable / Web::Loggable.
+    const graphIdByTail = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
             if (!isClassLike(def.type))
                 continue;
             const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
             if (graphId !== undefined) {
-                const simpleName = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-                graphIdByName.set(simpleName, graphId);
+                // Key by the FULL qualified name (`Outer.Inner`), NOT the simple tail.
+                // Same-tail nested classes (`Outer::Inner` + `Other::Inner`) otherwise
+                // collapse onto one `Inner` key (last-wins) and cross-wire their mixin /
+                // attr_accessor owners (#1982). The `__heritage__`/`__property__` markers
+                // carry the full qualified owner name in lockstep (see ruby/captures.ts).
+                const fullName = def.qualifiedName ?? '';
+                if (fullName.length > 0) {
+                    graphIdByName.set(fullName, graphId);
+                    const dot = fullName.lastIndexOf('.');
+                    const tail = dot === -1 ? fullName : fullName.slice(dot + 1);
+                    if (tail.length > 0) {
+                        const existingTail = graphIdByTail.get(tail);
+                        if (existingTail === undefined)
+                            graphIdByTail.set(tail, graphId);
+                        else if (existingTail !== null && existingTail !== graphId)
+                            graphIdByTail.set(tail, null); // same-tail collision — refuse to guess
+                    }
+                }
             }
         }
     }
@@ -28,14 +70,22 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     }
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
-            if (!imp.targetRaw.startsWith(HERITAGE_PREFIX))
+            const decoded = decodeMarker(imp.targetRaw);
+            if (decoded?.kind !== 'heritage')
                 continue;
-            const parts = imp.targetRaw.slice(HERITAGE_PREFIX.length).split(':');
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [kind, mixinName, className] = parts;
             const classGraphId = graphIdByName.get(className);
-            const mixinGraphId = graphIdByName.get(mixinName);
+            // Owner stays full-qn. The mixin target may be written by short name and miss
+            // the full-qn map; resolve it lexically by the including class's enclosing
+            // scope (`App::S` + `Loggable` -> `App::Loggable`), then fall back to the tail
+            // map ONLY when unambiguous — never first-wins on a collision (#1982/#1991).
+            const mixinGraphId = graphIdByName.get(mixinName) ??
+                qualifyMixinByOwnerScope(mixinName, className, graphIdByName) ??
+                graphIdByTail.get(mixinName) ??
+                undefined;
             if (classGraphId === undefined || mixinGraphId === undefined)
                 continue;
             const edgeKey = `${classGraphId}->${mixinGraphId}:${kind}`;
@@ -62,12 +112,12 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
             existingProps.add(`${rel.sourceId}->prop:${targetNode.properties.name}`);
         }
     }
-    const PROPERTY_PREFIX = '__property__:';
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
-            if (!imp.targetRaw.startsWith(PROPERTY_PREFIX))
+            const decoded = decodeMarker(imp.targetRaw);
+            if (decoded?.kind !== 'property')
                 continue;
-            const parts = imp.targetRaw.slice(PROPERTY_PREFIX.length).split(':');
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [_attrKind, propName, className] = parts;
@@ -137,8 +187,8 @@ function buildRubyMro(graph, parsedFiles, nodeLookup) {
     }
     // Step 4: Reorder MRO per Ruby semantics.
     // Order: prepend (reversed) → direct extends chain → include (reversed).
-    // `extend` is excluded — it belongs to singleton dispatch only (legacy
-    // `getInstanceAncestry` in heritage-map.ts explicitly drops extend entries).
+    // `extend` is excluded — it belongs to singleton dispatch only (the
+    // instance-ancestry walk drops extend entries).
     // Reversed because Ruby declaration order means last-declared wins
     // (prepend B; prepend A → B checked before A).
     for (const defId of defIdByGraphId.values()) {

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

@@ -24,10 +24,6 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { rubyVariableConfig } from '../variable-extractors/configs/ruby.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { rubyCallConfig } from '../call-extractors/configs/ruby.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
-import { rubyHeritageConfig } from '../heritage-extractors/configs/ruby.js';
-import { maybeRewriteRubyBareCallToSelf } from '../utils/ruby-self-call.js';
-import { findEnclosingClassInfo } from '../utils/ast-helpers.js';
 import { emitRubyScopeCaptures, rubyArityCompatibility, rubyBindingScopeFor, rubyImportOwningScope, rubyReceiverBinding, interpretRubyImport, interpretRubyTypeBinding, } from './ruby/index.js';
 /**
  * Ruby label override. Applied to:
@@ -122,7 +118,8 @@ const BUILT_INS = new Set([
 /**
  * Remaps `class << self` (singleton_class) to its enclosing class/module for
  * receiver inference. A `singleton_class` node is not itself a type — walking
- * up to the real owner lets `inferImplicitReceiver` set `hint='singleton'`.
+ * up to the real owner resolves the singleton's enclosing class for the
+ * `resolveEnclosingOwner` scope-resolution hook.
  * Returns null for orphaned singleton_class (no enclosing class/module found).
  * All other container types are returned as-is.
  */
@@ -172,7 +169,6 @@ export const rubyProvider = defineLanguage({
     exportChecker: rubyExportChecker,
     importResolver: createImportResolver(rubyImportConfig),
     callRouter: routeRubyCall,
-    importSemantics: 'wildcard-leaf',
     callExtractor: createCallExtractor(rubyCallConfig),
     resolveEnclosingOwner: rubyResolveEnclosingOwner,
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
@@ -182,56 +178,11 @@ export const rubyProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(rubyVariableConfig),
     classExtractor: createClassExtractor(rubyClassConfig),
-    heritageExtractor: createHeritageExtractor(rubyHeritageConfig),
     labelOverride: rubyLabelOverride,
     // Ruby MRO is kind-aware: prepend providers beat the class's own method,
-    // which in turn beats include providers. See `lookupMethodByOwnerWithMRO`
-    // in `model/resolve.ts` for the walk order.
+    // which in turn beats include providers. The graph-level MRO phase
+    // (mro-processor.ts) and per-resolver buildMro consume this strategy.
     mroStrategy: 'ruby-mixin',
-    // ── DAG hooks ────────────────────────────────────────────────────
-    //
-    // DAG stage 3: rewrite bare calls (e.g. `serialize` in Account#call_serialize)
-    // as `self.serialize` so they route through owner-scoped MRO instead of
-    // global free-call lookup. `dispatchKind` goes into `hint` for stage 4.
-    inferImplicitReceiver: ({ calledName, callForm, receiverName, receiverTypeName, callNode, filePath, }) => {
-        // Only fire when no receiver has been resolved already.
-        if (receiverName || receiverTypeName)
-            return null;
-        const enclosing = findEnclosingClassInfo(callNode, filePath, rubyResolveEnclosingOwner);
-        const rewrite = maybeRewriteRubyBareCallToSelf(calledName, callForm, callNode, enclosing?.className ?? null, { isBuiltInName: (n) => BUILT_INS.has(n), mroStrategy: 'ruby-mixin' });
-        if (!rewrite)
-            return null;
-        return {
-            callForm: rewrite.callForm,
-            receiverName: rewrite.receiverName,
-            receiverTypeName: rewrite.receiverTypeName,
-            receiverSource: 'implicit-self',
-            hint: rewrite.dispatchKind, // 'instance' | 'singleton'
-        };
-    },
-    // DAG stage 4: two Ruby dispatch overrides —
-    //   implicit-self: MRO walk first, fallback to free-arity-narrowed on miss.
-    //   class-as-receiver: singleton ancestry (extend providers only); miss null-routes.
-    selectDispatch: ({ receiverSource, hint }) => {
-        if (receiverSource === 'implicit-self') {
-            // hint='instance' → instance ancestry (prepend→direct→include, see mro-strategy.ts § 'ruby-mixin')
-            // hint='singleton' → singleton ancestry (extend providers only; miss null-routes)
-            const ancestryView = hint === 'singleton' ? 'singleton' : 'instance';
-            return {
-                primary: 'owner-scoped',
-                fallback: 'free-arity-narrowed',
-                ancestryView,
-            };
-        }
-        if (receiverSource === 'class-as-receiver') {
-            // Class constant receiver (e.g. Account.log): singleton ancestry only; miss null-routes.
-            return {
-                primary: 'owner-scoped',
-                ancestryView: 'singleton',
-            };
-        }
-        return null;
-    },
     builtInNames: BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
     emitScopeCaptures: emitRubyScopeCaptures,