gitnexus 1.6.6-rc.156 → 1.6.6-rc.157

package/dist/cli/analyze.js

@@ -41,6 +41,22 @@ const writeFatalToStderr = (label, err) => {
     realStderrWrite(`\n  ${label}: ${message}\n`);
     if (isErr && err.stack)
         realStderrWrite(`${err.stack}\n`);
+    // Walk and print the `cause` chain. The phase runner wraps the underlying
+    // failure as `new Error("Phase 'X' failed: …", { cause })`, so the original
+    // error (e.g. a WorkerPoolDispatchError carrying the worker-side stack from
+    // #2068) is only reachable via `.cause`. Without this the user sees the
+    // wrapper's main-thread stack and never the real frame. `cause.stack` already
+    // begins with the cause's message, so we print the stack alone (not message +
+    // stack) to avoid repeating it. Depth-bounded so a cyclic `cause` can't loop
+    // (the phase runner wraps one level; the bound leaves headroom for future
+    // nesting); uses realStderrWrite so the redirected console.error's ANSI
+    // clear-line wrapping can't erase it (#1169).
+    const MAX_CAUSE_DEPTH = 5;
+    let cause = isErr ? err.cause : undefined;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && cause instanceof Error; depth++) {
+        realStderrWrite(`\n  Caused by: ${cause.stack ?? cause.message}\n`);
+        cause = cause.cause;
+    }
 };
 let fatalHandlersInstalled = false;
 /**

package/dist/core/ingestion/call-processor.d.ts

@@ -9,14 +9,12 @@
  *
  *   - `processRoutesFromExtracted` — CALLS edges from framework routes
  *     (e.g. Laravel) to their controller methods.
- *   - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` /
- *     `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to
- *     Next.js Route nodes.
+ *   - `processNextjsFetchRoutes` / `extractConsumerAccessedKeys` — FETCHES edges
+ *     from `fetch()` calls to Next.js Route nodes.
  *   - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type
  *     map, consumed by the cross-file enrichment pass.
  */
 import { KnowledgeGraph } from '../graph/types.js';
-import { ASTCache } from './ast-cache.js';
 import type { SemanticModel, SymbolTableReader } from './model/index.js';
 import type { ExtractedRoute, ExtractedFetchCall } from './workers/parse-worker.js';
 /** Per-file resolved type bindings for exported symbols.
@@ -76,12 +74,3 @@ export declare const extractConsumerAccessedKeys: (content: string) => string[];
  */
 export declare const processNextjsFetchRoutes: (graph: KnowledgeGraph, fetchCalls: ExtractedFetchCall[], routeRegistry: Map<string, string>, // routeURL → handlerFilePath
 consumerContents?: Map<string, string>) => void;
-/**
- * Extract fetch() calls from source files (sequential path).
- * Workers handle this via tree-sitter captures in parse-worker; this function
- * provides the same extraction for the sequential fallback path.
- */
-export declare const extractFetchCallsFromFiles: (files: {
-    path: string;
-    content: string;
-}[], astCache: ASTCache) => Promise<ExtractedFetchCall[]>;

package/dist/core/ingestion/call-processor.js

@@ -9,20 +9,13 @@
  *
  *   - `processRoutesFromExtracted` — CALLS edges from framework routes
  *     (e.g. Laravel) to their controller methods.
- *   - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` /
- *     `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to
- *     Next.js Route nodes.
+ *   - `processNextjsFetchRoutes` / `extractConsumerAccessedKeys` — FETCHES edges
+ *     from `fetch()` calls to Next.js Route nodes.
  *   - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type
  *     map, consumed by the cross-file enrichment pass.
  */
-import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
-import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractReturnTypeName } from './type-extractors/shared.js';
 const MAX_EXPORTS_PER_FILE = 500;
@@ -408,73 +401,3 @@ consumerContents) => {
         }
     }
 };
