gitnexus 1.6.6-rc.134 → 1.6.6-rc.136

package/dist/core/ingestion/class-extractors/generic.js

@@ -124,6 +124,13 @@ export function createClassExtractor(config) {
         extractQualifiedName(node, simpleName) {
             return extract(node, { name: simpleName })?.qualifiedName ?? null;
         },
+        // #1991: qualify a non-typeDeclaration scope node (e.g. a Ruby `module` → Trait)
+        // by the same ancestor-scope walk the node-id path uses, so two same-tail nested
+        // mixin modules stay distinct. extract()/extractQualifiedName cannot be reused —
+        // they bail on non-typeDeclarations (a module is not in typeDeclarationNodes).
+        qualifyScopeName(node, simpleName) {
+            return buildQualifiedName(node, simpleName);
+        },
         shouldSkipClassCapture(context) {
             return config.shouldSkipClassCapture?.(context) ?? false;
         },

package/dist/core/ingestion/class-types.d.ts

@@ -34,6 +34,14 @@ export interface ClassExtractor {
         type?: NodeLabel | null;
     }): ExtractedClassSymbol | null;
     extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
+    /**
+     * #1991: qualify a scope-defining node that maps to a class-like registry label
+     * (e.g. a Ruby `module` → Trait) but is NOT a typeDeclaration, so it cannot go
+     * through extract()/extractQualifiedName (which bail on non-typeDeclarations).
+     * Walks the same ancestor scopes as the node-id path. Optional — only providers
+     * that materialize such nodes implement it.
+     */
+    qualifyScopeName?(node: SyntaxNode, simpleName: string): string;
     shouldSkipClassCapture?(context: ClassCaptureContext & {
         nodeLabel: ClassLikeNodeLabel;
     }): boolean;

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

