gitnexus 1.6.8-rc.47 → 1.6.8-rc.49

package/dist/_shared/scope-resolution/symbol-definition.d.ts

@@ -18,6 +18,8 @@ export interface ParameterTypeClass {
     indirection: 'value' | 'lvalue-ref' | 'rvalue-ref' | 'pointer' | 'unknown';
     /** Number of pointer markers when indirection is `pointer`; otherwise 0. */
     pointerDepth: number;
+    /** Normalized top-level template arguments, when a language preserves them. */
+    templateArguments?: string[];
 }
 export interface SymbolDefinition {
     nodeId: string;

package/dist/_shared/scope-resolution/symbol-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;4DAEwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;mEAE+D;IAC/D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;iEAO6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}
+{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;4DAEwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;mEAE+D;IAC/D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;iEAO6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/core/ingestion/languages/cpp/arity-metadata.js

@@ -173,6 +173,7 @@ export function classifyCppParameterType(rawType, declaratorText, fullParameterT
         cv,
         indirection,
         pointerDepth,
+        ...templateArgumentsFor(`${source} ${rawType} ${declaratorText ?? ''}`),
     };
 }
 function unknownTypeClass(base) {
@@ -183,6 +184,40 @@ function unknownTypeClass(base) {
         pointerDepth: 0,
     };
 }
