gitnexus 1.6.6-rc.50 → 1.6.6-rc.52

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

@@ -33,10 +33,6 @@ function shouldEmitReadMember(memberNode) {
     if (parent === null)
         return true;
     switch (parent.type) {
-        case 'method_invocation':
-            // Don't emit read.member when the field_access is the object of a method_invocation
-            // (the method call already handles this relationship)
-            return parent.childForFieldName('object')?.id !== memberNode.id;
         case 'assignment_expression':
             return parent.childForFieldName('left')?.id !== memberNode.id;
         default:
@@ -142,11 +138,125 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
                 const argTypes = args.map((arg) => inferArgType(arg));
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
+                const argNames = args.map((a) => (a.type === 'identifier' ? a.text : ''));
+                if (argNames.some((n) => n !== '')) {
+                    grouped['@reference.arg-names'] = syntheticCapture('@reference.arg-names', callNode, JSON.stringify(argNames));
+                }
             }
         }
         out.push(grouped);
     }
-    return out;
+    return resolveVarTypeBindings(out);
+}
+function resolveVarTypeBindings(matches) {
+    const returnTypes = new Map();
+    const varTypes = new Map();
+    const ambiguousReturns = new Set();
+    const ambiguousVars = new Set();
+    for (const m of matches) {
+        if (m['@type-binding.return'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const type = m['@type-binding.type'].text;
+            const existing = returnTypes.get(name);
+            if (existing !== undefined && existing !== type) {
+                ambiguousReturns.add(name);
+                returnTypes.delete(name);
+            }
+            else if (!ambiguousReturns.has(name)) {
+                returnTypes.set(name, type);
+            }
+        }
+        if (m['@type-binding.annotation'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const t = m['@type-binding.type'].text;
+            if (t !== 'var') {
+                const existing = varTypes.get(name);
+                if (existing !== undefined && existing !== t) {
+                    ambiguousVars.add(name);
+                    varTypes.delete(name);
+                }
+                else if (!ambiguousVars.has(name)) {
+                    varTypes.set(name, t);
+                }
+            }
+        }
+        if (m['@type-binding.constructor'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const type = m['@type-binding.type'].text;
+            const existing = varTypes.get(name);
+            if (existing !== undefined && existing !== type) {
+                ambiguousVars.add(name);
+                varTypes.delete(name);
+            }
+            else if (!ambiguousVars.has(name)) {
+                varTypes.set(name, type);
+            }
+        }
+    }
+    const resolved = [];
+    for (const m of matches) {
+        if (m['@type-binding.call-result'] !== undefined && m['@type-binding.type'] !== undefined) {
+            const methodName = m['@type-binding.type'].text;
+            const resolvedType = returnTypes.get(methodName);
+            if (resolvedType !== undefined) {
+                const patched = { ...m };
+                patched['@type-binding.type'] = { ...m['@type-binding.type'], text: resolvedType };
+                patched['@type-binding.annotation'] = m['@type-binding.call-result'];
+                delete patched['@type-binding.call-result'];
+                resolved.push(patched);
+                continue;
+            }
+        }
+        if (m['@type-binding.alias'] !== undefined && m['@type-binding.type'] !== undefined) {
+            const sourceName = m['@type-binding.type'].text;
+            const resolvedType = varTypes.get(sourceName);
+            if (resolvedType !== undefined) {
+                const patched = { ...m };
+                patched['@type-binding.type'] = { ...m['@type-binding.type'], text: resolvedType };
+                patched['@type-binding.annotation'] = m['@type-binding.alias'];
+                delete patched['@type-binding.alias'];
+                resolved.push(patched);
+                continue;
+            }
+        }
+        if (m['@reference.arg-names'] !== undefined && m['@reference.parameter-types'] !== undefined) {
+            try {
+                const types = JSON.parse(m['@reference.parameter-types'].text);
+                const names = JSON.parse(m['@reference.arg-names'].text);
+                let patched = false;
+                for (let i = 0; i < types.length; i++) {
+                    if (types[i] === '' && names[i] !== undefined && names[i] !== '') {
+                        const rt = varTypes.get(names[i]);
+                        if (rt !== undefined) {
+                            types[i] = rt;
+                            patched = true;
+                        }
+                    }
+                }
+                if (patched) {
+                    const patchedMatch = { ...m };
+                    patchedMatch['@reference.parameter-types'] = {
+                        ...m['@reference.parameter-types'],
+                        text: JSON.stringify(types),
+                    };
+                    delete patchedMatch['@reference.arg-names'];
+                    resolved.push(patchedMatch);
+                    continue;
+                }
+            }
+            catch {
+                // pass through
+            }
+        }
+        resolved.push(m);
+    }
+    return resolved;
 }
 /** Infer a Java argument's static type from literal patterns. */
 function inferArgType(argNode) {

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

@@ -19,10 +19,11 @@ export function interpretJavaImport(captures) {
     switch (kind) {
         case 'named': {
             // `import com.example.User;`
+            const simpleName = sourceCap.text.split('.').pop() ?? sourceCap.text;
             return {
                 kind: 'named',
-                localName: nameCap?.text ?? sourceCap.text.split('.').pop() ?? sourceCap.text,
-                importedName: sourceCap.text,
+                localName: nameCap?.text ?? simpleName,
+                importedName: simpleName,
                 targetRaw: sourceCap.text,
             };
         }
@@ -35,17 +36,14 @@ export function interpretJavaImport(captures) {
         }
         case 'static': {
             // `import static com.example.Utils.format;`
-            // The source contains the full path including the member name
-            // (e.g. `com.example.Utils.format`).  For file resolution we need
-            // the class path (`com.example.Utils`), so strip the final member
-            // segment.  The local binding name is the member itself.
             const fullSource = sourceCap.text;
             const lastDot = fullSource.lastIndexOf('.');
+            const memberName = lastDot >= 0 ? fullSource.slice(lastDot + 1) : fullSource;
             const classPath = lastDot >= 0 ? fullSource.slice(0, lastDot) : fullSource;
             return {
                 kind: 'named',
-                localName: nameCap?.text ?? (lastDot >= 0 ? fullSource.slice(lastDot + 1) : fullSource),
-                importedName: fullSource,
+                localName: nameCap?.text ?? memberName,
+                importedName: memberName,
                 targetRaw: classPath,
             };
         }
@@ -83,6 +81,12 @@ export function interpretJavaTypeBinding(captures) {
         source = 'self';
     else if (captures['@type-binding.constructor'] !== undefined)
         source = 'constructor-inferred';
+    else if (captures['@type-binding.pattern'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.call-result'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'annotation';
     else if (captures['@type-binding.annotation'] !== undefined)
         source = 'annotation';
     else if (captures['@type-binding.return'] !== undefined)

package/dist/core/ingestion/languages/java/package-siblings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Java package-scope implicit visibility.
+ *
+ * Classes in the same Java package see each other without explicit
+ * `import` statements.  This hook groups files by `package` declaration,
+ * then injects cross-file class defs into each file's module-scope
+ * `bindingAugmentations` and mirrors type-bindings across same-package
+ * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function populateJavaPackageSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+    readonly treeCache?: {
+        get(filePath: string): unknown;
+    };
+}): void;

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

@@ -0,0 +1,134 @@
+/**
+ * Java package-scope implicit visibility.
+ *
+ * Classes in the same Java package see each other without explicit
+ * `import` statements.  This hook groups files by `package` declaration,
+ * then injects cross-file class defs into each file's module-scope
+ * `bindingAugmentations` and mirrors type-bindings across same-package
+ * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
+ */
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { getJavaParser } from './query.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { logger } from '../../../logger.js';
+function extractPackageName(content, cachedTree) {
+    const tree = cachedTree ??
+        parseSourceSafe(getJavaParser(), content);
+    for (const child of tree.rootNode.namedChildren) {
+        if (child.type === 'package_declaration') {
+            const scoped = child.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
+            return scoped?.text ?? '';
+        }
+    }
+    return '';
+}
+export function populateJavaPackageSiblings(parsedFiles, indexes, ctx) {
+    const buckets = new Map();
+    for (const parsed of parsedFiles) {
+        const content = ctx.fileContents.get(parsed.filePath);
+        if (content === undefined)
+            continue;
+        const pkg = extractPackageName(content, ctx.treeCache?.get(parsed.filePath));
+        let bucket = buckets.get(pkg);
+        if (bucket === undefined) {
+            bucket = { parsed: [], moduleScopes: [] };
+            buckets.set(pkg, bucket);
+        }
+        bucket.parsed.push(parsed);
+        const ms = parsed.scopes.find((s) => s.kind === 'Module');
+        if (ms !== undefined) {
+            bucket.moduleScopes.push({ filePath: parsed.filePath, scope: ms });
+        }
+    }
+    const augmentations = indexes.bindingAugmentations;
+    const MAX_PACKAGE_FILES = 500;
+    for (const bucket of buckets.values()) {
+        if (bucket.moduleScopes.length < 2)
+            continue;
+        if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
+            logger.warn(`[java-package-siblings] skipping package with ${bucket.moduleScopes.length} files (cap=${MAX_PACKAGE_FILES}); same-package implicit visibility disabled for this package`);
+            continue;
+        }
+        const classDefs = [];
+        for (const parsed of bucket.parsed) {
+            const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
+            const moduleScopeId = moduleScope?.id;
+            for (const scope of parsed.scopes) {
+                if (scope.kind !== 'Class')
+                    continue;
+                if (scope.parent !== moduleScopeId)
+                    continue;
+                for (const def of scope.ownedDefs) {
+                    if (isClassLike(def.type)) {
+                        classDefs.push({ def, filePath: parsed.filePath });
+                        break;
+                    }
+                }
+            }
+        }
+        for (const { filePath, scope } of bucket.moduleScopes) {
+            let scopeAug = augmentations.get(scope.id);
+            if (scopeAug === undefined) {
+                scopeAug = new Map();
+                augmentations.set(scope.id, scopeAug);
+            }
+            const candidates = classDefs.filter((d) => d.filePath !== filePath);
+            const proximityCache = new Map();
+            for (const c of candidates) {
+                if (!proximityCache.has(c.filePath)) {
+                    proximityCache.set(c.filePath, sharedSegmentCount(c.filePath, filePath));
+                }
+            }
+            const sorted = candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
+            const injectedIds = new Set();
+            for (const { def } of sorted) {
+                if (injectedIds.has(def.nodeId))
+                    continue;
+                const qn = def.qualifiedName;
+                if (qn === undefined)
+                    continue;
+                injectedIds.add(def.nodeId);
+                const simpleName = qn.includes('.') ? qn.slice(qn.lastIndexOf('.') + 1) : qn;
+                let list = scopeAug.get(simpleName);
+                if (list === undefined) {
+                    list = [];
+                    scopeAug.set(simpleName, list);
+                }
+                list.push({ def, origin: 'namespace' });
+            }
+            const tb = scope.typeBindings;
+            for (const sibling of bucket.moduleScopes) {
+                if (sibling.filePath === filePath)
+                    continue;
+                for (const [name, ref] of sibling.scope.typeBindings) {
+                    if (tb.has(name))
+                        continue;
+                    tb.set(name, ref);
+                }
+            }
+            for (const sibParsed of bucket.parsed) {
+                if (sibParsed.filePath === filePath)
+                    continue;
+                for (const sibScope of sibParsed.scopes) {
+                    if (sibScope.kind !== 'Class')
+                        continue;
+                    for (const [name, ref] of sibScope.typeBindings) {
+                        if (ref.source === 'self')
+                            continue;
+                        if (tb.has(name))
+                            continue;
+                        tb.set(name, ref);
+                    }
+                }
+            }
+        }
+    }
+}
+function sharedSegmentCount(a, b) {
+    const sa = a.replace(/\\/g, '/').split('/');
+    const sb = b.replace(/\\/g, '/').split('/');
+    let i = 0;
+    while (i < sa.length && i < sb.length && sa[i] === sb[i])
+        i++;
+    return i;
+}

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

@@ -100,6 +100,47 @@ const JAVA_SCOPE_QUERY = `
   declarator: (variable_declarator
     name: (identifier) @type-binding.name)) @type-binding.annotation
 
+;; Type bindings — var u = svc.getUser(); (Java 10+ call-result inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (method_invocation
+      name: (identifier) @type-binding.type))) @type-binding.call-result
+
+;; Type bindings — var alias = u; (Java 10+ alias inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — var addr = user.address; (Java 10+ field-access alias)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (field_access
+      field: (identifier) @type-binding.type))) @type-binding.alias
+
+;; Type bindings — enhanced-for with var: for (var user : users)
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (identifier) @type-binding.type) @type-binding.alias
+
+;; Enhanced-for with var + method iterable: for (var user : data.values())
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (method_invocation
+    object: (identifier) @type-binding.type)) @type-binding.alias
+
 ;; Type bindings — var u = new User(); (Java 10+ local variable type inference)
 ;; tree-sitter-java parses \`var\` as a \`type_identifier\` with text "var".
 ;; The type-binding.constructor anchor fires when the rhs is an
@@ -141,6 +182,16 @@ const JAVA_SCOPE_QUERY = `
   type: (generic_type) @type-binding.type
   name: (identifier) @type-binding.name) @type-binding.annotation
 
+;; Type bindings — instanceof pattern (Java 16+): if (obj instanceof User user)
+(instanceof_expression
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
+;; Type bindings — switch case pattern (Java 21+): case User user ->
+(type_pattern
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
 ;; References — all method calls: foo() and obj.method()
 ;; tree-sitter-java's query engine drops negation-based \`!object\`
 ;; patterns when a positive \`object:\` pattern exists for the same
@@ -164,6 +215,30 @@ const JAVA_SCOPE_QUERY = `
 (object_creation_expression
   type: (scoped_type_identifier) @reference.call.constructor.qualified) @reference.call.constructor
 
+;; References — method references: User::getName, obj::method
+(method_reference
+  (identifier) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — this::method and super::method
+(method_reference
+  (this) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+(method_reference
+  (super) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — field_access::method: responseBuilder::buildResponse
+(method_reference
+  (field_access) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — constructor references: User::new
+(method_reference
+  (identifier) @reference.name
+  "new") @reference.call.constructor
+
 ;; References — field/property writes: obj.name = "x"
 (assignment_expression
   left: (field_access

package/dist/core/ingestion/languages/java/scope-resolver.d.ts

@@ -4,46 +4,12 @@
  *
  * ## Registry-primary parity status
  *
- * Java is **not** in `MIGRATED_LANGUAGES` — the scope-resolution
- * registry runs in shadow mode only.  Parity in forced registry mode
- * (`REGISTRY_PRIMARY_JAVA=1`) is 143/172 (83%).  The 29 gaps fall into:
+ * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
+ * the primary call-resolution path.  Parity: 178/178 (100%).
  *
- *   - switch pattern binding / sealed-class exhaustiveness
- *   - Map.values() / entrySet() iteration type propagation
- *   - assignment / method chain return-type propagation across files
- *   - virtual dispatch / interface default methods
- *
- * These are the same category of advanced-resolution gaps seen in prior
- * migrations (Python, C#, Go).  Parity is below the ≥99% flip threshold
- * per RFC §6.4.
- *
- * **CI visibility:** Because Java is absent from `MIGRATED_LANGUAGES`,
- * the parity CI workflow (`ci-scope-parity.yml`) does not run Java in
- * either `REGISTRY_PRIMARY_JAVA=0` or `=1` mode.  Regressions in forced
- * mode are only visible via manual `REGISTRY_PRIMARY_JAVA=1 npx vitest
- * run java.test.ts`.  Before flipping Java to registry-primary, a
- * non-required CI step should be added to run Java tests in forced mode
- * and report parity as a dashboard input.
- *
- * **Parity baseline (29 failures):** The 29 gaps in forced registry mode
- * are tracked in this PR (#1482) and this JSDoc.  If the gap count
- * changes (up or down), update this baseline accordingly.
- *
- * ### Known flip-blockers (must fix before adding to MIGRATED_LANGUAGES)
- *
- *   - Varargs arity: fixed-prefix count is now preserved, but no
- *     integration fixture exercises the 0-arg rejection path yet.
- *   - Static import resolution: `import static X.Y.m` now correctly
- *     resolves to `X/Y.java` (the class), not `X/Y/m.java` (the member).
- *     Edge cases with nested classes may remain.
- *   - Generic superclass receiver binding: `BaseModel<T>` now strips
- *     to `BaseModel` via JVM type-erasure fallback in `stripGeneric`.
- *   - Wildcard import (`import com.example.*`) file selection is
- *     nondeterministic when multiple classes share a package directory.
- *     May produce wrong-file edges in forced mode.
- *   - Qualified generic type parameters in field/parameter annotations
- *     (`com.example.BaseModel<T>`) — rare in practice but may miss
- *     resolution when the full qualifier is present with generics.
+ * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
+ * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
+ * automatically.
  */
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 declare const javaScopeResolver: ScopeResolver;

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

@@ -4,52 +4,21 @@
  *
  * ## Registry-primary parity status
  *
- * Java is **not** in `MIGRATED_LANGUAGES` — the scope-resolution
- * registry runs in shadow mode only.  Parity in forced registry mode
- * (`REGISTRY_PRIMARY_JAVA=1`) is 143/172 (83%).  The 29 gaps fall into:
+ * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
+ * the primary call-resolution path.  Parity: 178/178 (100%).
  *
- *   - switch pattern binding / sealed-class exhaustiveness
- *   - Map.values() / entrySet() iteration type propagation
- *   - assignment / method chain return-type propagation across files
- *   - virtual dispatch / interface default methods
- *
- * These are the same category of advanced-resolution gaps seen in prior
- * migrations (Python, C#, Go).  Parity is below the ≥99% flip threshold
- * per RFC §6.4.
- *
- * **CI visibility:** Because Java is absent from `MIGRATED_LANGUAGES`,
- * the parity CI workflow (`ci-scope-parity.yml`) does not run Java in
- * either `REGISTRY_PRIMARY_JAVA=0` or `=1` mode.  Regressions in forced
- * mode are only visible via manual `REGISTRY_PRIMARY_JAVA=1 npx vitest
- * run java.test.ts`.  Before flipping Java to registry-primary, a
- * non-required CI step should be added to run Java tests in forced mode
- * and report parity as a dashboard input.
- *
- * **Parity baseline (29 failures):** The 29 gaps in forced registry mode
- * are tracked in this PR (#1482) and this JSDoc.  If the gap count
- * changes (up or down), update this baseline accordingly.
- *
- * ### Known flip-blockers (must fix before adding to MIGRATED_LANGUAGES)
- *
- *   - Varargs arity: fixed-prefix count is now preserved, but no
- *     integration fixture exercises the 0-arg rejection path yet.
- *   - Static import resolution: `import static X.Y.m` now correctly
- *     resolves to `X/Y.java` (the class), not `X/Y/m.java` (the member).
- *     Edge cases with nested classes may remain.
- *   - Generic superclass receiver binding: `BaseModel<T>` now strips
- *     to `BaseModel` via JVM type-erasure fallback in `stripGeneric`.
- *   - Wildcard import (`import com.example.*`) file selection is
- *     nondeterministic when multiple classes share a package directory.
- *     May produce wrong-file edges in forced mode.
- *   - Qualified generic type parameters in field/parameter annotations
- *     (`com.example.BaseModel<T>`) — rare in practice but may miss
- *     resolution when the full qualifier is present with generics.
+ * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
+ * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
+ * automatically.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
-import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt, namesAtScope, populateClassOwnedMembers, } from '../../scope-resolution/scope/walkers.js';
+import { followChainPostFinalize } from '../../scope-resolution/passes/imported-return-types.js';
 import { javaProvider } from '../java.js';
 import { javaArityCompatibility, javaMergeBindings, resolveJavaImportTarget, } from './index.js';
+import { populateJavaPackageSiblings } from './package-siblings.js';
 const javaScopeResolver = {
     language: SupportedLanguages.Java,
     languageProvider: javaProvider,
@@ -60,15 +29,158 @@ const javaScopeResolver = {
     },
     mergeBindings: (existing, incoming) => [...javaMergeBindings([...existing, ...incoming])],
     arityCompatibility: (callsite, def) => javaArityCompatibility(def, callsite),
-    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    buildMro: buildJavaMro,
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
-    // Java is statically typed — field-fallback heuristic stays off
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
-    // Java doesn't collapse member calls
-    collapseMemberCallsByCallerTarget: false,
-    // Hoist return-type bindings to Module scope for cross-file propagation
+    collapseMemberCallsByCallerTarget: true,
     hoistTypeBindingsToModule: true,
+    populateNamespaceSiblings: populateJavaPackageSiblings,
+    populateRangeBindings: populateJavaCrossFileReturnTypes,
 };
 export { javaScopeResolver };
+function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {
+    const moduleScopeByFile = new Map();
+    const classScopesByFile = new Map();
+    for (const parsed of parsedFiles) {
+        const ms = parsed.scopes.find((s) => s.kind === 'Module');
+        if (ms !== undefined)
+            moduleScopeByFile.set(parsed.filePath, ms);
+        const cs = parsed.scopes.filter((s) => s.kind === 'Class');
+        if (cs.length > 0)
+            classScopesByFile.set(parsed.filePath, cs);
+    }
+    for (const parsed of parsedFiles) {
+        const importerModule = moduleScopeByFile.get(parsed.filePath);
+        if (importerModule === undefined)
+            continue;
+        const ambiguousMirrors = new Set();
+        for (const name of namesAtScope(importerModule.id, indexes)) {
+            const refs = lookupBindingsAt(importerModule.id, name, indexes);
+            for (const ref of refs) {
+                if (ref.origin !== 'import' && ref.origin !== 'reexport')
+                    continue;
+                if (!isClassLike(ref.def.type))
+                    continue;
+                const sourceModule = moduleScopeByFile.get(ref.def.filePath);
+                if (sourceModule === undefined)
+                    continue;
+                const tb = importerModule.typeBindings;
+                for (const [srcName, srcRef] of sourceModule.typeBindings) {
+                    if (srcRef.source !== 'return-annotation')
+                        continue;
+                    if (ambiguousMirrors.has(srcName))
+                        continue;
+                    const existing = tb.get(srcName);
+                    if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                        ambiguousMirrors.add(srcName);
+                        tb.delete(srcName);
+                        continue;
+                    }
+                    if (existing === undefined)
+                        tb.set(srcName, srcRef);
+                }
+                for (const classScope of classScopesByFile.get(ref.def.filePath) ?? []) {
+                    for (const [srcName, srcRef] of classScope.typeBindings) {
+                        if (srcRef.source === 'self' || srcRef.source === 'parameter-annotation')
+                            continue;
+                        if (ambiguousMirrors.has(srcName))
+                            continue;
+                        const existing = tb.get(srcName);
+                        if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                            ambiguousMirrors.add(srcName);
+                            tb.delete(srcName);
+                            continue;
+                        }
+                        if (existing === undefined)
+                            tb.set(srcName, srcRef);
+                    }
+                }
+            }
+        }
+        for (const [name, ref] of importerModule.typeBindings) {
+            const resolved = followChainPostFinalize(ref, importerModule.id, indexes);
+            if (resolved !== ref) {
+                importerModule.typeBindings.set(name, resolved);
+            }
+        }
+    }
+    for (const parsed of parsedFiles) {
+        const moduleScopeId = moduleScopeByFile.get(parsed.filePath)?.id;
+        for (const scope of parsed.scopes) {
+            if (scope.id === moduleScopeId)
+                continue;
+            for (const [name, ref] of scope.typeBindings) {
+                const resolved = followChainPostFinalize(ref, scope.id, indexes);
+                if (resolved !== ref) {
+                    scope.typeBindings.set(name, resolved);
+                }
+            }
+        }
+    }
+}
+function buildJavaMro(graph, parsedFiles, nodeLookup) {
+    const mro = buildMro(graph, parsedFiles, nodeLookup, defaultLinearize);
+    const defIdByGraphId = 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)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const directImpls = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const source = defIdByGraphId.get(rel.sourceId);
+        const target = defIdByGraphId.get(rel.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        let list = directImpls.get(source);
+        if (list === undefined) {
+            list = [];
+            directImpls.set(source, list);
+        }
+        if (!list.includes(target))
+            list.push(target);
+    }
+    for (const [classDefId, extendsMro] of mro) {
+        const ancestorChain = [classDefId, ...extendsMro];
+        const seeds = [];
+        for (const ancestorId of ancestorChain) {
+            for (const ifaceId of directImpls.get(ancestorId) ?? []) {
+                seeds.push(ifaceId);
+            }
+        }
+        if (seeds.length === 0)
+            continue;
+        const interfaces = closeInterfaces(seeds, directImpls);
+        mro.set(classDefId, [...extendsMro, ...interfaces.filter((i) => !extendsMro.includes(i))]);
+    }
+    for (const [classDefId, ifaces] of directImpls) {
+        if (mro.has(classDefId))
+            continue;
+        mro.set(classDefId, closeInterfaces([...ifaces], directImpls));
+    }
+    return mro;
+}
+function closeInterfaces(seeds, directImpls) {
+    const out = [];
+    const seen = new Set();
+    const queue = [...seeds];
+    let head = 0;
+    while (head < queue.length) {
+        const cur = queue[head++];
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        out.push(cur);
+        for (const next of directImpls.get(cur) ?? []) {
+            if (!seen.has(next))
+                queue.push(next);
+        }
+    }
+    return out;
+}

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -22,6 +22,7 @@ import { processHeritage, processHeritageFromExtracted, extractExtractedHeritage
 import { createResolutionContext } from '../model/resolution-context.js';
 import { createASTCache } from '../ast-cache.js';
 import { getLanguageFromFilename } from '../../../_shared/index.js';
+import { isRegistryPrimary } from '../registry-primary-flag.js';
 import { readFileContents } from '../filesystem-walker.js';
 import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
 import { createWorkerPool, WorkerPoolInitializationError } from '../workers/worker-pool.js';
@@ -461,14 +462,37 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 if (chunkNeedsSynthesis[chunkIdx]) {
                     anyChunkNeedsWildcardSynth = true;
                 }
-                for (const item of chunkWorkerData.imports)
-                    deferredWorkerImports.push(item);
-                for (const item of chunkWorkerData.calls)
-                    deferredWorkerCalls.push(item);
-                for (const item of chunkWorkerData.heritage)
-                    deferredWorkerHeritage.push(item);
-                for (const item of chunkWorkerData.constructorBindings)
-                    deferredConstructorBindings.push(item);
+                const skipFile = new Set();
+                const checkFile = new Set();
+                const shouldAccumulate = (filePath) => {
+                    if (checkFile.has(filePath))
+                        return true;
+                    if (skipFile.has(filePath))
+                        return false;
+                    const lang = getLanguageFromFilename(filePath);
+                    if (lang !== null && isRegistryPrimary(lang)) {
+                        skipFile.add(filePath);
+                        return false;
+                    }
+                    checkFile.add(filePath);
+                    return true;
+                };
+                for (const item of chunkWorkerData.imports) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerImports.push(item);
+                }
+                for (const item of chunkWorkerData.calls) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerCalls.push(item);
+                }
+                for (const item of chunkWorkerData.heritage) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerHeritage.push(item);
+                }
+                for (const item of chunkWorkerData.constructorBindings) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredConstructorBindings.push(item);
+                }
                 // Aggregate worker-produced ParsedFile artifacts so scope-
                 // resolution can use them as a re-extraction cache (skips its
                 // own tree-sitter re-parse on warm runs).
@@ -477,8 +501,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                         allParsedFiles.push(item);
                 }
                 if (chunkWorkerData.assignments?.length) {
-                    for (const item of chunkWorkerData.assignments)
-                        deferredAssignments.push(item);
+                    for (const item of chunkWorkerData.assignments) {
+                        if (shouldAccumulate(item.filePath))
+                            deferredAssignments.push(item);
+                    }
                 }
                 if (chunkWorkerData.fileScopeBindings?.length) {
                     for (const { filePath, bindings } of chunkWorkerData.fileScopeBindings) {

package/dist/core/ingestion/registry-primary-flag.js

@@ -75,6 +75,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.PHP,
     SupportedLanguages.JavaScript,
     SupportedLanguages.Kotlin,
+    SupportedLanguages.Java,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -41,7 +41,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             if (site.callForm === 'constructor') {
                 const classDef = findClassBindingInScope(site.inScope, site.name, scopes);
                 if (classDef !== undefined) {
-                    fnDef = pickConstructorOrClass(classDef, workspaceIndex);
+                    fnDef = pickConstructorOrClass(classDef, workspaceIndex, scopes);
                 }
             }
             // Implicit-this overload narrowing: an unqualified call inside
@@ -449,7 +449,7 @@ function logicalCallableKey(def) {
  *  Class def itself when no explicit Constructor exists. Matches
  *  legacy behavior — tests assert targetLabel === 'Class' for implicit
  *  ctors and targetLabel === 'Constructor' for explicit ones. */
-function pickConstructorOrClass(classDef, workspaceIndex) {
+function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
     const classScope = workspaceIndex.classScopeByDefId.get(classDef.nodeId);
     if (classScope === undefined)
         return classDef;
@@ -457,6 +457,17 @@ function pickConstructorOrClass(classDef, workspaceIndex) {
         if (def.type === 'Constructor')
             return def;
     }
+    if (scopes !== undefined) {
+        for (const childId of scopes.scopeTree.getChildren(classScope.id)) {
+            const childScope = scopes.scopeTree.getScope(childId);
+            if (childScope === undefined || childScope.kind === 'Class')
+                continue;
+            for (const def of childScope.ownedDefs) {
+                if (def.type === 'Constructor')
+                    return def;
+            }
+        }
+    }
     return classDef;
 }
 /** Walk up from the call-site scope to the enclosing class scope,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.50",
+  "version": "1.6.6-rc.52",
   "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",
@@ -48,6 +48,8 @@
     "test:integration": "vitest run test/integration",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "test:parity": "tsx scripts/run-parity.ts",
+    "test:cross-platform": "tsx scripts/run-cross-platform.ts",
     "postinstall": "node scripts/materialize-vendor-grammars.cjs && node scripts/build-tree-sitter-dart.cjs && node scripts/build-tree-sitter-proto.cjs && node scripts/build-tree-sitter-swift.cjs",
     "prepare": "node scripts/build.js",
     "prepack": "node scripts/build.js"

package/scripts/cross-platform-tests.ts

@@ -0,0 +1,131 @@
+/**
+ * Cross-platform test subset runner.
+ *
+ * Runs only the tests that exercise platform-sensitive behavior on
+ * Windows and macOS. The full suite runs on Ubuntu; this narrows the
+ * cross-platform matrix to tests that actually vary across OSes.
+ *
+ * Categories included:
+ *   - Platform-specific logic (path.sep, process.platform guards)
+ *   - Native addon loading (LadybugDB, tree-sitter)
+ *   - Process spawning and shell behavior
+ *   - Filesystem locking and temp-dir behavior
+ *   - Worker threads (real, not mocked)
+ *   - CLI end-to-end tests
+ *
+ * When adding a new test that uses platform-varying APIs (native addons,
+ * child_process with real spawning, filesystem locking, path.sep), add
+ * it to the appropriate section below.
+ *
+ * Usage:
+ *   npx vitest run $(npx tsx scripts/cross-platform-tests.ts)
+ *   # or via the package script:
+ *   npm run test:cross-platform
+ */
+
+// Platform-specific logic tests — contain explicit process.platform guards
+// or test behavior that differs across operating systems
+const PLATFORM_LOGIC = [
+  'test/unit/setup.test.ts',
+  'test/unit/setup-jsonc.test.ts',
+  'test/unit/setup-codex.test.ts',
+  'test/unit/platform-capabilities.test.ts',
+  'test/unit/worker-pool-windows-quarantine.test.ts',
+  'test/unit/lbug-pool-win-fts-probe.test.ts',
+  'test/unit/repo-manager.test.ts',
+  'test/unit/repo-manager-finalize-invariant.test.ts',
+  'test/unit/hooks.test.ts',
+  'test/unit/cursor-hook.test.ts',
+  'test/unit/sidecar-recovery.test.ts',
+  'test/unit/pool-wal-recovery.test.ts',
+  'test/unit/detect-changes-worktree.test.ts',
+  'test/unit/eval-server-bind-restriction.test.ts',
+  'test/unit/ignore-service.test.ts',
+  'test/unit/group/bridge-db.test.ts',
+  'test/unit/group/bridge-db-edge.test.ts',
+];
+
+// Native LadybugDB integration tests — exercise the @ladybugdb/core
+// N-API addon which has known platform-specific behavior (Windows
+// file-lock lag after close, macOS N-API destructor segfaults)
+const LBUG_NATIVE = [
+  'test/integration/lbug-core-adapter.test.ts',
+  'test/integration/lbug-vector-extension.test.ts',
+  'test/integration/lbug-pool.test.ts',
+  'test/integration/lbug-pool-stability.test.ts',
+  'test/integration/lbug-lock-retry.test.ts',
+  'test/integration/lbug-open-retry.test.ts',
+  'test/integration/lbug-close-handle-release.test.ts',
+  'test/integration/lbug-orphan-sidecar-recovery.test.ts',
+  'test/integration/lbug-readonly-init.test.ts',
+  'test/integration/local-backend.test.ts',
+  'test/integration/local-backend-calltool.test.ts',
+  'test/integration/search-core.test.ts',
+  'test/integration/search-pool.test.ts',
+  'test/integration/staleness-and-stability.test.ts',
+  'test/integration/analyze-wal-checkpoint-failure.test.ts',
+];
+
+// Process spawning and CLI tests — exercise child_process with real
+// process spawning, which behaves differently across platforms (shell
+// quoting, path resolution, signal handling)
+const SPAWN_CLI = [
+  'test/integration/cli-e2e.test.ts',
+  'test/integration/hooks-e2e.test.ts',
+  'test/integration/skills-e2e.test.ts',
+  'test/integration/server-http-startup.test.ts',
+  'test/integration/mcp/server-startup.test.ts',
+  'test/integration/analyze-heap-oom-e2e.test.ts',
+  'test/integration/group/group-cli.test.ts',
+  'test/integration/cli/tool-no-index-stderr.test.ts',
+  'test/integration/setup-skills.test.ts',
+];
+
+// Worker threads tests — exercise real worker_threads which have
+// platform-specific behavior (thread spawning, IPC, exit handling)
+const WORKER_THREADS = [
+  'test/integration/worker-pool.test.ts',
+  'test/integration/parse-impl-quarantine-cache-skip.test.ts',
+];
+
+// Tree-sitter native addon smoke tests — verify that native grammars
+// load correctly on each platform (binary compatibility, .node loading)
+const NATIVE_ADDON_SMOKE = [
+  'test/integration/tree-sitter-languages.test.ts',
+  'test/integration/parsing.test.ts',
+  'test/integration/pipeline.test.ts',
+  'test/integration/pipeline-graph-golden.test.ts',
+  'test/unit/parser-loader.test.ts',
+];
+
+// Filesystem behavior tests — exercise operations that vary across
+// platforms (CRLF, symlinks, permissions, temp dirs)
+const FILESYSTEM = [
+  'test/integration/filesystem-walker.test.ts',
+  'test/integration/markdown-processor-crlf.test.ts',
+  'test/integration/ignore-and-skip-e2e.test.ts',
+];
+
+const ALL_CROSS_PLATFORM = [
+  ...PLATFORM_LOGIC,
+  ...LBUG_NATIVE,
+  ...SPAWN_CLI,
+  ...WORKER_THREADS,
+  ...NATIVE_ADDON_SMOKE,
+  ...FILESYSTEM,
+];
+
+// When invoked directly, print the file list for vitest consumption
+if (process.argv[1]?.endsWith('cross-platform-tests.ts')) {
+  console.log(ALL_CROSS_PLATFORM.join('\n'));
+}
+
+export {
+  ALL_CROSS_PLATFORM,
+  PLATFORM_LOGIC,
+  LBUG_NATIVE,
+  SPAWN_CLI,
+  WORKER_THREADS,
+  NATIVE_ADDON_SMOKE,
+  FILESYSTEM,
+};

package/scripts/run-cross-platform.ts

@@ -0,0 +1,44 @@
+/**
+ * Cross-platform test runner.
+ *
+ * Runs the platform-sensitive test subset defined in cross-platform-tests.ts
+ * via vitest. Used by `npm run test:cross-platform` and by the CI cross-
+ * platform matrix (ci-tests.yml).
+ *
+ * The main vitest.config.ts is used, so lbug-db project files get
+ * sequential execution and other safety constraints are preserved.
+ */
+
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ALL_CROSS_PLATFORM } from './cross-platform-tests.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+// Verify all files exist
+const missing = ALL_CROSS_PLATFORM.filter((f) => !fs.existsSync(path.resolve(ROOT, f)));
+if (missing.length > 0) {
+  console.error(`Cross-platform test files not found (${missing.length}):`);
+  for (const f of missing) console.error(`  ${f}`);
+  console.error('\nUpdate scripts/cross-platform-tests.ts if files were moved or removed.');
+  process.exit(1);
+}
+
+console.log(`Running ${ALL_CROSS_PLATFORM.length} platform-sensitive tests...\n`);
+
+try {
+  execFileSync('npx', ['vitest', 'run', ...ALL_CROSS_PLATFORM], {
+    cwd: ROOT,
+    stdio: 'inherit',
+    timeout: 15 * 60 * 1000,
+    shell: true,
+  });
+} catch (err: any) {
+  if (err.killed || err.signal) {
+    console.error('vitest timed out after 15 minutes');
+  }
+  process.exit(1);
+}

package/scripts/run-parity.ts

@@ -0,0 +1,128 @@
+/**
+ * Consolidated scope-resolution parity runner.
+ *
+ * Replaces the per-language matrix in ci-scope-parity.yml with a single
+ * job that runs all migrated languages sequentially in one process. This
+ * eliminates 8× redundant checkout + npm ci + build cycles (the old
+ * workflow created a separate GitHub Actions job per language).
+ *
+ * For each language in MIGRATED_LANGUAGES:
+ *   1. Run its resolver test with REGISTRY_PRIMARY_<LANG>=0 (legacy DAG)
+ *   2. Run its resolver test with REGISTRY_PRIMARY_<LANG>=1 (registry-primary)
+ *
+ * Both modes must pass. Failures are collected and reported at the end
+ * so all regressions are visible in a single CI run (equivalent to the
+ * old workflow's fail-fast: false behavior).
+ *
+ * Vitest output streams to the console in real time (stdio: 'inherit')
+ * so CI logs show the actual test output directly. No per-invocation
+ * timeout — the CI job-level timeout (30 min) is the outer guard.
+ *
+ * Usage:
+ *   npx tsx scripts/run-parity.ts
+ *   npx tsx scripts/run-parity.ts --language python   # single language
+ */
+
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { MIGRATED_LANGUAGES } from '../src/core/ingestion/registry-primary-flag.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+interface ParityFailure {
+  lang: string;
+  mode: 'legacy' | 'registry-primary';
+}
+
+function envVarName(slug: string): string {
+  return `REGISTRY_PRIMARY_${slug.toUpperCase().replace(/-/g, '_')}`;
+}
+
+function testFilePath(slug: string): string {
+  return `test/integration/resolvers/${slug}.test.ts`;
+}
+
+function runVitest(testFile: string, env: Record<string, string>): boolean {
+  try {
+    execFileSync('npx', ['vitest', 'run', testFile], {
+      cwd: ROOT,
+      env: { ...process.env, ...env },
+      stdio: 'inherit',
+      shell: true,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+const langFlag = args.indexOf('--language');
+const singleLang = langFlag >= 0 ? args[langFlag + 1] : undefined;
+
+if (langFlag >= 0 && singleLang === undefined) {
+  console.error('--language requires a value');
+  process.exit(1);
+}
+
+const languages = singleLang ? [singleLang] : [...MIGRATED_LANGUAGES].map(String);
+
+// Verify test files exist before running
+const missingFiles: string[] = [];
+for (const lang of languages) {
+  const file = path.resolve(ROOT, testFilePath(lang));
+  try {
+    fs.accessSync(file);
+  } catch {
+    missingFiles.push(`${testFilePath(lang)} (${lang})`);
+  }
+}
+
+if (missingFiles.length > 0) {
+  console.error('Missing resolver test files:');
+  for (const f of missingFiles) console.error(`  ${f}`);
+  process.exit(1);
+}
+
+console.log(`Scope-resolution parity: ${languages.length} language(s)`);
+console.log(`Languages: ${languages.join(', ')}\n`);
+
+const failures: ParityFailure[] = [];
+
+for (const lang of languages) {
+  const file = testFilePath(lang);
+  const envVar = envVarName(lang);
+
+  console.log(`\n── ${lang} — legacy DAG (${envVar}=0) ──`);
+  if (!runVitest(file, { [envVar]: '0' })) {
+    failures.push({ lang, mode: 'legacy' });
+  }
+
+  console.log(`\n── ${lang} — registry-primary (${envVar}=1) ──`);
+  if (!runVitest(file, { [envVar]: '1' })) {
+    failures.push({ lang, mode: 'registry-primary' });
+  }
+}
+
+// Summary
+const total = languages.length * 2;
+const passed = total - failures.length;
+
+console.log('\n═══════════════════════════════════════');
+console.log('PARITY SUMMARY');
+console.log('═══════════════════════════════════════');
+console.log(`Passed: ${passed}/${total}`);
+
+if (failures.length > 0) {
+  console.log(`\nFAILURES (${failures.length}):`);
+  for (const f of failures) {
+    console.log(`  ✗ ${f.lang} [${f.mode}]`);
+  }
+  process.exit(1);
+}
+
+console.log('\nAll parity checks passed.');