gitnexus 1.6.5-rc.42 → 1.6.5-rc.44

package/dist/core/ingestion/languages/c-cpp.js

@@ -270,12 +270,20 @@ const cCppExtractFunctionName = (node) => {
     }
     return { funcName, label };
 };
-/** Check if a C/C++ function_definition is inside a class or struct body.
+/** Check if a C/C++ function_definition is inside a class or struct body
+ *  (and NOT a friend declaration).
  *  Used by cppLabelOverride to skip duplicate function captures
- *  that are already covered by definition.method queries. */
+ *  that are already covered by definition.method queries.
+ *  Friend functions are free functions defined inside class bodies —
+ *  they must NOT be skipped (ISO C++ hidden-friend idiom). */
 function isCppInsideClassOrStruct(functionNode) {
     let ancestor = functionNode?.parent ?? null;
     while (ancestor) {
+        // Friend declarations: the function_definition is wrapped in
+        // `friend_declaration` → `field_declaration_list` → class_specifier.
+        // These are free functions, not methods — don't skip them.
+        if (ancestor.type === 'friend_declaration')
+            return false;
         if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
             return true;
         ancestor = ancestor.parent;

package/dist/core/ingestion/languages/cpp/adl.d.ts

@@ -21,14 +21,28 @@
  *   - `audit::Event& r`, `audit::Event&& rr`
  *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
  *
- * Function-pointer arguments and the rest of the full closure are still
- * deliberately excluded. V2 additionally walks class ancestors (via MRO),
- * so base-class enclosing namespaces also contribute associated namespaces.
+ * V2 additionally walks class ancestors (via MRO), so base-class enclosing
+ * namespaces also contribute associated namespaces.
  *
- * The current implementation also short-circuits to ADL only when ordinary lookup is empty
- * (`findCallableBindingInScope` returned undefined). ISO C++ would
- * normally merge ADL candidates with ordinary-lookup candidates and
- * run overload resolution over the union; V1 defers that merge to V2.
+ * **GitNexus approximation (not strict ISO C++ ADL):** passing a qualified
+ * function reference like `utils::worker` contributes `utils` to the associated
+ * set, enabling resolution of unqualified calls like `with_callback(utils::worker)`
+ * to `utils::with_callback`. Under ISO C++ `[basic.lookup.argdep]`, associated
+ * entities for function-type arguments come from the **parameter types and return
+ * type** of each function in the overload set — NOT the function's enclosing
+ * namespace. For `void worker()`, the standard-compliant associated set is empty.
+ * GitNexus instead contributes the enclosing namespace of any Function/Method
+ * def whose simple name matches, because it enables the dominant real-world ADL
+ * pattern at reasonable precision cost.
+ *
+ * For qualified refs (e.g. `utils::worker`) the namespace is confirmed via a
+ * workspace lookup (only contributed when a Function/Method named `worker` exists
+ * in `utils`). For unqualified refs the workspace is searched for any Function
+ * def with that simple name. Locally-declared function-pointer variables
+ * (e.g. `void (*g)()`) and function parameters are excluded from this path.
+ *
+ * ADL candidates are merged with ordinary unqualified-lookup candidates
+ * in the free-call fallback before overload narrowing.
  *
  * ## Parenthesized-name suppression
  *
@@ -59,6 +73,7 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
  * Per-argument shape information collected at capture time. ADL fires for
  * arguments where `simpleClassName !== ''`, including class pointers and
  * references whose declarator chain resolves to a named class type.
+ * Free-function reference arguments use `functionRefText`.
  */
 export interface CppAdlArgInfo {
     /** Simple class-like type name (last segment of qualified name); empty
@@ -76,13 +91,16 @@ export interface CppAdlArgInfo {
     /** Enclosing namespaces extracted from explicit type template arguments,
      *  recursively bounded. */
     readonly templateArgNamespaces: readonly string[];
+    /** When set, the arg is a potential free-function reference (not a locally-
+     *  declared function-pointer variable or function parameter). Contains the
+     *  identifier text as written in source (e.g. `"utils::worker"` or
+     *  `"worker"`). GitNexus approximation: the function's enclosing namespace
+     *  is contributed to the ADL associated set. For qualified refs a workspace
+     *  lookup confirms a Function/Method with that simple name exists in the
+     *  namespace before contributing; for unqualified refs every namespace
+     *  containing a matching Function/Method def is contributed. */
+    readonly functionRefText?: string;
 }
-/** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
- *  candidates that share normalized parameter types — the caller MUST
- *  suppress (zero edges) rather than pick arbitrarily. Mirrors the
- *  OVERLOAD_AMBIGUOUS contract from the receiver-bound path. */
-export declare const ADL_AMBIGUOUS: unique symbol;
-export type AdlResult = SymbolDefinition | typeof ADL_AMBIGUOUS | undefined;
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
 export declare function markCppAdlSiteArgs(filePath: string, line: number, col: number, args: readonly CppAdlArgInfo[]): void;
@@ -104,13 +122,10 @@ export declare function clearCppAdlState(): void;
  */
 export declare function populateCppAssociatedNamespaces(parsed: ParsedFile): void;
 /**
- * V1 ADL candidate picker. Returns:
- *   - `SymbolDefinition` — exactly one ADL candidate (or unique survivor
- *     after narrowing); caller emits the CALLS edge.
- *   - `ADL_AMBIGUOUS` — multiple candidates with no disambiguator;
- *     caller MUST suppress (zero edges).
- *   - `undefined` — no ADL candidates; caller falls through to ordinary
- *     `pickUniqueGlobalCallable` fallback.
+ * ADL candidate collector. Returns:
+ *   - `readonly SymbolDefinition[]` — ADL candidates to merge with
+ *     ordinary unqualified lookup candidates.
+ *   - `undefined` — no ADL candidates.
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
@@ -119,10 +134,8 @@ export declare function populateCppAssociatedNamespaces(parsed: ParsedFile): voi
  */
 export declare function pickCppAdlCandidates(site: {
     readonly name: string;
-    readonly arity?: number;
-    readonly argumentTypes?: readonly string[];
     readonly atRange: {
         startLine: number;
         startCol: number;
     };
-}, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]): AdlResult;
+}, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]): readonly SymbolDefinition[] | undefined;

