gitnexus 1.6.6-rc.39 → 1.6.6-rc.40

package/dist/cli/analyze.js

@@ -374,6 +374,8 @@ async function ensureHeap() {
  */
 const ANALYZE_CLI_ENV_KEYS = [
     'GITNEXUS_VERBOSE',
+    'GITNEXUS_PROFILE_DEFERRED',
+    'GITNEXUS_PROFILE_DEFERRED_SLOW_MS',
     'GITNEXUS_MAX_FILE_SIZE',
     'GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS',
     'GITNEXUS_EMBEDDING_THREADS',

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

@@ -28,6 +28,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
 import { isRegistryPrimary } from './registry-primary-flag.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { deferredCallFileSlowMs, deferredCallLogEveryN, getDeferredProfileDroppedCount, isDeferredResolutionProfileEnabled, logDeferredProfile, profileElapsedMs, resetDeferredProfileDroppedCount, startTimer, } from './utils/deferred-resolution-profile.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { CLASS_CONTAINER_TYPES, FUNCTION_NODE_TYPES, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
@@ -2292,6 +2293,39 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
     }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
+    // Counts only files that survived the registry-primary skip — what the user
+    // is actually waiting on. Keyed by this counter, the first per-file progress
+    // log fires on the first *resolved* file rather than file #1 of byFile,
+    // which would silently land inside the skip block on mixed Python+JVM repos
+    // where the skipped language sorts first.
+    let resolvedFiles = 0;
+    const profileCalls = isDeferredResolutionProfileEnabled();
+    const slowFileMs = profileCalls ? deferredCallFileSlowMs() : 0;
+    const logEveryN = profileCalls ? deferredCallLogEveryN() : 0;
+    let skippedRegistryPrimaryFiles = 0;
+    // Fresh dropped-log counter per analyze run — the module-private counter
+    // in deferred-resolution-profile.ts is process-lived, so without a reset
+    // here it would accumulate across consecutive analyze invocations in the
+    // same Node process (e.g., the MCP server, eval harness, integration
+    // tests).
+    if (profileCalls)
+        resetDeferredProfileDroppedCount();
+    // One-pass pre-count of the eventual non-skipped total so the live progress
+    // denominator stays stable as the loop iterates. Otherwise `${totalFiles -
+    // skippedRegistryPrimaryFiles}` drifts upward — files iterated before later
+    // registry-primary skips have been seen carry an inflated denominator, and
+    // the ratio only self-corrects after every file has been classified. Pre-
+    // count runs only on the enabled path so the disabled path stays free of
+    // the extra Map iteration. Defaults to 0 on the disabled path; the live log
+    // gate is also disabled there, so the value is never read.
+    let resolvedTotal = 0;
+    if (profileCalls) {
+        for (const filePath of byFile.keys()) {
+            const lang = getLanguageFromFilename(filePath);
+            if (!lang || !isRegistryPrimary(lang))
+                resolvedTotal++;
+        }
+    }
     for (const [filePath, calls] of byFile) {
         filesProcessed++;
         if (filesProcessed % 100 === 0) {
@@ -2301,8 +2335,15 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
         // Registry-primary gate: skip Python (etc.) entirely when the
         // scope-based phase owns CALLS for this language.
         const fileLanguage = getLanguageFromFilename(filePath);
-        if (fileLanguage && isRegistryPrimary(fileLanguage))
+        if (fileLanguage && isRegistryPrimary(fileLanguage)) {
+            skippedRegistryPrimaryFiles++;
             continue;
+        }
+        resolvedFiles++;
+        const tFile = startTimer(profileCalls);
+        if (profileCalls && (resolvedFiles === 1 || resolvedFiles % logEveryN === 0)) {
+            logDeferredProfile(`calls ${resolvedFiles}/${resolvedTotal} file=${filePath} sites=${calls.length}`);
+        }
         ctx.enableCache(filePath);
         const widenCache = new Map();
         const receiverMap = fileReceiverTypes.get(filePath);
@@ -2408,6 +2449,19 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
             }
         }
         ctx.clearCache();
+        if (tFile !== null) {
+            const elapsed = profileElapsedMs(tFile);
+            if (elapsed >= slowFileMs) {
+                logDeferredProfile(`slow file ${elapsed.toFixed(0)}ms path=${filePath} calls=${calls.length} lang=${fileLanguage ?? 'unknown'}`);
+            }
+        }
+    }
+    if (profileCalls) {
+        logDeferredProfile(`processCallsFromExtracted done: ${totalFiles} files, ${extractedCalls.length} call sites, skipped registry-primary files=${skippedRegistryPrimaryFiles}`);
+        const droppedCount = getDeferredProfileDroppedCount();
+        if (droppedCount > 0) {
+            logDeferredProfile(`note: ${droppedCount} profile log lines dropped (logger errors)`);
+        }
     }
     onProgress?.(totalFiles, totalFiles);
 };

