@optave/codegraph 3.8.0 → 3.9.0

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

@@ -6,12 +6,21 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import {
+  closeDbPair,
+  getBuildMeta,
+  initSchema,
+  MIGRATIONS,
+  openDb,
+  setBuildMeta,
+} from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
-import { info, warn } from '../../../infrastructure/logger.js';
+import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
+import { semverCompare } from '../../../infrastructure/update-check.js';
+import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
-import type { BuildGraphOpts, BuildResult } from '../../../types.js';
+import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -50,8 +59,10 @@ function initializeEngine(ctx: PipelineContext): void {
       ? () => {
           try {
             ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-          } catch {
-            /* ignore — nativeDb may already be closed */
+          } catch (e) {
+            debug(
+              `resumeJsDb: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+            );
           }
         }
       : undefined,
@@ -123,7 +134,9 @@ function setupPipeline(ctx: PipelineContext): void {
   // Use NativeDatabase for schema init when native engine is available (Phase 6.13).
   // better-sqlite3 (ctx.db) is still always opened — needed for queries and stages
   // that haven't been migrated to rusqlite yet.
-  const native = loadNative();
+  // Skip native DB entirely when user explicitly requested --engine wasm.
+  const enginePref = ctx.opts.engine || 'auto';
+  const native = enginePref !== 'wasm' ? loadNative() : null;
   if (native?.NativeDatabase) {
     try {
       ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
@@ -132,11 +145,11 @@ function setupPipeline(ctx: PipelineContext): void {
       // with no cross-library WAL frames (#715, #717).
       ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch (err) {
-      warn(`NativeDatabase setup failed, falling back to JS: ${(err as Error).message}`);
+      warn(`NativeDatabase setup failed, falling back to JS: ${toErrorMessage(err)}`);
       try {
         ctx.nativeDb?.close();
-      } catch {
-        /* ignore close errors */
+      } catch (e) {
+        debug(`setupNativeDb: close failed during fallback: ${toErrorMessage(e)}`);
       }
       ctx.nativeDb = undefined;
     }
@@ -185,6 +198,59 @@ function formatTimingResult(ctx: PipelineContext): BuildResult {
   };
 }
 
+// ── NativeDb lifecycle helpers ──────────────────────────────────────────
+
+/** Checkpoint WAL through rusqlite and close the native connection. */
+function closeNativeDb(ctx: PipelineContext, label: string): void {
+  if (!ctx.nativeDb) return;
+  try {
+    ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+  } catch (e) {
+    debug(`${label} WAL checkpoint failed: ${toErrorMessage(e)}`);
+  }
+  try {
+    ctx.nativeDb.close();
+  } catch (e) {
+    debug(`${label} nativeDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.nativeDb = undefined;
+}
+
+/** Try to reopen the native connection for a given pipeline phase. */
+function reopenNativeDb(ctx: PipelineContext, label: string): void {
+  if ((ctx.opts.engine ?? 'auto') === 'wasm') return;
+  const native = loadNative();
+  if (!native?.NativeDatabase) return;
+  try {
+    ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+  } catch (e) {
+    debug(`reopen nativeDb for ${label} failed: ${toErrorMessage(e)}`);
+    ctx.nativeDb = undefined;
+  }
+}
+
+/** Close nativeDb and clear stale references in engineOpts. */
+function suspendNativeDb(ctx: PipelineContext, label: string): void {
+  closeNativeDb(ctx, label);
+  if (ctx.engineOpts?.nativeDb) {
+    ctx.engineOpts.nativeDb = undefined;
+  }
+}
+
+/**
+ * After native writes, reopen the JS db connection to get a fresh page cache.
+ * Rusqlite WAL truncation invalidates better-sqlite3's internal WAL index,
+ * causing SQLITE_CORRUPT on the next read (#715, #736).
+ */
+function refreshJsDb(ctx: PipelineContext): void {
+  try {
+    ctx.db.close();
+  } catch (e) {
+    debug(`refreshJsDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.db = openDb(ctx.dbPath);
+}
+
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
@@ -195,26 +261,7 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // that use suspendJsDb/resumeJsDb WAL checkpoint pattern (#696).
   const hadNativeDb = !!ctx.nativeDb;
   if (ctx.db && ctx.nativeDb) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    // Separate try/catch blocks ensure close() always runs even if checkpoint throws,
-    // preventing a live rusqlite connection from lingering until GC.
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
-    // Also clear stale reference in engineOpts to prevent stages from
-    // calling methods on the closed NativeDatabase.
-    if (ctx.engineOpts?.nativeDb) {
-      ctx.engineOpts.nativeDb = undefined;
-    }
+    suspendNativeDb(ctx, 'pre-collect');
   }
 
   await collectFiles(ctx);
@@ -228,44 +275,15 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // guard internally (same pattern as feature modules). Closed again before
   // resolveImports/buildEdges which don't yet have the guard (#709).
   if (hadNativeDb && ctx.engineName === 'native') {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-      } catch {
-        ctx.nativeDb = undefined;
-      }
-    }
+    reopenNativeDb(ctx, 'insertNodes');
   }
 
   await insertNodes(ctx);
 
   // Close nativeDb after insertNodes — remaining pipeline stages use JS paths.
   if (ctx.nativeDb && ctx.db) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
-    // Reopen better-sqlite3 connection to get a fresh page cache.
-    // After rusqlite truncates the WAL, better-sqlite3's internal WAL index
-    // (shared-memory mapping) may reference frames that no longer exist,
-    // causing SQLITE_CORRUPT on the next read. Closing and reopening
-    // forces a clean slate — the only reliable cross-library handoff (#715, #736).
-    try {
-      ctx.db.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.db = openDb(ctx.dbPath);
+    closeNativeDb(ctx, 'post-insertNodes');
+    refreshJsDb(ctx);
   }
 
   await resolveImports(ctx);
@@ -275,41 +293,23 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow)
   // which use suspendJsDb/resumeJsDb WAL checkpoint before native writes.
   if (hadNativeDb) {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-        if (ctx.engineOpts) {
-          ctx.engineOpts.nativeDb = ctx.nativeDb;
-        }
-      } catch {
-        ctx.nativeDb = undefined;
-        if (ctx.engineOpts) {
-          ctx.engineOpts.nativeDb = undefined;
-        }
-      }
+    reopenNativeDb(ctx, 'analyses');
+    if (ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = ctx.nativeDb;
+    }
+    if (!ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = undefined;
     }
   }
 
   await runAnalyses(ctx);
 
-  // Close nativeDb after analyses — finalize uses JS paths for setBuildMeta
-  // and closeDbPair handles cleanup. Avoids dual-connection during finalize.
+  // 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) {
-    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
-    // needs to apply WAL frames written by a different SQLite library (#715, #717).
-    // Separate try/catch blocks ensure close() always runs even if checkpoint throws.
-    try {
-      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore checkpoint errors */
-    }
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
+    refreshJsDb(ctx);
   }
 
   await finalize(ctx);
@@ -338,7 +338,31 @@ export async function buildGraph(
     // When available, run the entire build pipeline in Rust with zero
     // napi crossings (eliminates WAL dual-connection dance). Falls back
     // to the JS pipeline on failure or when native is unavailable.
-    const forceJs = process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1';
+    //
+    // Native addon ≤3.8.0 has a path bug: file_symbols keys are absolute
+    // paths but known_files are relative, causing zero import/call edges.
+    // Native addon ≤3.8.1 has an incremental barrel bug: the Rust pipeline
+    // doesn't re-parse barrel files that are imported by changed files,
+    // causing missing barrel import edges and lost analysis data for
+    // reverse-dep files during incremental builds.
+    // Skip the orchestrator for affected versions (fixed in 3.9.0+).
+    const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.8.1') <= 0;
+    const forceJs =
+      process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1' ||
+      ctx.forceFullRebuild ||
+      orchestratorBuggy ||
+      ctx.engineName !== 'native';
+    if (forceJs) {
+      const reason =
+        process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1'
+          ? 'CODEGRAPH_FORCE_JS_PIPELINE=1'
+          : ctx.forceFullRebuild
+            ? 'forceFullRebuild'
+            : orchestratorBuggy
+              ? `buggy addon ${ctx.engineVersion}`
+              : `engine=${ctx.engineName}`;
+      debug(`Skipping native orchestrator: ${reason}`);
+    }
     if (!forceJs && ctx.nativeDb?.buildGraph) {
       try {
         const resultJson = ctx.nativeDb.buildGraph(
@@ -353,21 +377,307 @@ export async function buildGraph(
           nodeCount?: number;
           edgeCount?: number;
           fileCount?: number;
+          changedFiles?: string[];
+          changedCount?: number;
+          removedCount?: number;
+          isFullBuild?: boolean;
         };
 
         if (result.earlyExit) {
+          info('No changes detected');
           closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
           return;
         }
 
+        // Log incremental status to match JS pipeline output
+        const changed = result.changedCount ?? 0;
+        const removed = result.removedCount ?? 0;
+        if (!result.isFullBuild && (changed > 0 || removed > 0)) {
+          info(`Incremental: ${changed} changed, ${removed} removed`);
+        }
+
         // Map Rust timing fields to the JS BuildResult format.
         // Rust handles collect+detect+parse+insert+resolve+edges+structure+roles.
-        // AST/complexity/CFG/dataflow analyses are not yet ported to Rust.
         const p = result.phases;
-        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+
+        // Sync build_meta so JS-side version/engine checks work on next build.
+        // Note: the Rust orchestrator also writes codegraph_version (using
+        // CARGO_PKG_VERSION). We intentionally overwrite it here with the npm
+        // package version so that the JS-side "version changed → full rebuild"
+        // detection (line ~97) compares against the authoritative JS version.
+        // The two versions are kept in lockstep by the release process.
+        setBuildMeta(ctx.db, {
+          engine: ctx.engineName,
+          engine_version: ctx.engineVersion || '',
+          codegraph_version: CODEGRAPH_VERSION,
+          schema_version: String(ctx.schemaVersion),
+          built_at: new Date().toISOString(),
+          node_count: String(result.nodeCount ?? 0),
+          edge_count: String(result.edgeCount ?? 0),
+        });
+
         info(
           `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
         );
+
+        // ── Run structure + analysis phases after native orchestrator ──
+        // Structure (directory nodes, contains edges, metrics) is not fully
+        // ported to Rust — the native pipeline only handles the small
+        // incremental fast path (≤5 changed files). For full builds and
+        // larger incremental builds, run JS buildStructure() to fill the gap.
+        // Analysis phases (AST, complexity, CFG, dataflow) are also not yet
+        // ported; run via JS engine after reconstructing fileSymbols from DB.
+        let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+        let structurePatchMs = 0;
+        const needsAnalysis =
+          opts.ast !== false ||
+          opts.complexity !== false ||
+          opts.cfg !== false ||
+          opts.dataflow !== false;
+
+        // The native fast path only runs structure for small incremental
+        // builds: !isFullBuild && changedCount <= 5 && existingFileCount > 20.
+        // For all other cases (full builds, large incrementals), we must
+        // run JS buildStructure() to create directory nodes + contains edges (#804).
+        // Always run JS structure — the native fast-path has an additional
+        // existingFileCount > 20 guard that isn't reflected in the result JSON,
+        // so we can't reliably detect whether native actually ran structure.
+        const nativeHandledStructure = false;
+        const needsStructure = !nativeHandledStructure;
+
+        if (needsAnalysis || needsStructure) {
+          // WAL handoff: checkpoint through rusqlite, close nativeDb,
+          // reopen better-sqlite3 with a fresh page cache (#715, #736).
+          try {
+            ctx.nativeDb!.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch {
+            /* ignore checkpoint errors */
+          }
+          try {
+            ctx.nativeDb!.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.nativeDb = undefined;
+          try {
+            ctx.db.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.db = null!; // avoid closeDbPair operating on a stale handle
+          try {
+            ctx.db = openDb(ctx.dbPath);
+          } catch (reopenErr) {
+            warn(`Failed to reopen DB after native build: ${(reopenErr as Error).message}`);
+            // Native build succeeded but we can't run post-processing — return partial result
+            return {
+              phases: {
+                setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+                parseMs: +(p.parseMs ?? 0).toFixed(1),
+                insertMs: +(p.insertMs ?? 0).toFixed(1),
+                resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+                edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+                structureMs: +(p.structureMs ?? 0).toFixed(1),
+                rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+                astMs: 0,
+                complexityMs: 0,
+                cfgMs: 0,
+                dataflowMs: 0,
+                finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+              },
+            };
+          }
+
+          // Reconstruct fileSymbols from DB. For structure we need ALL files
+          // (to build complete directory tree); for analysis we scope to
+          // changed files only. Load all files, then scope analysis later.
+          const allFileRows = ctx.db
+            .prepare(
+              'SELECT file, name, kind, line, end_line as endLine FROM nodes WHERE file IS NOT NULL ORDER BY file, line',
+            )
+            .all() as {
+            file: string;
+            name: string;
+            kind: string;
+            line: number;
+            endLine: number | null;
+          }[];
+
+          const allFileSymbols = new Map<string, ExtractorOutput>();
+          for (const row of allFileRows) {
+            let entry = allFileSymbols.get(row.file);
+            if (!entry) {
+              entry = {
+                definitions: [],
+                calls: [],
+                imports: [],
+                classes: [],
+                exports: [],
+                typeMap: new Map(),
+              };
+              allFileSymbols.set(row.file, entry);
+            }
+            entry.definitions.push({
+              name: row.name,
+              kind: row.kind as Definition['kind'],
+              line: row.line,
+              endLine: row.endLine ?? undefined,
+            });
+          }
+
+          // Populate import/export counts from DB edges so buildStructure
+          // computes correct import_count/export_count in node_metrics.
+          // The extractor arrays aren't persisted to the DB, so we derive
+          // counts from edge data instead (#804).
+          const importCountRows = ctx.db
+            .prepare(
+              `SELECT n.file, COUNT(*) AS cnt
+               FROM edges e JOIN nodes n ON e.source_id = n.id
+               WHERE e.kind IN ('imports', 'imports-type', 'dynamic-imports')
+                 AND n.file IS NOT NULL
+               GROUP BY n.file`,
+            )
+            .all() as { file: string; cnt: number }[];
+          for (const row of importCountRows) {
+            const entry = allFileSymbols.get(row.file);
+            if (entry) entry.imports = new Array(row.cnt) as ExtractorOutput['imports'];
+          }
+          // Export count: definitions in this file that are imported by other files
+          const exportCountRows = ctx.db
+            .prepare(
+              `SELECT n_tgt.file, COUNT(DISTINCT n_tgt.id) AS cnt
+               FROM edges e
+               JOIN nodes n_tgt ON e.target_id = n_tgt.id
+               JOIN nodes n_src ON e.source_id = n_src.id
+               WHERE e.kind IN ('imports', 'imports-type', 'reexports')
+                 AND n_tgt.file IS NOT NULL
+                 AND n_src.file != n_tgt.file
+               GROUP BY n_tgt.file`,
+            )
+            .all() as { file: string; cnt: number }[];
+          for (const row of exportCountRows) {
+            const entry = allFileSymbols.get(row.file);
+            if (entry) entry.exports = new Array(row.cnt) as ExtractorOutput['exports'];
+          }
+
+          // ── Structure phase: directory nodes + contains edges (#804) ──
+          if (needsStructure) {
+            const structureStart = performance.now();
+            try {
+              // Derive directories from file paths
+              const directories = new Set<string>();
+              for (const relPath of allFileSymbols.keys()) {
+                const parts = relPath.split('/');
+                for (let i = 1; i < parts.length; i++) {
+                  directories.add(parts.slice(0, i).join('/'));
+                }
+              }
+
+              // Build line count map from DB metrics or file content
+              const lineCountMap = new Map<string, number>();
+              const cachedLineCounts = ctx.db
+                .prepare(
+                  `SELECT n.name AS file, m.line_count
+                 FROM node_metrics m JOIN nodes n ON m.node_id = n.id
+                 WHERE n.kind = 'file'`,
+                )
+                .all() as Array<{ file: string; line_count: number }>;
+              for (const row of cachedLineCounts) {
+                lineCountMap.set(row.file, row.line_count);
+              }
+
+              // Native ran no structure at all — always do a full rebuild so
+              // every directory gets nodes + contains edges (#804).
+              const changedFilePaths = null;
+
+              const { buildStructure: buildStructureFn } = (await import(
+                '../../../features/structure.js'
+              )) as {
+                buildStructure: (
+                  db: typeof ctx.db,
+                  fileSymbols: Map<string, ExtractorOutput>,
+                  rootDir: string,
+                  lineCountMap: Map<string, number>,
+                  directories: Set<string>,
+                  changedFiles: string[] | null,
+                ) => void;
+              };
+              buildStructureFn(
+                ctx.db,
+                allFileSymbols,
+                ctx.rootDir,
+                lineCountMap,
+                directories,
+                changedFilePaths,
+              );
+              debug('Structure phase completed after native orchestrator');
+            } catch (err) {
+              warn(`Structure phase failed after native build: ${toErrorMessage(err)}`);
+            }
+            structurePatchMs = performance.now() - structureStart;
+          }
+
+          // ── Analysis phase ──
+          if (needsAnalysis) {
+            // Scope analysis fileSymbols to changed files only
+            const changedFiles = result.changedFiles;
+            let analysisFileSymbols: Map<string, ExtractorOutput>;
+            if (changedFiles && changedFiles.length > 0) {
+              analysisFileSymbols = new Map();
+              for (const f of changedFiles) {
+                const entry = allFileSymbols.get(f);
+                if (entry) analysisFileSymbols.set(f, entry);
+              }
+            } else {
+              analysisFileSymbols = allFileSymbols;
+            }
+
+            // Reopen nativeDb for analysis features (suspend/resume WAL pattern).
+            const native = loadNative();
+            if (native?.NativeDatabase) {
+              try {
+                ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+                if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
+              } catch {
+                ctx.nativeDb = undefined;
+                if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+              }
+            }
+
+            try {
+              const { runAnalyses: runAnalysesFn } = await import(
+                '../../../ast-analysis/engine.js'
+              );
+              analysisTiming = await runAnalysesFn(
+                ctx.db,
+                analysisFileSymbols,
+                ctx.rootDir,
+                opts,
+                ctx.engineOpts,
+              );
+            } catch (err) {
+              warn(`Analysis phases failed after native build: ${toErrorMessage(err)}`);
+            }
+
+            // Close nativeDb after analyses
+            if (ctx.nativeDb) {
+              try {
+                ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+              } catch {
+                /* ignore checkpoint errors */
+              }
+              try {
+                ctx.nativeDb.close();
+              } catch {
+                /* ignore close errors */
+              }
+              ctx.nativeDb = undefined;
+              if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+            }
+          }
+        }
+
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
         return {
           phases: {
             setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
@@ -375,18 +685,18 @@ export async function buildGraph(
             insertMs: +(p.insertMs ?? 0).toFixed(1),
             resolveMs: +(p.resolveMs ?? 0).toFixed(1),
             edgesMs: +(p.edgesMs ?? 0).toFixed(1),
-            structureMs: +(p.structureMs ?? 0).toFixed(1),
+            structureMs: +((p.structureMs ?? 0) + structurePatchMs).toFixed(1),
             rolesMs: +(p.rolesMs ?? 0).toFixed(1),
-            astMs: 0,
-            complexityMs: 0,
-            cfgMs: 0,
-            dataflowMs: 0,
+            astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
+            complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
+            cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
+            dataflowMs: +(analysisTiming.dataflowMs ?? 0).toFixed(1),
             finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
           },
         };
       } catch (err) {
         warn(
-          `Native build orchestrator failed, falling back to JS pipeline: ${(err as Error).message}`,
+          `Native build orchestrator failed, falling back to JS pipeline: ${toErrorMessage(err)}`,
         );
         // Fall through to JS pipeline
       }