package/dist/core/ingestion/languages/cpp/adl.js

@@ -21,14 +21,28 @@
  *   - `audit::Event& r`, `audit::Event&& rr`
  *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
  *
- * Function-pointer arguments and the rest of the full closure are still
- * deliberately excluded. V2 additionally walks class ancestors (via MRO),
- * so base-class enclosing namespaces also contribute associated namespaces.
+ * V2 additionally walks class ancestors (via MRO), so base-class enclosing
+ * namespaces also contribute associated namespaces.
  *
- * The current implementation also short-circuits to ADL only when ordinary lookup is empty
- * (`findCallableBindingInScope` returned undefined). ISO C++ would
- * normally merge ADL candidates with ordinary-lookup candidates and
- * run overload resolution over the union; V1 defers that merge to V2.
+ * **GitNexus approximation (not strict ISO C++ ADL):** passing a qualified
+ * function reference like `utils::worker` contributes `utils` to the associated
+ * set, enabling resolution of unqualified calls like `with_callback(utils::worker)`
+ * to `utils::with_callback`. Under ISO C++ `[basic.lookup.argdep]`, associated
+ * entities for function-type arguments come from the **parameter types and return
+ * type** of each function in the overload set — NOT the function's enclosing
+ * namespace. For `void worker()`, the standard-compliant associated set is empty.
+ * GitNexus instead contributes the enclosing namespace of any Function/Method
+ * def whose simple name matches, because it enables the dominant real-world ADL
+ * pattern at reasonable precision cost.
+ *
+ * For qualified refs (e.g. `utils::worker`) the namespace is confirmed via a
+ * workspace lookup (only contributed when a Function/Method named `worker` exists
+ * in `utils`). For unqualified refs the workspace is searched for any Function
+ * def with that simple name. Locally-declared function-pointer variables
+ * (e.g. `void (*g)()`) and function parameters are excluded from this path.
+ *
+ * ADL candidates are merged with ordinary unqualified-lookup candidates
+ * in the free-call fallback before overload narrowing.
  *
  * ## Parenthesized-name suppression
  *
@@ -53,15 +67,10 @@
  * but logically share the same namespace. ADL must consider candidates
  * declared in either file.
  */
-import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
+import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 const argInfoBySite = new Map();
 const noAdlSites = new Set();
 const classToNamespaceQualifiedName = new Map();
-/** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
- *  candidates that share normalized parameter types — the caller MUST
- *  suppress (zero edges) rather than pick arbitrarily. Mirrors the
- *  OVERLOAD_AMBIGUOUS contract from the receiver-bound path. */
-export const ADL_AMBIGUOUS = Symbol('ADL_AMBIGUOUS');
 function siteKey(filePath, line, col) {
     return `${filePath}:${line}:${col}`;
 }
@@ -108,15 +117,27 @@ export function populateCppAssociatedNamespaces(parsed) {
             classToNamespaceQualifiedName.set(def.nodeId, nsQName);
         }
     }