-/**
- * Extract fetch() calls from source files (sequential path).
- * Workers handle this via tree-sitter captures in parse-worker; this function
- * provides the same extraction for the sequential fallback path.
- */
-export const extractFetchCallsFromFiles = async (files, astCache) => {
-    const parser = await loadParser();
-    const result = [];
-    for (const file of files) {
-        const language = getLanguageFromFilename(file.path);
-        if (!language)
-            continue;
-        if (!isLanguageAvailable(language))
-            continue;
-        const provider = getProvider(language);
-        const queryStr = provider.treeSitterQueries;
-        if (!queryStr)
-            continue;
-        await loadLanguage(language, file.path);
-        let tree = astCache.get(file.path);
-        if (!tree) {
-            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
-            try {
-                tree = parseSourceSafe(parser, parseContent, undefined, {
-                    bufferSize: getTreeSitterBufferSize(parseContent),
-                });
-            }
-            catch {
-                continue;
-            }
-            astCache.set(file.path, tree);
-        }
-        let matches;
-        try {
-            const lang = parser.getLanguage();
-            const query = new Parser.Query(lang, queryStr);
-            matches = query.matches(tree.rootNode);
-        }
-        catch {
-            continue;
-        }
-        for (const match of matches) {
-            const captureMap = {};
-            match.captures.forEach((c) => (captureMap[c.name] = c.node));
-            if (captureMap['route.fetch']) {
-                const urlNode = captureMap['route.url'] ?? captureMap['route.template_url'];
-                if (urlNode) {
-                    result.push({
-                        filePath: file.path,
-                        fetchURL: urlNode.text,
-                        lineNumber: captureMap['route.fetch'].startPosition.row,
-                    });
-                }
-            }
-            else if (captureMap['http_client'] && captureMap['http_client.url']) {
-                const method = captureMap['http_client.method']?.text;
-                const url = captureMap['http_client.url'].text;
-                const HTTP_CLIENT_ONLY = new Set(['head', 'options', 'request', 'ajax']);
-                if (method && HTTP_CLIENT_ONLY.has(method) && url.startsWith('/')) {
-                    result.push({
-                        filePath: file.path,
-                        fetchURL: url,
-                        lineNumber: captureMap['http_client'].startPosition.row,
-                    });
-                }
-            }
-        }
-    }
-    return result;
-};

package/dist/core/ingestion/export-detection.d.ts

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { type SyntaxNode } from './utils/ast-helpers.js';
 /** Handler type: given a node and symbol name, return true if the symbol is exported/public. */

package/dist/core/ingestion/export-detection.js

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { findSiblingChild } from './utils/ast-helpers.js';
 // ============================================================================

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -1,7 +1,3 @@
-export interface FileEntry {
-    path: string;
-    content: string;
-}
 /** Lightweight entry — path + size from stat, no content in memory */
 export interface ScannedFile {
     path: string;
@@ -21,8 +17,3 @@ export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (curre
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.
  */
 export declare const readFileContents: (repoPath: string, relativePaths: string[]) => Promise<Map<string, string>>;
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export declare const walkRepository: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<FileEntry[]>;

package/dist/core/ingestion/filesystem-walker.js

@@ -111,14 +111,3 @@ export const readFileContents = async (repoPath, relativePaths) => {
     }
     return contents;
 };
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export const walkRepository = async (repoPath, onProgress) => {
-    const scanned = await walkRepositoryPaths(repoPath, onProgress);
-    const contents = await readFileContents(repoPath, scanned.map((f) => f.path));
-    return scanned
-        .filter((f) => contents.has(f.path))
-        .map((f) => ({ path: f.path, content: contents.get(f.path) }));
-};

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

@@ -26,9 +26,10 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { pythonFunctionDefinitionLabel } from './simple-hooks.js';
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
-    // Skip the parse when the caller (parse phase's ASTCache) already
-    // produced a Tree for this source. Cache miss = re-parse, same as
-    // before. The cachedTree parameter is typed as `unknown` at the
+    // Skip the parse when the caller (the scope-resolution orchestrator's
+    // `treeCache`) already produced a Tree for this source — empty under
+    // worker-pool runs, so cache miss = re-parse. The cachedTree parameter
+    // is typed as `unknown` at the
     // contract layer (see `LanguageProvider.emitScopeCaptures`); cast
     // here at the use site.
     let tree = cachedTree;

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -20,7 +20,6 @@ import { fileContentHash, computeChunkHash, loadParseCacheChunk, persistParseCac
 import { clearParsedFileStore, persistParsedFileChunk, getDurableParsedFileDir, loadDurableParsedFileIndex, restoreDurableParsedFileShard, } from '../../../storage/parsedfile-store.js';
 import { processRoutesFromExtracted, buildExportedTypeMapFromGraph, } from '../call-processor.js';
 import { createSemanticModel } from '../model/index.js';
-import { createASTCache } from '../ast-cache.js';
 import { getLanguageFromFilename } from '../../../_shared/index.js';
 import { readFileContents } from '../filesystem-walker.js';
 import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
@@ -328,13 +327,6 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         }
     };
     let filesParsedSoFar = 0;