+function templateArgumentsFor(rawType) {
+    const args = parseTopLevelTemplateArguments(rawType);
+    return args === undefined ? {} : { templateArguments: args };
+}
+function parseTopLevelTemplateArguments(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    const args = [];
+    let depth = 0;
+    let argStart = start + 1;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0) {
+                const finalArg = rawType.slice(argStart, i).trim();
+                if (finalArg.length > 0)
+                    args.push(normalizeCppParamType(finalArg));
+                return args.length > 0 ? args : undefined;
+            }
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            const arg = rawType.slice(argStart, i).trim();
+            if (arg.length > 0)
+                args.push(normalizeCppParamType(arg));
+            argStart = i + 1;
+        }
+    }
+    return undefined;
+}
 function findFuncDeclarator(node) {
     let decl = node.childForFieldName('declarator');
     if (decl === null) {

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

@@ -11,6 +11,7 @@ import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
 import { extractCppTemplateConstraints } from './constraint-extractor.js';
 import { captureCppMemberLookupFacts } from './member-lookup.js';
+import { CPP_BRACED_INIT_TYPE_PREFIX } from './conversion-rank.js';
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -906,6 +907,8 @@ function unknownTypeClass(base) {
  */
 function inferCppLiteralType(node) {
     switch (node.type) {
+        case 'initializer_list':
+            return inferCppBracedInitType(node);
         case 'number_literal': {
             const text = node.text;
             // Floating-point literals contain '.', 'e', 'E', or end with 'f'/'F'
@@ -934,6 +937,27 @@ function inferCppLiteralType(node) {
             return '';
     }
 }
+function inferCppBracedInitType(node) {
+    const elementTypes = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === ',' || child.type === '{' || child.type === '}')
+            continue;
+        const elementType = inferCppLiteralType(child);
+        if (elementType === '' || elementType.startsWith(CPP_BRACED_INIT_TYPE_PREFIX)) {
+            return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length + 1}`;
+        }
+        elementTypes.push(elementType);
+    }
+    if (elementTypes.length === 0)
+        return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:0`;
+    const first = elementTypes[0];
+    return elementTypes.every((type) => type === first)
+        ? `${CPP_BRACED_INIT_TYPE_PREFIX}${first}:${elementTypes.length}`
+        : `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length}`;
+}
 /**
  * Look up the declared type of a variable by scanning sibling declarations
  * in the enclosing compound_statement (function body). Handles:

package/dist/core/ingestion/languages/cpp/conversion-rank.d.ts

@@ -20,6 +20,8 @@
  * their own `ConversionRankFn` in the future.
  */
 import type { ParameterTypeClass } from '../../../../_shared/index.js';
+export declare const CPP_BRACED_INIT_TYPE_PREFIX = "braced-init:";
+export declare const CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES: readonly ["braced-init:"];
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *

package/dist/core/ingestion/languages/cpp/conversion-rank.js

@@ -19,6 +19,7 @@
  * This function is intentionally C++-specific. Other languages may define
  * their own `ConversionRankFn` in the future.
  */
+import { normalizeCppParamType } from './arity-metadata.js';
 import { hasCppUserDefinedConversion } from './user-defined-conversions.js';
 /** Set of normalized arithmetic types that support implicit conversion. */
 const ARITHMETIC = new Set(['int', 'double', 'char', 'bool']);
@@ -27,6 +28,22 @@ const INTEGRAL_PROMOTION = new Map([
     ['char', 'int'],
     ['bool', 'int'],
 ]);
+export const CPP_BRACED_INIT_TYPE_PREFIX = 'braced-init:';
+export const CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES = [CPP_BRACED_INIT_TYPE_PREFIX];
+const BRACED_INIT_CONTAINER_TYPES = new Set([
+    'array',
+    'deque',
+    'list',
+    'set',
+    'std::array',
+    'std::deque',
+    'std::list',
+    'std::set',
+    'std::unordered_set',
+    'std::vector',
+    'unordered_set',
+    'vector',
+]);
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *
@@ -36,6 +53,17 @@ const INTEGRAL_PROMOTION = new Map([
  *          for mismatch.
  */
 export function cppConversionRank(argType, paramType, argTypeClass, paramTypeClass) {
+    const bracedInitType = parseBracedInitArgType(argType);
+    if (bracedInitType !== undefined) {
+        if (bracedInitType.elementType === 'unknown')
+            return Infinity;
+        if (bracedInitType.elementCount === 1) {
+            const scalarRank = cppConversionRank(bracedInitType.elementType, paramType, undefined, paramTypeClass);
+            if (isFinite(scalarRank))
+                return scalarRank;
+        }
+        return bracedInitConversionRank(paramType, bracedInitType, paramTypeClass);
+    }
     if (argType === paramType) {
         return exactShapeCompatible(argTypeClass, paramTypeClass) ? 0 : Infinity;
     }
@@ -57,6 +85,67 @@ export function cppConversionRank(argType, paramType, argTypeClass, paramTypeCla
         return 4;
     return Infinity;
 }
+function parseBracedInitArgType(argType) {
+    if (!argType.startsWith(CPP_BRACED_INIT_TYPE_PREFIX))
+        return undefined;
+    const payload = argType.slice(CPP_BRACED_INIT_TYPE_PREFIX.length);
+    if (payload === '')
+        return undefined;
+    const separator = payload.lastIndexOf(':');
+    if (separator > 0) {
+        const countText = payload.slice(separator + 1);
+        if (/^\d+$/.test(countText)) {
+            return {
+                elementType: payload.slice(0, separator),
+                elementCount: Number(countText),
+            };
+        }
+    }
+    return { elementType: payload };
+}
+function bracedInitConversionRank(paramType, argType, paramTypeClass) {
+    const targetBase = bracedInitTargetBase(paramType);
+    if (targetBase === 'initializer_list' || targetBase === 'std::initializer_list') {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 0 : Infinity;
+    }
+    if (BRACED_INIT_CONTAINER_TYPES.has(targetBase)) {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 4 : Infinity;
+    }
+    return Infinity;
+}
+function bracedInitValueTypeMatches(paramType, argType, paramTypeClass) {
+    const valueType = bracedInitTargetValueType(paramType, paramTypeClass);
+    if (valueType === undefined)
+        return false;
+    return isFinite(cppConversionRank(argType.elementType, valueType));
+}
+function bracedInitTargetValueType(paramType, paramTypeClass) {
+    return firstTemplateArgument(paramType) ?? paramTypeClass?.templateArguments?.[0];
+}
+function firstTemplateArgument(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0)
+                return bracedInitTargetBase(rawType.slice(start + 1, i));
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            return bracedInitTargetBase(rawType.slice(start + 1, i));
+        }
+    }
+    return undefined;
+}
+function bracedInitTargetBase(paramType) {
+    return normalizeCppParamType(paramType);
+}
 function isPointer(typeClass) {
     return typeClass?.indirection === 'pointer' && typeClass.pointerDepth > 0;
 }

package/dist/core/ingestion/languages/cpp/inline-namespaces.js

@@ -27,7 +27,7 @@
  * declaration transparently.
  */
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 const inlineNamespaceRangesByFile = new Map();
 const inlineNamespaceScopeIds = new Set();
 function rangeKey(r) {
@@ -142,7 +142,12 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
     // can disambiguate via exact-type match and, when available, conversion-rank
     // scoring (`cppConversionRank`). Same-signature ambiguity is still detected
     // by `isOverloadAmbiguousAfterNormalization` below.
-    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined ? { conversionRankFn: cppConversionRank } : undefined);
+    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined
+        ? {
+            conversionRankFn: cppConversionRank,
+            conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
+        }
+        : undefined);
     if (narrowed.length === 1)
         return narrowed[0];
     if (narrowed.length === 0)

package/dist/core/ingestion/languages/cpp/member-lookup.js

@@ -3,7 +3,7 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 const capturedByFile = new Map();
 let directParentsByDefId = new Map();
 let virtualEdges = new Set();
@@ -193,6 +193,7 @@ function chooseOverload(candidates, callsite) {
     const narrowed = narrowOverloadCandidates(candidates, callsite.arity, callsite.argumentTypes, {
         argumentTypeClasses: callsite.argumentTypeClasses,
         conversionRankFn: cppConversionRank,
+        conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
         constraintCompatibility: cppConstraintCompatibility,
     });
     if (narrowed.length === 1)

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

@@ -3,7 +3,7 @@ import { SupportedLanguages } from '../../../../_shared/index.js';
 import { populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 import { cppMergeBindings } from './merge-bindings.js';
 import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
@@ -205,6 +205,7 @@ export const cppScopeResolver = {
     // Disambiguates `f(int)` vs `f(double)` called with `f(2.5)` by scoring
     // each candidate's conversion cost; exact match wins over standard conversion.
     conversionRankFn: cppConversionRank,
+    conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
     // Range-for element type inference: for (auto& user : users) → bind user to User
     populateRangeBindings: populateCppRangeBindings,
     // C++ method return-type bindings need to be visible from module scope

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

@@ -477,12 +477,19 @@ function parseJsonParameterTypeClassesCapture(cap) {
             if (typeof o.pointerDepth !== 'number' || !Number.isFinite(o.pointerDepth)) {
                 return undefined;
             }
-            out.push({
+            const shape = {
                 base: o.base,
                 cv: o.cv,
                 indirection: o.indirection,
                 pointerDepth: o.pointerDepth,
-            });
+            };
+            if (Array.isArray(o.templateArguments)) {
+                if (!o.templateArguments.every((x) => typeof x === 'string')) {
+                    return undefined;
+                }
+                shape.templateArguments = [...o.templateArguments];
+            }
+            out.push(shape);
         }
         return out;
     }

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

@@ -618,6 +618,15 @@ export interface ScopeResolver {
      * `cppConversionRank`; other languages define their own if needed.
      */
     readonly conversionRankFn?: ConversionRankFn;
+    /**
+     * Optional per-language argument-type prefixes for conversion-only
+     * argument sentinels. When ranking cannot find any viable candidate
+     * for a multi-overload set containing one of these sentinels, shared
+     * narrowing suppresses the ambiguous set instead of falling back to
+     * arity-only candidates. Languages without such sentinels leave this
+     * undefined.
+     */
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /**
      * Optional predicate to identify definitions with file-local linkage
      * (e.g. C `static` functions). When provided, `pickUniqueGlobalCallable`

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

@@ -49,6 +49,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
         };
     }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
     readonly conversionRankFn?: ConversionRankFn;
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Optional per-language constraint hook threaded into
      *  `narrowOverloadCandidates`. Drops candidates whose template
      *  constraints (e.g. C++ `enable_if_t`, C++20 `requires`) provably
@@ -99,7 +100,7 @@ export declare function buildGlobalClassIndex(scopes: ScopeResolutionIndexes): R
  * order. Exported for unit testing — the `scopeDefsCache` equivalence is
  * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
  */
-export declare function pickUniqueGlobalCallable(name: string, model: SemanticModel, globalCallablesBySimpleName: ReadonlyMap<string, readonly SymbolDefinition[]>, callerFilePath: string, isFileLocalDef?: (def: SymbolDefinition) => boolean, callArity?: number, isCallerVisible?: (candidate: SymbolDefinition) => boolean, callArgTypes?: readonly string[], callArgTypeClasses?: readonly ParameterTypeClass[], conversionRankFn?: ConversionRankFn, scopeDefsCache?: Map<string, readonly SymbolDefinition[]>): SymbolDefinition | undefined;
+export declare function pickUniqueGlobalCallable(name: string, model: SemanticModel, globalCallablesBySimpleName: ReadonlyMap<string, readonly SymbolDefinition[]>, callerFilePath: string, isFileLocalDef?: (def: SymbolDefinition) => boolean, callArity?: number, isCallerVisible?: (candidate: SymbolDefinition) => boolean, callArgTypes?: readonly string[], callArgTypeClasses?: readonly ParameterTypeClass[], conversionRankFn?: ConversionRankFn, scopeDefsCache?: Map<string, readonly SymbolDefinition[]>, conversionOnlyArgTypePrefixes?: readonly string[]): SymbolDefinition | undefined;
 /** Find a unique workspace-wide class-like def by simple name, for a
  *  constructor-form call `Type(...)` whose type lives outside the call
  *  site's lexical bindings (a sibling/imported file). Returns the def
@@ -142,5 +143,6 @@ export declare function pickImplicitThisOverload(site: {
     readonly argumentTypeClasses?: readonly import('../../../../_shared/index.js').ParameterTypeClass[];
 }, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, hookCtx?: {
     readonly conversionRankFn?: ConversionRankFn;
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
 }): SymbolDefinition | undefined;

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

@@ -89,6 +89,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             if (fnDef === undefined) {
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, {
                     conversionRankFn: options.conversionRankFn,
+                    conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                     constraintCompatibility: options.constraintCompatibility,
                 });
                 fnDefFromImplicitThis = fnDef !== undefined;
@@ -112,6 +113,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -190,6 +192,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -240,6 +243,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
                             argumentTypeClasses: site.argumentTypeClasses,
                             conversionRankFn: options.conversionRankFn,
+                            conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                             constraintCompatibility: options.constraintCompatibility,
                         });
                         if (narrowed.length === 1) {
@@ -285,7 +289,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache);
+                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache, options.conversionOnlyArgTypePrefixes);
             }
             if (fnDef === undefined)
                 continue;
@@ -442,7 +446,7 @@ export function buildGlobalClassIndex(scopes) {
  * order. Exported for unit testing — the `scopeDefsCache` equivalence is
  * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
  */
-export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache) {
+export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache, conversionOnlyArgTypePrefixes) {
     // The scope-index candidate list is a pure function of (name, callerFilePath):
     // the same-name bucket is fixed for the pass, the file-local filter depends
     // only on the candidate + callerFilePath, and the logical-key dedup is
@@ -504,6 +508,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -545,6 +550,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -687,6 +693,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
+        conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });
     if (candidates.length !== 1)

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -69,6 +69,10 @@ export interface OverloadNarrowingHookCtx {
     /** Conversion-rank scoring fallback (step 4b). Engages when the
      *  exact-type filter rejects every candidate. */
     readonly conversionRankFn?: ConversionRankFn;
+    /** Per-language argument-type prefixes whose conversion-rank failures
+     *  should suppress genuinely ambiguous multi-overload sets instead of
+     *  falling back to arity-only candidates. */
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Constraint filter (step 4c). Drops candidates whose template
      *  guards (SFINAE `enable_if_t`, C++20 `requires`, future Rust
      *  trait bounds, etc.) provably fail at the call site. Three-valued

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -106,6 +106,10 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn, hookCtx.argumentTypeClasses);
             if (ranked.length > 0)
                 result = ranked;
+            else if (candidates.length > 1 &&
+                hasConversionOnlyArgType(argTypes, hookCtx.conversionOnlyArgTypePrefixes)) {
+                result = [];
+            }
         }
     }
     // Constraint filter (step 4c; Tier-A — SFINAE / `requires` clauses).
@@ -145,6 +149,11 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     }
     return result;
 }