+    // Enum defs live in Namespace scopes directly (not inside Class scopes).
+    // Map each Enum def to its enclosing namespace so ADL on enum-typed
+    // arguments contributes the correct associated namespace.
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace')
+            continue;
+        const nsQName = computeNamespaceQName(scope, scopesById);
+        if (nsQName === '')
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (def.type !== 'Enum')
+                continue;
+            classToNamespaceQualifiedName.set(def.nodeId, nsQName);
+        }
+    }
 }
 /**
- * V1 ADL candidate picker. Returns:
- *   - `SymbolDefinition` — exactly one ADL candidate (or unique survivor
- *     after narrowing); caller emits the CALLS edge.
- *   - `ADL_AMBIGUOUS` — multiple candidates with no disambiguator;
- *     caller MUST suppress (zero edges).
- *   - `undefined` — no ADL candidates; caller falls through to ordinary
- *     `pickUniqueGlobalCallable` fallback.
+ * ADL candidate collector. Returns:
+ *   - `readonly SymbolDefinition[]` — ADL candidates to merge with
+ *     ordinary unqualified lookup candidates.
+ *   - `undefined` — no ADL candidates.
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
@@ -130,16 +151,22 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     const args = argInfoBySite.get(key);
     if (args === undefined || args.length === 0)
         return undefined;
-    // Collect associated namespace QNames from every participating class-typed arg.
+    // Collect associated namespace QNames from every participating class-typed arg
+    // and from function-reference args.
     const associatedNamespaces = new Set();
     for (const arg of args) {
         collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces);
+        if (arg.functionRefText !== undefined) {
+            collectFunctionRefNamespaces(arg.functionRefText, parsedFiles, associatedNamespaces);
+        }
     }
     if (associatedNamespaces.size === 0)
         return undefined;
     // Walk every namespace scope in every parsed file; collect callable
     // ownedDefs whose enclosing namespace matches one of the associated
     // QNames AND whose simple name matches the call's name.
+    // ISO C++: inline namespaces are transparent — candidates in inline
+    // children of an associated namespace are also ADL-reachable.
     const candidates = [];
     const seenKey = new Set();
     for (const parsed of parsedFiles) {
@@ -150,8 +177,20 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
             if (scope.kind !== 'Namespace')
                 continue;
             const qName = computeNamespaceQName(scope, scopesById);
-            if (!associatedNamespaces.has(qName))
-                continue;
+            if (!associatedNamespaces.has(qName)) {
+                // Check if this is an inline-namespace child of an associated NS.
+                // ISO C++ inline namespaces are transparent for ADL: if the outer
+                // namespace is in the associated set, candidates in the inline child
+                // are also reachable.
+                if (!isCppInlineNamespaceScope(scope.id))
+                    continue;
+                const parentScope = scope.parent !== null ? scopesById.get(scope.parent) : undefined;
+                if (parentScope === undefined || parentScope.kind !== 'Namespace')
+                    continue;
+                const parentQName = computeNamespaceQName(parentScope, scopesById);
+                if (!associatedNamespaces.has(parentQName))
+                    continue;
+            }
             for (const def of scope.ownedDefs) {
                 if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
                     continue;
@@ -169,26 +208,66 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
                 candidates.push(def);
             }
         }
+        // ISO C++ `[basic.lookup.argdep]` §2: hidden friend functions declared
+        // inside a class body are visible via ADL when the class is an associated
+        // class. Scan Class scopes whose enclosing namespace is in the associated
+        // set for callable ownedDefs matching the call name. This enables the
+        // canonical "hidden friend" idiom:
+        //   struct Foo { friend void swap(Foo&, Foo&) {} };
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            // Check if ANY class def in this scope has an associated namespace.
+            let isAssociatedClass = false;
+            for (const def of scope.ownedDefs) {
+                if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                    continue;
+                const nsQName = classToNamespaceQualifiedName.get(def.nodeId);
+                if (nsQName !== undefined && associatedNamespaces.has(nsQName)) {
+                    isAssociatedClass = true;
+                    break;
+                }
+            }
+            if (!isAssociatedClass)
+                continue;
+            // Also scan Function scopes that are direct children of this class
+            // scope — friend function definitions create their own Function scope
+            // underneath the Class scope.
+            for (const childScope of parsed.scopes) {
+                if (childScope.parent !== scope.id)
+                    continue;
+                if (childScope.kind !== 'Function')
+                    continue;
+                for (const def of childScope.ownedDefs) {
+                    if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
+                        continue;
+                    }
+                    const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (simple !== site.name)
+                        continue;
+                    if (seenKey.has(def.nodeId))
+                        continue;
+                    seenKey.add(def.nodeId);
+                    candidates.push(def);
+                }
+            }
+            for (const def of scope.ownedDefs) {
+                if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
+                    continue;
+                }
+                const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                if (simple !== site.name)
+                    continue;
+                if (seenKey.has(def.nodeId))
+                    continue;
+                seenKey.add(def.nodeId);
+                candidates.push(def);
+            }
+        }
     }
     if (candidates.length === 0)
         return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    // Multi-candidate: narrow then check ambiguity. Reuses the OVERLOAD_AMBIGUOUS
-    // sentinel contract from `overload-narrowing.ts` so int/long-collision-style
-    // ambiguity also suppresses on the ADL path.
-    const narrowed = narrowOverloadCandidates(candidates, site.arity, site.argumentTypes);
-    if (narrowed.length === 1)
-        return narrowed[0];
-    if (narrowed.length === 0)
-        return undefined;
-    if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity))
-        return ADL_AMBIGUOUS;
-    // Multiple surviving candidates that aren't normalization-ambiguous —
-    // ISO C++ would run overload resolution; V1 lacks conversion ranking so
-    // suppress rather than pick arbitrarily. Mirrors `pickImplicitThisOverload`'s
-    // unique-survivor requirement (see `pick-implicit-this-overload.test.ts`).
-    return ADL_AMBIGUOUS;
+    return candidates;
 }
 function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces) {
     // For template args this may be the template name itself (e.g. `vector`);
@@ -196,8 +275,8 @@ function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces)
     // V1/V2 simplification).
     addAssociatedNamespaceForClassName(arg.simpleClassName, scopes, associatedNamespaces);
     // Includes template-owner namespaces (e.g. `std` in std::vector<T>). If
-    // that surfaces extra candidates, ADL_AMBIGUOUS suppression below prevents
-    // arbitrary edge emission.
+    // that surfaces extra candidates, merged-candidate overload narrowing in
+    // free-call-fallback suppresses arbitrary edge emission.
     if (arg.templateNamespace.length > 0)
         associatedNamespaces.add(arg.templateNamespace);
     for (const ns of arg.templateArgNamespaces) {
@@ -296,15 +375,21 @@ function findNamespaceDefInScope(scope) {
     }
     return undefined;
 }
-/** Find a class-like def by simple name across the workspace. V1
- *  still arbitrary-picks the first class on collisions (multiple classes
+/** Find a class-like or enum def by simple name across the workspace.
+ *  V1 still arbitrary-picks the first match on collisions (multiple defs
  *  share the simple name), but reports the collision so callers can avoid
  *  amplifying that uncertainty (for example by skipping MRO expansion).
- *  C++ ADL strictness would require full type-driven lookup. */
+ *  C++ ADL strictness would require full type-driven lookup.
+ *
+ *  ISO C++ `[basic.lookup.argdep]` §2: enumerations contribute their
+ *  enclosing namespace to the associated set, just like class types. */
 function findCppClassDefBySimpleName(simpleName, scopes) {
     let firstMatch;
     for (const def of scopes.defs.byId.values()) {
-        if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+        if (def.type !== 'Class' &&
+            def.type !== 'Struct' &&
+            def.type !== 'Interface' &&
+            def.type !== 'Enum')
             continue;
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         if (simple !== simpleName)
@@ -319,3 +404,75 @@ function findCppClassDefBySimpleName(simpleName, scopes) {
         return undefined;
     return { classDef: firstMatch, ambiguous: false };
 }
+/**
+ * Contribute associated namespaces for a function-reference argument.
+ *
+ * - **Qualified refs** (`utils::worker`, `outer::inner::fn`): the namespace
+ *   is extracted from the qualifier text (converting `::` to `.` for dot-joined
+ *   QName matching). A workspace lookup then **verifies** that a Function or
+ *   Method def named `worker` (the simple name after the last `::`) actually
+ *   exists in the extracted namespace. This prevents false positives from
+ *   namespace-qualified variables, enum values, and static data members, which
+ *   also produce `qualified_identifier` AST nodes in tree-sitter-cpp (the
+ *   AST node type alone does not distinguish functions from non-function names).
+ * - **Unqualified refs** (`worker`): the workspace is searched for any
+ *   Function/Method def whose simple name matches. Every distinct enclosing
+ *   namespace found is added — overloads across the same namespace produce
+ *   a single entry; GitNexus does not select a specific overload at this stage.
+ */
+function collectFunctionRefNamespaces(refText, parsedFiles, out) {
+    const colonIdx = refText.lastIndexOf('::');
+    if (colonIdx !== -1) {
+        // Qualified ref: extract namespace prefix and normalise :: → dot notation.
+        const nsText = refText.slice(0, colonIdx).replace(/::/g, '.');
+        if (nsText === '')
+            return;
+        const simpleName = refText.slice(colonIdx + 2);
+        // Verify that a Function/Method named `simpleName` exists in `nsText`.
+        // Without this guard every `a::b` qualified_identifier arg (variable,
+        // enum value, static member, type alias) would blindly contribute `a`
+        // to the associated set and risk a false-positive CALLS edge.
+        for (const parsed of parsedFiles) {
+            const scopesById = new Map();
+            for (const sc of parsed.scopes)
+                scopesById.set(sc.id, sc);
+            for (const scope of parsed.scopes) {
+                if (scope.kind !== 'Namespace')
+                    continue;
+                if (computeNamespaceQName(scope, scopesById) !== nsText)
+                    continue;
+                for (const def of scope.ownedDefs) {
+                    if (def.type !== 'Function' && def.type !== 'Method')
+                        continue;
+                    const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (simple === simpleName) {
+                        out.add(nsText);
+                        return; // Namespace confirmed; no need to scan further files.
+                    }
+                }
+            }
+        }
+        return;
+    }
+    // Unqualified: search all namespace scopes for a Function def with this
+    // simple name and contribute its enclosing namespace.
+    for (const parsed of parsedFiles) {
+        const scopesById = new Map();
+        for (const sc of parsed.scopes)
+            scopesById.set(sc.id, sc);
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            for (const def of scope.ownedDefs) {
+                if (def.type !== 'Function' && def.type !== 'Method')
+                    continue;
+                const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                if (simple !== refText)
+                    continue;
+                const nsQName = computeNamespaceQName(scope, scopesById);
+                if (nsQName !== '')
+                    out.add(nsQName);
+            }
+        }
+    }
+}

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

@@ -717,15 +717,93 @@ function classifyAdlArg(argNode) {
         argNode.type === 'nullptr') {
         return EMPTY_ADL_ARG;
     }
+    // Qualified expression (a::b) — may be a function, variable, enum value,
+    // or static member. Record as a potential function reference; resolution
+    // time verifies via workspace lookup that a Function/Method with this simple
+    // name exists in the extracted namespace before contributing to the set.
+    if (argNode.type === 'qualified_identifier') {
+        return {
+            simpleClassName: '',
+            templateSimpleClassName: '',
+            templateNamespace: '',
+            templateArgClassNames: [],
+            templateArgNamespaces: [],
+            functionRefText: argNode.text,
+        };
+    }
     // Variable reference — look up its declared type (preserving pointer /
     // reference / qualified-name shape; the existing arity-narrowing helper
     // strips this info).
     if (argNode.type === 'identifier') {
-        return lookupAdlIdentifierType(argNode);
+        const result = lookupAdlIdentifierType(argNode);
+        if (result === null) {
+            // Not found in the local compound_statement scope — could be a
+            // free-function reference (unqualified name, namespace scope).
+            return {
+                simpleClassName: '',
+                templateSimpleClassName: '',
+                templateNamespace: '',
+                templateArgClassNames: [],
+                templateArgNamespaces: [],
+                functionRefText: argNode.text,
+            };
+        }
+        return result;
     }
     // Other shapes (calls, member access, operators) — V1 unsupported.
     return EMPTY_ADL_ARG;
 }
