fix(native): js-side fast-skip for incremental no-op rebuilds (#1054)

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,
@@ -39,6 +40,7 @@ import {
   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';
@@ -47,7 +49,7 @@ 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';
@@ -1000,6 +1002,36 @@ 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.
+    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)) {
+          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.
+        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

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

@@ -512,6 +512,63 @@ 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.
+ *
+ * Pure read of `db` and the filesystem — never mutates either.
+ */
+export function detectNoChanges(
+  db: BetterSqlite3Database,
+  allFiles: string[],
+  rootDir: string,
+): boolean {
+  let hasTable = false;
+  try {
+    db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
+    hasTable = true;
+  } catch {
+    /* table missing — first build */
+  }
+  if (!hasTable) return false;
+
+  const rows = db.prepare('SELECT file, hash, mtime, size FROM file_hashes').all() as FileHashRow[];
+  if (rows.length === 0) 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)) return false;
+  }
+
+  for (const file of allFiles) {
+    const relPath = normalizePath(path.relative(rootDir, file));
+    const record = existing.get(relPath);
+    if (!record) return false;
+    const stat = fileStat(file) as FileStat | undefined;
+    if (!stat) return false;
+    const storedMtime = record.mtime || 0;
+    const storedSize = record.size || 0;
+    if (storedSize <= 0) return false;
+    if (Math.floor(stat.mtimeMs) !== storedMtime || stat.size !== storedSize) return false;
+  }
+
+  return true;
+}
+
 export async function detectChanges(ctx: PipelineContext): Promise<void> {
   const start = performance.now();
   try {