+function hasConversionOnlyArgType(argTypes, prefixes) {
+    if (prefixes === undefined || prefixes.length === 0)
+        return false;
+    return argTypes.some((type) => prefixes.some((prefix) => type.startsWith(prefix)));
+}
 function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
     if (argType !== paramType)
         return false;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -47,7 +47,7 @@ import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel, options?: {
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
 }): number;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -352,6 +352,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                             const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: provider.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: provider.constraintCompatibility,
                             });
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
@@ -867,6 +868,7 @@ function pickOverload(ownerId, memberName, site, model, provider) {
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     // When narrowing leaves >1 candidate that share identical normalized
@@ -967,6 +969,7 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     // Same ambiguity handling as `pickOverload`: when normalization
@@ -1001,6 +1004,7 @@ function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memb
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     const reason = isOverloadAmbiguousAfterNormalization(candidates, site.arity)

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

@@ -446,6 +446,7 @@ export function runScopeResolution(input, provider) {
         isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
         resolveAdlCandidates: provider.resolveAdlCandidates,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
         recordResolutionOutcome,
     });

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -1,4 +1,5 @@
 import { extractSimpleTypeName, extractVarName, resolveIterableElementType, methodToTypeArgPosition, } from './shared.js';
+import { CPP_BRACED_INIT_TYPE_PREFIX } from '../languages/cpp/conversion-rank.js';
 const DECLARATION_NODE_TYPES = new Set(['declaration']);
 /** Smart pointer factory function names that create a typed object. */
 const SMART_PTR_FACTORIES = new Set(['make_shared', 'make_unique', 'make_shared_for_overwrite']);
