gitnexus 1.5.2 → 1.6.0

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

@@ -0,0 +1,522 @@
+/**
+ * LadybugDB connection pool (core). Used by MCP, sync, search, wiki, etc.
+ *
+ * LadybugDB Adapter (Connection Pool)
+ *
+ * Manages a pool of LadybugDB databases keyed by repoId, each with
+ * multiple Connection objects for safe concurrent query execution.
+ *
+ * LadybugDB Connections are NOT thread-safe — a single Connection
+ * segfaults if concurrent .query() calls hit it simultaneously.
+ * This adapter provides a checkout/return connection pool so each
+ * concurrent query gets its own Connection from the same Database.
+ *
+ * @see https://docs.ladybugdb.com/concurrency — multiple Connections
+ * from the same Database is the officially supported concurrency pattern.
+ */
+import fs from 'fs/promises';
+import lbug from '@ladybugdb/core';
+const pool = new Map();
+const dbCache = new Map();
+/** Max repos in the pool (LRU eviction) */
+const MAX_POOL_SIZE = 5;
+/** Idle timeout before closing a repo's connections */
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/** Max connections per repo (caps concurrent queries per repo) */
+const MAX_CONNS_PER_REPO = 8;
+let idleTimer = null;
+/** Saved real stdout/stderr write — used to silence native module output without race conditions */
+export const realStdoutWrite = process.stdout.write.bind(process.stdout);
+export const realStderrWrite = process.stderr.write.bind(process.stderr);
+let stdoutSilenceCount = 0;
+/** True while pre-warming connections — prevents watchdog from prematurely restoring stdout */
+let preWarmActive = false;
+/**
+ * Start the idle cleanup timer (runs every 60s)
+ */
+function ensureIdleTimer() {
+    if (idleTimer)
+        return;
+    idleTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [repoId, entry] of pool) {
+            if (now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) {
+                closeOne(repoId);
+            }
+        }
+    }, 60_000);
+    if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) {
+        idleTimer.unref();
+    }
+}
+/**
+ * Touch a repo to reset its idle timeout.
+ * Call this during long-running operations to prevent the connection from being closed.
+ */
+export const touchRepo = (repoId) => {
+    const entry = pool.get(repoId);
+    if (entry) {
+        entry.lastUsed = Date.now();
+    }
+};
+/**
+ * Evict the least-recently-used repo if pool is at capacity
+ */
+function evictLRU() {
+    if (pool.size < MAX_POOL_SIZE)
+        return;
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of pool) {
+        if (entry.checkedOut === 0 && entry.lastUsed < oldestTime) {
+            oldestTime = entry.lastUsed;
+            oldestId = id;
+        }
+    }
+    if (oldestId) {
+        closeOne(oldestId);
+    }
+}
+/**
+ * Remove a repo from the pool, close its connections, and release its
+ * shared Database ref.  Only closes the Database when no other repoIds
+ * reference it (refCount === 0).
+ */
+function closeOne(repoId) {
+    const entry = pool.get(repoId);
+    if (!entry)
+        return;
+    entry.closed = true;
+    // 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
+    // dangerouslyIgnoreUnhandledErrors absorb the crash.
+    for (const conn of entry.available) {
+        conn.close().catch(() => { });
+    }
+    entry.available.length = 0;
+    // Checked-out connections can't be closed here — they're in-flight.
+    // The checkin() function detects entry.closed and closes them on return.
+    // Only close the Database when no other repoIds reference it.
+    // External databases (injected via initLbugWithDb) are never closed here —
+    // the core adapter owns them and handles their lifecycle.
+    const shared = dbCache.get(entry.dbPath);
+    if (shared) {
+        shared.refCount--;
+        if (shared.refCount === 0) {
+            if (shared.external) {
+                // External databases are owned by the core adapter — don't close
+                // or remove from cache.  Keep the entry so future initLbug() calls
+                // for the same dbPath reuse it instead of hitting a file lock.
+                shared.refCount = 0;
+                shared.ftsLoaded = false;
+                shared.vectorLoaded = false;
+            }
+            else {
+                shared.db.close().catch(() => { });
+                dbCache.delete(entry.dbPath);
+            }
+        }
+    }
+    pool.delete(repoId);
+}
+/**
+ * Create a new Connection from a repo's Database.
+ * Silences stdout to prevent native module output from corrupting MCP stdio.
+ */
+let activeQueryCount = 0;
+/**
+ * Silence stdout by replacing process.stdout.write with a no-op.
+ * Uses a reference counter so nested silence/restore pairs are safe.
+ * Exported so other modules (e.g. embedder) use the same mechanism instead
+ * of independently patching stdout, which causes restore-order conflicts.
+ */
+export function silenceStdout() {
+    if (stdoutSilenceCount++ === 0) {
+        process.stdout.write = (() => true);
+    }
+}
+export function restoreStdout() {
+    if (--stdoutSilenceCount <= 0) {
+        stdoutSilenceCount = 0;
+        process.stdout.write = realStdoutWrite;
+    }
+}
+// Safety watchdog: restore stdout if it gets stuck silenced (e.g. native crash
+// inside createConnection before restoreStdout runs).
+// Exempts active queries and pre-warm — these legitimately hold silence for
+// longer than 1 second (queries can take up to QUERY_TIMEOUT_MS = 30s).
+setInterval(() => {
+    if (stdoutSilenceCount > 0 && !preWarmActive && activeQueryCount === 0) {
+        stdoutSilenceCount = 0;
+        process.stdout.write = realStdoutWrite;
+    }
+}, 1000).unref();
+function createConnection(db) {
+    silenceStdout();
+    try {
+        return new lbug.Connection(db);
+    }
+    finally {
+        restoreStdout();
+    }
+}
+/** Query timeout in milliseconds */
+const QUERY_TIMEOUT_MS = 30_000;
+/** Waiter queue timeout in milliseconds */
+const WAITER_TIMEOUT_MS = 15_000;
+const LOCK_RETRY_ATTEMPTS = 3;
+const LOCK_RETRY_DELAY_MS = 2000;
+/** Deduplicates concurrent initLbug calls for the same repoId */
+const initPromises = new Map();
+/**
+ * Initialize (or reuse) a Database + connection pool for a specific repo.
+ * Retries on lock errors (e.g., when `gitnexus analyze` is running).
+ *
+ * Concurrent calls for the same repoId are deduplicated — the second caller
+ * awaits the first's in-progress init rather than starting a redundant one.
+ */
+export const initLbug = async (repoId, dbPath) => {
+    const existing = pool.get(repoId);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return;
+    }
+    // Deduplicate concurrent init calls for the same repoId —
+    // prevents double-init race when multiple parallel tool calls
+    // trigger initialization for the same repo simultaneously.
+    const pending = initPromises.get(repoId);
+    if (pending)
+        return pending;
+    const promise = doInitLbug(repoId, dbPath);
+    initPromises.set(repoId, promise);
+    try {
+        await promise;
+    }
+    finally {
+        initPromises.delete(repoId);
+    }
+};
+/**
+ * Internal init — creates DB, pre-warms connections, loads FTS, then registers pool.
+ * Pool entry is registered LAST so concurrent executeQuery calls see either
+ * "not initialized" (and throw) or a fully ready pool — never a half-built one.
+ */
+async function doInitLbug(repoId, dbPath) {
+    // Check if database exists
+    try {
+        await fs.stat(dbPath);
+    }
+    catch {
+        throw new Error(`LadybugDB not found at ${dbPath}. Run: gitnexus analyze`);
+    }
+    evictLRU();
+    // Reuse an existing native Database if another repoId already opened this path.
+    // This prevents buffer manager exhaustion from multiple mmap regions on the same file.
+    let shared = dbCache.get(dbPath);
+    if (!shared) {
+        // Open in read-only mode — MCP server never writes to the database.
+        // This allows multiple MCP server instances to read concurrently, and
+        // avoids lock conflicts when `gitnexus analyze` is writing.
+        let lastError = null;
+        for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
+            silenceStdout();
+            try {
+                const db = new lbug.Database(dbPath, 0, // bufferManagerSize (default)
+                false, // enableCompression (default)
+                true);
+                restoreStdout();
+                shared = { db, refCount: 0, ftsLoaded: false, vectorLoaded: false };
+                dbCache.set(dbPath, shared);
+                break;
+            }
+            catch (err) {
+                restoreStdout();
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const isLockError = lastError.message.includes('Could not set lock') || lastError.message.includes('lock');
+                if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
+            }
+        }
+        if (!shared) {
+            throw new Error(`LadybugDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
+                `Retry later. (${lastError?.message || 'unknown error'})`);
+        }
+    }
+    shared.refCount++;
+    const db = shared.db;
+    // Pre-create the full pool upfront so createConnection() (which silences
+    // stdout) is never called lazily during active query execution.
+    // Mark preWarmActive so the watchdog timer doesn't interfere.
+    preWarmActive = true;
+    const available = [];
+    try {
+        for (let i = 0; i < MAX_CONNS_PER_REPO; i++) {
+            available.push(createConnection(db));
+        }
+    }
+    finally {
+        preWarmActive = false;
+    }
+    // Load FTS extension once per shared Database.
+    // Done BEFORE pool registration so no concurrent checkout can grab
+    // the connection while the async FTS load is in progress.
+    if (!shared.ftsLoaded) {
+        try {
+            await available[0].query('LOAD EXTENSION fts');
+            shared.ftsLoaded = true;
+        }
+        catch {
+            // Extension may not be installed — FTS queries will fail gracefully
+        }
+    }
+    // Load VECTOR extension once per shared Database for semantic search support.
+    if (!shared.vectorLoaded) {
+        try {
+            await available[0].query('INSTALL VECTOR');
+            await available[0].query('LOAD EXTENSION VECTOR');
+            shared.vectorLoaded = true;
+        }
+        catch {
+            // VECTOR extension may not be available
+        }
+    }
+    // Register pool entry only after all connections are pre-warmed and FTS is
+    // loaded.  Concurrent executeQuery calls see either "not initialized"
+    // (and throw cleanly) or a fully ready pool — never a half-built one.
+    pool.set(repoId, {
+        db,
+        available,
+        checkedOut: 0,
+        waiters: [],
+        lastUsed: Date.now(),
+        dbPath,
+        closed: false,
+    });
+    ensureIdleTimer();
+}
+/**
+ * Initialize a pool entry from a pre-existing Database object.
+ *
+ * Used in tests to avoid the writable→close→read-only cycle that crashes
+ * on macOS due to N-API destructor segfaults.  The pool adapter reuses
+ * the core adapter's writable Database instead of opening a new read-only one.
+ *
+ * The Database is registered in the shared dbCache so closeOne() decrements
+ * the refCount correctly.  If the Database is already cached (e.g. another
+ * repoId already injected it), the existing entry is reused.
+ */
+export async function initLbugWithDb(repoId, existingDb, dbPath) {
+    const existing = pool.get(repoId);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return;
+    }
+    // Register in dbCache with external: true so other initLbug() calls
+    // for the same dbPath reuse this Database instead of trying to open
+    // a new one (which would fail with a file lock error).
+    // closeOne() respects the external flag and skips db.close().
+    let shared = dbCache.get(dbPath);
+    if (!shared) {
+        shared = { db: existingDb, refCount: 0, ftsLoaded: false, vectorLoaded: false, external: true };
+        dbCache.set(dbPath, shared);
+    }
+    shared.refCount++;
+    const available = [];
+    preWarmActive = true;
+    try {
+        for (let i = 0; i < MAX_CONNS_PER_REPO; i++) {
+            available.push(createConnection(existingDb));
+        }
+    }
+    finally {
+        preWarmActive = false;
+    }
+    // Load FTS extension if not already loaded on this Database
+    if (!shared.ftsLoaded) {
+        try {
+            await available[0].query('LOAD EXTENSION fts');
+            shared.ftsLoaded = true;
+        }
+        catch {
+            // Extension may already be loaded or not installed
+        }
+    }
+    // Load VECTOR extension for semantic search support
+    if (!shared.vectorLoaded) {
+        try {
+            await available[0].query('INSTALL VECTOR');
+            await available[0].query('LOAD EXTENSION VECTOR');
+            shared.vectorLoaded = true;
+        }
+        catch {
+            // VECTOR extension may not be available
+        }
+    }
+    pool.set(repoId, {
+        db: existingDb,
+        available,
+        checkedOut: 0,
+        waiters: [],
+        lastUsed: Date.now(),
+        dbPath,
+        closed: false,
+    });
+    ensureIdleTimer();
+}
+/**
+ * Checkout a connection from the pool.
+ * Returns an available connection, or creates a new one if under the cap.
+ * If all connections are busy and at cap, queues the caller until one is returned.
+ */
+function checkout(entry) {
+    // Fast path: grab an available connection
+    if (entry.available.length > 0) {
+        entry.checkedOut++;
+        return Promise.resolve(entry.available.pop());
+    }
+    // Pool was pre-warmed to MAX_CONNS_PER_REPO during init.  If we're here
+    // with fewer total connections, something leaked — surface the bug rather
+    // than silently creating a connection (which would silence stdout mid-query).
+    const totalConns = entry.available.length + entry.checkedOut;
+    if (totalConns < MAX_CONNS_PER_REPO) {
+        throw new Error(`Connection pool integrity error: expected ${MAX_CONNS_PER_REPO} ` +
+            `connections but found ${totalConns} (${entry.available.length} available, ` +
+            `${entry.checkedOut} checked out)`);
+    }
+    // At capacity — queue the caller with a timeout.
+    return new Promise((resolve, reject) => {
+        const waiter = (conn) => {
+            clearTimeout(timer);
+            resolve(conn);
+        };
+        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_TIMEOUT_MS);
+        entry.waiters.push(waiter);
+    });
+}
+/**
+ * Return a connection to the pool after use.
+ * If the pool entry was closed while the connection was checked out (e.g.
+ * LRU eviction), close the orphaned connection instead of returning it.
+ * If there are queued waiters, hand the connection directly to the next one
+ * instead of putting it back in the available array (avoids race conditions).
+ */
+function checkin(entry, conn) {
+    if (entry.closed) {
+        // Pool entry was deleted during checkout — close the orphaned connection
+        conn.close().catch(() => { });
+        return;
+    }
+    if (entry.waiters.length > 0) {
+        // Hand directly to the next waiter — no intermediate available state
+        const waiter = entry.waiters.shift();
+        waiter(conn);
+    }
+    else {
+        entry.checkedOut--;
+        entry.available.push(conn);
+    }
+}
+/**
+ * Execute a query on a specific repo's connection pool.
+ * Automatically checks out a connection, runs the query, and returns it.
+ */
+/** Race a promise against a timeout */
+function withTimeout(promise, ms, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+export const executeQuery = async (repoId, cypher) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
+    }
+    if (isWriteQuery(cypher)) {
+        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
+    }
+    entry.lastUsed = Date.now();
+    const conn = await checkout(entry);
+    silenceStdout();
+    activeQueryCount++;
+    try {
+        const queryResult = await withTimeout(conn.query(cypher), QUERY_TIMEOUT_MS, 'Query');
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        return rows;
+    }
+    finally {
+        activeQueryCount--;
+        restoreStdout();
+        checkin(entry, conn);
+    }
+};
+/**
+ * Execute a parameterized query on a specific repo's connection pool.
+ * Uses prepare/execute pattern to prevent Cypher injection.
+ */
+export const executeParameterized = async (repoId, cypher, params) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
+    }
+    entry.lastUsed = Date.now();
+    const conn = await checkout(entry);
+    silenceStdout();
+    activeQueryCount++;
+    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');
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        return rows;
+    }
+    finally {
+        activeQueryCount--;
+        restoreStdout();
+        checkin(entry, conn);
+    }
+};
+/**
+ * Close one or all repo pools.
+ * If repoId is provided, close only that repo's connections.
+ * If omitted, close all repos.
+ */
+export const closeLbug = async (repoId) => {
+    if (repoId) {
+        closeOne(repoId);
+        return;
+    }
+    for (const id of [...pool.keys()]) {
+        closeOne(id);
+    }
+    if (idleTimer) {
+        clearInterval(idleTimer);
+        idleTimer = null;
+    }
+};
+/**
+ * Check if a specific repo's pool is active
+ */
+export const isLbugReady = (repoId) => pool.has(repoId);
+/** Regex to detect write operations in user-supplied Cypher queries.
+ * Note: CALL is NOT blocked — it's used for read-only FTS (CALL QUERY_FTS_INDEX)
+ * and vector search (CALL QUERY_VECTOR_INDEX). The database is opened in
+ * read-only mode as defense-in-depth against write procedures. */
+export const CYPHER_WRITE_RE = /(?<!:)\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH|FOREACH|INSTALL|LOAD)\b/i;
+/** Check if a Cypher query contains write operations */
+export function isWriteQuery(query) {
+    return CYPHER_WRITE_RE.test(query);
+}

package/dist/core/run-analyze.d.ts

@@ -18,6 +18,8 @@ export interface AnalyzeOptions {
     skipGit?: boolean;
     /** Skip AGENTS.md and CLAUDE.md gitnexus block updates. */
     skipAgentsMd?: boolean;
+    /** Omit volatile symbol/relationship counts from AGENTS.md and CLAUDE.md. */
+    noStats?: boolean;
 }
 export interface AnalyzeResult {
     repoName: string;

package/dist/core/run-analyze.js

@@ -229,7 +229,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 communities: pipelineResult.communityResult?.stats.totalCommunities,
                 clusters: aggregatedClusterCount,
                 processes: pipelineResult.processResult?.stats.totalProcesses,
-            }, undefined, { skipAgentsMd: options.skipAgentsMd });
+            }, undefined, { skipAgentsMd: options.skipAgentsMd, noStats: options.noStats });
         }
         catch {
             // Best-effort — don't fail the entire analysis for context file issues

package/dist/core/search/bm25-index.js

@@ -50,7 +50,7 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
         // The MCP pool supports multiple connections, but FTS is best run serially.
-        const { executeQuery } = await import('../../mcp/core/lbug-adapter.js');
+        const { executeQuery } = await import('../lbug/pool-adapter.js');
         const executor = (cypher) => executeQuery(repoId, cypher);
         fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
         functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);

package/dist/core/tree-sitter/parser-loader.js

@@ -45,6 +45,7 @@ const languageMap = {
     ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
     [SupportedLanguages.Ruby]: Ruby,
+    [SupportedLanguages.Vue]: TypeScript.typescript,
     ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };

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

@@ -4,7 +4,7 @@
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
  * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initLbug, executeQuery, closeLbug, touchRepo } from '../../mcp/core/lbug-adapter.js';
+import { initLbug, executeQuery, closeLbug, touchRepo } from '../lbug/pool-adapter.js';
 const REPO_ID = '__wiki__';
 /**
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.

package/dist/core/wiki/html-viewer.js

@@ -49,10 +49,12 @@ function esc(text) {
         .replace(/"/g, '"');
 }
 function buildHTML(projectName, moduleTree, pages, meta) {
-    // Embed data as JSON inside the HTML
-    const pagesJSON = JSON.stringify(pages);
-    const treeJSON = JSON.stringify(moduleTree);
-    const metaJSON = JSON.stringify(meta);
+    // Embed data as JSON inside the HTML.
+    // Escape </script> sequences so they don't prematurely close the <script> tag.
+    const escScript = (s) => s.replace(/<\//g, '<\\/');
+    const pagesJSON = escScript(JSON.stringify(pages));
+    const treeJSON = escScript(JSON.stringify(moduleTree));
+    const metaJSON = escScript(JSON.stringify(meta));
     const parts = [];
     // ── Head ──
     parts.push('<!DOCTYPE html>');

package/dist/core/wiki/llm-client.js

@@ -103,12 +103,10 @@ export async function callLLM(prompt, config, systemPrompt, options) {
         model: config.model,
         messages,
     };
-    if (reasoning) {
-        body.max_completion_tokens = config.maxTokens;
-        // Do NOT include temperature, top_p, presence_penalty, frequency_penalty
-    }
-    else {
-        body.max_tokens = config.maxTokens;
+    // max_tokens is deprecated; use max_completion_tokens for all models
+    body.max_completion_tokens = config.maxTokens;
+    // Only send temperature for non-Azure providers — some Azure models reject non-default values
+    if (!reasoning && !azure && config.temperature !== undefined) {
         body.temperature = config.temperature;
     }
     if (useStream)

package/dist/mcp/core/embedder.js

@@ -6,6 +6,7 @@
  */
 import { pipeline, env } from '@huggingface/transformers';
 import { isHttpMode, getHttpDimensions, httpEmbedQuery, } from '../../core/embeddings/http-client.js';
+import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/lbug/pool-adapter.js';
 // Model config
 const MODEL_ID = 'Snowflake/snowflake-arctic-embed-xs';
 // Module-level state for singleton pattern
@@ -39,9 +40,9 @@ export const initEmbedder = async () => {
                     // Silence stdout and stderr during model load — ONNX Runtime and transformers.js
                     // may write progress/init messages that corrupt MCP stdio protocol or produce
                     // noisy warnings (e.g. node assignment to execution providers).
-                    const origStdout = process.stdout.write;
-                    const origStderr = process.stderr.write;
-                    process.stdout.write = (() => true);
+                    // Use the centralized silenceStdout() to avoid conflicts with pool-adapter's
+                    // own stdout patching (independent patching caused restore-order bugs).
+                    silenceStdout();
                     process.stderr.write = (() => true);
                     try {
                         embedderInstance = await pipeline('feature-extraction', MODEL_ID, {
@@ -50,8 +51,8 @@ export const initEmbedder = async () => {
                         });
                     }
                     finally {
-                        process.stdout.write = origStdout;
-                        process.stderr.write = origStderr;
+                        restoreStdout();
+                        process.stderr.write = realStderrWrite;
                     }
                     console.error(`GitNexus: Embedding model loaded (${device})`);
                     return embedderInstance;