package/dist/core/ingestion/model/heritage-map.js

@@ -13,6 +13,7 @@
  *    classes implementing a given interface)
  */
 import { getLanguageFromFilename } from '../../../_shared/index.js';
+import { isDeferredResolutionProfileEnabled, logDeferredProfile, } from '../utils/deferred-resolution-profile.js';
 /**
  * Determine whether a heritage.extends capture is actually an IMPLEMENTS
  * relationship. Consults the symbol table first (authoritative — Tier 1 /
@@ -72,10 +73,35 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
     const seenParents = new Map();
     // interfaceName → Set<filePath>  (implementor lookup for interface dispatch)
     const implementorFiles = new Map();
+    const profileHeritage = isDeferredResolutionProfileEnabled();
+    let maxNameCartesian = 0;
+    let ambiguousHeritageRecords = 0;
+    let unresolvedChildLookups = 0;
+    let unresolvedParentLookups = 0;
     for (const h of heritage) {
         // ── Parent lookup (nodeId-based) ────────────────────────────────
         const childDefs = ctx.model.types.lookupClassByName(h.className);
         const parentDefs = ctx.model.types.lookupClassByName(h.parentName);
+        // Unresolved-side counters live in a separate guard so they observe
+        // records the ambiguity block below skips. On JVM monorepos the
+        // pathological fan-out case is precisely "many same-named children
+        // with an unresolved external supertype" (or the inverse) — both
+        // sides non-empty is the case `ambiguousHeritageRecords` already
+        // covers; the unresolved cases were silently dropped from the
+        // metric before this counter.
+        if (profileHeritage) {
+            if (childDefs.length === 0)
+                unresolvedChildLookups++;
+            if (parentDefs.length === 0)
+                unresolvedParentLookups++;
+        }
+        if (profileHeritage && childDefs.length > 0 && parentDefs.length > 0) {
+            const product = childDefs.length * parentDefs.length;
+            if (product > 1)
+                ambiguousHeritageRecords++;
+            if (product > maxNameCartesian)
+                maxNameCartesian = product;
+        }
         if (childDefs.length > 0 && parentDefs.length > 0) {
             for (const child of childDefs) {
                 for (const parent of parentDefs) {
@@ -249,6 +275,14 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
     const getImplementorFiles = (interfaceName) => {
         return implementorFiles.get(interfaceName) ?? EMPTY_SET;
     };
+    if (profileHeritage) {
+        logDeferredProfile(`buildHeritageMap: ${heritage.length} heritage records, ` +
+            `${ambiguousHeritageRecords} with child×parent lookup product >1, ` +
+            `max product ${maxNameCartesian}, ` +
+            `${unresolvedChildLookups} unresolved child lookups, ` +
+            `${unresolvedParentLookups} unresolved parent lookups, ` +
+            `${implementorFiles.size} interface implementor keys`);
+    }
     return {
         getParents,
         getAncestors,

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

@@ -31,6 +31,7 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { isDev } from '../utils/env.js';
 import { isVerboseIngestionEnabled } from '../utils/verbose.js';
+import { endTimer, isDeferredResolutionProfileEnabled, logDeferredProfile, startTimer, } from '../utils/deferred-resolution-profile.js';
 import { synthesizeWildcardImportBindings, needsSynthesis } from './wildcard-synthesis.js';
 import { extractORMQueriesInline } from './orm-extraction.js';
 import { logger } from '../../logger.js';
@@ -564,7 +565,13 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         //   heritage: 75 -> 80 (5)
         //   routes:   80 -> 85 (5)
         //   calls:    85 -> 95 (10)
+        const deferredProfile = isDeferredResolutionProfileEnabled();
+        if (deferredProfile) {
+            logDeferredProfile(`deferred band start: imports=${deferredWorkerImports.length} heritage=${deferredWorkerHeritage.length} ` +
+                `calls=${deferredWorkerCalls.length} routes=${allExtractedRoutes.length}`);
+        }
         if (deferredWorkerImports.length > 0) {
+            const tImports = startTimer(deferredProfile);
             await processImportsFromExtracted(graph, allPathObjects, deferredWorkerImports, ctx, (current, total) => {
                 const ratio = total > 0 ? current / total : 1;
                 onProgress({
@@ -579,6 +586,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             }, repoPath, importCtx);
+            endTimer(tImports, (ms) => `processImportsFromExtracted: ${ms.toFixed(0)}ms (${deferredWorkerImports.length} import batches before drain)`);
             // U15 (lightweight M1): processImportsFromExtracted is the sole
             // consumer of `deferredWorkerImports`. Free the array now so the
             // GC can reclaim the per-file ExtractedImport records before the
@@ -590,8 +598,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             deferredWorkerImports.length = 0;
         }
         if (anyChunkNeedsWildcardSynth) {
+            const tWildcard = startTimer(deferredProfile);
             synthesizeWildcardImportBindings(graph, ctx);
             hasSynthesized = true;
+            endTimer(tWildcard, (ms) => `synthesizeWildcardImportBindings: ${ms.toFixed(0)}ms`);
         }
         // L5 from PR #1693 review: populate `exportedTypeMap` from the in-progress
         // graph BEFORE `seedCrossFileReceiverTypes` runs. Previously the seeding
@@ -609,11 +619,22 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         }
         if (exportedTypeMap.size > 0 && ctx.namedImportMap.size > 0 && deferredWorkerCalls.length > 0) {
             const { enrichedCount } = seedCrossFileReceiverTypes(deferredWorkerCalls, ctx.namedImportMap, exportedTypeMap);
-            if (isDev && enrichedCount > 0) {
-                logger.info(`🔗 E1: Seeded ${enrichedCount} cross-file receiver types (all chunks)`);
+            if (enrichedCount > 0) {
+                // Two independent gates, not else-if: when both isDev AND
+                // deferredProfile are active, BOTH lines fire — log scrapers keyed
+                // on the original "🔗 E1" emoji marker keep matching, AND operators
+                // grepping the [deferred-profile] prefix see no gap between the
+                // wildcard-synth and heritage timings.
+                if (isDev) {
+                    logger.info(`🔗 E1: Seeded ${enrichedCount} cross-file receiver types (all chunks)`);
+                }
+                if (deferredProfile) {
+                    logDeferredProfile(`E1: seeded ${enrichedCount} cross-file receiver types (all chunks)`);
+                }
             }
         }
         if (deferredWorkerHeritage.length > 0) {
+            const tHeritage = startTimer(deferredProfile);
             await processHeritageFromExtracted(graph, deferredWorkerHeritage, ctx, (current, total) => {
                 const ratio = total > 0 ? current / total : 1;
                 onProgress({
@@ -628,8 +649,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             });
+            endTimer(tHeritage, (ms) => `processHeritageFromExtracted: ${ms.toFixed(0)}ms (${deferredWorkerHeritage.length} records)`);
         }
         if (allExtractedRoutes.length > 0) {
+            const tRoutes = startTimer(deferredProfile);
             await processRoutesFromExtracted(graph, allExtractedRoutes, ctx, (current, total) => {
                 const ratio = total > 0 ? current / total : 1;
                 onProgress({
@@ -644,10 +667,17 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             });
+            endTimer(tRoutes, (ms) => `processRoutesFromExtracted: ${ms.toFixed(0)}ms (${allExtractedRoutes.length} routes)`);
+        }
+        let fullWorkerHeritageMap;
+        if (deferredWorkerHeritage.length > 0) {
+            const tBuildHeritage = startTimer(deferredProfile);
+            fullWorkerHeritageMap = buildHeritageMap(deferredWorkerHeritage, ctx, getHeritageStrategyForLanguage);
+            endTimer(tBuildHeritage, (ms) => `buildHeritageMap wall: ${ms.toFixed(0)}ms`);
+        }
+        else if (deferredProfile) {
+            logDeferredProfile('buildHeritageMap: skipped (no heritage records)');
         }
-        const fullWorkerHeritageMap = deferredWorkerHeritage.length > 0
-            ? buildHeritageMap(deferredWorkerHeritage, ctx, getHeritageStrategyForLanguage)
-            : undefined;
         // U15 (lightweight M1): buildHeritageMap is the LAST consumer of the
         // raw `deferredWorkerHeritage` records — processCallsFromExtracted
         // below reads from the derived `fullWorkerHeritageMap` instead. Free
@@ -656,6 +686,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         // earlier was a read-only consumer (pushed to graph, didn't drain).
         deferredWorkerHeritage.length = 0;
         if (deferredWorkerCalls.length > 0) {
+            if (deferredProfile) {
+                logDeferredProfile(`processCallsFromExtracted: starting (${deferredWorkerCalls.length} call sites, heritageMap=${fullWorkerHeritageMap !== undefined})`);
+            }
+            const tCalls = startTimer(deferredProfile);
             await processCallsFromExtracted(graph, deferredWorkerCalls, ctx, (current, total) => {
                 const ratio = total > 0 ? current / total : 1;
                 onProgress({
@@ -673,6 +707,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             }, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, fullWorkerHeritageMap, bindingAccumulator);
+            endTimer(tCalls, (ms) => `processCallsFromExtracted: ${ms.toFixed(0)}ms total`);
         }
         if (deferredAssignments.length > 0) {
             processAssignmentsFromExtracted(graph, deferredAssignments, ctx, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, bindingAccumulator);

package/dist/core/ingestion/registry-primary-flag.js

@@ -36,6 +36,7 @@
  * lives in `shadow-harness.ts` (#923), not here.
  */
 import { SupportedLanguages } from '../../_shared/index.js';
