diff --git a/.claude/skills/titan-forge/SKILL.md b/.claude/skills/titan-forge/SKILL.md
deleted file mode 100644
index d79d89ae..00000000
--- a/.claude/skills/titan-forge/SKILL.md
+++ /dev/null
@@ -1,245 +0,0 @@
----
-name: titan-forge
-description: Execute the sync.json plan — refactor code, validate with /titan-gate, commit, and advance state (Titan Paradigm Phase 4)
-argument-hint: <--phase N> <--target name> <--dry-run> <--yes>
-allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill, Agent
----
-
-# Titan FORGE — Execute Sync Plan
-
-You are running the **FORGE** phase of the Titan Paradigm.
-
-Your goal: read `sync.json`, find the next incomplete execution phase, make the actual code changes for each target, validate with `/titan-gate`, commit, and advance state.
-
-> **Context budget:** One phase per invocation. Do not attempt all phases in one session — the context window will fill. Run one phase, report, stop. User re-runs for the next phase.
-
-**Arguments** (from `$ARGUMENTS`):
-- No args → run next incomplete phase
-- `--phase N` → jump to specific phase
-- `--target <name>` → run single target only (for retrying failures)
-- `--dry-run` → show what would be done without changing code
-- `--yes` → skip confirmation prompt
-
----
-
-## Step 0 — Pre-flight
-
-1. **Worktree check:**
-   ```bash
-   git rev-parse --show-toplevel && git worktree list
-   ```
-   If not in a worktree, stop: "Run `/worktree` first."
-
-2. **Sync with main:**
-   ```bash
-   git fetch origin main && git merge origin/main --no-edit
-   ```
-   If there are merge conflicts, stop: "Merge conflict detected. Resolve conflicts and re-run `/titan-forge`."
-
-3. **Load artifacts.** Read:
-   - `.codegraph/titan/sync.json` — execution plan (if missing: "Run `/titan-sync` first.")
-   - `.codegraph/titan/titan-state.json` — current state
-   - `.codegraph/titan/gauntlet.ndjson` — per-target audit details
-   - `.codegraph/titan/gauntlet-summary.json` — aggregated results
-
-4. **Validate state.** If `titan-state.json` has `currentPhase` other than `"sync"` and no existing `execution` block, stop: "State not ready. Run `/titan-sync` first."
-
-5. **Initialize execution state** (if first run). Add to `titan-state.json`:
-   ```json
-   {
-     "execution": {
-       "currentPhase": 1,
-       "completedPhases": [],
-       "currentTarget": null,
-       "completedTargets": [],
-       "failedTargets": [],
-       "commits": [],
-       "currentSubphase": null,
-       "completedSubphases": []
-     }
-   }
-   ```
-
-6. **Determine next phase.** Use `--phase N` if provided, otherwise find the lowest phase number not in `completedPhases`.
-
-7. **Print plan:**
-   > Phase N: \<label\> — N targets, estimated N commits
-
-8. **Ask for confirmation** before starting (unless `$ARGUMENTS` contains `--yes`).
-
----
-
-## Step 1 — Phase-specific execution strategies
-
-Each phase type requires different code-change logic:
-
-### Phase 1: Dead code cleanup
-- Delete the symbol/export
-- Verify no consumers: `codegraph fn-impact <target> -T --json`
-- Remove any orphaned imports
-- Run lint to clean up
-
-### Phase 2: Shared abstractions
-- Extract function/interface to new or existing file
-- Update imports in all consumers
-- Verify with: `codegraph exports <file> -T --json`
-
-### Phase 3: Empty catches / error handling
-- Replace `catch {}` with `catch (e) { logger.debug(...) }` or explicit fallback
-- Use contextually appropriate error handling
-- Subphases: each distinct catch pattern = one commit
-
-### Phase 4: Extractor decomposition
-- Split large `walkXNode` switch cases into handler functions
-- Keep dispatcher thin — handler per node kind
-- Subphases: each extractor = one commit
-
-### Phase 5: General decomposition
-- Read the gauntlet recommendation for the specific target
-- Apply the recommended decomposition strategy
-- Subphases: each function split = one commit
-
-### Phase 6: Small FAIL fixes
-- Read the gauntlet recommendation for the specific target
-- Apply the recommended fix (complexity reduction, metric improvement)
-- Group by domain where possible
-
----
-
-## Step 2 — Per-target execution loop
-
-For each target in the current phase:
-
-1. **Skip if done.** Check if target is already in `execution.completedTargets`. If so, skip.
-
-2. **Update state.** Set `execution.currentTarget` in `titan-state.json`.
-
-3. **Read gauntlet entry.** Find this target in `gauntlet.ndjson` → get recommendation, violations, metrics.
-
-4. **Understand before touching.** Run codegraph commands:
-   ```bash
-   codegraph context <target> -T --json
-   ```
-   If blast radius > 0:
-   ```bash
-   codegraph fn-impact <target> -T --json
-   ```
-
-5. **Check if already fixed.** If the file has changed since gauntlet ran, re-check metrics:
-   ```bash
-   codegraph complexity --file <file> --health -T --json
-   ```
-   If the target now passes all thresholds, skip with note: "Target already passes — skipping."
-
-6. **Read source file(s).** Understand the code before editing.
-
-7. **Apply the change** based on phase strategy (Step 1) + gauntlet recommendation.
-
-8. **Run tests:**
-   ```bash
-   npm test 2>&1
-   ```
-   If tests fail → go to rollback (step 11).
-
-9. **Run /titan-gate:**
-   Use the Skill tool to invoke `titan-gate`. If FAIL → go to rollback (step 11).
-
-10. **On success:**
-    ```bash
-    git add <specific changed files>
-    git commit -m "<commit message from sync.json>"
-    ```
-    - Record commit SHA in `execution.commits`
-    - Add target to `execution.completedTargets`
-    - Update `titan-state.json`
-
-11. **On failure (test or gate):**
-    ```bash
-    git checkout -- <changed files>
-    ```
-    - Add to `execution.failedTargets` with reason: `{ "target": "<name>", "reason": "<why>", "phase": N }`
-    - Clear `execution.currentTarget`
-    - **Continue to next target** — don't block the whole phase
-
----
-
-## Step 3 — Phase completion
-
-When all targets in the phase are processed:
-
-1. Add phase number to `execution.completedPhases`
-2. Advance `execution.currentPhase` to the next phase number
-3. Clear `execution.currentTarget`
-4. Write updated `titan-state.json`
-
----
-
-## Step 4 — Report
-
-Print:
-
-```
-## Phase N Complete: <label>
-
-Targets: X/Y completed, Z failed
-Commits: N
-Files changed: N
-
-### Failed targets (if any):
-- <target>: <reason>
-
-### Next: Phase M — <label> (N targets)
-Run /titan-forge to continue.
-```
-
-If all phases are complete:
-
-```
-## All phases complete
-
-Total commits: N
-Total targets: X completed, Y failed
-Failed targets: <list or "none">
-
-Run /titan-gate on the full branch to validate.
-```
-
----
-
-## Edge Cases
-
-- **Test failure mid-phase:** Revert target, mark failed, continue. Don't block the whole phase.
-- **Merge conflict with main:** Stop, report, ask user to resolve.
-- **Gate detects new cycle:** Stop immediately — this is a real problem, not skippable.
-- **Target already fixed on main:** Check if file has changed since gauntlet. If metrics now pass, skip with note.
-- **Interrupted mid-phase:** Re-running picks up from `execution.currentTarget`. Already-committed targets are skipped.
-- **`--dry-run`:** Walk through all targets, print what would be done (phase strategy, gauntlet recommendation, files affected), but make no changes.
-- **`--target <name>`:** Run only that target. Useful for retrying entries in `failedTargets`.
-
----
-
-## Rules
-
-- **One phase per invocation.** Stop after the phase completes. User re-runs for next.
-- **Resumable.** If interrupted, re-running picks up where it left off.
-- **Always use `--json` and `-T`** for codegraph commands.
-- **Gate before commit.** Every commit must pass `/titan-gate`. No exceptions.
-- **One commit per logical unit.** Use commit messages from `sync.json`.
-- **Stage only specific files.** Never `git add .` or `git add -A`.
-- **Rollback on failure is gentle** — `git checkout -- <files>`, not `git reset --hard`.
-- **Subphase awareness** — phases 3-6 have subphases. Each subphase = one commit. Track at subphase level.
-- **Never skip `/titan-gate`.** Even for "trivial" changes.
-
-## Relationship to Other Skills
-
-| Skill | Produces | Used by /titan-forge |
-|-------|----------|---------------------|
-| `/titan-recon` | `titan-state.json`, `GLOBAL_ARCH.md` | State tracking, domain context |
-| `/titan-gauntlet` | `gauntlet.ndjson`, `gauntlet-summary.json` | Per-target recommendations |
-| `/titan-sync` | `sync.json` | Execution plan (phases, targets, commits) |
-| `/titan-gate` | Gate verdict | Called per-commit for validation |
-| `/titan-reset` | Clean slate | Removes all artifacts |
-
-## Self-Improvement
-
-This skill lives at `.claude/skills/titan-forge/SKILL.md`. Edit if phase strategies need refinement or execution loop needs adjustment after dogfooding.
diff --git a/docs/examples/claude-code-skills/titan-forge/SKILL.md b/docs/examples/claude-code-skills/titan-forge/SKILL.md
deleted file mode 100644
index d79d89ae..00000000
--- a/docs/examples/claude-code-skills/titan-forge/SKILL.md
+++ /dev/null
@@ -1,245 +0,0 @@
----
-name: titan-forge
-description: Execute the sync.json plan — refactor code, validate with /titan-gate, commit, and advance state (Titan Paradigm Phase 4)
-argument-hint: <--phase N> <--target name> <--dry-run> <--yes>
-allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill, Agent
----
-
-# Titan FORGE — Execute Sync Plan
-
-You are running the **FORGE** phase of the Titan Paradigm.
-
-Your goal: read `sync.json`, find the next incomplete execution phase, make the actual code changes for each target, validate with `/titan-gate`, commit, and advance state.
-
-> **Context budget:** One phase per invocation. Do not attempt all phases in one session — the context window will fill. Run one phase, report, stop. User re-runs for the next phase.
-
-**Arguments** (from `$ARGUMENTS`):
-- No args → run next incomplete phase
-- `--phase N` → jump to specific phase
-- `--target <name>` → run single target only (for retrying failures)
-- `--dry-run` → show what would be done without changing code
-- `--yes` → skip confirmation prompt
-
----
-
-## Step 0 — Pre-flight
-
-1. **Worktree check:**
-   ```bash
-   git rev-parse --show-toplevel && git worktree list
-   ```
-   If not in a worktree, stop: "Run `/worktree` first."
-
-2. **Sync with main:**
-   ```bash
-   git fetch origin main && git merge origin/main --no-edit
-   ```
-   If there are merge conflicts, stop: "Merge conflict detected. Resolve conflicts and re-run `/titan-forge`."
-
-3. **Load artifacts.** Read:
-   - `.codegraph/titan/sync.json` — execution plan (if missing: "Run `/titan-sync` first.")
-   - `.codegraph/titan/titan-state.json` — current state
-   - `.codegraph/titan/gauntlet.ndjson` — per-target audit details
-   - `.codegraph/titan/gauntlet-summary.json` — aggregated results
-
-4. **Validate state.** If `titan-state.json` has `currentPhase` other than `"sync"` and no existing `execution` block, stop: "State not ready. Run `/titan-sync` first."
-
-5. **Initialize execution state** (if first run). Add to `titan-state.json`:
-   ```json
-   {
-     "execution": {
-       "currentPhase": 1,
-       "completedPhases": [],
-       "currentTarget": null,
-       "completedTargets": [],
-       "failedTargets": [],
-       "commits": [],
-       "currentSubphase": null,
-       "completedSubphases": []
-     }
-   }
-   ```
-
-6. **Determine next phase.** Use `--phase N` if provided, otherwise find the lowest phase number not in `completedPhases`.
-
-7. **Print plan:**
-   > Phase N: \<label\> — N targets, estimated N commits
-
-8. **Ask for confirmation** before starting (unless `$ARGUMENTS` contains `--yes`).
-
----
-
-## Step 1 — Phase-specific execution strategies
-
-Each phase type requires different code-change logic:
-
-### Phase 1: Dead code cleanup
-- Delete the symbol/export
-- Verify no consumers: `codegraph fn-impact <target> -T --json`
-- Remove any orphaned imports
-- Run lint to clean up
-
-### Phase 2: Shared abstractions
-- Extract function/interface to new or existing file
-- Update imports in all consumers
-- Verify with: `codegraph exports <file> -T --json`
-
-### Phase 3: Empty catches / error handling
-- Replace `catch {}` with `catch (e) { logger.debug(...) }` or explicit fallback
-- Use contextually appropriate error handling
-- Subphases: each distinct catch pattern = one commit
-
-### Phase 4: Extractor decomposition
-- Split large `walkXNode` switch cases into handler functions
-- Keep dispatcher thin — handler per node kind
-- Subphases: each extractor = one commit
-
-### Phase 5: General decomposition
-- Read the gauntlet recommendation for the specific target
-- Apply the recommended decomposition strategy
-- Subphases: each function split = one commit
-
-### Phase 6: Small FAIL fixes
-- Read the gauntlet recommendation for the specific target
-- Apply the recommended fix (complexity reduction, metric improvement)
-- Group by domain where possible
-
----
-
-## Step 2 — Per-target execution loop
-
-For each target in the current phase:
-
-1. **Skip if done.** Check if target is already in `execution.completedTargets`. If so, skip.
-
-2. **Update state.** Set `execution.currentTarget` in `titan-state.json`.
-
-3. **Read gauntlet entry.** Find this target in `gauntlet.ndjson` → get recommendation, violations, metrics.
-
-4. **Understand before touching.** Run codegraph commands:
-   ```bash
-   codegraph context <target> -T --json
-   ```
-   If blast radius > 0:
-   ```bash
-   codegraph fn-impact <target> -T --json
-   ```
-
-5. **Check if already fixed.** If the file has changed since gauntlet ran, re-check metrics:
-   ```bash
-   codegraph complexity --file <file> --health -T --json
-   ```
-   If the target now passes all thresholds, skip with note: "Target already passes — skipping."
-
-6. **Read source file(s).** Understand the code before editing.
-
-7. **Apply the change** based on phase strategy (Step 1) + gauntlet recommendation.
-
-8. **Run tests:**
-   ```bash
-   npm test 2>&1
-   ```
-   If tests fail → go to rollback (step 11).
-
-9. **Run /titan-gate:**
-   Use the Skill tool to invoke `titan-gate`. If FAIL → go to rollback (step 11).
-
-10. **On success:**
-    ```bash
-    git add <specific changed files>
-    git commit -m "<commit message from sync.json>"
-    ```
-    - Record commit SHA in `execution.commits`
-    - Add target to `execution.completedTargets`
-    - Update `titan-state.json`
-
-11. **On failure (test or gate):**
-    ```bash
-    git checkout -- <changed files>
-    ```
-    - Add to `execution.failedTargets` with reason: `{ "target": "<name>", "reason": "<why>", "phase": N }`
-    - Clear `execution.currentTarget`
-    - **Continue to next target** — don't block the whole phase
-
----
-
-## Step 3 — Phase completion
-
-When all targets in the phase are processed:
-
-1. Add phase number to `execution.completedPhases`
-2. Advance `execution.currentPhase` to the next phase number
-3. Clear `execution.currentTarget`
-4. Write updated `titan-state.json`
-
----
-
-## Step 4 — Report
-
-Print:
-
-```
-## Phase N Complete: <label>
-
-Targets: X/Y completed, Z failed
-Commits: N
-Files changed: N
-
-### Failed targets (if any):
-- <target>: <reason>
-
-### Next: Phase M — <label> (N targets)
-Run /titan-forge to continue.
-```
-
-If all phases are complete:
-
-```
-## All phases complete
-
-Total commits: N
-Total targets: X completed, Y failed
-Failed targets: <list or "none">
-
-Run /titan-gate on the full branch to validate.
-```
-
----
-
-## Edge Cases
-
-- **Test failure mid-phase:** Revert target, mark failed, continue. Don't block the whole phase.
-- **Merge conflict with main:** Stop, report, ask user to resolve.
-- **Gate detects new cycle:** Stop immediately — this is a real problem, not skippable.
-- **Target already fixed on main:** Check if file has changed since gauntlet. If metrics now pass, skip with note.
-- **Interrupted mid-phase:** Re-running picks up from `execution.currentTarget`. Already-committed targets are skipped.
-- **`--dry-run`:** Walk through all targets, print what would be done (phase strategy, gauntlet recommendation, files affected), but make no changes.
-- **`--target <name>`:** Run only that target. Useful for retrying entries in `failedTargets`.
-
----
-
-## Rules
-
-- **One phase per invocation.** Stop after the phase completes. User re-runs for next.
-- **Resumable.** If interrupted, re-running picks up where it left off.
-- **Always use `--json` and `-T`** for codegraph commands.
-- **Gate before commit.** Every commit must pass `/titan-gate`. No exceptions.
-- **One commit per logical unit.** Use commit messages from `sync.json`.
-- **Stage only specific files.** Never `git add .` or `git add -A`.
-- **Rollback on failure is gentle** — `git checkout -- <files>`, not `git reset --hard`.
-- **Subphase awareness** — phases 3-6 have subphases. Each subphase = one commit. Track at subphase level.
-- **Never skip `/titan-gate`.** Even for "trivial" changes.
-
-## Relationship to Other Skills
-
-| Skill | Produces | Used by /titan-forge |
-|-------|----------|---------------------|
-| `/titan-recon` | `titan-state.json`, `GLOBAL_ARCH.md` | State tracking, domain context |
-| `/titan-gauntlet` | `gauntlet.ndjson`, `gauntlet-summary.json` | Per-target recommendations |
-| `/titan-sync` | `sync.json` | Execution plan (phases, targets, commits) |
-| `/titan-gate` | Gate verdict | Called per-commit for validation |
-| `/titan-reset` | Clean slate | Removes all artifacts |
-
-## Self-Improvement
-
-This skill lives at `.claude/skills/titan-forge/SKILL.md`. Edit if phase strategies need refinement or execution loop needs adjustment after dogfooding.
diff --git a/src/ast-analysis/engine.js b/src/ast-analysis/engine.js
index 981ec514..5da9fe5e 100644
--- a/src/ast-analysis/engine.js
+++ b/src/ast-analysis/engine.js
@@ -50,294 +50,227 @@ async function getParserModule() {
   return _parserModule;
 }
 
-// ─── Public API ──────────────────────────────────────────────────────────
+// ─── WASM pre-parse ─────────────────────────────────────────────────────
 
