gitnexus 1.6.9-rc.33 → 1.6.9-rc.35

package/dist/core/embeddings/embedding-pipeline.d.ts

@@ -8,7 +8,7 @@
  * 4. Update LadybugDB with chunk-aware embeddings
  * 5. Create vector index for semantic search
  */
-import { type EmbeddingProgress, type EmbeddingConfig, type EmbeddableNode, type SemanticSearchResult, type EmbeddingContext } from './types.js';
+import { type EmbeddingProgress, type EmbeddingConfig, type EmbeddableNode, type SemanticSearchResult } from './types.js';
 import type { ExtensionInstallPolicy } from '../lbug/extension-loader.js';
 /**
  * Resolve the extension-install policy for the embedding WRITE path (analyze).
@@ -28,7 +28,7 @@ export declare const resolveEmbeddingInstallPolicy: () => ExtensionInstallPolicy
  * invalidate existing vectors, such as metadata/header shape changes,
  * structural container context changes, or preceding-context formatting rules.
  */
-export declare const EMBEDDING_TEXT_VERSION = "v2";
+export declare const EMBEDDING_TEXT_VERSION = "v4";
 /**
  * Compute a stable content fingerprint for an embeddable node.
  * Used to detect when the underlying text has changed so stale vectors
@@ -65,13 +65,11 @@ export interface EmbeddingPipelineResult {
  * @param onProgress - Callback for progress updates
  * @param config - Optional configuration override
  * @param skipNodeIds - Optional set of node IDs that already have embeddings (incremental mode)
- * @param context - Optional repo/server context for metadata enrichment
  * @param existingEmbeddings - Optional map of nodeId → contentHash for incremental mode.
  *        Nodes whose hash matches are skipped; nodes with a changed hash are DELETE'd
  *        and re-embedded; nodes not in the map are embedded fresh.
-
  */
-export declare const runEmbeddingPipeline: (executeQuery: (cypher: string) => Promise<any[]>, executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>, onProgress: EmbeddingProgressCallback, config?: Partial<EmbeddingConfig>, skipNodeIds?: Set<string>, context?: EmbeddingContext, existingEmbeddings?: Map<string, string>) => Promise<EmbeddingPipelineResult>;
+export declare const runEmbeddingPipeline: (executeQuery: (cypher: string) => Promise<any[]>, executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>, onProgress: EmbeddingProgressCallback, config?: Partial<EmbeddingConfig>, skipNodeIds?: Set<string>, existingEmbeddings?: Map<string, string>) => Promise<EmbeddingPipelineResult>;
 /**
  * Perform semantic search using the vector index with chunk deduplication
  */

package/dist/core/embeddings/embedding-pipeline.js

@@ -51,7 +51,7 @@ const ensureVectorExtensionAvailable = async () => {
  * invalidate existing vectors, such as metadata/header shape changes,
  * structural container context changes, or preceding-context formatting rules.
  */
-export const EMBEDDING_TEXT_VERSION = 'v2';
+export const EMBEDDING_TEXT_VERSION = 'v4';
 /**
  * Compute a stable content fingerprint for an embeddable node.
  * Used to detect when the underlying text has changed so stale vectors
@@ -185,6 +185,32 @@ const buildVectorIndex = async () => {
         return false;
     }
 };
+/**
+ * DELETE stale embedding rows for the given nodeIds so they can be re-inserted.
+ *
+ * Kuzu forbids SET on vector-indexed properties; DELETE-then-INSERT is the
+ * sanctioned pattern. A `"does not exist"` error means the rows are already gone
+ * (safe to proceed); any other error risks vector-index corruption, so it
+ * propagates and aborts the pipeline.
+ *
+ * Called per-batch (just before each batch's INSERT), not once up front — see
+ * the caller comment / KTD7: an up-front bulk delete of every stale row leaves
+ * the whole index deleted-not-reinserted if the re-embed is interrupted. Per-batch
+ * interleaving bounds that window to a single batch.
+ */
+const deleteStaleEmbeddingRows = async (executeWithReusedStatement, nodeIds) => {
+    if (nodeIds.length === 0)
+        return;
+    try {
+        await executeWithReusedStatement(`MATCH (e:${EMBEDDING_TABLE_NAME} {nodeId: $nodeId}) DELETE e`, nodeIds.map((nodeId) => ({ nodeId })));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!msg.includes('does not exist')) {
+            throw new Error(`[embed] Failed to delete stale embedding rows — aborting to prevent vector-index corruption: ${msg}`);
+        }
+    }
+};
 /**
  * Run the embedding pipeline
  *
@@ -193,13 +219,11 @@ const buildVectorIndex = async () => {
  * @param onProgress - Callback for progress updates
  * @param config - Optional configuration override
  * @param skipNodeIds - Optional set of node IDs that already have embeddings (incremental mode)
- * @param context - Optional repo/server context for metadata enrichment
  * @param existingEmbeddings - Optional map of nodeId → contentHash for incremental mode.
  *        Nodes whose hash matches are skipped; nodes with a changed hash are DELETE'd
  *        and re-embedded; nodes not in the map are embedded fresh.
-
  */
