fix(native): keep nativeDb open through finalize for correct build_meta (#784)

* fix(native): keep nativeDb open through finalize for correct build_meta (#751)

nativeDb was closed before finalize(), making persistBuildMetadata fall
back to the JS (better-sqlite3) path. After native WAL truncation the JS
connection's page cache was stale, causing the setBuildMeta write to
silently fail and leaving stale version/engine metadata. This broke
incremental builds by triggering a spurious "version changed" full
rebuild on every subsequent run.

Keep nativeDb alive through finalize so all metadata writes, advisory
checks, and count queries use the native path. Refresh the JS DB
beforehand so it has a valid page cache if finalize falls back to JS.

* fix(native): use npm version for engine_version in build_meta (#751)

engine_version was set to ctx.engineVersion which comes from the Rust
crate's CARGO_PKG_VERSION via native.engineVersion(). When the Rust
crate version drifts from the npm package version (e.g. Cargo.toml not
bumped during release), build_meta stores the wrong version. Use
CODEGRAPH_VERSION (the npm package.json version) for both
codegraph_version and engine_version since the native engine is
distributed as part of the npm package.

Also strengthens the #751 regression test to assert engine_version
equals the npm version and uses a full rebuild to ensure metadata is
written for the small test fixture.

Author: carlos-alm

src/domain/graph/builder/pipeline.ts

@@ -300,9 +300,13 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
 
   await runAnalyses(ctx);
 
-  // Close nativeDb after analyses — finalize uses JS paths for setBuildMeta
-  // and closeDbPair handles cleanup. Avoids dual-connection during finalize.
-  closeNativeDb(ctx, 'post-analyses');
+  // 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) {
+    refreshJsDb(ctx);
+  }
 
   await finalize(ctx);
 }

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(),

tests/integration/build.test.ts

@@ -477,6 +477,38 @@ describe('version/engine mismatch auto-promotes to full rebuild', () => {
     expect(output).toContain('promoting to full rebuild');
     expect(output).not.toContain('No changes detected');
   });
+
+  test('build_meta reflects actual engine and version after build (#751)', async () => {
+    // Force a full rebuild to ensure build_meta is freshly written
+    await buildGraph(promoDir, { skipRegistry: true, incremental: false });
+
+    const db2 = new Database(promoDbPath, { readonly: true });
+    const meta = Object.fromEntries(
+      (
+        db2.prepare('SELECT key, value FROM build_meta').all() as { key: string; value: string }[]
+      ).map((r) => [r.key, r.value]),
+    );
+    db2.close();
+
+    // codegraph_version must match the npm package version
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'),
+    );
+    expect(meta.codegraph_version).toBe(pkg.version);
+
+    // engine must be either 'native' or 'wasm' (not empty, not stale)
+    expect(['native', 'wasm']).toContain(meta.engine);
+
+    // engine_version must equal the npm package version (#751: was using Rust crate version)
+    expect(meta.engine_version).toBe(pkg.version);
+
+    // built_at must be a valid ISO timestamp from the current build
+    expect(new Date(meta.built_at).getTime()).toBeGreaterThan(0);
+
+    // node/edge counts must be positive
+    expect(Number(meta.node_count)).toBeGreaterThan(0);
+    expect(Number(meta.edge_count)).toBeGreaterThan(0);
+  });
 });
 
 describe('typed method call resolution', () => {