@@ -33,7 +33,7 @@ import { getDartParser, getDartScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
-import { DART_HERITAGE_PREFIX } from './interpret.js';
+import { encodeMarker } from '../../utils/heritage-marker.js';
 import { DART_BUILT_INS } from './built-ins.js';
 const FUNCTION_DECL_TAGS = [
     '@declaration.function',
@@ -439,7 +439,7 @@ function emitHeritageMarkers(container, kind, className, out) {
         const c = container.namedChild(i);
         if (c === null || c.type !== 'type_identifier')
             continue;
-        const payload = `${DART_HERITAGE_PREFIX}${kind}:${c.text}:${className}`;
+        const payload = encodeMarker('heritage', [kind, c.text, className]);
         out.push({ '@import.heritage': syntheticCapture('@import.heritage', c, payload) });
     }
 }

package/dist/core/ingestion/languages/dart/interpret.d.ts

@@ -15,8 +15,10 @@
  */
 import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
 /** Marker prefix carried on a side-effect `ParsedImport.targetRaw` for
- *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. */
-export declare const DART_HERITAGE_PREFIX = "__heritage__:";
+ *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. Aliased to
+ *  the shared codec prefix (#1994) so the Dart wire prefix has a single source of
+ *  truth and cannot desync from `encodeMarker`/`decodeMarker`. */
+export declare const DART_HERITAGE_PREFIX: string;
 export declare function interpretDartImport(captures: CaptureMatch): ParsedImport | null;
 export declare function normalizeDartType(text: string): string;
 export declare function interpretDartTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

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

@@ -13,9 +13,12 @@
  *     normalizing the Dart type (strip nullable `?`, unwrap single-arg
  *     container generics like `Future<X>`/`List<X>`, drop library prefixes).
  */
+import { HERITAGE_MARKER_PREFIX } from '../../utils/heritage-marker.js';
 /** Marker prefix carried on a side-effect `ParsedImport.targetRaw` for
- *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. */
-export const DART_HERITAGE_PREFIX = '__heritage__:';
+ *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. Aliased to
+ *  the shared codec prefix (#1994) so the Dart wire prefix has a single source of
+ *  truth and cannot desync from `encodeMarker`/`decodeMarker`. */
+export const DART_HERITAGE_PREFIX = HERITAGE_MARKER_PREFIX;
 function stripQuotes(s) {
     return s.replace(/^['"]|['"]$/g, '');
 }

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

@@ -31,7 +31,8 @@ import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/s
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { generateId } from '../../../../lib/utils.js';
 import { dartProvider } from '../dart.js';
-import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget, DART_HERITAGE_PREFIX, } from './index.js';
+import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget } from './index.js';
+import { decodeMarker } from '../../utils/heritage-marker.js';
 import { expandDartWildcardNames } from './expand-wildcards.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
@@ -88,9 +89,12 @@ function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
             const raw = imp.targetRaw;
-            if (typeof raw !== 'string' || !raw.startsWith(DART_HERITAGE_PREFIX))
+            if (typeof raw !== 'string')
                 continue;
-            const parts = raw.slice(DART_HERITAGE_PREFIX.length).split(':');
+            const decoded = decodeMarker(raw);
+            if (decoded?.kind !== 'heritage')
+                continue;
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [kind, baseName, childName] = parts;

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

@@ -5,6 +5,7 @@ import { synthesizeRubyReceiverBinding, findEnclosingClassOrModule } from './rec
 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([
@@ -159,7 +160,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                                     out.push({
                                         '@import.statement': grouped['@reference.call.free'],
                                         '@import.kind': syntheticCapture('@import.kind', callNode, 'namespace'),
-                                        '@import.source': syntheticCapture('@import.source', callNode, `__heritage__:${callName}:${mixinName}:${ownerName}`),
+                                        '@import.source': syntheticCapture('@import.source', callNode, encodeMarker('heritage', [callName, mixinName, ownerName])),
                                         '@import.name': syntheticCapture('@import.name', callNode, mixinName),
                                     });
                                 }
@@ -188,7 +189,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                                     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

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/scope-resolver.js

@@ -5,18 +5,34 @@ 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__:';
-const PROPERTY_PREFIX = '__property__:';
+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 (first-wins). 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
-    // (`include Loggable` where it is `App::Loggable`) misses the full-qn map and
-    // its IMPLEMENTS edge is silently dropped (#1982 follow-up). The tail fallback
-    // recovers it. OWNER (`className`) lookups stay full-qn only, preserving
-    // same-tail owner disambiguation; only the under-qualified mixin reference
-    // falls back, and a genuine same-tail mixin tie there resolves first-wins.
+    // 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) {
@@ -34,8 +50,13 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
                     graphIdByName.set(fullName, graphId);
                     const dot = fullName.lastIndexOf('.');
                     const tail = dot === -1 ? fullName : fullName.slice(dot + 1);
-                    if (tail.length > 0 && !graphIdByTail.has(tail))
-                        graphIdByTail.set(tail, graphId);
+                    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
+                    }
                 }
             }
         }
