gitnexus 1.6.13-rc.18 → 1.6.13-rc.19

package/dist/_shared/index.d.ts

@@ -23,6 +23,7 @@ export type { QualifiedNameIndex } from './scope-resolution/qualified-name-index
 export { resolveTypeRef } from './scope-resolution/resolve-type-ref.js';
 export type { ResolveTypeRefContext } from './scope-resolution/resolve-type-ref.js';
 export type { ParsedFile } from './scope-resolution/parsed-file.js';
+export type { CallResultAssignmentSite } from './scope-resolution/call-result-assignment-site.js';
 export type { ReferenceSite, ReferenceKind, CallForm, MixedChainStep, } from './scope-resolution/reference-site.js';
 export type { CallableFlowOperand, CallableFlowExpectedSignature, CallableFlowPassingMode, CallableFlowInvocationKind, CallableFlowSeedSite, CallableFlowCopySite, CallableFlowAliasSite, CallableFlowAddressSite, CallableFlowStoreSite, CallableFlowLoadSite, CallableFlowFormalSite, CallableFlowArgumentSite, CallableFlowInvokeSite, CallableFlowSite, } from './scope-resolution/callable-flow-site.js';
 export { buildMethodDispatchIndex } from './scope-resolution/method-dispatch-index.js';

package/dist/_shared/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/_shared/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,mBAAmB;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,mBAAmB;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAGjC,sBAAsB;AACtB,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AA4C5E,8DAA8D;AAC9D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAGxE,yDAAyD;AACzD,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,+CAA+C,CAAC;AAGvD,sEAAsE;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAGrF,gEAAgE;AAChE,yEAAyE;AACzE,2DAA2D;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AA4BxE,oFAAoF;AACpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AAMvF,uEAAuE;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAWpE,sEAAsE;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAErF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kDAAkD,CAAC;AAKvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAKrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAErF,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,mDAAmD,CAAC;AAEpF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAEpG,OAAO,EACL,gCAAgC,EAChC,kBAAkB,GACnB,MAAM,6CAA6C,CAAC;AAErD,OAAO,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,GACZ,MAAM,0CAA0C,CAAC;AAUlD,2EAA2E;AAC3E,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAErF,OAAO,EACL,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAG1E,8EAA8E;AAC9E,wEAAwE;AACxE,wEAAwE;AACxE,8DAA8D;AAC9D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAEjG,OAAO,EACL,cAAc,EACd,4BAA4B,EAC5B,kBAAkB,EAClB,eAAe,EACf,sBAAsB,GACvB,MAAM,mCAAmC,CAAC;AAG3C,mDAAmD;AACnD,OAAO,EACL,+BAA+B,EAC/B,6BAA6B,EAC7B,4BAA4B,EAC5B,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,GACf,MAAM,sCAAsC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,mBAAmB;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,mBAAmB;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAGjC,sBAAsB;AACtB,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AA4C5E,8DAA8D;AAC9D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAGxE,yDAAyD;AACzD,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,+CAA+C,CAAC;AAGvD,sEAAsE;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAGrF,gEAAgE;AAChE,yEAAyE;AACzE,2DAA2D;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AA6BxE,oFAAoF;AACpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AAMvF,uEAAuE;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAWpE,sEAAsE;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAErF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kDAAkD,CAAC;AAKvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAKrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAErF,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,mDAAmD,CAAC;AAEpF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAEpG,OAAO,EACL,gCAAgC,EAChC,kBAAkB,GACnB,MAAM,6CAA6C,CAAC;AAErD,OAAO,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,GACZ,MAAM,0CAA0C,CAAC;AAUlD,2EAA2E;AAC3E,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAErF,OAAO,EACL,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAG1E,8EAA8E;AAC9E,wEAAwE;AACxE,wEAAwE;AACxE,8DAA8D;AAC9D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAEjG,OAAO,EACL,cAAc,EACd,4BAA4B,EAC5B,kBAAkB,EAClB,eAAe,EACf,sBAAsB,GACvB,MAAM,mCAAmC,CAAC;AAG3C,mDAAmD;AACnD,OAAO,EACL,+BAA+B,EAC/B,6BAA6B,EAC7B,4BAA4B,EAC5B,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,GACf,MAAM,sCAAsC,CAAC"}

package/dist/_shared/scope-resolution/call-result-assignment-site.d.ts

@@ -0,0 +1,14 @@
+import type { Range, ScopeId } from './types.js';
+/**
+ * Compact extraction-time identity for `lhs = callee()`.
+ *
+ * The call-site range uses the same call-expression anchor as reference
+ * resolution, allowing downstream passes to join this fact to the exact
+ * resolved callee id without relying on a possibly polluted type binding.
+ */
+export interface CallResultAssignmentSite {
+    readonly callSite: Range;
+    readonly inScope: ScopeId;
+    readonly lhs: string;
+}
+//# sourceMappingURL=call-result-assignment-site.d.ts.map

package/dist/_shared/scope-resolution/call-result-assignment-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-result-assignment-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/call-result-assignment-site.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB"}

package/dist/_shared/scope-resolution/call-result-assignment-site.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=call-result-assignment-site.js.map

package/dist/_shared/scope-resolution/call-result-assignment-site.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-result-assignment-site.js","sourceRoot":"","sources":["../../src/scope-resolution/call-result-assignment-site.ts"],"names":[],"mappings":""}

package/dist/_shared/scope-resolution/parsed-file.d.ts

@@ -55,6 +55,7 @@ import type { ParsedImport } from './types.js';
 import type { SymbolDefinition } from './symbol-definition.js';
 import type { ReferenceSite } from './reference-site.js';
 import type { CallableFlowSite } from './callable-flow-site.js';
