@optave/codegraph 3.8.0 → 3.8.1

package/src/domain/graph/builder/pipeline.ts

@@ -6,12 +6,21 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import {
+  closeDbPair,
+  getBuildMeta,
+  initSchema,
+  MIGRATIONS,
+  openDb,
+  setBuildMeta,
+} from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
-import { info, warn } from '../../../infrastructure/logger.js';
+import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
+import { semverCompare } from '../../../infrastructure/update-check.js';
+import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
-import type { BuildGraphOpts, BuildResult } from '../../../types.js';
+import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -50,8 +59,10 @@ function initializeEngine(ctx: PipelineContext): void {
       ? () => {
           try {
             ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-          } catch {
-            /* ignore — nativeDb may already be closed */
+          } catch (e) {
+            debug(
+              `resumeJsDb: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+            );
           }
         }
       : undefined,
@@ -132,11 +143,11 @@ function setupPipeline(ctx: PipelineContext): void {
       // with no cross-library WAL frames (#715, #717).
       ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch (err) {
-      warn(`NativeDatabase setup failed, falling back to JS: ${(err as Error).message}`);
+      warn(`NativeDatabase setup failed, falling back to JS: ${toErrorMessage(err)}`);
       try {
         ctx.nativeDb?.close();
-      } catch {
-        /* ignore close errors */
+      } catch (e) {
+        debug(`setupNativeDb: close failed during fallback: ${toErrorMessage(e)}`);
       }
       ctx.nativeDb = undefined;
     }
@@ -185,6 +196,58 @@ function formatTimingResult(ctx: PipelineContext): BuildResult {
   };
 }
 
+// ── NativeDb lifecycle helpers ──────────────────────────────────────────
+
+/** Checkpoint WAL through rusqlite and close the native connection. */
+function closeNativeDb(ctx: PipelineContext, label: string): void {
+  if (!ctx.nativeDb) return;
+  try {
+    ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+  } catch (e) {
+    debug(`${label} WAL checkpoint failed: ${toErrorMessage(e)}`);
+  }
+  try {
+    ctx.nativeDb.close();
+  } catch (e) {
+    debug(`${label} nativeDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.nativeDb = undefined;
+}
+
+/** Try to reopen the native connection for a given pipeline phase. */
+function reopenNativeDb(ctx: PipelineContext, label: string): void {
+  const native = loadNative();
+  if (!native?.NativeDatabase) return;
+  try {
+    ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+  } catch (e) {
+    debug(`reopen nativeDb for ${label} failed: ${toErrorMessage(e)}`);
+    ctx.nativeDb = undefined;
+  }
+}
+
+/** Close nativeDb and clear stale references in engineOpts. */
+function suspendNativeDb(ctx: PipelineContext, label: string): void {
+  closeNativeDb(ctx, label);
+  if (ctx.engineOpts?.nativeDb) {
+    ctx.engineOpts.nativeDb = undefined;
+  }
+}
+
+/**
+ * After native writes, reopen the JS db connection to get a fresh page cache.
+ * Rusqlite WAL truncation invalidates better-sqlite3's internal WAL index,
+ * causing SQLITE_CORRUPT on the next read (#715, #736).
+ */
+function refreshJsDb(ctx: PipelineContext): void {
+  try {
+    ctx.db.close();
+  } catch (e) {
+    debug(`refreshJsDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.db = openDb(ctx.dbPath);
+}
+
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
@@ -195,26 +258,7 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // that use suspendJsDb/resumeJsDb WAL checkpoint pattern (#696).
   const hadNativeDb = !!ctx.nativeDb;
   if (ctx.db && ctx.nativeDb) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    // Separate try/catch blocks ensure close() always runs even if checkpoint throws,
-    // preventing a live rusqlite connection from lingering until GC.
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
-    // Also clear stale reference in engineOpts to prevent stages from
-    // calling methods on the closed NativeDatabase.
-    if (ctx.engineOpts?.nativeDb) {
-      ctx.engineOpts.nativeDb = undefined;
-    }
+    suspendNativeDb(ctx, 'pre-collect');
   }
 
   await collectFiles(ctx);
@@ -228,44 +272,15 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // guard internally (same pattern as feature modules). Closed again before
   // resolveImports/buildEdges which don't yet have the guard (#709).
   if (hadNativeDb && ctx.engineName === 'native') {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-      } catch {
-        ctx.nativeDb = undefined;
-      }
-    }
+    reopenNativeDb(ctx, 'insertNodes');
   }
 
   await insertNodes(ctx);
 
   // Close nativeDb after insertNodes — remaining pipeline stages use JS paths.
   if (ctx.nativeDb && ctx.db) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
-    // Reopen better-sqlite3 connection to get a fresh page cache.
-    // After rusqlite truncates the WAL, better-sqlite3's internal WAL index
-    // (shared-memory mapping) may reference frames that no longer exist,
-    // causing SQLITE_CORRUPT on the next read. Closing and reopening
-    // forces a clean slate — the only reliable cross-library handoff (#715, #736).
-    try {
-      ctx.db.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.db = openDb(ctx.dbPath);
+    closeNativeDb(ctx, 'post-insertNodes');
+    refreshJsDb(ctx);
   }
 
   await resolveImports(ctx);
@@ -275,41 +290,23 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow)
   // which use suspendJsDb/resumeJsDb WAL checkpoint before native writes.
   if (hadNativeDb) {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-        if (ctx.engineOpts) {
-          ctx.engineOpts.nativeDb = ctx.nativeDb;
-        }
-      } catch {
-        ctx.nativeDb = undefined;
-        if (ctx.engineOpts) {
-          ctx.engineOpts.nativeDb = undefined;
-        }
-      }
+    reopenNativeDb(ctx, 'analyses');
+    if (ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = ctx.nativeDb;
+    }
+    if (!ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = undefined;
     }
   }
 
   await runAnalyses(ctx);
 
-  // Close nativeDb after analyses — finalize uses JS paths for setBuildMeta
-  // and closeDbPair handles cleanup. Avoids dual-connection during finalize.
+  // Keep nativeDb open through finalize so persistBuildMetadata, advisory
+  // checks, and count queries use the native path.  closeDbPair inside
+  // finalize handles both connections.  Refresh the JS db so it has a
+  // valid page cache in case finalize falls back to JS paths (#751).
   if (ctx.nativeDb) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    // Separate try/catch blocks ensure close() always runs even if checkpoint throws.
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
+    refreshJsDb(ctx);
   }
 
   await finalize(ctx);
@@ -338,7 +335,27 @@ export async function buildGraph(
     // When available, run the entire build pipeline in Rust with zero
     // napi crossings (eliminates WAL dual-connection dance). Falls back
     // to the JS pipeline on failure or when native is unavailable.
-    const forceJs = process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1';
+    //
+    // Native addon 3.8.0 has a path bug: file_symbols keys are absolute
+    // paths but known_files are relative, causing zero import/call edges.
+    // Skip the orchestrator for affected versions (fixed in 3.9.0+).
+    const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.8.0') <= 0;
+    const forceJs =
+      process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1' ||
+      ctx.forceFullRebuild ||
+      orchestratorBuggy ||
+      ctx.engineName !== 'native';
+    if (forceJs) {
+      const reason =
+        process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1'
+          ? 'CODEGRAPH_FORCE_JS_PIPELINE=1'
+          : ctx.forceFullRebuild
+            ? 'forceFullRebuild'
+            : orchestratorBuggy
+              ? `buggy addon ${ctx.engineVersion}`
+              : `engine=${ctx.engineName}`;
+      debug(`Skipping native orchestrator: ${reason}`);
+    }
     if (!forceJs && ctx.nativeDb?.buildGraph) {
       try {
         const resultJson = ctx.nativeDb.buildGraph(
@@ -353,21 +370,193 @@ export async function buildGraph(
           nodeCount?: number;
           edgeCount?: number;
           fileCount?: number;
+          changedFiles?: string[];
+          changedCount?: number;
+          removedCount?: number;
+          isFullBuild?: boolean;
         };
 
         if (result.earlyExit) {
+          info('No changes detected');
           closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
           return;
         }
 
+        // Log incremental status to match JS pipeline output
+        const changed = result.changedCount ?? 0;
+        const removed = result.removedCount ?? 0;
+        if (!result.isFullBuild && (changed > 0 || removed > 0)) {
+          info(`Incremental: ${changed} changed, ${removed} removed`);
+        }
+
         // Map Rust timing fields to the JS BuildResult format.
         // Rust handles collect+detect+parse+insert+resolve+edges+structure+roles.
-        // AST/complexity/CFG/dataflow analyses are not yet ported to Rust.
         const p = result.phases;
-        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+
+        // Sync build_meta so JS-side version/engine checks work on next build.
+        // Note: the Rust orchestrator also writes codegraph_version (using
+        // CARGO_PKG_VERSION). We intentionally overwrite it here with the npm
+        // package version so that the JS-side "version changed → full rebuild"
+        // detection (line ~97) compares against the authoritative JS version.
+        // The two versions are kept in lockstep by the release process.
+        setBuildMeta(ctx.db, {
+          engine: ctx.engineName,
+          engine_version: ctx.engineVersion || '',
+          codegraph_version: CODEGRAPH_VERSION,
+          schema_version: String(ctx.schemaVersion),
+          built_at: new Date().toISOString(),
+          node_count: String(result.nodeCount ?? 0),
+          edge_count: String(result.edgeCount ?? 0),
+        });
+
         info(
           `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
         );
+
+        // ── Run analysis phases (AST, complexity, CFG, dataflow) ──────
+        // Not yet ported to Rust. After the native orchestrator finishes,
+        // reconstruct a minimal fileSymbols map from the DB and run analyses
+        // via the JS engine (native standalone functions + WASM fallback).
+        let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+        const needsAnalysis =
+          opts.ast !== false ||
+          opts.complexity !== false ||
+          opts.cfg !== false ||
+          opts.dataflow !== false;
+
+        if (needsAnalysis) {
+          // WAL handoff: checkpoint through rusqlite, close nativeDb,
+          // reopen better-sqlite3 with a fresh page cache (#715, #736).
+          try {
+            ctx.nativeDb!.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch {
+            /* ignore checkpoint errors */
+          }
+          try {
+            ctx.nativeDb!.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.nativeDb = undefined;
+          try {
+            ctx.db.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.db = null!; // avoid closeDbPair operating on a stale handle
+          try {
+            ctx.db = openDb(ctx.dbPath);
+          } catch (reopenErr) {
+            warn(
+              `Failed to reopen DB for analysis after native build: ${(reopenErr as Error).message}`,
+            );
+            // Native build succeeded but we can't run analyses — return partial result
+            return {
+              phases: {
+                setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+                parseMs: +(p.parseMs ?? 0).toFixed(1),
+                insertMs: +(p.insertMs ?? 0).toFixed(1),
+                resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+                edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+                structureMs: +(p.structureMs ?? 0).toFixed(1),
+                rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+                astMs: 0,
+                complexityMs: 0,
+                cfgMs: 0,
+                dataflowMs: 0,
+                finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+              },
+            };
+          }
+
+          // Reconstruct minimal fileSymbols from DB for analysis visitors.
+          // Each entry needs definitions with name/kind/line/endLine so the
+          // engine can match complexity/CFG results to the right functions.
+          // For incremental builds, scope to only the files that were parsed
+          // in this cycle (matching the JS pipeline's behaviour in run-analyses.ts).
+          const changedFiles = result.changedFiles;
+          let query =
+            'SELECT file, name, kind, line, end_line as endLine FROM nodes WHERE file IS NOT NULL';
+          const params: string[] = [];
+          if (changedFiles && changedFiles.length > 0) {
+            const placeholders = changedFiles.map(() => '?').join(',');
+            query += ` AND file IN (${placeholders})`;
+            params.push(...changedFiles);
+          }
+          query += ' ORDER BY file, line';
+          const rows = ctx.db.prepare(query).all(...params) as {
+            file: string;
+            name: string;
+            kind: string;
+            line: number;
+            endLine: number | null;
+          }[];
+
+          const fileSymbols = new Map<string, ExtractorOutput>();
+          for (const row of rows) {
+            let entry = fileSymbols.get(row.file);
+            if (!entry) {
+              entry = {
+                definitions: [],
+                calls: [],
+                imports: [],
+                classes: [],
+                exports: [],
+                typeMap: new Map(),
+              };
+              fileSymbols.set(row.file, entry);
+            }
+            entry.definitions.push({
+              name: row.name,
+              kind: row.kind as Definition['kind'],
+              line: row.line,
+              endLine: row.endLine ?? undefined,
+            });
+          }
+
+          // Reopen nativeDb for analysis features (suspend/resume WAL pattern).
+          const native = loadNative();
+          if (native?.NativeDatabase) {
+            try {
+              ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+              if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
+            } catch {
+              ctx.nativeDb = undefined;
+              if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+            }
+          }
+
+          try {
+            const { runAnalyses: runAnalysesFn } = await import('../../../ast-analysis/engine.js');
+            analysisTiming = await runAnalysesFn(
+              ctx.db,
+              fileSymbols,
+              ctx.rootDir,
+              opts,
+              ctx.engineOpts,
+            );
+          } catch (err) {
+            warn(`Analysis phases failed after native build: ${toErrorMessage(err)}`);
+          }
+
+          // Close nativeDb after analyses
+          if (ctx.nativeDb) {
+            try {
+              ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            } catch {
+              /* ignore checkpoint errors */
+            }
+            try {
+              ctx.nativeDb.close();
+            } catch {
+              /* ignore close errors */
+            }
+            ctx.nativeDb = undefined;
+            if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+          }
+        }
+
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
         return {
           phases: {
             setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
@@ -377,16 +566,16 @@ export async function buildGraph(
             edgesMs: +(p.edgesMs ?? 0).toFixed(1),
             structureMs: +(p.structureMs ?? 0).toFixed(1),
             rolesMs: +(p.rolesMs ?? 0).toFixed(1),
-            astMs: 0,
-            complexityMs: 0,
-            cfgMs: 0,
-            dataflowMs: 0,
+            astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
+            complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
+            cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
+            dataflowMs: +(analysisTiming.dataflowMs ?? 0).toFixed(1),
             finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
           },
         };
       } catch (err) {
         warn(
-          `Native build orchestrator failed, falling back to JS pipeline: ${(err as Error).message}`,
+          `Native build orchestrator failed, falling back to JS pipeline: ${toErrorMessage(err)}`,
         );
         // Fall through to JS pipeline
       }

package/src/domain/graph/builder/stages/build-edges.ts

@@ -197,8 +197,13 @@ function buildImportEdgesNative(
   };
   const fileNodeRowCache = new Map<string, { id: number }>();
 
-  // 2. Pre-resolve all imports and collect supplemental resolved entries
-  const supplementalResolved: Array<{ key: string; resolvedPath: string }> = [];
+  // 2. Pre-resolve all imports and build resolved imports array.
+  // Keys use forward-slash-normalized rootDir + "/" + relPath to match the Rust
+  // lookup format (format!("{}/{}", root_dir.replace('\\', "/"), file)).
+  // On Windows, rootDir has backslashes but Rust normalizes them — the JS side
+  // must do the same or every resolve key lookup misses (#750).
+  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
+  const fwdRootDir = rootDir.replace(/\\/g, '/');
 
   for (const [relPath, symbols] of fileSymbols) {
     const fileNodeRow = addFileNodeId(relPath);
@@ -218,11 +223,8 @@ function buildImportEdgesNative(
       const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
       addFileNodeId(resolvedPath);
 
-      // Check if this resolution is in batchResolved; if not, add supplemental
-      const resolveKey = `${path.join(rootDir, relPath)}|${imp.source}`;
-      if (!ctx.batchResolved?.has(resolveKey)) {
-        supplementalResolved.push({ key: resolveKey, resolvedPath });
-      }
+      // Key matches Rust's format!("{}/{}", root_dir.replace('\\', "/"), file_input.file)
+      resolvedImports.push({ key: `${fwdRootDir}/${relPath}|${imp.source}`, resolvedPath });
 
       importInfos.push({
         source: imp.source,
@@ -243,17 +245,6 @@ function buildImportEdgesNative(
     });
   }
 
-  // 3. Flatten batchResolved + supplemental into resolved imports array
-  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
-  if (ctx.batchResolved) {
-    for (const [key, resolvedPath] of ctx.batchResolved) {
-      resolvedImports.push({ key, resolvedPath });
-    }
-  }
-  for (const entry of supplementalResolved) {
-    resolvedImports.push(entry);
-  }
-
   // 4. Flatten reexportMap
   const fileReexports: Array<{
     file: string;
@@ -748,7 +739,20 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
     const useNativeImportEdges =
       native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
     if (useNativeImportEdges) {
+      const beforeLen = allEdgeRows.length;
       buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
+      // Fallback: if native produced 0 import edges but there are imports to
+      // process, the native binary may have a key-format mismatch (e.g. Windows
+      // path separators — #750).  Retry with the JS implementation.
+      // NOTE: This also fires for codebases where every import targets an
+      // external package (npm deps) that the resolver intentionally skips.
+      // In that case the JS path resolves zero edges too, so the only cost
+      // is the redundant JS traversal — no correctness impact.
+      const hasImports = [...ctx.fileSymbols.values()].some((s) => s.imports.length > 0);
+      if (allEdgeRows.length === beforeLen && hasImports) {
+        debug('Native buildImportEdges produced 0 edges — falling back to JS');
+        buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+      }
     } else {
       buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
     }

package/src/domain/graph/builder/stages/detect-changes.ts

@@ -349,7 +349,7 @@ function findReverseDependencies(
     const changedArray = [...changedRelPaths];
     const nativeResults = nativeDb.findReverseDependencies(changedArray);
     for (const dep of nativeResults) {
-      const absPath = path.join(rootDir, dep);
+      const absPath = path.isAbsolute(dep) ? dep : path.join(rootDir, dep);
       if (fs.existsSync(absPath)) {
         reverseDeps.add(dep);
       }
@@ -366,7 +366,7 @@ function findReverseDependencies(
   for (const relPath of changedRelPaths) {
     for (const row of findReverseDepsStmt.all(relPath) as Array<{ file: string }>) {
       if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
-        const absPath = path.join(rootDir, row.file);
+        const absPath = path.isAbsolute(row.file) ? row.file : path.join(rootDir, row.file);
         if (fs.existsSync(absPath)) {
           reverseDeps.add(row.file);
         }

package/src/domain/graph/builder/stages/finalize.ts

@@ -86,7 +86,7 @@ function persistBuildMetadata(
       ctx.nativeDb!.setBuildMeta(
         Object.entries({
           engine: ctx.engineName,
-          engine_version: ctx.engineVersion || '',
+          engine_version: CODEGRAPH_VERSION,
           codegraph_version: CODEGRAPH_VERSION,
           schema_version: String(ctx.schemaVersion),
           built_at: buildNow.toISOString(),
@@ -97,7 +97,7 @@ function persistBuildMetadata(
     } else {
       setBuildMeta(ctx.db, {
         engine: ctx.engineName,
-        engine_version: ctx.engineVersion || '',
+        engine_version: CODEGRAPH_VERSION,
         codegraph_version: CODEGRAPH_VERSION,
         schema_version: String(ctx.schemaVersion),
         built_at: buildNow.toISOString(),