@@ -49,16 +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);
-            // Owner stays full-qn; the mixin target may be written by short name and
-            // miss the full-qn map, so fall back to the simple-tail map (#1982).
-            const mixinGraphId = graphIdByName.get(mixinName) ?? graphIdByTail.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}`;
@@ -87,9 +114,10 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     }
     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;

package/dist/core/ingestion/parsing-processor.js

@@ -7,7 +7,7 @@ import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { buildConcreteTypedefDefinitionRanges, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, isSuppressedConcreteTypedefDuplicate, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { buildConcreteTypedefDefinitionRanges, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, isSuppressedConcreteTypedefDuplicate, isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from './utils/method-props.js';
@@ -450,7 +450,14 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             // the qualified class node id computed below. Gated on the flag, so the
             // owner walk and its cache entry are byte-identical when the flag is off.
             const getQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
-                ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                ? (node, simpleName) => 
+                // #1991: a Ruby `module` owner is not a typeDeclaration, so
+                // extractQualifiedName returns null; fall back to the scope walk so a
+                // method inside a nested module owns through the SAME qualified Trait
+                // id its node uses (App.Loggable), not a dangling bare id.
+                provider.classExtractor.extractQualifiedName(node, simpleName) ??
+                    provider.classExtractor.qualifyScopeName?.(node, simpleName) ??
+                    null
                 : undefined;
             const enclosingClassInfo = needsOwner
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
@@ -468,7 +475,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
                     ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
-                    : undefined);
+                    : // #1991: a Ruby `module` maps to Trait (class-like registry) but is not a
+                        // typeDeclaration, so extractQualifiedName bails. Qualify it via the scope
+                        // walk so two same-tail nested mixin modules get distinct ids. Gated on
+                        // qualifiedNodeId, so languages without the flag are unaffected.
+                        isQualifiableScopeLabel(nodeLabel) &&
+                            provider.classExtractor?.qualifiedNodeId === true &&
+                            classNodeForSymbol
+                            ? (provider.classExtractor.qualifyScopeName?.(classNodeForSymbol, nodeName) ??
+                                undefined)
+                            : undefined);
             // Qualify method/property IDs with enclosing class name to avoid collisions
             // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak".
             // Class-like nodes use their own fully-qualified path as the id key when the
@@ -487,13 +503,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 : undefined;
             const qualifiedName = rustImplQualifiedName !== undefined
                 ? rustImplQualifiedName
-                : isClassLikeLabel &&
-                    provider.classExtractor?.qualifiedNodeId === true &&
-                    qualifiedTypeName !== undefined
-                    ? qualifiedTypeName
-                    : enclosingClassInfo
-                        ? `${enclosingClassInfo.className}.${nodeName}`
-                        : nodeName;
+                : // #1991: include Trait so a Ruby mixin module's qualified scope id keys
+                    // the node, mirroring the class-like path (qualifiedTypeName is computed
+                    // for Trait above).
+                    (isClassLikeLabel || isQualifiableScopeLabel(nodeLabel)) &&
+                        provider.classExtractor?.qualifiedNodeId === true &&
+                        qualifiedTypeName !== undefined
+                        ? qualifiedTypeName
+                        : enclosingClassInfo
+                            ? `${enclosingClassInfo.className}.${nodeName}`
+                            : nodeName;
             // Extract method metadata for Function/Method/Constructor nodes BEFORE generating
             // the node ID — parameterCount is needed to disambiguate overloaded methods.
             // Use the per-language MethodExtractor for method metadata (isAbstract, isStatic,

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -17,6 +17,17 @@ export type SyntaxNode = Parser.SyntaxNode;
  * parse-worker mirrors this so the owner edge and node id agree byte-for-byte.
  */
 export declare const qualifyRustImplTargetByModScope: (implNode: SyntaxNode, rawTargetText: string) => string;
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export declare const isQualifiableScopeLabel: (nodeLabel: string) => boolean;
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.

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

@@ -28,6 +28,17 @@ export const qualifyRustImplTargetByModScope = (implNode, rawTargetText) => {
     }
     return [...modSegments, ...splitQualifiedName(rawTargetText)].filter(Boolean).join('.');
 };
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export const isQualifiableScopeLabel = (nodeLabel) => nodeLabel === 'Trait';
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.

package/dist/core/ingestion/utils/heritage-marker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * #1994: shared codec for the synthetic `__heritage__:` / `__property__:` import
+ * markers used by the Ruby and Dart scope resolvers to carry side-effect facts
+ * (mixin includes, attr_accessor properties) through the import channel. Both
+ * languages share the exact `':'`-delimited wire format, so a single encode/decode
+ * pair removes the per-site hand-rolled string handling that produced the #1981
+ * edge-drop. Language-NEUTRAL — keyed only on the literal prefixes; no provider
+ * branching belongs here.
+ */
+export type MarkerKind = 'heritage' | 'property';
+export declare const HERITAGE_MARKER_PREFIX: string;
+export declare const PROPERTY_MARKER_PREFIX: string;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export declare function encodeMarker(kind: MarkerKind, fields: readonly string[]): string;
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export declare function decodeMarker(raw: string): {
+    kind: MarkerKind;
+    fields: string[];
+} | null;
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export declare function isHeritageMarker(raw: string): boolean;

package/dist/core/ingestion/utils/heritage-marker.js

@@ -0,0 +1,41 @@
+const PREFIX_BY_KIND = {
+    heritage: '__heritage__:',
+    property: '__property__:',
+};
+export const HERITAGE_MARKER_PREFIX = PREFIX_BY_KIND.heritage;
+export const PROPERTY_MARKER_PREFIX = PREFIX_BY_KIND.property;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export function encodeMarker(kind, fields) {
+    for (const field of fields) {
+        if (field.includes(':')) {
+            throw new Error(`encodeMarker: field "${field}" contains the ':' delimiter; normalize it before encoding`);
+        }
+    }
+    return PREFIX_BY_KIND[kind] + fields.join(':');
+}
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export function decodeMarker(raw) {
+    if (raw.startsWith(PREFIX_BY_KIND.heritage)) {
+        return { kind: 'heritage', fields: raw.slice(PREFIX_BY_KIND.heritage.length).split(':') };
+    }
+    if (raw.startsWith(PREFIX_BY_KIND.property)) {
+        return { kind: 'property', fields: raw.slice(PREFIX_BY_KIND.property.length).split(':') };
+    }
+    return null;
+}
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export function isHeritageMarker(raw) {
+    return raw.startsWith(PREFIX_BY_KIND.heritage) || raw.startsWith(PREFIX_BY_KIND.property);
+}

package/dist/core/ingestion/workers/parse-worker.js

@@ -38,7 +38,7 @@ try {
 }
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
+import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
 import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
@@ -1290,7 +1290,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // to the *qualified* class id (Outer.Inner). Gated on the flag → byte-identical
             // when off. Mirrors parsing-processor.ts.
             const getQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
-                ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                ? (node, simpleName) => 
+                // #1991: LOCKSTEP — a Ruby `module` owner is not a typeDeclaration, so
+                // extractQualifiedName returns null; fall back to the scope walk so a
+                // method inside a nested module owns through the SAME qualified Trait
+                // id its node uses on the worker path too.
+                provider.classExtractor.extractQualifiedName(node, simpleName) ??
+                    provider.classExtractor.qualifyScopeName?.(node, simpleName) ??
+                    null
                 : undefined;
             const enclosingClassInfo = needsOwner
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
@@ -1306,7 +1313,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
                     ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
-                    : undefined);
+                    : // #1991: LOCKSTEP with parsing-processor.ts — qualify a Ruby `module`
+                        // (Trait) via the scope walk so same-tail nested mixin modules get
+                        // distinct ids on the worker path too. Gated on qualifiedNodeId.
+                        isQualifiableScopeLabel(nodeLabel) &&
+                            provider.classExtractor?.qualifiedNodeId === true &&
+                            classNodeForSymbol
+                            ? (provider.classExtractor.qualifyScopeName?.(classNodeForSymbol, nodeName) ??
+                                undefined)
+                            : undefined);
             // Qualify method/property IDs with enclosing class name to avoid collisions.
             // Class-like nodes use their own fully-qualified path as the id key when the
             // language enables qualifiedNodeId (#1978); everything else is unchanged.
@@ -1320,13 +1335,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 : undefined;
             const qualifiedName = rustImplQualifiedName !== undefined
                 ? rustImplQualifiedName
-                : isClassLikeLabel &&
-                    provider.classExtractor?.qualifiedNodeId === true &&
-                    qualifiedTypeName !== undefined
-                    ? qualifiedTypeName
-                    : enclosingClassInfo
-                        ? `${enclosingClassInfo.className}.${nodeName}`
-                        : nodeName;
+                : // #1991: LOCKSTEP — include Trait so a Ruby mixin module's qualified
+                    // scope id keys the worker-path node, matching the sequential path.
+                    (isClassLikeLabel || isQualifiableScopeLabel(nodeLabel)) &&
+                        provider.classExtractor?.qualifiedNodeId === true &&
+                        qualifiedTypeName !== undefined
+                        ? qualifiedTypeName
+                        : enclosingClassInfo
+                            ? `${enclosingClassInfo.className}.${nodeName}`
+                            : nodeName;
             // Extract method metadata BEFORE generating node ID — parameterCount is needed
             // to disambiguate overloaded methods via #<arity> suffix in the ID.
             let declaredType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.134",
+  "version": "1.6.6-rc.136",
   "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",