gitnexus 1.6.6-rc.37 → 1.6.6-rc.39

package/dist/cli/ai-context.js

@@ -156,7 +156,7 @@ async function fileExists(filePath) {
  * - If file exists without GitNexus section: append
  * - If file exists with GitNexus section: replace that section
  */
-async function upsertGitNexusSection(filePath, content, projectName, stats) {
+async function upsertGitNexusSection(filePath, content, projectName, stats, noStats) {
     const exists = await fileExists(filePath);
     if (!exists) {
         await fs.writeFile(filePath, content, 'utf-8');
@@ -189,13 +189,22 @@ async function upsertGitNexusSection(filePath, content, projectName, stats) {
             //       like `({target: "symbolName", direction: "upstream"})`
             //       when noStats is set
             // Passing projectName + stats explicitly makes the contract obvious.
-            // noStats controls template generation, not keep-section stat updates — the user opted into a stats line by keeping it.
+            // --no-stats wins in the keep path too (#1706): a lean block committed
+            // to git would otherwise churn the volatile counts on every analyze,
+            // producing no-value merge conflicts between branches. Under noStats we
+            // drop the parenthetical but still refresh the project name so renames
+            // propagate.
             const newStatsInner = `${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows`;
-            const statsLine = `Indexed as **${projectName}** (${newStatsInner})`;
+            const statsLine = noStats
+                ? `Indexed as **${projectName}**`
+                : `Indexed as **${projectName}** (${newStatsInner})`;
             // Match either canonical phrasing at line start (`^` with `m` flag) so we
             // cannot replace prose embedded mid-paragraph. Deliberately no `$`: text
-            // after the closing `)` on the same line (e.g. ". MCP tools.") stays intact.
-            const statsPattern = /^(?:Indexed as|indexed by GitNexus as) \*\*[^*]+\*\* \([^)]+\)/m;
+            // after the line on the same line (e.g. ". MCP tools.") stays intact.
+            // The parenthetical is optional so a count-free line left by a prior
+            // --no-stats run still matches — letting the name refresh, and letting
+            // counts return if --no-stats is later dropped.
+            const statsPattern = /^(?:Indexed as|indexed by GitNexus as) \*\*[^*]+\*\*(?: \([^)]+\))?/m;
             if (statsPattern.test(existingSection)) {
                 const updatedSection = existingSection.replace(statsPattern, statsLine);
                 const before = existingContent.substring(0, startIdx);
@@ -300,11 +309,11 @@ export async function generateAIContextFiles(repoPath, _storagePath, projectName
     if (!options?.skipAgentsMd) {
         // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.)
         const agentsPath = path.join(repoPath, 'AGENTS.md');
-        const agentsResult = await upsertGitNexusSection(agentsPath, content, projectName, stats);
+        const agentsResult = await upsertGitNexusSection(agentsPath, content, projectName, stats, options?.noStats);
         createdFiles.push(`AGENTS.md (${agentsResult})`);
         // Create CLAUDE.md (for Claude Code)
         const claudePath = path.join(repoPath, 'CLAUDE.md');
-        const claudeResult = await upsertGitNexusSection(claudePath, content, projectName, stats);
+        const claudeResult = await upsertGitNexusSection(claudePath, content, projectName, stats, options?.noStats);
         createdFiles.push(`CLAUDE.md (${claudeResult})`);
     }
     else {

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

@@ -23,6 +23,7 @@ export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
+    out.push(...synthesizeKotlinSmartCastBindings(tree.rootNode));
     for (const match of getKotlinScopeQuery().matches(tree.rootNode)) {
         const grouped = {};
         for (const capture of match.captures) {
@@ -51,6 +52,27 @@ export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
             if (navNode === null || !shouldEmitReadMember(navNode))
                 continue;
         }
+        // Virtual dispatch via constructor type (#1762). When a property
+        // declaration carries BOTH an explicit type annotation AND a
+        // constructor-style call value (e.g. `val animal: Animal = Dog()`),
+        // suppress the annotation capture so the constructor-inferred
+        // binding wins. This matches Kotlin's virtual dispatch semantics:
+        // `animal.speak()` should resolve to the overriding `Dog.speak`
+        // (the dynamic type), not `Animal.speak` (the static annotation).
+        //
+        // The annotation source has higher precedence than constructor-
+        // inferred in the generic scope-extractor (see
+        // `typeBindingStrength` in scope-extractor.ts), so the only way to
+        // make the constructor type prevail is to drop the annotation at
+        // emission time.
+        if (grouped['@type-binding.annotation'] !== undefined &&
+            grouped['@type-binding.name'] !== undefined &&
+            grouped['@type-binding.type'] !== undefined) {
+            const annotation = grouped['@type-binding.annotation'];
+            if (propertyDeclHasConstructorValue(tree.rootNode, annotation.range)) {
+                continue;
+            }
+        }
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
             const fnNode = findNodeAtRange(tree.rootNode, grouped['@scope.function'].range, 'function_declaration');
@@ -118,12 +140,107 @@ function synthesizeKotlinLoopBindings(rootNode, returnTypes) {
     }
     return out;
 }
+/**
+ * Synthesize narrowed type-bindings for Kotlin smart-cast forms — issue #1758.
+ *
+ * For each `when (x) { is T -> body }` and `if (x is T) body`, emits a
+ * `@type-binding.annotation` capture binding `x → T` anchored on the body
+ * node. The capture lands in the matching `@scope.block` scope (see query.ts
+ * smart-cast scopes), shadowing the outer parameter binding for calls inside
+ * the body without leaking across sibling arms or to `else`.
+ *
+ * Only narrows when:
+ *   - the `when` subject is a `simple_identifier` (not a call or field chain);
+ *   - the `when_entry` condition is exactly one `type_test` (skips `!is`,
+ *     compound conditions, range/`in`/value patterns);
+ *   - the `if_expression` condition is a `check_expression` of the form
+ *     `<simple_identifier> is <user_type>` and the then-branch is a
+ *     `control_structure_body`.
+ *
+ * `else` arms and non-narrowing conditions emit nothing — the fall-through to
+ * the outer scope's declared type is the correct semantic.
+ */
+function synthesizeKotlinSmartCastBindings(rootNode) {
+    const out = [];
+    for (const whenNode of descendantsOfType(rootNode, 'when_expression')) {
+        const subjectName = extractWhenSubjectIdentifier(whenNode);
+        if (subjectName === null)
+            continue;
+        for (const entry of whenNode.namedChildren) {
+            if (entry.type !== 'when_entry')
+                continue;
+            const narrowedType = extractIsTestTargetType(entry);
+            if (narrowedType === null)
+                continue;
+            const body = entry.namedChildren.find((child) => child.type === 'control_structure_body');
+            if (body === undefined)
+                continue;
+            out.push(buildNarrowedTypeBindingCapture(subjectName.node, body, narrowedType));
+        }
+    }
+    for (const ifNode of descendantsOfType(rootNode, 'if_expression')) {
+        const check = ifNode.namedChildren.find((child) => child.type === 'check_expression');
+        if (check === undefined)
+            continue;
+        const subject = check.namedChildren.find((child) => child.type === 'simple_identifier');
+        const typeNode = check.namedChildren.find((child) => isKotlinTypeNode(child));
+        if (subject === undefined || typeNode === undefined)
+            continue;
+        // The first control_structure_body sibling is the then-branch; else
+        // branches (when present) appear as the second control_structure_body
+        // and are intentionally not narrowed.
+        const body = ifNode.namedChildren.find((child) => child.type === 'control_structure_body');
+        if (body === undefined)
+            continue;
+        out.push(buildNarrowedTypeBindingCapture(subject, body, typeNode));
+    }
+    return out;
+}
+function extractWhenSubjectIdentifier(whenNode) {
+    const subject = whenNode.namedChildren.find((child) => child.type === 'when_subject');
+    if (subject === undefined)
+        return null;
+    const ident = subject.namedChildren.find((child) => child.type === 'simple_identifier');
+    return ident === undefined ? null : { node: ident };
+}
+function extractIsTestTargetType(whenEntry) {
+    const condition = whenEntry.namedChildren.find((child) => child.type === 'when_condition');
+    if (condition === undefined)
+        return null;
+    // Exactly one when_condition child must be a positive type_test.
+    // Compound conditions (multiple `when_condition` siblings joined with
+    // commas in some grammars) or negated `!is` are not safe to narrow.
+    if (condition.namedChildCount !== 1)
+        return null;
+    const test = condition.namedChild(0);
+    if (test === null || test.type !== 'type_test')
+        return null;
+    // `!is` produces a different node (`negated_type_test` in some grammars,
+    // or an extra `!` child in others) — defend by checking text prefix.
+    if (test.text.trim().startsWith('!'))
+        return null;
+    return test.namedChildren.find((child) => isKotlinTypeNode(child)) ?? null;
+}
+function buildNarrowedTypeBindingCapture(subject, bodyAnchor, typeNode) {
+    return {
+        '@type-binding.annotation': nodeToCapture('@type-binding.annotation', bodyAnchor),
+        '@type-binding.name': syntheticCapture('@type-binding.name', subject, subject.text),
+        '@type-binding.type': syntheticCapture('@type-binding.type', typeNode, normalizeKotlinType(typeNode.text)),
+        // Marker consumed by `kotlinBindingScopeFor` in simple-hooks.ts to
+        // override the scope-extractor's auto-hoist. Unbraced arm bodies
+        // (`is User -> obj.save()`) make the body anchor coincide with the
+        // Block scope's range; without this marker the binding would hoist
+        // to the enclosing function scope and lose its arm-local narrowing.
+        '@type-binding.narrowed': syntheticCapture('@type-binding.narrowed', bodyAnchor, '1'),
+    };
+}
 function synthesizeKotlinLocalAssignmentBindings(rootNode, returnTypes) {
     const out = [];
+    const classMembers = collectKotlinClassMembers(rootNode);
     for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
         const localTypes = new Map();
         for (const prop of descendantsOfType(fnNode, 'property_declaration')) {
-            const inferred = inferKotlinPropertyType(prop, localTypes, returnTypes);
+            const inferred = inferKotlinPropertyType(prop, localTypes, returnTypes, classMembers);
             if (inferred === null)
                 continue;
             localTypes.set(inferred.name.text, inferred.rawType);
@@ -138,6 +255,69 @@ function synthesizeKotlinLocalAssignmentBindings(rootNode, returnTypes) {
     }
     return out;
 }
+/**
+ * Per-file class-member index — primary-constructor `val`/`var` params,
+ * body property declarations, and method return types. Used by
+ * `inferKotlinPropertyType` to walk single-level field and method chains
+ * like `val addr = user.address` and `val city = addr.getCity()` (#1760).
+ *
+ * Indexes by simple class name only. Multi-class collisions inside a
+ * single file will pick whichever class was visited last for that name
+ * — acceptable because Kotlin forbids same-name top-level classes in
+ * one file and per-file resolution is the design boundary here.
+ */
+function collectKotlinClassMembers(rootNode) {
+    const fields = new Map();
+    const methods = new Map();
+    for (const cls of descendantsOfType(rootNode, 'class_declaration')) {
+        const className = cls.namedChildren.find((child) => child.type === 'type_identifier')?.text;
+        if (className === undefined)
+            continue;
+        const fmap = fields.get(className) ?? new Map();
+        const mmap = methods.get(className) ?? new Map();
+        const primary = cls.namedChildren.find((child) => child.type === 'primary_constructor');
+        if (primary !== undefined) {
+            for (const param of primary.namedChildren) {
+                if (param.type !== 'class_parameter')
+                    continue;
+                // Constructor params are class fields ONLY when prefixed with
+                // `val`/`var` (binding_pattern_kind). Plain `fn(x: Int)`-style
+                // params remain locals to the constructor.
+                if (param.namedChildren.find((c) => c.type === 'binding_pattern_kind') === undefined) {
+                    continue;
+                }
+                const fname = param.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+                const ftype = param.namedChildren.find((c) => isKotlinTypeNode(c))?.text;
+                if (fname !== undefined && ftype !== undefined)
+                    fmap.set(fname, ftype);
+            }
+        }
+        const body = cls.namedChildren.find((child) => child.type === 'class_body');
+        if (body !== undefined) {
+            for (const member of body.namedChildren) {
+                if (member.type === 'property_declaration') {
+                    const v = member.namedChildren.find((c) => c.type === 'variable_declaration');
+                    const fname = v?.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+                    const ftype = v?.namedChildren.find((c) => isKotlinTypeNode(c))?.text;
+                    if (fname !== undefined && ftype !== undefined)
+                        fmap.set(fname, ftype);
+                }
+                else if (member.type === 'function_declaration') {
+                    const mname = member.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+                    const paramsIdx = member.namedChildren.findIndex((c) => c.type === 'function_value_parameters');
+                    const rtype = paramsIdx < 0
+                        ? undefined
+                        : member.namedChildren.slice(paramsIdx + 1).find((c) => isKotlinTypeNode(c))?.text;
+                    if (mname !== undefined && rtype !== undefined)
+                        mmap.set(mname, rtype);
+                }
+            }
+        }
+        fields.set(className, fmap);
+        methods.set(className, mmap);
+    }
+    return { fields, methods };
+}
 function collectKotlinLocalTypeTexts(fnNode, returnTypes) {
     const out = new Map();
     for (const node of descendants(fnNode)) {
@@ -169,7 +349,7 @@ function collectKotlinReturnTypeTexts(rootNode) {
     }
     return out;
 }
-function inferKotlinPropertyType(prop, localTypes, returnTypes) {
+function inferKotlinPropertyType(prop, localTypes, returnTypes, classMembers) {
     const variable = prop.namedChildren.find((child) => child.type === 'variable_declaration');
     const name = variable?.namedChildren.find((child) => child.type === 'simple_identifier');
     if (variable === undefined || name === undefined)
@@ -183,17 +363,70 @@ function inferKotlinPropertyType(prop, localTypes, returnTypes) {
         const rawType = localTypes.get(value.text);
         return rawType === undefined ? null : { name, rawType, source: value, synthetic: true };
     }
+    if (value?.type === 'navigation_expression') {
+        // `val addr = user.address` — receiver type → field on that class (#1760).
+        const chained = inferKotlinNavigationFieldType(value, localTypes, classMembers);
+        if (chained === null)
+            return null;
+        return { name, rawType: chained, source: value, synthetic: true };
+    }
     if (value?.type === 'call_expression') {
-        const callee = value.namedChildren.find((child) => child.type === 'simple_identifier');
+        const callee = value.namedChildren.find((child) => child.type === 'simple_identifier' || child.type === 'navigation_expression');
         if (callee === undefined)
             return null;
-        const rawType = returnTypes.get(callee.text) ?? (isUppercaseName(callee.text) ? callee.text : null);
-        if (rawType === null)
+        if (callee.type === 'simple_identifier') {
+            const rawType = returnTypes.get(callee.text) ?? (isUppercaseName(callee.text) ? callee.text : null);
+            if (rawType === null)
+                return null;
+            return { name, rawType, source: callee, synthetic: true };
+        }
+        // `val city = addr.getCity()` — receiver type → method return on that class (#1760).
+        const chained = inferKotlinNavigationCallReturnType(callee, localTypes, classMembers);
+        if (chained === null)
             return null;
-        return { name, rawType, source: callee, synthetic: true };
+        return { name, rawType: chained, source: callee, synthetic: true };
     }
     return null;
 }
+/** Resolve `receiver.field` → field's declared type, where `receiver`
+ *  is a simple identifier whose type is in `localTypes` and `field`
+ *  is declared on that type in `classMembers.fields`. Returns null
+ *  when any link in the chain is unknown — safe over-conservative. */
+function inferKotlinNavigationFieldType(nav, localTypes, classMembers) {
+    if (classMembers === undefined)
+        return null;
+    const receiver = nav.namedChild(0);
+    if (receiver === null || receiver.type !== 'simple_identifier')
+        return null;
+    const member = nav.namedChildren
+        .find((c) => c.type === 'navigation_suffix')
+        ?.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+    if (member === undefined)
+        return null;
+    const recvType = localTypes.get(receiver.text);
+    if (recvType === undefined)
+        return null;
+    return classMembers.fields.get(normalizeKotlinType(recvType))?.get(member) ?? null;
+}
+/** Resolve `receiver.method()` → method's declared return type, where
+ *  `receiver` is a simple identifier whose type is in `localTypes` and
+ *  `method` is declared on that type in `classMembers.methods`. */
+function inferKotlinNavigationCallReturnType(navCallee, localTypes, classMembers) {
+    if (classMembers === undefined)
+        return null;
+    const receiver = navCallee.namedChild(0);
+    if (receiver === null || receiver.type !== 'simple_identifier')
+        return null;
+    const methodName = navCallee.namedChildren
+        .find((c) => c.type === 'navigation_suffix')
+        ?.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+    if (methodName === undefined)
+        return null;
+    const recvType = localTypes.get(receiver.text);
+    if (recvType === undefined)
+        return null;
+    return classMembers.methods.get(normalizeKotlinType(recvType))?.get(methodName) ?? null;
+}
 function inferKotlinIterableElementType(iterable, localTypes, returnTypes) {
     if (iterable.type === 'simple_identifier') {
         const raw = localTypes.get(iterable.text);
@@ -214,7 +447,17 @@ function inferKotlinIterableElementType(iterable, localTypes, returnTypes) {
         if (callee === undefined)
             return null;
         const raw = returnTypes.get(callee.text);
-        return raw === undefined ? null : kotlinContainerElementType(raw, 'values');
+        if (raw !== undefined)
+            return kotlinContainerElementType(raw, 'values');
+        // Cross-file fallback (#1759): the callee's return type is unknown
+        // locally because the function lives in another file. Emit the
+        // callee name itself as the binding's rawName; `propagateImported
+        // ReturnTypes` will chain-follow `loopvar → callee → <ElementType>`
+        // once the imported module's `callee → ElementType` mirror lands at
+        // module scope. If `callee` isn't actually an imported callable
+        // (e.g. a local lambda or unrelated symbol), chain-follow fails
+        // safely and no edge is emitted.
+        return callee.text;
     }
     return null;
 }
@@ -306,6 +549,20 @@ function shouldEmitReadMember(navNode) {
         return false;
     return true;
 }
+/** True when the property_declaration anchored at `range` has a
+ *  `call_expression` value sibling (i.e. `val x: T = Foo()`). Used to
+ *  suppress the explicit-annotation type-binding capture so the
+ *  constructor-inferred binding wins (#1762). */
+function propertyDeclHasConstructorValue(rootNode, range) {
+    const propNode = findNodeAtRange(rootNode, range, 'property_declaration');
+    if (propNode === null)
+        return false;
+    const variable = propNode.namedChildren.find((c) => c.type === 'variable_declaration');
+    if (variable === undefined)
+        return false;
+    const value = propNode.namedChildren.find((c) => c.id !== variable.id && c.type !== 'binding_pattern_kind');
+    return value?.type === 'call_expression';
+}
 function callArguments(callNode) {
     const suffix = callNode.namedChildren.find((child) => child.type === 'call_suffix');
     if (suffix === undefined)

package/dist/core/ingestion/languages/kotlin/import-target.d.ts

@@ -3,4 +3,4 @@ export interface KotlinResolveContext {
     readonly fromFile: string;
     readonly allFilePaths: ReadonlySet<string>;
 }
-export declare function resolveKotlinImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;
+export declare function resolveKotlinImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | readonly string[] | null;

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

@@ -13,19 +13,41 @@ export function resolveKotlinImportTarget(parsedImport, workspaceIndex) {
         ? parsedImport.targetRaw.slice(0, -2)
         : parsedImport.targetRaw;
     const pathLike = target.replace(/\./g, '/');
+    // Resolution tiers, most-specific first:
+    //  1. The full `pathLike` matches a `.kt`/`.kts` file directly
+    //     (`import util.User` → `util/User.kt`).
+    //  2. Stripped (last-segment removed) `pathLike` matches a file
+    //     directly (`import util.OneArg.writeAudit` → `util/OneArg.kt`,
+    //     a class-or-object holding `writeAudit`).
+    //  3. Stripped `pathLike` matches a *package directory* — fan out to
+    //     every `.kt`/`.kts` file inside it (`import models.getRepo` →
+    //     `[models/User.kt, models/Repo.kt]`). The finalize pass walks
+    //     each candidate and picks the one whose `localDefs` actually
+    //     export the imported name (#1759).
+    //  4. Progressive prefix strip for deeper namespace aliases that
+    //     don't map 1:1 to directories.
+    const stripped = pathLike.split('/').slice(0, -1).join('/');
     return (findKotlinFile(ctx.allFilePaths, pathLike) ??
-        findKotlinFile(ctx.allFilePaths, pathLike.split('/').slice(0, -1).join('/')) ??
+        findKotlinExactOrSuffix(ctx.allFilePaths, stripped) ??
+        findKotlinPackageFiles(ctx.allFilePaths, stripped) ??
         findByProgressivePrefixStrip(ctx.allFilePaths, pathLike));
 }
 function findKotlinFile(allFilePaths, pathLike) {
+    return (findKotlinExactOrSuffix(allFilePaths, pathLike) ??
+        findKotlinDirectoryChild(allFilePaths, pathLike));
+}
+/** Exact (`file === pathLike+ext`) or suffix (`file ends with /pathLike+ext`)
+ *  match — does NOT fall back to picking an arbitrary file inside a
+ *  `pathLike/` directory. Used by the stripped-path tier in
+ *  `resolveKotlinImportTarget` so a package import like `models.getRepo`
+ *  delegates to `findKotlinPackageFiles` (multi-file fan-out) instead of
+ *  silently committing to the first directory child. */
+function findKotlinExactOrSuffix(allFilePaths, pathLike) {
     if (pathLike === '')
         return null;
     const extensions = ['.kt', '.kts'];
     const suffix = `/${pathLike}`;
-    const dirPrefix = `${pathLike}/`;
-    const suffixDirPrefix = `/${dirPrefix}`;
     let suffixFile = null;
-    let directoryChild = null;
     for (const raw of allFilePaths) {
         const file = raw.replace(/\\/g, '/');
         if (!extensions.some((ext) => file.endsWith(ext)))
@@ -36,18 +58,68 @@ function findKotlinFile(allFilePaths, pathLike) {
             if (suffixFile === null && file.endsWith(`${suffix}${ext}`))
                 suffixFile = raw;
         }
-        if (directoryChild === null) {
-            const atRoot = file.startsWith(dirPrefix);
-            const atNested = file.includes(suffixDirPrefix);
-            if (atRoot || atNested) {
-                const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
-                const after = file.slice(idx + dirPrefix.length);
-                if (after.length > 0 && !after.includes('/'))
-                    directoryChild = raw;
-            }
-        }
     }
-    return suffixFile ?? directoryChild;
+    return suffixFile;
+}
+/** First directory child of `pathLike/` — preserves the legacy single-
+ *  file fallback for cases where `pathLike` itself is an unqualified
+ *  package reference (rare in real Kotlin code; some fixtures rely on
+ *  it). Multi-file package fan-out goes through
+ *  `findKotlinPackageFiles` instead. */
+function findKotlinDirectoryChild(allFilePaths, pathLike) {
+    if (pathLike === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const dirPrefix = `${pathLike}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        const atRoot = file.startsWith(dirPrefix);
+        const atNested = file.includes(suffixDirPrefix);
+        if (!atRoot && !atNested)
+            continue;
+        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
+        const after = file.slice(idx + dirPrefix.length);
+        if (after.length > 0 && !after.includes('/'))
+            return raw;
+    }
+    return null;
+}
+/**
+ * Return every `.kt`/`.kts` file inside the package directory `dirPath`
+ * (e.g. `models` → `['models/User.kt', 'models/Repo.kt']`). Used as a
+ * fallback when an import like `models.getRepo` does not resolve to a
+ * file named after the symbol — in Kotlin the symbol can live in any
+ * file inside the package directory. The finalize pass walks each
+ * candidate and picks the one whose `localDefs` actually export the
+ * imported name (#1759).
+ */
+function findKotlinPackageFiles(allFilePaths, dirPath) {
+    if (dirPath === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const dirPrefix = `${dirPath}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    const out = [];
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        const atRoot = file.startsWith(dirPrefix);
+        const atNested = file.includes(suffixDirPrefix);
+        if (!atRoot && !atNested)
+            continue;
+        const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
+        const after = file.slice(idx + dirPrefix.length);
+        // Direct children only — `models/sub/Util.kt` is a different package
+        // (`models.sub`) and must not be merged with `models`.
+        if (after.length === 0 || after.includes('/'))
+            continue;
+        out.push(raw);
+    }
+    return out.length === 0 ? null : out;
 }
 function findByProgressivePrefixStrip(allFilePaths, pathLike) {
     const segments = pathLike.split('/').filter(Boolean);

package/dist/core/ingestion/languages/kotlin/owners.js

@@ -2,6 +2,30 @@ import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/s
 export function populateKotlinOwners(parsed) {
     populateClassOwnedMembers(parsed);
     populateCompanionMembersOnEnclosingClass(parsed);
+    upgradeClassOwnedFunctionsToMethods(parsed);
+}
+/**
+ * Align scope-resolution `def.type` with the graph's node-label
+ * conventions: a `Function` def that lives inside a class body becomes
+ * a `Method`. The Kotlin extractor labels every `function_declaration`
+ * as `Function`, but the graph parsing-processor emits a `Method`
+ * graph-node label for class members. Without this realignment,
+ * `resolveDefGraphId`'s parameter-typed key lookup (gated on
+ * `def.type === 'Method'`) falls through to the simple-name fallback
+ * for class methods, collapsing same-name same-arity overloads onto
+ * the first-registered node (#1761).
+ *
+ * Only Method-bearing types are touched. Methods have a class owner
+ * (set by `populateClassOwnedMembers`) and a class-qualified name.
+ */
+function upgradeClassOwnedFunctionsToMethods(parsed) {
+    for (const def of parsed.localDefs) {
+        if (def.type !== 'Function')
+            continue;
+        if (def.ownerId === undefined)
+            continue;
+        def.type = 'Method';
+    }
 }
 function populateCompanionMembersOnEnclosingClass(parsed) {
     const scopesById = new Map();

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

@@ -8,6 +8,19 @@ const KOTLIN_SCOPE_QUERY = `
 (companion_object) @scope.class
 (function_declaration) @scope.function
 
+;; Smart-cast narrowing scopes (RFC #909 Ring 3, issue #1758).
+;; Each is-test arm body and each if-then body becomes its own Block
+;; scope so synthesized narrowed type-bindings (see captures.ts
+;; synthesizeKotlinSmartCastBindings) shadow the outer parameter
+;; binding for calls inside the body — without leaking across arms.
+(when_entry
+  (when_condition (type_test))
+  (control_structure_body) @scope.block)
+
+(if_expression
+  (check_expression)
+  (control_structure_body) @scope.block)
+
 ;; Declarations — types
 (class_declaration
   "interface"

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

@@ -1,5 +1,7 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { kotlinProvider } from '../kotlin.js';
 import { kotlinArityCompatibility, kotlinMergeBindings, populateKotlinOwners, resolveKotlinImportTarget, } from './index.js';
 /**
@@ -27,7 +29,7 @@ export const kotlinScopeResolver = {
     },
     mergeBindings: (existing, incoming) => [...kotlinMergeBindings([...existing, ...incoming])],
     arityCompatibility: (callsite, def) => kotlinArityCompatibility(def, callsite),
-    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildKotlinMro(graph, parsedFiles, nodeLookup),
     populateOwners: (parsed) => populateKotlinOwners(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
     fieldFallbackOnMethodLookup: false,
@@ -35,3 +37,88 @@ export const kotlinScopeResolver = {
     collapseMemberCallsByCallerTarget: false,
     hoistTypeBindingsToModule: true,
 };
+/**
+ * Kotlin MRO builder — extends `defaultLinearize` (EXTENDS-only) with
+ * interface ancestors discovered via `IMPLEMENTS` edges. Interface
+ * default methods (`interface Validator { fun validate(): Boolean = true }`)
+ * are inherited by implementing classes without an explicit override;
+ * the generic MRO would not surface them because the implementor has
+ * no `EXTENDS` link to the interface (#1763).
+ *
+ * Interfaces are appended after the EXTENDS chain (Kotlin resolves
+ * conflicts by requiring an explicit override, so first-seen-in-MRO
+ * ordering is a reasonable approximation for method lookup). Transitive
+ * interface inheritance (`interface A : B`) is closed via BFS.
+ */
+function buildKotlinMro(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);
+        }
+    }
+    // Direct IMPLEMENTS targets per class-like def.
+    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 each class, append the transitive closure of interfaces reachable
+    // through its own + ancestor classes' IMPLEMENTS edges. Walking
+    // ancestors picks up interfaces inherited via the EXTENDS chain
+    // (e.g. `class C : B; class B : A; interface A` — C inherits A's
+    // interface methods through B).
+    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))]);
+    }
+    // Classes with no EXTENDS still need an MRO entry when they implement
+    // interfaces (e.g. `class User : Validator` — no `mro` entry from the
+    // EXTENDS-only pass because no EXTENDS edges exist).
+    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];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        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/languages/kotlin/simple-hooks.js

@@ -1,4 +1,11 @@
 export function kotlinBindingScopeFor(decl, innermost, tree) {
+    // Smart-cast narrowed bindings (issue #1758) must stay at the innermost
+    // (Block) scope. Their anchor coincides with the Block's range for
+    // unbraced arm bodies (`is User -> obj.save()`), which would otherwise
+    // trigger scope-extractor auto-hoist into the enclosing function scope
+    // and erase the arm-local narrowing.
+    if (decl['@type-binding.narrowed'] !== undefined)
+        return innermost.id;
     if (decl['@type-binding.return'] === undefined)
         return null;
     let current = innermost;

package/package.json

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