gitnexus 1.6.8-rc.46 → 1.6.8-rc.48

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/lbug/csv-generator.d.ts

@@ -55,5 +55,22 @@ export interface StreamedCSVResult {
  * Stream all CSV data directly to disk files.
  * Iterates graph nodes exactly ONCE — routes each node to the right writer.
  * File contents are lazy-read from disk with a generous LRU cache.
+ *
+ * `onNodePhaseComplete` (optional, #2203 parallelism leg): fired exactly once,
+ * right after every node CSV is fully flushed to disk and BEFORE the
+ * relationship pass starts writing any `rel_*.csv`. It receives the finished
+ * node-file manifest so the caller can begin `COPY`-ing nodes while this
+ * function keeps generating relationship CSVs (the only single-writer-safe
+ * overlap — node `COPY` ‖ relationship emit). It is intentionally NOT awaited:
+ * the relationship pass proceeds concurrently with whatever the caller
+ * schedules. A synchronous throw from the callback is allowed and propagates out
+ * of this function (rejecting the returned promise) — it is raised before the
+ * relationship pass begins, so no `rel_*.csv` is written; `loadGraphToLbug` uses
+ * this to surface its PDG-manifest collision guard. The callback must NOT, however,
+ * schedule un-awaited async work that can reject unobserved. Absent ⇒ today's
+ * behavior, byte-for-byte.
  */
-export declare const streamAllCSVsToDisk: (graph: KnowledgeGraph, repoPath: string, csvDir: string) => Promise<StreamedCSVResult>;
+export declare const streamAllCSVsToDisk: (graph: KnowledgeGraph, repoPath: string, csvDir: string, onNodePhaseComplete?: (nodeFiles: Map<NodeTableName, {
+    csvPath: string;
+    rows: number;
+}>) => void) => Promise<StreamedCSVResult>;

package/dist/core/lbug/csv-generator.js

@@ -33,6 +33,14 @@ const orderedNodes = (graph, sorted) => sorted ? [...graph.iterNodes()].sort(byG
 const orderedRelationships = (graph, sorted) => sorted ? [...graph.iterRelationships()].sort(byGraphId) : graph.iterRelationships();
 /** Flush buffered rows to disk every N rows */
 const FLUSH_EVERY = 500;
+/**
+ * Yield the event loop every N relationship rows during the emit pass (#2226 F4)
+ * so a concurrent node COPY (the overlap in loadGraphToLbug) and write-stream
+ * drain callbacks get scheduling time during long synchronous emit stretches.
+ * Scheduling-only — never changes row content or order (byte-identical). Tuning
+ * constant, not load-bearing.
+ */
+const REL_YIELD_EVERY = 5000;
 // ============================================================================
 // CSV ESCAPE UTILITIES
 // ============================================================================
@@ -239,8 +247,22 @@ export const buildBasicBlockRow = (node) => [
  * Stream all CSV data directly to disk files.
  * Iterates graph nodes exactly ONCE — routes each node to the right writer.
  * File contents are lazy-read from disk with a generous LRU cache.
+ *
+ * `onNodePhaseComplete` (optional, #2203 parallelism leg): fired exactly once,
+ * right after every node CSV is fully flushed to disk and BEFORE the
+ * relationship pass starts writing any `rel_*.csv`. It receives the finished
+ * node-file manifest so the caller can begin `COPY`-ing nodes while this
+ * function keeps generating relationship CSVs (the only single-writer-safe
+ * overlap — node `COPY` ‖ relationship emit). It is intentionally NOT awaited:
+ * the relationship pass proceeds concurrently with whatever the caller
+ * schedules. A synchronous throw from the callback is allowed and propagates out
+ * of this function (rejecting the returned promise) — it is raised before the
+ * relationship pass begins, so no `rel_*.csv` is written; `loadGraphToLbug` uses
+ * this to surface its PDG-manifest collision guard. The callback must NOT, however,
+ * schedule un-awaited async work that can reject unobserved. Absent ⇒ today's
+ * behavior, byte-for-byte.
  */
-export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
+export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseComplete) => {
     // Deterministic (id-sorted) node/relationship row order when enabled;
     // default off = today's graph-insertion order (byte-identical).
     const sortOutput = parseTruthyEnv(process.env.GITNEXUS_SORT_GRAPH_OUTPUT);
@@ -502,30 +524,11 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
             ...multiLangWriters.values(),
         ];
         await Promise.all(allWriters.map((w) => w.finish()));
-        // --- Stream relationships directly to per-FROM→TO-label-pair files ---
-        // (#2203 U2) Route every edge to its pair file in this single pass. The old
-        // monolithic relations.csv — and its line-by-line re-read + per-edge regex
-        // re-split in loadGraphToLbug — are gone, so the ~1M-edge set is written and
-        // read once instead of twice. The router applies the SAME label-derivation +
-        // validTables filter as the legacy splitRelCsvByLabelPair, so the per-pair
-        // files are byte-identical (asserted by the differential test).
-        const relRouter = new RelPairRouter(csvDir, REL_CSV_HEADER, new Set(NODE_TABLES));
-        try {
-            for (const rel of orderedRelationships(graph, sortOutput)) {
-                const pending = relRouter.route(rel.sourceId, rel.targetId, buildRelRow(rel));
-                if (pending)
-                    await pending;
-            }
-            await relRouter.close();
-        }
-        catch (err) {
-            relRouter.destroy();
-            // Rethrow the real stream error (EMFILE / disk-full) rather than the generic
-            // AbortError a pending drain-await rejects with — mirrors the retained
-            // splitRelCsvByLabelPair's `throw streamError ?? err`.
-            throw relRouter.lastError ?? err;
-        }
-        // Build result map — only include tables that have rows
+        // Build the node-file manifest now (all writers are flushed; `.rows` is
+        // final). Hoisted above the relationship pass so `onNodePhaseComplete` can
+        // hand the caller a complete node manifest to start COPY-ing while we keep
+        // generating relationship CSVs below (#2203 overlap). The same map is
+        // returned, so the result is unchanged when no callback is supplied.
         const nodeFiles = new Map();
         const tableMap = [
             ['File', fileWriter],
@@ -551,6 +554,38 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 });
             }
         }
+        // Node CSVs are on disk; relationship CSVs have not been touched yet. Hand
+        // the manifest to the caller (not awaited — the rel pass runs concurrently).
+        onNodePhaseComplete?.(nodeFiles);
+        // --- Stream relationships directly to per-FROM→TO-label-pair files ---
+        // (#2203 U2) Route every edge to its pair file in this single pass. The old
+        // monolithic relations.csv — and its line-by-line re-read + per-edge regex
+        // re-split in loadGraphToLbug — are gone, so the ~1M-edge set is written and
+        // read once instead of twice. The router applies the SAME label-derivation +
+        // validTables filter as the legacy splitRelCsvByLabelPair, so the per-pair
+        // files are byte-identical (asserted by the differential test).
+        const relRouter = new RelPairRouter(csvDir, REL_CSV_HEADER, new Set(NODE_TABLES));
+        try {
+            let emitted = 0;
+            for (const rel of orderedRelationships(graph, sortOutput)) {
+                const pending = relRouter.route(rel.sourceId, rel.targetId, buildRelRow(rel));
+                if (pending)
+                    await pending;
+                // Periodically hand the event loop back so the overlapped node COPY and
+                // write-stream drains run instead of starving behind this synchronous
+                // loop (#2226 F4). No effect on emitted bytes — pure scheduling.
+                if (++emitted % REL_YIELD_EVERY === 0)
+                    await new Promise((r) => setImmediate(r));
+            }
+            await relRouter.close();
+        }
+        catch (err) {
+            relRouter.destroy();
+            // Rethrow the real stream error (EMFILE / disk-full) rather than the generic
+            // AbortError a pending drain-await rejects with — mirrors the retained
+            // splitRelCsvByLabelPair's `throw streamError ?? err`.
+            throw relRouter.lastError ?? err;
+        }
         return {
             nodeFiles,
             relsByPair: relRouter.byPair,

package/dist/core/lbug/lbug-adapter.d.ts

@@ -1,5 +1,6 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
+import { NodeTableName } from './schema.js';
 import type { PdgEmitManifest } from './pdg-emit-sink.js';
 import type { CachedEmbedding } from '../embeddings/types.js';
 import { type ExtensionEnsureOptions } from './extension-loader.js';
@@ -54,6 +55,18 @@ export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>
     readOnly?: boolean;
 }) => Promise<T>;
 export type LbugProgressCallback = (message: string) => void;