-    // Chunk-local tree-sitter cache, cleared between chunks — call / heritage /
-    // import processors read it during parse to avoid re-parsing within the same
-    // chunk. (The former cross-phase `scopeTreeCache` was only ever populated by
-    // the sequential parser, which has been removed; workers can't return native
-    // Trees across the MessageChannel, so scope-resolution re-parses as needed.)
-    const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0);
-    const astCache = createASTCache(maxChunkFiles);
     const exportedTypeMap = new Map();
     const bindingAccumulator = new BindingAccumulator();
     const allFetchCalls = [];
@@ -494,7 +486,6 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 }
             }
             filesParsedSoFar += chunkFiles.length;
-            astCache.clear();
             if (verboseThroughputLog && chunkStartMs !== null) {
                 const elapsedMs = Date.now() - chunkStartMs;
                 const filesPerSec = elapsedMs > 0 ? (chunkFiles.length * 1000) / elapsedMs : 0;
@@ -747,7 +738,6 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // Finalize the accumulator and propagate any fixpoint-inferred exports before
     // `crossFile` disposes it downstream. Wrapped in try/catch so a cleanup
     // failure never masks a real parse error; disposal stays with `crossFile`.
-    astCache.clear();
     try {
         bindingAccumulator.finalize();
         const enriched = enrichExportedTypeMap(bindingAccumulator, graph, exportedTypeMap);

package/dist/core/ingestion/workers/parse-worker.js

@@ -1888,7 +1888,21 @@ parentPort.on('message', (msg) => {
         }
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        parentPort.postMessage({ type: 'error', error: message });
+        // Carry the worker-side stack across the MessageChannel, not just the
+        // message. Without this, an unexpected worker throw (e.g. the minified
+        // `this.#<x> is not a function` family) reaches the operator as a bare
+        // one-liner with no file:line — exactly what made #2068 undebuggable. The
+        // pool embeds `errorStack` into its death/circuit-breaker reason so the
+        // surfaced "Phase 'parse' failed" message points at the real frame (the
+        // stack's first line already carries the error's type + message). We send
+        // primitive fields (not the raw Error) so a non-cloneable `cause` payload
+        // can never turn the report itself into a `messageerror`. `errorStack` is
+        // optional on the wire, so an older pool ignores it.
+        const e = err instanceof Error ? err : new Error(String(err));
+        parentPort.postMessage({
+            type: 'error',
+            error: e.message,
+            errorStack: e.stack,
+        });
     }
 });

package/dist/core/ingestion/workers/worker-pool.js

@@ -356,6 +356,24 @@ function withStderr(worker, message) {
     const tail = workerStderrTail(worker);
     return tail ? `${message}. Worker stderr:\n${tail}` : message;
 }