+/**
+ * Returns `true` when `varName` appears as a parameter name in the nearest
+ * enclosing `function_definition` or `function_declarator` that contains
+ * `identNode`. Parameters live in `parameter_list` (a sibling of the
+ * `compound_statement`), so the `compound_statement`-local declaration scan
+ * in `lookupAdlIdentifierType` would not find them — causing them to be
+ * mistakenly classified as potential free-function references.
+ *
+ * In tree-sitter-cpp a `function_definition` does NOT expose `parameters`
+ * as a direct named field; parameters live inside the nested
+ * `function_declarator`. For `function_declarator` nodes the `parameters`
+ * field IS direct. Both cases are handled below.
+ */
+function isIdentifierAFunctionParameter(identNode, varName) {
+    let node = identNode.parent;
+    let safety = 64;
+    while (node !== null && safety-- > 0) {
+        let params = null;
+        if (node.type === 'function_declarator') {
+            // parameters is a direct field on function_declarator.
+            params = node.childForFieldName('parameters');
+        }
+        else if (node.type === 'function_definition') {
+            // function_definition carries parameters inside its `declarator` field
+            // (which is a function_declarator). Walk through it.
+            const decl = node.childForFieldName('declarator');
+            if (decl !== null && decl.type === 'function_declarator') {
+                params = decl.childForFieldName('parameters');
+            }
+        }
+        if (params !== null) {
+            for (let i = 0; i < params.namedChildCount; i++) {
+                const param = params.namedChild(i);
+                if (param === null)
+                    continue;
+                const declNode = param.childForFieldName('declarator');
+                if (declNode === null)
+                    continue;
+                const leafName = extractDeclaratorLeafName(declNode);
+                if (leafName === varName)
+                    return true;
+            }
+            // Only check the immediately enclosing function — do not climb further.
+            break;
+        }
+        if (node.type === 'translation_unit')
+            break;
+        node = node.parent;
+    }
+    return false;
+}
 function lookupAdlIdentifierType(identNode) {
     const varName = identNode.text;
     let scope = identNode.parent;
@@ -735,7 +813,15 @@ function lookupAdlIdentifierType(identNode) {
         scope = scope.parent;
     }
     if (scope === null)
+        return null;
+    // Function parameters live in the enclosing function's `parameter_list`,
+    // NOT inside the `compound_statement`, so the declaration scan below would
+    // never find them and would return `null` — incorrectly triggering the
+    // free-function-reference path. Check the parameter_list first.
+    if (isIdentifierAFunctionParameter(identNode, varName)) {
         return EMPTY_ADL_ARG;
+    }
+    let foundAsLocalFunctionPointer = false;
     for (let i = 0; i < scope.childCount; i++) {
         const stmt = scope.child(i);
         if (stmt === null || stmt.type !== 'declaration')
@@ -764,6 +850,9 @@ function lookupAdlIdentifierType(identNode) {
             if (inner.type === 'pointer_declarator') {
                 if (findFirstDescendantOfType(inner, 'function_declarator') !== null) {
                     isFunctionPointer = true;
+                    // Extract the name from within the function-pointer declarator chain
+                    // so `foundAsLocalFunctionPointer` can detect a matching declaration.
+                    nameText = extractDeclaratorLeafName(inner);
                     break;
                 }
                 const next = inner.childForFieldName('declarator');
@@ -796,12 +885,22 @@ function lookupAdlIdentifierType(identNode) {
             }
             if (inner.type === 'function_declarator') {
                 isFunctionPointer = true;
+                // Extract the name from the inner declarator (e.g. `(*g)` in `void (*g)()`).
+                const innerDecl = inner.childForFieldName('declarator');
+                if (innerDecl !== null)
+                    nameText = extractDeclaratorLeafName(innerDecl);
                 break;
             }
             // Reached the leaf — usually `identifier`. Take its text.
             nameText = inner.text;
             break;
         }
+        if (nameText === varName && isFunctionPointer) {
+            // Explicitly declared as a function-pointer variable — must not be
+            // treated as a free-function reference by the caller.
+            foundAsLocalFunctionPointer = true;
+            continue;
+        }
         if (isFunctionPointer || nameText !== varName)
             continue;
         const simpleClassName = extractAdlSimpleTypeName(typeNode);
@@ -814,7 +913,22 @@ function lookupAdlIdentifierType(identNode) {
             templateArgNamespaces,
         };
     }
-    return EMPTY_ADL_ARG;
+    // If the identifier was found in local scope as a function-pointer variable,
+    // return EMPTY_ADL_ARG so the caller does NOT treat it as a free-function
+    // reference. Otherwise return null to indicate "not in local scope".
+    //
+    // Known limitation (Finding 4): variables whose type is a typedef/using alias
+    // for a function-pointer type are NOT detected here. For example:
+    //   using Callback = void (*)();
+    //   Callback g;
+    //   foo(g);  // `g`'s declarator is `identifier` with type `Callback`
+    // The declarator has no `pointer_declarator` wrapper, so `isFunctionPointer`
+    // stays false and `extractAdlSimpleTypeName` returns `"Callback"`. ADL then
+    // looks for a class named `Callback`; if none exists, this degrades to
+    // EMPTY_ADL_ARG (class not found → no namespace contributed). If a class
+    // named `Callback` does exist, a spurious namespace contribution could occur.
+    // Risk is low in practice; a future fix should resolve the typedef/alias chain.
+    return foundAsLocalFunctionPointer ? EMPTY_ADL_ARG : null;
 }
 /** Extract the simple class-like type name from a `type:` field node.
  *  Returns '' for primitives and any other
@@ -963,6 +1077,29 @@ function extractNamespaceFromQualifiedText(text) {
         return '';
     return normalizeCppNamespaceQName(cleaned.slice(0, idx));
 }
+/**
+ * Walk a declarator node chain, unwrapping pointer/reference/function/
+ * parenthesized wrappers, and return the text of the innermost identifier.
+ * Returns `null` when no identifier is found within `safety` steps.
+ * Used by `lookupAdlIdentifierType` to extract the variable name from
+ * function-pointer declarator trees such as `(*g)()` in `void (*g)()`.
+ */
+function extractDeclaratorLeafName(node) {
+    let cur = node;
+    let safety = 16;
+    while (safety-- > 0) {
+        if (cur.type === 'identifier' || cur.type === 'type_identifier')
+            return cur.text;
+        // Common wrapper nodes — follow the 'declarator' field when present.
+        const next = cur.childForFieldName('declarator') ??
+            // parenthesized_declarator: single named child
+            (cur.type === 'parenthesized_declarator' ? cur.namedChild(0) : null);
+        if (next === null)
+            return null;
+        cur = next;
+    }
+    return null;
+}
 /**
  * Check if a C++ function_definition or declaration has `static` storage class.
  */

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

@@ -9,10 +9,9 @@ import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
 import { expandCppWildcardNames, isFileLocal, clearFileLocalNames, populateCppAnonymousNamespaceScopes, populateCppNonGloballyVisible, isCppDefGloballyVisible, } from './file-local-linkage.js';
 import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMember, } from './two-phase-lookup.js';
