@optave/codegraph 3.12.0 → 3.13.0

package/dist/domain/graph/builder/stages/native-orchestrator.js

@@ -23,9 +23,8 @@ import { CODEGRAPH_VERSION } from '../../../../shared/version.js';
 import { classifyNativeDrops, formatDropExtensionSummary, getInstalledWasmExtensions, NATIVE_SUPPORTED_EXTENSIONS, parseFilesWasmForBackfill, } from '../../../parser.js';
 import { computeConfidence } from '../../resolve.js';
 import { resolveThisDispatch } from '../cha.js';
-import { batchInsertEdges, batchInsertNodes, collectFiles as collectFilesUtil, fileHash, fileStat, readFileSafe, } from '../helpers.js';
+import { batchInsertEdges, batchInsertNodes, CHA_DISPATCH_PENALTY, CHA_TYPED_DISPATCH_CONFIDENCE, collectFiles as collectFilesUtil, fileHash, fileStat, readFileSafe, } from '../helpers.js';
 import { NativeDbProxy } from '../native-db-proxy.js';
-import { CHA_DISPATCH_PENALTY } from './build-edges.js';
 import { closeNativeDb } from './native-db-lifecycle.js';
 // ── Native orchestrator helpers ───────────────────────────────────────
 /** Determine whether the native orchestrator should be skipped. Returns a reason string, or null if it should run. */
@@ -246,7 +245,7 @@ async function runPostNativeAnalysis(ctx, allFileSymbols, changedFiles) {
     return timing;
 }
 /**
- * Phase 8.5: CHA expansion post-pass for the native orchestrator path.
+ * Phase 8.6: CHA expansion post-pass for the native orchestrator path.
  *
  * The Rust build pipeline resolves typed receiver calls (e.g. `worker.doWork()`
  * where `worker: IWorker`) to the interface method declaration only.  This
@@ -258,12 +257,25 @@ async function runPostNativeAnalysis(ctx, allFileSymbols, changedFiles) {
  * Note: `this`/`super` dispatch is handled separately by `runPostNativeThisDispatch`,
  * which WASM-re-parses JS/TS files to obtain raw call site receiver info.
  *
+ * `changedFiles` controls candidate scoping on incremental builds:
+ *   - null  → full build; scan all call→method edges (existing behaviour).
+ *   - array → incremental; two cheap gate queries decide scope:
+ *       Gate A: any class/interface/trait/struct/record nodes in changed files?
+ *               If yes, a new implementor may have appeared — full scan required.
+ *       Gate B: any `calls` edges from changed-file sources targeting
+ *               class/constructor/function-kind nodes? If yes, the RTA set may
+ *               have grown (also covers the older-schema fallback where
+ *               constructor calls target `constructor`/`function` nodes instead
+ *               of `class` nodes) — full scan required.
+ *       If neither gate fires: scope `callToMethods` to `src.file IN changedFiles`
+ *       (safe because no hierarchy or RTA evidence changed).
+ *
  * Returns the count of newly inserted CHA edges plus the set of files containing
  * the new edges' endpoints, so the caller can scope role re-classification to the
  * nodes whose fan-in/out actually changed. A zero count means no edges were added
  * and role re-classification is unnecessary.
  */