-/**
- * Run all enabled AST analyses in a coordinated pass.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, calls, _tree, _langId, ... }>
- * @param {string} rootDir - absolute project root path
- * @param {object} opts - build options (ast, complexity, cfg, dataflow toggles)
- * @param {object} [engineOpts] - engine options
- * @returns {Promise<{ astMs: number, complexityMs: number, cfgMs: number, dataflowMs: number }>}
- */
-export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
-  const timing = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
-
-  const doAst = opts.ast !== false;
+async function ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir) {
   const doComplexity = opts.complexity !== false;
   const doCfg = opts.cfg !== false;
   const doDataflow = opts.dataflow !== false;
 
-  if (!doAst && !doComplexity && !doCfg && !doDataflow) return timing;
-
-  const extToLang = buildExtToLangMap();
-
-  // ── WASM pre-parse for files that need it ───────────────────────────
-  // The native engine only handles parsing (symbols, calls, imports).
-  // Complexity, CFG, and dataflow all require a WASM tree-sitter tree
-  // for their visitor walks. Without this, incremental rebuilds on the
-  // native engine silently lose these analyses for changed files (#468).
-  if (doComplexity || doCfg || doDataflow) {
-    let needsWasmTrees = false;
-    for (const [relPath, symbols] of fileSymbols) {
-      if (symbols._tree) continue;
-      const ext = path.extname(relPath).toLowerCase();
-      const defs = symbols.definitions || [];
-
-      const needsComplexity =
-        doComplexity &&
-        COMPLEXITY_EXTENSIONS.has(ext) &&
-        defs.some((d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity);
-      const needsCfg =
-        doCfg &&
-        CFG_EXTENSIONS.has(ext) &&
-        defs.some(
-          (d) =>
-            (d.kind === 'function' || d.kind === 'method') &&
-            d.line &&
-            d.cfg !== null &&
-            !Array.isArray(d.cfg?.blocks),
-        );
-      const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
-
-      if (needsComplexity || needsCfg || needsDataflow) {
-        needsWasmTrees = true;
-        break;
-      }
-    }
-
-    if (needsWasmTrees) {
-      try {
-        const { ensureWasmTrees } = await getParserModule();
-        await ensureWasmTrees(fileSymbols, rootDir);
-      } catch (err) {
-        debug(`ensureWasmTrees failed: ${err.message}`);
-      }
-    }
-  }
-
-  // ── Phase 7 Optimization: Unified pre-walk ─────────────────────────
-  // For files with WASM trees, run all applicable visitors in a SINGLE
-  // walkWithVisitors call. Store results in the format that buildXxx
-  // functions already expect as pre-computed data (same fields as native
-  // engine output). This eliminates ~3 redundant tree traversals per file.
-  const t0walk = performance.now();
+  if (!doComplexity && !doCfg && !doDataflow) return;
 
+  let needsWasmTrees = false;
   for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) continue; // No WASM tree — native path handles it
-
+    if (symbols._tree) continue;
     const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || extToLang.get(ext);
-    if (!langId) continue;
-
     const defs = symbols.definitions || [];
-    const visitors = [];
-    const walkerOpts = {
-      functionNodeTypes: new Set(),
-      nestingNodeTypes: new Set(),
-      getFunctionName: (_node) => null,
-    };
-
-    // ─ AST-store visitor ─
-    const astTypeMap = AST_TYPE_MAPS.get(langId);
-    let astVisitor = null;
-    if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
-      const nodeIdMap = new Map();
-      for (const row of bulkNodeIdsByFile(db, relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      astVisitor = createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap);
-      visitors.push(astVisitor);
-    }
 
-    // ─ Complexity visitor (file-level mode) ─
-    const cRules = COMPLEXITY_RULES.get(langId);
-    const hRules = HALSTEAD_RULES.get(langId);
-    let complexityVisitor = null;
-    if (doComplexity && cRules) {
-      // Only use visitor if some functions lack pre-computed complexity
-      const needsWasmComplexity = defs.some(
-        (d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity,
-      );
-      if (needsWasmComplexity) {
-        complexityVisitor = createComplexityVisitor(cRules, hRules, {
-          fileLevelWalk: true,
-          langId,
-        });
-        visitors.push(complexityVisitor);
-
-        // Merge nesting nodes for complexity tracking
-        // NOTE: do NOT add functionNodes here — funcDepth in the complexity
-        // visitor already tracks function-level nesting.  Adding them to
-        // nestingNodeTypes would inflate context.nestingLevel by +1 inside
-        // every function body, double-counting in cognitive += 1 + nestingLevel.
-        for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes.add(t);
-
-        // Provide getFunctionName for complexity visitor
-        const dfRules = DATAFLOW_RULES.get(langId);
-        walkerOpts.getFunctionName = (node) => {
-          // Try complexity rules' function name field first
-          const nameNode = node.childForFieldName('name');
-          if (nameNode) return nameNode.text;
-          // Fall back to dataflow rules' richer name extraction
-          if (dfRules) return getFuncName(node, dfRules);
-          return null;
-        };
-      }
-    }
-
-    // ─ CFG visitor ─
-    const cfgRulesForLang = CFG_RULES.get(langId);
-    let cfgVisitor = null;
-    if (doCfg && cfgRulesForLang && CFG_EXTENSIONS.has(ext)) {
-      // Only use visitor if some functions lack pre-computed CFG
-      const needsWasmCfg = defs.some(
+    const needsComplexity =
+      doComplexity &&
+      COMPLEXITY_EXTENSIONS.has(ext) &&
+      defs.some((d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity);
+    const needsCfg =
+      doCfg &&
+      CFG_EXTENSIONS.has(ext) &&
+      defs.some(
         (d) =>
           (d.kind === 'function' || d.kind === 'method') &&
           d.line &&
           d.cfg !== null &&
           !Array.isArray(d.cfg?.blocks),
       );
-      if (needsWasmCfg) {
-        cfgVisitor = createCfgVisitor(cfgRulesForLang);
-        visitors.push(cfgVisitor);
-      }
+    const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
+
+    if (needsComplexity || needsCfg || needsDataflow) {
+      needsWasmTrees = true;
+      break;
     }
+  }
 
-    // ─ Dataflow visitor ─
-    const dfRules = DATAFLOW_RULES.get(langId);
-    let dataflowVisitor = null;
-    if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
-      dataflowVisitor = createDataflowVisitor(dfRules);
-      visitors.push(dataflowVisitor);
+  if (needsWasmTrees) {
+    try {
+      const { ensureWasmTrees } = await getParserModule();
+      await ensureWasmTrees(fileSymbols, rootDir);
+    } catch (err) {
+      debug(`ensureWasmTrees failed: ${err.message}`);
     }
+  }
+}
 
-    // ─ Run unified walk if we have visitors ─
-    if (visitors.length === 0) continue;
+// ─── Per-file visitor setup ─────────────────────────────────────────────
 
-    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+function setupVisitors(db, relPath, symbols, langId, opts) {
+  const ext = path.extname(relPath).toLowerCase();
+  const defs = symbols.definitions || [];
+  const doAst = opts.ast !== false;
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  const doDataflow = opts.dataflow !== false;
 
-    // ─ Store AST results (buildAstNodes will find symbols.astNodes and skip its walk) ─
-    if (astVisitor) {
-      const astRows = results['ast-store'] || [];
-      if (astRows.length > 0) {
-        // Store in the format buildAstNodes expects for the native path
-        symbols.astNodes = astRows;
-      }
+  const visitors = [];
+  const walkerOpts = {
+    functionNodeTypes: new Set(),
+    nestingNodeTypes: new Set(),
+    getFunctionName: (_node) => null,
+  };
+
+  // AST-store visitor
+  let astVisitor = null;
+  const astTypeMap = AST_TYPE_MAPS.get(langId);
+  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
+    astVisitor = createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap);
+    visitors.push(astVisitor);
+  }
 
-    // ─ Store complexity results on definitions (buildComplexityMetrics will find def.complexity) ─
-    if (complexityVisitor) {
-      const complexityResults = results.complexity || [];
-      // Match results back to definitions by function start line
-      // Store the full result (metrics + funcNode) for O(1) lookup
-      const resultByLine = new Map();
-      for (const r of complexityResults) {
-        if (r.funcNode) {
-          const line = r.funcNode.startPosition.row + 1;
-          if (!resultByLine.has(line)) resultByLine.set(line, []);
-          resultByLine.get(line).push(r);
-        }
-      }
-      for (const def of defs) {
-        if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
-          const candidates = resultByLine.get(def.line);
-          const funcResult = !candidates
-            ? undefined
-            : candidates.length === 1
-              ? candidates[0]
-              : (candidates.find((r) => {
-                  const n = r.funcNode.childForFieldName('name');
-                  return n && n.text === def.name;
-                }) ?? candidates[0]);
-          if (funcResult) {
-            const { metrics } = funcResult;
-            const loc = computeLOCMetrics(funcResult.funcNode, langId);
-            const volume = metrics.halstead ? metrics.halstead.volume : 0;
-            const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
-            const mi = computeMaintainabilityIndex(
-              volume,
-              metrics.cyclomatic,
-              loc.sloc,
-              commentRatio,
-            );
-
-            def.complexity = {
-              cognitive: metrics.cognitive,
-              cyclomatic: metrics.cyclomatic,
-              maxNesting: metrics.maxNesting,
-              halstead: metrics.halstead,
-              loc,
-              maintainabilityIndex: mi,
-            };
-          }
-        }
-      }
+  // Complexity visitor (file-level mode)
+  let complexityVisitor = null;
+  const cRules = COMPLEXITY_RULES.get(langId);
+  const hRules = HALSTEAD_RULES.get(langId);
+  if (doComplexity && cRules) {
+    const needsWasmComplexity = defs.some(
+      (d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity,
+    );
+    if (needsWasmComplexity) {
+      complexityVisitor = createComplexityVisitor(cRules, hRules, { fileLevelWalk: true, langId });
+      visitors.push(complexityVisitor);
+
+      for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes.add(t);
+
+      const dfRules = DATAFLOW_RULES.get(langId);
+      walkerOpts.getFunctionName = (node) => {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) return nameNode.text;
+        if (dfRules) return getFuncName(node, dfRules);
+        return null;
+      };
     }
+  }
 
-    // ─ Store CFG results on definitions (buildCFGData will find def.cfg and skip its walk) ─
-    if (cfgVisitor) {
-      const cfgResults = results.cfg || [];
-      const cfgByLine = new Map();
-      for (const r of cfgResults) {
-        if (r.funcNode) {
-          const line = r.funcNode.startPosition.row + 1;
-          if (!cfgByLine.has(line)) cfgByLine.set(line, []);
-          cfgByLine.get(line).push(r);
-        }
-      }
-      for (const def of defs) {
-        if (
-          (def.kind === 'function' || def.kind === 'method') &&
-          def.line &&
-          !def.cfg?.blocks?.length
-        ) {
-          const candidates = cfgByLine.get(def.line);
-          const cfgResult = !candidates
-            ? undefined
-            : candidates.length === 1
-              ? candidates[0]
-              : (candidates.find((r) => {
-                  const n = r.funcNode.childForFieldName('name');
-                  return n && n.text === def.name;
-                }) ?? candidates[0]);
-          if (cfgResult) {
-            def.cfg = { blocks: cfgResult.blocks, edges: cfgResult.edges };
-
-            // Override complexity's cyclomatic with CFG-derived value (single source of truth)
-            // and recompute maintainability index to stay consistent
-            if (def.complexity && cfgResult.cyclomatic != null) {
-              def.complexity.cyclomatic = cfgResult.cyclomatic;
-              const { loc, halstead } = def.complexity;
-              const volume = halstead ? halstead.volume : 0;
-              const commentRatio = loc?.loc > 0 ? loc.commentLines / loc.loc : 0;
-              def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
-                volume,
-                cfgResult.cyclomatic,
-                loc?.sloc ?? 0,
-                commentRatio,
-              );
-            }
-          }
-        }
-      }
+  // CFG visitor
+  let cfgVisitor = null;
+  const cfgRulesForLang = CFG_RULES.get(langId);
+  if (doCfg && cfgRulesForLang && CFG_EXTENSIONS.has(ext)) {
+    const needsWasmCfg = defs.some(
+      (d) =>
+        (d.kind === 'function' || d.kind === 'method') &&
+        d.line &&
+        d.cfg !== null &&
+        !Array.isArray(d.cfg?.blocks),
+    );
+    if (needsWasmCfg) {
+      cfgVisitor = createCfgVisitor(cfgRulesForLang);
+      visitors.push(cfgVisitor);
     }
+  }
+
+  // Dataflow visitor
+  let dataflowVisitor = null;
+  const dfRules = DATAFLOW_RULES.get(langId);
+  if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
+    dataflowVisitor = createDataflowVisitor(dfRules);
+    visitors.push(dataflowVisitor);
+  }
+
+  return { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor };
+}
 
-    // ─ Store dataflow results (buildDataflowEdges will find symbols.dataflow and skip its walk) ─
-    if (dataflowVisitor) {
-      symbols.dataflow = results.dataflow;
+// ─── Result storage helpers ─────────────────────────────────────────────
+
+function storeComplexityResults(results, defs, langId) {
+  const complexityResults = results.complexity || [];
+  const resultByLine = new Map();
+  for (const r of complexityResults) {
+    if (r.funcNode) {
+      const line = r.funcNode.startPosition.row + 1;
+      if (!resultByLine.has(line)) resultByLine.set(line, []);
+      resultByLine.get(line).push(r);
     }
   }
+  for (const def of defs) {
+    if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
+      const candidates = resultByLine.get(def.line);
+      const funcResult = !candidates
+        ? undefined
+        : candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => {
+              const n = r.funcNode.childForFieldName('name');
+              return n && n.text === def.name;
+            }) ?? candidates[0]);
+      if (funcResult) {
+        const { metrics } = funcResult;
+        const loc = computeLOCMetrics(funcResult.funcNode, langId);
+        const volume = metrics.halstead ? metrics.halstead.volume : 0;
+        const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
+        const mi = computeMaintainabilityIndex(volume, metrics.cyclomatic, loc.sloc, commentRatio);
+
+        def.complexity = {
+          cognitive: metrics.cognitive,
+          cyclomatic: metrics.cyclomatic,
+          maxNesting: metrics.maxNesting,
+          halstead: metrics.halstead,
+          loc,
+          maintainabilityIndex: mi,
+        };
+      }
+    }
+  }
+}
 
-  timing._unifiedWalkMs = performance.now() - t0walk;
+function storeCfgResults(results, defs) {
+  const cfgResults = results.cfg || [];
+  const cfgByLine = new Map();
+  for (const r of cfgResults) {
+    if (r.funcNode) {
+      const line = r.funcNode.startPosition.row + 1;
+      if (!cfgByLine.has(line)) cfgByLine.set(line, []);
+      cfgByLine.get(line).push(r);
+    }
+  }
+  for (const def of defs) {
+    if (
+      (def.kind === 'function' || def.kind === 'method') &&
+      def.line &&
+      !def.cfg?.blocks?.length
+    ) {
+      const candidates = cfgByLine.get(def.line);
+      const cfgResult = !candidates
+        ? undefined
+        : candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => {
+              const n = r.funcNode.childForFieldName('name');
+              return n && n.text === def.name;
+            }) ?? candidates[0]);
+      if (cfgResult) {
+        def.cfg = { blocks: cfgResult.blocks, edges: cfgResult.edges };
+
+        // Override complexity's cyclomatic with CFG-derived value (single source of truth)
+        if (def.complexity && cfgResult.cyclomatic != null) {
+          def.complexity.cyclomatic = cfgResult.cyclomatic;
+          const { loc, halstead } = def.complexity;
+          const volume = halstead ? halstead.volume : 0;
+          const commentRatio = loc?.loc > 0 ? loc.commentLines / loc.loc : 0;
+          def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
+            volume,
+            cfgResult.cyclomatic,
+            loc?.sloc ?? 0,
+            commentRatio,
+          );
+        }
+      }
+    }
+  }
+}
 
-  // ── Delegate to buildXxx functions ─────────────────────────────────
-  // Each function finds pre-computed data from the unified walk above
-  // (or from the native engine) and only does DB writes + native fallback.
+// ─── Build delegation ───────────────────────────────────────────────────
 
