@optave/codegraph 3.9.5 → 3.10.0

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

@@ -9,6 +9,7 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import {
   acquireAdvisoryLock,
+  closeDb,
   closeDbPair,
   getBuildMeta,
   initSchema,
@@ -32,16 +33,30 @@ import type {
   ExtractorOutput,
   SqliteStatement,
 } from '../../../types.js';
-import { getActiveEngine, getInstalledWasmExtensions, parseFilesAuto } from '../../parser.js';
+import {
+  classifyNativeDrops,
+  formatDropExtensionSummary,
+  getActiveEngine,
+  getInstalledWasmExtensions,
+  parseFilesWasmForBackfill,
+} from '../../parser.js';
+import { writeJournalHeader } from '../journal.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
-import { batchInsertNodes, collectFiles as collectFilesUtil, loadPathAliases } from './helpers.js';
+import {
+  batchInsertNodes,
+  collectFiles as collectFilesUtil,
+  fileHash,
+  fileStat,
+  loadPathAliases,
+  readFileSafe,
+} from './helpers.js';
 import { NativeDbProxy } from './native-db-proxy.js';
 import { buildEdges } from './stages/build-edges.js';
 import { buildStructure } from './stages/build-structure.js';
 // Pipeline stages
 import { collectFiles } from './stages/collect-files.js';
-import { detectChanges } from './stages/detect-changes.js';
+import { detectChanges, detectNoChanges } from './stages/detect-changes.js';
 import { finalize } from './stages/finalize.js';
 import { insertNodes } from './stages/insert-nodes.js';
 import { parseFiles } from './stages/parse-files.js';
@@ -61,9 +76,14 @@ function initializeEngine(ctx: PipelineContext): void {
     suspendJsDb: undefined,
     resumeJsDb: undefined,
   };
-  const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
+  const {
+    name: engineName,
+    version: engineVersion,
+    binaryVersion: nativeBinaryVersion,
+  } = getActiveEngine(ctx.engineOpts);
   ctx.engineName = engineName as 'native' | 'wasm';
   ctx.engineVersion = engineVersion;
+  ctx.nativeBinaryVersion = nativeBinaryVersion;
   info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 }
 
@@ -90,13 +110,15 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
     );
     ctx.forceFullRebuild = true;
   }
-  // When the native engine is active, the Rust addon's version (ctx.engineVersion)
-  // is written into codegraph_version by setBuildMeta after a native orchestrator
-  // build. The check must compare against the same version, otherwise JS and Rust
-  // fight over which version to record — causing every incremental build to be
-  // promoted to a full rebuild when npm and crate versions diverge.
+  // When the native engine is active, the Rust orchestrator writes
+  // build_meta.codegraph_version = CARGO_PKG_VERSION (the binary's own value).
+  // Compare against the same value here so a CI hot-swap that leaves the
+  // platform package.json behind doesn't trigger a perpetual full-rebuild
+  // loop on every incremental (#1066).
   const effectiveVersion =