@@ -447,6 +448,8 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope })
 /** Infer the type of a literal AST node for C++ overload disambiguation. */
 const inferLiteralType = (node) => {
     switch (node.type) {
+        case 'initializer_list':
+            return inferBracedInitLiteralType(node);
         case 'number_literal': {
             const t = node.text;
             // Float suffixes
@@ -475,6 +478,24 @@ const inferLiteralType = (node) => {
             return undefined;
     }
 };
+function inferBracedInitLiteralType(node) {
+    const elementTypes = [];
+    for (const child of node.children) {
+        if (child.type === ',' || child.type === '{' || child.type === '}')
+            continue;
+        const elementType = inferLiteralType(child);
+        if (elementType === undefined || elementType.startsWith(CPP_BRACED_INIT_TYPE_PREFIX)) {
+            return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length + 1}`;
+        }
+        elementTypes.push(elementType);
+    }
+    if (elementTypes.length === 0)
+        return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:0`;
+    const first = elementTypes[0];
+    return elementTypes.every((type) => type === first)
+        ? `${CPP_BRACED_INIT_TYPE_PREFIX}${first}:${elementTypes.length}`
+        : `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length}`;
+}
 /** C++: detect constructor type from smart pointer factory calls (make_shared<Dog>()).
  *  Extracts the template type argument as the constructor type for virtual dispatch. */
 const detectCppConstructorType = (node, classNames) => {

package/dist/core/wiki/generator.js

@@ -12,7 +12,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { execSync, execFileSync } from 'child_process';
-import { initWikiDb, closeWikiDb, touchWikiDb, getFilesWithExports, getAllFiles, getIntraModuleCallEdges, getInterModuleCallEdges, getProcessesForFiles, getAllProcesses, getInterModuleEdgesForOverview, } from './graph-queries.js';
+import { initWikiDb, closeWikiDb, touchWikiDb, pinWikiDb, getFilesWithExports, getAllFiles, getIntraModuleCallEdges, getInterModuleCallEdges, getProcessesForFiles, getAllProcesses, getInterModuleEdgesForOverview, } from './graph-queries.js';
 import { generateHTMLViewer } from './html-viewer.js';
 import { sanitizeMermaidMarkdown } from './mermaid-sanitizer.js';
 import { callLLM, estimateTokens, } from './llm-client.js';
@@ -183,6 +183,7 @@ export class WikiGenerator {
         }
         // Init graph
         this.onProgress('init', 2, 'Connecting to knowledge graph...');
+        const releaseWikiDbPin = pinWikiDb();
         await initWikiDb(this.lbugPath);
         let result;
         try {
@@ -201,6 +202,7 @@ export class WikiGenerator {
             }
         }
         finally {
+            releaseWikiDbPin();
             await closeWikiDb();
         }
         // Always generate the HTML viewer after wiki content changes

package/dist/core/wiki/graph-queries.d.ts

@@ -8,6 +8,12 @@
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.
  */
 export declare function touchWikiDb(): void;
+/**
+ * Keep the wiki DB resident for a full generation run. Wiki generation can spend
+ * minutes inside LLM calls, and the pooled DB must survive both idle cleanup and
+ * unrelated LRU pressure until the run reaches its final graph queries.
+ */
+export declare function pinWikiDb(): () => void;
 export interface FileWithExports {
     filePath: string;
     symbols: Array<{

package/dist/core/wiki/graph-queries.js

@@ -4,7 +4,7 @@
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
  * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initLbug, executeQuery, closeLbug, touchRepo } from '../lbug/pool-adapter.js';
+import { initLbug, executeQuery, closeLbug, touchRepo, pinRepo } from '../lbug/pool-adapter.js';
 const REPO_ID = '__wiki__';
 /**
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.
@@ -12,6 +12,14 @@ const REPO_ID = '__wiki__';
 export function touchWikiDb() {
     touchRepo(REPO_ID);
 }
+/**
+ * Keep the wiki DB resident for a full generation run. Wiki generation can spend
+ * minutes inside LLM calls, and the pooled DB must survive both idle cleanup and
+ * unrelated LRU pressure until the run reaches its final graph queries.
+ */
+export function pinWikiDb() {
+    return pinRepo(REPO_ID);
+}
 /**
  * Initialize the LadybugDB connection for wiki generation.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.8-rc.47",
+  "version": "1.6.8-rc.49",
   "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",