@optave/codegraph 2.5.1 → 3.0.0

package/src/builder.js

@@ -338,7 +338,103 @@ function getChangedFiles(db, allFiles, rootDir) {
   return { changed, removed, isFullBuild: false };
 }
 
+/**
+ * Purge all graph data for the specified files.
+ * Deletes: embeddings → edges (in+out) → node_metrics → function_complexity → dataflow → nodes.
+ * Handles missing tables gracefully (embeddings, complexity, dataflow may not exist in older DBs).
+ *
+ * @param {import('better-sqlite3').Database} db - Open writable database
+ * @param {string[]} files - Relative file paths to purge
+ * @param {object} [options]
+ * @param {boolean} [options.purgeHashes=true] - Also delete file_hashes entries
+ */
+export function purgeFilesFromGraph(db, files, options = {}) {
+  const { purgeHashes = true } = options;
+  if (!files || files.length === 0) return;
+
+  // Check if embeddings table exists
+  let hasEmbeddings = false;
+  try {
+    db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
+    hasEmbeddings = true;
+  } catch {
+    /* table doesn't exist */
+  }
+
+  const deleteEmbeddingsForFile = hasEmbeddings
+    ? db.prepare('DELETE FROM embeddings WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)')
+    : null;
+  const deleteNodesForFile = db.prepare('DELETE FROM nodes WHERE file = ?');
+  const deleteEdgesForFile = db.prepare(`
+    DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f)
+    OR target_id IN (SELECT id FROM nodes WHERE file = @f)
+  `);
+  const deleteMetricsForFile = db.prepare(
+    'DELETE FROM node_metrics WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
+  );
+  let deleteComplexityForFile;
+  try {
+    deleteComplexityForFile = db.prepare(
+      'DELETE FROM function_complexity WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
+  } catch {
+    deleteComplexityForFile = null;
+  }
+  let deleteDataflowForFile;
+  try {
+    deleteDataflowForFile = db.prepare(
+      'DELETE FROM dataflow WHERE source_id IN (SELECT id FROM nodes WHERE file = ?) OR target_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
+  } catch {
+    deleteDataflowForFile = null;
+  }
+  let deleteHashForFile;
+  if (purgeHashes) {
+    try {
+      deleteHashForFile = db.prepare('DELETE FROM file_hashes WHERE file = ?');
+    } catch {
+      deleteHashForFile = null;
+    }
+  }
+  let deleteAstNodesForFile;
+  try {
+    deleteAstNodesForFile = db.prepare('DELETE FROM ast_nodes WHERE file = ?');
+  } catch {
+    deleteAstNodesForFile = null;
+  }
+  let deleteCfgForFile;
+  try {
+    deleteCfgForFile = db.prepare(
+      'DELETE FROM cfg_edges WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
+  } catch {
+    deleteCfgForFile = null;
+  }
+  let deleteCfgBlocksForFile;
+  try {
+    deleteCfgBlocksForFile = db.prepare(
+      'DELETE FROM cfg_blocks WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
+  } catch {
+    deleteCfgBlocksForFile = null;
+  }
+
+  for (const relPath of files) {
+    deleteEmbeddingsForFile?.run(relPath);
+    deleteEdgesForFile.run({ f: relPath });
+    deleteMetricsForFile.run(relPath);
+    deleteComplexityForFile?.run(relPath);
+    deleteDataflowForFile?.run(relPath, relPath);
+    deleteAstNodesForFile?.run(relPath);
+    deleteCfgForFile?.run(relPath);
+    deleteCfgBlocksForFile?.run(relPath);
+    deleteNodesForFile.run(relPath);
+    if (purgeHashes) deleteHashForFile?.run(relPath);
+  }
+}
+
 export async function buildGraph(rootDir, opts = {}) {
+  rootDir = path.resolve(rootDir);
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   const db = openDb(dbPath);
   initSchema(db);
@@ -352,19 +448,18 @@ export async function buildGraph(rootDir, opts = {}) {
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
   info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
-  // Check for engine/version mismatch on incremental builds
+  // Check for engine/version mismatch — auto-promote to full rebuild
+  let forceFullRebuild = false;
   if (incremental) {
     const prevEngine = getBuildMeta(db, 'engine');
     const prevVersion = getBuildMeta(db, 'codegraph_version');
     if (prevEngine && prevEngine !== engineName) {
-      warn(
-        `Engine changed (${prevEngine} → ${engineName}). Consider rebuilding with --no-incremental for consistency.`,
-      );
+      info(`Engine changed (${prevEngine} → ${engineName}), promoting to full rebuild.`);
+      forceFullRebuild = true;
     }
     if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
-      warn(
-        `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}). Consider rebuilding with --no-incremental for consistency.`,
-      );
+      info(`Version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`);
+      forceFullRebuild = true;
     }
   }
 
@@ -384,21 +479,91 @@ export async function buildGraph(rootDir, opts = {}) {
     );
   }
 
-  const collected = collectFiles(rootDir, [], config, new Set());
-  const files = collected.files;
-  const discoveredDirs = collected.directories;
-  info(`Found ${files.length} files to parse`);
-
-  // Check for incremental build
-  const { changed, removed, isFullBuild } = incremental
-    ? getChangedFiles(db, files, rootDir)
-    : { changed: files.map((f) => ({ file: f })), removed: [], isFullBuild: true };
-
-  // Separate metadata-only updates (mtime/size self-heal) from real changes
-  const parseChanges = changed.filter((c) => !c.metadataOnly);
-  const metadataUpdates = changed.filter((c) => c.metadataOnly);
+  // ── Scoped rebuild: rebuild only specified files ──────────────────
+  let files, discoveredDirs, parseChanges, metadataUpdates, removed, isFullBuild;
+
+  if (opts.scope) {
+    const scopedFiles = opts.scope.map((f) => normalizePath(f));
+    const existing = [];
+    const missing = [];
+    for (const rel of scopedFiles) {
+      const abs = path.join(rootDir, rel);
+      if (fs.existsSync(abs)) {
+        existing.push({ file: abs, relPath: rel });
+      } else {
+        missing.push(rel);
+      }
+    }
+    files = existing.map((e) => e.file);
+    // Derive discoveredDirs from scoped files' parent directories
+    discoveredDirs = new Set(existing.map((e) => path.dirname(e.file)));
+    parseChanges = existing;
+    metadataUpdates = [];
+    removed = missing;
+    isFullBuild = false;
+    info(`Scoped rebuild: ${existing.length} files to rebuild, ${missing.length} to purge`);
+  } else {
+    const collected = collectFiles(rootDir, [], config, new Set());
+    files = collected.files;
+    discoveredDirs = collected.directories;
+    info(`Found ${files.length} files to parse`);
+
+    // Check for incremental build
+    const increResult =
+      incremental && !forceFullRebuild
+        ? getChangedFiles(db, files, rootDir)
+        : { changed: files.map((f) => ({ file: f })), removed: [], isFullBuild: true };
+    removed = increResult.removed;
+    isFullBuild = increResult.isFullBuild;
+
+    // Separate metadata-only updates (mtime/size self-heal) from real changes
+    parseChanges = increResult.changed.filter((c) => !c.metadataOnly);
+    metadataUpdates = increResult.changed.filter((c) => c.metadataOnly);
+  }
 
   if (!isFullBuild && parseChanges.length === 0 && removed.length === 0) {
+    // Check if optional analysis was requested but never computed
+    const needsCfg =
+      opts.cfg &&
+      (() => {
+        try {
+          return db.prepare('SELECT COUNT(*) as c FROM cfg_blocks').get().c === 0;
+        } catch {
+          return true;
+        }
+      })();
+    const needsDataflow =
+      opts.dataflow &&
+      (() => {
+        try {
+          return (
+            db
+              .prepare(
+                "SELECT COUNT(*) as c FROM edges WHERE kind IN ('flows_to','returns','mutates')",
+              )
+              .get().c === 0
+          );
+        } catch {
+          return true;
+        }
+      })();
+
+    if (needsCfg || needsDataflow) {
+      info('No file changes. Running pending analysis pass...');
+      const analysisSymbols = await parseFilesAuto(files, rootDir, engineOpts);
+      if (needsCfg) {
+        const { buildCFGData } = await import('./cfg.js');
+        await buildCFGData(db, analysisSymbols, rootDir, engineOpts);
+      }
+      if (needsDataflow) {
+        const { buildDataflowEdges } = await import('./dataflow.js');
+        await buildDataflowEdges(db, analysisSymbols, rootDir, engineOpts);
+      }
+      closeDb(db);
+      writeJournalHeader(rootDir, Date.now());
+      return;
+    }
+
     // Still update metadata for self-healing even when no real changes
     if (metadataUpdates.length > 0) {
       try {
@@ -435,7 +600,7 @@ export async function buildGraph(rootDir, opts = {}) {
 
   if (isFullBuild) {
     const deletions =
-      'PRAGMA foreign_keys = OFF; DELETE FROM node_metrics; DELETE FROM edges; DELETE FROM nodes; PRAGMA foreign_keys = ON;';
+      'PRAGMA foreign_keys = OFF; DELETE FROM cfg_edges; DELETE FROM cfg_blocks; DELETE FROM node_metrics; DELETE FROM edges; DELETE FROM function_complexity; DELETE FROM dataflow; DELETE FROM ast_nodes; DELETE FROM nodes; PRAGMA foreign_keys = ON;';
     db.exec(
       hasEmbeddings
         ? `${deletions.replace('PRAGMA foreign_keys = ON;', '')} DELETE FROM embeddings; PRAGMA foreign_keys = ON;`
@@ -446,29 +611,33 @@ export async function buildGraph(rootDir, opts = {}) {
     // Find files with edges pointing TO changed/removed files.
     // Their nodes stay intact (preserving IDs), but outgoing edges are
     // deleted so they can be rebuilt during the edge-building pass.
-    const changedRelPaths = new Set();
-    for (const item of parseChanges) {
-      changedRelPaths.add(item.relPath || normalizePath(path.relative(rootDir, item.file)));
-    }
-    for (const relPath of removed) {
-      changedRelPaths.add(relPath);
-    }
-
+    // When opts.noReverseDeps is true (e.g. agent rollback to same version),
+    // skip this cascade — the agent knows exports didn't change.
     const reverseDeps = new Set();
-    if (changedRelPaths.size > 0) {
-      const findReverseDeps = db.prepare(`
-        SELECT DISTINCT n_src.file FROM edges e
-        JOIN nodes n_src ON e.source_id = n_src.id
-        JOIN nodes n_tgt ON e.target_id = n_tgt.id
-        WHERE n_tgt.file = ? AND n_src.file != n_tgt.file
-      `);
-      for (const relPath of changedRelPaths) {
-        for (const row of findReverseDeps.all(relPath)) {
-          if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
-            // Verify the file still exists on disk
-            const absPath = path.join(rootDir, row.file);
-            if (fs.existsSync(absPath)) {
-              reverseDeps.add(row.file);
+    if (!opts.noReverseDeps) {
+      const changedRelPaths = new Set();
+      for (const item of parseChanges) {
+        changedRelPaths.add(item.relPath || normalizePath(path.relative(rootDir, item.file)));
+      }
+      for (const relPath of removed) {
+        changedRelPaths.add(relPath);
+      }
+
+      if (changedRelPaths.size > 0) {
+        const findReverseDeps = db.prepare(`
+          SELECT DISTINCT n_src.file FROM edges e
+          JOIN nodes n_src ON e.source_id = n_src.id
+          JOIN nodes n_tgt ON e.target_id = n_tgt.id
+          WHERE n_tgt.file = ? AND n_src.file != n_tgt.file AND n_src.kind != 'directory'
+        `);
+        for (const relPath of changedRelPaths) {
+          for (const row of findReverseDeps.all(relPath)) {
+            if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
+              // Verify the file still exists on disk
+              const absPath = path.join(rootDir, row.file);
+              if (fs.existsSync(absPath)) {
+                reverseDeps.add(row.file);
+              }
             }
           }
         }
@@ -482,47 +651,16 @@ export async function buildGraph(rootDir, opts = {}) {
       debug(`Changed files: ${parseChanges.map((c) => c.relPath).join(', ')}`);
     if (removed.length > 0) debug(`Removed files: ${removed.join(', ')}`);
     // Remove embeddings/metrics/edges/nodes for changed and removed files
-    // Embeddings must be deleted BEFORE nodes (we need node IDs to find them)
-    const deleteEmbeddingsForFile = hasEmbeddings
-      ? db.prepare('DELETE FROM embeddings WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)')
-      : null;
-    const deleteNodesForFile = db.prepare('DELETE FROM nodes WHERE file = ?');
-    const deleteEdgesForFile = db.prepare(`
-      DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f)
-      OR target_id IN (SELECT id FROM nodes WHERE file = @f)
-    `);
-    const deleteOutgoingEdgesForFile = db.prepare(
-      'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-    const deleteMetricsForFile = db.prepare(
-      'DELETE FROM node_metrics WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
+    const changePaths = parseChanges.map(
+      (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
     );
-    let deleteComplexityForFile;
-    try {
-      deleteComplexityForFile = db.prepare(
-        'DELETE FROM function_complexity WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
-      );
-    } catch {
-      deleteComplexityForFile = null;
-    }
-    for (const relPath of removed) {
-      deleteEmbeddingsForFile?.run(relPath);
-      deleteEdgesForFile.run({ f: relPath });
-      deleteMetricsForFile.run(relPath);
-      deleteComplexityForFile?.run(relPath);
-      deleteNodesForFile.run(relPath);
-    }
-    for (const item of parseChanges) {
-      const relPath = item.relPath || normalizePath(path.relative(rootDir, item.file));
-      deleteEmbeddingsForFile?.run(relPath);
-      deleteEdgesForFile.run({ f: relPath });
-      deleteMetricsForFile.run(relPath);
-      deleteComplexityForFile?.run(relPath);
-      deleteNodesForFile.run(relPath);
-    }
+    purgeFilesFromGraph(db, [...removed, ...changePaths], { purgeHashes: false });
 
     // Process reverse deps: delete only outgoing edges (nodes/IDs preserved)
     // then add them to the parse list so they participate in edge building
+    const deleteOutgoingEdgesForFile = db.prepare(
+      'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
     for (const relPath of reverseDeps) {
       deleteOutgoingEdgesForFile.run(relPath);
     }
@@ -533,7 +671,7 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   const insertNode = db.prepare(
-    'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
+    'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line, parent_id) VALUES (?, ?, ?, ?, ?, ?)',
   );
   const getNodeId = db.prepare(
     'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
@@ -587,12 +725,39 @@ export async function buildGraph(rootDir, opts = {}) {
     for (const [relPath, symbols] of allSymbols) {
       fileSymbols.set(relPath, symbols);
 
-      insertNode.run(relPath, 'file', relPath, 0, null);
+      insertNode.run(relPath, 'file', relPath, 0, null, null);
+      const fileRow = getNodeId.get(relPath, 'file', relPath, 0);
       for (const def of symbols.definitions) {
-        insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
+        insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null, null);
+        const defRow = getNodeId.get(def.name, def.kind, relPath, def.line);
+        // File → top-level definition contains edge
+        if (fileRow && defRow) {
+          insertEdge.run(fileRow.id, defRow.id, 'contains', 1.0, 0);
+        }
+        if (def.children?.length && defRow) {
+          for (const child of def.children) {
+            insertNode.run(
+              child.name,
+              child.kind,
+              relPath,
+              child.line,
+              child.endLine || null,
+              defRow.id,
+            );
+            // Parent → child contains edge
+            const childRow = getNodeId.get(child.name, child.kind, relPath, child.line);
+            if (childRow) {
+              insertEdge.run(defRow.id, childRow.id, 'contains', 1.0, 0);
+              // Parameter → parent parameter_of edge (inverse direction)
+              if (child.kind === 'parameter') {
+                insertEdge.run(childRow.id, defRow.id, 'parameter_of', 1.0, 0);
+              }
+            }
+          }
+        }
       }
       for (const exp of symbols.exports) {
-        insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
+        insertNode.run(exp.name, exp.kind, relPath, exp.line, null, null);
       }
 
       // Update file hash with real mtime+size for incremental builds
@@ -687,6 +852,46 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
+  // For incremental builds, load unchanged barrel files into reexportMap
+  // so barrel-resolved import/call edges aren't dropped for reverse-dep files.
+  // These files are loaded only for resolution — they must NOT be iterated
+  // in the edge-building loop (their existing edges are still in the DB).
+  const barrelOnlyFiles = new Set();
+  if (!isFullBuild) {
+    const barrelCandidates = db
+      .prepare(
+        `SELECT DISTINCT n1.file FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+      )
+      .all();
+    for (const { file: relPath } of barrelCandidates) {
+      if (fileSymbols.has(relPath)) continue;
+      const absPath = path.join(rootDir, relPath);
+      try {
+        const symbols = await parseFilesAuto([absPath], rootDir, engineOpts);
+        const fileSym = symbols.get(relPath);
+        if (fileSym) {
+          fileSymbols.set(relPath, fileSym);
+          barrelOnlyFiles.add(relPath);
+          const reexports = fileSym.imports.filter((imp) => imp.reexport);
+          if (reexports.length > 0) {
+            reexportMap.set(
+              relPath,
+              reexports.map((imp) => ({
+                source: getResolved(absPath, imp.source),
+                names: imp.names,
+                wildcardReexport: imp.wildcardReexport || false,
+              })),
+            );
+          }
+        }
+      } catch {
+        /* skip if unreadable */
+      }
+    }
+  }
+
   function isBarrelFile(relPath) {
     const symbols = fileSymbols.get(relPath);
     if (!symbols) return false;
@@ -732,7 +937,7 @@ export async function buildGraph(rootDir, opts = {}) {
   // N+1 optimization: pre-load all nodes into a lookup map for edge building
   const allNodes = db
     .prepare(
-      `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface')`,
+      `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface','struct','type','module','enum','trait')`,
     )
     .all();
   const nodesByName = new Map();
@@ -749,9 +954,10 @@ export async function buildGraph(rootDir, opts = {}) {
 
   // Second pass: build edges
   _t.edges0 = performance.now();
-  let edgeCount = 0;
   const buildEdges = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
+      // Skip barrel-only files — loaded for resolution, edges already in DB
+      if (barrelOnlyFiles.has(relPath)) continue;
       const fileNodeRow = getNodeId.get(relPath, 'file', relPath, 0);
       if (!fileNodeRow) continue;
       const fileNodeId = fileNodeRow.id;
@@ -763,7 +969,6 @@ export async function buildGraph(rootDir, opts = {}) {
         if (targetRow) {
           const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
           insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
-          edgeCount++;
 
           if (!imp.reexport && isBarrelFile(resolvedPath)) {
             const resolvedSources = new Set();
@@ -785,7 +990,6 @@ export async function buildGraph(rootDir, opts = {}) {
                     0.9,
                     0,
                   );
-                  edgeCount++;
                 }
               }
             }
@@ -886,7 +1090,29 @@ export async function buildGraph(rootDir, opts = {}) {
             seenCallEdges.add(edgeKey);
             const confidence = computeConfidence(relPath, t.file, importedFrom);
             insertEdge.run(caller.id, t.id, 'calls', confidence, isDynamic);
-            edgeCount++;
+          }
+        }
+
+        // Receiver edge: caller → receiver type node
+        if (
+          call.receiver &&
+          !BUILTIN_RECEIVERS.has(call.receiver) &&
+          call.receiver !== 'this' &&
+          call.receiver !== 'self' &&
+          call.receiver !== 'super'
+        ) {
+          const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
+          // Same-file first, then global
+          const samefile = nodesByNameAndFile.get(`${call.receiver}|${relPath}`) || [];
+          const candidates = samefile.length > 0 ? samefile : nodesByName.get(call.receiver) || [];
+          const receiverNodes = candidates.filter((n) => receiverKinds.has(n.kind));
+          if (receiverNodes.length > 0 && caller) {
+            const recvTarget = receiverNodes[0];
+            const recvKey = `recv|${caller.id}|${recvTarget.id}`;
+            if (!seenCallEdges.has(recvKey)) {
+              seenCallEdges.add(recvKey);
+              insertEdge.run(caller.id, recvTarget.id, 'receiver', 0.7, 0);
+            }
           }
         }
       }
@@ -902,7 +1128,6 @@ export async function buildGraph(rootDir, opts = {}) {
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'extends', 1.0, 0);
-              edgeCount++;
             }
           }
         }
@@ -918,7 +1143,6 @@ export async function buildGraph(rootDir, opts = {}) {
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'implements', 1.0, 0);
-              edgeCount++;
             }
           }
         }
@@ -1026,6 +1250,17 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   _t.rolesMs = performance.now() - _t.roles0;
 
+  // Always-on AST node extraction (calls, new, string, regex, throw, await)
+  // Must run before complexity which releases _tree references
+  _t.ast0 = performance.now();
+  try {
+    const { buildAstNodes } = await import('./ast.js');
+    await buildAstNodes(db, allSymbols, rootDir, engineOpts);
+  } catch (err) {
+    debug(`AST node extraction failed: ${err.message}`);
+  }
+  _t.astMs = performance.now() - _t.ast0;
+
   // Compute per-function complexity metrics (cognitive, cyclomatic, nesting)
   _t.complexity0 = performance.now();
   try {
@@ -1036,6 +1271,30 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   _t.complexityMs = performance.now() - _t.complexity0;
 
+  // Opt-in CFG analysis (--cfg)
+  if (opts.cfg) {
+    _t.cfg0 = performance.now();
+    try {
+      const { buildCFGData } = await import('./cfg.js');
+      await buildCFGData(db, allSymbols, rootDir, engineOpts);
+    } catch (err) {
+      debug(`CFG analysis failed: ${err.message}`);
+    }
+    _t.cfgMs = performance.now() - _t.cfg0;
+  }
+
+  // Opt-in dataflow analysis (--dataflow)
+  if (opts.dataflow) {
+    _t.dataflow0 = performance.now();
+    try {
+      const { buildDataflowEdges } = await import('./dataflow.js');
+      await buildDataflowEdges(db, allSymbols, rootDir, engineOpts);
+    } catch (err) {
+      debug(`Dataflow analysis failed: ${err.message}`);
+    }
+    _t.dataflowMs = performance.now() - _t.dataflow0;
+  }
+
   // Release any remaining cached WASM trees for GC
   for (const [, symbols] of allSymbols) {
     symbols._tree = null;
@@ -1043,9 +1302,30 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   const nodeCount = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
-  info(`Graph built: ${nodeCount} nodes, ${edgeCount} edges`);
+  const actualEdgeCount = db.prepare('SELECT COUNT(*) as c FROM edges').get().c;
+  info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
   info(`Stored in ${dbPath}`);
 
+  // Verify incremental build didn't diverge significantly from previous counts
+  if (!isFullBuild) {
+    const prevNodes = getBuildMeta(db, 'node_count');
+    const prevEdges = 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.build?.driftThreshold ?? 0.2;
+        if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
+          warn(
+            `Incremental build diverged significantly from previous counts (nodes: ${prevN}→${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}→${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
+          );
+        }
+      }
+    }
+  }
+
   // Warn about orphaned embeddings that no longer match any node
   if (hasEmbeddings) {
     try {
@@ -1069,6 +1349,8 @@ export async function buildGraph(rootDir, opts = {}) {
       engine_version: engineVersion || '',
       codegraph_version: CODEGRAPH_VERSION,
       built_at: new Date().toISOString(),
+      node_count: nodeCount,
+      edge_count: actualEdgeCount,
     });
   } catch (err) {
     warn(`Failed to write build metadata: ${err.message}`);
@@ -1104,6 +1386,7 @@ export async function buildGraph(rootDir, opts = {}) {
       structureMs: +_t.structureMs.toFixed(1),
       rolesMs: +_t.rolesMs.toFixed(1),
       complexityMs: +_t.complexityMs.toFixed(1),
+      ...(_t.cfgMs != null && { cfgMs: +_t.cfgMs.toFixed(1) }),
     },
   };
 }