gitnexus 1.6.8-rc.39 → 1.6.8-rc.40

package/dist/core/lbug/csv-generator.d.ts

@@ -11,19 +11,36 @@
  * - Double quotes within fields are escaped by doubling them ("")
  * - All fields are consistently quoted for safety with code content
  */
+import type { GraphRelationship } from '../../_shared/index.js';
 import { KnowledgeGraph } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
 export declare const sanitizeUTF8: (str: string) => string;
 export declare const escapeCSVField: (value: string | number | undefined | null) => string;
 export declare const escapeCSVNumber: (value: number | undefined | null, defaultValue?: number) => string;
 export declare const isBinaryContent: (content: string) => boolean;
+/** Canonical relationship CSV header — shared by the emit pass and the
+ * `splitRelCsvByLabelPair` differential oracle. */
+export declare const REL_CSV_HEADER = "from,to,type,confidence,reason,step";
+/** Build the escaped CSV row (no trailing newline) for one relationship.
+ * Single source of the relationship row bytes — used by the emit pass and by
+ * the byte-identity differential test that feeds the legacy split oracle. */
+export declare const buildRelRow: (rel: GraphRelationship) => string;
 export interface StreamedCSVResult {
     nodeFiles: Map<NodeTableName, {
         csvPath: string;
         rows: number;
     }>;
-    relCsvPath: string;
-    relRows: number;
+    /** pairKey (`From|To`) → per-FROM→TO-label-pair CSV file. */
+    relsByPair: Map<string, {
+        csvPath: string;
+        rows: number;
+    }>;
+    /** Header line shared by every per-pair file. */
+    relHeader: string;
+    /** Edges skipped because an endpoint label is not a valid node table. */
+    skippedRels: number;
+    /** Edges routed to a per-pair file. */
+    totalValidRels: number;
 }
 /**
  * Stream all CSV data directly to disk files.

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

@@ -14,6 +14,8 @@
 import fs from 'fs/promises';
 import { createWriteStream } from 'fs';
 import path from 'path';
+import { NODE_TABLES } from './schema.js';
+import { RelPairRouter } from './rel-pair-routing.js';
 import { parseTruthyEnv } from '../ingestion/utils/env.js';
 /**
  * Deterministic output ordering — optional (out-of-core / windowed-resolve
@@ -158,13 +160,20 @@ class BufferedCSVWriter {
         this.ws.setMaxListeners(50);
         this.buffer.push(header);
     }
+    /**
+     * Buffer a row. Returns a promise ONLY when the buffer crossed FLUSH_EVERY
+     * and a disk write was issued; otherwise returns `undefined` so the caller
+     * can skip awaiting (#2203 U3) — avoiding a microtask tick on every buffered
+     * row (millions at scale). The flush promise still resolves on drain, so
+     * backpressure is preserved on the rows that actually write.
+     */
     addRow(row) {
         this.buffer.push(row);
         this.rows++;
         if (this.buffer.length >= FLUSH_EVERY) {
             return this.flush();
         }
-        return Promise.resolve();
+        return undefined;
     }
     flush() {
         if (this.buffer.length === 0)
@@ -194,6 +203,23 @@ class BufferedCSVWriter {
         });
     }
 }