-function runPostNativeCha(db) {
+function runPostNativeCha(db, changedFiles) {
     const affectedFiles = new Set();
     const empty = { newEdgeCount: 0, affectedFiles };
     // Fast guard: no hierarchy edges → no CHA work
@@ -327,19 +339,113 @@ function runPostNativeCha(db) {
     if (noRtaEvidence) {
         debug('runPostNativeCha: no constructor-call evidence found — proceeding without RTA filter');
     }
+    // ── Incremental candidate scoping ──────────────────────────────────────────
+    // On incremental builds, two gate queries decide whether to restrict the
+    // candidate scan to changed-file call sites or run the full graph scan.
+    //
+    // Gate A: did a changed file add/change a class hierarchy node?
+    //   A new `extends`/`implements` edge means a previously-untracked implementor
+    //   is now in the hierarchy — unchanged call sites in OTHER files may gain new
+    //   valid expansions, so the full scan is required.
+    //   Note: *removed* class nodes are safe — Rust's `purge_changed_files` runs
+    //   before this post-pass and deletes stale nodes and their hierarchy edges, so
+    //   Gate A queries the post-purge DB. A deleted class returns no row here, which
+    //   is correct: its stale CHA edges were already cleaned up by the Rust purge.
+    //
+    // Gate B: did a changed file add new RTA evidence (`new ConcreteX()`)?
+    //   A new `calls` edge to a class/constructor/function-kind target means the
+    //   instantiated set grew — previously RTA-filtered expansions in unchanged
+    //   caller files become admissible, so the full scan is required.
+    //   (`constructor`/`function` cover the older native engine fallback schema.)
+    //
+    // If neither gate fires, the hierarchy and RTA set are unchanged for all files
+    // outside changedFiles, so restricting to changed-file sources is safe.
+    let scopeToChangedFiles = false; // true → add WHERE src.file IN changedFiles
+    if (changedFiles !== null && changedFiles.length > 0) {
+        // Gate A: class/interface/trait/struct/record nodes in changed files?
+        const CHUNK_SIZE = 500;
+        let gateAFired = false;
+        for (let i = 0; i < changedFiles.length && !gateAFired; i += CHUNK_SIZE) {
+            const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+            const ph = chunk.map(() => '?').join(',');
+            const row = db
+                .prepare(`SELECT 1 FROM nodes
+           WHERE file IN (${ph})
+           AND kind IN ('class', 'interface', 'trait', 'struct', 'record')
+           LIMIT 1`)
+                .get(...chunk);
+            if (row)
+                gateAFired = true;
+        }
+        // Gate B: calls from changed-file sources to class/instantiable-kind targets
+        // (also covers older-schema fallback and future CHA extensions to struct/record).
+        // Includes class/interface/trait/struct/record (future CHA extension safety) and
+        // constructor/function (older native engine schema fallback).
+        let gateBFired = false;
+        if (!gateAFired) {
+            for (let i = 0; i < changedFiles.length && !gateBFired; i += CHUNK_SIZE) {
+                const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+                const ph = chunk.map(() => '?').join(',');
+                const row = db
+                    .prepare(`SELECT 1 FROM edges e
+             JOIN nodes src ON e.source_id = src.id
+             JOIN nodes tgt ON e.target_id = tgt.id
+             WHERE e.kind = 'calls'
+             AND tgt.kind IN ('class', 'interface', 'trait', 'struct', 'record', 'constructor', 'function')
+             AND src.file IN (${ph})
+             LIMIT 1`)
+                    .get(...chunk);
+                if (row)
+                    gateBFired = true;
+            }
+        }
+        if (!gateAFired && !gateBFired) {
+            scopeToChangedFiles = true;
+            debug(`runPostNativeCha: neither gate fired — scoping candidate scan to ${changedFiles.length} changed file(s)`);
+        }
+        else {
+            debug(`runPostNativeCha: ${gateAFired ? 'Gate A (hierarchy)' : 'Gate B (RTA)'} fired — running full scan`);
+        }
+    }
     // Find existing call edges targeting qualified methods (e.g., 'IWorker.doWork').
-    // Include the caller node's file so confidence can be computed file-pair-aware,
-    // matching the WASM path's computeConfidence(callerFile, targetFile, null) - CHA_DISPATCH_PENALTY formula.
-    const callToMethods = db
-        .prepare(`
-      SELECT e.source_id, tgt.name AS method_name, src.file AS caller_file
-      FROM edges e
-      JOIN nodes tgt ON e.target_id = tgt.id
-      JOIN nodes src ON e.source_id = src.id
-      WHERE e.kind = 'calls' AND tgt.kind = 'method'
-      AND INSTR(tgt.name, '.') > 0
-    `)
-        .all();
+    // Include caller_file and method_file so affectedFiles can be populated for
+    // incremental role reclassification; confidence uses CHA_TYPED_DISPATCH_CONFIDENCE matching runChaPostPass.
+    // When scopeToChangedFiles is true, restrict to call sites in the changed files
+    // (safe because no hierarchy or RTA evidence changed outside those files).
+    let callToMethods;
+    if (scopeToChangedFiles && changedFiles && changedFiles.length > 0) {
+        const CHUNK_SIZE = 500;
+        const rows = [];
+        for (let i = 0; i < changedFiles.length; i += CHUNK_SIZE) {
+            const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+            const ph = chunk.map(() => '?').join(',');
+            const chunkRows = db
+                .prepare(`SELECT e.source_id, src.name AS caller_name, tgt.name AS method_name, src.file AS caller_file
+           FROM edges e
+           JOIN nodes tgt ON e.target_id = tgt.id
+           JOIN nodes src ON e.source_id = src.id
+           WHERE e.kind = 'calls' AND tgt.kind = 'method'
+           AND INSTR(tgt.name, '.') > 0
+           AND (e.technique IS NULL OR e.technique != 'cha-expanded')
+           AND src.file IN (${ph})`)
+                .all(...chunk);
+            rows.push(...chunkRows);
+        }
+        callToMethods = rows;
+    }
+    else {
+        callToMethods = db
+            .prepare(`
+        SELECT e.source_id, src.name AS caller_name, tgt.name AS method_name, src.file AS caller_file
+        FROM edges e
+        JOIN nodes tgt ON e.target_id = tgt.id
+        JOIN nodes src ON e.source_id = src.id
+        WHERE e.kind = 'calls' AND tgt.kind = 'method'
+        AND INSTR(tgt.name, '.') > 0
+        AND (e.technique IS NULL OR e.technique != 'cha-expanded')
+      `)
+            .all();
+    }
     // Seed seen-pairs only from the source_ids we'll be expanding — avoids loading every
     // call edge in the DB (which would be O(all edges)) for large codebases.
     const seen = new Set();
@@ -384,17 +490,14 @@ function runPostNativeCha(db) {
                     const qualifiedName = `${cls}.${methodSuffix}`;
                     const methodNodes = findMethodStmt.all(qualifiedName);
                     for (const methodNode of methodNodes) {
+                        if (methodNode.id === source_id)
+                            continue; // skip self-loops
                         const key = `${source_id}|${methodNode.id}`;
                         if (seen.has(key))
                             continue;
                         seen.add(key);
-                        // Compute confidence file-pair-aware (mirrors WASM path: computeConfidence - CHA_DISPATCH_PENALTY)
-                        // Skip zero-confidence edges to match buildFileCallEdges / buildChaPostPass behaviour.
-                        const conf = computeConfidence(caller_file ?? '', methodNode.method_file ?? '', null) -
-                            CHA_DISPATCH_PENALTY;
-                        if (conf <= 0)
-                            continue;
-                        newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha']);
+                        const conf = CHA_TYPED_DISPATCH_CONFIDENCE;
+                        newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha-expanded']);
                         newEdgeCount++;
                         if (caller_file)
                             affectedFiles.add(caller_file);
@@ -409,6 +512,9 @@ function runPostNativeCha(db) {
     }
     if (newEdges.length > 0) {
         db.transaction(() => batchInsertEdges(db, newEdges))();
+        // Account for post-pass edges excluded from the build summary line (#1452),
+        // mirroring the this/super dispatch post-pass insertion log.
+        debug(`CHA expansion post-pass: inserted ${newEdgeCount} edge(s)`);
     }
     return { newEdgeCount, affectedFiles };
 }
@@ -423,36 +529,52 @@ const THIS_DISPATCH_EXTS = new Set(['.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs'
  * `this`/`super` receivers, then resolves them through the class hierarchy stored
  * in DB `extends` edges — mirroring what `buildChaPostPass` does on the WASM path.
  *
- * Only runs when `extends` edges exist in the DB; if there is no inheritance
- * hierarchy there is nothing to resolve via `this`/`super` dispatch.
+ * Also handles function-as-object-property methods (`f.h = function() { this.g() }`):
+ * these use `this` to reference sibling properties on the same object (`f`), so
+ * `resolveThisDispatch` resolves them by treating the dot-prefix of the caller name
+ * (`f` from `f.h`) as the class and looking up `f.g` directly — no `extends` edge needed.
+ *
+ * Runs when either `extends` edges exist (class inheritance) OR dot-named `method`
+ * nodes exist (func-prop assignments); skips only when neither is present.
  */
 async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild) {
-    const t0 = Date.now();
+    const t0 = performance.now();
     const targetIds = new Set();
     // Files containing endpoints of newly inserted edges — lets the caller scope
     // role re-classification to the nodes whose fan-in/out actually changed.
     const affectedFiles = new Set();
-    // Fast guard: need at least one extends edge for this/super to have meaning
+    // Fast guard: need at least one extends edge (class inheritance) OR a dot-named
+    // method node (func-prop assignment: `f.h = function() { this.g() }`) for
+    // this/super dispatch to produce any edges.
     const hasExtends = db.prepare(`SELECT 1 FROM edges WHERE kind = 'extends' LIMIT 1`).get();
-    if (!hasExtends)
+    const hasFuncPropMethod = db
+        .prepare(`SELECT 1 FROM nodes WHERE kind = 'method' AND INSTR(name, '.') > 0 LIMIT 1`)
+        .get();
+    if (!hasExtends && !hasFuncPropMethod)
         return { elapsedMs: 0, targetIds, affectedFiles };
-    // Build parents map: child class → direct parent class (from `extends` edges)
-    const parentRows = db
-        .prepare(`
-      SELECT src.name AS child_name, tgt.name AS parent_name
-      FROM edges e
-      JOIN nodes src ON e.source_id = src.id
-      JOIN nodes tgt ON e.target_id = tgt.id
-      WHERE e.kind = 'extends'
-    `)
-        .all();
+    // Build parents map: child class → direct parent class (from `extends` edges).
+    // May be empty when only func-prop methods exist (no class inheritance) —
+    // resolveThisDispatch handles that case via direct class-prefix lookup.
+    const parentRows = hasExtends
+        ? db
+            .prepare(`
+          SELECT src.name AS child_name, tgt.name AS parent_name
+          FROM edges e
+          JOIN nodes src ON e.source_id = src.id
+          JOIN nodes tgt ON e.target_id = tgt.id
+          WHERE e.kind = 'extends'
+        `)
+            .all()
+        : [];
     const parents = new Map();
     for (const row of parentRows) {
         if (!parents.has(row.child_name))
             parents.set(row.child_name, row.parent_name);
     }
-    if (parents.size === 0)
-        return { elapsedMs: 0, targetIds, affectedFiles };
+    // Note: parents may be empty when hasFuncPropMethod but !hasExtends — that is
+    // intentional. resolveThisDispatch still resolves `this.g()` inside `f.h` by
+    // treating `f` (the dot-prefix of callerName `f.h`) as the class and looking
+    // up `f.g` directly via lookup.byName(), without traversing the parents chain.
     const chaCtx = {
         implementors: new Map(), // not needed for this/super resolution
         parents,
@@ -463,13 +585,11 @@ async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild)
     // On a full build we do NOT re-parse every JS/TS file — that would WASM-parse
     // the entire project on top of the native pass, causing a massive regression
     // (measured: +358% ms/file on codegraph itself). Instead we restrict to files
-    // that are part of the class inheritance hierarchy: both subclass files (which
-    // contain `super.X()` calls dispatching to a parent) and parent-class files
-    // (whose method bodies contain `this.X()` calls that CHA must resolve). Any
-    // file not in the hierarchy has no `extends` relationship, so `this`/`super`
-    // calls in it either resolve locally (same-class dispatch, already handled by
-    // the direct-call edge) or have no class context — and will be skipped by
-    // `resolveThisDispatch` anyway.
+    // that are part of the class inheritance hierarchy (both subclass files with
+    // `super.X()` calls and parent-class files with `this.X()` calls) OR that
+    // contain dot-named method nodes (func-prop assignments whose bodies may call
+    // `this.sibling()`). Any file not in either set has no class or object context
+    // where `this`/`super` dispatch would produce new edges.
     let relFiles;
     if (isFullBuild || !changedFiles) {
         const rows = db
@@ -484,6 +604,21 @@ async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild)
           FROM edges e
           JOIN nodes tgt ON e.target_id = tgt.id
           WHERE e.kind = 'extends' AND tgt.file IS NOT NULL
+          UNION
+          -- Files with func-prop method definitions (e.g. f.h = function(){this.g()}).
+          -- Only include files where the method's owner prefix is NOT a known class name —
+          -- this keeps the re-parse set small (func-prop files only, not all class-method files).
+          -- AND name IS NOT NULL guards the NOT IN sub-select: if any class node had a NULL
+          -- name the entire NOT IN clause would silently return no rows (SQL NULL semantics).
+          SELECT n.file AS file
+          FROM nodes n
+          WHERE n.kind = 'method'
+          AND INSTR(n.name, '.') > 0
+          AND n.file IS NOT NULL
+          AND SUBSTR(n.name, 1, INSTR(n.name, '.') - 1) NOT IN (
+            SELECT name FROM nodes WHERE kind IN ('class', 'struct', 'interface', 'type')
+            AND name IS NOT NULL
+          )
         )
       `)
             .all();
@@ -603,8 +738,10 @@ async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild)
             const callerRow = findCallerByLineStmt.get(relPath, call.line, call.line);
             if (!callerRow)
                 continue;
-            const targets = resolveThisDispatch(call.name, callerRow.name, call.receiver, chaCtx, lookup);
+            const targets = resolveThisDispatch(call.name, callerRow.name, call.receiver, chaCtx, lookup, relPath);
             for (const t of targets) {
+                if (t.id === callerRow.id)
+                    continue; // skip self-loops
                 const key = `${callerRow.id}|${t.id}`;
                 if (seen.has(key))
                     continue;
@@ -612,7 +749,10 @@ async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild)
                 const conf = computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
                 if (conf <= 0)
                     continue;
-                newEdges.push([callerRow.id, t.id, 'calls', conf, 0, 'cha']);
+                // Tag super-dispatch edges distinctly so runPostNativeCha can exclude them
+                // from further CHA expansion (super calls are not virtual dispatch).
+                const technique = call.receiver === 'super' ? 'super-dispatch' : 'cha';
+                newEdges.push([callerRow.id, t.id, 'calls', conf, 0, technique]);
                 targetIds.add(t.id);
                 affectedFiles.add(relPath);
                 if (t.file)
@@ -638,10 +778,10 @@ async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild)
         symbols._tree = undefined;
         symbols._langId = undefined;
     }
-    return { elapsedMs: Date.now() - t0, targetIds, affectedFiles };
+    return { elapsedMs: performance.now() - t0, targetIds, affectedFiles };
 }
 /** Format timing result from native orchestrator phases + JS post-processing. */
-function formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispatchMs) {
+function formatNativeTimingResult(p, structurePatchMs, analysisTiming, postPass) {
     return {
         phases: {
             setupMs: +(p.setupMs ?? 0).toFixed(1),
@@ -653,7 +793,11 @@ function formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispa
             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),
@@ -841,20 +985,83 @@ async function backfillNativeDroppedFiles(ctx, gap) {
     }
     if (missingAbs.length === 0)
         return;
+    // Parse all missing files via WASM first so we can distinguish real native
+    // extractor failures (WASM finds symbols but native didn't) from files the
+    // Rust engine legitimately skipped (gitignored artifacts, empty declaration
+    // files, etc. where WASM also produces 0 symbols). Both categories are
+    // backfilled — only the former triggers a WARN (#1566).
+    const wasmResults = await parseFilesWasmForBackfill(missingAbs, ctx.rootDir);
+    // Build two sets from wasmResults:
+    //   wasmParsedFiles  — rel-paths present in wasmResults (WASM succeeded, even 0 symbols)
+    //   wasmFoundSymbols — subset where WASM found ≥1 symbol
+    // Files absent from wasmParsedFiles were skipped by WASM entirely (extension
+    // not in _extToLang, wasmExtractSymbols returned null, or a read error).
+    // Those files do NOT end up in the batchInsertNodes loop below.
+    const wasmParsedFiles = new Set();
+    const wasmFoundSymbols = new Set();
+    for (const [relPath, symbols] of wasmResults) {
+        wasmParsedFiles.add(relPath);
+        if ((symbols.definitions?.length ?? 0) > 0 || (symbols.exports?.length ?? 0) > 0) {
+            wasmFoundSymbols.add(relPath);
+        }
+    }
     // Classify drops so users see per-extension reasons instead of just a count
     // (#1011). `unsupported-by-native` is a legitimate parser limit (no Rust
     // extractor); `native-extractor-failure` indicates a real native bug since
-    // the language IS supported by the addon yet the file was dropped anyway.
+    // the language IS supported by the addon yet WASM found symbols the native
+    // engine should have extracted. Files where both engines produce 0 symbols
+    // are legitimately empty (e.g. gitignored napi-generated declaration stubs)
+    // and logged at debug level only.
     const { byReason, totals } = classifyNativeDrops(missingRel);
     if (totals['unsupported-by-native'] > 0) {
         const buckets = byReason['unsupported-by-native'];
         info(`Native orchestrator skipped ${totals['unsupported-by-native']} file(s) across ${buckets.size} extension(s) in languages without a Rust extractor; backfilling via WASM:${formatDropExtensionSummary(buckets)}`);
     }
     if (totals['native-extractor-failure'] > 0) {
-        const buckets = byReason['native-extractor-failure'];
-        warn(`Native orchestrator dropped ${totals['native-extractor-failure']} file(s) across ${buckets.size} extension(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM:${formatDropExtensionSummary(buckets)}`);
+        // Three-way split of native-extractor-failure files:
+        //   realFailureBuckets  — WASM found symbols → real Rust extractor bug (WARN)
+        //   emptyFileBuckets    — WASM parsed but found 0 symbols → gitignored/empty (debug)
+        //                         These DO receive a file-node insert in the loop below.
+        //   wasmSkipBuckets     — WASM skipped entirely (ext unknown or parse error) →
+        //                         no file-node insert, and no WARN (debug only, distinct
+        //                         message to avoid overstating backfill coverage).
+        const allFailurePaths = byReason['native-extractor-failure'];
+        const realFailureBuckets = new Map();
+        const emptyFileBuckets = new Map();
+        const wasmSkipBuckets = new Map();
+        for (const [ext, paths] of allFailurePaths) {
+            for (const relPath of paths) {
+                let bucket;
+                if (wasmFoundSymbols.has(relPath)) {
+                    bucket = realFailureBuckets;
+                }
+                else if (wasmParsedFiles.has(relPath)) {
+                    bucket = emptyFileBuckets;
+                }
+                else {
+                    bucket = wasmSkipBuckets;
+                }
+                let list = bucket.get(ext);
+                if (!list) {
+                    list = [];
+                    bucket.set(ext, list);
+                }
+                list.push(relPath);
+            }
+        }
+        if (realFailureBuckets.size > 0) {
+            const realCount = [...realFailureBuckets.values()].reduce((s, a) => s + a.length, 0);
+            warn(`Native orchestrator dropped ${realCount} file(s) across ${realFailureBuckets.size} extension(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM:${formatDropExtensionSummary(realFailureBuckets)}`);
+        }
+        if (emptyFileBuckets.size > 0) {
+            const emptyCount = [...emptyFileBuckets.values()].reduce((s, a) => s + a.length, 0);
+            debug(`Native orchestrator skipped ${emptyCount} file(s) in natively-supported languages that also produced 0 symbols via WASM (likely gitignored or empty); backfilling file nodes:${formatDropExtensionSummary(emptyFileBuckets)}`);
+        }
+        if (wasmSkipBuckets.size > 0) {
+            const skipCount = [...wasmSkipBuckets.values()].reduce((s, a) => s + a.length, 0);
+            debug(`Native orchestrator skipped ${skipCount} file(s) in natively-supported languages that WASM also could not parse (unregistered extension or parse error); no file-node inserted:${formatDropExtensionSummary(wasmSkipBuckets)}`);
+        }
     }
-    const wasmResults = await parseFilesWasmForBackfill(missingAbs, ctx.rootDir);
     const rows = [];
     const exportKeys = [];
     for (const [relPath, symbols] of wasmResults) {
@@ -1072,7 +1279,7 @@ export async function tryNativeOrchestrator(ctx) {
         // Even on no-op rebuilds, dropped-language files added since the last
         // full build are still missing from `nodes`/`file_hashes` (#1083), and
         // WASM-only files deleted from disk leave stale rows behind (#1073).
-        // The orchestrator's file_collector skipped them, so its earlyExit
+        // The orchestrator's collect_files skipped them, so its earlyExit
         // doesn't imply DB consistency. Run the gap repair before returning.
         const gap = detectDroppedLanguageGap(ctx);
         if (gap.missingAbs.length > 0 || gap.staleRel.length > 0) {
@@ -1110,7 +1317,9 @@ export async function tryNativeOrchestrator(ctx) {
         schema_version: String(ctx.schemaVersion),
         built_at: new Date().toISOString(),
     });
-    info(`Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`);
+    // The build summary is logged after the JS edge-writing post-passes below
+    // (dropped-language backfill, CHA, this/super dispatch) so the reported
+    // counts include their edges (#1452).
     // ── Post-native structure + analysis ──────────────────────────────
     let analysisTiming = {
         astMs: +(p.astMs ?? 0),
@@ -1143,8 +1352,14 @@ export async function tryNativeOrchestrator(ctx) {
             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,
+            });
         }
     }
     // ── Edge-writing post-passes (run before structure so roles see full graph) ──
@@ -1153,36 +1368,42 @@ export async function tryNativeOrchestrator(ctx) {
     // stale native binaries). WASM handles those — backfill via WASM so both
     // engines process the same file set (#967).
     //
-    // Detect the gap once (fs walk + 2 DB queries, ~20–30ms) and use it for
-    // both gating and the backfill itself. On dirty incrementals/full builds
-    // the orchestrator signals trigger backfill, so the walk happens once
-    // (instead of redundantly inside backfill). On quiet incrementals we
-    // still pay the walk so we can detect brand-new files in dropped-language
-    // extensions — a gap that the orchestrator's `detect_removed_files`
-    // filter (#1070) leaves open (#1083, #1091). The pre-check is cheap
-    // because the expensive part (WASM re-parse of the missing set) is
-    // gated below.
-    const removedCount = result.removedCount ?? 0;
-    const changedCount = result.changedCount ?? 0;
+    // Detect the gap once (fs walk + 2 DB queries) and use it for both gating
+    // and the backfill itself. On quiet incrementals we still pay the walk so
+    // we can detect brand-new files in dropped-language extensions — a gap that
+    // the orchestrator's `detect_removed_files` filter (#1070) leaves open
+    // (#1083, #1091). The pre-check is cheap because the expensive part (WASM
+    // re-parse of the missing set) is gated below.
+    const gapDetectStart = performance.now();
     const gap = detectDroppedLanguageGap(ctx);
-    if (result.isFullBuild ||
-        removedCount > 0 ||
-        changedCount > 0 ||
-        gap.missingAbs.length > 0 ||
-        gap.staleRel.length > 0) {
+    const backfillHappened = gap.missingAbs.length > 0 || gap.staleRel.length > 0;
+    if (backfillHappened) {
         await backfillNativeDroppedFiles(ctx, gap);
     }
-    // Phase 8.5: expand CHA call edges (interface dispatch → concrete implementations).
+    const gapDetectMs = performance.now() - gapDetectStart;
+    // 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.
+    // Runs BEFORE the CHA expansion pass so that super.method() → Parent.method edges
+    // (technique='cha') are in the DB when runPostNativeCha expands them to sibling
+    // class overrides (e.g. PostMixin.m → B.m when PostMixin and B both extend A).
+    const { elapsedMs: thisDispatchMs, targetIds: thisDispatchTargetIds, affectedFiles: thisDispatchAffectedFiles, } = await runPostNativeThisDispatch(ctx.db, ctx.rootDir, result.changedFiles, !!result.isFullBuild);
+    // Phase 8.6: expand CHA call edges (interface dispatch → concrete implementations).
     // Returns the affected files so role re-classification below can be scoped to
     // the nodes whose fan-in/out actually changed.
     //
+    // Runs AFTER this/super dispatch so super.method() edges are already in the DB.
+    // The 'cha-expanded' technique tag on this pass's own output prevents re-expansion
+    // of those edges in subsequent incremental builds, while 'cha'-tagged edges from
+    // this/super dispatch remain eligible for expansion here.
+    //
     // 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 { newEdgeCount: chaEdgeCount, affectedFiles: chaAffectedFiles } = runPostNativeCha(ctx.db);
-    // 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.
-    const { elapsedMs: thisDispatchMs, targetIds: thisDispatchTargetIds, affectedFiles: thisDispatchAffectedFiles, } = await runPostNativeThisDispatch(ctx.db, ctx.rootDir, result.changedFiles, !!result.isFullBuild);
+    const chaStart = performance.now();
+    const { newEdgeCount: chaEdgeCount, affectedFiles: chaAffectedFiles } = runPostNativeCha(ctx.db, 
+    // 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;
     // Role re-classification after JS edge-writing post-passes.
     // The Rust orchestrator classifies roles before these post-passes (CHA,
     // this-dispatch) add edges, so roles for the edge endpoints are stale.
@@ -1191,6 +1412,7 @@ export async function tryNativeOrchestrator(ctx) {
     // 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`
@@ -1199,6 +1421,7 @@ export async function tryNativeOrchestrator(ctx) {
         // 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'));
             classifyNodeRoles(ctx.db, scopedFiles);
@@ -1209,12 +1432,42 @@ export async function tryNativeOrchestrator(ctx) {
         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
+    // edges, so both its summary and build_meta under-report (#1452).
+    //
+    // Fast path: skip the COUNT(*) scan when no post-pass wrote any edges.
+    // COUNT(*) on large tables (50K+ edges) is non-trivial, especially via the
+    // NativeDbProxy napi-rs round-trip. When all post-passes were no-ops, the
+    // Rust orchestrator's counts are still accurate — no re-count needed.
+    let finalNodeCount = result.nodeCount ?? 0;
+    let finalEdgeCount = result.edgeCount ?? 0;
+    const postPassWroteData = backfillHappened || chaEdgeCount > 0 || thisDispatchTargetIds.size > 0;
+    if (postPassWroteData) {
+        try {
+            const counts = ctx.db
+                .prepare('SELECT (SELECT COUNT(*) FROM nodes) AS n, (SELECT COUNT(*) FROM edges) AS e')
+                .get();
+            if (counts.n !== finalNodeCount || counts.e !== finalEdgeCount) {
+                finalNodeCount = counts.n;
+                finalEdgeCount = counts.e;
+                setBuildMeta(ctx.db, { node_count: finalNodeCount, edge_count: finalEdgeCount });
+            }
+        }
+        catch (err) {
+            debug(`Post-pass node/edge re-count failed: ${toErrorMessage(err)}`);
+        }
+    }
+    info(`Native build orchestrator completed: ${finalNodeCount} nodes, ${finalEdgeCount} edges, ${result.fileCount ?? 0} files`);
     // ── Structure and analysis fallback (run after edge-writing so roles see full graph) ──
     // Reconstruct fileSymbols once for both structure and analysis to avoid two
     // expensive DB scans. The DB handoff above already ensured ctx.db is a proper
@@ -1229,6 +1482,12 @@ export async function tryNativeOrchestrator(ctx) {
         }
     }
     closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
-    return formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispatchMs);
+    return formatNativeTimingResult(p, structurePatchMs, analysisTiming, {
+        gapDetectMs,
+        chaMs,
+        thisDispatchMs,
+        reclassifyMs,
+        techniqueBackfillMs,
+    });
 }
 //# sourceMappingURL=native-orchestrator.js.map