-    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
+    ctx.engineName === 'native' && ctx.nativeBinaryVersion
+      ? ctx.nativeBinaryVersion
+      : CODEGRAPH_VERSION;
   const prevVersion = meta('codegraph_version');
   if (prevVersion && prevVersion !== effectiveVersion) {
     info(
@@ -650,16 +672,24 @@ async function tryNativeOrchestrator(
   const p = result.phases;
 
   // Sync build_meta so JS-side version/engine checks work on next build.
-  // Use the Rust addon version as codegraph_version when the native
-  // orchestrator performed the build — the Rust side's check_version_mismatch
-  // compares this value against CARGO_PKG_VERSION.  Writing the JS
-  // CODEGRAPH_VERSION here would create a permanent mismatch whenever the
-  // npm package version diverges from the Rust crate version, forcing every
-  // subsequent native build to be a full rebuild (no incremental).
+  // Use the binary's CARGO_PKG_VERSION (ctx.nativeBinaryVersion), not the
+  // platform package.json version (ctx.engineVersion). The Rust side's
+  // check_version_mismatch compares against CARGO_PKG_VERSION; writing
+  // the package.json value would create a permanent mismatch whenever
+  // the binary and platform package.json diverge — e.g., CI hot-swap
+  // via ci-install-native.mjs (#1066) — forcing every subsequent build
+  // to be a full rebuild.
+  //
+  // When the native addon doesn't expose engineVersion() (older addon),
+  // fall back to CODEGRAPH_VERSION — same fallback used by both
+  // checkEngineSchemaMismatch (read path) and persistBuildMetadata
+  // (the JS-pipeline write path in finalize.ts). Using ctx.engineVersion
+  // here would re-introduce the asymmetry this PR fixes for that case.
+  const nativeVersionForMeta = ctx.nativeBinaryVersion || CODEGRAPH_VERSION;
   setBuildMeta(ctx.db, {
     engine: ctx.engineName,
-    engine_version: ctx.engineVersion || '',
-    codegraph_version: ctx.engineVersion || CODEGRAPH_VERSION,
+    engine_version: nativeVersionForMeta,
+    codegraph_version: nativeVersionForMeta,
     schema_version: String(ctx.schemaVersion),
     built_at: new Date().toISOString(),
   });
@@ -723,10 +753,20 @@ async function tryNativeOrchestrator(
   // stale native binaries). WASM handles those — backfill via WASM so both
   // engines process the same file set (#967).
   //
-  // Only runs on full builds: incremental builds only touch changed files,
-  // which are parsed through parseFilesAuto (which has its own per-file
-  // backfill), so a full filesystem scan here would be wasted work.
-  if (result.isFullBuild) {
+  // Runs on full builds and on incrementals when the orchestrator reports
+  // any file activity (removals or changes). The orchestrator's
+  // `detect_removed_files` filter (#1070) skips files outside its narrower
+  // file_collector, so on a current binary a no-op rebuild reports
+  // `removedCount=0` and `changedCount=0`, making the backfill call pure
+  // overhead (fs walk + 2 DB queries + 48-file WASM re-parse). Legacy
+  // binaries lacking the filter still report `removedCount>0` and get the
+  // gap-repair behavior #1068 introduced. Triggering on `changedCount>0`
+  // narrows (but does not fully close) the gap where a brand-new
+  // unsupported-extension file is added on an otherwise-quiet incremental
+  // — see #1091 for the residual gap.
+  const removedCount = result.removedCount ?? 0;
+  const changedCount = result.changedCount ?? 0;
+  if (result.isFullBuild || removedCount > 0 || changedCount > 0) {
     await backfillNativeDroppedFiles(ctx);
   }
 
@@ -739,41 +779,83 @@ async function tryNativeOrchestrator(
  * Falls back to WASM + inserts file/symbol nodes so engine counts match (#967).
  */
 async function backfillNativeDroppedFiles(ctx: PipelineContext): Promise<void> {
-  // Needs a real better-sqlite3 connection for INSERT.
-  if (ctx.nativeFirstProxy) {
-    closeNativeDb(ctx, 'pre-parity-backfill');
-    ctx.db = openDb(ctx.dbPath);
-    ctx.nativeFirstProxy = false;
-  }
-
+  // Compute the missing-file set FIRST, before any expensive DB handoff.
+  // NativeDbProxy supports .prepare().all(), so the upfront query works
+  // whether ctx.db is a proxy or a real better-sqlite3 connection. On
+  // incremental no-op rebuilds nothing is missing, so we want to early-return
+  // without paying the close-native / reopen-better-sqlite3 cost.
   const collected = collectFilesUtil(ctx.rootDir, [], ctx.config, new Set<string>());
   const expected = new Set(
     collected.files.map((f) => normalizePath(path.relative(ctx.rootDir, f))),
   );
 
-  const existingRows = ctx.db
+  const existingNodeRows = ctx.db
     .prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'")
     .all() as Array<{ file: string }>;
-  const existing = new Set(existingRows.map((r) => r.file));
+  const existingNodes = new Set(existingNodeRows.map((r) => r.file));
+
+  // Belt-and-suspenders: also check `file_hashes`. The fast-skip pre-flight
+  // (#1054) rejects on `file_hashes` gaps, and the two tables can diverge
+  // (e.g. a DB written by old code where `nodes` was populated but
+  // `file_hashes` was not). Treating "in nodes but not in file_hashes" as
+  // missing closes the gap so the backfill repairs the file_hashes row even
+  // when the node row already exists.
+  let existingHashes = new Set<string>();
+  try {
+    const existingHashRows = ctx.db
+      .prepare('SELECT DISTINCT file FROM file_hashes')
+      .all() as Array<{ file: string }>;
+    existingHashes = new Set(existingHashRows.map((r) => r.file));
+  } catch (e) {
+    // file_hashes table may not exist on legacy DBs; treat as fully missing
+    // so the backfill writes rows on the upsert path below.
+    debug(
+      `backfillNativeDroppedFiles: file_hashes read failed (table may not exist): ${toErrorMessage(e)}`,
+    );
+  }
 
   // Restrict backfill to files with an installed WASM grammar. Extensions in
   // LANGUAGE_REGISTRY without a shipped grammar file (e.g. groovy, erlang on
   // minimal installs) can't be parsed by either engine, so they're not a
   // native regression — excluding them keeps the warn count meaningful.
   const installedExts = getInstalledWasmExtensions();
+  const missingRel: string[] = [];
   const missingAbs: string[] = [];
   for (const rel of expected) {
-    if (existing.has(rel)) continue;
+    // A file is "missing" if it's absent from EITHER nodes OR file_hashes.
+    // Both must be present for fast-skip to work correctly.
+    if (existingNodes.has(rel) && existingHashes.has(rel)) continue;
     const ext = path.extname(rel).toLowerCase();
     if (!installedExts.has(ext)) continue;
+    missingRel.push(rel);
     missingAbs.push(path.join(ctx.rootDir, rel));
   }
   if (missingAbs.length === 0) return;
 
-  warn(
-    `Native orchestrator dropped ${missingAbs.length} file(s); backfilling via WASM for engine parity`,
-  );
-  const wasmResults = await parseFilesAuto(missingAbs, ctx.rootDir, { engine: 'wasm' });
+  // Now that we know there's work to do, hand off to better-sqlite3 (needed
+  // for the INSERT path below).
+  if (ctx.nativeFirstProxy) {
+    closeNativeDb(ctx, 'pre-parity-backfill');
+    ctx.db = openDb(ctx.dbPath);
+    ctx.nativeFirstProxy = false;
+  }
+
+  // Classify drops so users see per-extension reasons instead of just a count
+  // (#1011). `unsupported-by-native` is a legitimate parser limit (no Rust
+  // extractor); `native-extractor-failure` indicates a real native bug since
+  // the language IS supported by the addon yet the file was dropped anyway.
+  const { byReason, totals } = classifyNativeDrops(missingRel);
+  if (totals['unsupported-by-native'] > 0) {
+    info(
+      `Native orchestrator skipped ${totals['unsupported-by-native']} file(s) in languages without a Rust extractor; backfilling via WASM: ${formatDropExtensionSummary(byReason['unsupported-by-native'])}`,
+    );
+  }
+  if (totals['native-extractor-failure'] > 0) {
+    warn(
+      `Native orchestrator dropped ${totals['native-extractor-failure']} file(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM: ${formatDropExtensionSummary(byReason['native-extractor-failure'])}`,
+    );
+  }
+  const wasmResults = await parseFilesWasmForBackfill(missingAbs, ctx.rootDir);
 
   const rows: unknown[][] = [];
   const exportKeys: unknown[][] = [];
@@ -833,6 +915,68 @@ async function backfillNativeDroppedFiles(ctx: PipelineContext): Promise<void> {
       updateStmt.run(...vals);
     }
   }
+
+  // Persist file_hashes rows for every backfilled file. The Rust orchestrator
+  // only hashes files it parsed itself, so without this step files in
+  // optional-language extensions (e.g. .clj when no Rust extractor exists)
+  // would be missing from `file_hashes` — permanently breaking the JS-side
+  // fast-skip pre-flight (#1054), which rejects on `collected file missing
+  // from file_hashes` and forces every no-op rebuild back through the full
+  // ~2s native pipeline (#1068).
+  //
+  // Iterates `missingRel` (every collected file the Rust orchestrator
+  // dropped), not `wasmResults`, so files that produced zero symbols still
+  // get a row.
+  try {
+    const upsertHash = db.prepare(
+      'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
+    );
+    const writeHashes = db.transaction(() => {
+      for (let i = 0; i < missingRel.length; i++) {
+        const relPath = missingRel[i];
+        const absPath = missingAbs[i];
+        if (!relPath || !absPath) continue;
+        let code: string | null;
+        try {
+          code = readFileSafe(absPath);
+        } catch (e) {
+          debug(`backfillNativeDroppedFiles: read failed for ${relPath}: ${toErrorMessage(e)}`);
+          continue;
+        }
+        if (code === null) continue;
+        const stat = fileStat(absPath);
+        const mtime = stat ? stat.mtime : 0;
+        const size = stat ? stat.size : 0;
+        upsertHash.run(relPath, fileHash(code), mtime, size);
+      }
+    });
+    writeHashes();
+  } catch (e) {
+    debug(
+      `backfillNativeDroppedFiles: file_hashes write failed (table may not exist): ${toErrorMessage(e)}`,
+    );
+  }
+
+  // Free WASM parse trees from the inline backfill path (#1058).
+  // `parseFilesWasmInline` sets `symbols._tree` (a live web-tree-sitter Tree
+  // backed by WASM linear memory) on every result, but these symbols are
+  // consumed locally for DB row construction and never added to
+  // `ctx.allSymbols`, so the finalize-stage `releaseWasmTrees` sweep never
+  // sees them. Without this, trees leak WASM memory until process exit —
+  // bounded per run but cumulative across in-process integration tests.
+  // Mirrors the cleanup discipline established for #931.
+  for (const [, symbols] of wasmResults) {
+    const tree = (symbols as { _tree?: { delete?: () => void } })._tree;
+    if (tree && typeof tree.delete === 'function') {
+      try {
+        tree.delete();
+      } catch {
+        /* ignore cleanup errors */
+      }
+    }
+    (symbols as { _tree?: unknown; _langId?: unknown })._tree = undefined;
+    (symbols as { _tree?: unknown; _langId?: unknown })._langId = undefined;
+  }
 }
 
 // ── Pipeline stages execution ───────────────────────────────────────────
@@ -959,6 +1103,60 @@ export async function buildGraph(
   try {
     setupPipeline(ctx);
 
+    // ── JS-side fast-skip for native incremental (#1054) ──────────────
+    // The Rust orchestrator's internal early-exit fires reliably locally
+    // but not in CI, where every no-op rebuild was paying the full ~2s
+    // pipeline cost. A read-only mtime+size check here matches WASM's
+    // ~20ms early-exit and skips the orchestrator entirely when no
+    // source files have changed. Tier-2 hashing is left to the native
+    // side: any mismatch falls through and lets Rust's detect_changes
+    // remain the source of truth.
+    //
+    // Diagnostic logging gated by CODEGRAPH_FAST_SKIP_DIAG (#1066) — when
+    // any of the call-site guards short-circuit (forceFullRebuild,
+    // engineName, scope, etc.) we log the reason so the bench gate run
+    // produces observable output even if `detectNoChanges` is never
+    // entered.
+    const fastSkipDiag = process.env.CODEGRAPH_FAST_SKIP_DIAG === '1';
+    if (fastSkipDiag) {
+      const reasons: string[] = [];
+      if (!ctx.nativeAvailable) reasons.push('nativeAvailable=false');
+      if (ctx.engineName !== 'native') reasons.push(`engineName=${ctx.engineName}`);
+      if (!ctx.incremental) reasons.push('incremental=false');
+      if (ctx.forceFullRebuild) reasons.push('forceFullRebuild=true');
+      if ((ctx.opts as Record<string, unknown>).scope) reasons.push('scope=set');
+      if (reasons.length > 0) {
+        info(`[fast-skip] false: pre-flight gate skipped — ${reasons.join(', ')}`);
+      }
+    }
+    if (
+      ctx.nativeAvailable &&
+      ctx.engineName === 'native' &&
+      ctx.incremental &&
+      !ctx.forceFullRebuild &&
+      !(ctx.opts as Record<string, unknown>).scope
+    ) {
+      try {
+        await collectFiles(ctx);
+        if (
+          detectNoChanges(ctx.db, ctx.allFiles, ctx.rootDir, ctx.opts as Record<string, unknown>)
+        ) {
+          info('No changes detected. Graph is up to date.');
+          writeJournalHeader(ctx.rootDir, Date.now());
+          closeDb(ctx.db);
+          return;
+        }
+      } catch (err) {
+        // Pre-flight is best-effort — any failure falls through to the
+        // orchestrator, which performs its own complete detection.
+        // Reset ctx.allFiles so runPipelineStages re-collects under its own
+        // engine state if we ended up partially populated before throwing.
+        ctx.allFiles = undefined as unknown as string[];
+        ctx.discoveredDirs = undefined as unknown as Set<string>;
+        debug(`native fast-skip pre-flight failed: ${toErrorMessage(err)}`);
+      }
+    }
+
     // ── Rust orchestrator fast path (#695) ────────────────────────────
     // When available, run the entire build pipeline in Rust with zero
     // napi crossings (eliminates WAL dual-connection dance). Falls back

package/src/domain/graph/builder/stages/collect-files.ts

@@ -100,6 +100,15 @@ function tryFastCollect(
 export async function collectFiles(ctx: PipelineContext): Promise<void> {
   const { rootDir, config, opts } = ctx;
 
+  // Skip when the JS-side fast-skip pre-flight (#1054) already populated the
+  // file list and changes were detected, causing fallthrough to the native
+  // orchestrator and then to runPipelineStages. Avoids redoing the filesystem
+  // walk on the non-skip path (~8ms on 473 files). On pre-flight failure the
+  // caller resets ctx.allFiles so this guard correctly falls through.
+  if (!opts.scope && ctx.allFiles?.length && ctx.discoveredDirs?.size) {
+    return;
+  }
+
   if (opts.scope) {
     // Scoped rebuild: rebuild only specified files.
     //

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

@@ -27,7 +27,7 @@ interface FileHashRow {
 }
 
 interface FileStat {
-  mtimeMs: number;
+  mtime: number;
   size: number;
 }
 
@@ -182,7 +182,7 @@ function mtimeAndHashTiers(
     if (!stat) continue;
     const storedMtime = record.mtime || 0;
     const storedSize = record.size || 0;
-    if (storedSize > 0 && Math.floor(stat.mtimeMs) === storedMtime && stat.size === storedSize) {
+    if (storedSize > 0 && stat.mtime === storedMtime && stat.size === storedSize) {
       skipped.push(relPath);
       continue;
     }
@@ -512,6 +512,132 @@ function handleIncrementalBuild(ctx: PipelineContext): void {
   purgeAndAddReverseDeps(ctx, changePaths, reverseDeps);
 }
 
+/**
+ * Read-only pre-flight check for the native orchestrator.
+ *
+ * Returns true iff every collected source file has matching mtime+size in
+ * `file_hashes` and no DB-tracked file has been removed. When true, the
+ * caller can short-circuit before invoking the native orchestrator —
+ * matching WASM's ~20 ms early-exit path and avoiding the ~2s flat
+ * per-call native rebuild overhead seen in CI (#1054).
+ *
+ * Intentionally Tier-0/Tier-1 only (journal + mtime/size). Tier-2 content
+ * hashing is left to the native side: when this returns false the caller
+ * falls through to the orchestrator, which performs its own complete
+ * detection and is the source of truth.
+ *
+ * Conservatively returns false when CFG or dataflow analysis is enabled
+ * but the corresponding tables are empty — otherwise the fast-skip would
+ * silently suppress the pending-analysis pass that the JS path runs via
+ * `runPendingAnalysis`, and CFG/dataflow data would never populate on
+ * repos where source files don't change between builds.
+ *
+ * Pure read of `db` and the filesystem — never mutates either.
+ */
+export function detectNoChanges(
+  db: BetterSqlite3Database,
+  allFiles: string[],
+  rootDir: string,
+  opts?: Record<string, unknown>,
+): boolean {
+  // Diagnostic logging gated by env var — used by the bench gate to surface
+  // why the fast-skip is not firing on CI runners (#1066). Off by default to
+  // avoid noise on every regular incremental build.
+  const diag = process.env.CODEGRAPH_FAST_SKIP_DIAG === '1';
+  const log = (reason: string): void => {
+    if (diag) info(`[fast-skip] ${reason}`);
+  };
+
+  let hasTable = false;
+  try {
+    db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
+    hasTable = true;
+  } catch {
+    /* table missing — first build */
+  }
+  if (!hasTable) {
+    log('false: file_hashes table missing');
+    return false;
+  }
+
+  const rows = db.prepare('SELECT file, hash, mtime, size FROM file_hashes').all() as FileHashRow[];
+  if (rows.length === 0) {
+    log('false: file_hashes table empty');
+    return false;
+  }
+  const existing = new Map<string, FileHashRow>(rows.map((r) => [r.file, r]));
+
+  const currentFiles = new Set<string>();
+  for (const file of allFiles) {
+    currentFiles.add(normalizePath(path.relative(rootDir, file)));
+  }
+  for (const existingFile of existing.keys()) {
+    if (!currentFiles.has(existingFile)) {
+      log(`false: tracked file no longer collected: ${existingFile}`);
+      return false;
+    }
+  }
+
+  for (const file of allFiles) {
+    const relPath = normalizePath(path.relative(rootDir, file));
+    const record = existing.get(relPath);
+    if (!record) {
+      log(`false: collected file missing from file_hashes: ${relPath}`);
+      return false;
+    }
+    const stat = fileStat(file) as FileStat | undefined;
+    if (!stat) {
+      log(`false: stat failed for ${relPath}`);
+      return false;
+    }
+    const storedMtime = record.mtime || 0;
+    const storedSize = record.size || 0;
+    if (storedSize <= 0) {
+      log(`false: stored size <= 0 for ${relPath} (stored=${record.size})`);
+      return false;
+    }
+    if (stat.mtime !== storedMtime || stat.size !== storedSize) {
+      log(
+        `false: mtime/size diff for ${relPath}: stat=${stat.mtime}/${stat.size} stored=${storedMtime}/${storedSize}`,
+      );
+      return false;
+    }
+  }
+
+  // Pending-analysis guard: if CFG/dataflow is enabled but the corresponding
+  // table is empty (analysis newly enabled, or tables wiped between builds),
+  // fall through so the orchestrator / JS pipeline can run runPendingAnalysis.
+  // Mirrors the check at the top of runPendingAnalysis (see line ~244).
+  if (opts) {
+    if (opts.cfg !== false && hasEmptyAnalysisTable(db, 'cfg_blocks')) {
+      log('false: pending-analysis guard — cfg_blocks is empty');
+      return false;
+    }
+    if (opts.dataflow !== false && hasEmptyAnalysisTable(db, 'dataflow')) {
+      log('false: pending-analysis guard — dataflow is empty');
+      return false;
+    }
+  }
+
+  log(`true: all checks passed (${allFiles.length} files)`);
+  return true;
+}
+
+/**
+ * Returns true if `table` exists and has zero rows, matching the empty-table
+ * semantics of `runPendingAnalysis`. A missing table is treated as empty
+ * (the conservative outcome), so the caller falls through to the orchestrator
+ * which will create the schema and populate it.
+ */
+function hasEmptyAnalysisTable(db: BetterSqlite3Database, table: string): boolean {
+  try {
+    const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get() as { c: number } | undefined;
+    return (row?.c ?? 0) === 0;
+  } catch {
+    return true;
+  }
+}
+
 export async function detectChanges(ctx: PipelineContext): Promise<void> {
   const start = performance.now();
   try {
@@ -537,7 +663,7 @@ export async function detectChanges(ctx: PipelineContext): Promise<void> {
         relPath: c.relPath,
         content: c.content,
         hash: c.hash,
-        stat: c.stat ? { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size } : undefined,
+        stat: c.stat ? { mtime: c.stat.mtime, size: c.stat.size } : undefined,
         _reverseDepOnly: c._reverseDepOnly,
       }));
     ctx.metadataUpdates = increResult.changed
@@ -548,7 +674,7 @@ export async function detectChanges(ctx: PipelineContext): Promise<void> {
       .map((c) => ({
         relPath: c.relPath,
         hash: c.hash,
-        stat: { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size },
+        stat: { mtime: c.stat.mtime, size: c.stat.size },
       }));
     if (!ctx.isFullBuild && ctx.parseChanges.length === 0 && ctx.removed.length === 0) {
       const ranAnalysis = await runPendingAnalysis(ctx);

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

@@ -82,13 +82,16 @@ function persistBuildMetadata(
 ): void {
   const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
   if (!ctx.isFullBuild && ctx.allSymbols.size <= 3) return;
-  // When the native engine is active, persist the Rust addon version so that
-  // checkEngineSchemaMismatch compares against the same value on the next build.
-  // Writing CODEGRAPH_VERSION (the npm package version) here would create a
-  // permanent mismatch whenever npm and crate versions diverge, forcing every
-  // subsequent build to be a full rebuild.
+  // When the native engine is active, persist the binary's CARGO_PKG_VERSION
+  // (ctx.nativeBinaryVersion). The Rust orchestrator's check_version_mismatch
+  // compares against that exact value, so writing the platform package.json
+  // version (ctx.engineVersion) — which can drift from the binary in CI
+  // hot-swap flows (#1066) — would force every subsequent native build to
+  // be a full rebuild.
   const codeVersionToWrite =
-    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
+    ctx.engineName === 'native' && ctx.nativeBinaryVersion
+      ? ctx.nativeBinaryVersion
+      : CODEGRAPH_VERSION;
   // Persist the repo root so downstream commands (e.g. `codegraph embed`)
   // can resolve relative file paths regardless of the invoking cwd.
   // Use realpathSync (symlink-resolving) to match the Rust engine's