-  if (doAst) {
+async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing) {
+  if (opts.ast !== false) {
     const t0 = performance.now();
     try {
       const { buildAstNodes } = await import('../features/ast.js');
@@ -348,7 +281,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.astMs = performance.now() - t0;
   }
 
-  if (doComplexity) {
+  if (opts.complexity !== false) {
     const t0 = performance.now();
     try {
       const { buildComplexityMetrics } = await import('../features/complexity.js');
@@ -359,7 +292,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.complexityMs = performance.now() - t0;
   }
 
-  if (doCfg) {
+  if (opts.cfg !== false) {
     const t0 = performance.now();
     try {
       const { buildCFGData } = await import('../features/cfg.js');
@@ -370,7 +303,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.cfgMs = performance.now() - t0;
   }
 
-  if (doDataflow) {
+  if (opts.dataflow !== false) {
     const t0 = performance.now();
     try {
       const { buildDataflowEdges } = await import('../features/dataflow.js');
@@ -380,6 +313,67 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     }
     timing.dataflowMs = performance.now() - t0;
   }
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Run all enabled AST analyses in a coordinated pass.
+ *
+ * @param {object} db - open better-sqlite3 database (read-write)
+ * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, calls, _tree, _langId, ... }>
+ * @param {string} rootDir - absolute project root path
+ * @param {object} opts - build options (ast, complexity, cfg, dataflow toggles)
+ * @param {object} [engineOpts] - engine options
+ * @returns {Promise<{ astMs: number, complexityMs: number, cfgMs: number, dataflowMs: number }>}
+ */
+export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
+  const timing = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+
+  const doAst = opts.ast !== false;
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  const doDataflow = opts.dataflow !== false;
+
+  if (!doAst && !doComplexity && !doCfg && !doDataflow) return timing;
+
+  const extToLang = buildExtToLangMap();
+
+  // WASM pre-parse for files that need it
+  await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
+
+  // Unified pre-walk: run all applicable visitors in a single DFS per file
+  const t0walk = performance.now();
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (!symbols._tree) continue;
+
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || extToLang.get(ext);
+    if (!langId) continue;
+
+    const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
+      setupVisitors(db, relPath, symbols, langId, opts);
+
+    if (visitors.length === 0) continue;
+
+    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+    const defs = symbols.definitions || [];
+
+    if (astVisitor) {
+      const astRows = results['ast-store'] || [];
+      if (astRows.length > 0) symbols.astNodes = astRows;
+    }
+
+    if (complexityVisitor) storeComplexityResults(results, defs, langId);
+    if (cfgVisitor) storeCfgResults(results, defs);
+    if (dataflowVisitor) symbols.dataflow = results.dataflow;
+  }
+
+  timing._unifiedWalkMs = performance.now() - t0walk;
+
+  // Delegate to buildXxx functions for DB writes + native fallback
+  await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
 
   return timing;
 }
diff --git a/src/ast-analysis/visitors/cfg-visitor.js b/src/ast-analysis/visitors/cfg-visitor.js
index 1fb1de50..97bb344f 100644
--- a/src/ast-analysis/visitors/cfg-visitor.js
+++ b/src/ast-analysis/visitors/cfg-visitor.js
@@ -10,756 +10,746 @@
  * hooks, using a control-flow frame stack to track branch/loop/switch context.
  */
 
-/**
- * Create a CFG visitor for use with walkWithVisitors.
- *
- * @param {object} cfgRules - CFG_RULES for the language
- * @returns {Visitor}
- */
-export function createCfgVisitor(cfgRules) {
-  // ── Per-function state ──────────────────────────────────────────────
-  // Pushed/popped on enterFunction/exitFunction for nested function support.
-
-  /** @type {Array<object>} Stack of per-function CFG state */
-  const funcStateStack = [];
-
-  /** @type {object|null} Active per-function state */
-  let S = null;
-
-  // Collected results (one per top-level function)
-  const results = [];
-
-  function makeFuncState() {
-    const blocks = [];
-    const edges = [];
-    let nextIndex = 0;
-
-    function makeBlock(type, startLine = null, endLine = null, label = null) {
-      const block = { index: nextIndex++, type, startLine, endLine, label };
-      blocks.push(block);
-      return block;
-    }
-
-    function addEdge(source, target, kind) {
-      edges.push({ sourceIndex: source.index, targetIndex: target.index, kind });
-    }
+// ── Node-type predicates ────────────────────────────────────────────────
 
-    const entry = makeBlock('entry');
-    const exit = makeBlock('exit');
-    const firstBody = makeBlock('body');
-    addEdge(entry, firstBody, 'fallthrough');
-
-    return {
-      blocks,
-      edges,
-      makeBlock,
-      addEdge,
-      entryBlock: entry,
-      exitBlock: exit,
-      currentBlock: firstBody,
-      loopStack: [],
-      labelMap: new Map(),
-      /** Control-flow frame stack for nested if/switch/try/loop/labeled */
-      cfgStack: [],
-      funcNode: null,
-    };
-  }
-
-  // ── Helpers ─────────────────────────────────────────────────────────
+function isIfNode(type, cfgRules) {
+  return type === cfgRules.ifNode || cfgRules.ifNodes?.has(type);
+}
 
-  function isIfNode(type) {
-    return type === cfgRules.ifNode || cfgRules.ifNodes?.has(type);
-  }
+function isForNode(type, cfgRules) {
+  return cfgRules.forNodes.has(type);
+}
 
-  function isForNode(type) {
-    return cfgRules.forNodes.has(type);
-  }
+function isWhileNode(type, cfgRules) {
+  return type === cfgRules.whileNode || cfgRules.whileNodes?.has(type);
+}
 
-  function isWhileNode(type) {
-    return type === cfgRules.whileNode || cfgRules.whileNodes?.has(type);
-  }
+function isSwitchNode(type, cfgRules) {
+  return type === cfgRules.switchNode || cfgRules.switchNodes?.has(type);
+}
 
-  function isSwitchNode(type) {
-    return type === cfgRules.switchNode || cfgRules.switchNodes?.has(type);
-  }
+function isCaseNode(type, cfgRules) {
+  return (
+    type === cfgRules.caseNode || type === cfgRules.defaultNode || cfgRules.caseNodes?.has(type)
+  );
+}
 
-  function isCaseNode(type) {
-    return (
-      type === cfgRules.caseNode || type === cfgRules.defaultNode || cfgRules.caseNodes?.has(type)
-    );
-  }
+function isBlockNode(type, cfgRules) {
+  return type === 'statement_list' || type === cfgRules.blockNode || cfgRules.blockNodes?.has(type);
+}
 
-  function isBlockNode(type) {
-    return (
-      type === 'statement_list' || type === cfgRules.blockNode || cfgRules.blockNodes?.has(type)
-    );
-  }
+/** Check if a node is a control-flow statement that we handle specially */
+function isControlFlow(type, cfgRules) {
+  return (
+    isIfNode(type, cfgRules) ||
+    (cfgRules.unlessNode && type === cfgRules.unlessNode) ||
+    isForNode(type, cfgRules) ||
+    isWhileNode(type, cfgRules) ||
+    (cfgRules.untilNode && type === cfgRules.untilNode) ||
+    (cfgRules.doNode && type === cfgRules.doNode) ||
+    (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) ||
+    isSwitchNode(type, cfgRules) ||
+    (cfgRules.tryNode && type === cfgRules.tryNode) ||
+    type === cfgRules.returnNode ||
+    type === cfgRules.throwNode ||
+    type === cfgRules.breakNode ||
+    type === cfgRules.continueNode ||
+    type === cfgRules.labeledNode
+  );
+}
 
-  /** Check if a node is a control-flow statement that we handle specially */
-  function isControlFlow(type) {
-    return (
-      isIfNode(type) ||
-      (cfgRules.unlessNode && type === cfgRules.unlessNode) ||
-      isForNode(type) ||
-      isWhileNode(type) ||
-      (cfgRules.untilNode && type === cfgRules.untilNode) ||
-      (cfgRules.doNode && type === cfgRules.doNode) ||
-      (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) ||
-      isSwitchNode(type) ||
-      (cfgRules.tryNode && type === cfgRules.tryNode) ||
-      type === cfgRules.returnNode ||
-      type === cfgRules.throwNode ||
-      type === cfgRules.breakNode ||
-      type === cfgRules.continueNode ||
-      type === cfgRules.labeledNode
-    );
-  }
+// ── Utility functions ───────────────────────────────────────────────────
 
-  /**
-   * Get the actual control-flow node (unwrapping expression_statement if needed).
-   */
-  function effectiveNode(node) {
-    if (node.type === 'expression_statement' && node.namedChildCount === 1) {
-      const inner = node.namedChild(0);
-      if (isControlFlow(inner.type)) return inner;
-    }
-    return node;
+/**
+ * Get the actual control-flow node (unwrapping expression_statement if needed).
+ */
+function effectiveNode(node, cfgRules) {
+  if (node.type === 'expression_statement' && node.namedChildCount === 1) {
+    const inner = node.namedChild(0);
+    if (isControlFlow(inner.type, cfgRules)) return inner;
   }
+  return node;
+}
 
-  /**
-   * Register a loop/switch in label map for labeled break/continue.
-   */
-  function registerLabelCtx(headerBlock, exitBlock) {
-    for (const [, ctx] of S.labelMap) {
-      if (!ctx.headerBlock) {
-        ctx.headerBlock = headerBlock;
-        ctx.exitBlock = exitBlock;
-      }
+/**
+ * Register a loop/switch in label map for labeled break/continue.
+ */
+function registerLabelCtx(S, headerBlock, exitBlock) {
+  for (const [, ctx] of S.labelMap) {
+    if (!ctx.headerBlock) {
+      ctx.headerBlock = headerBlock;
+      ctx.exitBlock = exitBlock;
     }
   }
+}
 
-  /**
-   * Get statements from a body node (block or single statement).
-   * Returns effective (unwrapped) nodes.
-   */
-  function getBodyStatements(bodyNode) {
-    if (!bodyNode) return [];
-    if (isBlockNode(bodyNode.type)) {
-      const stmts = [];
-      for (let i = 0; i < bodyNode.namedChildCount; i++) {
-        const child = bodyNode.namedChild(i);
-        if (child.type === 'statement_list') {
-          for (let j = 0; j < child.namedChildCount; j++) {
-            stmts.push(child.namedChild(j));
-          }
-        } else {
-          stmts.push(child);
+/**
+ * Get statements from a body node (block or single statement).
+ * Returns effective (unwrapped) nodes.
+ */
+function getBodyStatements(bodyNode, cfgRules) {
+  if (!bodyNode) return [];
+  if (isBlockNode(bodyNode.type, cfgRules)) {
+    const stmts = [];
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+      const child = bodyNode.namedChild(i);
+      if (child.type === 'statement_list') {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          stmts.push(child.namedChild(j));
         }
+      } else {
+        stmts.push(child);
       }
-      return stmts;
     }
-    return [bodyNode];
+    return stmts;
   }
+  return [bodyNode];
+}
 
-  // ── Statement-level processing (replicates buildFunctionCFG logic) ──
-  // The visitor delegates to these for each control-flow construct,
-  // processing the body statements sequentially just like the original.
+function makeFuncState() {
+  const blocks = [];
+  const edges = [];
+  let nextIndex = 0;
 
-  function processStatements(stmts, currentBlock) {
-    let cur = currentBlock;
-    for (const stmt of stmts) {
-      if (!cur) break;
-      cur = processStatement(stmt, cur);
-    }
-    return cur;
+  function makeBlock(type, startLine = null, endLine = null, label = null) {
+    const block = { index: nextIndex++, type, startLine, endLine, label };
+    blocks.push(block);
+    return block;
   }
 
-  function processStatement(stmt, currentBlock) {
-    if (!stmt || !currentBlock) return currentBlock;
+  function addEdge(source, target, kind) {
+    edges.push({ sourceIndex: source.index, targetIndex: target.index, kind });
+  }
 
-    // Unwrap expression_statement for Rust-style control flow expressions
-    const effNode = effectiveNode(stmt);
-    const type = effNode.type;
+  const entry = makeBlock('entry');
+  const exit = makeBlock('exit');
+  const firstBody = makeBlock('body');
+  addEdge(entry, firstBody, 'fallthrough');
 
-    // Labeled statement
-    if (type === cfgRules.labeledNode) {
-      return processLabeled(effNode, currentBlock);
-    }
+  return {
+    blocks,
+    edges,
+    makeBlock,
+    addEdge,
+    entryBlock: entry,
+    exitBlock: exit,
+    currentBlock: firstBody,
+    loopStack: [],
+    labelMap: new Map(),
+    cfgStack: [],
+    funcNode: null,
+  };
+}
 
-    // If / unless
-    if (isIfNode(type) || (cfgRules.unlessNode && type === cfgRules.unlessNode)) {
-      return processIf(effNode, currentBlock);
-    }
+// ── Statement processors ────────────────────────────────────────────────
 
-    // For loops
-    if (isForNode(type)) {
-      return processForLoop(effNode, currentBlock);
-    }
+function processStatements(stmts, currentBlock, S, cfgRules) {
+  let cur = currentBlock;
+  for (const stmt of stmts) {
+    if (!cur) break;
+    cur = processStatement(stmt, cur, S, cfgRules);
+  }
+  return cur;
+}
 
-    // While / until
-    if (isWhileNode(type) || (cfgRules.untilNode && type === cfgRules.untilNode)) {
-      return processWhileLoop(effNode, currentBlock);
-    }
+function processStatement(stmt, currentBlock, S, cfgRules) {
+  if (!stmt || !currentBlock) return currentBlock;
 
-    // Do-while
-    if (cfgRules.doNode && type === cfgRules.doNode) {
-      return processDoWhileLoop(effNode, currentBlock);
-    }
+  const effNode = effectiveNode(stmt, cfgRules);
+  const type = effNode.type;
 
-    // Infinite loop (Rust)
-    if (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) {
-      return processInfiniteLoop(effNode, currentBlock);
-    }
+  if (type === cfgRules.labeledNode) {
+    return processLabeled(effNode, currentBlock, S, cfgRules);
+  }
+  if (isIfNode(type, cfgRules) || (cfgRules.unlessNode && type === cfgRules.unlessNode)) {
+    return processIf(effNode, currentBlock, S, cfgRules);
+  }
+  if (isForNode(type, cfgRules)) {
+    return processForLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (isWhileNode(type, cfgRules) || (cfgRules.untilNode && type === cfgRules.untilNode)) {
+    return processWhileLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.doNode && type === cfgRules.doNode) {
+    return processDoWhileLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) {
+    return processInfiniteLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (isSwitchNode(type, cfgRules)) {
+    return processSwitch(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.tryNode && type === cfgRules.tryNode) {
+    return processTryCatch(effNode, currentBlock, S, cfgRules);
+  }
+  if (type === cfgRules.returnNode) {
+    currentBlock.endLine = effNode.startPosition.row + 1;
+    S.addEdge(currentBlock, S.exitBlock, 'return');
+    return null;
+  }
+  if (type === cfgRules.throwNode) {
+    currentBlock.endLine = effNode.startPosition.row + 1;
+    S.addEdge(currentBlock, S.exitBlock, 'exception');
+    return null;
+  }
+  if (type === cfgRules.breakNode) {
+    return processBreak(effNode, currentBlock, S);
+  }
+  if (type === cfgRules.continueNode) {
+    return processContinue(effNode, currentBlock, S);
+  }
 
-    // Switch / match
-    if (isSwitchNode(type)) {
-      return processSwitch(effNode, currentBlock);
-    }
+  // Regular statement — extend current block
+  if (!currentBlock.startLine) {
+    currentBlock.startLine = stmt.startPosition.row + 1;
+  }
+  currentBlock.endLine = stmt.endPosition.row + 1;
+  return currentBlock;
+}
 
-    // Try/catch/finally
-    if (cfgRules.tryNode && type === cfgRules.tryNode) {
-      return processTryCatch(effNode, currentBlock);
-    }
+// ── Labeled / break / continue ──────────────────────────────────────────
+
+function processLabeled(node, currentBlock, S, cfgRules) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
+  const body = node.childForFieldName('body');
+  if (body && labelName) {
+    const labelCtx = { headerBlock: null, exitBlock: null };
+    S.labelMap.set(labelName, labelCtx);
+    const result = processStatement(body, currentBlock, S, cfgRules);
+    S.labelMap.delete(labelName);
+    return result;
+  }
+  return currentBlock;
+}
 
-    // Return
-    if (type === cfgRules.returnNode) {
-      currentBlock.endLine = effNode.startPosition.row + 1;
-      S.addEdge(currentBlock, S.exitBlock, 'return');
-      return null;
-    }
+function processBreak(node, currentBlock, S) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
 
-    // Throw
-    if (type === cfgRules.throwNode) {
-      currentBlock.endLine = effNode.startPosition.row + 1;
-      S.addEdge(currentBlock, S.exitBlock, 'exception');
-      return null;
-    }
+  let target = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = S.labelMap.get(labelName).exitBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1].exitBlock;
+  }
 
-    // Break
-    if (type === cfgRules.breakNode) {
-      return processBreak(effNode, currentBlock);
-    }
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'break');
+    return null;
+  }
+  return currentBlock;
+}
 
-    // Continue
-    if (type === cfgRules.continueNode) {
-      return processContinue(effNode, currentBlock);
-    }
+function processContinue(node, currentBlock, S) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
 
-    // Regular statement — extend current block
-    if (!currentBlock.startLine) {
-      currentBlock.startLine = stmt.startPosition.row + 1;
-    }
-    currentBlock.endLine = stmt.endPosition.row + 1;
-    return currentBlock;
-  }
-
-  function processLabeled(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
-    const body = node.childForFieldName('body');
-    if (body && labelName) {
-      const labelCtx = { headerBlock: null, exitBlock: null };
-      S.labelMap.set(labelName, labelCtx);
-      const result = processStatement(body, currentBlock);
-      S.labelMap.delete(labelName);
-      return result;
-    }
-    return currentBlock;
+  let target = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = S.labelMap.get(labelName).headerBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1].headerBlock;
   }
 
-  function processBreak(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'continue');
+    return null;
+  }
+  return currentBlock;
+}
 
-    let target = null;
-    if (labelName && S.labelMap.has(labelName)) {
-      target = S.labelMap.get(labelName).exitBlock;
-    } else if (S.loopStack.length > 0) {
-      target = S.loopStack[S.loopStack.length - 1].exitBlock;
-    }
+// ── If / else-if / else ─────────────────────────────────────────────────
+
+function processIf(ifStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = ifStmt.startPosition.row + 1;
+
+  const condBlock = S.makeBlock(
+    'condition',
+    ifStmt.startPosition.row + 1,
+    ifStmt.startPosition.row + 1,
+    'if',
+  );
+  S.addEdge(currentBlock, condBlock, 'fallthrough');
+
+  const joinBlock = S.makeBlock('body');
+
+  // True branch
+  const consequentField = cfgRules.ifConsequentField || 'consequence';
+  const consequent = ifStmt.childForFieldName(consequentField);
+  const trueBlock = S.makeBlock('branch_true', null, null, 'then');
+  S.addEdge(condBlock, trueBlock, 'branch_true');
+  const trueStmts = getBodyStatements(consequent, cfgRules);
+  const trueEnd = processStatements(trueStmts, trueBlock, S, cfgRules);
+  if (trueEnd) {
+    S.addEdge(trueEnd, joinBlock, 'fallthrough');
+  }
 
-    if (target) {
-      currentBlock.endLine = node.startPosition.row + 1;
-      S.addEdge(currentBlock, target, 'break');
-      return null;
-    }
-    return currentBlock;
+  // False branch
+  if (cfgRules.elifNode) {
+    processElifSiblings(ifStmt, condBlock, joinBlock, S, cfgRules);
+  } else {
+    processAlternative(ifStmt, condBlock, joinBlock, S, cfgRules);
   }
 
-  function processContinue(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
+  return joinBlock;
+}
 
-    let target = null;
-    if (labelName && S.labelMap.has(labelName)) {
-      target = S.labelMap.get(labelName).headerBlock;
-    } else if (S.loopStack.length > 0) {
-      target = S.loopStack[S.loopStack.length - 1].headerBlock;
-    }
+function processAlternative(ifStmt, condBlock, joinBlock, S, cfgRules) {
+  const alternative = ifStmt.childForFieldName('alternative');
+  if (!alternative) {
+    S.addEdge(condBlock, joinBlock, 'branch_false');
+    return;
+  }
 
-    if (target) {
-      currentBlock.endLine = node.startPosition.row + 1;
-      S.addEdge(currentBlock, target, 'continue');
-      return null;
+  if (cfgRules.elseViaAlternative && alternative.type !== cfgRules.elseClause) {
+    // Pattern C: direct alternative (Go, Java, C#)
+    if (isIfNode(alternative.type, cfgRules)) {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const elseIfEnd = processIf(alternative, falseBlock, S, cfgRules);
+      if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
+    } else {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const falseStmts = getBodyStatements(alternative, cfgRules);
+      const falseEnd = processStatements(falseStmts, falseBlock, S, cfgRules);
+      if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
+    }
+  } else if (alternative.type === cfgRules.elseClause) {
+    // Pattern A: else_clause wrapper (JS/TS, Rust)
+    const elseChildren = [];
+    for (let i = 0; i < alternative.namedChildCount; i++) {
+      elseChildren.push(alternative.namedChild(i));
+    }
+    if (elseChildren.length === 1 && isIfNode(elseChildren[0].type, cfgRules)) {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const elseIfEnd = processIf(elseChildren[0], falseBlock, S, cfgRules);
+      if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
+    } else {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const falseEnd = processStatements(elseChildren, falseBlock, S, cfgRules);
+      if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
     }
-    return currentBlock;
   }
+}
 
-  // ── If/else-if/else ─────────────────────────────────────────────────
-
-  function processIf(ifStmt, currentBlock) {
-    currentBlock.endLine = ifStmt.startPosition.row + 1;
+function processElifSiblings(ifStmt, firstCondBlock, joinBlock, S, cfgRules) {
+  let lastCondBlock = firstCondBlock;
+  let foundElse = false;
 
-    const condBlock = S.makeBlock(
-      'condition',
-      ifStmt.startPosition.row + 1,
-      ifStmt.startPosition.row + 1,
-      'if',
-    );
-    S.addEdge(currentBlock, condBlock, 'fallthrough');
-
-    const joinBlock = S.makeBlock('body');
-
-    // True branch
-    const consequentField = cfgRules.ifConsequentField || 'consequence';
-    const consequent = ifStmt.childForFieldName(consequentField);
-    const trueBlock = S.makeBlock('branch_true', null, null, 'then');
-    S.addEdge(condBlock, trueBlock, 'branch_true');
-    const trueStmts = getBodyStatements(consequent);
-    const trueEnd = processStatements(trueStmts, trueBlock);
-    if (trueEnd) {
-      S.addEdge(trueEnd, joinBlock, 'fallthrough');
-    }
+  for (let i = 0; i < ifStmt.namedChildCount; i++) {
+    const child = ifStmt.namedChild(i);
 
-    // False branch
-    if (cfgRules.elifNode) {
-      processElifSiblings(ifStmt, condBlock, joinBlock);
-    } else {
-      const alternative = ifStmt.childForFieldName('alternative');
-      if (alternative) {
-        if (cfgRules.elseViaAlternative && alternative.type !== cfgRules.elseClause) {
-          // Pattern C: direct alternative (Go, Java, C#)
-          if (isIfNode(alternative.type)) {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const elseIfEnd = processIf(alternative, falseBlock);
-            if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
-          } else {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const falseStmts = getBodyStatements(alternative);
-            const falseEnd = processStatements(falseStmts, falseBlock);
-            if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
-          }
-        } else if (alternative.type === cfgRules.elseClause) {
-          // Pattern A: else_clause wrapper (JS/TS, Rust)
-          const elseChildren = [];
-          for (let i = 0; i < alternative.namedChildCount; i++) {
-            elseChildren.push(alternative.namedChild(i));
-          }
-          if (elseChildren.length === 1 && isIfNode(elseChildren[0].type)) {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const elseIfEnd = processIf(elseChildren[0], falseBlock);
-            if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
-          } else {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const falseEnd = processStatements(elseChildren, falseBlock);
-            if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
-          }
-        }
+    if (child.type === cfgRules.elifNode) {
+      const elifCondBlock = S.makeBlock(
+        'condition',
+        child.startPosition.row + 1,
+        child.startPosition.row + 1,
+        'else-if',
+      );
+      S.addEdge(lastCondBlock, elifCondBlock, 'branch_false');
+
+      const elifConsequentField = cfgRules.ifConsequentField || 'consequence';
+      const elifConsequent = child.childForFieldName(elifConsequentField);
+      const elifTrueBlock = S.makeBlock('branch_true', null, null, 'then');
+      S.addEdge(elifCondBlock, elifTrueBlock, 'branch_true');
+      const elifTrueStmts = getBodyStatements(elifConsequent, cfgRules);
+      const elifTrueEnd = processStatements(elifTrueStmts, elifTrueBlock, S, cfgRules);
+      if (elifTrueEnd) S.addEdge(elifTrueEnd, joinBlock, 'fallthrough');
+
+      lastCondBlock = elifCondBlock;
+    } else if (child.type === cfgRules.elseClause) {
+      const elseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(lastCondBlock, elseBlock, 'branch_false');
+
+      const elseBody = child.childForFieldName('body');
+      let elseStmts;
+      if (elseBody) {
+        elseStmts = getBodyStatements(elseBody, cfgRules);
       } else {
-        // No else
-        S.addEdge(condBlock, joinBlock, 'branch_false');
-      }
-    }
-
-    return joinBlock;
-  }
-
-  function processElifSiblings(ifStmt, firstCondBlock, joinBlock) {
-    let lastCondBlock = firstCondBlock;
-    let foundElse = false;
-
-    for (let i = 0; i < ifStmt.namedChildCount; i++) {
-      const child = ifStmt.namedChild(i);
-
-      if (child.type === cfgRules.elifNode) {
-        const elifCondBlock = S.makeBlock(
-          'condition',
-          child.startPosition.row + 1,
-          child.startPosition.row + 1,
-          'else-if',
-        );
-        S.addEdge(lastCondBlock, elifCondBlock, 'branch_false');
-
-        const elifConsequentField = cfgRules.ifConsequentField || 'consequence';
-        const elifConsequent = child.childForFieldName(elifConsequentField);
-        const elifTrueBlock = S.makeBlock('branch_true', null, null, 'then');
-        S.addEdge(elifCondBlock, elifTrueBlock, 'branch_true');
-        const elifTrueStmts = getBodyStatements(elifConsequent);
-        const elifTrueEnd = processStatements(elifTrueStmts, elifTrueBlock);
-        if (elifTrueEnd) S.addEdge(elifTrueEnd, joinBlock, 'fallthrough');
-
-        lastCondBlock = elifCondBlock;
-      } else if (child.type === cfgRules.elseClause) {
-        const elseBlock = S.makeBlock('branch_false', null, null, 'else');
-        S.addEdge(lastCondBlock, elseBlock, 'branch_false');
-
-        const elseBody = child.childForFieldName('body');
-        let elseStmts;
-        if (elseBody) {
-          elseStmts = getBodyStatements(elseBody);
-        } else {
-          elseStmts = [];
-          for (let j = 0; j < child.namedChildCount; j++) {
-            elseStmts.push(child.namedChild(j));
-          }
+        elseStmts = [];
+        for (let j = 0; j < child.namedChildCount; j++) {
+          elseStmts.push(child.namedChild(j));
         }
-        const elseEnd = processStatements(elseStmts, elseBlock);
-        if (elseEnd) S.addEdge(elseEnd, joinBlock, 'fallthrough');
-
-        foundElse = true;
       }
-    }
+      const elseEnd = processStatements(elseStmts, elseBlock, S, cfgRules);
+      if (elseEnd) S.addEdge(elseEnd, joinBlock, 'fallthrough');
 
-    if (!foundElse) {
-      S.addEdge(lastCondBlock, joinBlock, 'branch_false');
+      foundElse = true;
     }
   }
 
-  // ── Loops ───────────────────────────────────────────────────────────
-
-  function processForLoop(forStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      forStmt.startPosition.row + 1,
-      forStmt.startPosition.row + 1,
-      'for',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
-
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+  if (!foundElse) {
+    S.addEdge(lastCondBlock, joinBlock, 'branch_false');
+  }
+}
 
-    const body = forStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+// ── Loops ───────────────────────────────────────────────────────────────
+
+function processForLoop(forStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    forStmt.startPosition.row + 1,
+    forStmt.startPosition.row + 1,
+    'for',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = forStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+function processWhileLoop(whileStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    whileStmt.startPosition.row + 1,
+    whileStmt.startPosition.row + 1,
+    'while',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = whileStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+function processDoWhileLoop(doStmt, currentBlock, S, cfgRules) {
+  const bodyBlock = S.makeBlock('loop_body', doStmt.startPosition.row + 1, null, 'do');
+  S.addEdge(currentBlock, bodyBlock, 'fallthrough');
 
-  function processWhileLoop(whileStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      whileStmt.startPosition.row + 1,
-      whileStmt.startPosition.row + 1,
-      'while',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
+  const condBlock = S.makeBlock('loop_header', null, null, 'do-while');
+  const loopExitBlock = S.makeBlock('body');
 
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+  const loopCtx = { headerBlock: condBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, condBlock, loopExitBlock);
 
-    const body = whileStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+  const body = doStmt.childForFieldName('body');
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, condBlock, 'fallthrough');
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+  S.addEdge(condBlock, bodyBlock, 'loop_back');
+  S.addEdge(condBlock, loopExitBlock, 'loop_exit');
 
-    S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-  function processDoWhileLoop(doStmt, currentBlock) {
-    const bodyBlock = S.makeBlock('loop_body', doStmt.startPosition.row + 1, null, 'do');
-    S.addEdge(currentBlock, bodyBlock, 'fallthrough');
+function processInfiniteLoop(loopStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    loopStmt.startPosition.row + 1,
+    loopStmt.startPosition.row + 1,
+    'loop',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = loopStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  // No loop_exit from header — only via break
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    const condBlock = S.makeBlock('loop_header', null, null, 'do-while');
-    const loopExitBlock = S.makeBlock('body');
+// ── Switch / match ──────────────────────────────────────────────────────
 
-    const loopCtx = { headerBlock: condBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(condBlock, loopExitBlock);
+function processSwitch(switchStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = switchStmt.startPosition.row + 1;
 
-    const body = doStmt.childForFieldName('body');
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, condBlock, 'fallthrough');
+  const switchHeader = S.makeBlock(
+    'condition',
+    switchStmt.startPosition.row + 1,
+    switchStmt.startPosition.row + 1,
+    'switch',
+  );
+  S.addEdge(currentBlock, switchHeader, 'fallthrough');
 
-    S.addEdge(condBlock, bodyBlock, 'loop_back');
-    S.addEdge(condBlock, loopExitBlock, 'loop_exit');
+  const joinBlock = S.makeBlock('body');
+  const switchCtx = { headerBlock: switchHeader, exitBlock: joinBlock };
+  S.loopStack.push(switchCtx);
 
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+  const switchBody = switchStmt.childForFieldName('body');
+  const container = switchBody || switchStmt;
 
-  function processInfiniteLoop(loopStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      loopStmt.startPosition.row + 1,
-      loopStmt.startPosition.row + 1,
-      'loop',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
+  let hasDefault = false;
+  for (let i = 0; i < container.namedChildCount; i++) {
+    const caseClause = container.namedChild(i);
 
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+    const isDefault = caseClause.type === cfgRules.defaultNode;
+    const isCase = isDefault || isCaseNode(caseClause.type, cfgRules);
+    if (!isCase) continue;
 
-    const body = loopStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+    const caseLabel = isDefault ? 'default' : 'case';
+    const caseBlock = S.makeBlock('case', caseClause.startPosition.row + 1, null, caseLabel);
+    S.addEdge(switchHeader, caseBlock, isDefault ? 'branch_false' : 'branch_true');
+    if (isDefault) hasDefault = true;
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+    const caseStmts = extractCaseBody(caseClause, cfgRules);
+    const caseEnd = processStatements(caseStmts, caseBlock, S, cfgRules);
+    if (caseEnd) S.addEdge(caseEnd, joinBlock, 'fallthrough');
+  }
 
-    // No loop_exit from header — only via break
-    S.loopStack.pop();
-    return loopExitBlock;
+  if (!hasDefault) {
+    S.addEdge(switchHeader, joinBlock, 'branch_false');
   }
 
-  // ── Switch / match ──────────────────────────────────────────────────
+  S.loopStack.pop();
+  return joinBlock;
+}
 
-  function processSwitch(switchStmt, currentBlock) {
-    currentBlock.endLine = switchStmt.startPosition.row + 1;
+function extractCaseBody(caseClause, cfgRules) {
+  const caseBodyNode =
+    caseClause.childForFieldName('body') || caseClause.childForFieldName('consequence');
+  if (caseBodyNode) {
+    return getBodyStatements(caseBodyNode, cfgRules);
+  }
 
-    const switchHeader = S.makeBlock(
-      'condition',
-      switchStmt.startPosition.row + 1,
-      switchStmt.startPosition.row + 1,
-      'switch',
-    );
-    S.addEdge(currentBlock, switchHeader, 'fallthrough');
-
-    const joinBlock = S.makeBlock('body');
-    const switchCtx = { headerBlock: switchHeader, exitBlock: joinBlock };
-    S.loopStack.push(switchCtx);
-
-    const switchBody = switchStmt.childForFieldName('body');
-    const container = switchBody || switchStmt;
-
-    let hasDefault = false;
-    for (let i = 0; i < container.namedChildCount; i++) {
-      const caseClause = container.namedChild(i);
-
-      const isDefault = caseClause.type === cfgRules.defaultNode;
-      const isCase = isDefault || isCaseNode(caseClause.type);
-      if (!isCase) continue;
-
-      const caseLabel = isDefault ? 'default' : 'case';
-      const caseBlock = S.makeBlock('case', caseClause.startPosition.row + 1, null, caseLabel);
-      S.addEdge(switchHeader, caseBlock, isDefault ? 'branch_false' : 'branch_true');
-      if (isDefault) hasDefault = true;
-
-      // Extract case body
-      const caseBodyNode =
-        caseClause.childForFieldName('body') || caseClause.childForFieldName('consequence');
-      let caseStmts;
-      if (caseBodyNode) {
-        caseStmts = getBodyStatements(caseBodyNode);
-      } else {
-        caseStmts = [];
-        const valueNode = caseClause.childForFieldName('value');
-        const patternNode = caseClause.childForFieldName('pattern');
-        for (let j = 0; j < caseClause.namedChildCount; j++) {
-          const child = caseClause.namedChild(j);
-          if (child !== valueNode && child !== patternNode && child.type !== 'switch_label') {
-            if (child.type === 'statement_list') {
-              for (let k = 0; k < child.namedChildCount; k++) {
-                caseStmts.push(child.namedChild(k));
-              }
-            } else {
-              caseStmts.push(child);
-            }
-          }
+  const stmts = [];
+  const valueNode = caseClause.childForFieldName('value');
+  const patternNode = caseClause.childForFieldName('pattern');
+  for (let j = 0; j < caseClause.namedChildCount; j++) {
+    const child = caseClause.namedChild(j);
+    if (child !== valueNode && child !== patternNode && child.type !== 'switch_label') {
+      if (child.type === 'statement_list') {
+        for (let k = 0; k < child.namedChildCount; k++) {
+          stmts.push(child.namedChild(k));
         }
+      } else {
+        stmts.push(child);
       }
-
-      const caseEnd = processStatements(caseStmts, caseBlock);
-      if (caseEnd) S.addEdge(caseEnd, joinBlock, 'fallthrough');
     }
+  }
+  return stmts;
+}
 
-    if (!hasDefault) {
-      S.addEdge(switchHeader, joinBlock, 'branch_false');
-    }
+// ── Try / catch / finally ───────────────────────────────────────────────
+
+function processTryCatch(tryStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = tryStmt.startPosition.row + 1;
 
-    S.loopStack.pop();
-    return joinBlock;
+  const joinBlock = S.makeBlock('body');
+
+  // Try body
+  const tryBody = tryStmt.childForFieldName('body');
+  let tryBodyStart;
+  let tryStmts;
+  if (tryBody) {
+    tryBodyStart = tryBody.startPosition.row + 1;
+    tryStmts = getBodyStatements(tryBody, cfgRules);
+  } else {
+    tryBodyStart = tryStmt.startPosition.row + 1;
+    tryStmts = [];
+    for (let i = 0; i < tryStmt.namedChildCount; i++) {
+      const child = tryStmt.namedChild(i);
+      if (cfgRules.catchNode && child.type === cfgRules.catchNode) continue;
+      if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) continue;
+      tryStmts.push(child);
+    }
   }
 
-  // ── Try/catch/finally ───────────────────────────────────────────────
+  const tryBlock = S.makeBlock('body', tryBodyStart, null, 'try');
+  S.addEdge(currentBlock, tryBlock, 'fallthrough');
+  const tryEnd = processStatements(tryStmts, tryBlock, S, cfgRules);
 
-  function processTryCatch(tryStmt, currentBlock) {
-    currentBlock.endLine = tryStmt.startPosition.row + 1;
+  // Find catch and finally handlers
+  const { catchHandler, finallyHandler } = findTryHandlers(tryStmt, cfgRules);
 
-    const joinBlock = S.makeBlock('body');
+  if (catchHandler) {
+    processCatchHandler(catchHandler, tryBlock, tryEnd, finallyHandler, joinBlock, S, cfgRules);
+  } else if (finallyHandler) {
+    processFinallyOnly(finallyHandler, tryEnd, joinBlock, S, cfgRules);
+  } else {
+    if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
+  }
 
-    // Try body
-    const tryBody = tryStmt.childForFieldName('body');
-    let tryBodyStart;
-    let tryStmts;
-    if (tryBody) {
-      tryBodyStart = tryBody.startPosition.row + 1;
-      tryStmts = getBodyStatements(tryBody);
-    } else {
-      tryBodyStart = tryStmt.startPosition.row + 1;
-      tryStmts = [];
-      for (let i = 0; i < tryStmt.namedChildCount; i++) {
-        const child = tryStmt.namedChild(i);
-        if (cfgRules.catchNode && child.type === cfgRules.catchNode) continue;
-        if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) continue;
-        tryStmts.push(child);
-      }
-    }
+  return joinBlock;
+}
 
-    const tryBlock = S.makeBlock('body', tryBodyStart, null, 'try');
-    S.addEdge(currentBlock, tryBlock, 'fallthrough');
-    const tryEnd = processStatements(tryStmts, tryBlock);
+function findTryHandlers(tryStmt, cfgRules) {
+  let catchHandler = null;
+  let finallyHandler = null;
+  for (let i = 0; i < tryStmt.namedChildCount; i++) {
+    const child = tryStmt.namedChild(i);
+    if (cfgRules.catchNode && child.type === cfgRules.catchNode) catchHandler = child;
+    if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) finallyHandler = child;
+  }
+  return { catchHandler, finallyHandler };
+}
 
-    // Find catch and finally handlers
-    let catchHandler = null;
-    let finallyHandler = null;
-    for (let i = 0; i < tryStmt.namedChildCount; i++) {
-      const child = tryStmt.namedChild(i);
-      if (cfgRules.catchNode && child.type === cfgRules.catchNode) catchHandler = child;
-      if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) finallyHandler = child;
+function processCatchHandler(
+  catchHandler,
+  tryBlock,
+  tryEnd,
+  finallyHandler,
+  joinBlock,
+  S,
+  cfgRules,
+) {
+  const catchBlock = S.makeBlock('catch', catchHandler.startPosition.row + 1, null, 'catch');
+  S.addEdge(tryBlock, catchBlock, 'exception');
+
+  const catchBodyNode = catchHandler.childForFieldName('body');
+  let catchStmts;
+  if (catchBodyNode) {
+    catchStmts = getBodyStatements(catchBodyNode, cfgRules);
+  } else {
+    catchStmts = [];
+    for (let i = 0; i < catchHandler.namedChildCount; i++) {
+      catchStmts.push(catchHandler.namedChild(i));
     }
+  }
+  const catchEnd = processStatements(catchStmts, catchBlock, S, cfgRules);
+
+  if (finallyHandler) {
+    const finallyBlock = S.makeBlock(
+      'finally',
+      finallyHandler.startPosition.row + 1,
+      null,
+      'finally',
+    );
+    if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
+    if (catchEnd) S.addEdge(catchEnd, finallyBlock, 'fallthrough');
+
+    const finallyBodyNode = finallyHandler.childForFieldName('body');
+    const finallyStmts = finallyBodyNode
+      ? getBodyStatements(finallyBodyNode, cfgRules)
+      : getBodyStatements(finallyHandler, cfgRules);
+    const finallyEnd = processStatements(finallyStmts, finallyBlock, S, cfgRules);
+    if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
+  } else {
+    if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
+    if (catchEnd) S.addEdge(catchEnd, joinBlock, 'fallthrough');
+  }
+}
 
-    if (catchHandler) {
-      const catchBlock = S.makeBlock('catch', catchHandler.startPosition.row + 1, null, 'catch');
-      S.addEdge(tryBlock, catchBlock, 'exception');
+function processFinallyOnly(finallyHandler, tryEnd, joinBlock, S, cfgRules) {
+  const finallyBlock = S.makeBlock(
+    'finally',
+    finallyHandler.startPosition.row + 1,
+    null,
+    'finally',
+  );
+  if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
+
+  const finallyBodyNode = finallyHandler.childForFieldName('body');
+  const finallyStmts = finallyBodyNode
+    ? getBodyStatements(finallyBodyNode, cfgRules)
+    : getBodyStatements(finallyHandler, cfgRules);
+  const finallyEnd = processStatements(finallyStmts, finallyBlock, S, cfgRules);
+  if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
+}
 
-      const catchBodyNode = catchHandler.childForFieldName('body');
-      let catchStmts;
-      if (catchBodyNode) {
-        catchStmts = getBodyStatements(catchBodyNode);
-      } else {
-        catchStmts = [];
-        for (let i = 0; i < catchHandler.namedChildCount; i++) {
-          catchStmts.push(catchHandler.namedChild(i));
-        }
-      }
-      const catchEnd = processStatements(catchStmts, catchBlock);
-
-      if (finallyHandler) {
-        const finallyBlock = S.makeBlock(
-          'finally',
-          finallyHandler.startPosition.row + 1,
-          null,
-          'finally',
-        );
-        if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
-        if (catchEnd) S.addEdge(catchEnd, finallyBlock, 'fallthrough');
-
-        const finallyBodyNode = finallyHandler.childForFieldName('body');
-        const finallyStmts = finallyBodyNode
-          ? getBodyStatements(finallyBodyNode)
-          : getBodyStatements(finallyHandler);
-        const finallyEnd = processStatements(finallyStmts, finallyBlock);
-        if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
-      } else {
-        if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
-        if (catchEnd) S.addEdge(catchEnd, joinBlock, 'fallthrough');
-      }
-    } else if (finallyHandler) {
-      const finallyBlock = S.makeBlock(
-        'finally',
-        finallyHandler.startPosition.row + 1,
-        null,
-        'finally',
-      );
-      if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
-
-      const finallyBodyNode = finallyHandler.childForFieldName('body');
-      const finallyStmts = finallyBodyNode
-        ? getBodyStatements(finallyBodyNode)
-        : getBodyStatements(finallyHandler);
-      const finallyEnd = processStatements(finallyStmts, finallyBlock);
-      if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
-    } else {
-      if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
-    }
+// ── Enter-function body processing ──────────────────────────────────────
+
+function processFunctionBody(funcNode, S, cfgRules) {
+  const body = funcNode.childForFieldName('body');
+  if (!body) {
+    // No body — entry → exit
+    S.blocks.length = 2;
+    S.edges.length = 0;
+    S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
+  }
 
-    return joinBlock;
+  if (!isBlockNode(body.type, cfgRules)) {
+    // Expression body (e.g., arrow function `(x) => x + 1`)
+    const bodyBlock = S.blocks[2];
+    bodyBlock.startLine = body.startPosition.row + 1;
+    bodyBlock.endLine = body.endPosition.row + 1;
+    S.addEdge(bodyBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
   }
 
-  // ── Visitor interface ───────────────────────────────────────────────
+  // Block body — process statements
+  const stmts = getBodyStatements(body, cfgRules);
+  if (stmts.length === 0) {
+    S.blocks.length = 2;
+    S.edges.length = 0;
+    S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
+  }
+
+  const firstBody = S.blocks[2];
+  const lastBlock = processStatements(stmts, firstBody, S, cfgRules);
+  if (lastBlock) {
+    S.addEdge(lastBlock, S.exitBlock, 'fallthrough');
+  }
+  S.currentBlock = null;
+}
+
+// ── Visitor factory ─────────────────────────────────────────────────────
+
+/**
+ * Create a CFG visitor for use with walkWithVisitors.
+ *
+ * @param {object} cfgRules - CFG_RULES for the language
+ * @returns {Visitor}
+ */
+export function createCfgVisitor(cfgRules) {
+  const funcStateStack = [];
+  let S = null;
+  const results = [];
 
   return {
     name: 'cfg',
     functionNodeTypes: cfgRules.functionNodes,
 
     enterFunction(funcNode, _funcName, _context) {
-      if (S) {
-        // Nested function — push current state
-        funcStateStack.push(S);
-      }
+      if (S) funcStateStack.push(S);
       S = makeFuncState();
       S.funcNode = funcNode;
-
-      // Check for expression body (arrow functions): no block body
-      const body = funcNode.childForFieldName('body');
-      if (!body) {
-        // No body at all — entry → exit
-        // Remove the firstBody block and its edge
-        S.blocks.length = 2; // keep entry + exit
-        S.edges.length = 0;
-        S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null;
-        return;
-      }
-
-      if (!isBlockNode(body.type)) {
-        // Expression body (e.g., arrow function `(x) => x + 1`)
-        // entry → body → exit (body is the expression)
-        const bodyBlock = S.blocks[2]; // the firstBody we already created
-        bodyBlock.startLine = body.startPosition.row + 1;
-        bodyBlock.endLine = body.endPosition.row + 1;
-        S.addEdge(bodyBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null; // no further processing needed
-        return;
-      }
-
-      // Block body — process statements
-      const stmts = getBodyStatements(body);
-      if (stmts.length === 0) {
-        // Empty function
-        S.blocks.length = 2;
-        S.edges.length = 0;
-        S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null;
-        return;
-      }
-
-      // Process all body statements using the statement-level processor
-      const firstBody = S.blocks[2]; // the firstBody block
-      const lastBlock = processStatements(stmts, firstBody);
-      if (lastBlock) {
-        S.addEdge(lastBlock, S.exitBlock, 'fallthrough');
-      }
-      S.currentBlock = null; // done processing
+      processFunctionBody(funcNode, S, cfgRules);
     },
 
     exitFunction(funcNode, _funcName, _context) {
       if (S && S.funcNode === funcNode) {
-        // Derive cyclomatic complexity from CFG: E - N + 2
         const cyclomatic = S.edges.length - S.blocks.length + 2;
         results.push({
           funcNode: S.funcNode,
@@ -768,21 +758,17 @@ export function createCfgVisitor(cfgRules) {
           cyclomatic: Math.max(cyclomatic, 1),
         });
       }
-
-      // Pop to parent function state (if nested)
       S = funcStateStack.length > 0 ? funcStateStack.pop() : null;
     },
 
     enterNode(_node, _context) {
-      // No-op — all CFG construction is done in enterFunction via
-      // processStatements.  We intentionally do NOT return skipChildren here
-      // so that the walker still recurses into children, allowing nested
-      // function definitions to trigger enterFunction/exitFunction and get
-      // their own CFG computed via the funcStateStack.
+      // No-op — all CFG construction is done in enterFunction via processStatements.
+      // We intentionally do NOT return skipChildren so the walker recurses into
+      // children, allowing nested functions to trigger enterFunction/exitFunction.
     },
 
     exitNode(_node, _context) {
-      // No-op — all work done in enterFunction/exitFunction
+      // No-op
     },
 
     finish() {
diff --git a/src/ast-analysis/visitors/complexity-visitor.js b/src/ast-analysis/visitors/complexity-visitor.js
index df386afc..ca19c0c5 100644
--- a/src/ast-analysis/visitors/complexity-visitor.js
+++ b/src/ast-analysis/visitors/complexity-visitor.js
@@ -12,6 +12,122 @@ import {
   computeMaintainabilityIndex,
 } from '../metrics.js';
 
+// ── Halstead classification ─────────────────────────────────────────────
+
+function classifyHalstead(node, hRules, acc) {
+  const type = node.type;
+  if (hRules.skipTypes.has(type)) acc.halsteadSkipDepth++;
+  if (acc.halsteadSkipDepth > 0) return;
+
+  if (hRules.compoundOperators.has(type)) {
+    acc.operators.set(type, (acc.operators.get(type) || 0) + 1);
+  }
+  if (node.childCount === 0) {
+    if (hRules.operatorLeafTypes.has(type)) {
+      acc.operators.set(type, (acc.operators.get(type) || 0) + 1);
+    } else if (hRules.operandLeafTypes.has(type)) {
+      const text = node.text;
+      acc.operands.set(text, (acc.operands.get(text) || 0) + 1);
+    }
+  }
+}
+
+// ── Branch complexity classification ────────────────────────────────────
+
+function classifyBranchNode(node, type, nestingLevel, cRules, acc) {
+  // Pattern A: else clause wraps if (JS/C#/Rust)
+  if (cRules.elseNodeType && type === cRules.elseNodeType) {
+    const firstChild = node.namedChild(0);
+    if (firstChild && firstChild.type === cRules.ifNodeType) {
+      // else-if: the if_statement child handles its own increment
+      return;
+    }
+    acc.cognitive++;
+    return;
+  }
+
+  // Pattern B: explicit elif node (Python/Ruby/PHP)
+  if (cRules.elifNodeType && type === cRules.elifNodeType) {
+    acc.cognitive++;
+    acc.cyclomatic++;
+    return;
+  }
+
+  // Detect else-if via Pattern A or C
+  let isElseIf = false;
+  if (type === cRules.ifNodeType) {
+    if (cRules.elseViaAlternative) {
+      isElseIf =
+        node.parent?.type === cRules.ifNodeType &&
+        node.parent.childForFieldName('alternative')?.id === node.id;
+    } else if (cRules.elseNodeType) {
+      isElseIf = node.parent?.type === cRules.elseNodeType;
+    }
+  }
+
+  if (isElseIf) {
+    acc.cognitive++;
+    acc.cyclomatic++;
+    return;
+  }
+
+  // Regular branch node
+  acc.cognitive += 1 + nestingLevel;
+  acc.cyclomatic++;
+
+  if (cRules.switchLikeNodes?.has(type)) {
+    acc.cyclomatic--;
+  }
+}
+
+// ── Plain-else detection (Pattern C: Go/Java) ──────────────────────────
+
+function classifyPlainElse(node, type, cRules, acc) {
+  if (
+    cRules.elseViaAlternative &&
+    type !== cRules.ifNodeType &&
+    node.parent?.type === cRules.ifNodeType &&
+    node.parent.childForFieldName('alternative')?.id === node.id
+  ) {
+    acc.cognitive++;
+  }
+}
+
+// ── Result collection ───────────────────────────────────────────────────
+
+function collectResult(funcNode, acc, hRules, langId) {
+  const halstead =
+    hRules && acc.operators && acc.operands
+      ? computeHalsteadDerived(acc.operators, acc.operands)
+      : null;
+  const loc = computeLOCMetrics(funcNode, langId);
+  const volume = halstead ? halstead.volume : 0;
+  const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
+  const mi = computeMaintainabilityIndex(volume, acc.cyclomatic, loc.sloc, commentRatio);
+
+  return {
+    cognitive: acc.cognitive,
+    cyclomatic: acc.cyclomatic,
+    maxNesting: acc.maxNesting,
+    halstead,
+    loc,
+    mi,
+  };
+}
+
+function resetAccumulators(hRules) {
+  return {
+    cognitive: 0,
+    cyclomatic: 1,
+    maxNesting: 0,
+    operators: hRules ? new Map() : null,
+    operands: hRules ? new Map() : null,
+    halsteadSkipDepth: 0,
+  };
+}
+
+// ── Visitor factory ─────────────────────────────────────────────────────
+
 /**
  * Create a complexity visitor for use with walkWithVisitors.
  *
@@ -28,43 +144,12 @@ import {
 export function createComplexityVisitor(cRules, hRules, options = {}) {
   const { fileLevelWalk = false, langId = null } = options;
 
-  // Per-function accumulators
-  let cognitive = 0;
-  let cyclomatic = 1;
-  let maxNesting = 0;
-  let operators = hRules ? new Map() : null;
-  let operands = hRules ? new Map() : null;
-  let halsteadSkipDepth = 0;
-
-  // In file-level mode, we only count when inside a function
+  let acc = resetAccumulators(hRules);
   let activeFuncNode = null;
   let activeFuncName = null;
-  // Nesting depth relative to the active function (for nested functions)
   let funcDepth = 0;
-
-  // Collected results (one per function)
   const results = [];
 
-  function reset() {
-    cognitive = 0;
-    cyclomatic = 1;
-    maxNesting = 0;
-    operators = hRules ? new Map() : null;
-    operands = hRules ? new Map() : null;
-    halsteadSkipDepth = 0;
-  }
-
-  function collectResult(funcNode) {
-    const halstead =
-      hRules && operators && operands ? computeHalsteadDerived(operators, operands) : null;
-    const loc = computeLOCMetrics(funcNode, langId);
-    const volume = halstead ? halstead.volume : 0;
-    const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
-    const mi = computeMaintainabilityIndex(volume, cyclomatic, loc.sloc, commentRatio);
-
-    return { cognitive, cyclomatic, maxNesting, halstead, loc, mi };
-  }
-
   return {
     name: 'complexity',
     functionNodeTypes: cRules.functionNodes,
@@ -72,17 +157,14 @@ export function createComplexityVisitor(cRules, hRules, options = {}) {
     enterFunction(funcNode, funcName, _context) {
       if (fileLevelWalk) {
         if (!activeFuncNode) {
-          // Top-level function: start fresh
-          reset();
+          acc = resetAccumulators(hRules);
           activeFuncNode = funcNode;
           activeFuncName = funcName;
           funcDepth = 0;
         } else {
-          // Nested function: increase nesting for complexity
           funcDepth++;
         }
       } else {
-        // Function-level mode: track nested functions for correct nesting depth
         funcDepth++;
       }
     },
@@ -90,11 +172,10 @@ export function createComplexityVisitor(cRules, hRules, options = {}) {
     exitFunction(funcNode, _funcName, _context) {
       if (fileLevelWalk) {
         if (funcNode === activeFuncNode) {
-          // Leaving the top-level function: emit result
           results.push({
             funcNode,
             funcName: activeFuncName,
-            metrics: collectResult(funcNode),
+            metrics: collectResult(funcNode, acc, hRules, langId),
           });
           activeFuncNode = null;
           activeFuncName = null;
@@ -107,137 +188,52 @@ export function createComplexityVisitor(cRules, hRules, options = {}) {
     },
 
     enterNode(node, context) {
-      // In file-level mode, skip nodes outside any function
       if (fileLevelWalk && !activeFuncNode) return;
 
       const type = node.type;
       const nestingLevel = fileLevelWalk ? context.nestingLevel + funcDepth : context.nestingLevel;
 
-      // ── Halstead classification ──
-      if (hRules) {
-        if (hRules.skipTypes.has(type)) halsteadSkipDepth++;
-        if (halsteadSkipDepth === 0) {
-          if (hRules.compoundOperators.has(type)) {
-            operators.set(type, (operators.get(type) || 0) + 1);
-          }
-          if (node.childCount === 0) {
-            if (hRules.operatorLeafTypes.has(type)) {
-              operators.set(type, (operators.get(type) || 0) + 1);
-            } else if (hRules.operandLeafTypes.has(type)) {
-              const text = node.text;
-              operands.set(text, (operands.get(text) || 0) + 1);
-            }
-          }
-        }
-      }
+      if (hRules) classifyHalstead(node, hRules, acc);
 
-      // ── Complexity: track nesting depth ──
-      if (nestingLevel > maxNesting) maxNesting = nestingLevel;
+      if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
 
-      // Handle logical operators in binary expressions
+      // Logical operators in binary expressions
       if (type === cRules.logicalNodeType) {
         const op = node.child(1)?.type;
         if (op && cRules.logicalOperators.has(op)) {
-          cyclomatic++;
+          acc.cyclomatic++;
           const parent = node.parent;
           let sameSequence = false;
           if (parent && parent.type === cRules.logicalNodeType) {
             const parentOp = parent.child(1)?.type;
             if (parentOp === op) sameSequence = true;
           }
-          if (!sameSequence) cognitive++;
-          // Don't skip children — walker handles recursion
+          if (!sameSequence) acc.cognitive++;
         }
       }
 
-      // Handle optional chaining (cyclomatic only)
-      if (type === cRules.optionalChainType) {
-        cyclomatic++;
-      }
+      // Optional chaining (cyclomatic only)
+      if (type === cRules.optionalChainType) acc.cyclomatic++;
 
-      // Handle branch/control flow nodes (skip keyword leaf tokens)
+      // Branch/control flow nodes (skip keyword leaf tokens)
       if (cRules.branchNodes.has(type) && node.childCount > 0) {
-        // Pattern A: else clause wraps if (JS/C#/Rust)
-        if (cRules.elseNodeType && type === cRules.elseNodeType) {
-          const firstChild = node.namedChild(0);
-          if (firstChild && firstChild.type === cRules.ifNodeType) {
-            // else-if: the if_statement child handles its own increment
-            return;
-          }
-          cognitive++;
-          return;
-        }
-
-        // Pattern B: explicit elif node (Python/Ruby/PHP)
-        if (cRules.elifNodeType && type === cRules.elifNodeType) {
-          cognitive++;
-          cyclomatic++;
-          return;
-        }
-
-        // Detect else-if via Pattern A or C
-        let isElseIf = false;
-        if (type === cRules.ifNodeType) {
-          if (cRules.elseViaAlternative) {
-            isElseIf =
-              node.parent?.type === cRules.ifNodeType &&
-              node.parent.childForFieldName('alternative')?.id === node.id;
-          } else if (cRules.elseNodeType) {
-            isElseIf = node.parent?.type === cRules.elseNodeType;
-          }
-        }
-
-        if (isElseIf) {
-          cognitive++;
-          cyclomatic++;
-          return;
-        }
-
-        // Regular branch node
-        cognitive += 1 + nestingLevel;
-        cyclomatic++;
-
-        if (cRules.switchLikeNodes?.has(type)) {
-          cyclomatic--;
-        }
-
-        // Nesting nodes are handled by the walker's nestingNodeTypes option
-        // But we still need them to count in complexity — they already do above
-      }
-
-      // Pattern C plain else: block that is the alternative of an if_statement (Go/Java)
-      if (
-        cRules.elseViaAlternative &&
-        type !== cRules.ifNodeType &&
-        node.parent?.type === cRules.ifNodeType &&
-        node.parent.childForFieldName('alternative')?.id === node.id
-      ) {
-        cognitive++;
+        classifyBranchNode(node, type, nestingLevel, cRules, acc);
       }
 
-      // Handle case nodes (cyclomatic only, skip keyword leaves)
-      if (cRules.caseNodes.has(type) && node.childCount > 0) {
-        cyclomatic++;
-      }
+      // Pattern C plain else (Go/Java)
+      classifyPlainElse(node, type, cRules, acc);
 
-      // Handle nested function definitions (increase nesting)
-      // In file-level mode funcDepth handles this; in function-level mode the
-      // nestingNodeTypes option should include function nodes
+      // Case nodes (cyclomatic only, skip keyword leaves)
+      if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
     },
 
     exitNode(node) {
-      // Decrement skip depth when leaving a skip-type subtree
-      if (hRules?.skipTypes.has(node.type)) {
-        halsteadSkipDepth--;
-      }
+      if (hRules?.skipTypes.has(node.type)) acc.halsteadSkipDepth--;
     },
 
     finish() {
-      if (fileLevelWalk) {
-        return results;
-      }
-      // Function-level mode: return single result (no funcNode reference needed)
-      return collectResult({ text: '' });
+      if (fileLevelWalk) return results;
+      return collectResult({ text: '' }, acc, hRules, langId);
     },
   };
 }
diff --git a/src/ast-analysis/visitors/dataflow-visitor.js b/src/ast-analysis/visitors/dataflow-visitor.js
index c6fe9fa9..644490be 100644
--- a/src/ast-analysis/visitors/dataflow-visitor.js
+++ b/src/ast-analysis/visitors/dataflow-visitor.js
@@ -21,254 +21,280 @@ import {
   truncate,
 } from '../visitor-utils.js';
 
-/**
- * Create a dataflow visitor for use with walkWithVisitors.
- *
- * @param {object} rules - DATAFLOW_RULES for the language
- * @returns {Visitor}
- */
-export function createDataflowVisitor(rules) {
-  const isCallNode = rules.callNodes ? (t) => rules.callNodes.has(t) : (t) => t === rules.callNode;
-
-  const parameters = [];
-  const returns = [];
-  const assignments = [];
-  const argFlows = [];
-  const mutations = [];
+// ── Scope helpers ───────────────────────────────────────────────────────
 
-  const scopeStack = [];
+function currentScope(scopeStack) {
+  return scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+}
 
-  function currentScope() {
-    return scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+function findBinding(name, scopeStack) {
+  for (let i = scopeStack.length - 1; i >= 0; i--) {
+    const scope = scopeStack[i];
+    if (scope.params.has(name))
+      return { type: 'param', index: scope.params.get(name), funcName: scope.funcName };
+    if (scope.locals.has(name))
+      return { type: 'local', source: scope.locals.get(name), funcName: scope.funcName };
   }
+  return null;
+}
 
-  function findBinding(name) {
-    for (let i = scopeStack.length - 1; i >= 0; i--) {
-      const scope = scopeStack[i];
-      if (scope.params.has(name))
-        return { type: 'param', index: scope.params.get(name), funcName: scope.funcName };
-      if (scope.locals.has(name))
-        return { type: 'local', source: scope.locals.get(name), funcName: scope.funcName };
-    }
-    return null;
+function bindingConfidence(binding) {
+  if (!binding) return 0.5;
+  if (binding.type === 'param') return 1.0;
+  if (binding.type === 'local') {
+    if (binding.source?.type === 'call_return') return 0.9;
+    if (binding.source?.type === 'destructured') return 0.8;
+    return 0.9;
   }
+  return 0.5;
+}
 
-  function bindingConfidence(binding) {
-    if (!binding) return 0.5;
-    if (binding.type === 'param') return 1.0;
-    if (binding.type === 'local') {
-      if (binding.source?.type === 'call_return') return 0.9;
-      if (binding.source?.type === 'destructured') return 0.8;
-      return 0.9;
-    }
-    return 0.5;
-  }
+// ── Node helpers ────────────────────────────────────────────────────────
 
-  function unwrapAwait(node) {
-    if (rules.awaitNode && node.type === rules.awaitNode) {
-      return node.namedChildren[0] || node;
-    }
-    return node;
+function unwrapAwait(node, rules) {
+  if (rules.awaitNode && node.type === rules.awaitNode) {
+    return node.namedChildren[0] || node;
   }
+  return node;
+}
 
-  function isCall(node) {
-    return node && isCallNode(node.type);
-  }
+function isCall(node, isCallNode) {
+  return node && isCallNode(node.type);
+}
 
-  function handleVarDeclarator(node) {
-    let nameNode = node.childForFieldName(rules.varNameField);
-    let valueNode = rules.varValueField ? node.childForFieldName(rules.varValueField) : null;
+// ── Node handlers ───────────────────────────────────────────────────────
 
-    if (!valueNode && rules.equalsClauseType) {
-      for (const child of node.namedChildren) {
-        if (child.type === rules.equalsClauseType) {
-          valueNode = child.childForFieldName('value') || child.namedChildren[0];
-          break;
-        }
-      }
-    }
+function handleVarDeclarator(node, rules, scopeStack, assignments, isCallNode) {
+  let nameNode = node.childForFieldName(rules.varNameField);
+  let valueNode = rules.varValueField ? node.childForFieldName(rules.varValueField) : null;
 
-    if (!valueNode) {
-      for (const child of node.namedChildren) {
-        if (child !== nameNode && isCall(unwrapAwait(child))) {
-          valueNode = child;
-          break;
-        }
+  if (!valueNode && rules.equalsClauseType) {
+    for (const child of node.namedChildren) {
+      if (child.type === rules.equalsClauseType) {
+        valueNode = child.childForFieldName('value') || child.namedChildren[0];
+        break;
       }
     }
+  }
 
-    if (rules.expressionListType) {
-      if (nameNode?.type === rules.expressionListType) nameNode = nameNode.namedChildren[0];
-      if (valueNode?.type === rules.expressionListType) valueNode = valueNode.namedChildren[0];
+  if (!valueNode) {
+    for (const child of node.namedChildren) {
+      if (child !== nameNode && isCall(unwrapAwait(child, rules), isCallNode)) {
+        valueNode = child;
+        break;
+      }
     }
+  }
 
-    const scope = currentScope();
-    if (!nameNode || !valueNode || !scope) return;
-
-    const unwrapped = unwrapAwait(valueNode);
-    const callExpr = isCall(unwrapped) ? unwrapped : null;
+  if (rules.expressionListType) {
+    if (nameNode?.type === rules.expressionListType) nameNode = nameNode.namedChildren[0];
+    if (valueNode?.type === rules.expressionListType) valueNode = valueNode.namedChildren[0];
+  }
 
-    if (callExpr) {
-      const callee = resolveCalleeName(callExpr, rules);
-      if (callee && scope.funcName) {
-        if (
-          (rules.objectDestructType && nameNode.type === rules.objectDestructType) ||
-          (rules.arrayDestructType && nameNode.type === rules.arrayDestructType)
-        ) {
-          const names = extractParamNames(nameNode, rules);
-          for (const n of names) {
-            assignments.push({
-              varName: n,
-              callerFunc: scope.funcName,
-              sourceCallName: callee,
-              expression: truncate(node.text),
-              line: node.startPosition.row + 1,
-            });
-            scope.locals.set(n, { type: 'destructured', callee });
-          }
-        } else {
-          const varName =
-            nameNode.type === 'identifier' || nameNode.type === rules.paramIdentifier
-              ? nameNode.text
-              : nameNode.text;
+  const scope = currentScope(scopeStack);
+  if (!nameNode || !valueNode || !scope) return;
+
+  const unwrapped = unwrapAwait(valueNode, rules);
+  const callExpr = isCall(unwrapped, isCallNode) ? unwrapped : null;
+
+  if (callExpr) {
+    const callee = resolveCalleeName(callExpr, rules);
+    if (callee && scope.funcName) {
+      if (
+        (rules.objectDestructType && nameNode.type === rules.objectDestructType) ||
+        (rules.arrayDestructType && nameNode.type === rules.arrayDestructType)
+      ) {
+        const names = extractParamNames(nameNode, rules);
+        for (const n of names) {
           assignments.push({
-            varName,
+            varName: n,
             callerFunc: scope.funcName,
             sourceCallName: callee,
             expression: truncate(node.text),
             line: node.startPosition.row + 1,
           });
-          scope.locals.set(varName, { type: 'call_return', callee });
+          scope.locals.set(n, { type: 'destructured', callee });
         }
+      } else {
+        const varName =
+          nameNode.type === 'identifier' || nameNode.type === rules.paramIdentifier
+            ? nameNode.text
+            : nameNode.text;
+        assignments.push({
+          varName,
+          callerFunc: scope.funcName,
+          sourceCallName: callee,
+          expression: truncate(node.text),
+          line: node.startPosition.row + 1,
+        });
+        scope.locals.set(varName, { type: 'call_return', callee });
       }
     }
   }
+}
 
-  function handleAssignment(node) {
-    const left = node.childForFieldName(rules.assignLeftField);
-    const right = node.childForFieldName(rules.assignRightField);
-    const scope = currentScope();
-    if (!scope?.funcName) return;
-
-    if (left && rules.memberNode && left.type === rules.memberNode) {
-      const receiver = memberReceiver(left, rules);
-      if (receiver) {
-        const binding = findBinding(receiver);
-        if (binding) {
-          mutations.push({
-            funcName: scope.funcName,
-            receiverName: receiver,
-            binding,
-            mutatingExpr: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-        }
+function handleAssignment(node, rules, scopeStack, assignments, mutations, isCallNode) {
+  const left = node.childForFieldName(rules.assignLeftField);
+  const right = node.childForFieldName(rules.assignRightField);
+  const scope = currentScope(scopeStack);
+  if (!scope?.funcName) return;
+
+  if (left && rules.memberNode && left.type === rules.memberNode) {
+    const receiver = memberReceiver(left, rules);
+    if (receiver) {
+      const binding = findBinding(receiver, scopeStack);
+      if (binding) {
+        mutations.push({
+          funcName: scope.funcName,
+          receiverName: receiver,
+          binding,
+          mutatingExpr: truncate(node.text),
+          line: node.startPosition.row + 1,
+        });
       }
     }
+  }
 
-    if (left && isIdent(left.type, rules) && right) {
-      const unwrapped = unwrapAwait(right);
-      const callExpr = isCall(unwrapped) ? unwrapped : null;
-      if (callExpr) {
-        const callee = resolveCalleeName(callExpr, rules);
-        if (callee) {
-          assignments.push({
-            varName: left.text,
-            callerFunc: scope.funcName,
-            sourceCallName: callee,
-            expression: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-          scope.locals.set(left.text, { type: 'call_return', callee });
-        }
+  if (left && isIdent(left.type, rules) && right) {
+    const unwrapped = unwrapAwait(right, rules);
+    const callExpr = isCall(unwrapped, isCallNode) ? unwrapped : null;
+    if (callExpr) {
+      const callee = resolveCalleeName(callExpr, rules);
+      if (callee) {
+        assignments.push({
+          varName: left.text,
+          callerFunc: scope.funcName,
+          sourceCallName: callee,
+          expression: truncate(node.text),
+          line: node.startPosition.row + 1,
+        });
+        scope.locals.set(left.text, { type: 'call_return', callee });
       }
     }
   }
+}
 
-  function handleCallExpr(node) {
-    const callee = resolveCalleeName(node, rules);
-    const argsNode = node.childForFieldName(rules.callArgsField);
-    const scope = currentScope();
-    if (!callee || !argsNode || !scope?.funcName) return;
+function handleCallExpr(node, rules, scopeStack, argFlows) {
+  const callee = resolveCalleeName(node, rules);
+  const argsNode = node.childForFieldName(rules.callArgsField);
+  const scope = currentScope(scopeStack);
+  if (!callee || !argsNode || !scope?.funcName) return;
 
-    let argIndex = 0;
-    for (let arg of argsNode.namedChildren) {
-      if (rules.argumentWrapperType && arg.type === rules.argumentWrapperType) {
-        arg = arg.namedChildren[0] || arg;
-      }
-      const unwrapped =
-        rules.spreadType && arg.type === rules.spreadType ? arg.namedChildren[0] || arg : arg;
-      if (!unwrapped) {
-        argIndex++;
-        continue;
-      }
+  let argIndex = 0;
+  for (let arg of argsNode.namedChildren) {
+    if (rules.argumentWrapperType && arg.type === rules.argumentWrapperType) {
+      arg = arg.namedChildren[0] || arg;
+    }
+    const unwrapped =
+      rules.spreadType && arg.type === rules.spreadType ? arg.namedChildren[0] || arg : arg;
+    if (!unwrapped) {
+      argIndex++;
+      continue;
+    }
 
-      const argName = isIdent(unwrapped.type, rules) ? unwrapped.text : null;
-      const argMember =
-        rules.memberNode && unwrapped.type === rules.memberNode
-          ? memberReceiver(unwrapped, rules)
-          : null;
-      const trackedName = argName || argMember;
-
-      if (trackedName) {
-        const binding = findBinding(trackedName);
-        if (binding) {
-          argFlows.push({
-            callerFunc: scope.funcName,
-            calleeName: callee,
-            argIndex,
-            argName: trackedName,
-            binding,
-            confidence: bindingConfidence(binding),
-            expression: truncate(arg.text),
-            line: node.startPosition.row + 1,
-          });
-        }
+    const argName = isIdent(unwrapped.type, rules) ? unwrapped.text : null;
+    const argMember =
+      rules.memberNode && unwrapped.type === rules.memberNode
+        ? memberReceiver(unwrapped, rules)
+        : null;
+    const trackedName = argName || argMember;
+
+    if (trackedName) {
+      const binding = findBinding(trackedName, scopeStack);
+      if (binding) {
+        argFlows.push({
+          callerFunc: scope.funcName,
+          calleeName: callee,
+          argIndex,
+          argName: trackedName,
+          binding,
+          confidence: bindingConfidence(binding),
+          expression: truncate(arg.text),
+          line: node.startPosition.row + 1,
+        });
       }
-      argIndex++;
     }
+    argIndex++;
   }
+}
 
-  function handleExprStmtMutation(node) {
-    if (rules.mutatingMethods.size === 0) return;
-    const expr = node.namedChildren[0];
-    if (!expr || !isCall(expr)) return;
+function handleExprStmtMutation(node, rules, scopeStack, mutations, isCallNode) {
+  if (rules.mutatingMethods.size === 0) return;
+  const expr = node.namedChildren[0];
+  if (!expr || !isCall(expr, isCallNode)) return;
 
-    let methodName = null;
-    let receiver = null;
+  let methodName = null;
+  let receiver = null;
 
-    const fn = expr.childForFieldName(rules.callFunctionField);
-    if (fn && fn.type === rules.memberNode) {
-      const prop = fn.childForFieldName(rules.memberPropertyField);
-      methodName = prop ? prop.text : null;
-      receiver = memberReceiver(fn, rules);
-    }
+  const fn = expr.childForFieldName(rules.callFunctionField);
+  if (fn && fn.type === rules.memberNode) {
+    const prop = fn.childForFieldName(rules.memberPropertyField);
+    methodName = prop ? prop.text : null;
+    receiver = memberReceiver(fn, rules);
+  }
 
-    if (!receiver && rules.callObjectField) {
-      const obj = expr.childForFieldName(rules.callObjectField);
-      const name = expr.childForFieldName(rules.callFunctionField);
-      if (obj && name) {
-        methodName = name.text;
-        receiver = isIdent(obj.type, rules) ? obj.text : null;
-      }
+  if (!receiver && rules.callObjectField) {
+    const obj = expr.childForFieldName(rules.callObjectField);
+    const name = expr.childForFieldName(rules.callFunctionField);
+    if (obj && name) {
+      methodName = name.text;
+      receiver = isIdent(obj.type, rules) ? obj.text : null;
     }
+  }
 
-    if (!methodName || !rules.mutatingMethods.has(methodName)) return;
+  if (!methodName || !rules.mutatingMethods.has(methodName)) return;
 
-    const scope = currentScope();
-    if (!receiver || !scope?.funcName) return;
+  const scope = currentScope(scopeStack);
+  if (!receiver || !scope?.funcName) return;
 
-    const binding = findBinding(receiver);
-    if (binding) {
-      mutations.push({
-        funcName: scope.funcName,
-        receiverName: receiver,
-        binding,
-        mutatingExpr: truncate(expr.text),
-        line: node.startPosition.row + 1,
-      });
-    }
+  const binding = findBinding(receiver, scopeStack);
+  if (binding) {
+    mutations.push({
+      funcName: scope.funcName,
+      receiverName: receiver,
+      binding,
+      mutatingExpr: truncate(expr.text),
+      line: node.startPosition.row + 1,
+    });
   }
+}
+
+// ── Return statement handler ────────────────────────────────────────────
+
+function handleReturn(node, rules, scopeStack, returns) {
+  if (node.parent?.type === rules.returnNode) return; // keyword token, not statement
+
+  const scope = currentScope(scopeStack);
+  if (scope?.funcName) {
+    const expr = node.namedChildren[0];
+    const referencedNames = [];
+    if (expr) collectIdentifiers(expr, referencedNames, rules);
+    returns.push({
+      funcName: scope.funcName,
+      expression: truncate(expr ? expr.text : ''),
+      referencedNames,
+      line: node.startPosition.row + 1,
+    });
+  }
+}
+
+// ── Visitor factory ─────────────────────────────────────────────────────
+
+/**
+ * Create a dataflow visitor for use with walkWithVisitors.
+ *
+ * @param {object} rules - DATAFLOW_RULES for the language
+ * @returns {Visitor}
+ */
+export function createDataflowVisitor(rules) {
+  const isCallNode = rules.callNodes ? (t) => rules.callNodes.has(t) : (t) => t === rules.callNode;
+
+  const parameters = [];
+  const returns = [];
+  const assignments = [];
+  const argFlows = [];
+  const mutations = [];
+  const scopeStack = [];
 
   return {
     name: 'dataflow',
@@ -300,54 +326,34 @@ export function createDataflowVisitor(rules) {
     enterNode(node, _context) {
       const t = node.type;
 
-      // Skip function nodes — handled by enterFunction/exitFunction
       if (rules.functionNodes.has(t)) return;
 
-      // Return statements (skip keyword tokens inside return statements, e.g. Ruby's
-      // `return` node nests a `return` keyword child with the same type string)
       if (rules.returnNode && t === rules.returnNode) {
-        if (node.parent?.type === rules.returnNode) return; // keyword token, not statement
-
-        const scope = currentScope();
-        if (scope?.funcName) {
-          const expr = node.namedChildren[0];
-          const referencedNames = [];
-          if (expr) collectIdentifiers(expr, referencedNames, rules);
-          returns.push({
-            funcName: scope.funcName,
-            expression: truncate(expr ? expr.text : ''),
-            referencedNames,
-            line: node.startPosition.row + 1,
-          });
-        }
+        handleReturn(node, rules, scopeStack, returns);
         return;
       }
 
-      // Variable declarations
       if (rules.varDeclaratorNode && t === rules.varDeclaratorNode) {
-        handleVarDeclarator(node);
+        handleVarDeclarator(node, rules, scopeStack, assignments, isCallNode);
         return;
       }
       if (rules.varDeclaratorNodes?.has(t)) {
-        handleVarDeclarator(node);
+        handleVarDeclarator(node, rules, scopeStack, assignments, isCallNode);
         return;
       }
 
-      // Call expressions
       if (isCallNode(t)) {
-        handleCallExpr(node);
+        handleCallExpr(node, rules, scopeStack, argFlows);
         return;
       }
 
-      // Assignment expressions
       if (rules.assignmentNode && t === rules.assignmentNode) {
-        handleAssignment(node);
+        handleAssignment(node, rules, scopeStack, assignments, mutations, isCallNode);
         return;
       }
 
-      // Mutation detection via expression_statement
       if (rules.expressionStmtNode && t === rules.expressionStmtNode) {
-        handleExprStmtMutation(node);
+        handleExprStmtMutation(node, rules, scopeStack, mutations, isCallNode);
       }
     },
 
diff --git a/src/domain/graph/builder/incremental.js b/src/domain/graph/builder/incremental.js
index f04a136e..63694385 100644
--- a/src/domain/graph/builder/incremental.js
+++ b/src/domain/graph/builder/incremental.js
@@ -12,10 +12,121 @@ import { parseFileIncremental } from '../../parser.js';
 import { computeConfidence, resolveImportPath } from '../resolve.js';
 import { BUILTIN_RECEIVERS, readFileSafe } from './helpers.js';
 
+// ── Node insertion ──────────────────────────────────────────────────────
+
+function insertFileNodes(stmts, relPath, symbols) {
+  stmts.insertNode.run(relPath, 'file', relPath, 0, null);
+  for (const def of symbols.definitions) {
+    stmts.insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
+  }
+  for (const exp of symbols.exports) {
+    stmts.insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
+  }
+}
+
+// ── Import edge building ────────────────────────────────────────────────
+
+function buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeId, aliases) {
+  let edgesAdded = 0;
+  for (const imp of symbols.imports) {
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
+    const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
+    if (targetRow) {
+      const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
+      stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
+      edgesAdded++;
+    }
+  }
+  return edgesAdded;
+}
+
+function buildImportedNamesMap(symbols, rootDir, relPath, aliases) {
+  const importedNames = new Map();
+  for (const imp of symbols.imports) {
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
+    for (const name of imp.names) {
+      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
+    }
+  }
+  return importedNames;
+}
+
+// ── Call edge building ──────────────────────────────────────────────────
+
+function findCaller(call, definitions, relPath, stmts) {
+  let caller = null;
+  let callerSpan = Infinity;
+  for (const def of definitions) {
+    if (def.line <= call.line) {
+      const end = def.endLine || Infinity;
+      if (call.line <= end) {
+        const span = end - def.line;
+        if (span < callerSpan) {
+          const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
+          if (row) {
+            caller = row;
+            callerSpan = span;
+          }
+        }
+      } else if (!caller) {
+        const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
+        if (row) caller = row;
+      }
+    }
+  }
+  return caller;
+}
+
+function resolveCallTargets(stmts, call, relPath, importedNames) {
+  const importedFrom = importedNames.get(call.name);
+  let targets;
+  if (importedFrom) {
+    targets = stmts.findNodeInFile.all(call.name, importedFrom);
+  }
+  if (!targets || targets.length === 0) {
+    targets = stmts.findNodeInFile.all(call.name, relPath);
+    if (targets.length === 0) {
+      targets = stmts.findNodeByName.all(call.name);
+    }
+  }
+  return { targets, importedFrom };
+}
+
+function buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames) {
+  let edgesAdded = 0;
+  for (const call of symbols.calls) {
+    if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
+
+    const caller = findCaller(call, symbols.definitions, relPath, stmts) || fileNodeRow;
+    const { targets, importedFrom } = resolveCallTargets(stmts, call, relPath, importedNames);
+
+    for (const t of targets) {
+      if (t.id !== caller.id) {
+        const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
+        stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
+        edgesAdded++;
+      }
+    }
+  }
+  return edgesAdded;
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
 /**
  * Parse a single file and update the database incrementally.
  *
- * @param {import('better-sqlite3').Database} db
+ * @param {import('better-sqlite3').Database} _db
  * @param {string} rootDir - Absolute root directory
  * @param {string} filePath - Absolute file path
  * @param {object} stmts - Prepared DB statements
@@ -61,105 +172,20 @@ export async function rebuildFile(_db, rootDir, filePath, stmts, engineOpts, cac
   const symbols = await parseFileIncremental(cache, filePath, code, engineOpts);
   if (!symbols) return null;
 
-  // Insert nodes
-  stmts.insertNode.run(relPath, 'file', relPath, 0, null);
-  for (const def of symbols.definitions) {
-    stmts.insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
-  }
-  for (const exp of symbols.exports) {
-    stmts.insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
-  }
+  insertFileNodes(stmts, relPath, symbols);
 
   const newNodes = stmts.countNodes.get(relPath)?.c || 0;
   const newSymbols = diffSymbols ? stmts.listSymbols.all(relPath) : [];
 
-  let edgesAdded = 0;
   const fileNodeRow = stmts.getNodeId.get(relPath, 'file', relPath, 0);
   if (!fileNodeRow)
     return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
-  const fileNodeId = fileNodeRow.id;
 
-  // Load aliases for import resolution
   const aliases = { baseUrl: null, paths: {} };
 
-  // Import edges
-  for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(
-      path.join(rootDir, relPath),
-      imp.source,
-      rootDir,
-      aliases,
-    );
-    const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
-    if (targetRow) {
-      const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
-      stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
-      edgesAdded++;
-    }
-  }
-
-  // Build import name → resolved file mapping
-  const importedNames = new Map();
-  for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(
-      path.join(rootDir, relPath),
-      imp.source,
-      rootDir,
-      aliases,
-    );
-    for (const name of imp.names) {
-      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
-    }
-  }
-
-  // Call edges
-  for (const call of symbols.calls) {
-    if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
-
-    let caller = null;
-    let callerSpan = Infinity;
-    for (const def of symbols.definitions) {
-      if (def.line <= call.line) {
-        const end = def.endLine || Infinity;
-        if (call.line <= end) {
-          const span = end - def.line;
-          if (span < callerSpan) {
-            const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-            if (row) {
-              caller = row;
-              callerSpan = span;
-            }
-          }
-        } else if (!caller) {
-          const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-          if (row) caller = row;
-        }
-      }
-    }
-    if (!caller) caller = fileNodeRow;
-
-    const importedFrom = importedNames.get(call.name);
-    let targets;
-    if (importedFrom) {
-      targets = stmts.findNodeInFile.all(call.name, importedFrom);
-    }
-    if (!targets || targets.length === 0) {
-      targets = stmts.findNodeInFile.all(call.name, relPath);
-      if (targets.length === 0) {
-        targets = stmts.findNodeByName.all(call.name);
-      }
-    }
-
-    for (const t of targets) {
-      if (t.id !== caller.id) {
-        const confidence = importedFrom
-          ? computeConfidence(relPath, t.file, importedFrom)
-          : computeConfidence(relPath, t.file, null);
-        stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
-        edgesAdded++;
-      }
-    }
-  }
+  let edgesAdded = buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeRow.id, aliases);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases);
+  edgesAdded += buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames);
 
   const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, newSymbols) : null;
   const event = oldNodes === 0 ? 'added' : 'modified';
diff --git a/src/domain/graph/builder/pipeline.js b/src/domain/graph/builder/pipeline.js
index ea9848c5..963a0086 100644
--- a/src/domain/graph/builder/pipeline.js
+++ b/src/domain/graph/builder/pipeline.js
@@ -23,94 +23,73 @@ import { parseFiles } from './stages/parse-files.js';
 import { resolveImports } from './stages/resolve-imports.js';
 import { runAnalyses } from './stages/run-analyses.js';
 
-/**
- * Build the dependency graph for a codebase.
- *
- * Signature and return value are identical to the original monolithic buildGraph().
- *
- * @param {string} rootDir - Root directory to scan
- * @param {object} [opts] - Build options
- * @returns {Promise<{ phases: object } | undefined>}
- */
-export async function buildGraph(rootDir, opts = {}) {
-  const ctx = new PipelineContext();
-  ctx.buildStart = performance.now();
-  ctx.opts = opts;
+// ── Setup helpers ───────────────────────────────────────────────────────
 
-  // ── Setup (creates DB, loads config, selects engine) ──────────────
-  ctx.rootDir = path.resolve(rootDir);
-  ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
-  ctx.db = openDb(ctx.dbPath);
-  try {
-    initSchema(ctx.db);
-
-    ctx.config = loadConfig(ctx.rootDir);
-    ctx.incremental =
-      opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
-
-    ctx.engineOpts = {
-      engine: opts.engine || 'auto',
-      dataflow: opts.dataflow !== false,
-      ast: opts.ast !== false,
-    };
-    const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
-    ctx.engineName = engineName;
-    ctx.engineVersion = engineVersion;
-    info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
-
-    // Engine/schema mismatch detection
-    ctx.schemaVersion = MIGRATIONS[MIGRATIONS.length - 1].version;
-    ctx.forceFullRebuild = false;
-    if (ctx.incremental) {
-      const prevEngine = getBuildMeta(ctx.db, 'engine');
-      if (prevEngine && prevEngine !== engineName) {
-        info(`Engine changed (${prevEngine} → ${engineName}), promoting to full rebuild.`);
-        ctx.forceFullRebuild = true;
-      }
-      const prevSchema = getBuildMeta(ctx.db, 'schema_version');
-      if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
-        info(
-          `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
-        );
-        ctx.forceFullRebuild = true;
-      }
-    }
+function initializeEngine(ctx) {
+  ctx.engineOpts = {
+    engine: ctx.opts.engine || 'auto',
+    dataflow: ctx.opts.dataflow !== false,
+    ast: ctx.opts.ast !== false,
+  };
+  const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
+  ctx.engineName = engineName;
+  ctx.engineVersion = engineVersion;
+  info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
+}
 
-    // Path aliases
-    ctx.aliases = loadPathAliases(ctx.rootDir);
-    if (ctx.config.aliases) {
-      for (const [key, value] of Object.entries(ctx.config.aliases)) {
-        const pattern = key.endsWith('/') ? `${key}*` : key;
-        const target = path.resolve(ctx.rootDir, value);
-        ctx.aliases.paths[pattern] = [target.endsWith('/') ? `${target}*` : `${target}/*`];
-      }
-    }
-    if (ctx.aliases.baseUrl || Object.keys(ctx.aliases.paths).length > 0) {
-      info(
-        `Loaded path aliases: baseUrl=${ctx.aliases.baseUrl || 'none'}, ${Object.keys(ctx.aliases.paths).length} path mappings`,
-      );
+function checkEngineSchemaMismatch(ctx) {
+  ctx.schemaVersion = MIGRATIONS[MIGRATIONS.length - 1].version;
+  ctx.forceFullRebuild = false;
+  if (!ctx.incremental) return;
+
+  const prevEngine = getBuildMeta(ctx.db, 'engine');
+  if (prevEngine && prevEngine !== ctx.engineName) {
+    info(`Engine changed (${prevEngine} → ${ctx.engineName}), promoting to full rebuild.`);
+    ctx.forceFullRebuild = true;
+  }
+  const prevSchema = getBuildMeta(ctx.db, 'schema_version');
+  if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
+    info(
+      `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
+    );
+    ctx.forceFullRebuild = true;
+  }
+}
+
+function loadAliases(ctx) {
+  ctx.aliases = loadPathAliases(ctx.rootDir);
+  if (ctx.config.aliases) {
+    for (const [key, value] of Object.entries(ctx.config.aliases)) {
+      const pattern = key.endsWith('/') ? `${key}*` : key;
+      const target = path.resolve(ctx.rootDir, value);
+      ctx.aliases.paths[pattern] = [target.endsWith('/') ? `${target}*` : `${target}/*`];
     }
+  }
+  if (ctx.aliases.baseUrl || Object.keys(ctx.aliases.paths).length > 0) {
+    info(
+      `Loaded path aliases: baseUrl=${ctx.aliases.baseUrl || 'none'}, ${Object.keys(ctx.aliases.paths).length} path mappings`,
+    );
+  }
+}
 
-    ctx.timing.setupMs = performance.now() - ctx.buildStart;
+function setupPipeline(ctx) {
+  ctx.rootDir = path.resolve(ctx.rootDir);
+  ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
+  ctx.db = openDb(ctx.dbPath);
+  initSchema(ctx.db);
 
-    // ── Pipeline stages ─────────────────────────────────────────────
-    await collectFiles(ctx);
-    await detectChanges(ctx);
+  ctx.config = loadConfig(ctx.rootDir);
+  ctx.incremental =
+    ctx.opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
 
-    if (ctx.earlyExit) return;
+  initializeEngine(ctx);
+  checkEngineSchemaMismatch(ctx);
+  loadAliases(ctx);
 
-    await parseFiles(ctx);
-    await insertNodes(ctx);
-    await resolveImports(ctx);
-    await buildEdges(ctx);
-    await buildStructure(ctx);
-    await runAnalyses(ctx);
-    await finalize(ctx);
-  } catch (err) {
-    if (!ctx.earlyExit) closeDb(ctx.db);
-    throw err;
-  }
+  ctx.timing.setupMs = performance.now() - ctx.buildStart;
+}
 
+function formatTimingResult(ctx) {
   return {
     phases: {
       setupMs: +ctx.timing.setupMs.toFixed(1),
@@ -128,3 +107,50 @@ export async function buildGraph(rootDir, opts = {}) {
     },
   };
 }
+
+// ── Pipeline stages execution ───────────────────────────────────────────
+
+async function runPipelineStages(ctx) {
+  await collectFiles(ctx);
+  await detectChanges(ctx);
+
+  if (ctx.earlyExit) return;
+
+  await parseFiles(ctx);
+  await insertNodes(ctx);
+  await resolveImports(ctx);
+  await buildEdges(ctx);
+  await buildStructure(ctx);
+  await runAnalyses(ctx);
+  await finalize(ctx);
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
+/**
+ * Build the dependency graph for a codebase.
+ *
+ * Signature and return value are identical to the original monolithic buildGraph().
+ *
+ * @param {string} rootDir - Root directory to scan
+ * @param {object} [opts] - Build options
+ * @returns {Promise<{ phases: object } | undefined>}
+ */
+export async function buildGraph(rootDir, opts = {}) {
+  const ctx = new PipelineContext();
+  ctx.buildStart = performance.now();
+  ctx.opts = opts;
+  ctx.rootDir = rootDir;
+
+  try {
+    setupPipeline(ctx);
+    await runPipelineStages(ctx);
+  } catch (err) {
+    if (!ctx.earlyExit) closeDb(ctx.db);
+    throw err;
+  }
+
+  if (ctx.earlyExit) return;
+
+  return formatTimingResult(ctx);
+}
diff --git a/src/domain/graph/builder/stages/build-edges.js b/src/domain/graph/builder/stages/build-edges.js
index a1529454..0651c865 100644
--- a/src/domain/graph/builder/stages/build-edges.js
+++ b/src/domain/graph/builder/stages/build-edges.js
@@ -12,25 +12,18 @@ import { computeConfidence } from '../../resolve.js';
 import { BUILTIN_RECEIVERS, batchInsertEdges } from '../helpers.js';
 import { getResolved, isBarrelFile, resolveBarrelExport } from './resolve-imports.js';
 
-/**
- * @param {import('../context.js').PipelineContext} ctx
- */
-export async function buildEdges(ctx) {
-  const { db, fileSymbols, barrelOnlyFiles, rootDir, engineName } = ctx;
+// ── Node lookup setup ───────────────────────────────────────────────────
 
-  const getNodeIdStmt = {
+function makeGetNodeIdStmt(db) {
+  return {
     get: (name, kind, file, line) => {
       const id = getNodeId(db, name, kind, file, line);
       return id != null ? { id } : undefined;
     },
   };
+}
 
-  // Pre-load all nodes into lookup maps
-  const allNodes = db
-    .prepare(
-      `SELECT id, name, kind, file, line FROM nodes WHERE kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`,
-    )
-    .all();
+function setupNodeLookups(ctx, allNodes) {
   ctx.nodesByName = new Map();
   for (const node of allNodes) {
     if (!ctx.nodesByName.has(node.name)) ctx.nodesByName.set(node.name, []);
@@ -42,253 +35,339 @@ export async function buildEdges(ctx) {
     if (!ctx.nodesByNameAndFile.has(key)) ctx.nodesByNameAndFile.set(key, []);
     ctx.nodesByNameAndFile.get(key).push(node);
   }
+}
 
-  const t0 = performance.now();
-  const buildEdgesTx = db.transaction(() => {
-    const allEdgeRows = [];
+// ── Import edges ────────────────────────────────────────────────────────
 
-    // ── Import edges ────────────────────────────────────────────────
-    for (const [relPath, symbols] of fileSymbols) {
-      if (barrelOnlyFiles.has(relPath)) continue;
-      const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-      if (!fileNodeRow) continue;
-      const fileNodeId = fileNodeRow.id;
-
-      for (const imp of symbols.imports) {
-        const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
-        const targetRow = getNodeIdStmt.get(resolvedPath, 'file', resolvedPath, 0);
-        if (targetRow) {
-          const edgeKind = imp.reexport
-            ? 'reexports'
-            : imp.typeOnly
-              ? 'imports-type'
-              : imp.dynamicImport
-                ? 'dynamic-imports'
-                : 'imports';
-          allEdgeRows.push([fileNodeId, targetRow.id, edgeKind, 1.0, 0]);
-
-          if (!imp.reexport && isBarrelFile(ctx, resolvedPath)) {
-            const resolvedSources = new Set();
-            for (const name of imp.names) {
-              const cleanName = name.replace(/^\*\s+as\s+/, '');
-              const actualSource = resolveBarrelExport(ctx, resolvedPath, cleanName);
-              if (
-                actualSource &&
-                actualSource !== resolvedPath &&
-                !resolvedSources.has(actualSource)
-              ) {
-                resolvedSources.add(actualSource);
-                const actualRow = getNodeIdStmt.get(actualSource, 'file', actualSource, 0);
-                if (actualRow) {
-                  allEdgeRows.push([
-                    fileNodeId,
-                    actualRow.id,
-                    edgeKind === 'imports-type'
-                      ? 'imports-type'
-                      : edgeKind === 'dynamic-imports'
-                        ? 'dynamic-imports'
-                        : 'imports',
-                    0.9,
-                    0,
-                  ]);
-                }
-              }
-            }
-          }
-        }
+function buildImportEdges(ctx, getNodeIdStmt, allEdgeRows) {
+  const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (barrelOnlyFiles.has(relPath)) continue;
+    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (!fileNodeRow) continue;
+    const fileNodeId = fileNodeRow.id;
+
+    for (const imp of symbols.imports) {
+      const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+      const targetRow = getNodeIdStmt.get(resolvedPath, 'file', resolvedPath, 0);
+      if (!targetRow) continue;
+
+      const edgeKind = imp.reexport
+        ? 'reexports'
+        : imp.typeOnly
+          ? 'imports-type'
+          : imp.dynamicImport
+            ? 'dynamic-imports'
+            : 'imports';
+      allEdgeRows.push([fileNodeId, targetRow.id, edgeKind, 1.0, 0]);
+
+      if (!imp.reexport && isBarrelFile(ctx, resolvedPath)) {
+        buildBarrelEdges(ctx, imp, resolvedPath, fileNodeId, edgeKind, getNodeIdStmt, allEdgeRows);
       }
     }
+  }
+}
 
-    // ── Call/receiver/extends/implements edges ───────────────────────
-    const native = engineName === 'native' ? loadNative() : null;
-    if (native?.buildCallEdges) {
-      const nativeFiles = [];
-      for (const [relPath, symbols] of fileSymbols) {
-        if (barrelOnlyFiles.has(relPath)) continue;
-        const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-        if (!fileNodeRow) continue;
-
-        const importedNames = [];
-        for (const imp of symbols.imports) {
-          const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
-          for (const name of imp.names) {
-            const cleanName = name.replace(/^\*\s+as\s+/, '');
-            let targetFile = resolvedPath;
-            if (isBarrelFile(ctx, resolvedPath)) {
-              const actual = resolveBarrelExport(ctx, resolvedPath, cleanName);
-              if (actual) targetFile = actual;
-            }
-            importedNames.push({ name: cleanName, file: targetFile });
+function buildBarrelEdges(ctx, imp, resolvedPath, fileNodeId, edgeKind, getNodeIdStmt, edgeRows) {
+  const resolvedSources = new Set();
+  for (const name of imp.names) {
+    const cleanName = name.replace(/^\*\s+as\s+/, '');
+    const actualSource = resolveBarrelExport(ctx, resolvedPath, cleanName);
+    if (actualSource && actualSource !== resolvedPath && !resolvedSources.has(actualSource)) {
+      resolvedSources.add(actualSource);
+      const actualRow = getNodeIdStmt.get(actualSource, 'file', actualSource, 0);
+      if (actualRow) {
+        const kind =
+          edgeKind === 'imports-type'
+            ? 'imports-type'
+            : edgeKind === 'dynamic-imports'
+              ? 'dynamic-imports'
+              : 'imports';
+        edgeRows.push([fileNodeId, actualRow.id, kind, 0.9, 0]);
+      }
+    }
+  }
+}
+
+// ── Call edges (native engine) ──────────────────────────────────────────
+
+function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native) {
+  const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+  const nativeFiles = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (barrelOnlyFiles.has(relPath)) continue;
+    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (!fileNodeRow) continue;
+
+    const importedNames = buildImportedNamesForNative(ctx, relPath, symbols, rootDir);
+    nativeFiles.push({
+      file: relPath,
+      fileNodeId: fileNodeRow.id,
+      definitions: symbols.definitions.map((d) => ({
+        name: d.name,
+        kind: d.kind,
+        line: d.line,
+        endLine: d.endLine ?? null,
+      })),
+      calls: symbols.calls,
+      importedNames,
+      classes: symbols.classes,
+    });
+  }
+
+  const nativeEdges = native.buildCallEdges(nativeFiles, allNodes, [...BUILTIN_RECEIVERS]);
+  for (const e of nativeEdges) {
+    allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
+  }
+}
+
+function buildImportedNamesForNative(ctx, relPath, symbols, rootDir) {
+  const importedNames = [];
+  for (const imp of symbols.imports) {
+    const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+    for (const name of imp.names) {
+      const cleanName = name.replace(/^\*\s+as\s+/, '');
+      let targetFile = resolvedPath;
+      if (isBarrelFile(ctx, resolvedPath)) {
+        const actual = resolveBarrelExport(ctx, resolvedPath, cleanName);
+        if (actual) targetFile = actual;
+      }
+      importedNames.push({ name: cleanName, file: targetFile });
+    }
+  }
+  return importedNames;
+}
+
+// ── Call edges (JS fallback) ────────────────────────────────────────────
+
+function buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows) {
+  const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (barrelOnlyFiles.has(relPath)) continue;
+    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (!fileNodeRow) continue;
+
+    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
+    const seenCallEdges = new Set();
+
+    buildFileCallEdges(
+      ctx,
+      relPath,
+      symbols,
+      fileNodeRow,
+      importedNames,
+      seenCallEdges,
+      getNodeIdStmt,
+      allEdgeRows,
+    );
+    buildClassHierarchyEdges(ctx, relPath, symbols, allEdgeRows);
+  }
+}
+
+function buildImportedNamesMap(ctx, relPath, symbols, rootDir) {
+  const importedNames = new Map();
+  for (const imp of symbols.imports) {
+    const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+    for (const name of imp.names) {
+      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
+    }
+  }
+  return importedNames;
+}
+
+function findCaller(call, definitions, relPath, getNodeIdStmt, fileNodeRow) {
+  let caller = null;
+  let callerSpan = Infinity;
+  for (const def of definitions) {
+    if (def.line <= call.line) {
+      const end = def.endLine || Infinity;
+      if (call.line <= end) {
+        const span = end - def.line;
+        if (span < callerSpan) {
+          const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
+          if (row) {
+            caller = row;
+            callerSpan = span;
           }
         }
+      } else if (!caller) {
+        const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
+        if (row) caller = row;
+      }
+    }
+  }
+  return caller || fileNodeRow;
+}
 
-        nativeFiles.push({
-          file: relPath,
-          fileNodeId: fileNodeRow.id,
-          definitions: symbols.definitions.map((d) => ({
-            name: d.name,
-            kind: d.kind,
-            line: d.line,
-            endLine: d.endLine ?? null,
-          })),
-          calls: symbols.calls,
-          importedNames,
-          classes: symbols.classes,
-        });
+function resolveCallTargets(ctx, call, relPath, importedNames) {
+  const importedFrom = importedNames.get(call.name);
+  let targets;
+
+  if (importedFrom) {
+    targets = ctx.nodesByNameAndFile.get(`${call.name}|${importedFrom}`) || [];
+    if (targets.length === 0 && isBarrelFile(ctx, importedFrom)) {
+      const actualSource = resolveBarrelExport(ctx, importedFrom, call.name);
+      if (actualSource) {
+        targets = ctx.nodesByNameAndFile.get(`${call.name}|${actualSource}`) || [];
       }
+    }
+  }
 
-      const nativeEdges = native.buildCallEdges(nativeFiles, allNodes, [...BUILTIN_RECEIVERS]);
-      for (const e of nativeEdges) {
-        allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
+  if (!targets || targets.length === 0) {
+    targets = ctx.nodesByNameAndFile.get(`${call.name}|${relPath}`) || [];
+    if (targets.length === 0) {
+      targets = resolveByMethodOrGlobal(ctx, call, relPath);
+    }
+  }
+
+  if (targets.length > 1) {
+    targets.sort((a, b) => {
+      const confA = computeConfidence(relPath, a.file, importedFrom);
+      const confB = computeConfidence(relPath, b.file, importedFrom);
+      return confB - confA;
+    });
+  }
+
+  return { targets, importedFrom };
+}
+
+function resolveByMethodOrGlobal(ctx, call, relPath) {
+  const methodCandidates = (ctx.nodesByName.get(call.name) || []).filter(
+    (n) => n.name.endsWith(`.${call.name}`) && n.kind === 'method',
+  );
+  if (methodCandidates.length > 0) return methodCandidates;
+
+  if (
+    !call.receiver ||
+    call.receiver === 'this' ||
+    call.receiver === 'self' ||
+    call.receiver === 'super'
+  ) {
+    return (ctx.nodesByName.get(call.name) || []).filter(
+      (n) => computeConfidence(relPath, n.file, null) >= 0.5,
+    );
+  }
+  return [];
+}
+
+function buildFileCallEdges(
+  ctx,
+  relPath,
+  symbols,
+  fileNodeRow,
+  importedNames,
+  seenCallEdges,
+  getNodeIdStmt,
+  allEdgeRows,
+) {
+  for (const call of symbols.calls) {
+    if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
+
+    const caller = findCaller(call, symbols.definitions, relPath, getNodeIdStmt, fileNodeRow);
+    const isDynamic = call.dynamic ? 1 : 0;
+    const { targets, importedFrom } = resolveCallTargets(ctx, call, relPath, importedNames);
+
+    for (const t of targets) {
+      const edgeKey = `${caller.id}|${t.id}`;
+      if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
+        seenCallEdges.add(edgeKey);
+        const confidence = computeConfidence(relPath, t.file, importedFrom);
+        allEdgeRows.push([caller.id, t.id, 'calls', confidence, isDynamic]);
       }
-    } else {
-      // JS fallback
-      for (const [relPath, symbols] of fileSymbols) {
-        if (barrelOnlyFiles.has(relPath)) continue;
-        const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-        if (!fileNodeRow) continue;
-
-        const importedNames = new Map();
-        for (const imp of symbols.imports) {
-          const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
-          for (const name of imp.names) {
-            const cleanName = name.replace(/^\*\s+as\s+/, '');
-            importedNames.set(cleanName, resolvedPath);
-          }
-        }
+    }
 
-        const seenCallEdges = new Set();
-        for (const call of symbols.calls) {
-          if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
-          let caller = null;
-          let callerSpan = Infinity;
-          for (const def of symbols.definitions) {
-            if (def.line <= call.line) {
-              const end = def.endLine || Infinity;
-              if (call.line <= end) {
-                const span = end - def.line;
-                if (span < callerSpan) {
-                  const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
-                  if (row) {
-                    caller = row;
-                    callerSpan = span;
-                  }
-                }
-              } else if (!caller) {
-                const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
-                if (row) caller = row;
-              }
-            }
-          }
-          if (!caller) caller = fileNodeRow;
-
-          const isDynamic = call.dynamic ? 1 : 0;
-          let targets;
-          const importedFrom = importedNames.get(call.name);
-
-          if (importedFrom) {
-            targets = ctx.nodesByNameAndFile.get(`${call.name}|${importedFrom}`) || [];
-            if (targets.length === 0 && isBarrelFile(ctx, importedFrom)) {
-              const actualSource = resolveBarrelExport(ctx, importedFrom, call.name);
-              if (actualSource) {
-                targets = ctx.nodesByNameAndFile.get(`${call.name}|${actualSource}`) || [];
-              }
-            }
-          }
-          if (!targets || targets.length === 0) {
-            targets = ctx.nodesByNameAndFile.get(`${call.name}|${relPath}`) || [];
-            if (targets.length === 0) {
-              const methodCandidates = (ctx.nodesByName.get(call.name) || []).filter(
-                (n) => n.name.endsWith(`.${call.name}`) && n.kind === 'method',
-              );
-              if (methodCandidates.length > 0) {
-                targets = methodCandidates;
-              } else if (
-                !call.receiver ||
-                call.receiver === 'this' ||
-                call.receiver === 'self' ||
-                call.receiver === 'super'
-              ) {
-                targets = (ctx.nodesByName.get(call.name) || []).filter(
-                  (n) => computeConfidence(relPath, n.file, null) >= 0.5,
-                );
-              }
-            }
-          }
+    // Receiver edge
+    if (
+      call.receiver &&
+      !BUILTIN_RECEIVERS.has(call.receiver) &&
+      call.receiver !== 'this' &&
+      call.receiver !== 'self' &&
+      call.receiver !== 'super'
+    ) {
+      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows);
+    }
+  }
+}
 
-          if (targets.length > 1) {
-            targets.sort((a, b) => {
-              const confA = computeConfidence(relPath, a.file, importedFrom);
-              const confB = computeConfidence(relPath, b.file, importedFrom);
-              return confB - confA;
-            });
-          }
+function buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows) {
+  const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
+  const samefile = ctx.nodesByNameAndFile.get(`${call.receiver}|${relPath}`) || [];
+  const candidates = samefile.length > 0 ? samefile : ctx.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);
+      allEdgeRows.push([caller.id, recvTarget.id, 'receiver', 0.7, 0]);
+    }
+  }
+}
 
-          for (const t of targets) {
-            const edgeKey = `${caller.id}|${t.id}`;
-            if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
-              seenCallEdges.add(edgeKey);
-              const confidence = computeConfidence(relPath, t.file, importedFrom);
-              allEdgeRows.push([caller.id, t.id, 'calls', confidence, isDynamic]);
-            }
-          }
+// ── Class hierarchy edges ───────────────────────────────────────────────
 
-          // Receiver edge
-          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']);
-            const samefile = ctx.nodesByNameAndFile.get(`${call.receiver}|${relPath}`) || [];
-            const candidates =
-              samefile.length > 0 ? samefile : ctx.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);
-                allEdgeRows.push([caller.id, recvTarget.id, 'receiver', 0.7, 0]);
-              }
-            }
-          }
+function buildClassHierarchyEdges(ctx, relPath, symbols, allEdgeRows) {
+  for (const cls of symbols.classes) {
+    if (cls.extends) {
+      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
+        (n) => n.kind === 'class',
+      );
+      const targetRows = (ctx.nodesByName.get(cls.extends) || []).filter((n) => n.kind === 'class');
+      if (sourceRow) {
+        for (const t of targetRows) {
+          allEdgeRows.push([sourceRow.id, t.id, 'extends', 1.0, 0]);
         }
+      }
+    }
 
-        // Class extends edges
-        for (const cls of symbols.classes) {
-          if (cls.extends) {
-            const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
-              (n) => n.kind === 'class',
-            );
-            const targetCandidates = ctx.nodesByName.get(cls.extends) || [];
-            const targetRows = targetCandidates.filter((n) => n.kind === 'class');
-            if (sourceRow) {
-              for (const t of targetRows) {
-                allEdgeRows.push([sourceRow.id, t.id, 'extends', 1.0, 0]);
-              }
-            }
-          }
-
-          if (cls.implements) {
-            const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
-              (n) => n.kind === 'class',
-            );
-            const targetCandidates = ctx.nodesByName.get(cls.implements) || [];
-            const targetRows = targetCandidates.filter(
-              (n) => n.kind === 'interface' || n.kind === 'class',
-            );
-            if (sourceRow) {
-              for (const t of targetRows) {
-                allEdgeRows.push([sourceRow.id, t.id, 'implements', 1.0, 0]);
-              }
-            }
-          }
+    if (cls.implements) {
+      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
+        (n) => n.kind === 'class',
+      );
+      const targetRows = (ctx.nodesByName.get(cls.implements) || []).filter(
+        (n) => n.kind === 'interface' || n.kind === 'class',
+      );
+      if (sourceRow) {
+        for (const t of targetRows) {
+          allEdgeRows.push([sourceRow.id, t.id, 'implements', 1.0, 0]);
         }
       }
     }
+  }
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function buildEdges(ctx) {
+  const { db, engineName } = ctx;
+
+  const getNodeIdStmt = makeGetNodeIdStmt(db);
+
+  const allNodes = db
+    .prepare(
+      `SELECT id, name, kind, file, line FROM nodes WHERE kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`,
+    )
+    .all();
+  setupNodeLookups(ctx, allNodes);
+
+  const t0 = performance.now();
+  const buildEdgesTx = db.transaction(() => {
+    const allEdgeRows = [];
+
+    buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+
+    const native = engineName === 'native' ? loadNative() : null;
+    if (native?.buildCallEdges) {
+      buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native);
+    } else {
+      buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows);
+    }
 
     batchInsertEdges(db, allEdgeRows);
   });
diff --git a/src/domain/graph/builder/stages/detect-changes.js b/src/domain/graph/builder/stages/detect-changes.js
index 50ffbd1d..baf03e95 100644
--- a/src/domain/graph/builder/stages/detect-changes.js
+++ b/src/domain/graph/builder/stages/detect-changes.js
@@ -13,12 +13,13 @@ import { parseFilesAuto } from '../../../parser.js';
 import { readJournal, writeJournalHeader } from '../../journal.js';
 import { fileHash, fileStat, purgeFilesFromGraph, readFileSafe } from '../helpers.js';
 
+// ── Three-tier change detection ─────────────────────────────────────────
+
 /**
  * Determine which files have changed since last build.
- * Three-tier cascade:
- *   Tier 0 — Journal: O(changed) when watcher was running
- *   Tier 1 — mtime+size: O(n) stats, O(changed) reads
- *   Tier 2 — Hash comparison: O(changed) reads (fallback from Tier 1)
+ * Tier 0 — Journal: O(changed) when watcher was running
+ * Tier 1 — mtime+size: O(n) stats, O(changed) reads
+ * Tier 2 — Hash comparison: O(changed) reads (fallback from Tier 1)
  */
 function getChangedFiles(db, allFiles, rootDir) {
   let hasTable = false;
@@ -44,6 +45,17 @@ function getChangedFiles(db, allFiles, rootDir) {
       .map((r) => [r.file, r]),
   );
 
+  const removed = detectRemovedFiles(existing, allFiles, rootDir);
+
+  // Tier 0: Journal
+  const journalResult = tryJournalTier(db, existing, rootDir, removed);
+  if (journalResult) return journalResult;
+
+  // Tier 1 + 2: mtime/size fast-path → hash comparison
+  return mtimeAndHashTiers(existing, allFiles, rootDir, removed);
+}
+
+function detectRemovedFiles(existing, allFiles, rootDir) {
   const currentFiles = new Set();
   for (const file of allFiles) {
     currentFiles.add(normalizePath(path.relative(rootDir, file)));
@@ -55,51 +67,57 @@ function getChangedFiles(db, allFiles, rootDir) {
       removed.push(existingFile);
     }
   }
+  return removed;
+}
 
-  // ── Tier 0: Journal ──────────────────────────────────────────────
+function tryJournalTier(db, existing, rootDir, removed) {
   const journal = readJournal(rootDir);
-  if (journal.valid) {
-    const dbMtimes = db.prepare('SELECT MAX(mtime) as latest FROM file_hashes').get();
-    const latestDbMtime = dbMtimes?.latest || 0;
-    const hasJournalEntries = journal.changed.length > 0 || journal.removed.length > 0;
-
-    if (hasJournalEntries && journal.timestamp >= latestDbMtime) {
-      debug(
-        `Tier 0: journal valid, ${journal.changed.length} changed, ${journal.removed.length} removed`,
-      );
-      const changed = [];
-
-      for (const relPath of journal.changed) {
-        const absPath = path.join(rootDir, relPath);
-        const stat = fileStat(absPath);
-        if (!stat) continue;
-
-        let content;
-        try {
-          content = readFileSafe(absPath);
-        } catch {
-          continue;
-        }
-        const hash = fileHash(content);
-        const record = existing.get(relPath);
-        if (!record || record.hash !== hash) {
-          changed.push({ file: absPath, content, hash, relPath, stat });
-        }
-      }
+  if (!journal.valid) return null;
 
-      const removedSet = new Set(removed);
-      for (const relPath of journal.removed) {
-        if (existing.has(relPath)) removedSet.add(relPath);
-      }
+  const dbMtimes = db.prepare('SELECT MAX(mtime) as latest FROM file_hashes').get();
+  const latestDbMtime = dbMtimes?.latest || 0;
+  const hasJournalEntries = journal.changed.length > 0 || journal.removed.length > 0;
 
-      return { changed, removed: [...removedSet], isFullBuild: false };
-    }
+  if (!hasJournalEntries || journal.timestamp < latestDbMtime) {
     debug(
       `Tier 0: skipped (${hasJournalEntries ? 'timestamp stale' : 'no entries'}), falling to Tier 1`,
     );
+    return null;
+  }
+
+  debug(
+    `Tier 0: journal valid, ${journal.changed.length} changed, ${journal.removed.length} removed`,
+  );
+  const changed = [];
+
+  for (const relPath of journal.changed) {
+    const absPath = path.join(rootDir, relPath);
+    const stat = fileStat(absPath);
+    if (!stat) continue;
+
+    let content;
+    try {
+      content = readFileSafe(absPath);
+    } catch {
+      continue;
+    }
+    const hash = fileHash(content);
+    const record = existing.get(relPath);
+    if (!record || record.hash !== hash) {
+      changed.push({ file: absPath, content, hash, relPath, stat });
+    }
+  }
+
+  const removedSet = new Set(removed);
+  for (const relPath of journal.removed) {
+    if (existing.has(relPath)) removedSet.add(relPath);
   }
 
-  // ── Tier 1: mtime+size fast-path ─────────────────────────────────
+  return { changed, removed: [...removedSet], isFullBuild: false };
+}
+
+function mtimeAndHashTiers(existing, allFiles, rootDir, removed) {
+  // Tier 1: mtime+size fast-path
   const needsHash = [];
   const skipped = [];
 
@@ -130,7 +148,7 @@ function getChangedFiles(db, allFiles, rootDir) {
     debug(`Tier 1: ${skipped.length} skipped by mtime+size, ${needsHash.length} need hash check`);
   }
 
-  // ── Tier 2: Hash comparison ──────────────────────────────────────
+  // Tier 2: Hash comparison
   const changed = [];
 
   for (const item of needsHash) {
@@ -168,9 +186,10 @@ function getChangedFiles(db, allFiles, rootDir) {
   return { changed, removed, isFullBuild: false };
 }
 
+// ── Pending analysis ────────────────────────────────────────────────────
+
 /**
  * Run pending analysis pass when no file changes but analysis tables are empty.
- * @returns {boolean} true if analysis was run and we should early-exit
  */
 async function runPendingAnalysis(ctx) {
   const { db, opts, engineOpts, allFiles, rootDir } = ctx;
@@ -213,9 +232,8 @@ async function runPendingAnalysis(ctx) {
   return true;
 }
 
-/**
- * Self-heal metadata-only updates (mtime/size) without re-parsing.
- */
+// ── Metadata self-heal ──────────────────────────────────────────────────
+
 function healMetadata(ctx) {
   const { db, metadataUpdates } = ctx;
   if (!metadataUpdates || metadataUpdates.length === 0) return;
@@ -237,126 +255,111 @@ function healMetadata(ctx) {
   }
 }
 
-/**
- * @param {import('../context.js').PipelineContext} ctx
- */
-export async function detectChanges(ctx) {
-  const { db, allFiles, rootDir, incremental, forceFullRebuild, opts } = ctx;
-
-  // Scoped builds already set parseChanges in collectFiles.
-  // Still need to purge removed files and set hasEmbeddings.
-  if (opts.scope) {
-    let hasEmbeddings = false;
-    try {
-      db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
-      hasEmbeddings = true;
-    } catch {
-      /* table doesn't exist */
-    }
-    ctx.hasEmbeddings = hasEmbeddings;
+// ── Reverse-dependency cascade ──────────────────────────────────────────
 
-    // Reverse-dependency cascade BEFORE purging (needs existing edges to find importers)
-    const changePaths = ctx.parseChanges.map(
-      (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
-    );
-    const reverseDeps = new Set();
-    if (!opts.noReverseDeps) {
-      const changedRelPaths = new Set([...changePaths, ...ctx.removed]);
-      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)) {
-              const absPath = path.join(rootDir, row.file);
-              if (fs.existsSync(absPath)) {
-                reverseDeps.add(row.file);
-              }
-            }
-          }
+function findReverseDependencies(db, changedRelPaths, rootDir) {
+  const reverseDeps = new Set();
+  if (changedRelPaths.size === 0) return reverseDeps;
+
+  const findReverseDepsStmt = 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 findReverseDepsStmt.all(relPath)) {
+      if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
+        const absPath = path.join(rootDir, row.file);
+        if (fs.existsSync(absPath)) {
+          reverseDeps.add(row.file);
         }
       }
     }
-
-    // Now purge changed + removed files
-    if (changePaths.length > 0 || ctx.removed.length > 0) {
-      purgeFilesFromGraph(db, [...ctx.removed, ...changePaths], { purgeHashes: false });
-    }
-
-    // Delete outgoing edges for reverse-dep files and add to parse list
-    if (reverseDeps.size > 0) {
-      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);
-      }
-      for (const relPath of reverseDeps) {
-        const absPath = path.join(rootDir, relPath);
-        ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
-      }
-      info(
-        `Scoped rebuild: ${changePaths.length} changed, ${ctx.removed.length} removed, ${reverseDeps.size} reverse-deps`,
-      );
-    }
-    return;
   }
+  return reverseDeps;
+}
 
-  const increResult =
-    incremental && !forceFullRebuild
-      ? getChangedFiles(db, allFiles, rootDir)
-      : { changed: allFiles.map((f) => ({ file: f })), removed: [], isFullBuild: true };
+function purgeAndAddReverseDeps(ctx, changePaths, reverseDeps) {
+  const { db, rootDir } = ctx;
 
-  ctx.removed = increResult.removed;
-  ctx.isFullBuild = increResult.isFullBuild;
-  ctx.parseChanges = increResult.changed.filter((c) => !c.metadataOnly);
-  ctx.metadataUpdates = increResult.changed.filter((c) => c.metadataOnly);
+  if (changePaths.length > 0 || ctx.removed.length > 0) {
+    purgeFilesFromGraph(db, [...ctx.removed, ...changePaths], { purgeHashes: false });
+  }
 
-  // Early exit: no changes detected
-  if (!ctx.isFullBuild && ctx.parseChanges.length === 0 && ctx.removed.length === 0) {
-    const ranAnalysis = await runPendingAnalysis(ctx);
-    if (ranAnalysis) {
-      closeDb(db);
-      writeJournalHeader(rootDir, Date.now());
-      ctx.earlyExit = true;
-      return;
+  if (reverseDeps.size > 0) {
+    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);
+    }
+    for (const relPath of reverseDeps) {
+      const absPath = path.join(rootDir, relPath);
+      ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
     }
-
-    healMetadata(ctx);
-    info('No changes detected. Graph is up to date.');
-    closeDb(db);
-    writeJournalHeader(rootDir, Date.now());
-    ctx.earlyExit = true;
-    return;
   }
+}
 
-  // ── Full build: truncate all tables ──────────────────────────────
-  let hasEmbeddings = false;
+// ── Shared helpers ───────────────────────────────────────────────────────
+
+function detectHasEmbeddings(db) {
   try {
     db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
-    hasEmbeddings = true;
+    return true;
   } catch {
-    /* table doesn't exist */
+    return false;
   }
-  ctx.hasEmbeddings = hasEmbeddings;
+}
 
-  if (ctx.isFullBuild) {
-    const deletions =
-      '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;`
-        : deletions,
-    );
-    return;
+// ── Scoped build path ───────────────────────────────────────────────────
+
+function handleScopedBuild(ctx) {
+  const { db, rootDir, opts } = ctx;
+
+  ctx.hasEmbeddings = detectHasEmbeddings(db);
+
+  const changePaths = ctx.parseChanges.map(
+    (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
+  );
+
+  let reverseDeps = new Set();
+  if (!opts.noReverseDeps) {
+    const changedRelPaths = new Set([...changePaths, ...ctx.removed]);
+    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir);
   }
 
-  // ── Reverse-dependency cascade (incremental) ─────────────────────
-  const reverseDeps = new Set();
+  // Purge changed + removed files, then add reverse-deps
+  purgeAndAddReverseDeps(ctx, changePaths, reverseDeps);
+
+  info(
+    `Scoped rebuild: ${changePaths.length} changed, ${ctx.removed.length} removed, ${reverseDeps.size} reverse-deps`,
+  );
+}
+
+// ── Full/incremental build path ─────────────────────────────────────────
+
+function handleFullBuild(ctx) {
+  const { db } = ctx;
+
+  const hasEmbeddings = detectHasEmbeddings(db);
+  ctx.hasEmbeddings = hasEmbeddings;
+
+  const deletions =
+    '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;`
+      : deletions,
+  );
+}
+
+function handleIncrementalBuild(ctx) {
+  const { db, rootDir, opts } = ctx;
+
+  ctx.hasEmbeddings = detectHasEmbeddings(db);
+
+  let reverseDeps = new Set();
   if (!opts.noReverseDeps) {
     const changedRelPaths = new Set();
     for (const item of ctx.parseChanges) {
@@ -365,25 +368,7 @@ export async function detectChanges(ctx) {
     for (const relPath of ctx.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)) {
-            const absPath = path.join(rootDir, row.file);
-            if (fs.existsSync(absPath)) {
-              reverseDeps.add(row.file);
-            }
-          }
-        }
-      }
-    }
+    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir);
   }
 
   info(
@@ -393,21 +378,57 @@ export async function detectChanges(ctx) {
     debug(`Changed files: ${ctx.parseChanges.map((c) => c.relPath).join(', ')}`);
   if (ctx.removed.length > 0) debug(`Removed files: ${ctx.removed.join(', ')}`);
 
-  // Purge changed and removed files
   const changePaths = ctx.parseChanges.map(
     (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
   );
-  purgeFilesFromGraph(db, [...ctx.removed, ...changePaths], { purgeHashes: false });
+  purgeAndAddReverseDeps(ctx, changePaths, reverseDeps);
+}
 
-  // Delete outgoing edges for reverse-dep files, then add them to parse list
-  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);
+// ── Main entry point ────────────────────────────────────────────────────
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function detectChanges(ctx) {
+  const { db, allFiles, rootDir, incremental, forceFullRebuild, opts } = ctx;
+
+  // Scoped builds already set parseChanges in collectFiles
+  if (opts.scope) {
+    handleScopedBuild(ctx);
+    return;
   }
-  for (const relPath of reverseDeps) {
-    const absPath = path.join(rootDir, relPath);
-    ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
+
+  const increResult =
+    incremental && !forceFullRebuild
+      ? getChangedFiles(db, allFiles, rootDir)
+      : { changed: allFiles.map((f) => ({ file: f })), removed: [], isFullBuild: true };
+
+  ctx.removed = increResult.removed;
+  ctx.isFullBuild = increResult.isFullBuild;
+  ctx.parseChanges = increResult.changed.filter((c) => !c.metadataOnly);
+  ctx.metadataUpdates = increResult.changed.filter((c) => c.metadataOnly);
+
+  // Early exit: no changes detected
+  if (!ctx.isFullBuild && ctx.parseChanges.length === 0 && ctx.removed.length === 0) {
+    const ranAnalysis = await runPendingAnalysis(ctx);
+    if (ranAnalysis) {
+      closeDb(db);
+      writeJournalHeader(rootDir, Date.now());
+      ctx.earlyExit = true;
+      return;
+    }
+
+    healMetadata(ctx);
+    info('No changes detected. Graph is up to date.');
+    closeDb(db);
+    writeJournalHeader(rootDir, Date.now());
+    ctx.earlyExit = true;
+    return;
+  }
+
+  if (ctx.isFullBuild) {
+    handleFullBuild(ctx);
+  } else {
+    handleIncrementalBuild(ctx);
   }
 }
diff --git a/src/domain/graph/builder/stages/insert-nodes.js b/src/domain/graph/builder/stages/insert-nodes.js
index 2eaf6a73..6e22c966 100644
--- a/src/domain/graph/builder/stages/insert-nodes.js
+++ b/src/domain/graph/builder/stages/insert-nodes.js
@@ -15,23 +15,159 @@ import {
   readFileSafe,
 } from '../helpers.js';
 
+// ── Phase 1: Insert file nodes, definitions, exports ────────────────────
+
+function insertDefinitionsAndExports(db, allSymbols) {
+  const phase1Rows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
+    for (const def of symbols.definitions) {
+      const dotIdx = def.name.lastIndexOf('.');
+      const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
+      phase1Rows.push([
+        def.name,
+        def.kind,
+        relPath,
+        def.line,
+        def.endLine || null,
+        null,
+        def.name,
+        scope,
+        def.visibility || null,
+      ]);
+    }
+    for (const exp of symbols.exports) {
+      phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
+    }
+  }
+  batchInsertNodes(db, phase1Rows);
+
+  // Mark exported symbols
+  const markExported = db.prepare(
+    'UPDATE nodes SET exported = 1 WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+  );
+  for (const [relPath, symbols] of allSymbols) {
+    for (const exp of symbols.exports) {
+      markExported.run(exp.name, exp.kind, relPath, exp.line);
+    }
+  }
+}
+
+// ── Phase 2: Insert children (needs parent IDs) ────────────────────────
+
+function insertChildren(db, allSymbols) {
+  const childRows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+    for (const def of symbols.definitions) {
+      if (!def.children?.length) continue;
+      const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+      if (!defId) continue;
+      for (const child of def.children) {
+        const qualifiedName = `${def.name}.${child.name}`;
+        childRows.push([
+          child.name,
+          child.kind,
+          relPath,
+          child.line,
+          child.endLine || null,
+          defId,
+          qualifiedName,
+          def.name,
+          child.visibility || null,
+        ]);
+      }
+    }
+  }
+  batchInsertNodes(db, childRows);
+}
+
+// ── Phase 3: Insert containment + parameter_of edges ────────────────────
+
+function insertContainmentEdges(db, allSymbols) {
+  const edgeRows = [];
+  for (const [relPath, symbols] of allSymbols) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+    const fileId = nodeIdMap.get(`${relPath}|file|0`);
+    for (const def of symbols.definitions) {
+      const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+      if (fileId && defId) {
+        edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
+      }
+      if (def.children?.length && defId) {
+        for (const child of def.children) {
+          const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
+          if (childId) {
+            edgeRows.push([defId, childId, 'contains', 1.0, 0]);
+            if (child.kind === 'parameter') {
+              edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
+            }
+          }
+        }
+      }
+    }
+  }
+  batchInsertEdges(db, edgeRows);
+}
+
+// ── Phase 4: Update file hashes ─────────────────────────────────────────
+
+function updateFileHashes(_db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash) {
+  if (!upsertHash) return;
+
+  for (const [relPath] of allSymbols) {
+    const precomputed = precomputedData.get(relPath);
+    if (precomputed?._reverseDepOnly) {
+      // no-op: file unchanged, hash already correct
+    } else if (precomputed?.hash) {
+      const stat = precomputed.stat || fileStat(path.join(rootDir, relPath));
+      const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+      const size = stat ? stat.size : 0;
+      upsertHash.run(relPath, precomputed.hash, mtime, size);
+    } else {
+      const absPath = path.join(rootDir, relPath);
+      let code;
+      try {
+        code = readFileSafe(absPath);
+      } catch {
+        code = null;
+      }
+      if (code !== null) {
+        const stat = fileStat(absPath);
+        const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+        const size = stat ? stat.size : 0;
+        upsertHash.run(relPath, fileHash(code), mtime, size);
+      }
+    }
+  }
+
+  // Also update metadata-only entries (self-heal mtime/size without re-parse)
+  for (const item of metadataUpdates) {
+    const mtime = item.stat ? Math.floor(item.stat.mtimeMs) : 0;
+    const size = item.stat ? item.stat.size : 0;
+    upsertHash.run(item.relPath, item.hash, mtime, size);
+  }
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
 /**
  * @param {import('../context.js').PipelineContext} ctx
  */
 export async function insertNodes(ctx) {
   const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
 
-  // Build lookup from incremental data (pre-computed hashes + stats)
   const precomputedData = new Map();
   for (const item of filesToParse) {
-    if (item.relPath) {
-      precomputedData.set(item.relPath, item);
-    }
+    if (item.relPath) precomputedData.set(item.relPath, item);
   }
 
-  const bulkGetNodeIds = { all: (file) => bulkNodeIdsByFile(db, file) };
-
-  // Prepare hash upsert
   let upsertHash;
   try {
     upsertHash = db.prepare(
@@ -42,143 +178,15 @@ export async function insertNodes(ctx) {
   }
 
   // Populate fileSymbols before the transaction so it is a pure input
-  // to (rather than a side-effect of) the DB write — avoids partial
-  // population if the transaction rolls back.
   for (const [relPath, symbols] of allSymbols) {
     ctx.fileSymbols.set(relPath, symbols);
   }
 
   const insertAll = db.transaction(() => {
-    // Phase 1: Batch insert all file nodes + definitions + exports
-    // Row format: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
-    const phase1Rows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
-      for (const def of symbols.definitions) {
-        // Methods already have 'Class.method' as name — use as qualified_name.
-        // For methods, scope is the class portion; for top-level defs, scope is null.
-        const dotIdx = def.name.lastIndexOf('.');
-        const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
-        phase1Rows.push([
-          def.name,
-          def.kind,
-          relPath,
-          def.line,
-          def.endLine || null,
-          null,
-          def.name,
-          scope,
-          def.visibility || null,
-        ]);
-      }
-      for (const exp of symbols.exports) {
-        phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
-      }
-    }
-    batchInsertNodes(db, phase1Rows);
-
-    // Phase 1b: Mark exported symbols
-    const markExported = db.prepare(
-      'UPDATE nodes SET exported = 1 WHERE name = ? AND kind = ? AND file = ? AND line = ?',
-    );
-    for (const [relPath, symbols] of allSymbols) {
-      for (const exp of symbols.exports) {
-        markExported.run(exp.name, exp.kind, relPath, exp.line);
-      }
-    }
-
-    // Phase 3: Batch insert children (needs parent IDs from Phase 2)
-    const childRows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      const nodeIdMap = new Map();
-      for (const row of bulkGetNodeIds.all(relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      for (const def of symbols.definitions) {
-        if (!def.children?.length) continue;
-        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
-        if (!defId) continue;
-        for (const child of def.children) {
-          const qualifiedName = `${def.name}.${child.name}`;
-          childRows.push([
-            child.name,
-            child.kind,
-            relPath,
-            child.line,
-            child.endLine || null,
-            defId,
-            qualifiedName,
-            def.name,
-            child.visibility || null,
-          ]);
-        }
-      }
-    }
-    batchInsertNodes(db, childRows);
-
-    // Phase 5: Batch insert contains/parameter_of edges
-    const edgeRows = [];
-    for (const [relPath, symbols] of allSymbols) {
-      const nodeIdMap = new Map();
-      for (const row of bulkGetNodeIds.all(relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      const fileId = nodeIdMap.get(`${relPath}|file|0`);
-      for (const def of symbols.definitions) {
-        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
-        if (fileId && defId) {
-          edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
-        }
-        if (def.children?.length && defId) {
-          for (const child of def.children) {
-            const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
-            if (childId) {
-              edgeRows.push([defId, childId, 'contains', 1.0, 0]);
-              if (child.kind === 'parameter') {
-                edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
-              }
-            }
-          }
-        }
-      }
-
-      // Update file hash — skip reverse-dep files (unchanged)
-      if (upsertHash) {
-        const precomputed = precomputedData.get(relPath);
-        if (precomputed?._reverseDepOnly) {
-          // no-op: file unchanged, hash already correct
-        } else if (precomputed?.hash) {
-          const stat = precomputed.stat || fileStat(path.join(rootDir, relPath));
-          const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
-          const size = stat ? stat.size : 0;
-          upsertHash.run(relPath, precomputed.hash, mtime, size);
-        } else {
-          const absPath = path.join(rootDir, relPath);
-          let code;
-          try {
-            code = readFileSafe(absPath);
-          } catch {
-            code = null;
-          }
-          if (code !== null) {
-            const stat = fileStat(absPath);
-            const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
-            const size = stat ? stat.size : 0;
-            upsertHash.run(relPath, fileHash(code), mtime, size);
-          }
-        }
-      }
-    }
-    batchInsertEdges(db, edgeRows);
-
-    // Also update metadata-only entries (self-heal mtime/size without re-parse)
-    if (upsertHash) {
-      for (const item of metadataUpdates) {
-        const mtime = item.stat ? Math.floor(item.stat.mtimeMs) : 0;
-        const size = item.stat ? item.stat.size : 0;
-        upsertHash.run(item.relPath, item.hash, mtime, size);
-      }
-    }
+    insertDefinitionsAndExports(db, allSymbols);
+    insertChildren(db, allSymbols);
+    insertContainmentEdges(db, allSymbols);
+    updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
   });
 
   const t0 = performance.now();