+/**
+ * Build a worker-death reason string that carries the worker-side stack when one
+ * is available (#2068). The stack is appended AFTER the `Worker N error: <msg>`
+ * prefix so every prefix/substring consumer downstream — recoverAndResume →
+ * handleWorkerDeath → the circuit-breaker `WorkerPoolDispatchError` message, and
+ * the tests that regex-match those — keeps working unchanged, while the operator
+ * now gets the real frame instead of a bare one-liner. The stack's first line is
+ * normally the message itself; keeping both is harmless and the indented block
+ * scans cleanly in a log. The stack is capped at WORKER_STDERR_TAIL_LIMIT,
+ * mirroring the sibling stderr-tail bound, so a pathological error type (or a
+ * raised `Error.stackTraceLimit`) can't bloat the death reason. `stack` is
+ * `undefined` for an older worker build (or a thrown non-Error), in which case
+ * the reason is exactly the prior message-only form.
+ */
+function workerErrorReason(workerIndex, message, stack) {
+    const base = `Worker ${workerIndex} error: ${message}`;
+    return stack ? `${base}\n  worker stack:\n${stack.slice(0, WORKER_STDERR_TAIL_LIMIT)}` : base;
+}
 /**
  * Wait for a freshly-spawned replacement worker to emit the
  * `{type:'ready'}` handshake from `parse-worker.ts` before treating its
@@ -1338,7 +1356,7 @@ export const createWorkerPool = (workerUrl, poolSize, options) => {
                     else if (msg.type === 'error') {
                         settled = true;
                         cleanup();
-                        void recoverAndResume(`Worker ${workerIndex} error: ${msg.error}`, resolveExcludePaths());
+                        void recoverAndResume(workerErrorReason(workerIndex, msg.error, msg.errorStack), resolveExcludePaths());
                     }
                     else if (msg.type === 'result') {
                         if (!waitingForFlush) {
@@ -1379,7 +1397,12 @@ export const createWorkerPool = (workerUrl, poolSize, options) => {
                     if (!settled) {
                         settled = true;
                         cleanup();
-                        void recoverAndResume(`Worker ${workerIndex} error: ${err.message}`, resolveExcludePaths());
+                        // The Node 'error' event fires on an UNCAUGHT worker throw (one that
+                        // escaped the worker's own try/catch, or an async rejection). Unlike
+                        // the `{type:'error'}` message, the event delivers a real Error whose
+                        // `.stack` is the worker-side frame — carry it so the surfaced reason
+                        // points at the actual failure site, not just `err.message` (#2068).
+                        void recoverAndResume(workerErrorReason(workerIndex, err.message, err.stack), resolveExcludePaths());
                     }
                 };
                 const exitHandler = (code) => {

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

@@ -7,6 +7,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import lbug from '@ladybugdb/core';
+import { closeQueryResults } from './query-result-utils.js';
 import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, STALE_HASH_SENTINEL, } from './schema.js';
 import { streamAllCSVsToDisk } from './csv-generator.js';
 import { extensionManager } from './extension-loader.js';
@@ -153,8 +154,19 @@ const DB_LOCK_RETRY_DELAY_MS = 500;
  * analyze` and either already happened or will happen on the next run.
  */
 export const isReadOnlyDbError = (err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    return /read-only database/i.test(msg);
+    // Walk the `cause` chain (bounded) so a wrapped read-only error — e.g. the
+    // pool adapter's `new Error('…read-only.', { cause: nativeReadOnlyErr })` —
+    // is still detected by callers that only see the wrapper (#2068 follow-up).
+    // The same strict regex is re-applied at each level, so a non-read-only
+    // chain stays false; the depth bound guards a cyclic `cause`.
+    let cur = err;
+    for (let depth = 0; depth < 5 && cur != null; depth++) {
+        const msg = cur instanceof Error ? cur.message : String(cur);
+        if (/read-only database/i.test(msg))
+            return true;
+        cur = cur instanceof Error ? cur.cause : undefined;
+    }
+    return false;
 };
 const isMissingFileError = (err) => {
     const errno = err;
@@ -301,13 +313,10 @@ const runWithSessionLock = async (operation) => {
     }
 };
 const normalizeCopyPath = (filePath) => toNativeSafePath(filePath).replace(/\\/g, '/');
