fix(native): add post-pass phase timings to result.phases

Times each JS post-pass in tryNativeOrchestrator and exposes the
measurements in BuildResult.phases:

- gapDetectMs  — dropped-language gap detection + backfill
- chaMs        — CHA expansion (interface dispatch)
- thisDispatchMs — this/super dispatch WASM re-parse (was already
                   tracked but now properly named alongside the rest)
- reclassifyMs — scoped role re-classification after edge insertion
- techniqueBackfillMs — technique-column UPDATE on native-written edges

Previously only thisDispatchMs was reported, causing wall-clock vs
phaseSum to diverge by 1.1s+ on 1-file rebuilds and making benchmark
regressions undiagnosable from committed history.

Updates update-incremental-report.ts to render the new phases in a
collapsible details block under each engine's 1-file rebuild section.

Closes #1434

Author: carlos-alm

scripts/update-incremental-report.ts

@@ -161,6 +161,55 @@ for (const engineKey of ['native', 'wasm']) {
 	md += `| Full build | ${formatMs(e.fullBuildMs)} |\n`;
 	md += `| No-op rebuild | ${e.noopRebuildMs != null ? formatMs(e.noopRebuildMs) : 'n/a'} |\n`;
 	md += `| 1-file rebuild | ${e.oneFileRebuildMs != null ? formatMs(e.oneFileRebuildMs) : 'n/a'} |\n\n`;
+
+	// 1-file rebuild phase breakdown — skipped when phases are unavailable (older
+	// benchmark entries that predate per-phase tracking, or failed runs).
+	const ph = e.oneFilePhases;
+	if (ph && typeof ph === 'object') {
+		md += `<details><summary>1-file rebuild phase breakdown (${engineKey})</summary>\n\n`;
+		md += '| Phase | Time |\n';
+		md += '|-------|-----:|\n';
+		// Core Rust pipeline phases (present for both engines)
+		const corePhases = [
+			['setup', 'setupMs'],
+			['collect', 'collectMs'],
+			['detect', 'detectMs'],
+			['parse', 'parseMs'],
+			['insert', 'insertMs'],
+			['resolve', 'resolveMs'],
+			['edges', 'edgesMs'],
+			['structure', 'structureMs'],
+			['roles', 'rolesMs'],
+		];
+		for (const [label, key] of corePhases) {
+			if (ph[key] != null) md += `| ${label} | ${formatMs(ph[key])} |\n`;
+		}
+		// Native-only JS post-pass phases (only present when engine=native)
+		if (engineKey === 'native') {
+			const nativePostPhases = [
+				['gap detect + backfill', 'gapDetectMs'],
+				['CHA expansion', 'chaMs'],
+				['this/super dispatch', 'thisDispatchMs'],
+				['role reclassify', 'reclassifyMs'],
+				['technique backfill', 'techniqueBackfillMs'],
+			];
+			for (const [label, key] of nativePostPhases) {
+				if (ph[key] != null) md += `| ${label} | ${formatMs(ph[key])} |\n`;
+			}
+		}
+		// Analysis phases (present for both engines)
+		const analysisPhases = [
+			['ast', 'astMs'],
+			['complexity', 'complexityMs'],
+			['cfg', 'cfgMs'],
+			['dataflow', 'dataflowMs'],
+			['finalize', 'finalizeMs'],
+		];
+		for (const [label, key] of analysisPhases) {
+			if (ph[key] != null) md += `| ${label} | ${formatMs(ph[key])} |\n`;
+		}
+		md += '\n</details>\n\n';
+	}
 }
 
 const r = latest.resolve;

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -577,7 +577,11 @@ function runPostNativeCha(
            AND INSTR(tgt.name, '.') > 0
            AND src.file IN (${ph})`,
         )
-        .all(...chunk) as Array<{ source_id: number; method_name: string; caller_file: string | null }>;
+        .all(...chunk) as Array<{
+        source_id: number;
+        method_name: string;
+        caller_file: string | null;
+      }>;
       rows.push(...chunkRows);
     }
     callToMethods = rows;
@@ -933,12 +937,20 @@ async function runPostNativeThisDispatch(
   return { elapsedMs: Date.now() - t0, targetIds, affectedFiles };
 }
 
+interface PostPassTimings {
+  gapDetectMs: number;
+  chaMs: number;
+  thisDispatchMs: number;
+  reclassifyMs: number;
+  techniqueBackfillMs: number;
+}
+
 /** Format timing result from native orchestrator phases + JS post-processing. */
 function formatNativeTimingResult(
   p: Record<string, number>,
   structurePatchMs: number,
   analysisTiming: { astMs: number; complexityMs: number; cfgMs: number; dataflowMs: number },
-  thisDispatchMs: number,
+  postPass: PostPassTimings,
 ): BuildResult {
   return {
     phases: {
@@ -951,7 +963,11 @@ function formatNativeTimingResult(
       edgesMs: +(p.edgesMs ?? 0).toFixed(1),
       structureMs: +((p.structureMs ?? 0) + structurePatchMs).toFixed(1),
       rolesMs: +(p.rolesMs ?? 0).toFixed(1),
-      thisDispatchMs: +thisDispatchMs.toFixed(1),
+      gapDetectMs: +postPass.gapDetectMs.toFixed(1),
+      chaMs: +postPass.chaMs.toFixed(1),
+      thisDispatchMs: +postPass.thisDispatchMs.toFixed(1),
+      reclassifyMs: +postPass.reclassifyMs.toFixed(1),
+      techniqueBackfillMs: +postPass.techniqueBackfillMs.toFixed(1),
       astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
       complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
       cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
@@ -1490,8 +1506,14 @@ export async function tryNativeOrchestrator(
       ctx.db = openDb(ctx.dbPath);
       ctx.nativeFirstProxy = false;
     } else if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
-      // DB reopen failed — return partial result
-      return formatNativeTimingResult(p, 0, analysisTiming, 0);
+      // DB reopen failed — return partial result (no post-pass phases completed)
+      return formatNativeTimingResult(p, 0, analysisTiming, {
+        gapDetectMs: 0,
+        chaMs: 0,
+        thisDispatchMs: 0,
+        reclassifyMs: 0,
+        techniqueBackfillMs: 0,
+      });
     }
   }
 
@@ -1513,6 +1535,7 @@ export async function tryNativeOrchestrator(
   // gated below.
   const removedCount = result.removedCount ?? 0;
   const changedCount = result.changedCount ?? 0;
+  const gapDetectStart = performance.now();
   const gap = detectDroppedLanguageGap(ctx);
   if (
     result.isFullBuild ||
@@ -1523,6 +1546,7 @@ export async function tryNativeOrchestrator(
   ) {
     await backfillNativeDroppedFiles(ctx, gap);
   }
+  const gapDetectMs = performance.now() - gapDetectStart;
 
   // Phase 8.5: expand CHA call edges (interface dispatch → concrete implementations).
   // Returns the affected files so role re-classification below can be scoped to
@@ -1531,11 +1555,13 @@ export async function tryNativeOrchestrator(
   // Function-as-object-property methods (`fn.method = function() {}`) are extracted
   // natively by the Rust engine (#1432) and resolved in-build by its edge builder, so
   // no WASM re-parse post-pass is needed for them. `Foo.prototype.bar = fn` likewise.
+  const chaStart = performance.now();
   const { newEdgeCount: chaEdgeCount, affectedFiles: chaAffectedFiles } = runPostNativeCha(
     ctx.db as unknown as BetterSqlite3Database,
     // null = full build (scan all call→method edges); array = incremental (gate queries decide scope)
     result.isFullBuild ? null : (result.changedFiles ?? null),
   );
+  const chaMs = performance.now() - chaStart;
 
   // Phase 8.5: this/super dispatch — hybrid WASM re-parse to resolve call sites
   // whose raw receiver info the Rust pipeline does not persist to DB.
@@ -1558,6 +1584,7 @@ export async function tryNativeOrchestrator(
   // files restores correctness without re-running the classifier over the
   // whole graph (which cost ~130ms per build on codegraph itself and was a
   // major part of the v3.12.0 native full-build benchmark regression).
+  let reclassifyMs = 0;
   if (chaEdgeCount > 0 || thisDispatchTargetIds.size > 0) {
     const affectedFiles = [...new Set([...chaAffectedFiles, ...thisDispatchAffectedFiles])];
     // When edges were inserted but all their endpoint nodes have null `file`
@@ -1566,6 +1593,7 @@ export async function tryNativeOrchestrator(
     // case — scoped classification with an empty set would be a no-op, leaving
     // roles stale for those nodes.
     const scopedFiles = affectedFiles.length > 0 ? affectedFiles : null;
+    const reclassifyStart = performance.now();
     try {
       const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
         classifyNodeRoles: (
@@ -1582,13 +1610,16 @@ export async function tryNativeOrchestrator(
     } catch (err) {
       debug(`Post-pass role re-classification failed: ${toErrorMessage(err)}`);
     }
+    reclassifyMs = performance.now() - reclassifyStart;
   }
 
   // Backfill the `technique` column on `calls` edges written by the Rust
   // orchestrator, which does not write the column. Runs after all edge-writing
   // phases (including the WASM dropped-language backfill, CHA post-pass, and
   // this/super dispatch) so every new edge in this build cycle gets a label.
+  const techniqueBackfillStart = performance.now();
   backfillEdgeTechniquesAfterNativeOrchestrator(ctx.db, !!result.isFullBuild, result.changedFiles);
+  const techniqueBackfillMs = performance.now() - techniqueBackfillStart;
 
   // Re-count nodes/edges now that all edge-writing post-passes have run: the
   // Rust orchestrator captured its counts before the JS post-passes added
@@ -1633,5 +1664,11 @@ export async function tryNativeOrchestrator(
   }
 
   closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
-  return formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispatchMs);
+  return formatNativeTimingResult(p, structurePatchMs, analysisTiming, {
+    gapDetectMs,
+    chaMs,
+    thisDispatchMs,
+    reclassifyMs,
+    techniqueBackfillMs,
+  });
 }

src/types.ts

@@ -1268,8 +1268,18 @@ export interface BuildResult {
     edgesMs: number;
     structureMs: number;
     rolesMs: number;
+    /** Wall-clock time for the prototype-method post-pass (native path only). */
+    protoMethodsMs?: number;
+    /** Wall-clock time for the CHA expansion post-pass (native path only). */
+    chaMs?: number;
     /** Wall-clock time for the this/super dispatch WASM post-pass (native path only). */
     thisDispatchMs?: number;
+    /** Wall-clock time for the dropped-language gap detection + backfill (native path only). */
+    gapDetectMs?: number;
+    /** Wall-clock time for role re-classification after JS edge-writing post-passes (native path only). */
+    reclassifyMs?: number;
+    /** Wall-clock time for the technique-column backfill on native-written edges (native path only). */
+    techniqueBackfillMs?: number;
     astMs: number;
     complexityMs: number;
     cfgMs: number;