-import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates, ADL_AMBIGUOUS, } from './adl.js';
+import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates } from './adl.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
-import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -187,12 +186,12 @@ export const cppScopeResolver = {
         return !isCppDependentBaseMember(callerScope, candidate, scopes);
     },
     // C++ argument-dependent / Koenig lookup (U2 of plan 2026-05-13-001).
-    // Fires after `findCallableBindingInScope` returns undefined; surfaces
-    // candidates from the associated namespaces of class-typed arguments.
+    // Contributes candidates from associated namespaces of class-typed
+    // arguments; caller merges with ordinary unqualified lookup candidates.
     // Current boundary: class-typed value/pointer/reference args and template
     // specializations with explicit type arguments contribute associated
-    // namespaces. Function-pointer args, base-class associated namespaces,
-    // and full ordinary+ADL merge remain excluded.
+    // namespaces. Function-pointer args and full conversion-ranking remain
+    // excluded.
     resolveAdlCandidates: (site, callerParsed, scopes, parsedFiles) => {
         // `using ns::name;` introduces `name` into ordinary unqualified lookup.
         // For template-class method bodies, lexical scope walks can miss this
@@ -213,19 +212,24 @@ export const cppScopeResolver = {
             seenUsing.add(member.nodeId);
             usingNamedHits.push(member);
         }
-        if (usingNamedHits.length > 0) {
-            const narrowed = narrowOverloadCandidates(usingNamedHits, site.arity, site.argumentTypes);
-            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity))
-                return 'ambiguous';
-            if (narrowed.length === 1)
-                return narrowed[0];
-            if (narrowed.length > 1)
-                return 'ambiguous';
+        const adlHits = pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles);
+        if (usingNamedHits.length === 0)
+            return adlHits;
+        if (adlHits === undefined || adlHits.length === 0)
+            return usingNamedHits;
+        const merged = [];
+        const seen = new Set();
+        for (const hit of usingNamedHits) {
+            seen.add(hit.nodeId);
+            merged.push(hit);
         }
