@optave/codegraph 3.5.0 → 3.6.0

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

@@ -6,9 +6,9 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { getNodeId } from '#db/index.js';
-import { debug } from '#infrastructure/logger.js';
-import { loadNative } from '#infrastructure/native.js';
+import { getNodeId } from '../../../../db/index.js';
+import { debug } from '../../../../infrastructure/logger.js';
+import { loadNative } from '../../../../infrastructure/native.js';
 import type {
   BetterSqlite3Database,
   Call,
@@ -18,10 +18,11 @@ import type {
   NativeAddon,
   NodeRow,
   TypeMapEntry,
-} from '#types';
+} from '../../../../types.js';
 import { computeConfidence } from '../../resolve.js';
 import type { PipelineContext } from '../context.js';
 import { BUILTIN_RECEIVERS, batchInsertEdges } from '../helpers.js';
+
 import { getResolved, isBarrelFile, resolveBarrelExport } from './resolve-imports.js';
 
 // ── Local types ──────────────────────────────────────────────────────────
@@ -61,12 +62,6 @@ interface NativeEdge {
   dynamic: number;
 }
 
-/** TypeMap entry used in receiver supplement (normalized from native format). */
-interface NormalizedTypeEntry {
-  type: string;
-  confidence: number;
-}
-
 // ── Node lookup setup ───────────────────────────────────────────────────
 
 function makeGetNodeIdStmt(db: BetterSqlite3Database): NodeIdStmt {
@@ -210,14 +205,6 @@ function buildCallEdgesNative(
   for (const e of nativeEdges) {
     allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
   }
-
-  // Older native binaries (< 3.2.0) don't emit receiver or type-resolved method-call
-  // edges. Supplement them on the JS side if the native binary missed them.
-  // TODO: Remove once all published native binaries handle receivers (>= 3.2.0)
-  const hasReceiver = nativeEdges.some((e) => e.kind === 'receiver');
-  if (!hasReceiver) {
-    supplementReceiverEdges(ctx, nativeFiles, getNodeIdStmt, allEdgeRows);
-  }
 }
 
 function buildImportedNamesForNative(
@@ -242,58 +229,6 @@ function buildImportedNamesForNative(
   return importedNames;
 }
 
-// ── Receiver edge supplement for older native binaries ──────────────────
-
-function supplementReceiverEdges(
-  ctx: PipelineContext,
-  nativeFiles: NativeFileEntry[],
-  getNodeIdStmt: NodeIdStmt,
-  allEdgeRows: EdgeRowTuple[],
-): void {
-  const seenCallEdges = new Set<string>();
-  // Collect existing edges to avoid duplicates
-  for (const row of allEdgeRows) {
-    seenCallEdges.add(`${row[0]}|${row[1]}|${row[2]}`);
-  }
-
-  for (const nf of nativeFiles) {
-    const relPath = nf.file;
-    const typeMap = new Map<string, NormalizedTypeEntry>(
-      nf.typeMap.map((t) => [t.name, { type: t.typeName, confidence: t.confidence ?? 0.9 }]),
-    );
-    const fileNodeRow = { id: nf.fileNodeId };
-
-    for (const call of nf.calls) {
-      if (!call.receiver || BUILTIN_RECEIVERS.has(call.receiver)) continue;
-      if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super')
-        continue;
-
-      const caller = findCaller(call, nf.definitions, relPath, getNodeIdStmt, fileNodeRow);
-
-      // Receiver edge: caller → receiver type node
-      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows, typeMap);
-
-      // Type-resolved method call: caller → Type.method
-      const typeEntry = typeMap.get(call.receiver);
-      const typeName = typeEntry ? typeEntry.type : null;
-      if (typeName) {
-        const qualifiedName = `${typeName}.${call.name}`;
-        const targets = (ctx.nodesByName.get(qualifiedName) || []).filter(
-          (n) => n.kind === 'method',
-        );
-        for (const t of targets) {
-          const key = `${caller.id}|${t.id}|calls`;
-          if (t.id !== caller.id && !seenCallEdges.has(key)) {
-            seenCallEdges.add(key);
-            const confidence = computeConfidence(relPath, t.file, null);
-            allEdgeRows.push([caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0]);
-          }
-        }
-      }
-    }
-  }
-}
-
 // ── Call edges (JS fallback) ────────────────────────────────────────────
 
 function buildCallEdgesJS(
@@ -495,7 +430,7 @@ function buildReceiverEdge(
   relPath: string,
   seenCallEdges: Set<string>,
   allEdgeRows: EdgeRowTuple[],
-  typeMap: Map<string, TypeMapEntry | NormalizedTypeEntry | string>,
+  typeMap: Map<string, TypeMapEntry | string>,
 ): void {
   const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
   const typeEntry = typeMap?.get(call.receiver!);
@@ -608,7 +543,7 @@ function loadNodes(ctx: PipelineContext): { rows: QueryNodeRow[]; scoped: boolea
 
 /**
  * For scoped node loading, patch nodesByName.get with a lazy SQL fallback
- * so global name-only lookups (resolveByMethodOrGlobal, supplementReceiverEdges)
+ * so global name-only lookups (resolveByMethodOrGlobal)
  * can still find nodes outside the scoped set.
  */
 function addLazyFallback(ctx: PipelineContext, scopedLoad: boolean): void {
@@ -673,7 +608,7 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
 
     // When using native edge insert, skip JS insert here — do it after tx commits.
     // Otherwise insert edges within this transaction for atomicity.
-    const useNativeEdgeInsert = !!ctx.nativeDb?.bulkInsertEdges;
+    const useNativeEdgeInsert = ctx.engineName === 'native' && !!ctx.nativeDb?.bulkInsertEdges;
     if (!useNativeEdgeInsert) {
       batchInsertEdges(db, allEdgeRows);
     }
@@ -683,7 +618,7 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
   // Phase 2: Native rusqlite bulk insert (outside better-sqlite3 transaction
   // to avoid SQLITE_BUSY contention). Uses NativeDatabase persistent connection.
   // Standalone napi functions were removed in 6.17.
-  if (ctx.nativeDb?.bulkInsertEdges && allEdgeRows.length > 0) {
+  if (ctx.engineName === 'native' && ctx.nativeDb?.bulkInsertEdges && allEdgeRows.length > 0) {
     const nativeEdges = allEdgeRows.map((r) => ({
       sourceId: r[0],
       targetId: r[1],
@@ -694,7 +629,7 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
     const ok = ctx.nativeDb.bulkInsertEdges(nativeEdges);
     if (!ok) {
       debug('Native bulkInsertEdges failed — falling back to JS batchInsertEdges');
-      batchInsertEdges(db, allEdgeRows);
+      batchInsertEdges(ctx.db, allEdgeRows);
     }
   }
 

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

@@ -5,9 +5,9 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { debug } from '#infrastructure/logger.js';
-import { normalizePath } from '#shared/constants.js';
-import type { ExtractorOutput } from '#types';
+import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
+import type { ExtractorOutput } from '../../../../types.js';
 import type { PipelineContext } from '../context.js';
 import { readFileSafe } from '../helpers.js';
 
@@ -39,10 +39,11 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
   // loading ALL definitions from DB (~8ms) and recomputing ALL metrics (~15ms).
   // Gate: ≤5 changed files AND significantly more existing files (>20) to
   // avoid triggering on small test fixtures where directory metrics matter.
+  const useNativeReads = ctx.engineName === 'native' && !!ctx.nativeDb;
   const existingFileCount = !isFullBuild
     ? (
-        (ctx.nativeDb
-          ? ctx.nativeDb.queryGet("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'", [])
+        (useNativeReads
+          ? ctx.nativeDb!.queryGet("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'", [])
           : db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get()) as {
           c: number;
         }
@@ -96,7 +97,8 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
 
     // Use NativeDatabase persistent connection (Phase 6.15+).
     // Standalone napi functions were removed in 6.17 — falls through to JS if nativeDb unavailable.
-    if (ctx.nativeDb?.classifyRolesFull) {
+    // Note: classifyRoles* both read (fan-in/fan-out) and write (UPDATE nodes SET role).
+    if (useNativeReads && ctx.nativeDb?.classifyRolesFull) {
       const nativeResult =
         changedFileList && changedFileList.length > 0
           ? ctx.nativeDb.classifyRolesIncremental(changedFileList)
@@ -126,7 +128,7 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
           changedFiles?: string[] | null,
         ) => Record<string, number>;
       };
-      roleSummary = classifyNodeRoles(db, changedFileList);
+      roleSummary = classifyNodeRoles(ctx.db, changedFileList);
     }
 
     debug(

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

@@ -7,8 +7,8 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, info } from '#infrastructure/logger.js';
-import { normalizePath } from '#shared/constants.js';
+import { debug, info } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import { readJournal } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
 import { collectFiles as collectFilesUtil } from '../helpers.js';

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

@@ -338,7 +338,7 @@ function purgeAndAddReverseDeps(
   if (hasPurge || hasReverseDeps) {
     const filesToPurge = hasPurge ? [...ctx.removed, ...changePaths] : [];
     // Prefer NativeDatabase: purge + reverse-dep edge deletion in one transaction (#670)
-    if (ctx.nativeDb?.purgeFilesData) {
+    if (ctx.engineName === 'native' && ctx.nativeDb?.purgeFilesData) {
       ctx.nativeDb.purgeFilesData(filesToPurge, false, hasReverseDeps ? reverseDepList : undefined);
     } else {
       if (hasPurge) {
@@ -433,7 +433,12 @@ export async function detectChanges(ctx: PipelineContext): Promise<void> {
   }
   const increResult =
     incremental && !forceFullRebuild
-      ? getChangedFiles(db, allFiles, rootDir, ctx.nativeDb)
+      ? getChangedFiles(
+          db,
+          allFiles,
+          rootDir,
+          ctx.engineName === 'native' ? ctx.nativeDb : undefined,
+        )
       : {
           changed: allFiles.map((f): ChangedFile => ({ file: f })),
           removed: [] as string[],

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

@@ -17,12 +17,8 @@ import { CODEGRAPH_VERSION } from '../../../../shared/version.js';
 import { writeJournalHeader } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
 
-export async function finalize(ctx: PipelineContext): Promise<void> {
-  const { db, allSymbols, rootDir, isFullBuild, hasEmbeddings, config, opts, schemaVersion } = ctx;
-
-  const t0 = performance.now();
-
-  // Release cached WASM trees
+/** Release cached WASM parse trees to free memory. */
+function releaseWasmTrees(allSymbols: PipelineContext['allSymbols']): void {
   for (const [, symbols] of allSymbols) {
     const tree = symbols._tree as { delete?: () => void } | undefined;
     if (tree && typeof tree.delete === 'function') {
@@ -35,133 +31,141 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
     symbols._tree = undefined;
     symbols._langId = undefined;
   }
+}
 
-  // Capture a single wall-clock timestamp for the current build — used for
-  // both the stale-embeddings comparison and the persisted built_at metadata.
-  const buildNow = new Date();
+/**
+ * Detect significant drift between current and previous node/edge counts.
+ * Skipped for small incremental changes where count fluctuation is expected.
+ */
+function detectIncrementalDrift(
+  ctx: PipelineContext,
+  nodeCount: number,
+  actualEdgeCount: number,
+): void {
+  const { db, allSymbols, config } = ctx;
+  const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
+  if (ctx.isFullBuild || allSymbols.size <= 3) return;
 
-  const nodeCount = (db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number }).c;
-  const actualEdgeCount = (db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
-  info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
-  info(`Stored in ${ctx.dbPath}`);
+  const prevNodes = useNativeDb
+    ? ctx.nativeDb!.getBuildMeta('node_count')
+    : getBuildMeta(db, 'node_count');
+  const prevEdges = useNativeDb
+    ? ctx.nativeDb!.getBuildMeta('edge_count')
+    : getBuildMeta(db, 'edge_count');
+  if (!prevNodes || !prevEdges) return;
 
-  // Incremental drift detection — skip for small incremental changes where
-  // count fluctuation is expected (reverse-dep edge churn).
-  if (!isFullBuild && allSymbols.size > 3) {
-    const prevNodes = ctx.nativeDb
-      ? ctx.nativeDb.getBuildMeta('node_count')
-      : getBuildMeta(db, 'node_count');
-    const prevEdges = ctx.nativeDb
-      ? ctx.nativeDb.getBuildMeta('edge_count')
-      : getBuildMeta(db, 'edge_count');
-    if (prevNodes && prevEdges) {
-      const prevN = Number(prevNodes);
-      const prevE = Number(prevEdges);
-      if (prevN > 0) {
-        const nodeDrift = Math.abs(nodeCount - prevN) / prevN;
-        const edgeDrift = prevE > 0 ? Math.abs(actualEdgeCount - prevE) / prevE : 0;
-        const driftThreshold =
-          (config as { build?: { driftThreshold?: number } }).build?.driftThreshold ?? 0.2;
-        if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
-          warn(
-            `Incremental build diverged significantly from previous counts (nodes: ${prevN}\u2192${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}\u2192${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
-          );
-        }
-      }
-    }
+  const prevN = Number(prevNodes);
+  const prevE = Number(prevEdges);
+  if (prevN <= 0) return;
+
+  const nodeDrift = Math.abs(nodeCount - prevN) / prevN;
+  const edgeDrift = prevE > 0 ? Math.abs(actualEdgeCount - prevE) / prevE : 0;
+  const driftThreshold =
+    (config as { build?: { driftThreshold?: number } }).build?.driftThreshold ?? 0.2;
+  if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
+    warn(
+      `Incremental build diverged significantly from previous counts (nodes: ${prevN}\u2192${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}\u2192${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
+    );
   }
+}
 
-  // For small incremental builds, skip persisting build metadata — the
-  // engine/version/schema haven't changed (would have triggered a full rebuild),
-  // built_at is only used by stale-embeddings check (skipped for incremental),
-  // and counts are only used by drift detection (skipped for ≤3 files).
-  // This avoids a transaction commit + WAL fsync (~15-30ms).
-  // Threshold aligned with drift detection gate (allSymbols.size > 3) so stored
-  // counts stay fresh whenever drift detection reads them.
-  if (isFullBuild || allSymbols.size > 3) {
-    try {
-      if (ctx.nativeDb) {
-        ctx.nativeDb.setBuildMeta(
-          Object.entries({
-            engine: ctx.engineName,
-            engine_version: ctx.engineVersion || '',
-            codegraph_version: CODEGRAPH_VERSION,
-            schema_version: String(schemaVersion),
-            built_at: buildNow.toISOString(),
-            node_count: String(nodeCount),
-            edge_count: String(actualEdgeCount),
-          }).map(([key, value]) => ({ key, value: String(value) })),
-        );
-      } else {
-        setBuildMeta(db, {
+/**
+ * Persist build metadata (engine, version, counts, timestamp).
+ * Skipped for small incremental builds to avoid WAL fsync cost.
+ */
+function persistBuildMetadata(
+  ctx: PipelineContext,
+  nodeCount: number,
+  actualEdgeCount: number,
+  buildNow: Date,
+): void {
+  const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
+  if (!ctx.isFullBuild && ctx.allSymbols.size <= 3) return;
+  try {
+    if (useNativeDb) {
+      ctx.nativeDb!.setBuildMeta(
+        Object.entries({
           engine: ctx.engineName,
           engine_version: ctx.engineVersion || '',
           codegraph_version: CODEGRAPH_VERSION,
-          schema_version: String(schemaVersion),
+          schema_version: String(ctx.schemaVersion),
           built_at: buildNow.toISOString(),
-          node_count: nodeCount,
-          edge_count: actualEdgeCount,
-        });
-      }
-    } catch (err) {
-      warn(`Failed to write build metadata: ${(err as Error).message}`);
+          node_count: String(nodeCount),
+          edge_count: String(actualEdgeCount),
+        }).map(([key, value]) => ({ key, value: String(value) })),
+      );
+    } else {
+      setBuildMeta(ctx.db, {
+        engine: ctx.engineName,
+        engine_version: ctx.engineVersion || '',
+        codegraph_version: CODEGRAPH_VERSION,
+        schema_version: String(ctx.schemaVersion),
+        built_at: buildNow.toISOString(),
+        node_count: nodeCount,
+        edge_count: actualEdgeCount,
+      });
     }
+  } catch (err) {
+    warn(`Failed to write build metadata: ${(err as Error).message}`);
   }
+}
 
-  // Skip expensive advisory queries for incremental builds — these are
-  // informational warnings that don't affect correctness and cost ~40-60ms.
-  if (!isFullBuild) {
-    debug(
-      'Finalize: skipping advisory queries (orphaned/stale embeddings, unused exports) for incremental build',
-    );
-  } else {
-    // Orphaned embeddings warning
-    if (hasEmbeddings) {
-      try {
-        const orphaned = (
-          db
-            .prepare(
-              'SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)',
-            )
-            .get() as { c: number }
-        ).c;
-        if (orphaned > 0) {
-          warn(
-            `${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
-          );
-        }
-      } catch {
-        /* ignore - embeddings table may have been dropped */
+/**
+ * Run advisory checks on full builds: orphaned embeddings, stale embeddings,
+ * and unused exports. Informational only — does not affect correctness.
+ */
+function runAdvisoryChecks(
+  db: PipelineContext['db'],
+  hasEmbeddings: boolean,
+  buildNow: Date,
+): void {
+  // Orphaned embeddings warning
+  if (hasEmbeddings) {
+    try {
+      const orphaned = (
+        db
+          .prepare(
+            'SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)',
+          )
+          .get() as { c: number }
+      ).c;
+      if (orphaned > 0) {
+        warn(
+          `${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
+        );
       }
+    } catch {
+      /* ignore - embeddings table may have been dropped */
     }
+  }
 
-    // Stale embeddings warning (built before current graph rebuild)
-    if (hasEmbeddings) {
-      try {
-        const embedBuiltAt = (
-          db.prepare("SELECT value FROM embedding_meta WHERE key = 'built_at'").get() as
-            | { value: string }
-            | undefined
-        )?.value;
-        if (embedBuiltAt) {
-          const embedTime = new Date(embedBuiltAt).getTime();
-          if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
-            warn(
-              'Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.',
-            );
-          }
+  // Stale embeddings warning (built before current graph rebuild)
+  if (hasEmbeddings) {
+    try {
+      const embedBuiltAt = (
+        db.prepare("SELECT value FROM embedding_meta WHERE key = 'built_at'").get() as
+          | { value: string }
+          | undefined
+      )?.value;
+      if (embedBuiltAt) {
+        const embedTime = new Date(embedBuiltAt).getTime();
+        if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
+          warn(
+            'Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.',
+          );
         }
-      } catch {
-        /* ignore - embedding_meta table may not exist */
       }
+    } catch {
+      /* ignore - embedding_meta table may not exist */
     }
+  }
 
-    // Unused exports warning
-    try {
-      const unusedCount = (
-        db
-          .prepare(
-            `SELECT COUNT(*) as c FROM nodes
+  // Unused exports warning
+  try {
+    const unusedCount = (
+      db
+        .prepare(
+          `SELECT COUNT(*) as c FROM nodes
          WHERE exported = 1 AND kind != 'file'
            AND id NOT IN (
              SELECT DISTINCT e.target_id FROM edges e
@@ -169,17 +173,47 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
              JOIN nodes target ON e.target_id = target.id
              WHERE e.kind = 'calls' AND caller.file != target.file
            )`,
-          )
-          .get() as { c: number }
-      ).c;
-      if (unusedCount > 0) {
-        warn(
-          `${unusedCount} exported symbol${unusedCount > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
-        );
-      }
-    } catch {
-      /* exported column may not exist on older DBs */
+        )
+        .get() as { c: number }
+    ).c;
+    if (unusedCount > 0) {
+      warn(
+        `${unusedCount} exported symbol${unusedCount > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
+      );
     }
+  } catch {
+    /* exported column may not exist on older DBs */
+  }
+}
+
+export async function finalize(ctx: PipelineContext): Promise<void> {
+  const { allSymbols, rootDir, isFullBuild, hasEmbeddings, opts } = ctx;
+
+  const t0 = performance.now();
+
+  releaseWasmTrees(allSymbols);
+
+  // Capture a single wall-clock timestamp for the current build — used for
+  // both the stale-embeddings comparison and the persisted built_at metadata.
+  const buildNow = new Date();
+
+  const nodeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number }).c;
+  const actualEdgeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number })
+    .c;
+  info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
+  info(`Stored in ${ctx.dbPath}`);
+
+  detectIncrementalDrift(ctx, nodeCount, actualEdgeCount);
+  persistBuildMetadata(ctx, nodeCount, actualEdgeCount, buildNow);
+
+  // Skip expensive advisory queries for incremental builds — these are
+  // informational warnings that don't affect correctness and cost ~40-60ms.
+  if (!isFullBuild) {
+    debug(
+      'Finalize: skipping advisory queries (orphaned/stale embeddings, unused exports) for incremental build',
+    );
+  } else {
+    runAdvisoryChecks(ctx.db, hasEmbeddings, buildNow);
   }
 
   // Intentionally measured before closeDb / writeJournalHeader / auto-registration:
@@ -192,7 +226,7 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
   // For small incremental builds, defer the expensive WAL checkpoint to the
   // next event loop tick. Skip for temp directories (tests) — they rmSync
   // immediately after build.
-  const pair = { db, nativeDb: ctx.nativeDb };
+  const pair = { db: ctx.db, nativeDb: ctx.nativeDb };
   const isTempDir = path.resolve(rootDir).startsWith(path.resolve(tmpdir()));
   if (!isFullBuild && allSymbols.size <= 5 && !isTempDir) {
     closeDbPairDeferred(pair);