-export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatement, onProgress, config = {}, skipNodeIds, context, existingEmbeddings) => {
+export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatement, onProgress, config = {}, skipNodeIds, existingEmbeddings) => {
     const finalConfig = resolveEmbeddingConfig(config);
     let totalChunks = 0;
     try {
@@ -233,20 +257,16 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
         }
         // Phase 2: Query embeddable nodes
         let nodes = await queryEmbeddableNodes(executeQuery);
-        // Apply context metadata
-        if (context?.repoName) {
-            for (const node of nodes) {
-                node.repoName = context.repoName;
-                node.serverName = context.serverName;
-            }
-        }
         // Incremental mode: compare content hashes, delete stale rows, skip fresh ones.
         // Computed hashes for stale nodes are cached so batchInsertEmbeddings can reuse them
         // (avoids double computation).
         const computedStaleHashes = new Map();
+        // Stale rows are DELETE'd per-batch (just before each batch's INSERT) rather
+        // than all up front — see U6 / KTD7. `staleNodeIds` is consulted inside the
+        // batch loop; it stays empty in full (non-incremental) mode so no deletes fire.
+        const staleNodeIds = new Set();
         if (existingEmbeddings && existingEmbeddings.size > 0) {
             const beforeCount = nodes.length;
-            const staleNodeIds = [];
             nodes = nodes.filter((n) => {
                 const existingHash = existingEmbeddings.get(n.id);
                 if (existingHash === undefined) {
@@ -257,33 +277,14 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
                 if (currentHash !== existingHash) {
                     // Content changed — cache hash for reuse during insert, mark for DELETE + re-embed
                     computedStaleHashes.set(n.id, currentHash);
-                    staleNodeIds.push(n.id);
+                    staleNodeIds.add(n.id);
                     return true;
                 }
                 // Hash matches — skip (fresh); no need to cache hash for skipped nodes
                 return false;
             });
-            // DELETE stale embedding rows so they can be re-inserted
-            // (Kuzu forbids SET on vector-indexed properties; DELETE-then-INSERT is the sanctioned pattern)
-            if (staleNodeIds.length > 0) {
-                if (isDev) {
-                    logger.info(`🔄 Deleting ${staleNodeIds.length} stale embedding rows for re-embed`);
-                }
-                try {
-                    await executeWithReusedStatement(`MATCH (e:${EMBEDDING_TABLE_NAME} {nodeId: $nodeId}) DELETE e`, staleNodeIds.map((nodeId) => ({ nodeId })));
-                }
-                catch (err) {
-                    // "does not exist" = rows already gone — safe to proceed.
-                    // All other errors risk vector-index corruption (Kuzu requires DELETE-before-INSERT
-                    // for vector-indexed properties) — propagate so the pipeline aborts cleanly.
-                    const msg = err instanceof Error ? err.message : String(err);
-                    if (!msg.includes('does not exist')) {
-                        throw new Error(`[embed] Failed to delete stale embedding rows — aborting to prevent vector-index corruption: ${msg}`);
-                    }
-                }
-            }
             if (isDev) {
-                logger.info(`📦 Incremental embeddings: ${beforeCount} total, ${existingEmbeddings.size} cached, ${staleNodeIds.length} stale, ${nodes.length} to embed`);
+                logger.info(`📦 Incremental embeddings: ${beforeCount} total, ${existingEmbeddings.size} cached, ${staleNodeIds.size} stale, ${nodes.length} to embed`);
             }
         }
         const totalNodes = nodes.length;
@@ -373,6 +374,11 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
                     prevTail = overlap > 0 ? chunk.text.slice(-overlap) : '';
                 }
             }