+import type { CallResultAssignmentSite } from './call-result-assignment-site.js';
 export interface ParsedFile {
     readonly filePath: string;
     /** `Scope.id` of the file's root `Module` scope. */
@@ -79,6 +80,8 @@ export interface ParsedFile {
      * syntax remain source-compatible; consumers normalize absence to `[]`.
      */
     readonly callableFlowSites?: readonly CallableFlowSite[];
+    /** Exact call-expression → assigned local identity for return-type replay. */
+    readonly callResultAssignmentSites?: readonly CallResultAssignmentSite[];
     /**
      * Opaque, language-private serialization of capture-time side-channel
      * state that a provider's `emitScopeCaptures` populates into module-level

package/dist/_shared/scope-resolution/parsed-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsed-file.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACzD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC"}
+{"version":3,"file":"parsed-file.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,yBAAyB,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACzE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC"}

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

@@ -37,6 +37,7 @@ import { swiftQualifiedBaseTail } from './base-type.js';
 import { computeSwiftArityMetadata } from './arity-metadata.js';
 import { findEnclosingTypeDeclaration, synthesizeSwiftReceiverBinding, } from './receiver-binding.js';
 import { synthesizeSwiftSignatureBindings } from './signature-bindings.js';
+import { swiftMethodConfig } from '../../method-extractors/configs/swift.js';
 import { getSwiftParser, getSwiftScopeQuery } from './query.js';
 import { preprocessSwiftConditionalDirectives } from './conditional-directive-preprocess.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
@@ -174,6 +175,23 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
             }
             continue;
         }
+        // The query deliberately recognizes the compact `lhs = call()` shape;
+        // enforce "untyped lhs" here because tree-sitter queries cannot express
+        // absence of Swift's sibling type_annotation robustly. A typed declaration
+        // remains authoritative and must never enter return-type replay.
+        if (grouped['@call-result-assignment.call'] !== undefined) {
+            const callNode = nodeIfType(nodeMap['@call-result-assignment.call'], 'call_expression');
+            let property = callNode?.parent;
+            while (property?.type === 'await_expression' || property?.type === 'try_expression') {
+                property = property.parent;
+            }
+            if (property?.type !== 'property_declaration' ||
+                property.namedChildren.some((child) => child.type === 'type_annotation')) {
+                continue;
+            }
+            out.push(grouped);
+            continue;
+        }
         // ── Field accesses: a `navigation_expression` (`obj.field`) is one of
         // three things. Drop it when it's a call's callee (`u.save` in
         // `u.save()` — the @reference.call.member query already covers that).
@@ -279,8 +297,13 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
             const fnNodeForArity = nodeIfType(nodeMap['@scope.function'] ??
                 nodeMap['@declaration.method'] ??
                 nodeMap['@declaration.constructor'], ...FUNCTION_NODE_TYPES);
-            if (fnNodeForArity !== null)
+            if (fnNodeForArity !== null) {
                 attachArityMetadata(grouped, fnNodeForArity);
+                const returnType = swiftMethodConfig.extractReturnType?.(fnNodeForArity);
+                if (returnType !== undefined && returnType !== '') {
+                    grouped['@declaration.return-type'] = syntheticCapture('@declaration.return-type', fnNodeForArity, returnType);
+                }
+            }
             // Structural receiver chain for a call whose receiver is itself an
             // expression, so resolution can type it by folding over structure
             // instead of re-parsing the receiver's source text. Self-gating: a
@@ -304,8 +327,13 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
         const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
         if (declTag !== undefined) {
             const fnNode = nodeIfType(nodeMap[declTag], ...FUNCTION_NODE_TYPES);
-            if (fnNode !== null)
+            if (fnNode !== null) {
                 attachArityMetadata(grouped, fnNode);
+                const returnType = swiftMethodConfig.extractReturnType?.(fnNode);
+                if (returnType !== undefined && returnType !== '') {
+                    grouped['@declaration.return-type'] = syntheticCapture('@declaration.return-type', fnNode, returnType);
+                }
+            }
         }
         // ── Constructor calls: Swift has no `new`, so `Foo()` is a free call
         // whose callee is a type. Re-tag an UpperCamelCase free-call callee as

package/dist/core/ingestion/languages/swift/index.d.ts

@@ -26,7 +26,7 @@
  */
 export { emitSwiftScopeCaptures } from './captures.js';
 export { getSwiftCaptureCacheStats, resetSwiftCaptureCacheStats } from './cache-stats.js';
-export { interpretSwiftImport, interpretSwiftTypeBinding } from './interpret.js';
+export { interpretSwiftImport, interpretSwiftTypeBinding, normalizeSwiftTypeName, stripSwiftTypePreservingDecoration, } from './interpret.js';
 export { swiftMergeBindings } from './merge-bindings.js';
 export { swiftArityCompatibility } from './arity.js';
 export { resolveSwiftImportTarget, type SwiftResolveContext } from './import-target.js';

package/dist/core/ingestion/languages/swift/index.js

@@ -26,7 +26,7 @@
  */
 export { emitSwiftScopeCaptures } from './captures.js';
 export { getSwiftCaptureCacheStats, resetSwiftCaptureCacheStats } from './cache-stats.js';
-export { interpretSwiftImport, interpretSwiftTypeBinding } from './interpret.js';
+export { interpretSwiftImport, interpretSwiftTypeBinding, normalizeSwiftTypeName, stripSwiftTypePreservingDecoration, } from './interpret.js';
 export { swiftMergeBindings } from './merge-bindings.js';
 export { swiftArityCompatibility } from './arity.js';
 export { resolveSwiftImportTarget } from './import-target.js';

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

@@ -13,3 +13,11 @@
 import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
 export declare function interpretSwiftImport(captures: CaptureMatch): ParsedImport | null;
 export declare function interpretSwiftTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+export declare function normalizeSwiftTypeName(text: string): string;
+/**
+ * Type-preserving decoration only — used by `stripTypePreservingDecoration`
+ * for class lookup and declared-return replay. `User?` / `User!` → `User`.
+ * Arrays, generics, and nested `Foo.Bar` are left intact so a binding used
+ * for member lookup does not follow the element type or the trailing ident.
+ */
+export declare function stripSwiftTypePreservingDecoration(typeName: string): string | undefined;

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

@@ -40,7 +40,7 @@ export function interpretSwiftTypeBinding(captures) {
     //   `[User]`                    → User   (array sugar)
     //   `Array<User>` / `Optional<User>` → User (single-arg generic)
     //   `Foundation.URL`            → URL    (qualifier)
-    const rawType = stripQualifier(stripGeneric(stripArraySugar(stripOptional(typeCap.text.trim()))));
+    const rawType = normalizeSwiftTypeName(typeCap.text);
     let source = 'parameter-annotation';
     if (captures['@type-binding.self'] !== undefined)
         source = 'self';
@@ -54,6 +54,21 @@ export function interpretSwiftTypeBinding(captures) {
         source = 'return-annotation';
     return { boundName: nameCap.text, rawTypeName: rawType, source };
 }
+export function normalizeSwiftTypeName(text) {
+    return stripQualifier(stripGeneric(stripArraySugar(stripOptional(text.trim()))));
+}
+/**
+ * Type-preserving decoration only — used by `stripTypePreservingDecoration`
+ * for class lookup and declared-return replay. `User?` / `User!` → `User`.
+ * Arrays, generics, and nested `Foo.Bar` are left intact so a binding used
+ * for member lookup does not follow the element type or the trailing ident.
+ */
+export function stripSwiftTypePreservingDecoration(typeName) {
+    const trimmed = typeName.trim();
+    if (trimmed.endsWith('?') || trimmed.endsWith('!'))
+        return trimmed.slice(0, -1).trim();
+    return undefined;
+}
 /** `User?` / `User!` → `User`. */
 function stripOptional(text) {
     if (text.endsWith('?') || text.endsWith('!'))

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

@@ -186,6 +186,32 @@ const SWIFT_SCOPE_QUERY = `
 (call_expression
   (simple_identifier) @reference.name) @reference.call.free
 
+;; Exact identity for \`let lhs = callee()\`. The call-expression anchor is
+;; byte-identical to @reference.call.free / member for downstream position join.
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @call-result-assignment.lhs)
+  value: (call_expression) @call-result-assignment.call)
+
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @call-result-assignment.lhs)
+  value: (await_expression
+    (call_expression) @call-result-assignment.call))
+
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @call-result-assignment.lhs)
+  value: (try_expression
+    (call_expression) @call-result-assignment.call))
+
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @call-result-assignment.lhs)
+  value: (try_expression
+    (await_expression
+      (call_expression) @call-result-assignment.call)))
+
 ;; ── References — member / method calls: \`obj.method(...)\` ───────────
 ;; navigation_expression carries the receiver (target:) and the member
 ;; (suffix > navigation_suffix > simple_identifier). \`self\` is a

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

@@ -14,7 +14,8 @@
  *     re-keys an `extension Foo { … }` to a `class_declaration`-style def
  *     named `Foo`, so its members land on `Foo`'s scope and the shared
  *     `populateClassOwnedMembers` stamps them with `Foo`'s ownerId — the
- *     same mechanism C# uses for `partial class`. No separate hoist pass.
+ *     same mechanism C# uses for `partial class`. Cross-file extensions
+ *     that mint no type def are reconciled by `populateWorkspaceOwners`.
  *   - **Labeled arguments** narrow by ARITY only (count-primary, labels
  *     soft) — see `arity.ts`. Label-precise dispatch is deferred to the
  *     type-binding layer.

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

@@ -14,7 +14,8 @@
  *     re-keys an `extension Foo { … }` to a `class_declaration`-style def
  *     named `Foo`, so its members land on `Foo`'s scope and the shared
  *     `populateClassOwnedMembers` stamps them with `Foo`'s ownerId — the
- *     same mechanism C# uses for `partial class`. No separate hoist pass.
+ *     same mechanism C# uses for `partial class`. Cross-file extensions
+ *     that mint no type def are reconciled by `populateWorkspaceOwners`.
  *   - **Labeled arguments** narrow by ARITY only (count-primary, labels
  *     soft) — see `arity.ts`. Label-precise dispatch is deferred to the
  *     type-binding layer.
@@ -52,6 +53,8 @@ import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/s
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { swiftProvider } from '../swift.js';
 import { swiftArityCompatibility, swiftMergeBindings, interpretSwiftImport, resolveSwiftImportTarget, populateSwiftTargetSiblings, emitSwiftImplicitImportEdges, mirrorSwiftSiblingTypeBindings, } from './index.js';
+import { stripSwiftTypePreservingDecoration } from './interpret.js';
+import { coerceSwiftTargets, groupSwiftFilesBySpmTarget } from './target-grouping.js';
 import { swiftIsGlobalNameFallbackPlausible } from './name-fallback-visibility.js';
 const ZERO_RANGE = { startLine: 0, startCol: 0, endLine: 0, endCol: 0 };
 const swiftScopeResolver = {
@@ -77,11 +80,19 @@ const swiftScopeResolver = {
     // Adapter: swiftArityCompatibility uses (def, callsite); contract is (callsite, def).
     arityCompatibility: (callsite, def) => swiftArityCompatibility(def, callsite),
     buildMro: (graph, parsedFiles, nodeLookup) => buildSwiftMro(graph, parsedFiles, nodeLookup),
+    implicitThisWalksMro: true,
+    stripTypePreservingDecoration: stripSwiftTypePreservingDecoration,
     // Methods/properties/init are owned by their enclosing class/struct/
     // extension(→extended type)/protocol. Extension members hoist for free
     // because captures.ts re-keys the extension to a Class def named after
     // the extended type.
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // An extension has its own Class scope but deliberately does not mint a
+    // second type def. Its members therefore leave the per-file owner walk with
+    // a qualified name (`ExtendedType.member`) but no ownerId. Reconcile those
+    // members after all files are available so extensions declared in sibling
+    // files work as well as extensions beside the original type.
+    populateWorkspaceOwners: populateSwiftExtensionOwners,
     // `super.method()` dispatches through the superclass chain.
     isSuperReceiver: (text) => text.trim() === 'super',
     // Whole-module same-target visibility without `import`.
@@ -172,6 +183,84 @@ function buildSwiftMro(graph, parsedFiles, nodeLookup) {
     }
     return mro;
 }
+function populateSwiftExtensionOwners(parsedFiles, ctx) {
+    const filesByTarget = groupSwiftFilesBySpmTarget(parsedFiles, (parsed) => parsed.filePath, coerceSwiftTargets(ctx?.resolutionConfig));
+    for (const files of filesByTarget.values()) {
+        stampSwiftExtensionOwnersInTarget(files);
+    }
+}
+function stampSwiftExtensionOwnersInTarget(parsedFiles) {
+    const ownersByName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!isClassLike(def.type) || def.qualifiedName === undefined)
+                continue;
+            const bucket = ownersByName.get(def.qualifiedName);
+            if (bucket === undefined)
+                ownersByName.set(def.qualifiedName, [def]);
+            else
+                bucket.push(def);
+        }
+    }
+    // Extension members are Function-owned defs whose parent Class minted no
+    // type def. Nested locals are Function-owned defs whose parent is another
+    // Function — leave those ownerless so they cannot enter implicit-self CALLS.
+    for (const parsed of parsedFiles) {
+        const byId = new Map(parsed.scopes.map((scope) => [scope.id, scope]));
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Function')
+                continue;
+            const parent = scope.parent === null ? undefined : byId.get(scope.parent);
+            if (parent?.kind !== 'Class')
+                continue;
+            // A type-decl Class owns the type that opened it (same start line).
+            // Nested types inside an `extension` are also class-like and live on
+            // that Class scope — they are not the extended type, so they must
+            // not suppress stamping `func added` onto `Foo`.
+            if (parent.ownedDefs.some((d) => isClassLike(d.type) && defDeclaresThisClassScope(parent, d)))
+                continue;
+            for (const def of scope.ownedDefs) {
+                if (def.ownerId !== undefined || def.qualifiedName === undefined)
+                    continue;
+                const dot = def.qualifiedName.lastIndexOf('.');
+                if (dot <= 0)
+                    continue;
+                const owner = uniqueOwnerForExtensionPrefix(ownersByName, def.qualifiedName.slice(0, dot));
+                if (owner !== undefined) {
+                    def.ownerId = owner.nodeId;
+                }
+            }
+        }
+    }
+}
+function defDeclaresThisClassScope(parent, def) {
+    const line = /#(\d+):/.exec(def.nodeId);
+    if (line === null)
+        return true;
+    return Number(line[1]) === parent.range.startLine;
+}
+function uniqueOwnerForExtensionPrefix(ownersByName, prefix) {
+    const seen = new Set();
+    const matches = [];
+    const consider = (defs) => {
+        if (defs === undefined)
+            return;
+        for (const def of defs) {
+            if (seen.has(def.nodeId))
+                continue;
+            seen.add(def.nodeId);
+            matches.push(def);
+        }
+    };
+    consider(ownersByName.get(prefix));
+    if (!prefix.includes('.')) {
+        for (const [qn, defs] of ownersByName) {
+            if (qn !== prefix && qn.endsWith('.' + prefix))
+                consider(defs);
+        }
+    }
+    return matches.length === 1 ? matches[0] : undefined;
+}
 function closeProtocols(seeds, directImpls) {
     const out = [];
     const seen = new Set();

package/dist/core/ingestion/scope-extractor.d.ts

@@ -4,7 +4,7 @@
  * (RFC §5.3 + §3.2 Phase 1; Ring 2 PKG #919).
  *
  * Exactly one entry point: `extract(matches, filePath, provider) → ParsedFile`.
- * Runs a five-pass pipeline over the matches. Each pass is internal; the
+ * Runs a seven-pass pipeline over the matches. Each pass is internal; the
  * public contract is the output `ParsedFile`.
  *
  * ## Design principles
@@ -22,7 +22,7 @@
  *     don't overlap) are enforced by `buildScopeTree` from Ring 2 SHARED
  *     (#912). Malformed inputs throw `ScopeTreeInvariantError`.
  *
- * ## The five passes
+ * ## The seven passes
  *
  *   1. **Build scope tree.** Walk `@scope.*` matches. For each, consult
  *      `provider.resolveScopeKind` (default: suffix of the capture name).
@@ -60,6 +60,10 @@
  *      one `ReferenceSite` per match. Classify call form via
  *      `provider.classifyCallForm` (default: the capture's sub-tag if
  *      present; else `'free'`).
+ *   6. **Collect callable-value-flow facts.** Independent of Pass 5 so
+ *      existing reference-site extraction stays byte-identical.
+ *   7. **Preserve call-result assignment identity.** Untyped
+ *      `let lhs = call()` facts used by exact-callee return-type replay.
  *
  * ## What gets attached where
  *
@@ -90,7 +94,7 @@ import type { LanguageProvider } from './language-provider.js';
  */
 export type ScopeExtractorHooks = Pick<LanguageProvider, 'resolveScopeKind' | 'scopeOwnsReceivers' | 'bindingScopeFor' | 'interpretImport' | 'importsExecuteWhereWritten' | 'interpretTypeBinding' | 'classifyCallForm'>;
 /**
- * Drive the five extraction passes and return a `ParsedFile`.
+ * Drive the seven extraction passes and return a `ParsedFile`.
  *
  * Throws `ScopeTreeInvariantError` (from #912) when the provider emits
  * captures that violate structural scope invariants (e.g., overlapping

package/dist/core/ingestion/scope-extractor.js

@@ -4,7 +4,7 @@
  * (RFC §5.3 + §3.2 Phase 1; Ring 2 PKG #919).
  *
  * Exactly one entry point: `extract(matches, filePath, provider) → ParsedFile`.
- * Runs a five-pass pipeline over the matches. Each pass is internal; the
+ * Runs a seven-pass pipeline over the matches. Each pass is internal; the
  * public contract is the output `ParsedFile`.
  *
  * ## Design principles
@@ -22,7 +22,7 @@
  *     don't overlap) are enforced by `buildScopeTree` from Ring 2 SHARED
  *     (#912). Malformed inputs throw `ScopeTreeInvariantError`.
  *
- * ## The five passes
+ * ## The seven passes
  *
  *   1. **Build scope tree.** Walk `@scope.*` matches. For each, consult
  *      `provider.resolveScopeKind` (default: suffix of the capture name).
@@ -60,6 +60,10 @@
  *      one `ReferenceSite` per match. Classify call form via
  *      `provider.classifyCallForm` (default: the capture's sub-tag if
  *      present; else `'free'`).
+ *   6. **Collect callable-value-flow facts.** Independent of Pass 5 so
+ *      existing reference-site extraction stays byte-identical.
+ *   7. **Preserve call-result assignment identity.** Untyped
+ *      `let lhs = call()` facts used by exact-callee return-type replay.
  *
  * ## What gets attached where
  *
@@ -79,7 +83,7 @@ import { extractTemplateArguments, stripTrailingCallSuffix, typeApplicationArgum
 import { parseTypeParameterList } from './utils/type-parameters.js';
 // ─── Public entry point ─────────────────────────────────────────────────────
 /**
- * Drive the five extraction passes and return a `ParsedFile`.
+ * Drive the seven extraction passes and return a `ParsedFile`.
  *
  * Throws `ScopeTreeInvariantError` (from #912) when the provider emits
  * captures that violate structural scope invariants (e.g., overlapping
@@ -137,6 +141,9 @@ export function extract(matches, filePath, provider) {
     // extraction remains byte-identical.
     const callableFlowSites = [];
     pass6CollectCallableFlows(partitioned.callableFlow, positionIndex, filePath, callableFlowSites);
+    // ── Pass 7: preserve call-result assignment identity ───────────────
+    const callResultAssignmentSites = [];
+    pass7CollectCallResultAssignments(partitioned.callResultAssignment, positionIndex, filePath, callResultAssignmentSites);
     // Freeze Scope drafts into final shape and return.
     const frozenScopes = scopeDrafts.map(draftToScope);
     return Object.freeze({
@@ -149,6 +156,9 @@ export function extract(matches, filePath, provider) {
         ...(callableFlowSites.length > 0
             ? { callableFlowSites: Object.freeze(callableFlowSites.slice()) }
             : {}),
+        ...(callResultAssignmentSites.length > 0
+            ? { callResultAssignmentSites: Object.freeze(callResultAssignmentSites.slice()) }
+            : {}),
     });
 }
 /**
@@ -168,6 +178,7 @@ function partitionByTopic(matches) {
     const typeBinding = [];
     const reference = [];
     const callableFlow = [];
+    const callResultAssignment = [];
     for (const match of matches) {
         for (const topic of topicsOf(match)) {
             switch (topic) {
@@ -189,10 +200,21 @@ function partitionByTopic(matches) {
                 case 'callable-flow':
                     callableFlow.push(match);
                     break;
+                case 'call-result-assignment':
+                    callResultAssignment.push(match);
+                    break;
             }
         }
     }
-    return { scope, declaration, import_, typeBinding, reference, callableFlow };
+    return {
+        scope,
+        declaration,
+        import_,
+        typeBinding,
+        reference,
+        callableFlow,
+        callResultAssignment,
+    };
 }
 function topicsOf(match) {
     const topics = new Set();
@@ -209,6 +231,8 @@ function topicsOf(match) {
             topics.add('reference');
         else if (name.startsWith('@callable-flow.'))
             topics.add('callable-flow');
+        else if (name.startsWith('@call-result-assignment.'))
+            topics.add('call-result-assignment');
     }
     return topics;
 }
@@ -396,19 +420,28 @@ function pass2AttachDeclarations(matches, drafts, positionIndex, localDefs, file
         // fact is the failure mode this subsystem rejects everywhere else.
         //
         // Copying the field onto BOTH twins makes the outcome identical whichever
-        // one wins. Deliberately narrow — only `typeParameters`, the one field with
-        // an asymmetric twin today. Widening this to "merge all metadata" would
-        // change what every existing duplicate resolves to, which is a different
-        // change with a different blast radius and no evidence behind it yet.
+        // one wins. Deliberately narrow — only metadata whose asymmetric twins have
+        // executable regressions (`typeParameters` and `returnType`). Widening this
+        // to "merge all metadata" would change what every existing duplicate
+        // resolves to, which is a different change with a different blast radius
+        // and no evidence behind it yet.
         const first = firstDefByNodeId.get(def.nodeId);
         if (first === undefined) {
             firstDefByNodeId.set(def.nodeId, def);
         }
-        else if (first.typeParameters === undefined && def.typeParameters !== undefined) {
-            first.typeParameters = def.typeParameters;
-        }
-        else if (def.typeParameters === undefined && first.typeParameters !== undefined) {
-            def.typeParameters = first.typeParameters;
+        else {
+            if (first.typeParameters === undefined && def.typeParameters !== undefined) {
+                first.typeParameters = def.typeParameters;
+            }
+            else if (def.typeParameters === undefined && first.typeParameters !== undefined) {
+                def.typeParameters = first.typeParameters;
+            }
+            if (first.returnType === undefined && def.returnType !== undefined) {
+                first.returnType = def.returnType;
+            }
+            else if (def.returnType === undefined && first.returnType !== undefined) {
+                def.returnType = first.returnType;
+            }
         }
         // Find the innermost scope that contains the declaration's anchor range.
         const innermostId = positionIndex.atPosition(filePath, anchor.range.startLine, anchor.range.startCol);
@@ -1343,6 +1376,19 @@ function pass6CollectCallableFlows(matches, positionIndex, filePath, out) {
         }
     }
 }
+// ─── Pass 7: collect call-result assignment identity ──────────────────────
+function pass7CollectCallResultAssignments(matches, positionIndex, filePath, out) {
+    for (const match of matches) {
+        const call = match['@call-result-assignment.call'];
+        const lhs = match['@call-result-assignment.lhs'];
+        if (call === undefined || lhs === undefined || !nonEmpty(lhs.text))
+            continue;
+        const inScope = positionIndex.atPosition(filePath, call.range.startLine, call.range.startCol);
+        if (inScope === undefined)
+            continue;
+        out.push({ callSite: call.range, inScope, lhs: lhs.text });
+    }
+}
 function callableFlowKind(match) {
     return CALLABLE_FLOW_KINDS.find((kind) => match[`@callable-flow.${kind}`] !== undefined);
 }

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -612,6 +612,7 @@ export interface ScopeResolver {
      */
     readonly populateWorkspaceOwners?: (parsedFiles: readonly ParsedFile[], ctx: {
         readonly fileContents: ReadonlyMap<string, string>;
+        readonly resolutionConfig?: unknown;
     }) => void;
     /**
      * Optional workspace-wide enrichment of extracted reference sites. Runs
@@ -862,6 +863,10 @@ export interface ScopeResolver {
      * regression).
      */
     readonly freeCallsRequireInstanceOwnership?: boolean;
+    /** Whether an unqualified call inside a type may dispatch to an inherited
+     * instance method. Languages such as Swift allow implicit-self lookup,
+     * while Python/JavaScript/PHP require an explicit receiver. */
+    readonly implicitThisWalksMro?: boolean;
     /**
      * When true, a constructor-form call `Type(...)` links to the Class def
      * itself rather than its explicit Constructor def. Default

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

@@ -82,6 +82,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  contains the method's owner. See
      *  `ScopeResolver.freeCallsRequireInstanceOwnership`. */
     readonly freeCallsRequireInstanceOwnership?: boolean;
+    readonly implicitThisWalksMro?: boolean;
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
     /** Call sites owned by a later precise pass (for example callable-value-flow). */
     readonly skipSites?: ReadonlySet<string>;
@@ -164,11 +165,14 @@ export declare function pickUniqueGlobalClass(name: string, index: ReadonlyMap<s
  *  pick a method member by name with overload narrowing on arity +
  *  argument types. Returns undefined if there's no enclosing class,
  *  no matching method, OR narrowing leaves multiple compatible
- *  candidates — in the multi-candidate case, picking
- *  `candidates[0]` would emit a high-confidence CALLS edge whose
- *  target depends on registration order rather than a defensible
- *  resolution. Mirrors `pickUniqueGlobalCallable`'s uniqueness check
- *  in the same file (Codex PR #1497 review, finding 2).
+ *  candidates — except when those survivors are a protocol/interface
+ *  requirement plus exactly one extension witness, in which case the
+ *  witness (the default body) is returned. An inherited class, struct,
+ *  or enum member still wins over a protocol-extension default.
+ *  Picking `candidates[0]` would emit a high-confidence CALLS edge
+ *  whose target depends on registration order rather than a
+ *  defensible resolution. Mirrors `pickUniqueGlobalCallable`'s
+ *  uniqueness check in the same file (Codex PR #1497 review, finding 2).
  *
  *  Exported for unit testing — language-agnostic logic, exercised
  *  via synthetic stubs in `pick-implicit-this-overload.test.ts`. The
@@ -183,4 +187,5 @@ export declare function pickImplicitThisOverload(site: {
     readonly conversionRankFn?: ConversionRankFn;
     readonly conversionOnlyArgTypePrefixes?: readonly string[];
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
+    readonly implicitThisWalksMro?: boolean;
 }): SymbolDefinition | undefined;

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

@@ -171,6 +171,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     conversionRankFn: options.conversionRankFn,
                     conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                     constraintCompatibility: options.constraintCompatibility,
+                    implicitThisWalksMro: options.implicitThisWalksMro,
                 });
                 fnDefFromImplicitThis = fnDef !== undefined;
             }
@@ -925,11 +926,14 @@ export function pickUniqueGlobalClass(name, index) {
  *  pick a method member by name with overload narrowing on arity +
  *  argument types. Returns undefined if there's no enclosing class,
  *  no matching method, OR narrowing leaves multiple compatible
- *  candidates — in the multi-candidate case, picking
- *  `candidates[0]` would emit a high-confidence CALLS edge whose
- *  target depends on registration order rather than a defensible
- *  resolution. Mirrors `pickUniqueGlobalCallable`'s uniqueness check
- *  in the same file (Codex PR #1497 review, finding 2).
+ *  candidates — except when those survivors are a protocol/interface
+ *  requirement plus exactly one extension witness, in which case the
+ *  witness (the default body) is returned. An inherited class, struct,
+ *  or enum member still wins over a protocol-extension default.
+ *  Picking `candidates[0]` would emit a high-confidence CALLS edge
+ *  whose target depends on registration order rather than a
+ *  defensible resolution. Mirrors `pickUniqueGlobalCallable`'s
+ *  uniqueness check in the same file (Codex PR #1497 review, finding 2).
  *
  *  Exported for unit testing — language-agnostic logic, exercised
  *  via synthetic stubs in `pick-implicit-this-overload.test.ts`. The
@@ -954,24 +958,93 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     const classDefId = workspaceIndex.classScopeIdToDefId.get(classScopeId);
     if (classDefId === undefined)
         return undefined;
-    const overloads = model.methods.lookupAllByOwner(classDefId, site.name);
+    // Bare calls in an instance method use the same implicit receiver as
+    // `self.member()`. Prefer declarations on the enclosing type; when the
+    // language opts into MRO implicit-this, walk inherited owners
+    // nearest-first and arity-narrow per owner. Compatible-but-ambiguous
+    // on a nearer ancestor fail-closes — do not fall through to a farther
+    // override. Falling through to the global name lookup makes inherited
+    // defaults depend on file order.
+    const own = model.methods.lookupAllByOwner(classDefId, site.name);
+    const ownPicked = pickUniqueImplicitThisCandidate(own, site, hookCtx, workspaceIndex);
+    if (ownPicked !== undefined)
+        return ownPicked;
+    if (own.length > 0) {
+        const ownCompatible = narrowOverloadCandidates(own, site.arity, site.argumentTypes, {
+            argumentTypeClasses: site.argumentTypeClasses,
+            conversionRankFn: hookCtx?.conversionRankFn,
+            conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
+            constraintCompatibility: hookCtx?.constraintCompatibility,
+        });
+        if (ownCompatible.length > 0)
+            return undefined;
+    }
+    if (hookCtx?.implicitThisWalksMro !== true)
+        return undefined;
+    for (const ownerId of scopes.methodDispatch?.mroFor(classDefId) ?? []) {
+        const inherited = model.methods.lookupAllByOwner(ownerId, site.name);
+        const inheritedPicked = pickUniqueImplicitThisCandidate(inherited, site, hookCtx, workspaceIndex);
+        if (inheritedPicked !== undefined)
+            return inheritedPicked;
+        if (inherited.length > 0) {
+            const inheritedCompatible = narrowOverloadCandidates(inherited, site.arity, site.argumentTypes, {
+                argumentTypeClasses: site.argumentTypeClasses,
+                conversionRankFn: hookCtx?.conversionRankFn,
+                conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
+                constraintCompatibility: hookCtx?.constraintCompatibility,
+            });
+            if (inheritedCompatible.length > 0)
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function pickUniqueImplicitThisCandidate(overloads, site, hookCtx, workspaceIndex) {
     if (overloads.length === 0)
         return undefined;
-    if (overloads.length === 1)
-        return overloads[0];
-    // Narrow on arity + argument types. Require a UNIQUE survivor —
-    // ambiguous narrowing (multiple compatible candidates with no
-    // disambiguating signal) leaves the call unresolved rather than
-    // routing to an arbitrary first overload by registration order.
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
         conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });
-    if (candidates.length !== 1)
+    if (candidates.length === 0)
         return undefined;
-    return candidates[0];
+    if (candidates.length === 1)
+        return candidates[0];
+    const witnesses = preferExtensionWitnesses(candidates, workspaceIndex);
+    return witnesses.length === 1 ? witnesses[0] : undefined;
+}
+function preferExtensionWitnesses(candidates, workspaceIndex) {
+    const onOwnerType = [];
+    const extensionWitnesses = [];
+    for (const def of candidates) {
+        const ownerId = def.ownerId;
+        if (ownerId === undefined) {
+            extensionWitnesses.push(def);
+            continue;
+        }
+        const ownerScope = workspaceIndex.classScopeByDefId?.get(ownerId);
+        const livesOnOwner = ownerScope?.ownedDefs.some((owned) => owned.nodeId === def.nodeId) === true;
+        if (livesOnOwner)
+            onOwnerType.push(def);
+        else
+            extensionWitnesses.push(def);
+    }
+    if (extensionWitnesses.length === 0 || onOwnerType.length === 0)
+        return candidates;
+    const concrete = onOwnerType.filter((def) => !isProtocolLikeOwner(def.ownerId, workspaceIndex));
+    if (concrete.length > 0)
+        return concrete;
+    return extensionWitnesses;
+}
+function isProtocolLikeOwner(ownerId, workspaceIndex) {
+    if (ownerId === undefined)
+        return false;
+    const ownerScope = workspaceIndex.classScopeByDefId?.get(ownerId);
+    if (ownerScope === undefined)
+        return false;
+    return ownerScope.ownedDefs.some((owned) => owned.nodeId === ownerId && (owned.type === 'Protocol' || owned.type === 'Interface'));
 }
 /**
  * True when `name` is bound somewhere along the TRUE lexical scope

package/dist/core/ingestion/scope-resolution/pipeline/run.d.ts

@@ -25,14 +25,25 @@
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { MutableSemanticModel } from '../../model/semantic-model.js';
+import { finalizeScopeModel } from '../../finalize-orchestrator.js';
 import { type ResolveStats } from '../../resolve-references.js';
 import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { type FunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
 import type { FunctionSummary } from '../../taint/summary-model.js';
 import type { CallSummary } from '../../taint/call-summary-model.js';
 import { type PropertyNameIndex } from '../passes/unique-name-properties.js';
+import { type CalleeIdAccumulator } from '../graph-bridge/callee-id-sink.js';
 import type { ScopeResolver, UndecidedSatisfaction } from '../contract/scope-resolver.js';
+import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import type { ResolutionOutcome, ResolutionOutcomeRecorder } from '../resolution-outcome.js';
+/**
+ * Join extraction-time assignment identity to Phase-4's exact resolved callee.
+ * Ambiguous dispatch and missing return annotations deliberately produce no
+ * binding. Extraction emits these facts only for untyped declarations, so an
+ * existing entry here is necessarily inference/mirroring and may be corrected;
+ * explicit annotations never enter this join.
+ */
+export declare function applyPreciseCallResultBindings(parsedFiles: readonly ParsedFile[], indexes: ReturnType<typeof finalizeScopeModel>, workspaceIndex: ReturnType<typeof buildWorkspaceResolutionIndex>, calleeIds: CalleeIdAccumulator, nodeLookup: ReturnType<typeof buildGraphNodeLookup>): number;
 export type ScopeResolutionSubPhase = 'extracting' | 'analyzing types' | 'resolving references' | 'linking symbols';
 interface RunScopeResolutionInput {
     readonly graph: KnowledgeGraph;

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -47,7 +47,7 @@ import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js'
 import { buildPropertyNameIndex, emitUniqueNamePropertyAccesses, } from '../passes/unique-name-properties.js';
 import { emitReturnShapeMemberAccesses } from '../passes/return-shape-members.js';
 import { emitImportedValueReferences } from '../passes/imported-value-refs.js';
-import { createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
+import { calleeIdPosKey, createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
 import { callableFlowSiteKey, collectDeferredIndirectCollection, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
 import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
@@ -55,6 +55,56 @@ import { heritageTypeArgumentsKey, } from '../utils/generic-instantiation.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
 import { parseTruthyEnv } from '../../utils/env.js';
+/**
+ * Join extraction-time assignment identity to Phase-4's exact resolved callee.
+ * Ambiguous dispatch and missing return annotations deliberately produce no
+ * binding. Extraction emits these facts only for untyped declarations, so an
+ * existing entry here is necessarily inference/mirroring and may be corrected;
+ * explicit annotations never enter this join.
+ */
+export function applyPreciseCallResultBindings(parsedFiles, indexes, workspaceIndex, calleeIds, nodeLookup) {
+    let updated = 0;
+    const returnTypeByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            const returnType = workspaceIndex.declaredReturnTypeByCallableId.get(def.nodeId);
+            if (returnType === undefined)
+                continue;
+            const graphId = resolveDefGraphId(def.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                returnTypeByGraphId.set(graphId, returnType);
+        }
+    }
+    for (const parsed of parsedFiles) {
+        const resolvedByPosition = calleeIds.get(parsed.filePath);
+        if (resolvedByPosition === undefined)
+            continue;
+        for (const assignment of parsed.callResultAssignmentSites ?? []) {
+            const targets = resolvedByPosition.get(calleeIdPosKey(assignment.callSite.startLine, assignment.callSite.startCol));
+            if (targets === undefined || targets.size !== 1)
+                continue;
+            const targetId = targets.values().next().value;
+            if (targetId === undefined)
+                continue;
+            const returnType = returnTypeByGraphId.get(targetId);
+            if (returnType === undefined)
+                continue;
+            const scope = indexes.scopeTree.getScope(assignment.inScope);
+            if (scope === undefined)
+                continue;
+            scope.typeBindings.set(assignment.lhs, {
+                rawName: returnType.rawName,
+                ...(returnType.declaredSpelling !== undefined
+                    ? { declaredSpelling: returnType.declaredSpelling }
+                    : {}),
+                declaredAtScope: assignment.inScope,
+                source: 'assignment-inferred',
+            });
+            updated++;
+        }
+    }
+    return updated;
+}
 import { isValueDefinitionLabel } from '../../utils/ast-helpers.js';
 import { TransitionalScopeTree } from '../../../../storage/scope-index-store.js';
 import { forceGc } from '../../../../storage/parsedfile-store.js';
@@ -235,7 +285,6 @@ export function runScopeResolution(input, provider) {
     const undecidedSatisfaction = [];
     const recordResolutionOutcome = (outcome) => {
         resolutionOutcomes.push(outcome);
-        input.recordResolutionOutcome?.(outcome);
     };
     const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
     const tStart = PROF ? process.hrtime.bigint() : 0n;
@@ -311,7 +360,10 @@ export function runScopeResolution(input, provider) {
         logger.warn(`[scope-resolution prof] pre-extracted hits: ${preExtractedHits}/${files.length}`);
     }
     logHeapProbe('sr-extract-end', `lang=${provider.language} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits} skipped=${filesSkipped}`);
-    provider.populateWorkspaceOwners?.(parsedFiles, { fileContents: getFileContents() });
+    provider.populateWorkspaceOwners?.(parsedFiles, {
+        fileContents: getFileContents(),
+        resolutionConfig: input.resolutionConfig,
+    });
     provider.populateWorkspaceReferences?.(parsedFiles, {
         fileContents: getFileContents(),
         treeCache,
@@ -481,7 +533,9 @@ export function runScopeResolution(input, provider) {
     // views that delegate to it (out-of-core scope index) — the index pins no Scope objects, so the
     // disk seal can reclaim them. Byte-identical: the view returns the same Scope
     // the resident tree holds (or a value-identical revived one in disk mode).
-    const workspaceIndex = buildWorkspaceResolutionIndex(parsedFiles, indexes.scopeTree);
+    const workspaceIndex = buildWorkspaceResolutionIndex(parsedFiles, indexes.scopeTree, {
+        stripTypePreservingDecoration: provider.stripTypePreservingDecoration,
+    });
     logHeapProbe('sr-post-workspaceIndex', `lang=${provider.language}`);
     // Cross-file implicit-namespace visibility (C#). Must run before
     // propagateImportedReturnTypes so the latter pass sees siblings'
@@ -637,6 +691,12 @@ export function runScopeResolution(input, provider) {
     const deferredIndirectCollection = collectDeferredIndirectCollection(emitParsedFiles, indexes);
     const deferredIndirectSites = deferredIndirectCollection.sites;
     const callableArgumentSites = new Set();
+    const callResultAssignmentSites = new Set();
+    for (const parsed of emitParsedFiles) {
+        for (const site of parsed.callResultAssignmentSites ?? []) {
+            callResultAssignmentSites.add(callableFlowSiteKey(parsed.filePath, site.callSite));
+        }
+    }
     if (input.pdg !== true && deferredIndirectSites.size > 0) {
         for (const parsed of emitParsedFiles) {
             for (const site of parsed.callableFlowSites ?? []) {
@@ -650,10 +710,13 @@ export function runScopeResolution(input, provider) {
     // for PDG OR when indirect-call facts need direct targets for actual→formal
     // propagation. Populated below at every CALLS emit path before dedup; the CFG
     // join still consumes it only inside the `input.pdg` block.
-    const calleeIdAccumulator = input.pdg === true || deferredIndirectSites.size > 0
+    const calleeIdAccumulator = input.pdg === true || deferredIndirectSites.size > 0 || callResultAssignmentSites.size > 0
         ? createCalleeIdAccumulator(input.pdg === true
             ? undefined
-            : (filePath, line, col) => callableArgumentSites.has(`${filePath}:${line}:${col}`))
+            : (filePath, line, col) => {
+                const key = `${filePath}:${line}:${col}`;
+                return callableArgumentSites.has(key) || callResultAssignmentSites.has(key);
+            })
         : undefined;
     const receiverBound = callableFlowOnly
         ? {
@@ -673,7 +736,7 @@ export function runScopeResolution(input, provider) {
             // (#2912). Empty under `callableFlowOnly`, which emits no dispatch.
             heritageTypeArguments,
         });
-    const receiverExtras = receiverBound.emitted;
+    let receiverExtras = receiverBound.emitted;
     if (receiverBound.dispatchFanoutSkipped > 0) {
         // Never drop dispatch coverage silently (#2829) — same contract as the
         // property-dispatch cap below. An interface member over the cap loses real
@@ -704,6 +767,7 @@ export function runScopeResolution(input, provider) {
             isFileLocalDef: provider.isFileLocalDef,
             isBuiltInName: provider.languageProvider.isBuiltInName,
             freeCallsRequireInstanceOwnership: provider.freeCallsRequireInstanceOwnership === true,
+            implicitThisWalksMro: provider.implicitThisWalksMro === true,
             isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
             resolveAdlCandidates: provider.resolveAdlCandidates,
             resolveQualifiedFreeCall: provider.resolveQualifiedFreeCall,
@@ -714,6 +778,42 @@ export function runScopeResolution(input, provider) {
             calleeIdSink: calleeIdAccumulator,
             skipSites: deferredIndirectSites,
         });
+    const replayedCallResultBindings = callableFlowOnly || calleeIdAccumulator === undefined
+        ? 0
+        : applyPreciseCallResultBindings(emitParsedFiles, indexes, workspaceIndex, calleeIdAccumulator, postHeritageNodeLookup);
+    if (replayedCallResultBindings > 0) {
+        const handledBeforeReplay = new Set(handledSites);
+        const replayedReceiverBound = emitReceiverBoundCalls(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
+            calleeIdSink: calleeIdAccumulator,
+            isBuiltInName: provider.languageProvider.isBuiltInName,
+            heritageTypeArguments,
+        });
+        receiverExtras += replayedReceiverBound.emitted;
+        if (replayedReceiverBound.dispatchFanoutSkipped > 0) {
+            logger.warn({
+                lang: provider.language,
+                dispatchFanoutSkipped: replayedReceiverBound.dispatchFanoutSkipped,
+                dispatchFanoutSkippedNames: replayedReceiverBound.dispatchFanoutSkippedNames,
+                fanoutCap: MAX_INTERFACE_DISPATCH_FANOUT,
+                replay: true,
+            }, 'interface-dispatch: members over the fan-out cap dropped implementors (their CALLS edges were not emitted)');
+        }
+        const resolvedOnReplay = new Set();
+        for (const key of handledSites) {
+            if (!handledBeforeReplay.has(key))
+                resolvedOnReplay.add(key);
+        }
+        if (resolvedOnReplay.size > 0) {
+            for (let i = resolutionOutcomes.length - 1; i >= 0; i--) {
+                const outcome = resolutionOutcomes[i];
+                if (outcome.kind === 'suppressed' &&
+                    outcome.reason === 'receiver-unresolved' &&
+                    resolvedOnReplay.has(callableFlowSiteKey(outcome.filePath, outcome.range))) {
+                    resolutionOutcomes.splice(i, 1);
+                }
+            }
+        }
+    }
     const referenceSkipSites = new Set(handledSites);
     for (const key of deferredIndirectSites)
         referenceSkipSites.add(key);
@@ -1176,6 +1276,8 @@ export function runScopeResolution(input, provider) {
             ` (${parsedFiles.length} files)`);
     }
     logHeapProbe('sr-end', `lang=${provider.language} parsedFiles=${parsedFiles.length}`);
+    for (const outcome of resolutionOutcomes)
+        input.recordResolutionOutcome?.(outcome);
     return {
         filesProcessed: parsedFiles.length,
         filesSkipped,

package/dist/core/ingestion/scope-resolution/workspace-index-types.d.ts

@@ -12,7 +12,7 @@
  * See `./workspace-index.ts` for what belongs in this index versus what belongs
  * on `SemanticModel`, and for the builder itself.
  */
-import type { Scope, ScopeId, SymbolDefinition } from '../../../_shared/index.js';
+import type { Scope, ScopeId, SymbolDefinition, TypeRef } from '../../../_shared/index.js';
 export interface WorkspaceResolutionIndex {
     /** Class def `nodeId` → that class's `Scope`. */
     readonly classScopeByDefId: ReadonlyMap<string, Scope>;
@@ -31,4 +31,9 @@ export interface WorkspaceResolutionIndex {
      *  killer). "First module-local callable in `moduleScopeByFile` order" is the
      *  exact semantics the old scan returned, so it is byte-identical. */
     readonly exportedCallableByName: ReadonlyMap<string, SymbolDefinition>;
+    /** Exact callable def `nodeId` → its declared return type binding.
+     * Built from definitions owned by each callable's Function scope, so methods
+     * declared in extension/partial scopes remain addressable even when those
+     * scopes deliberately own no separate class-like definition. */
+    readonly declaredReturnTypeByCallableId: ReadonlyMap<string, TypeRef>;
 }

package/dist/core/ingestion/scope-resolution/workspace-index.d.ts

@@ -52,4 +52,6 @@ export type { WorkspaceResolutionIndex } from './workspace-index-types.js';
  * reclaim them. Without it (unit tests), the legacy direct `Map<K, Scope>` form
  * is returned unchanged.
  */
-export declare function buildWorkspaceResolutionIndex(parsedFiles: readonly ParsedFile[], scopeTree?: ScopeTree): WorkspaceResolutionIndex;
+export declare function buildWorkspaceResolutionIndex(parsedFiles: readonly ParsedFile[], scopeTree?: ScopeTree, options?: {
+    readonly stripTypePreservingDecoration?: (typeName: string) => string | undefined;
+}): WorkspaceResolutionIndex;

package/dist/core/ingestion/scope-resolution/workspace-index.js

@@ -97,11 +97,12 @@ class ScopeByKeyView {
  * reclaim them. Without it (unit tests), the legacy direct `Map<K, Scope>` form
  * is returned unchanged.
  */
-export function buildWorkspaceResolutionIndex(parsedFiles, scopeTree) {
+export function buildWorkspaceResolutionIndex(parsedFiles, scopeTree, options) {
     const classScopeIdByDefId = new Map();
     const classScopeIdToDefId = new Map();
     const moduleScopeIdByFile = new Map();
     const exportedCallableByName = new Map();
+    const declaredReturnTypeByCallableId = new Map();
     // Back-compat (no scopeTree): keep the direct Scope-object maps.
     const classScopeByDefIdDirect = scopeTree === undefined ? new Map() : undefined;
     const moduleScopeByFileDirect = scopeTree === undefined ? new Map() : undefined;
@@ -128,6 +129,24 @@ export function buildWorkspaceResolutionIndex(parsedFiles, scopeTree) {
             }
         }
         for (const scope of parsed.scopes) {
+            if (scope.kind === 'Function' && scope.parent !== null) {
+                for (const def of scope.ownedDefs) {
+                    if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
+                        continue;
+                    }
+                    if (def.returnType !== undefined) {
+                        const stripped = options?.stripTypePreservingDecoration?.(def.returnType);
+                        const rawName = stripped ?? def.returnType;
+                        declaredReturnTypeByCallableId.set(def.nodeId, {
+                            rawName,
+                            ...(rawName !== def.returnType ? { declaredSpelling: def.returnType } : {}),
+                            declaredAtScope: scope.id,
+                            source: 'return-annotation',
+                        });
+                        continue;
+                    }
+                }
+            }
             if (scope.kind !== 'Class')
                 continue;
             const cd = scope.ownedDefs.find((d) => isClassLike(d.type));
@@ -144,5 +163,11 @@ export function buildWorkspaceResolutionIndex(parsedFiles, scopeTree) {
     const moduleScopeByFile = scopeTree === undefined
         ? moduleScopeByFileDirect
         : new ScopeByKeyView(moduleScopeIdByFile, scopeTree);
-    return { classScopeByDefId, classScopeIdToDefId, moduleScopeByFile, exportedCallableByName };
+    return {
+        classScopeByDefId,
+        classScopeIdToDefId,
+        moduleScopeByFile,
+        exportedCallableByName,
+        declaredReturnTypeByCallableId,
+    };
 }

package/dist/storage/parse-cache.js

@@ -764,7 +764,9 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // v101 (#3294 review): Rust bare-keyword glob imports retain crate/self/super
 // instead of an empty target path; restricted pub(...) imports are no longer
 // captured as unrestricted reexports. Re-extract both facts on warm indexes.
-const SCHEMA_BUMP = 101;
+// v102: ParsedFile gained callResultAssignmentSites; old durable shards do
+// not carry the exact assignment identity required by return-type replay.
+const SCHEMA_BUMP = 102;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/dist/storage/parsedfile-store.js

@@ -301,21 +301,27 @@ export const loadParsedFilesForPaths = async (storagePath, wantPaths) => {
                     rejectedFiles++;
                     continue;
                 }
+                const assignments = sanitizeCallResultAssignmentSites(pf.callResultAssignmentSites);
+                if (assignments === undefined) {
+                    rejectedFiles++;
+                    continue;
+                }
                 const chains = sanitizeReceiverChains(pf.referenceSites);
                 if (chains === undefined) {
                     rejectedFiles++;
                     continue;
                 }
-                if (flow.dropped === 0 && chains.dropped === 0) {
+                if (flow.dropped === 0 && assignments.dropped === 0 && chains.dropped === 0) {
                     out.set(pf.filePath, pf);
                 }
                 else {
-                    droppedSites += flow.dropped;
+                    droppedSites += flow.dropped + assignments.dropped;
                     droppedChains += chains.dropped;
                     filesWithDroppedSites++;
                     out.set(pf.filePath, {
                         ...pf,
                         ...(flow.dropped === 0 ? {} : { callableFlowSites: flow.sites }),
+                        ...(assignments.dropped === 0 ? {} : { callResultAssignmentSites: assignments.sites }),
                         ...(chains.dropped === 0 ? {} : { referenceSites: chains.sites }),
                     });
                 }
@@ -342,6 +348,17 @@ function sanitizeCallableFlowSites(value) {
     const sites = bounded.filter(isValidCallableFlowSite);
     return { sites, dropped: value.length - sites.length };
 }
+function sanitizeCallResultAssignmentSites(value) {
+    if (value === undefined)
+        return { sites: undefined, dropped: 0 };
+    if (!Array.isArray(value))
+        return undefined;
+    const bounded = value.length > MAX_CALLABLE_FLOW_SITES_PER_FILE
+        ? value.slice(0, MAX_CALLABLE_FLOW_SITES_PER_FILE)
+        : value;
+    const sites = bounded.filter(isValidCallResultAssignmentSite);
+    return { sites, dropped: value.length - sites.length };
+}
 /**
  * Untrusted-boundary handling for the compact `receiverChain` on a reference site.
  *
@@ -434,6 +451,12 @@ function isValidCallableFlowSite(value) {
             return false;
     }
 }
+function isValidCallResultAssignmentSite(value) {
+    return (isRecord(value) &&
+        isValidRange(value.callSite) &&
+        isBoundedString(value.inScope) &&
+        isBoundedString(value.lhs));
+}
 function isValidOperand(value) {
     if (!isRecord(value))
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.18",
+  "version": "1.6.13-rc.19",
   "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",