+/**
+ * Persist a KnowledgeGraph: stream CSVs, then bulk-COPY nodes (overlapped with
+ * relationship emit — see the body) and relationships.
+ *
+ * NOT TRANSACTIONAL (#2226). Each `COPY` commits independently and there is no
+ * surrounding transaction, so a failure partway through — a node `COPY` that
+ * throws at the FK barrier, a relationship `COPY` failure, or a `pdgEmitManifest`
+ * collision raised after node rows have already committed in the overlap path —
+ * leaves a partially-loaded DB. The caller surfaces the error; recovery is a
+ * `--force` re-analyze (a full rebuild), not a partial retry. Callers must not
+ * assume the DB is either fully loaded or untouched after a rejection.
+ */
 export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback, 
 /**
  * Streamed PDG-emit manifest (#2202). When present (streaming was on, full
@@ -69,6 +82,8 @@ pdgEmitManifest?: PdgEmitManifest) => Promise<{
     skippedRels: number;
     warnings: string[];
 }>;
+export declare const COPY_CSV_OPTS = "(HEADER=true, ESCAPE='\"', DELIM=',', QUOTE='\"', PARALLEL=false, auto_detect=false)";
+export declare const getCopyQuery: (table: NodeTableName, filePath: string) => string;
 /**
  * Insert a single node to LadybugDB
  * @param label - Node type (File, Function, Class, etc.)

package/dist/core/lbug/lbug-adapter.js

@@ -740,6 +740,60 @@ const doInitLbug = async (dbPath, readOnly = false) => {
     currentDbPath = dbPath;
     return { db, conn };
 };
+/**
+ * Run a COPY, retrying once with IGNORE_ERRORS=true (which skips row-level
+ * errors) on first failure. On a second failure, hand the RAW retry error to
+ * `onError` — each call site formats + slices its own message (#2226 F5: node
+ * COPY slices to 200 chars and throws; relationship COPY slices to 80 and warns,
+ * so the helper must not pre-format and lose that distinction). `onError` may
+ * throw to propagate the failure.
+ */
+const copyCsvWithRetry = async (targetConn, copyQuery, onError) => {
+    try {
+        await queryAndDrain(targetConn, copyQuery);
+    }
+    catch {
+        try {
+            const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
+            await queryAndDrain(targetConn, retryQuery);
+        }
+        catch (retryErr) {
+            onError(retryErr);
+        }
+    }
+};
+/**
+ * Bulk-COPY every node CSV sequentially on the single writable connection
+ * (LadybugDB allows one write txn at a time). Extracted from loadGraphToLbug so
+ * it can run either at the node-phase boundary — overlapping the relationship
+ * emit pass (#2203) — or after emit in the serial escape-hatch path. Each COPY
+ * keeps the IGNORE_ERRORS=true retry; a hard failure throws (no node rows ⇒ the
+ * relationship COPY would dangle on missing endpoints).
+ */
+const copyNodeCSVs = async (targetConn, nodeFileEntries, log, totalSteps) => {
+    let stepsDone = 0;
+    for (const [table, { csvPath, rows }] of nodeFileEntries) {
+        stepsDone++;
+        log(`Loading nodes ${stepsDone}/${totalSteps}: ${table} (${rows.toLocaleString()} rows)`);
+        const copyQuery = getCopyQuery(table, normalizeCopyPath(csvPath));
+        await copyCsvWithRetry(targetConn, copyQuery, (retryErr) => {
+            const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+            throw new Error(`COPY failed for ${table}: ${retryMsg.slice(0, 200)}`);
+        });
+    }
+};
+/**
+ * Persist a KnowledgeGraph: stream CSVs, then bulk-COPY nodes (overlapped with
+ * relationship emit — see the body) and relationships.
+ *
+ * NOT TRANSACTIONAL (#2226). Each `COPY` commits independently and there is no
+ * surrounding transaction, so a failure partway through — a node `COPY` that
+ * throws at the FK barrier, a relationship `COPY` failure, or a `pdgEmitManifest`
+ * collision raised after node rows have already committed in the overlap path —
+ * leaves a partially-loaded DB. The caller surfaces the error; recovery is a
+ * `--force` re-analyze (a full rebuild), not a partial retry. Callers must not
+ * assume the DB is either fully loaded or untouched after a rejection.
+ */
 export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress, 
 /**
  * Streamed PDG-emit manifest (#2202). When present (streaming was on, full
@@ -761,31 +815,87 @@ pdgEmitManifest) => {
     // the gap that the DB-persistence path is un-timed today (the analyze
     // "emit" number is the scope-resolution emit bucket, not this COPY path).
     const PROF = process.env.PROF_LBUG_LOAD === '1';
+    // Escape hatch / differential oracle (#2203): force the legacy strictly-serial
+    // load order (emit everything, THEN COPY nodes, THEN COPY rels) instead of the
+    // default node-COPY ‖ rel-emit overlap. Lets an operator revert the behavior at
+    // runtime, and lets a test load the same graph both ways and assert identical
+    // persisted content.
+    const SERIAL = process.env.GITNEXUS_SERIAL_LBUG_LOAD === '1';
     const mark = () => (PROF ? process.hrtime.bigint() : 0n);
     const span = (a, b) => (Number(b - a) / 1e6).toFixed(1);
     const tStart = mark();
     const csvDir = resolveNativeSafeStorageDir(storagePath, 'csv');
-    log('Streaming CSVs to disk...');
-    const csvResult = await streamAllCSVsToDisk(graph, repoPath, csvDir);
-    // Merge the streamed PDG-emit CSVs (#2202) into the COPY plan so the
-    // BasicBlock node table + per-pair PDG edges (CFG / REACHING_DEF / CDG /
-    // POST_DOMINATE / TAINTED / SANITIZES) load through the SAME node + per-pair
-    // COPY loops as the structural CSVs. The graph held zero BasicBlocks when
-    // streaming, so `streamAllCSVsToDisk` produced none of these — the manifest
-    // is the sole source and there is no double-COPY. Absent ⇒ no-op.
-    if (pdgEmitManifest) {
+    // The single writable connection (LadybugDB is single-writer). Captured as a
+    // const so the node-COPY closure has a non-null reference — TS cannot narrow
+    // the reassignable module-level `conn` across the callback boundary.
+    const writeConn = conn;
+    const validTables = new Set(NODE_TABLES);
+    // Merge the streamed PDG-emit node CSVs (#2202) into a node-file map. Collision
+    // guard: a BasicBlock in the in-memory graph during a streamed run is an
+    // invariant violation (streamAllCSVsToDisk would also emit basicblock.csv), so
+    // fail loudly rather than drop rows (#2202 review #3). Runs at the node-phase
+    // boundary so the manifest BasicBlock table COPYs with the structural CSVs.
+    const mergeManifestNodeFiles = (nodeFilesMap) => {
+        if (!pdgEmitManifest)
+            return;
         for (const [table, meta] of pdgEmitManifest.nodeFiles) {
-            // A collision means a BasicBlock leaked into the in-memory graph during a
-            // streamed run (streamAllCSVsToDisk then emitted a structural basicblock.csv).
-            // That is a streaming-invariant violation — fail loudly rather than
-            // silently overwrite one CSV with the other and drop its rows (#2202 review #3).
-            if (csvResult.nodeFiles.has(table)) {
+            if (nodeFilesMap.has(table)) {
                 throw new Error(`Streaming PDG manifest collides with a structural node CSV for "${table}" — ` +
                     `the in-memory graph should hold zero ${table} nodes when streaming. ` +
                     `A ${table} node leaked into the graph during a streamed emit.`);
             }
-            csvResult.nodeFiles.set(table, meta);
+            nodeFilesMap.set(table, meta);
         }
+    };
+    // Node COPY is the only DB write that can overlap relationship CSV emit: the
+    // rel pass writes new rel_*.csv files and never touches `conn`, while node COPY
+    // uses `conn` and never touches the rel files. We start node COPY at the
+    // node-phase boundary and let the rel pass run concurrently — the only
+    // single-writer-safe parallelism (#2203). The rel COPY still waits for node
+    // COPY (FK precondition), so the DB load order is unchanged.
+    let nodeCopyPromise;
+    let nodeCopyError;
+    const beginNodeCopy = (nodeFilesMap) => {
+        mergeManifestNodeFiles(nodeFilesMap);
+        const entries = [...nodeFilesMap.entries()];
+        // copyNodeCSVs logs node progress as step/total; it processes only node
+        // tables (the rel COPY has its own "Loading edges" progress line), so the
+        // denominator is the node-table count — not +1 reserving a rel step.
+        // .catch captures the failure so an overlapped (mid-emit) rejection cannot
+        // surface as an unhandled rejection; it is rethrown at the FK barrier below.
+        nodeCopyPromise = copyNodeCSVs(writeConn, entries, log, entries.length).catch((e) => {
+            nodeCopyError = e;
+        });
+    };
+    log('Streaming CSVs to disk...');
+    let csvResult;
+    try {
+        csvResult = SERIAL
+            ? await streamAllCSVsToDisk(graph, repoPath, csvDir)
+            : await streamAllCSVsToDisk(graph, repoPath, csvDir, beginNodeCopy);
+    }
+    catch (emitErr) {
+        // Relationship emit failed. In overlap mode a node COPY may be in flight —
+        // settle it (the .catch above means this never rejects) before rethrowing so
+        // it cannot leak as an unhandled rejection.
+        if (nodeCopyPromise)
+            await nodeCopyPromise;
+        // If node COPY ALSO failed, emitErr wins the throw — log the swallowed node
+        // error so a half-loaded DB isn't misattributed to the emit failure alone.
+        if (nodeCopyError) {
+            logger.warn({ err: nodeCopyError }, '[lbug-load] node COPY also failed while relationship emit was failing');
+        }
+        throw emitErr;
+    }
+    const tCsv = mark();
+    // Merge the streamed PDG-emit per-pair rel CSVs (#2202) into the COPY plan —
+    // collision-guarded. Done BEFORE node COPY so the serial escape hatch detects a
+    // manifest/structural pair collision before committing any node rows (legacy
+    // parity with the pre-overlap path), and the overlap path detects it as early
+    // as csvResult is available. When a manifest is present, streaming was on and
+    // the in-memory graph held zero BasicBlocks, so a structural collision means a
+    // streaming-invariant violation — fail loudly rather than load corrupt data.
+    if (pdgEmitManifest) {
         for (const [pairKey, meta] of pdgEmitManifest.relsByPair) {
             if (csvResult.relsByPair.has(pairKey)) {
                 throw new Error(`Streaming PDG manifest collides with a structural relationship CSV for pair ` +
@@ -795,30 +905,17 @@ pdgEmitManifest) => {
             csvResult.totalValidRels += meta.rows;
         }
     }
-    const tCsv = mark();
-    const validTables = new Set(NODE_TABLES);
-    // Bulk COPY all node CSVs (sequential — LadybugDB allows only one write txn at a time)
-    const nodeFiles = [...csvResult.nodeFiles.entries()];
-    const totalSteps = nodeFiles.length + 1; // +1 for relationships
-    let stepsDone = 0;
-    for (const [table, { csvPath, rows }] of nodeFiles) {
-        stepsDone++;
-        log(`Loading nodes ${stepsDone}/${totalSteps}: ${table} (${rows.toLocaleString()} rows)`);
-        const normalizedPath = normalizeCopyPath(csvPath);
-        const copyQuery = getCopyQuery(table, normalizedPath);
-        try {
-            await queryAndDrain(conn, copyQuery);
-        }
-        catch (err) {
-            try {
-                const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                await queryAndDrain(conn, retryQuery);
-            }
-            catch (retryErr) {
-                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                throw new Error(`COPY failed for ${table}: ${retryMsg.slice(0, 200)}`);
-            }
-        }
+    // Serial path: all CSVs are on disk and node COPY has not started — start it
+    // here so the barrier below blocks on it exactly as the legacy path did.
+    if (SERIAL)
+        beginNodeCopy(csvResult.nodeFiles);
+    // FK barrier: node rows must exist before the relationship COPY resolves their
+    // endpoints. In overlap mode most of node COPY was hidden behind rel emit, so
+    // this await is the *residual* node-COPY time (≈0 when fully overlapped).
+    if (nodeCopyPromise)
+        await nodeCopyPromise;
+    if (nodeCopyError) {
+        throw nodeCopyError instanceof Error ? nodeCopyError : new Error(String(nodeCopyError));
     }
     const tCopyNodes = mark();
     // Bulk COPY relationships. They were already routed to per-FROM→TO-label-pair
@@ -838,25 +935,17 @@ pdgEmitManifest) => {
             pairIdx++;
             const [fromLabel, toLabel] = pairKey.split('|');
             const normalizedPath = normalizeCopyPath(pairCsvPath);
+            // PARALLEL=false is load-bearing here too — see COPY_CSV_OPTS (#2203 / kuzudb/kuzu#5778).
             const copyQuery = `COPY ${REL_TABLE_NAME} FROM "${normalizedPath}" (from="${fromLabel}", to="${toLabel}", HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
             if (pairIdx % 5 === 0 || rows > 1000) {
                 log(`Loading edges: ${pairIdx}/${relsByPair.size} types (${fromLabel} -> ${toLabel})`);
             }
-            try {
-                await queryAndDrain(conn, copyQuery);
-            }
-            catch (err) {
-                try {
-                    const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                    await queryAndDrain(conn, retryQuery);
-                }
-                catch (retryErr) {
-                    const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                    warnings.push(`${fromLabel}->${toLabel} (${rows} edges): ${retryMsg.slice(0, 80)}`);
-                    failedPairEdges += rows;
-                    failedPairCsvPaths.add(pairCsvPath);
-                }
-            }
+            await copyCsvWithRetry(conn, copyQuery, (retryErr) => {
+                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                warnings.push(`${fromLabel}->${toLabel} (${rows} edges): ${retryMsg.slice(0, 80)}`);
+                failedPairEdges += rows;
+                failedPairCsvPaths.add(pairCsvPath);
+            });
             // Only delete if not in failedPairCsvPaths (needed for fallback)
             if (!failedPairCsvPaths.has(pairCsvPath)) {
                 try {
@@ -919,7 +1008,12 @@ pdgEmitManifest) => {
         let totalNodeRows = 0;
         for (const [, { rows }] of csvResult.nodeFiles)
             totalNodeRows += rows;
-        logger.warn(`[lbug-load prof] csv-emit=${span(tStart, tCsv)}ms ` +
+        // `mode` records which load path ran. In overlap mode `csv-emit` is the wall
+        // to streamAllCSVsToDisk's return (node COPY overlapped part of it) and
+        // `copy-nodes` is the RESIDUAL node-COPY await after emit returned — it
+        // trends to 0 as the overlap hides node COPY behind relationship emit. In
+        // serial mode the buckets carry their legacy, disjoint meaning.
+        logger.warn(`[lbug-load prof] mode=${SERIAL ? 'serial' : 'overlap'} csv-emit=${span(tStart, tCsv)}ms ` +
             `copy-nodes=${span(tCsv, tCopyNodes)}ms copy-rels=${span(tCopyNodes, tCopyRels)}ms ` +
             `fallback=${span(tCopyRels, tFallback)}ms total=${span(tStart, tEnd)}ms ` +
             `(${totalNodeRows} nodes, ${insertedRels} rels)`);
@@ -930,7 +1024,18 @@ pdgEmitManifest) => {
 // Source code content is full of backslashes which confuse the auto-detection.
 // We MUST explicitly set ESCAPE='"' to use RFC 4180 escaping, and disable auto_detect to prevent
 // LadybugDB from overriding our settings based on sample rows.
-const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
+//
+// PARALLEL=false IS LOAD-BEARING FOR CORRECTNESS — DO NOT FLIP IT (#2203).
+// LadybugDB's parallel CSV reader (Kuzu-derived; default PARALLEL=true) splits the
+// file into byte ranges parsed concurrently, and CANNOT determine line boundaries
+// when a quoted field contains an embedded newline — it errors with "Quoted newlines
+// are not supported in parallel CSV reader. Please specify PARALLEL=FALSE", or worse,
+// mis-parses silently (upstream kuzudb/kuzu#5778, still open). Our `content`/`text`
+// columns hold source code, so quoted multiline fields are guaranteed. PARALLEL=false
+// is therefore required, not conservative. The multiline-quoted round-trip in
+// test/integration/copy-parallel-invariant.test.ts fails loudly if this is ever flipped.
+// Exported so that test asserts the invariant statically as well.
+export const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
 // Multi-language table names that were created with backticks in CODE_ELEMENT_BASE
 // and must always be referenced with backticks in queries
 const BACKTICK_TABLES = new Set([
@@ -996,7 +1101,7 @@ const TABLES_WITH_EXPORTED = new Set([
     'Method',
     'CodeElement',
 ]);
-const getCopyQuery = (table, filePath) => {
+export const getCopyQuery = (table, filePath) => {
     const t = escapeTableName(table);
     if (table === 'File') {
         return `COPY ${t}(id, name, filePath, content) FROM "${filePath}" ${COPY_CSV_OPTS}`;

package/package.json

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