+            // U6 / KTD7: delete this batch's stale rows immediately before its inserts,
+            // so an interrupted re-embed loses at most one batch (not the whole index).
+            // Preserves Kuzu's required DELETE-before-INSERT for vector-indexed rows.
+            const batchStaleIds = batch.filter((n) => staleNodeIds.has(n.id)).map((n) => n.id);
+            await deleteStaleEmbeddingRows(executeWithReusedStatement, batchStaleIds);
             // Embed chunk texts in sub-batches to control memory
             const EMBED_SUB_BATCH = finalConfig.subBatchSize;
             for (let si = 0; si < allTexts.length; si += EMBED_SUB_BATCH) {

package/dist/core/embeddings/text-generator.d.ts

@@ -1,7 +1,7 @@
 /**
  * Text Generator Module
  *
- * Generates enriched embedding text from code nodes with metadata.
+ * Generates compact, description-forward embedding text from code nodes.
  * Supports chunkable labels (Function/Method with AST chunking),
  * Class-specific structural text, and short-node direct embed.
  *

package/dist/core/embeddings/text-generator.js

@@ -1,7 +1,7 @@
 /**
  * Text Generator Module
  *
- * Generates enriched embedding text from code nodes with metadata.
+ * Generates compact, description-forward embedding text from code nodes.
  * Supports chunkable labels (Function/Method with AST chunking),
  * Class-specific structural text, and short-node direct embed.
  *
@@ -41,27 +41,48 @@ const cleanContent = (content) => {
         .trim();
 };
 /**
- * Build metadata header for a node
+ * Compact location signal for the embedding header: the last 1-2 path segments
+ * (immediate parent dir + basename), never the full deep path.
+ *
+ * #2333 / PR #2334 tri-review: U1 dropped the location entirely, which regressed
+ * path/service-qualified semantic search (e.g. `billing/handler` vs
+ * `identity/handler` in a monorepo) — and FTS indexes only name/content/description,
+ * never `filePath`, so there is no keyword backfill. The bounded form restores the
+ * discriminating tokens (service dir + filename-concept) at a fraction of the
+ * dilution the full path caused.
  */
-const buildMetadataHeader = (node, config) => {
+const boundedLocation = (filePath) => {
+    const segments = filePath.replace(/\\/g, '/').split('/').filter(Boolean);
+    return segments.slice(-2).join('/');
+};
+/**
+ * Build a compact, description-forward header for embedding text.
+ *
+ * Issue #2333 (sub-issue of #2326), Option A: lead the embedding text with the
+ * symbol name + doc-comment description and drop the low-signal metadata lines
+ * (`Repo`/`Server`/`Export` and the verbose full `Path`). For short doc comments
+ * those lines used to be ~25-30% of the embedding text, diluting the description's
+ * semantic weight in the vector and weakening description-shaped search — worst
+ * for CJK, where a complete concept is often 4-20 characters.
+ *
+ * A *bounded* location signal (last 1-2 path segments) is kept after the
+ * description — see `boundedLocation` for why the full path drop was reversed.
+ *
+ * Full metadata is unaffected: it lives on the graph node properties, which is
+ * what display/context tools read. Only the embedding text changes here.
+ *
+ * Option B (reorder only, keep metadata) was rejected — mean-pooled embeddings
+ * weight by token proportion, not position, so reordering alone barely moves the
+ * signal. Option C (a separate description-only embedding + hybrid merge) is
+ * deferred to follow-up; build it only if Option A proves insufficient against
+ * real measurement. Any change to this template MUST bump EMBEDDING_TEXT_VERSION.
+ */
+const buildEmbeddingHeader = (node, config) => {
     const parts = [];
     // Label + name
     parts.push(`${node.label}: ${node.name}`);
-    // Repo name
-    if (node.repoName) {
-        parts.push(`Repo: ${node.repoName}`);
-    }
-    // Server name (optional)
-    if (node.serverName) {
-        parts.push(`Server: ${node.serverName}`);
-    }
-    // Full file path
-    parts.push(`Path: ${node.filePath}`);
-    // Export status
-    if (node.isExported !== undefined) {
-        parts.push(`Export: ${node.isExported}`);
-    }
-    // Description (truncated)
+    // Description hoisted above everything else so its semantic signal dominates
+    // the embedding vector and is never the part lost to token-limit truncation.
     if (node.description) {
         const maxLen = config.maxDescriptionLength ?? DEFAULT_EMBEDDING_CONFIG.maxDescriptionLength;
         const truncated = truncateDescription(node.description, maxLen);
@@ -69,10 +90,19 @@ const buildMetadataHeader = (node, config) => {
             parts.push(truncated);
         }
     }
+    // Bounded location signal — placed after the description so the description
+    // still leads the vector. Restores path/service disambiguation lost when the
+    // full Path line was dropped (FTS does not index filePath to backfill it).
+    if (node.filePath) {
+        const loc = boundedLocation(node.filePath);
+        if (loc) {
+            parts.push(`Loc: ${loc}`);
+        }
+    }
     return parts.join('\n');
 };
 const generateCodeBodyText = (node, codeBody, config, prevTail) => {
-    const header = buildMetadataHeader(node, config);
+    const header = buildEmbeddingHeader(node, config);
     const parts = [header];
     if (prevTail) {
         parts.push(`[preceding context]: ...${cleanContent(prevTail)}`);
@@ -87,7 +117,7 @@ const getCompactContainerContext = (cleanedContent, declarationOnly) => {
     return firstLine ? `Container: ${firstLine}` : undefined;
 };
 const generateStructuralTypeText = (node, codeBody, config, chunkIndex, prevTail) => {
-    const header = buildMetadataHeader(node, config);
+    const header = buildEmbeddingHeader(node, config);
     const parts = [header];
     const isFirstChunk = chunkIndex === undefined || chunkIndex === 0;
     const cleanedContent = cleanContent(node.content);
@@ -192,7 +222,7 @@ export const extractDeclarationOnly = (content) => {
  */
 export const generateEmbeddingText = (node, codeBody, config = {}, chunkIndex, prevTail) => {
     if (isShortLabel(node.label)) {
-        const header = buildMetadataHeader(node, config);
+        const header = buildEmbeddingHeader(node, config);
         const cleaned = cleanContent(node.content);
         return `${header}\n\n${cleaned}`;
     }

package/dist/core/embeddings/types.d.ts

@@ -168,13 +168,6 @@ export interface CachedEmbedding {
     embedding: number[];
     contentHash?: string;
 }
-/**
- * Context info for embedding pipeline (repo/server metadata enrichment)
- */
-export interface EmbeddingContext {
-    repoName?: string;
-    serverName?: string;
-}
 /**
  * Model download progress from transformers.js
  */

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

@@ -3,7 +3,7 @@
  *
  * Streams CSV rows directly to disk files in a single pass over graph nodes.
  * File contents are lazy-read from disk per-node to avoid holding the entire
- * repo in RAM. Rows are buffered (FLUSH_EVERY) before writing to minimize
+ * repo in RAM. Rows are buffered (FLUSH_BYTES) before writing to minimize
  * per-row Promise overhead.
  *
  * RFC 4180 Compliant:
@@ -14,6 +14,32 @@
 import type { GraphNode, GraphRelationship } from '../../_shared/index.js';
 import { KnowledgeGraph } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
+/**
+ * Flush buffered rows to disk once the buffered chunk reaches this many bytes.
+ * Byte-bounded rather than row-count-bounded: row size ranges from a few dozen
+ * bytes (typical symbol/relationship rows) up to a full File's content
+ * (#2317/#2323), so a row-count-only cap lets a handful of huge rows build an
+ * unbounded `buffer.join('\n')` string before ever tripping it.
+ *
+ * Not an env knob — fixed by a safety margin, not a preference. The one worst
+ * case that matters: one more oversized row lands right after the buffer was
+ * just under this threshold, before the flush fires. That row is capped at
+ * TREE_SITTER_MAX_BUFFER (32MB, hard-clamped — GITNEXUS_MAX_FILE_SIZE cannot
+ * raise it), and escapeCSVField's quote-doubling can at most double it. So the
+ * peak joined-string size is bounded by
+ *   FLUSH_BYTES + 2 * TREE_SITTER_MAX_BUFFER ≈ 8MB + 64MB = 72MB,
+ * versus Node's `buffer.constants.MAX_STRING_LENGTH` (~512MB) that throws
+ * `RangeError: Invalid string length` past it — a >7x margin (see the
+ * `shouldFlushCSVBuffer stays within the V8 string-length ceiling` test,
+ * which fails loudly if either constant ever moves this margin the wrong
+ * way). Raising FLUSH_BYTES trades fewer/larger flushes for less margin;
+ * lowering it trades the reverse for lower peak transient memory. Change the
+ * constant directly if a real workload needs a different point on that
+ * curve — a per-host env var would let the margin get silently reintroduced
+ * by an operator with no way to know why 512MB is dangerous.
+ */
+export declare const FLUSH_BYTES: number;
+export declare const shouldFlushCSVBuffer: (byteCount: number) => boolean;
 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;

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

@@ -3,7 +3,7 @@
  *
  * Streams CSV rows directly to disk files in a single pass over graph nodes.
  * File contents are lazy-read from disk per-node to avoid holding the entire
- * repo in RAM. Rows are buffered (FLUSH_EVERY) before writing to minimize
+ * repo in RAM. Rows are buffered (FLUSH_BYTES) before writing to minimize
  * per-row Promise overhead.
  *
  * RFC 4180 Compliant:
@@ -31,8 +31,32 @@ import { parseTruthyEnv } from '../ingestion/utils/env.js';
 const byGraphId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 const orderedNodes = (graph, sorted) => sorted ? [...graph.iterNodes()].sort(byGraphId) : graph.iterNodes();
 const orderedRelationships = (graph, sorted) => sorted ? [...graph.iterRelationships()].sort(byGraphId) : graph.iterRelationships();
-/** Flush buffered rows to disk every N rows */
-const FLUSH_EVERY = 500;
+/**
+ * Flush buffered rows to disk once the buffered chunk reaches this many bytes.
+ * Byte-bounded rather than row-count-bounded: row size ranges from a few dozen
+ * bytes (typical symbol/relationship rows) up to a full File's content
+ * (#2317/#2323), so a row-count-only cap lets a handful of huge rows build an
+ * unbounded `buffer.join('\n')` string before ever tripping it.
+ *
+ * Not an env knob — fixed by a safety margin, not a preference. The one worst
+ * case that matters: one more oversized row lands right after the buffer was
+ * just under this threshold, before the flush fires. That row is capped at
+ * TREE_SITTER_MAX_BUFFER (32MB, hard-clamped — GITNEXUS_MAX_FILE_SIZE cannot
+ * raise it), and escapeCSVField's quote-doubling can at most double it. So the
+ * peak joined-string size is bounded by
+ *   FLUSH_BYTES + 2 * TREE_SITTER_MAX_BUFFER ≈ 8MB + 64MB = 72MB,
+ * versus Node's `buffer.constants.MAX_STRING_LENGTH` (~512MB) that throws
+ * `RangeError: Invalid string length` past it — a >7x margin (see the
+ * `shouldFlushCSVBuffer stays within the V8 string-length ceiling` test,
+ * which fails loudly if either constant ever moves this margin the wrong
+ * way). Raising FLUSH_BYTES trades fewer/larger flushes for less margin;
+ * lowering it trades the reverse for lower peak transient memory. Change the
+ * constant directly if a real workload needs a different point on that
+ * curve — a per-host env var would let the margin get silently reintroduced
+ * by an operator with no way to know why 512MB is dangerous.
+ */
+export const FLUSH_BYTES = 8 * 1024 * 1024;
+export const shouldFlushCSVBuffer = (byteCount) => byteCount >= FLUSH_BYTES;
 /**
  * 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
@@ -127,6 +151,23 @@ class FileContentCache {
         this.accessOrder.push(key);
     }
 }
+/**
+ * Flatten newlines and tabs to single spaces for FTS-indexed text columns
+ * (`content`, `description`) — the real fix for #2317.
+ *
+ * Ladybug's full-text-search tokenizer splits ONLY on the space character —
+ * `\n`, `\r`, and `\t` are NOT token delimiters. So multiline text indexes as
+ * a handful of giant tokens (each whole line, joined across lines), and a
+ * word query matches none of them: `searchFTSFromLbug('foo')` misses a file
+ * whose content is `... \nfoo\n ...`. Removing the 10KB cap (#2333/#2317)
+ * stores the full body but leaves it unsearchable; collapsing intra-text
+ * whitespace to spaces is what actually makes every word searchable.
+ *
+ * This rewrites the STORED column too (the same value is COPYed in), so File
+ * content returned via the graph API is space-flattened — an accepted trade
+ * for making file/symbol text searchable. Leading/trailing/empty are no-ops.
+ */
+const normalizeFtsText = (text) => text.replace(/[\r\n\t]+/g, ' ');
 const extractContent = async (node, contentCache) => {
     const filePath = node.properties.filePath;
     const content = await contentCache.get(filePath);
@@ -136,11 +177,13 @@ const extractContent = async (node, contentCache) => {
         return '';
     if (isBinaryContent(content))
         return '[Binary file - content not stored]';
+    // File content is stored in full — intentionally NOT length-capped here, so
+    // text past the old 10KB cutoff stays FTS-searchable (#2317). It is already
+    // bounded upstream by the walker's max-file-size cap (512KB default / 32MB),
+    // and only whitespace-normalized for the tokenizer. The symbol snippet path
+    // below, by contrast, deliberately stays capped at MAX_SNIPPET.
     if (node.label === 'File') {
-        const MAX_FILE_CONTENT = 10000;
-        return content.length > MAX_FILE_CONTENT
-            ? content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]'
-            : content;
+        return normalizeFtsText(content);
     }
     const startLine = node.properties.startLine;
     const endLine = node.properties.endLine;
@@ -151,9 +194,8 @@ const extractContent = async (node, contentCache) => {
     const end = Math.min(lines.length - 1, endLine + 2);
     const snippet = lines.slice(start, end + 1).join('\n');
     const MAX_SNIPPET = 5000;
-    return snippet.length > MAX_SNIPPET
-        ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
-        : snippet;
+    const capped = snippet.length > MAX_SNIPPET ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]' : snippet;
+    return normalizeFtsText(capped);
 };
 // ============================================================================
 // BUFFERED CSV WRITER
@@ -161,15 +203,17 @@ const extractContent = async (node, contentCache) => {
 class BufferedCSVWriter {
     ws;
     buffer = [];
+    bufferedBytes = 0;
     rows = 0;
     constructor(filePath, header) {
         this.ws = createWriteStream(filePath, 'utf-8');
         // Large repos flush many times — raise listener cap to avoid MaxListenersExceededWarning
         this.ws.setMaxListeners(50);
         this.buffer.push(header);
+        this.bufferedBytes = Buffer.byteLength(header) + 1;
     }
     /**
-     * Buffer a row. Returns a promise ONLY when the buffer crossed FLUSH_EVERY
+     * Buffer a row. Returns a promise ONLY when the buffer crossed FLUSH_BYTES
      * 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
@@ -177,8 +221,9 @@ class BufferedCSVWriter {
      */
     addRow(row) {
         this.buffer.push(row);
+        this.bufferedBytes += Buffer.byteLength(row) + 1;
         this.rows++;
-        if (this.buffer.length >= FLUSH_EVERY) {
+        if (shouldFlushCSVBuffer(this.bufferedBytes)) {
             return this.flush();
         }
         return undefined;
@@ -188,6 +233,7 @@ class BufferedCSVWriter {
             return Promise.resolve();
         const chunk = this.buffer.join('\n') + '\n';
         this.buffer.length = 0;
+        this.bufferedBytes = 0;
         return new Promise((resolve, reject) => {
             this.ws.once('error', reject);
             const ok = this.ws.write(chunk);
@@ -355,7 +401,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
             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).
+            // tick on the rows buffered between byte-bounded flushes (#2203 U3).
             let pending;
             switch (node.label) {
                 case 'File': {
@@ -383,7 +429,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         escapeCSVField(node.properties.name || ''),
                         escapeCSVField(node.properties.heuristicLabel || ''),
                         keywordsStr,
-                        escapeCSVField(node.properties.description || ''),
+                        escapeCSVField(normalizeFtsText(node.properties.description || '')),
                         escapeCSVField(node.properties.enrichedBy || 'heuristic'),
                         escapeCSVNumber(node.properties.cohesion, 0),
                         escapeCSVNumber(node.properties.symbolCount, 0),
@@ -415,7 +461,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         escapeCSVNumber(node.properties.endLine, -1),
                         node.properties.isExported ? 'true' : 'false',
                         escapeCSVField(content),
-                        escapeCSVField(node.properties.description || ''),
+                        escapeCSVField(normalizeFtsText(node.properties.description || '')),
                         escapeCSVNumber(node.properties.parameterCount, 0),
                         escapeCSVField(node.properties.returnType || ''),
                     ].join(','));
@@ -431,7 +477,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         escapeCSVNumber(node.properties.endLine, -1),
                         escapeCSVNumber(node.properties.level, 1),
                         escapeCSVField(content),
-                        escapeCSVField(node.properties.description || ''),
+                        escapeCSVField(normalizeFtsText(node.properties.description || '')),
                     ].join(','));
                     break;
                 }
@@ -461,7 +507,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         escapeCSVField(node.id),
                         escapeCSVField(node.properties.name || ''),
                         escapeCSVField(node.properties.filePath || ''),
-                        escapeCSVField(node.properties.description || ''),
+                        escapeCSVField(normalizeFtsText(node.properties.description || '')),
                     ].join(','));
                     break;
                 case 'BasicBlock':
@@ -480,7 +526,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                             escapeCSVNumber(node.properties.endLine, -1),
                             node.properties.isExported ? 'true' : 'false',
                             escapeCSVField(content),
-                            escapeCSVField(node.properties.description || ''),
+                            escapeCSVField(normalizeFtsText(node.properties.description || '')),
                         ].join(','));
                     }
                     else {
@@ -495,7 +541,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                                 escapeCSVNumber(node.properties.startLine, -1),
                                 escapeCSVNumber(node.properties.endLine, -1),
                                 escapeCSVField(content),
-                                escapeCSVField(node.properties.description || ''),
+                                escapeCSVField(normalizeFtsText(node.properties.description || '')),
                                 ...(node.label === 'Property'
                                     ? [escapeCSVField(node.properties.declaredType || '')]
                                     : []),

package/dist/core/run-analyze.js

@@ -982,20 +982,6 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                     existingEmbeddings.set(e.nodeId, e.contentHash ?? STALE_HASH_SENTINEL);
                 }
             }
-            const { readServerMapping } = await import('./embeddings/server-mapping.js');
-            // Mirror the registry's name-resolution chain so the server-mapping
-            // lookup key stays aligned with the final registry name (#1259):
-            //   --name → remote-derived → canonical-root basename
-            // (preserved-alias is intentionally NOT consulted here — server
-            // mappings are addressed by the operationally-meaningful name the
-            // user configures, not by a sticky registry-only alias they may not
-            // know about. The previous canonical-only logic ignored both --name
-            // and remote-derived names, silently breaking server-mapping for
-            // anyone with a `--name` alias or remote-named repo.)
-            const projectName = options.registryName ??
-                getInferredRepoName(repoPath) ??
-                path.basename(resolveRepoIdentityRoot(repoPath));
-            const serverName = await readServerMapping(projectName);
             const embeddingResult = await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (p) => {
                 const scaled = 90 + Math.round((p.percent / 100) * 8);
                 const label = p.phase === 'loading-model'
@@ -1004,7 +990,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                         : 'Loading embedding model...'
                     : `Embedding ${p.nodesProcessed || 0}/${p.totalNodes || '?'}`;
                 progress('embeddings', scaled, label);
-            }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined, { repoName: projectName, serverName }, existingEmbeddings);
+            }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined, existingEmbeddings);
             if (embeddingResult.semanticMode === 'exact-scan') {
                 semanticMode = 'exact-scan';
                 log('Semantic embeddings were generated without a VECTOR index; ' +

package/dist/server/api.js

@@ -1520,7 +1520,6 @@ export const createServer = async (port, host = '127.0.0.1') => {
                             });
                         }, {}, // config: use defaults
                         undefined, // skipNodeIds
-                        undefined, // context
                         existingEmbeddings);
                         // Flush WAL so subsequent /api/search requests see the new
                         // embeddings immediately (#1149). In the CLI path closeLbug()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.9-rc.33",
+  "version": "1.6.9-rc.35",
   "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",