-        const result = pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles);
-        if (result === ADL_AMBIGUOUS)
-            return 'ambiguous';
-        return result;
+        for (const hit of adlHits) {
+            if (seen.has(hit.nodeId))
+                continue;
+            seen.add(hit.nodeId);
+            merged.push(hit);
+        }
+        return merged;
     },
     // C++ qualified namespace-member resolution (U5 of plan 2026-05-13-001).
     // Handles `outer::foo()` where `outer` is a namespace (not a class).

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

@@ -506,16 +506,15 @@ export interface ScopeResolver {
      * Optional argument-dependent-lookup (ADL / Koenig lookup) hook for
      * languages with C++-style associated-namespace candidate addition.
      *
-     * Runs in the free-call fallback AFTER `findCallableBindingInScope`
-     * returns `undefined` and BEFORE `pickUniqueGlobalCallable`. The hook
-     * inspects the call site's argument types, computes the associated
-     * namespace set, and returns either:
-     *   - a unique `SymbolDefinition` — emit the CALLS edge to it.
-     *   - `'ambiguous'` — multiple candidates share normalized parameter
-     *     types; the caller MUST suppress (zero edges). Mirrors the
-     *     OVERLOAD_AMBIGUOUS sentinel from `overload-narrowing.ts`.
-     *   - `undefined` — no ADL candidates; caller falls through to the
-     *     global free-call fallback (`pickUniqueGlobalCallable`).
+     * Runs in the free-call fallback alongside ordinary unqualified lookup.
+     * The fallback merges ordinary candidates with ADL candidates and applies
+     * overload narrowing over the union.
+     *
+     * The hook inspects the call site's argument types, computes the
+     * associated namespace set, and returns either:
+     *   - an array of candidate `SymbolDefinition`s to add to the
+     *     ordinary-lookup candidate pool.
+     *   - `undefined` when ADL contributes no candidates.
      *
      * Languages without C++-style ADL leave this undefined. The
      * cross-language contract is "additive tier" — defining the hook never
@@ -529,7 +528,7 @@ export interface ScopeResolver {
             readonly startLine: number;
             readonly startCol: number;
         };
-    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
+    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
     /**
      * Optional resolver for qualified-receiver member calls where the
      * receiver is a namespace (not a class) and ordinary scope-chain /

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

@@ -41,7 +41,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
             readonly startLine: number;
             readonly startCol: number;
         };
-    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
+    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
 }): number;
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +

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

@@ -17,8 +17,8 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findCallableBindingInScope, findClassBindingInScope } from '../scope/walkers.js';
-import { narrowOverloadCandidates } from './overload-narrowing.js';
+import { findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } from '../scope/walkers.js';
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from './overload-narrowing.js';
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
     const seen = new Set();
@@ -48,36 +48,74 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model);
             }
             if (fnDef === undefined) {
-                fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
-            }
-            // V1 ADL tier (C++ Koenig lookup, opt-in via provider.resolveAdlCandidates).
-            // Fires only when ordinary lookup is empty — V1 limitation per
-            // plan 2026-05-13-001 U2; ISO C++ would merge ADL with ordinary lookup
-            // and run overload resolution over the union.
-            //
-            // Sentinel 'ambiguous': ADL surfaced multiple candidates with
-            // identical normalized parameter types (mirrors OVERLOAD_AMBIGUOUS).
-            // We mark the site handled so `emit-references` does not retry, and
-            // continue to the next site without emitting an edge.
-            if (fnDef === undefined && options.resolveAdlCandidates !== undefined) {
-                const adlResult = options.resolveAdlCandidates({
-                    name: site.name,
-                    arity: site.arity,
-                    argumentTypes: site.argumentTypes,
-                    atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
-                }, parsed, scopes, parsedFiles);
-                if (adlResult === 'ambiguous') {
-                    handledSites.add(`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`);
-                    continue;
+                if (options.resolveAdlCandidates === undefined) {
+                    fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
                 }
-                if (adlResult !== undefined) {
-                    fnDef = adlResult;
+                else {
+                    // ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when
+                    // ordinary lookup finds a non-function name (variable, class, enum)
+                    // or a block-scope function declaration (not via using-declaration)
+                    // at the nearest scope where the name exists.
+                    const { callables: ordinary, nonCallableFound, blockScopeDeclFound, } = findCallableBindingsAndAdlBlocker(site.inScope, site.name, scopes);
+                    const adlSuppressed = nonCallableFound || blockScopeDeclFound;
+                    const adl = adlSuppressed
+                        ? undefined
+                        : options.resolveAdlCandidates({
+                            name: site.name,
+                            arity: site.arity,
+                            argumentTypes: site.argumentTypes,
+                            atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
+                        }, parsed, scopes, parsedFiles);
+                    // Preserve existing ordinary-lookup behavior when ADL contributed
+                    // no candidates.
+                    if (adl === undefined || adl.length === 0) {
+                        fnDef = ordinary[0];
+                    }
+                    else {
+                        const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+                        const merged = [];
+                        const seen = new Set();
+                        const push = (defs) => {
+                            for (const d of defs) {
+                                if (seen.has(d.nodeId))
+                                    continue;
+                                seen.add(d.nodeId);
+                                merged.push(d);
+                            }
+                        };
+                        push(ordinary);
+                        push(adl);
+                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes);
+                        if (narrowed.length === 1) {
+                            fnDef = narrowed[0];
+                        }
+                        else if (narrowed.length === 0) {
+                            // ADL contributed candidates, but none survived arity/type
+                            // narrowing. Treat as handled to avoid global-name fallback
+                            // binding to the same mismatched symbol by simple-name
+                            // uniqueness.
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                        else if (narrowed.length > 1) {
+                            // Suppress ambiguous overload calls (emit zero edges) when
+                            // merged ordinary+ADL candidate sets cannot be disambiguated.
+                            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
+                                handledSites.add(siteKey);
+                                continue;
+                            }
+                            // Multiple survivors remain but no conversion-ranking step
+                            // exists yet; suppress instead of picking arbitrarily.
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                    }
                 }
             }
             // V1: pickUniqueGlobalCallable ignores import context — resolves to any
             // globally-unique callable. False cross-package edges are possible when
             // the caller does not import the target package. Same-package calls are
-            // caught by findCallableBindingInScope above before reaching here.
+            // usually caught by nearest-scope lookup before reaching here.
             if (fnDef === undefined && options.allowGlobalFallback === true) {
                 fnDef = pickUniqueGlobalCallable(site.name, model, scopes, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
                     ? (candidate) => options.isCallableVisibleFromCaller({

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -102,6 +102,36 @@ export declare function findClassBindingInScope(startScope: ScopeId, receiverNam
  * def-type predicate differs.
  */
 export declare function findCallableBindingInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Look up all callable bindings (Function/Method/Constructor) by name
+ * from the nearest scope in the chain that binds `callableName`.
+ *
+ * Preserves the original scope-walk boundary used by
+ * `findCallableBindingInScope`: once any callable binding is found in a
+ * scope, outer scopes are not consulted.
+ */
+export declare function findAllCallableBindingsInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): readonly SymbolDefinition[];
+/**
+ * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
+ * unqualified lookup finds:
+ *   - a name that is NOT a function or function template, OR
+ *   - a block-scope function declaration that is NOT a using-declaration.
+ *
+ * Combined walker that stops at the **nearest scope** where `name` has any
+ * binding (callable or non-callable) and returns:
+ *   - `callables`: Function/Method/Constructor defs found at that scope
+ *   - `nonCallableFound`: a non-function binding was present (variable, class, etc.)
+ *   - `blockScopeDeclFound`: a callable was found at a Function or Block scope
+ *     (block-scope function declaration that blocks ADL)
+ *
+ * One pass, one stop — no divergence between callable collection and blocker
+ * detection.
+ */
+export declare function findCallableBindingsAndAdlBlocker(startScope: ScopeId, name: string, scopes: ScopeResolutionIndexes): {
+    callables: readonly SymbolDefinition[];
+    nonCallableFound: boolean;
+    blockScopeDeclFound: boolean;
+};
 /**
  * Populate `ownerId` on every def structurally owned by a Class
  * scope — methods (defs in Function scopes whose parent is Class)

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -209,32 +209,114 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
  * def-type predicate differs.
  */
 export function findCallableBindingInScope(startScope, callableName, scopes) {
+    return findAllCallableBindingsInScope(startScope, callableName, scopes)[0];
+}
+/**
+ * Look up all callable bindings (Function/Method/Constructor) by name
+ * from the nearest scope in the chain that binds `callableName`.
+ *
+ * Preserves the original scope-walk boundary used by
+ * `findCallableBindingInScope`: once any callable binding is found in a
+ * scope, outer scopes are not consulted.
+ */
+export function findAllCallableBindingsInScope(startScope, callableName, scopes) {
     let currentId = startScope;
     const visited = new Set();
     while (currentId !== null) {
         if (visited.has(currentId))
-            return undefined;
+            return [];
         visited.add(currentId);
         const scope = scopes.scopeTree.getScope(currentId);
         if (scope === undefined)
-            return undefined;
+            return [];
+        const out = [];
+        const seen = new Set();
+        const pushCallable = (def) => {
+            if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+                return;
+            if (seen.has(def.nodeId))
+                return;
+            seen.add(def.nodeId);
+            out.push(def);
+        };
         const localBindings = scope.bindings.get(callableName);
         if (localBindings !== undefined) {
             for (const b of localBindings) {
-                if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
-                    return b.def;
-                }
+                pushCallable(b.def);
             }
         }
         const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
         for (const b of importedBindings) {
-            if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
-                return b.def;
+            pushCallable(b.def);
+        }
+        if (out.length > 0)
+            return out;
+        currentId = scope.parent;
+    }
+    return [];
+}
+/**
+ * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
+ * unqualified lookup finds:
+ *   - a name that is NOT a function or function template, OR
+ *   - a block-scope function declaration that is NOT a using-declaration.
+ *
+ * Combined walker that stops at the **nearest scope** where `name` has any
+ * binding (callable or non-callable) and returns:
+ *   - `callables`: Function/Method/Constructor defs found at that scope
+ *   - `nonCallableFound`: a non-function binding was present (variable, class, etc.)
+ *   - `blockScopeDeclFound`: a callable was found at a Function or Block scope
+ *     (block-scope function declaration that blocks ADL)
+ *
+ * One pass, one stop — no divergence between callable collection and blocker
+ * detection.
+ */
+export function findCallableBindingsAndAdlBlocker(startScope, name, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
+        const callables = [];
+        const seen = new Set();
+        let nonCallableFound = false;
+        let anyBinding = false;
+        const process = (def) => {
+            anyBinding = true;
+            if (def.type === 'Function' || def.type === 'Method' || def.type === 'Constructor') {
+                if (!seen.has(def.nodeId)) {
+                    seen.add(def.nodeId);
+                    callables.push(def);
+                }
+            }
+            else {
+                nonCallableFound = true;
+            }
+        };
+        const localBindings = scope.bindings.get(name);
+        if (localBindings !== undefined) {
+            for (const b of localBindings) {
+                process(b.def);
             }
         }
+        const importedBindings = lookupBindingsAt(currentId, name, scopes);
+        for (const b of importedBindings) {
+            process(b.def);
+        }
+        if (anyBinding) {
+            // ISO C++: a block-scope function declaration (Function or Block scope)
+            // that is NOT a using-declaration blocks ADL. If we found callables at
+            // a function/block scope, ADL must be suppressed.
+            const blockScopeDeclFound = callables.length > 0 && (scope.kind === 'Function' || scope.kind === 'Block');
+            return { callables, nonCallableFound, blockScopeDeclFound };
+        }
         currentId = scope.parent;
     }
-    return undefined;
+    return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
 }
 /**
  * Populate `ownerId` on every def structurally owned by a Class

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.42",
+  "version": "1.6.5-rc.44",
   "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",