+// ============================================================================
+// STREAMING CSV GENERATION — SINGLE PASS
+// ============================================================================
+/** Canonical relationship CSV header — shared by the emit pass and the
+ * `splitRelCsvByLabelPair` differential oracle. */
+export const REL_CSV_HEADER = 'from,to,type,confidence,reason,step';
+/** Build the escaped CSV row (no trailing newline) for one relationship.
+ * Single source of the relationship row bytes — used by the emit pass and by
+ * the byte-identity differential test that feeds the legacy split oracle. */
+export const buildRelRow = (rel) => [
+    escapeCSVField(rel.sourceId),
+    escapeCSVField(rel.targetId),
+    escapeCSVField(rel.type),
+    escapeCSVNumber(rel.confidence, 1.0),
+    escapeCSVField(rel.reason),
+    escapeCSVNumber(rel.step, 0),
+].join(',');
 /**
  * Stream all CSV data directly to disk files.
  * Iterates graph nodes exactly ONCE — routes each node to the right writer.
@@ -213,191 +239,131 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     // MaxListenersExceededWarning (restored after all streams finish).
     const prevMax = process.getMaxListeners();
     process.setMaxListeners(prevMax + 40);
-    const contentCache = new FileContentCache(repoPath);
-    // Create writers for every node type up-front
-    const fileWriter = new BufferedCSVWriter(path.join(csvDir, 'file.csv'), 'id,name,filePath,content');
-    const folderWriter = new BufferedCSVWriter(path.join(csvDir, 'folder.csv'), 'id,name,filePath');
-    const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description';
-    const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader);
-    const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), codeElementHeader);
-    const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader);
-    const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
-    const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), methodHeader);
-    const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader);
-    const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
-    const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
-    // Section nodes have an extra 'level' column
-    const sectionWriter = new BufferedCSVWriter(path.join(csvDir, 'section.csv'), 'id,name,filePath,startLine,endLine,level,content,description');
-    // Route nodes for API endpoint mapping
-    const routeWriter = new BufferedCSVWriter(path.join(csvDir, 'route.csv'), 'id,name,filePath,responseKeys,errorKeys,middleware');
-    // Tool nodes for MCP tool definitions
-    const toolWriter = new BufferedCSVWriter(path.join(csvDir, 'tool.csv'), 'id,name,filePath,description');
-    // BasicBlock nodes — taint/PDG substrate (issue #2080). No `name` column;
-    // blocks are identified by id + source span. Emitted by no phase yet.
-    const basicBlockWriter = new BufferedCSVWriter(path.join(csvDir, 'basicblock.csv'), 'id,filePath,startLine,endLine,text');
-    // Multi-language node types share the same CSV shape (no isExported column)
-    const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
-    const MULTI_LANG_TYPES = [
-        'Struct',
-        'Enum',
-        'Macro',
-        'Typedef',
-        'Union',
-        'Namespace',
-        'Trait',
-        'Impl',
-        'TypeAlias',
-        'Const',
-        'Static',
-        'Variable',
-        'Property',
-        'Record',
-        'Delegate',
-        'Annotation',
-        'Constructor',
-        'Template',
-        'Module',
-    ];
-    const propertyHeader = 'id,name,filePath,startLine,endLine,content,description,declaredType';
-    const multiLangWriters = new Map();
-    for (const t of MULTI_LANG_TYPES) {
-        multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : multiLangHeader));
-    }
-    const codeWriterMap = {
-        Function: functionWriter,
-        Class: classWriter,
-        Interface: interfaceWriter,
-        CodeElement: codeElemWriter,
-    };
-    // Deduplicate all node types — the pipeline can produce duplicate IDs across
-    // all symbol types (Class, Method, Function, etc.), not just File nodes.
-    // A single Set covering every label prevents PK violations on COPY.
-    const seenNodeIds = new Set();
-    // --- SINGLE PASS over all nodes ---
-    for (const node of orderedNodes(graph, sortOutput)) {
-        if (seenNodeIds.has(node.id))
-            continue;
-        seenNodeIds.add(node.id);
-        switch (node.label) {
-            case 'File': {
-                const content = await extractContent(node, contentCache);
-                await fileWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVField(content),
-                ].join(','));
-                break;
-            }
-            case 'Folder':
-                await folderWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                ].join(','));
-                break;
-            case 'Community': {
-                const keywords = node.properties.keywords || [];
-                const keywordsStr = `[${keywords.map((k) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`;
-                await communityWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.heuristicLabel || ''),
-                    keywordsStr,
-                    escapeCSVField(node.properties.description || ''),
-                    escapeCSVField(node.properties.enrichedBy || 'heuristic'),
-                    escapeCSVNumber(node.properties.cohesion, 0),
-                    escapeCSVNumber(node.properties.symbolCount, 0),
-                ].join(','));
-                break;
-            }
-            case 'Process': {
-                const communities = node.properties.communities || [];
-                const communitiesStr = `[${communities.map((c) => `'${c.replace(/'/g, "''")}'`).join(',')}]`;
-                await processWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.heuristicLabel || ''),
-                    escapeCSVField(node.properties.processType || ''),
-                    escapeCSVNumber(node.properties.stepCount, 0),
-                    escapeCSVField(communitiesStr),
-                    escapeCSVField(node.properties.entryPointId || ''),
-                    escapeCSVField(node.properties.terminalId || ''),
-                ].join(','));
-                break;
-            }
-            case 'Method': {
-                const content = await extractContent(node, contentCache);
-                await methodWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVNumber(node.properties.startLine, -1),
-                    escapeCSVNumber(node.properties.endLine, -1),
-                    node.properties.isExported ? 'true' : 'false',
-                    escapeCSVField(content),
-                    escapeCSVField(node.properties.description || ''),
-                    escapeCSVNumber(node.properties.parameterCount, 0),
-                    escapeCSVField(node.properties.returnType || ''),
-                ].join(','));
-                break;
-            }
-            case 'Section': {
-                const content = await extractContent(node, contentCache);
-                await sectionWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVNumber(node.properties.startLine, -1),
-                    escapeCSVNumber(node.properties.endLine, -1),
-                    escapeCSVNumber(node.properties.level, 1),
-                    escapeCSVField(content),
-                    escapeCSVField(node.properties.description || ''),
-                ].join(','));
-                break;
-            }
-            case 'Route': {
-                const responseKeys = node.properties.responseKeys || [];
-                // LadybugDB array literal inside a quoted CSV field: escapeCSVField wraps in "..."
-                // and the array uses single-quoted elements
-                const keysStr = `[${responseKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
-                const errorKeys = node.properties.errorKeys || [];
-                const errorKeysStr = `[${errorKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
-                const middleware = node.properties.middleware || [];
-                const middlewareStr = `[${middleware.map((m) => `'${m.replace(/'/g, "''")}'`).join(',')}]`;
-                await routeWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVField(keysStr),
-                    escapeCSVField(errorKeysStr),
-                    escapeCSVField(middlewareStr),
-                ].join(','));
-                break;
-            }
-            case 'Tool':
-                await toolWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.name || ''),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVField(node.properties.description || ''),
-                ].join(','));
-                break;
-            case 'BasicBlock':
-                await basicBlockWriter.addRow([
-                    escapeCSVField(node.id),
-                    escapeCSVField(node.properties.filePath || ''),
-                    escapeCSVNumber(node.properties.startLine, -1),
-                    escapeCSVNumber(node.properties.endLine, -1),
-                    escapeCSVField(node.properties.text || ''),
-                ].join(','));
-                break;
-            default: {
-                // Code element nodes (Function, Class, Interface, CodeElement)
-                const writer = codeWriterMap[node.label];
-                if (writer) {
+    // try/finally so the listener bump is ALWAYS restored — including the
+    // rel-routing throw path (#2203 U2) and any node-writer finish() rejection,
+    // not just the success path (avoids leaking +40 listeners across failed runs
+    // in long-lived hosts / the test suite).
+    try {
+        const contentCache = new FileContentCache(repoPath);
+        // Create writers for every node type up-front
+        const fileWriter = new BufferedCSVWriter(path.join(csvDir, 'file.csv'), 'id,name,filePath,content');
+        const folderWriter = new BufferedCSVWriter(path.join(csvDir, 'folder.csv'), 'id,name,filePath');
+        const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description';
+        const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader);
+        const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), codeElementHeader);
+        const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader);
+        const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
+        const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), methodHeader);
+        const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader);
+        const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
+        const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
+        // Section nodes have an extra 'level' column
+        const sectionWriter = new BufferedCSVWriter(path.join(csvDir, 'section.csv'), 'id,name,filePath,startLine,endLine,level,content,description');
+        // Route nodes for API endpoint mapping
+        const routeWriter = new BufferedCSVWriter(path.join(csvDir, 'route.csv'), 'id,name,filePath,responseKeys,errorKeys,middleware');
+        // Tool nodes for MCP tool definitions
+        const toolWriter = new BufferedCSVWriter(path.join(csvDir, 'tool.csv'), 'id,name,filePath,description');
+        // BasicBlock nodes — taint/PDG substrate (issue #2080). No `name` column;
+        // blocks are identified by id + source span. Emitted by no phase yet.
+        const basicBlockWriter = new BufferedCSVWriter(path.join(csvDir, 'basicblock.csv'), 'id,filePath,startLine,endLine,text');
+        // Multi-language node types share the same CSV shape (no isExported column)
+        const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
+        const MULTI_LANG_TYPES = [
+            'Struct',
+            'Enum',
+            'Macro',
+            'Typedef',
+            'Union',
+            'Namespace',
+            'Trait',
+            'Impl',
+            'TypeAlias',
+            'Const',
+            'Static',
+            'Variable',
+            'Property',
+            'Record',
+            'Delegate',
+            'Annotation',
+            'Constructor',
+            'Template',
+            'Module',
+        ];
+        const propertyHeader = 'id,name,filePath,startLine,endLine,content,description,declaredType';
+        const multiLangWriters = new Map();
+        for (const t of MULTI_LANG_TYPES) {
+            multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : multiLangHeader));
+        }
+        const codeWriterMap = {
+            Function: functionWriter,
+            Class: classWriter,
+            Interface: interfaceWriter,
+            CodeElement: codeElemWriter,
+        };
+        // Deduplicate all node types — the pipeline can produce duplicate IDs across
+        // all symbol types (Class, Method, Function, etc.), not just File nodes.
+        // A single Set covering every label prevents PK violations on COPY.
+        const seenNodeIds = new Set();
+        // --- SINGLE PASS over all nodes ---
+        for (const node of orderedNodes(graph, sortOutput)) {
+            if (seenNodeIds.has(node.id))
+                continue;
+            seenNodeIds.add(node.id);
+            // addRow returns a promise only when it flushes; awaiting it once after the
+            // switch (instead of `await`-ing every addRow) skips a per-row microtask
+            // tick on the ~FLUSH_EVERY-1 buffered rows between flushes (#2203 U3).
+            let pending;
+            switch (node.label) {
+                case 'File': {
                     const content = await extractContent(node, contentCache);
-                    await writer.addRow([
+                    pending = fileWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVField(content),
+                    ].join(','));
+                    break;
+                }
+                case 'Folder':
+                    pending = folderWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                    ].join(','));
+                    break;
+                case 'Community': {
+                    const keywords = node.properties.keywords || [];
+                    const keywordsStr = `[${keywords.map((k) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`;
+                    pending = communityWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.heuristicLabel || ''),
+                        keywordsStr,
+                        escapeCSVField(node.properties.description || ''),
+                        escapeCSVField(node.properties.enrichedBy || 'heuristic'),
+                        escapeCSVNumber(node.properties.cohesion, 0),
+                        escapeCSVNumber(node.properties.symbolCount, 0),
+                    ].join(','));
+                    break;
+                }
+                case 'Process': {
+                    const communities = node.properties.communities || [];
+                    const communitiesStr = `[${communities.map((c) => `'${c.replace(/'/g, "''")}'`).join(',')}]`;
+                    pending = processWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.heuristicLabel || ''),
+                        escapeCSVField(node.properties.processType || ''),
+                        escapeCSVNumber(node.properties.stepCount, 0),
+                        escapeCSVField(communitiesStr),
+                        escapeCSVField(node.properties.entryPointId || ''),
+                        escapeCSVField(node.properties.terminalId || ''),
+                    ].join(','));
+                    break;
+                }
+                case 'Method': {
+                    const content = await extractContent(node, contentCache);
+                    pending = methodWriter.addRow([
                         escapeCSVField(node.id),
                         escapeCSVField(node.properties.name || ''),
                         escapeCSVField(node.properties.filePath || ''),
@@ -406,90 +372,186 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                         node.properties.isExported ? 'true' : 'false',
                         escapeCSVField(content),
                         escapeCSVField(node.properties.description || ''),
+                        escapeCSVNumber(node.properties.parameterCount, 0),
+                        escapeCSVField(node.properties.returnType || ''),
+                    ].join(','));
+                    break;
+                }
+                case 'Section': {
+                    const content = await extractContent(node, contentCache);
+                    pending = sectionWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVNumber(node.properties.startLine, -1),
+                        escapeCSVNumber(node.properties.endLine, -1),
+                        escapeCSVNumber(node.properties.level, 1),
+                        escapeCSVField(content),
+                        escapeCSVField(node.properties.description || ''),
                     ].join(','));
+                    break;
                 }
-                else {
-                    // Multi-language node types (Struct, Impl, Trait, Macro, etc.)
-                    const mlWriter = multiLangWriters.get(node.label);
-                    if (mlWriter) {
+                case 'Route': {
+                    const responseKeys = node.properties.responseKeys || [];
+                    // LadybugDB array literal inside a quoted CSV field: escapeCSVField wraps in "..."
+                    // and the array uses single-quoted elements
+                    const keysStr = `[${responseKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+                    const errorKeys = node.properties.errorKeys || [];
+                    const errorKeysStr = `[${errorKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+                    const middleware = node.properties.middleware || [];
+                    const middlewareStr = `[${middleware.map((m) => `'${m.replace(/'/g, "''")}'`).join(',')}]`;
+                    pending = routeWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVField(keysStr),
+                        escapeCSVField(errorKeysStr),
+                        escapeCSVField(middlewareStr),
+                    ].join(','));
+                    break;
+                }
+                case 'Tool':
+                    pending = toolWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVField(node.properties.description || ''),
+                    ].join(','));
+                    break;
+                case 'BasicBlock':
+                    pending = basicBlockWriter.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVNumber(node.properties.startLine, -1),
+                        escapeCSVNumber(node.properties.endLine, -1),
+                        escapeCSVField(node.properties.text || ''),
+                    ].join(','));
+                    break;
+                default: {
+                    // Code element nodes (Function, Class, Interface, CodeElement)
+                    const writer = codeWriterMap[node.label];
+                    if (writer) {
                         const content = await extractContent(node, contentCache);
-                        await mlWriter.addRow([
+                        pending = writer.addRow([
                             escapeCSVField(node.id),
                             escapeCSVField(node.properties.name || ''),
                             escapeCSVField(node.properties.filePath || ''),
                             escapeCSVNumber(node.properties.startLine, -1),
                             escapeCSVNumber(node.properties.endLine, -1),
+                            node.properties.isExported ? 'true' : 'false',
                             escapeCSVField(content),
                             escapeCSVField(node.properties.description || ''),
-                            ...(node.label === 'Property'
-                                ? [escapeCSVField(node.properties.declaredType || '')]
-                                : []),
                         ].join(','));
                     }
+                    else {
+                        // Multi-language node types (Struct, Impl, Trait, Macro, etc.)
+                        const mlWriter = multiLangWriters.get(node.label);
+                        if (mlWriter) {
+                            const content = await extractContent(node, contentCache);
+                            pending = mlWriter.addRow([
+                                escapeCSVField(node.id),
+                                escapeCSVField(node.properties.name || ''),
+                                escapeCSVField(node.properties.filePath || ''),
+                                escapeCSVNumber(node.properties.startLine, -1),
+                                escapeCSVNumber(node.properties.endLine, -1),
+                                escapeCSVField(content),
+                                escapeCSVField(node.properties.description || ''),
+                                ...(node.label === 'Property'
+                                    ? [escapeCSVField(node.properties.declaredType || '')]
+                                    : []),
+                            ].join(','));
+                        }
+                        else {
+                            // Unknown label: not in codeWriterMap or multiLangWriters, so there
+                            // is no CSV table for it and it is intentionally NOT persisted —
+                            // `pending` stays undefined, so the loop awaits nothing. Made
+                            // explicit so a future node type isn't silently dropped here: wire
+                            // it into one of the writer maps above (or this branch).
+                        }
+                    }
+                    break;
                 }
-                break;
             }
+            if (pending)
+                await pending;
         }
-    }
-    // Finish all node writers
-    const allWriters = [
-        fileWriter,
-        folderWriter,
-        functionWriter,
-        classWriter,
-        interfaceWriter,
-        methodWriter,
-        codeElemWriter,
-        communityWriter,
-        processWriter,
-        sectionWriter,
-        routeWriter,
-        toolWriter,
-        basicBlockWriter,
-        ...multiLangWriters.values(),
-    ];
-    await Promise.all(allWriters.map((w) => w.finish()));
-    // --- Stream relationship CSV ---
-    const relCsvPath = path.join(csvDir, 'relations.csv');
-    const relWriter = new BufferedCSVWriter(relCsvPath, 'from,to,type,confidence,reason,step');
-    for (const rel of orderedRelationships(graph, sortOutput)) {
-        await relWriter.addRow([
-            escapeCSVField(rel.sourceId),
-            escapeCSVField(rel.targetId),
-            escapeCSVField(rel.type),
-            escapeCSVNumber(rel.confidence, 1.0),
-            escapeCSVField(rel.reason),
-            escapeCSVNumber(rel.step, 0),
-        ].join(','));
-    }
-    await relWriter.finish();
-    // Build result map — only include tables that have rows
-    const nodeFiles = new Map();
-    const tableMap = [
-        ['File', fileWriter],
-        ['Folder', folderWriter],
-        ['Function', functionWriter],
-        ['Class', classWriter],
-        ['Interface', interfaceWriter],
-        ['Method', methodWriter],
-        ['CodeElement', codeElemWriter],
-        ['Community', communityWriter],
-        ['Process', processWriter],
-        ['Section', sectionWriter],
-        ['Route', routeWriter],
-        ['Tool', toolWriter],
-        ['BasicBlock', basicBlockWriter],
-        ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name, w]),
-    ];
-    for (const [name, writer] of tableMap) {
-        if (writer.rows > 0) {
-            nodeFiles.set(name, {
-                csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`),
-                rows: writer.rows,
-            });
+        // Finish all node writers
+        const allWriters = [
+            fileWriter,
+            folderWriter,
+            functionWriter,
+            classWriter,
+            interfaceWriter,
+            methodWriter,
+            codeElemWriter,
+            communityWriter,
+            processWriter,
+            sectionWriter,
+            routeWriter,
+            toolWriter,
+            basicBlockWriter,
+            ...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
+        const nodeFiles = new Map();
+        const tableMap = [
+            ['File', fileWriter],
+            ['Folder', folderWriter],
+            ['Function', functionWriter],
+            ['Class', classWriter],
+            ['Interface', interfaceWriter],
+            ['Method', methodWriter],
+            ['CodeElement', codeElemWriter],
+            ['Community', communityWriter],
+            ['Process', processWriter],
+            ['Section', sectionWriter],
+            ['Route', routeWriter],
+            ['Tool', toolWriter],
+            ['BasicBlock', basicBlockWriter],
+            ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name, w]),
+        ];
+        for (const [name, writer] of tableMap) {
+            if (writer.rows > 0) {
+                nodeFiles.set(name, {
+                    csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`),
+                    rows: writer.rows,
+                });
+            }
+        }
+        return {
+            nodeFiles,
+            relsByPair: relRouter.byPair,
+            relHeader: REL_CSV_HEADER,
+            skippedRels: relRouter.skipped,
+            totalValidRels: relRouter.total,
+        };
+    }
+    finally {
+        // Restore original process listener limit on every path (success or throw).
+        process.setMaxListeners(prevMax);
     }
-    // Restore original process listener limit
-    process.setMaxListeners(prevMax);
-    return { nodeFiles, relCsvPath, relRows: relWriter.rows };
 };

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

@@ -2,8 +2,6 @@ import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
 import type { CachedEmbedding } from '../embeddings/types.js';
 import { type ExtensionEnsureOptions } from './extension-loader.js';
-/** Factory for creating WriteStreams — injectable for testing. */
-export type WriteStreamFactory = (filePath: string) => import('fs').WriteStream;
 /** Result of splitting the relationship CSV into per-label-pair files. */
 export interface RelCsvSplitResult {
     relHeader: string;
@@ -15,21 +13,6 @@ export interface RelCsvSplitResult {
     skippedRels: number;
     totalValidRels: number;
 }
-/**
- * Split a relationship CSV into per-label-pair files on disk.
- *
- * Streams the CSV line-by-line, routing each relationship to a file named
- * `rel_{fromLabel}_{toLabel}.csv`. Handles backpressure correctly: only one
- * drain listener per stream at a time, and readline resumes only when ALL
- * backpressured streams have drained.
- *
- * @param csvPath       Path to the combined relationship CSV
- * @param csvDir        Directory to write per-pair CSV files
- * @param validTables   Set of valid node table names
- * @param getNodeLabel  Function to extract the label from a node ID
- * @param wsFactory     Optional WriteStream factory (defaults to fs.createWriteStream)
- */
-export declare const splitRelCsvByLabelPair: (csvPath: string, csvDir: string, validTables: Set<string>, getNodeLabel: (id: string) => string, wsFactory?: WriteStreamFactory) => Promise<RelCsvSplitResult>;
 /** Expose the current Database for pool adapter reuse in tests. */
 export declare const getDatabase: () => lbug.Database | null;
 /**

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

@@ -10,6 +10,7 @@ import lbug from '@ladybugdb/core';
 import { closeQueryResults } from './query-result-utils.js';
 import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, CREATE_VECTOR_INDEX_QUERY, STALE_HASH_SENTINEL, } from './schema.js';
 import { streamAllCSVsToDisk } from './csv-generator.js';
+import { getNodeLabel as deriveNodeLabel } from './rel-pair-routing.js';
 import { extensionManager } from './extension-loader.js';
 import { closeLbugConnection, isDbBusyError, isOpenRetryExhausted, isWalCorruptionError, openLbugConnection, toNativeSafePath, WAL_RECOVERY_SUGGESTION, waitForWindowsHandleRelease, } from './lbug-config.js';
 import { finalizeLbugSidecarsAfterClose, inspectLbugSidecars, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, shadowSidecarRecoveryMessage, } from './sidecar-recovery.js';
@@ -18,6 +19,15 @@ import { logger } from '../logger.js';
 /**
  * Split a relationship CSV into per-label-pair files on disk.
  *
+ * @internal RETAINED AS A DIFFERENTIAL ORACLE. As of #2203 U2, production emit
+ * routes relationships to per-pair files directly during the single pass (see
+ * RelPairRouter in `rel-pair-routing.ts`), so this function has NO production
+ * callers — it is kept ONLY so the byte-identity test in
+ * `test/integration/csv-pipeline.test.ts` ("direct per-pair emit matches the
+ * split oracle") can diff the direct-emit output against this proven path. Do
+ * NOT delete it as dead code without also removing that test and accepting the
+ * loss of the byte-identity guard (and likewise `test/unit/rel-csv-split.test.ts`).
+ *
  * Streams the CSV line-by-line, routing each relationship to a file named
  * `rel_{fromLabel}_{toLabel}.csv`. Handles backpressure correctly: only one
  * drain listener per stream at a time, and readline resumes only when ALL
@@ -737,6 +747,16 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const log = onProgress || (() => { });
+    // ── #2203 persistence-path profiling ──────────────────────────────────
+    // Mirrors the PROF_SCOPE_RESOLUTION pattern (scope-resolution/pipeline/
+    // run.ts): zero-cost when off — process.hrtime.bigint() is only read under
+    // PROF_LBUG_LOAD=1, and the summary is logged behind the same gate. Fills
+    // 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';
+    const mark = () => (PROF ? process.hrtime.bigint() : 0n);
+    const span = (a, b) => (Number(b - a) / 1e6).toFixed(1);
+    const tStart = mark();
     let csvDir;
     if (process.platform === 'win32' && /[^\x00-\x7F]/.test(storagePath)) {
         const hash = crypto.createHash('sha256').update(storagePath).digest('hex').slice(0, 16);
@@ -747,14 +767,8 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
     }
     log('Streaming CSVs to disk...');
     const csvResult = await streamAllCSVsToDisk(graph, repoPath, csvDir);
+    const tCsv = mark();
     const validTables = new Set(NODE_TABLES);
-    const getNodeLabel = (nodeId) => {
-        if (nodeId.startsWith('comm_'))
-            return 'Community';
-        if (nodeId.startsWith('proc_'))
-            return 'Process';
-        return nodeId.split(':')[0];
-    };
     // 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
@@ -778,29 +792,27 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
             }
         }
     }
-    // Bulk COPY relationships — split by FROM→TO label pair (LadybugDB requires it)
-    const { relHeader, relsByPairMeta, pairWriteStreams, skippedRels, totalValidRels } = await splitRelCsvByLabelPair(csvResult.relCsvPath, csvDir, validTables, getNodeLabel);
-    // Close all per-pair write streams before COPY. `stream/promises.finished`
-    // resolves on the stream's 'finish' event and rejects on 'error' — replaces
-    // a hand-rolled promisification with the stdlib primitive.
-    await Promise.all(Array.from(pairWriteStreams.values()).map(async (ws) => {
-        ws.end();
-        await finished(ws);
-    }));
+    const tCopyNodes = mark();
+    // Bulk COPY relationships. They were already routed to per-FROM→TO-label-pair
+    // files during the emit pass (#2203 U2) — there is no monolithic relations.csv
+    // to re-read/re-split here; we COPY each pair file directly.
+    const { relsByPair, relHeader, skippedRels, totalValidRels } = csvResult;
+    let tCopyRels = tCopyNodes;
+    let tFallback = tCopyNodes;
     const insertedRels = totalValidRels;
     const warnings = [];
     if (insertedRels > 0) {
-        log(`Loading edges: ${insertedRels.toLocaleString()} across ${relsByPairMeta.size} types`);
+        log(`Loading edges: ${insertedRels.toLocaleString()} across ${relsByPair.size} types`);
         let pairIdx = 0;
         let failedPairEdges = 0;
         const failedPairCsvPaths = new Set();
-        for (const [pairKey, { csvPath: pairCsvPath, rows }] of relsByPairMeta) {
+        for (const [pairKey, { csvPath: pairCsvPath, rows }] of relsByPair) {
             pairIdx++;
             const [fromLabel, toLabel] = pairKey.split('|');
             const normalizedPath = normalizeCopyPath(pairCsvPath);
             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}/${relsByPairMeta.size} types (${fromLabel} -> ${toLabel})`);
+                log(`Loading edges: ${pairIdx}/${relsByPair.size} types (${fromLabel} -> ${toLabel})`);
             }
             try {
                 await queryAndDrain(conn, copyQuery);
@@ -825,6 +837,7 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
                 catch { }
             }
         }
+        tCopyRels = mark();
         if (failedPairCsvPaths.size > 0) {
             log(`Inserting ${failedPairEdges} edges individually (missing schema pairs)`);
             // Read failed pair files and merge for fallback inserts
@@ -846,15 +859,13 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
                 catch { }
             }
             if (allLines.length > 1) {
-                await fallbackRelationshipInserts(allLines, validTables, getNodeLabel);
+                await fallbackRelationshipInserts(allLines, validTables, deriveNodeLabel);
             }
         }
+        tFallback = mark();
     }
-    // Cleanup all CSVs
-    try {
-        await fs.unlink(csvResult.relCsvPath);
-    }
-    catch { }
+    // Cleanup all CSVs (per-pair rel files are unlinked in the COPY loop above;
+    // the remaining sweep below catches node CSVs + any leftover pair files).
     for (const [, { csvPath }] of csvResult.nodeFiles) {
         try {
             await fs.unlink(csvPath);
@@ -875,6 +886,16 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
         await fs.rmdir(csvDir);
     }
     catch { }
+    if (PROF) {
+        const tEnd = mark();
+        let totalNodeRows = 0;
+        for (const [, { rows }] of csvResult.nodeFiles)
+            totalNodeRows += rows;
+        logger.warn(`[lbug-load prof] 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)`);
+    }
     return { success: true, insertedRels, skippedRels, warnings };
 };
 // LadybugDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes).

package/dist/core/lbug/rel-pair-routing.d.ts

@@ -0,0 +1,54 @@
+import { type WriteStream } from 'fs';
+/** Injectable for tests (backpressure/error simulation), mirroring split. */
+export type WriteStreamFactory = (filePath: string) => WriteStream;
+/**
+ * Derive a node's table label from its graph id. Matches the legacy
+ * `getNodeLabel` that lived inline in `loadGraphToLbug`:
+ *   - `comm_*`  → Community
+ *   - `proc_*`  → Process
+ *   - otherwise the prefix before the first `:` (e.g. `Function:…` → Function)
+ */
+export declare const getNodeLabel: (nodeId: string) => string;
+export interface RelPairMeta {
+    csvPath: string;
+    rows: number;
+}
+/**
+ * Routes already-escaped relationship CSV rows to per-FROM→TO-label-pair
+ * files. Filters edges whose endpoint labels are not valid node tables
+ * (counted as `skipped`), exactly as the legacy split did.
+ */
+export declare class RelPairRouter {
+    private readonly csvDir;
+    private readonly header;
+    private readonly validTables;
+    private readonly wsFactory;
+    /** pairKey (`From|To`) → { csvPath, rows } */
+    readonly byPair: Map<string, RelPairMeta>;
+    private readonly streams;
+    skipped: number;
+    total: number;
+    private streamError;
+    private readonly abort;
+    constructor(csvDir: string, header: string, validTables: Set<string>, wsFactory?: WriteStreamFactory);
+    private markError;
+    /**
+     * The first stream error observed, if any. Lets the emit caller rethrow the
+     * real error (EMFILE / disk-full) instead of the generic `AbortError` that a
+     * pending `once(ws,'drain',{signal})` rejects with when the abort fires —
+     * mirroring the retained `splitRelCsvByLabelPair`'s `throw streamError ?? err`.
+     */
+    get lastError(): Error | null;
+    /**
+     * Route one already-escaped CSV row (no trailing newline) to its pair file.
+     * Returns `void` on the synchronous hot path; a `Promise<void>` only when a
+     * stream signals backpressure (or a new pair's header does) — the caller
+     * awaits the promise before routing the next edge.
+     */
+    route(fromId: string, toId: string, row: string): void | Promise<void>;
+    private openAndWrite;
+    /** Flush + close every pair stream. Rejects if any stream errored. */
+    close(): Promise<void>;
+    /** Tear down all streams (no flush) — used on the error path. */
+    destroy(): void;
+}

package/dist/core/lbug/rel-pair-routing.js

@@ -0,0 +1,140 @@
+/**
+ * Relationship per-label-pair routing (#2203 U2).
+ *
+ * LadybugDB's bulk `COPY` into the single `CodeRelation` rel table requires a
+ * separate CSV per FROM→TO node-label pair (the `from=`/`to=` COPY params).
+ * Historically the emit pass wrote one monolithic `relations.csv`, which
+ * `loadGraphToLbug` then RE-READ line-by-line (regex per edge) and re-split
+ * into per-pair files — writing and reading the entire ~1M-edge set twice.
+ *
+ * This router lets the single emit pass route each edge to its per-pair file
+ * directly, so the monolithic write + re-read + per-edge regex are all gone.
+ * The label-derivation + validTables filtering + per-pair-file format here match
+ * the legacy `splitRelCsvByLabelPair`, so the per-pair files are byte-identical
+ * for all quote-free ids — see the differential test in
+ * `test/integration/csv-pipeline.test.ts`. ONE intentional divergence: this
+ * router derives the label from the RAW id, while the oracle re-derives it via a
+ * regex over the ESCAPED row — so for an id containing a `"` the router is the
+ * more-correct path (it routes the edge to the right pair; the oracle's regex
+ * mis-buckets or drops it). `splitRelCsvByLabelPair` is retained as the
+ * differential oracle (the quote-in-id divergence is asserted explicitly).
+ *
+ * Backpressure: at most one stream is awaited at a time (the caller routes
+ * edges sequentially and awaits the returned drain promise before the next),
+ * mirroring the legacy split's `for await` invariant. The hot path (existing
+ * pair, no backpressure) returns `void` — no microtask per edge.
+ */
+import path from 'path';
+import { createWriteStream } from 'fs';
+import { once } from 'events';
+import { finished } from 'stream/promises';
+/**
+ * Derive a node's table label from its graph id. Matches the legacy
+ * `getNodeLabel` that lived inline in `loadGraphToLbug`:
+ *   - `comm_*`  → Community
+ *   - `proc_*`  → Process
+ *   - otherwise the prefix before the first `:` (e.g. `Function:…` → Function)
+ */
+export const getNodeLabel = (nodeId) => {
+    if (nodeId.startsWith('comm_'))
+        return 'Community';
+    if (nodeId.startsWith('proc_'))
+        return 'Process';
+    return nodeId.split(':')[0];
+};
+/**
+ * Routes already-escaped relationship CSV rows to per-FROM→TO-label-pair
+ * files. Filters edges whose endpoint labels are not valid node tables
+ * (counted as `skipped`), exactly as the legacy split did.
+ */
+export class RelPairRouter {
+    csvDir;
+    header;
+    validTables;
+    wsFactory;
+    /** pairKey (`From|To`) → { csvPath, rows } */
+    byPair = new Map();
+    streams = new Map();
+    skipped = 0;
+    total = 0;
+    streamError = null;
+    abort = new AbortController();
+    constructor(csvDir, header, validTables, wsFactory = (p) => createWriteStream(p, 'utf-8')) {
+        this.csvDir = csvDir;
+        this.header = header;
+        this.validTables = validTables;
+        this.wsFactory = wsFactory;
+    }
+    markError = (err) => {
+        this.streamError ??= err;
+        this.abort.abort(err);
+    };
+    /**
+     * The first stream error observed, if any. Lets the emit caller rethrow the
+     * real error (EMFILE / disk-full) instead of the generic `AbortError` that a
+     * pending `once(ws,'drain',{signal})` rejects with when the abort fires —
+     * mirroring the retained `splitRelCsvByLabelPair`'s `throw streamError ?? err`.
+     */
+    get lastError() {
+        return this.streamError;
+    }
+    /**
+     * Route one already-escaped CSV row (no trailing newline) to its pair file.
+     * Returns `void` on the synchronous hot path; a `Promise<void>` only when a
+     * stream signals backpressure (or a new pair's header does) — the caller
+     * awaits the promise before routing the next edge.
+     */
+    route(fromId, toId, row) {
+        if (this.streamError)
+            throw this.streamError;
+        const fromLabel = getNodeLabel(fromId);
+        const toLabel = getNodeLabel(toId);
+        if (!this.validTables.has(fromLabel) || !this.validTables.has(toLabel)) {
+            this.skipped++;
+            return;
+        }
+        const pairKey = `${fromLabel}|${toLabel}`;
+        const ws = this.streams.get(pairKey);
+        if (ws === undefined) {
+            // First edge for this pair: open the stream, write header + row.
+            return this.openAndWrite(pairKey, fromLabel, toLabel, row);
+        }
+        this.byPair.get(pairKey).rows++;
+        this.total++;
+        if (!ws.write(row + '\n')) {
+            return once(ws, 'drain', { signal: this.abort.signal }).then(() => undefined);
+        }
+    }
+    async openAndWrite(pairKey, fromLabel, toLabel, row) {
+        const csvPath = path.join(this.csvDir, `rel_${fromLabel}_${toLabel}.csv`);
+        const ws = this.wsFactory(csvPath);
+        ws.on('error', this.markError);
+        this.streams.set(pairKey, ws);
+        this.byPair.set(pairKey, { csvPath, rows: 1 });
+        this.total++;
+        if (!ws.write(this.header + '\n')) {
+            await once(ws, 'drain', { signal: this.abort.signal });
+        }
+        if (!ws.write(row + '\n')) {
+            await once(ws, 'drain', { signal: this.abort.signal });
+        }
+    }
+    /** Flush + close every pair stream. Rejects if any stream errored. */
+    async close() {
+        if (this.streamError) {
+            this.destroy();
+            throw this.streamError;
+        }
+        await Promise.all(Array.from(this.streams.values()).map(async (ws) => {
+            ws.end();
+            await finished(ws);
+        }));
+        if (this.streamError)
+            throw this.streamError;
+    }
+    /** Tear down all streams (no flush) — used on the error path. */
+    destroy() {
+        for (const ws of this.streams.values())
+            ws.destroy();
+    }
+}

package/package.json

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