+// Single-result convenience wrapper over the shared best-effort closer
+// (drainQueryResult / readQueryRows close one cursor at a time).
 const closeQueryResult = async (result) => {
-    try {
-        await result.close();
-    }
-    catch {
-        // Best-effort cleanup only.
-    }
+    await closeQueryResults(result);
 };
 const drainQueryResult = async (queryResult) => {
     const results = Array.isArray(queryResult) ? queryResult : [queryResult];
@@ -1544,8 +1553,9 @@ export const queryImporters = async (targetFilePath) => {
     WHERE r.type = 'IMPORTS' AND b.filePath = '${escaped}'
     RETURN DISTINCT a.filePath AS importer
   `;
+    let queryResult;
     try {
-        const queryResult = await conn.query(cypher);
+        queryResult = await conn.query(cypher);
         const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
         const rows = await result.getAll();
         const out = [];
@@ -1559,6 +1569,10 @@ export const queryImporters = async (targetFilePath) => {
     catch {
         return [];
     }
+    finally {
+        if (queryResult)
+            await closeQueryResults(queryResult);
+    }
 };
 /**
  * Drop every Community and Process node (and their MEMBER_OF /
@@ -1573,8 +1587,9 @@ export const deleteAllCommunitiesAndProcesses = async () => {
     }
     let nodesDeleted = 0;
     for (const label of ['Community', 'Process']) {
+        let countResult;
         try {
-            const countResult = await conn.query(`MATCH (n:${label}) RETURN count(n) AS cnt`);
+            countResult = await conn.query(`MATCH (n:${label}) RETURN count(n) AS cnt`);
             const result = Array.isArray(countResult) ? countResult[0] : countResult;
             const rows = await result.getAll();
             const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0);
@@ -1586,6 +1601,10 @@ export const deleteAllCommunitiesAndProcesses = async () => {
         catch {
             // Table may not exist yet on a freshly-initialized DB — fine.
         }
+        finally {
+            if (countResult)
+                await closeQueryResults(countResult);
+        }
     }
     return { nodesDeleted };
 };

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

@@ -17,6 +17,7 @@
 import fs from 'fs/promises';
 import lbug from '@ladybugdb/core';
 import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js';
+import { closeQueryResults } from './query-result-utils.js';
 import { createLbugDatabase, isWalCorruptionError, toNativeSafePath, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
 import { isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
 const pool = new Map();
@@ -112,6 +113,18 @@ function closeOne(repoId) {
     if (!entry)
         return;
     entry.closed = true;
+    // Reject any callers still queued for a connection: the pool is going away
+    // (re-init / teardown / LRU eviction), so they must fail fast with an
+    // actionable error instead of hanging until WAITER_TIMEOUT_MS and then
+    // surfacing a misleading "pool exhausted" (#2068 follow-up). Draining the
+    // queue also guarantees checkin() below finds no waiter expecting a
+    // connection, so a connection returned after close is simply closed.
+    if (entry.waiters.length > 0) {
+        const closedErr = new Error(`LadybugDB connection pool closed for repo "${repoId}" (re-init/teardown); retry the query.`);
+        for (const waiter of entry.waiters)
+            waiter.reject(closedErr);
+        entry.waiters.length = 0;
+    }
     // Close available connections — fire-and-forget with .catch() to prevent
     // unhandled rejections.  Native close() returns Promise<void> but can crash
     // the N-API destructor on macOS/Windows; deferring to process exit lets
@@ -575,15 +588,21 @@ function checkout(entry) {
     }
     // At capacity — queue the caller with a timeout.
     return new Promise((resolve, reject) => {
-        const waiter = (conn) => {
-            clearTimeout(timer);
-            resolve(conn);
+        const waiter = {
+            resolve: (conn) => {
+                clearTimeout(timer);
+                resolve(conn);
+            },
+            reject: (err) => {
+                clearTimeout(timer);
+                reject(err);
+            },
         };
         const timer = setTimeout(() => {
             const idx = entry.waiters.indexOf(waiter);
             if (idx !== -1)
                 entry.waiters.splice(idx, 1);
-            reject(new Error(`Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`));
+            waiter.reject(new Error(`Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`));
         }, WAITER_TIMEOUT_MS);
         entry.waiters.push(waiter);
     });
@@ -604,7 +623,7 @@ function checkin(entry, conn) {
     if (entry.waiters.length > 0) {
         // Hand directly to the next waiter — no intermediate available state
         const waiter = entry.waiters.shift();
-        waiter(conn);
+        waiter.resolve(conn);
     }
     else {
         entry.checkedOut--;
@@ -639,24 +658,36 @@ export const executeParameterized = async (repoId, cypher, params) => {
     const conn = await checkout(entry);
     silenceStdout();
     activeQueryCount++;
+    let queryResult;
     try {
         const stmt = await withTimeout(conn.prepare(cypher), QUERY_TIMEOUT_MS, 'Prepare');
         if (!stmt.isSuccess()) {
             const errMsg = await stmt.getErrorMessage();
             throw new Error(`Prepare failed: ${errMsg}`);
         }
-        const queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute');
+        queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute');
         const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
         const rows = await result.getAll();
         return rows;
     }
     catch (err) {
         if (isReadOnlyDbError(err)) {
-            throw new Error('Write operations are not allowed. The pool adapter is read-only.');
+            // Preserve the native error as `cause` so the original frame/message is
+            // not lost behind the friendly read-only message (#2068 follow-up).
+            throw new Error('Write operations are not allowed. The pool adapter is read-only.', {
+                cause: err,
+            });
         }
         throw err;
     }
     finally {
+        // Close the native QueryResult cursor(s) before returning the connection —
+        // getAll() drains rows but does not release the native cursor, so without
+        // this the cursor leaks for the connection's lifetime (#2068 follow-up).
+        // Best-effort via the shared helper; never masks the query result or a real
+        // error.
+        if (queryResult)
+            await closeQueryResults(queryResult);
         activeQueryCount--;
         restoreStdout();
         checkin(entry, conn);

package/dist/core/lbug/query-result-utils.d.ts

@@ -0,0 +1,19 @@
+import lbug from '@ladybugdb/core';
+/**
+ * Best-effort close of one or more native `QueryResult` cursors.
+ *
+ * `result.getAll()` materializes rows into a JS array but does not release the
+ * native cursor — leaving it open holds native resources for the connection's
+ * lifetime. Both the pooled adapter (`pool-adapter.ts`) and the direct adapter
+ * (`lbug-adapter.ts`) must release cursors after reading; this is the single
+ * shared implementation so neither re-rolls the array-normalize + swallow loop
+ * (a #2068 follow-up de-dup). Lives in its own leaf module so the two adapters
+ * depend on it rather than on each other.
+ *
+ * `conn.execute()` can return either a single `QueryResult` or an array
+ * (multi-statement); this normalizes both. Each close is independent and
+ * best-effort: a failing or absent `close()` on one cursor never throws and
+ * never prevents the others from closing — a cleanup failure must not mask the
+ * query result or a real error at the call site.
+ */
+export declare function closeQueryResults(queryResult: lbug.QueryResult | lbug.QueryResult[]): Promise<void>;

package/dist/core/lbug/query-result-utils.js

@@ -0,0 +1,28 @@
+/**
+ * Best-effort close of one or more native `QueryResult` cursors.
+ *
+ * `result.getAll()` materializes rows into a JS array but does not release the
+ * native cursor — leaving it open holds native resources for the connection's
+ * lifetime. Both the pooled adapter (`pool-adapter.ts`) and the direct adapter
+ * (`lbug-adapter.ts`) must release cursors after reading; this is the single
+ * shared implementation so neither re-rolls the array-normalize + swallow loop
+ * (a #2068 follow-up de-dup). Lives in its own leaf module so the two adapters
+ * depend on it rather than on each other.
+ *
+ * `conn.execute()` can return either a single `QueryResult` or an array
+ * (multi-statement); this normalizes both. Each close is independent and
+ * best-effort: a failing or absent `close()` on one cursor never throws and
+ * never prevents the others from closing — a cleanup failure must not mask the
+ * query result or a real error at the call site.
+ */
+export async function closeQueryResults(queryResult) {
+    const results = Array.isArray(queryResult) ? queryResult : [queryResult];
+    for (const r of results) {
+        try {
+            await r?.close();
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+}

package/dist/mcp/local/local-backend.js

@@ -143,7 +143,20 @@ function logQueryError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.error({ context, err: msg }, 'GitNexus query failed');
 }
-const isReadOnlyDbError = (err) => /read-only database/i.test(err instanceof Error ? err.message : String(err));
+const isReadOnlyDbError = (err) => {
+    // Walk the `cause` chain (bounded) so a wrapped read-only error (e.g. the
+    // pool adapter's `{ cause }` wrapper) is still detected here — this is the
+    // copy the MCP cypher handler uses to surface its curated read-only message
+    // (#2068 follow-up). Mirrors lbug-adapter's isReadOnlyDbError.
+    let cur = err;
+    for (let depth = 0; depth < 5 && cur != null; depth++) {
+        const msg = cur instanceof Error ? cur.message : String(cur);
+        if (/read-only database/i.test(msg))
+            return true;
+        cur = cur instanceof Error ? cur.cause : undefined;
+    }
+    return false;
+};
 /**
  * Per-query latency telemetry for production aggregation (#553).
  *

package/dist/types/pipeline.d.ts

@@ -17,9 +17,12 @@ export interface PipelineResult {
      */
     resolutionOutcomes: readonly ResolutionOutcome[];
     /**
-     * True if the parse phase spawned a worker pool for this run. False means
-     * the sequential fallback handled every chunk. Primarily a test affordance
-     * so regression suites can prove which path executed.
+     * True if a worker pool was actually constructed for this run. The worker
+     * pool is the sole parse path (sequential parsing was removed). False means
+     * no pool was needed: either there were no parseable files, or every chunk
+     * was a parse-cache hit and the cached worker output was replayed without
+     * spawning workers (a warm all-cache-hit run, #2038). Primarily a test
+     * affordance so regression suites can prove the pool engaged.
      */
     usedWorkerPool: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.156",
+  "version": "1.6.6-rc.157",
   "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",
@@ -70,7 +70,6 @@
     "ignore": "^7.0.5",
     "js-yaml": "^4.1.1",
     "jsonc-parser": "^3.3.1",
-    "lru-cache": "^11.0.0",
     "mnemonist": "^0.40.3",
     "onnxruntime-node": "^1.24.0",
     "pandemonium": "^2.4.0",

package/dist/core/ingestion/ast-cache.d.ts

@@ -1,26 +0,0 @@
-import Parser from 'tree-sitter';
-/**
- * Minimal structural shape consumers need when reading Trees back
- * through a phase-dependency boundary. Declared here so phases that
- * receive ASTCache via `getPhaseOutput<...>` don't hand-roll their
- * own inline structural types that silently drift when ASTCache's
- * contract changes.
- *
- * Typed as `unknown` at the Tree boundary because consumers on the
- * other side of the phase-output map don't share tree-sitter's type
- * graph (e.g. COBOL's standalone processor).
- */
-export interface ASTCacheReader {
-    get(filePath: string): unknown;
-    clear(): void;
-}
-export interface ASTCache extends ASTCacheReader {
-    get: (filePath: string) => Parser.Tree | undefined;
-    set: (filePath: string, tree: Parser.Tree) => void;
-    clear: () => void;
-    stats: () => {
-        size: number;
-        maxSize: number;
-    };
-}
-export declare const createASTCache: (maxSize?: number) => ASTCache;

package/dist/core/ingestion/ast-cache.js

@@ -1,48 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import { logger } from '../logger.js';
-export const createASTCache = (maxSize = 50) => {
-    const effectiveMax = Math.max(maxSize, 1);
-    // Initialize the cache with a 'dispose' handler
-    // This is the magic: When an item is evicted (dropped), this runs automatically.
-    const cache = new LRUCache({
-        max: effectiveMax,
-        dispose: (tree) => {
-            try {
-                // NOTE: web-tree-sitter has tree.delete(); native tree-sitter
-                // trees are GC-managed and .delete is absent (no-op here).
-                //
-                // Single-owner invariant (load-bearing under WASM): a given
-                // Parser.Tree reference must live in AT MOST ONE ASTCache
-                // that disposes. The parse-phase chunk-local cache clears
-                // between chunks; the cross-phase `scopeTreeCache` (also an
-                // ASTCache today) holds the same Tree by reference. Under
-                // native tree-sitter this is benign (dispose is a no-op).
-                // If/when GitNexus adopts web-tree-sitter for sequential
-                // parsing, the cross-phase cache must either (a) skip
-                // writing Trees that are already owned by a disposing cache,
-                // or (b) use tree.copy() per entry. Failing to pick one
-                // will hand freed memory to scope-resolution.
-                tree.delete?.();
-            }
-            catch (e) {
-                logger.warn({ e }, 'Failed to delete tree from WASM memory');
-            }
-        },
-    });
-    return {
-        get: (filePath) => {
-            const tree = cache.get(filePath);
-            return tree; // Returns undefined if not found
-        },
-        set: (filePath, tree) => {
-            cache.set(filePath, tree);
-        },
-        clear: () => {
-            cache.clear();
-        },
-        stats: () => ({
-            size: cache.size,
-            maxSize: effectiveMax,
-        }),
-    };
-};

package/dist/core/ingestion/pipeline-phases/orm-extraction.d.ts

@@ -1,22 +0,0 @@
-/**
- * Inline ORM query extraction (sequential fallback path).
- *
- * Extracts Prisma and Supabase query calls from source content using
- * regex patterns. Used by the sequential parse path when workers are
- * not available — the worker path extracts ORM queries via tree-sitter
- * queries instead.
- *
- * @module
- */
-import type { ExtractedORMQuery } from '../workers/parse-worker.js';
-/**
- * Extract ORM query calls from file content using regex.
- *
- * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
- * Results are appended to the `out` array (push pattern avoids allocation).
- *
- * @param filePath  Relative path of the source file
- * @param content   File content string
- * @param out       Output array to append extracted queries to
- */
-export declare function extractORMQueriesInline(filePath: string, content: string, out: ExtractedORMQuery[]): void;

package/dist/core/ingestion/pipeline-phases/orm-extraction.js

@@ -1,92 +0,0 @@
-/**
- * Inline ORM query extraction (sequential fallback path).
- *
- * Extracts Prisma and Supabase query calls from source content using
- * regex patterns. Used by the sequential parse path when workers are
- * not available — the worker path extracts ORM queries via tree-sitter
- * queries instead.
- *
- * @module
- */
-// ── Regex patterns ─────────────────────────────────────────────────────────
-/** Matches Prisma client method calls: `prisma.user.findMany(...)` */
-const PRISMA_QUERY_RE = /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g;
-/** Matches Supabase client method calls: `supabase.from('users').select(...)` */
-const SUPABASE_QUERY_RE = /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g;
-// ── Extraction function ───────────────────────────────────────────────────
-/**
- * Extract ORM query calls from file content using regex.
- *
- * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
- * Results are appended to the `out` array (push pattern avoids allocation).
- *
- * @param filePath  Relative path of the source file
- * @param content   File content string
- * @param out       Output array to append extracted queries to
- */
-export function extractORMQueriesInline(filePath, content, out) {
-    const hasPrisma = content.includes('prisma.');
-    const hasSupabase = content.includes('supabase.from');
-    if (!hasPrisma && !hasSupabase)
-        return;
-    // Pre-compute line number offsets to avoid O(n²) substring+split per match
-    const lineOffsets = buildLineOffsets(content);
-    if (hasPrisma) {
-        PRISMA_QUERY_RE.lastIndex = 0;
-        let m;
-        while ((m = PRISMA_QUERY_RE.exec(content)) !== null) {
-            const model = m[1];
-            if (model.startsWith('$'))
-                continue;
-            out.push({
-                filePath,
-                orm: 'prisma',
-                model,
-                method: m[2],
-                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
-            });
-        }
-    }
-    if (hasSupabase) {
-        SUPABASE_QUERY_RE.lastIndex = 0;
-        let m;
-        while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) {
-            out.push({
-                filePath,
-                orm: 'supabase',
-                model: m[1],
-                method: m[2],
-                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
-            });
-        }
-    }
-}
-// ── Line offset helpers ───────────────────────────────────────────────────
-/** Build an array of byte offsets where each newline occurs (O(n) once). */
-function buildLineOffsets(content) {
-    const offsets = [];
-    for (let i = 0; i < content.length; i++) {
-        if (content[i] === '\n')
-            offsets.push(i);
-    }
-    return offsets;
-}
-/**
- * Binary search for 0-based line number at a given character offset.
- *
- * Returns the number of newlines that occur before `offset` in the content,
- * which is the 0-based line number. When `offset` is beyond the last newline,
- * returns `lineOffsets.length` (i.e., the last line index).
- */
-function lineNumberAtOffset(lineOffsets, offset) {
-    let lo = 0;
-    let hi = lineOffsets.length;
-    while (lo < hi) {
-        const mid = (lo + hi) >>> 1;
-        if (lineOffsets[mid] < offset)
-            lo = mid + 1;
-        else
-            hi = mid;
-    }
-    return lo;
-}