+import { parseTruthyEnv } from './utils/env.js';
 /**
  * Languages whose RFC #909 Ring 3 scope-resolution migration is complete.
  *
@@ -110,10 +111,6 @@ export function primaryLanguages() {
     return out;
 }
 // ─── Internal ───────────────────────────────────────────────────────────────
-/** Accepted truthy strings (case-insensitive, trimmed). */
-const TRUTHY_VALUES = new Set(['true', '1', 'yes']);
 function parseFlag(raw) {
-    if (raw === undefined)
-        return false;
-    return TRUTHY_VALUES.has(raw.trim().toLowerCase());
+    return parseTruthyEnv(raw);
 }

package/dist/core/ingestion/utils/deferred-resolution-profile.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Wall-clock logging for the post-chunk deferred resolution band
+ * (imports → heritage → heritage map → legacy call resolution).
+ *
+ * Enabled when either:
+ *   - `GITNEXUS_VERBOSE=1` / `gitnexus analyze -v` (primary path for #1741), or
+ *   - `GITNEXUS_PROFILE_DEFERRED=1` (force on without full verbose ingestion noise)
+ *
+ * Issue #1741: large Java/Kotlin repos appear stuck at "Resolving calls"
+ * because the UI progress bar updates every 100 files and intermediate
+ * stages emit little to the log.
+ */
+/** True when deferred-stage timing / progress logs should emit. */
+export declare const isDeferredResolutionProfileEnabled: () => boolean;
+/** Log a call-resolution progress line every N files (finer when verbose). */
+export declare const deferredCallLogEveryN: () => number;
+/** Per-file call-resolution log threshold (ms). Lower default when verbose. */
+export declare const deferredCallFileSlowMs: () => number;
+export declare const profileNow: () => bigint;
+export declare const profileElapsedMs: (start: bigint) => number;
+/**
+ * Number of `logDeferredProfile` calls whose underlying `logger.info` threw.
+ * Surfaced in the deferred-band done-summary when greater than zero.
+ */
+export declare const getDeferredProfileDroppedCount: () => number;
+/**
+ * Reset the dropped-line counter. Call from test `afterEach` to keep the
+ * module-private state from leaking across tests. Also used inside
+ * `processCallsFromExtracted` at function entry so each analyze run gets
+ * a fresh count rather than accumulating across the process lifetime.
+ */
+export declare const resetDeferredProfileDroppedCount: () => void;
+export declare const logDeferredProfile: (message: string) => void;
+/**
+ * Capture a monotonic timestamp when profiling is enabled; otherwise return null.
+ * Pair with `endTimer` so the type system narrows correctly — using `null` instead
+ * of a `0n` sentinel makes "profiling disabled" structurally distinct from
+ * "zero elapsed time" and lets TypeScript catch missing guards.
+ */
+export declare const startTimer: (enabled: boolean) => bigint | null;
+/**
+ * Emit a `[deferred-profile]` log line for a captured timer. No-op when the
+ * timer is `null` (profiling was disabled at capture time). The formatter
+ * receives elapsed ms so the call sites stay readable.
+ *
+ * The format callback runs inside a try/catch so a throwing formatter
+ * (custom toString, JSON.stringify on a circular object) cannot abort the
+ * deferred resolution band — observability code must never escalate to a
+ * load-bearing failure. On catch we emit a single `formatter error: …`
+ * line via logDeferredProfile and return; the caller's stage continues
+ * as if profiling had no-op'd for this timer. DoD §2.8 ("no silent
+ * catches that swallow diagnostics") is satisfied by surfacing the
+ * failure message rather than dropping it.
+ */
+export declare const endTimer: (start: bigint | null, format: (elapsedMs: number) => string) => void;

package/dist/core/ingestion/utils/deferred-resolution-profile.js

@@ -0,0 +1,107 @@
+/**
+ * Wall-clock logging for the post-chunk deferred resolution band
+ * (imports → heritage → heritage map → legacy call resolution).
+ *
+ * Enabled when either:
+ *   - `GITNEXUS_VERBOSE=1` / `gitnexus analyze -v` (primary path for #1741), or
+ *   - `GITNEXUS_PROFILE_DEFERRED=1` (force on without full verbose ingestion noise)
+ *
+ * Issue #1741: large Java/Kotlin repos appear stuck at "Resolving calls"
+ * because the UI progress bar updates every 100 files and intermediate
+ * stages emit little to the log.
+ */
+import { logger } from '../../logger.js';
+import { parseTruthyEnv } from './env.js';
+import { isVerboseIngestionEnabled } from './verbose.js';
+// Module-private tuning constants for the gates below. Not exported — these
+// are internal knobs, not part of the module's API surface.
+const LOG_EVERY_N_VERBOSE = 10;
+const LOG_EVERY_N_PROFILE = 100;
+const DEFAULT_SLOW_MS_VERBOSE = 3_000;
+const DEFAULT_SLOW_MS = 5_000;
+/** True when deferred-stage timing / progress logs should emit. */
+export const isDeferredResolutionProfileEnabled = () => isVerboseIngestionEnabled() || parseTruthyEnv(process.env.GITNEXUS_PROFILE_DEFERRED);
+/** Log a call-resolution progress line every N files (finer when verbose). */
+export const deferredCallLogEveryN = () => isVerboseIngestionEnabled() ? LOG_EVERY_N_VERBOSE : LOG_EVERY_N_PROFILE;
+/** Per-file call-resolution log threshold (ms). Lower default when verbose. */
+export const deferredCallFileSlowMs = () => {
+    const raw = process.env.GITNEXUS_PROFILE_DEFERRED_SLOW_MS;
+    if (raw) {
+        // Use Number() not parseInt: parseInt('1e9', 10) === 1 (prefix-parses, drops the exponent),
+        // which would turn a user-intended "effectively disabled" threshold into a 1 ms log storm.
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return isVerboseIngestionEnabled() ? DEFAULT_SLOW_MS_VERBOSE : DEFAULT_SLOW_MS;
+};
+export const profileNow = () => process.hrtime.bigint();
+export const profileElapsedMs = (start) => Number(process.hrtime.bigint() - start) / 1e6;
+// Module-private counter for `[deferred-profile]` log lines the underlying
+// logger refused to accept. Pino's SonicBoom transport is sync:false today,
+// so steady-state `logger.info(string)` calls don't throw — but first-use
+// construction paths (pino-pretty resolve, level validation) and any future
+// transport reconfiguration could. The wrap below catches and counts so a
+// failing logger cannot abort the deferred band, and the count surfaces in
+// the deferred-band done-summary (see processCallsFromExtracted) so the
+// failure is visible rather than silently swallowed (DoD §2.8).
+let droppedLogLines = 0;
+/**
+ * Number of `logDeferredProfile` calls whose underlying `logger.info` threw.
+ * Surfaced in the deferred-band done-summary when greater than zero.
+ */
+export const getDeferredProfileDroppedCount = () => droppedLogLines;
+/**
+ * Reset the dropped-line counter. Call from test `afterEach` to keep the
+ * module-private state from leaking across tests. Also used inside
+ * `processCallsFromExtracted` at function entry so each analyze run gets
+ * a fresh count rather than accumulating across the process lifetime.
+ */
+export const resetDeferredProfileDroppedCount = () => {
+    droppedLogLines = 0;
+};
+export const logDeferredProfile = (message) => {
+    try {
+        logger.info(`[deferred-profile] ${message}`);
+    }
+    catch {
+        // Do not call the failing logger from the handler — that would risk
+        // an infinite loop if the failure mode is steady-state. Just count.
+        droppedLogLines++;
+    }
+};
+/**
+ * Capture a monotonic timestamp when profiling is enabled; otherwise return null.
+ * Pair with `endTimer` so the type system narrows correctly — using `null` instead
+ * of a `0n` sentinel makes "profiling disabled" structurally distinct from
+ * "zero elapsed time" and lets TypeScript catch missing guards.
+ */
+export const startTimer = (enabled) => enabled ? process.hrtime.bigint() : null;
+/**
+ * Emit a `[deferred-profile]` log line for a captured timer. No-op when the
+ * timer is `null` (profiling was disabled at capture time). The formatter
+ * receives elapsed ms so the call sites stay readable.
+ *
+ * The format callback runs inside a try/catch so a throwing formatter
+ * (custom toString, JSON.stringify on a circular object) cannot abort the
+ * deferred resolution band — observability code must never escalate to a
+ * load-bearing failure. On catch we emit a single `formatter error: …`
+ * line via logDeferredProfile and return; the caller's stage continues
+ * as if profiling had no-op'd for this timer. DoD §2.8 ("no silent
+ * catches that swallow diagnostics") is satisfied by surfacing the
+ * failure message rather than dropping it.
+ */
+export const endTimer = (start, format) => {
+    if (start === null)
+        return;
+    const elapsedMs = profileElapsedMs(start);
+    let message;
+    try {
+        message = format(elapsedMs);
+    }
+    catch (err) {
+        logDeferredProfile(`formatter error: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    logDeferredProfile(message);
+};

package/dist/core/ingestion/utils/env.d.ts

@@ -8,6 +8,19 @@
  */
 /** Whether we're running in development mode (enables verbose console logging). */
 export declare const isDev: boolean;
+/**
+ * Parse a narrow-form truthy env-var value. Accepts `'1'`, `'true'`, `'yes'`
+ * (case-insensitive, whitespace-trimmed). Anything else — including
+ * `undefined`, empty string, `'0'`, `'false'`, `'no'`, or unknown tokens —
+ * returns `false`.
+ *
+ * This is the shared helper for narrow-form truthy parsing across the
+ * ingestion module. `logger.ts` uses a broader negative-list form
+ * (`isTruthyEnv`) that intentionally accepts anything except a small set of
+ * falsy tokens — that lives separately because it follows pino-debug
+ * conventions and serves a different purpose.
+ */
+export declare const parseTruthyEnv: (raw: string | undefined) => boolean;
 /**
  * Whether scope-resolution dev validators (e.g. `validateBindingsImmutability`)
  * should run AND emit warnings. Off by default in CLI runs to avoid silent

package/dist/core/ingestion/utils/env.js

@@ -8,6 +8,24 @@
  */
 /** Whether we're running in development mode (enables verbose console logging). */
 export const isDev = process.env.NODE_ENV === 'development';
+/**
+ * Parse a narrow-form truthy env-var value. Accepts `'1'`, `'true'`, `'yes'`
+ * (case-insensitive, whitespace-trimmed). Anything else — including
+ * `undefined`, empty string, `'0'`, `'false'`, `'no'`, or unknown tokens —
+ * returns `false`.
+ *
+ * This is the shared helper for narrow-form truthy parsing across the
+ * ingestion module. `logger.ts` uses a broader negative-list form
+ * (`isTruthyEnv`) that intentionally accepts anything except a small set of
+ * falsy tokens — that lives separately because it follows pino-debug
+ * conventions and serves a different purpose.
+ */
+export const parseTruthyEnv = (raw) => {
+    if (raw === undefined)
+        return false;
+    const value = raw.trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+};
 /**
  * Whether scope-resolution dev validators (e.g. `validateBindingsImmutability`)
  * should run AND emit warnings. Off by default in CLI runs to avoid silent

package/dist/core/ingestion/utils/verbose.js

@@ -1,7 +1,2 @@
-export const isVerboseIngestionEnabled = () => {
-    const raw = process.env.GITNEXUS_VERBOSE;
-    if (!raw)
-        return false;
-    const value = raw.toLowerCase();
-    return value === '1' || value === 'true' || value === 'yes';
-};
+import { parseTruthyEnv } from './env.js';
+export const isVerboseIngestionEnabled = () => parseTruthyEnv(process.env.GITNEXUS_VERBOSE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.39",
+  "version": "1.6.6-rc.40",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",