diff --git a/.claude/skills/titan-grind/SKILL.md b/.claude/skills/titan-grind/SKILL.md
new file mode 100644
index 00000000..77481238
--- /dev/null
+++ b/.claude/skills/titan-grind/SKILL.md
@@ -0,0 +1,447 @@
+---
+name: titan-grind
+description: Adopt extracted helpers — find dead symbols from forge, wire them into consumers, replace duplicated inline patterns, and gate on dead-symbol delta (Titan Paradigm Phase 4.5)
+argument-hint: <--dry-run> <--phase N> <--target name> <--yes>
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill, Agent
+---
+
+# Titan GRIND — Adopt Extracted Helpers
+
+You are running the **GRIND** phase of the Titan Paradigm.
+
+Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers that forge extracted but never wired into consumers, adopt them across the codebase, and gate on a non-positive dead-symbol delta.
+
+> **Why this phase exists:** Forge decomposes god-functions into smaller helpers, but those helpers are only called within their own file. The dead symbol count inflates with every forge phase because the adoption loop is never closed. Grind closes it.
+
+> **Context budget:** One forge phase per invocation. Process all targets from one forge phase's commits, then stop. User re-runs for the next phase.
+
+**Arguments** (from `$ARGUMENTS`):
+- No args → process the next unground forge phase
+- `--phase N` → process a specific forge phase
+- `--target <name>` → run single target only (for retrying failures)
+- `--dry-run` → analyze and report without making changes
+- `--yes` → skip confirmation prompt (typically passed by `/titan-run` orchestrator)
+
+---
+
+## 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 merge conflicts → stop: "Merge conflict detected. Resolve and re-run `/titan-grind`."
+
+3. **Load artifacts.** Read:
+   - `.codegraph/titan/titan-state.json` — current state (required)
+   - `.codegraph/titan/sync.json` — execution plan (required)
+   - `.codegraph/titan/gate-log.ndjson` — gate verdicts (optional)
+   - `.codegraph/titan/grind-targets.ndjson` — persisted grind analysis (optional, exists on resume)
+
+4. **Validate state.** Grind runs after forge. Check:
+   - `titan-state.json → execution` block exists
+   - `execution.completedPhases` has at least one entry
+   - If no `execution` block → stop: "No forge execution found. Run `/titan-forge` first."
+
+5. **Initialize grind state** (if `grind` block doesn't exist in `titan-state.json`). Merge into `titan-state.json`:
+   ```json
+   {
+     "grind": {
+       "completedPhases": [],
+       "currentPhase": null,
+       "currentTarget": null,
+       "processedTargets": [],
+       "failedTargets": [],
+       "adoptions": [],
+       "removals": [],
+       "falsePositives": [],
+       "deadSymbolBaseline": null,
+       "deadSymbolCurrent": null
+     }
+   }
+   ```
+
+6. **Ensure graph is current.** Rebuild if stale:
+   ```bash
+   codegraph build
+   ```
+
+7. **Capture dead-symbol baseline** (only if `grind.deadSymbolBaseline` is null):
+   ```bash
+   codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const items=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:items.length,byRole:items.reduce((a,i)=>{a[i.role]=(a[i.role]||0)+1;return a},{})}));})"
+   ```
+   Store the total in `grind.deadSymbolBaseline`. Write `titan-state.json` immediately.
+
+8. **Determine next phase.** Use `--phase N` if provided, otherwise find the lowest forge phase number not in `grind.completedPhases`.
+
+9. **Update state.** Set `grind.currentPhase` to the target phase number. Write `titan-state.json`.
+
+10. **Print plan and ask for confirmation** (unless `--yes`):
+    ```
+    GRIND — Phase N: <label>
+    Forge made N commits for this phase.
+    Dead symbol baseline: <N>
+    Previously processed: <N> targets (<N> adopted, <N> failed)
+    
+    Will: identify new dead symbols, find adoption opportunities, wire helpers into consumers.
+    Proceed? [y/n]
+    ```
+
+---
+
+## Step 1 — Identify forge's new symbols
+
+**Skip if:** `.codegraph/titan/grind-targets.ndjson` already has entries for this phase (resume case). Load existing entries and skip to Step 3.
+
+For the target forge phase, get the commits from `titan-state.json → execution.commits` that belong to this phase (cross-reference with `sync.json → executionOrder[phase].targets`).
+
+For each commit, identify changed files:
+```bash
+git diff-tree --no-commit-id --name-only -r <commit-sha>
+```
+
+For each changed file, inventory the symbols:
+```bash
+codegraph where --file <changed-file> -T --json
+```
+
+Collect all symbols defined in files touched by this forge phase. These are the **candidate symbols** — forge created or modified them.
+
+---
+
+## Step 2 — Find and classify dead helpers
+
+Run dead-code detection scoped to the candidate files:
+
+```bash
+codegraph roles --role dead -T --file <changed-file> --json
+```
+
+For each file touched by forge in this phase, collect symbols flagged as dead. Filter to:
+- **Functions** and **constants** only (skip interfaces, parameters, type aliases — these are typically false positives from TypeScript type-level usage)
+- **Symbols that are exported** (file-local helpers called within their own file are not dead — they're just private)
+- **Symbols NOT in the public API barrel** (`src/index.ts`) unless they have zero external consumers
+
+For each candidate dead symbol, run the full analysis:
+
+### 2a. Understand the helper
+
+```bash
+codegraph where <helper-name>
+codegraph context <helper-name> -T --json
+codegraph audit --quick <helper-name> -T --json
+```
+
+Read the helper's source file to understand its signature, parameters, and behavior. This is critical — you cannot classify or adopt a helper you don't understand.
+
+### 2b. Check if actually dead (false-positive detection)
+
+```bash
+codegraph fn-impact <helper-name> -T --json
+codegraph ast --kind call <helper-name> -T --json
+```
+
+Check for:
+- **Dynamic imports** (`await import(...)`) that call this symbol — codegraph can't trace these
+- **Re-export chains** (`export { X } from './foo.js'`) — codegraph may not count re-exports as references
+- **Closure-local usage** — the symbol is assigned to a variable and called within the same function
+- **Template literal usage** — the symbol is referenced inside a string template (e.g., HTML renderer)
+
+If any of these apply → classify as **false-positive**.
+
+### 2c. Duplicate-logic scan
+
+Search the codebase for inline code that duplicates what the helper does:
+
+```bash
+codegraph query <helper-name> -T --json
+```
+
+Read the helper's source to extract its key pattern. Then search for that pattern:
+
+```bash
+# Use Grep with patterns derived from the helper's implementation
+# Example: if helper is toSymbolRef({ name, kind, file, line }),
+# search for the inline pattern it replaces
+```
+
+Use `Grep` with patterns derived from the helper's implementation. Look for:
+- Identical multi-line patterns (e.g., object literal mappings)
+- Equivalent `.map()` callbacks that the helper could replace
+- Hand-rolled loops that duplicate the helper's logic
+- Similar function signatures doing the same work in a different module
+
+### 2d. Consumer-wiring scan
+
+Check if the helper should be called by existing code that currently does the same work:
+
+```bash
+codegraph fn-impact <helper-name> -T --json
+codegraph path <helper-name> <potential-consumer> -T --json
+```
+
+If the helper wraps a common operation (error construction, AST traversal, data mapping), search for call sites of the underlying operation that could use the wrapper instead:
+
+```bash
+codegraph ast --kind call <underlying-function> -T --json
+```
+
+### 2e. Re-export check
+
+If the helper is in a module with a barrel file (index.ts, mod.rs), check if it needs to be re-exported:
+
+```bash
+codegraph exports <barrel-file> -T --json
+```
+
+### 2f. Classify and persist
+
+For each grind target, assign one of:
+
+| Classification | Action |
+|---------------|--------|
+| **adopt** | Found N sites where this helper replaces duplicated code. Wire it in. |
+| **re-export** | Helper is consumed internally but missing from barrel. Add re-export. |
+| **promote** | Helper is file-local but useful elsewhere. Export and wire consumers. |
+| **false-positive** | Not actually dead (dynamic import, closure, re-export chain). Skip. |
+| **intentionally-private** | Helper is file-local and only used within its file. Remove export or leave as-is. |
+| **remove** | Helper is genuinely unused and has no adoption opportunity. Delete it. |
+
+**Persist each classification immediately** to `.codegraph/titan/grind-targets.ndjson` (one JSON object per line):
+```json
+{"target":"<name>","file":"<file>","phase":N,"classification":"adopt|re-export|promote|false-positive|intentionally-private|remove","reason":"<why>","consumers":["file1.ts"],"pattern":"<what to search for>","timestamp":"<ISO 8601>"}
+```
+
+This ensures resume works — if interrupted, re-running loads existing entries and skips already-classified targets.
+
+If zero actionable grind targets (only false-positives and intentionally-private) → print "Phase N: no dead helpers to adopt. Forge wired everything correctly (or all dead symbols are false positives)." Mark phase complete, stop.
+
+---
+
+## Step 3 — Execute adoptions (per-target loop)
+
+For each grind target classified as **adopt**, **re-export**, **promote**, or **remove**:
+
+1. **Skip if done.** Check if target is already in `grind.processedTargets`. If so, skip.
+
+2. **Update state.** Set `grind.currentTarget` in `titan-state.json`. Write immediately.
+
+3. **Reload grind-targets.ndjson** entry for this target to get classification, consumers, and pattern.
+
+4. **Understand before touching.** Run codegraph commands to get current state (code may have changed since classification):
+   ```bash
+   codegraph context <target> -T --json
+   codegraph fn-impact <target> -T --json
+   ```
+
+   For adopt targets, also understand each consumer site:
+   ```bash
+   codegraph audit --quick <consumer-file> -T --json
+   codegraph where --file <consumer-file> -T --json
+   ```
+
+5. **Check if still dead.** The target may have been adopted by a previous grind commit in this phase:
+   ```bash
+   codegraph roles --role dead -T --file <target-file> --json
+   ```
+   If the target is no longer dead → skip with note: "Target already adopted by a prior grind commit."
+
+6. **Read source file(s).** Read the helper source and each consumer site. Understand the code before editing.
+
+7. **Apply the change** based on classification:
+
+   - **adopt**: Replace inline duplications with calls to the helper. Add imports at each consumer. Verify semantic equivalence — the replacement must produce identical behavior.
+   - **re-export**: Add the symbol to the barrel file's export list.
+   - **promote**: Add `export` keyword (or `pub` visibility in Rust), add to barrel if applicable, then wire consumers as in **adopt**.
+   - **remove**: Delete the symbol. Clean up orphaned imports. Verify no consumers with `codegraph fn-impact <target> -T --json` first.
+
+8. **Stage changed files:**
+   ```bash
+   git add <specific changed files>
+   ```
+   Never `git add .` or `git add -A`.
+
+9. **Verify impact before committing:**
+   ```bash
+   codegraph diff-impact --staged -T --json
+   ```
+   Review the blast radius. If transitive callers > 30 for a simple adoption, something is wrong — review the change carefully.
+
+10. **Run /titan-gate:**
+    Use the Skill tool to invoke `titan-gate`.
+    - If FAIL on **cycle/test/lint/build** → go to rollback (step 13).
+    - If FAIL on **other checks** → unstage with `git restore --staged $(git diff --cached --name-only)`, add to `grind.failedTargets` with reason, continue to next target.
+
+11. **Commit on success:**
+    ```bash
+    git commit -m "grind(<scope>): adopt <helper> across <N> consumers"
+    ```
+    For removals:
+    ```bash
+    git commit -m "grind(<scope>): remove unused <helper>"
+    ```
+
+12. **Update state on success.** Write `titan-state.json` immediately after each commit:
+    - Add target to `grind.processedTargets`
+    - Record in `grind.adoptions` (or `grind.removals`):
+      ```json
+      {
+        "target": "<helper-name>",
+        "classification": "adopt|re-export|promote|remove",
+        "consumers": ["file1.ts", "file2.ts"],
+        "commit": "<sha>",
+        "phase": N
+      }
+      ```
+    - Clear `grind.currentTarget`
+
+13. **On failure (test or gate rollback):**
+    ```bash
+    # Discover dirty files at rollback time
+    git restore --staged $(git diff --cached --name-only) 2>/dev/null
+    git checkout -- $(git diff --name-only) 2>/dev/null
+    ```
+    - Add to `grind.failedTargets`: `{ "target": "<name>", "reason": "<why>", "phase": N }`
+    - Add target to `grind.processedTargets` (so it's not retried on resume)
+    - Clear `grind.currentTarget`
+    - Write `titan-state.json`
+    - **Continue to next target** — don't block the whole phase
+
+14. **Rebuild graph** after changes to keep it current for the next target:
+    ```bash
+    codegraph build
+    ```
+
+For **false-positive** and **intentionally-private** targets: add to `grind.processedTargets` and `grind.falsePositives`, write state, but make no code changes. These inform future improvements to codegraph's dead-code detection.
+
+---
+
+## Step 4 — Dead-symbol delta gate
+
+After all targets in the phase are processed:
+
+```bash
+codegraph build
+codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const items=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:items.length,byRole:items.reduce((a,i)=>{a[i.role]=(a[i.role]||0)+1;return a},{})}));})"
+```
+
+Store in `grind.deadSymbolCurrent`. Write `titan-state.json`.
+
+Compute delta: `current - baseline`.
+
+| Delta | Verdict |
+|-------|---------|
+| delta < 0 | **PASS** — grind reduced dead symbols |
+| delta == 0 | **PASS** — neutral (all new helpers were adopted or removed) |
+| delta > 0, delta <= 10 | **WARN** — slight increase, likely false positives from type-level symbols |
+| delta > 10 | **FAIL** — forge created helpers that grind couldn't adopt. Review `grind.adoptions` for missed opportunities |
+
+On FAIL: print the new dead symbols that were not addressed and their files. Do NOT block — log the warning and continue.
+
+---
+
+## Step 5 — Phase completion
+
+1. Add phase number to `grind.completedPhases`
+2. Update `grind.deadSymbolBaseline` to `grind.deadSymbolCurrent` (rolling baseline for next phase)
+3. Clear `grind.currentPhase`
+4. Clear `grind.currentTarget`
+5. Write updated `titan-state.json`
+
+---
+
+## Step 6 — Report
+
+Print:
+
+```
+## Grind Phase N Complete: <label>
+
+Dead symbols: <baseline> → <current> (delta: <+/-N>)
+Targets: <processed>/<total> processed, <failed> failed
+Adoptions: <N> helpers wired into <M> consumers
+Removals: <N> unused helpers deleted
+False positives: <N> (codegraph resolution bugs)
+Intentionally private: <N>
+
+### Adoptions:
+- <helper>: adopted by <N> consumers (<classification>)
+  Commit: <sha>
+
+### Removals:
+- <helper>: removed (no adoption opportunity)
+  Commit: <sha>
+
+### Failed targets (if any):
+- <target>: <reason>
+
+### False positives (codegraph bugs to investigate):
+- <symbol>: <reason> (dynamic import / re-export chain / closure)
+
+### Next: Phase M — <label>
+Run /titan-grind to continue.
+```
+
+If all phases are complete:
+
+```
+## All grind phases complete
+
+Dead symbols: <initial baseline> → <final> (total delta: <+/-N>)
+Total adoptions: <N> across <M> consumers
+Total removals: <N>
+Total false positives: <N>
+Total failed: <N>
+
+Run /titan-close to finalize.
+```
+
+---
+
+## Edge Cases
+
+- **Interrupted mid-target:** On re-run, `grind.currentTarget` is set. Check if target has uncommitted changes (`git status`). If dirty → rollback dirty files, then re-process the target. If clean → the commit succeeded but state wasn't updated; check `git log -1` to see if the last commit matches, and update state accordingly.
+- **Interrupted mid-classification (Step 2):** On re-run, `grind-targets.ndjson` has partial entries. Load existing entries, skip already-classified targets, continue from the next unclassified candidate.
+- **No dead helpers in a phase:** Skip with note. Some forge phases may have wired everything correctly.
+- **Helper is used via dynamic import:** Classify as false-positive. Note for codegraph bug tracking.
+- **Helper is in Rust, consumers are TypeScript (or vice versa):** Cross-language helpers cannot be adopted across the FFI boundary. Classify as intentionally-private if used within their language, or false-positive if the dead flag is from FFI resolution limits.
+- **Gate fails on adoption:** Rollback, record failure, continue. A failed adoption may indicate the helper's semantics don't match the inline pattern exactly.
+- **Helper was adopted by a previous target in this phase:** Check `codegraph roles --role dead` before applying — if no longer dead, skip.
+- **`--target <name>`:** Run single target only. Useful for retrying entries in `grind.failedTargets`.
+- **`--dry-run`:** Walk through all targets, classify them, persist to `grind-targets.ndjson`, print the adoption plan, but make no code changes or commits.
+
+---
+
+## Rules
+
+- **One forge phase per invocation.** Stop after the phase completes. User re-runs for next.
+- **Resumable.** State is written after every target. If interrupted, re-running picks up from `grind.currentTarget` and `grind.processedTargets`. Already-committed adoptions are skipped.
+- **Always use `--json` and `-T`** for codegraph commands.
+- **Use codegraph to understand before editing.** Run `codegraph context`, `codegraph audit --quick`, `codegraph fn-impact`, and `codegraph where` before touching any code. Run `codegraph diff-impact --staged` before committing.
+- **Gate before commit.** Every commit must pass `/titan-gate`. No exceptions.
+- **Stage only specific files.** Never `git add .` or `git add -A`.
+- **Never change control flow.** Adoptions must be semantically identical to the code they replace. If the helper does something slightly different from the inline pattern, skip it.
+- **Rollback on failure is gentle** — `git restore --staged` to unstage, `git checkout --` to revert working tree. Never `git reset --hard`.
+- **Persist state after every target.** Write `titan-state.json` after each commit, failure, or classification. The `.ndjson` file is append-only — never rewrite it.
+- **Dead-symbol delta is advisory, not blocking.** Some increase from type-level symbols is expected. The gate catches real problems.
+- **Log false positives.** These are codegraph bugs. The report feeds back into improving dead-code detection.
+
+## Relationship to Other Skills
+
+| Skill | Relationship |
+|-------|-------------|
+| `/titan-forge` | Grind runs after forge — processes forge's output |
+| `/titan-gate` | Called per-commit for validation (same as forge) |
+| `/titan-close` | Runs after grind — includes grind metrics in final report |
+| `/titan-sync` | Grind reads sync.json to map commits to phases |
+| `/titan-recon` | Grind reads titan-state.json produced by recon |
+
+## Self-Improvement
+
+This skill lives at `.claude/skills/titan-grind/SKILL.md`. Edit if adoption strategies need refinement or the dead-symbol delta thresholds need adjustment after dogfooding.
diff --git a/.claude/skills/titan-run/SKILL.md b/.claude/skills/titan-run/SKILL.md
index e8be1c75..7cce5b2f 100644
--- a/.claude/skills/titan-run/SKILL.md
+++ b/.claude/skills/titan-run/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: titan-run
-description: Run the full Titan Paradigm pipeline end-to-end by dispatching each phase to sub-agents with fresh context windows. Orchestrates recon → gauntlet → sync → forge automatically.
-argument-hint: <path (default: .)> <--skip-recon> <--skip-gauntlet> <--start-from recon|gauntlet|sync|forge> <--gauntlet-batch-size 5> <--yes>
+description: Run the full Titan Paradigm pipeline end-to-end by dispatching each phase to sub-agents with fresh context windows. Orchestrates recon → gauntlet → sync → forge → grind automatically.
+argument-hint: <path (default: .)> <--skip-recon> <--skip-gauntlet> <--start-from recon|gauntlet|sync|forge|grind> <--gauntlet-batch-size 5> <--yes>
 allowed-tools: Agent, Read, Bash, Glob, Write, Edit
 ---
 
@@ -16,7 +16,7 @@ You are the **orchestrator** for the full Titan Paradigm pipeline. Your job is t
 - `<path>` → target path (passed to recon)
 - `--skip-recon` → skip recon (assumes artifacts exist)
 - `--skip-gauntlet` → skip gauntlet (assumes artifacts exist)
-- `--start-from <phase>` → jump to phase: `recon`, `gauntlet`, `sync`, `forge`
+- `--start-from <phase>` → jump to phase: `recon`, `gauntlet`, `sync`, `forge`, `grind`
 - `--gauntlet-batch-size <N>` → batch size for gauntlet (default: 5)
 - `--yes` → skip all confirmation prompts in the orchestrator (pre-pipeline, forge checkpoint, and resume prompts) and in forge (per-phase confirmation)
 
@@ -62,11 +62,11 @@ You are the **orchestrator** for the full Titan Paradigm pipeline. Your job is t
    ```bash
    npm install -g @optave/codegraph@latest
    ```
-   Log the installed version (skip if codegraph is not available):
+   Log the installed version:
    ```bash
-   codegraph --version || true
+   codegraph --version
    ```
-   If the install fails or `codegraph` is not found, warn the user but continue — the sub-agents may still work if a project-local version is available.
+   If the install fails, warn the user but continue with whichever version is currently available.
 
 5. **Sync with main** (once, before any sub-agent runs):
    ```bash
@@ -81,9 +81,10 @@ You are the **orchestrator** for the full Titan Paradigm pipeline. Your job is t
    Starting from: <phase>
    Gauntlet batch size: <N>
 
-   Phases: recon → gauntlet (loop) → sync → [PAUSE] → forge (loop)
+   Phases: recon → gauntlet (loop) → sync → [PAUSE] → forge (loop) → grind (loop) → close
    Each phase runs in a sub-agent with a fresh context window.
    Forge requires explicit confirmation (analysis phases are safe to automate).
+   Grind runs after forge to adopt extracted helpers into consumers.
    ```
 
    Start immediately — do NOT ask for confirmation before analysis phases. The user invoked `/titan-run`; that is the confirmation. Analysis phases (recon, gauntlet, sync) are read-only and safe to automate. The forge checkpoint (Step 3.5b) still applies unless `--yes` is set.
@@ -141,6 +142,7 @@ For each phase BEFORE `startPhase`, run the corresponding V-checks:
 | `recon` | V1 structural fields only (domains, batches, priorityQueue, stats — skip `currentPhase == "recon"` check since later phases advance it), V2 (GLOBAL_ARCH.md), V3 (snapshot exists — WARN if missing), V4 (cross-check counts) |
 | `gauntlet` | V5 (coverage ≥ 50%), V6 (entry completeness sample), V7 (summary consistency); also run NDJSON integrity check (2c) |
 | `sync` | V8 (sync.json structure), V9 (targets trace to gauntlet), V10 (dependency order) |
+| `forge` | V14 (final state consistency), V15 (gate log consistency); execution block must exist in titan-state.json |
 
 If ANY required artifact is **missing** → stop: "Cannot start from `<phase>` — `<artifact>` is missing. Run the full pipeline or start from an earlier phase."
 
@@ -632,6 +634,113 @@ Record `phaseTimestamps.forge.completedAt`.
 
 ---
 
+## Step 4.5 — GRIND (loop)
+
+Grind runs after forge to close the adoption loop. Forge extracts helpers; grind wires them into consumers and removes dead code. Without grind, the dead symbol count inflates with every forge phase.
+
+**Skip if:** `--start-from` is `close`, or `titan-state.json → grind.completedPhases` already covers all forge phases.
+
+### 4.5a. Pre-loop check
+
+Record `phaseTimestamps.grind.startedAt` (only if not already set — grind may be resuming).
+
+Read `.codegraph/titan/sync.json` → count total phases in `executionOrder`.
+Read `.codegraph/titan/titan-state.json` → check `grind.completedPhases` (may not exist yet if grind hasn't started).
+
+### 4.5b. Grind loop
+
+Set `maxIterations = 20` (safety limit — same as forge).
+Set `stallCount = 0`, `maxStalls = 2`.
+
+```
+previousGrindPhases = grind.completedPhases (or [])
+iteration = 0
+
+while iteration < maxIterations:
+    iteration += 1
+
+    # Run Pre-Agent Gate (G1-G4)
+
+    # Determine next forge phase to grind
+    Read .codegraph/titan/titan-state.json
+    grindCompleted = grind.completedPhases (or [])
+    forgePhases = execution.completedPhases (or [])
+    ungroundPhases = forgePhases.filter(p => !grindCompleted.includes(p))
+    if len(ungroundPhases) == 0 → break
+
+    nextPhase = ungroundPhases[0]
+
+    headBefore = $(git rev-parse HEAD)
+
+    yesFlag = "--yes" if autoConfirm else ""
+    Agent → "Run /titan-grind --phase <nextPhase> <yesFlag>.
+             Read .claude/skills/titan-grind/SKILL.md and follow it exactly.
+             Skip worktree check and main sync — already handled.
+
+             For each dead helper from forge phase <nextPhase>:
+             1. Classify: adopt / re-export / promote / false-positive / intentionally-private / remove
+             2. For adopt/re-export/promote: wire consumers, stage, run /titan-gate, commit
+             3. For remove: delete, stage, run /titan-gate, commit
+             4. Gate on dead-symbol delta at phase end"
+
+    # Post-agent checks
+    headAfter = $(git rev-parse HEAD)
+
+    Read .codegraph/titan/titan-state.json
+    newGrindPhases = grind.completedPhases (or [])
+
+    if newGrindPhases == previousGrindPhases:
+        stallCount += 1
+        Print: "WARNING: Grind iteration <iteration> made no progress (stall <stallCount>/<maxStalls>)"
+        if stallCount >= maxStalls:
+            Stop: "Grind stalled on phase <nextPhase>. Check titan-state.json → grind for details."
+    else:
+        stallCount = 0
+
+    previousGrindPhases = newGrindPhases
+
+    # V16. Commit audit
+    if headAfter != headBefore:
+        git log --oneline <headBefore>..<headAfter>
+        commitCount = number of commits
+        Print: "Grind phase <nextPhase>: <commitCount> adoption commits"
+    else:
+        Print: "Grind phase <nextPhase>: no adoptions needed (forge wired everything correctly)"
+
+    # V17. Test suite still green (same as forge V13)
+    if headAfter != headBefore:
+        testCmd = <same detection as forge V13>
+        if testCmd != "NO_TEST_SCRIPT":
+            Run: <testCmd> 2>&1
+            if tests fail:
+                Print: "CRITICAL: Test suite fails after grind phase <nextPhase>. Stopping pipeline."
+                Print: "Commits from this phase: git log --oneline <headBefore>..<headAfter>"
+                Stop.
+```
+
+### 4.5c. Post-loop validation
+
+**V18. Dead-symbol delta:**
+Read `grind.deadSymbolBaseline` and `grind.deadSymbolCurrent` from `titan-state.json`.
+- If delta > 10: **WARN** "Grind could not fully adopt forge's helpers. <delta> new dead symbols remain."
+- Otherwise: Print summary.
+
+**V19. Grind coverage:**
+- Count forge phases processed vs total forge phases
+- If < 100%: **WARN** with details
+
+Print grind summary:
+```
+GRIND complete.
+Dead symbols: <baseline> → <current> (delta: <+/-N>)
+Adoptions: <N> helpers wired, <N> removed, <N> false positives logged
+Phases ground: <N>/<M>
+```
+
+Record `phaseTimestamps.grind.completedAt`.
+
+---
+
 ## Step 5 — CLOSE (report + PRs)
 
 After forge completes, dispatch `/titan-close` to produce the final report with before/after metrics and split commits into focused PRs.
@@ -676,7 +785,7 @@ Record `phaseTimestamps.close.completedAt`.
 
 - **You are the orchestrator, not the executor.** Never run codegraph commands, edit source files, or make commits yourself. Only spawn sub-agents and read state files. Exceptions (pure validation/snapshot, no code changes): the post-forge test run (V13), NDJSON integrity checks, the V3 baseline snapshot check (`codegraph snapshot list`), and the pre-forge architectural snapshot capture (Step 3.5a) are run directly by the orchestrator.
 - **Run the Pre-Agent Gate (G1-G4) before EVERY sub-agent.** No exceptions.
-- **One sub-agent at a time.** Phases are sequential — recon before gauntlet, gauntlet before sync, sync before forge.
+- **One sub-agent at a time.** Phases are sequential — recon before gauntlet, gauntlet before sync, sync before forge, forge before grind, grind before close.
 - **Fresh context per sub-agent.** This is the whole point — each sub-agent gets a clean context window.
 - **Read AND validate state files after every sub-agent.** Trust the on-disk state, not the sub-agent's text output — but verify the state is structurally sound.
 - **Back up state before every sub-agent.** The `.bak` file is your safety net against mid-write crashes.
diff --git a/crates/codegraph-core/src/extractors/c.rs b/crates/codegraph-core/src/extractors/c.rs
index 1dde22be..cd864a05 100644
--- a/crates/codegraph-core/src/extractors/c.rs
+++ b/crates/codegraph-core/src/extractors/c.rs
@@ -297,11 +297,11 @@ fn match_c_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: u
                         });
                     }
                     "field_expression" => {
-                        let name = fn_node.child_by_field_name("field")
-                            .map(|n| node_text(&n, source).to_string())
+                        let name = named_child_text(&fn_node, "field", source)
+                            .map(|s| s.to_string())
                             .unwrap_or_else(|| node_text(&fn_node, source).to_string());
-                        let receiver = fn_node.child_by_field_name("argument")
-                            .map(|n| node_text(&n, source).to_string());
+                        let receiver = named_child_text(&fn_node, "argument", source)
+                            .map(|s| s.to_string());
                         symbols.calls.push(Call {
                             name,
                             line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/cpp.rs b/crates/codegraph-core/src/extractors/cpp.rs
index d9e97266..ea069146 100644
--- a/crates/codegraph-core/src/extractors/cpp.rs
+++ b/crates/codegraph-core/src/extractors/cpp.rs
@@ -171,21 +171,6 @@ fn extract_cpp_enum_constants(node: &Node, source: &[u8]) -> Vec<Definition> {
     constants
 }
 
-fn find_cpp_parent_class<'a>(node: &Node<'a>, source: &[u8]) -> Option<String> {
-    let mut current = node.parent();
-    while let Some(parent) = current {
-        match parent.kind() {
-            "class_specifier" | "struct_specifier" => {
-                return parent.child_by_field_name("name")
-                    .map(|n| node_text(&n, source).to_string());
-            }
-            _ => {}
-        }
-        current = parent.parent();
-    }
-    None
-}
-
 fn extract_cpp_base_classes(node: &Node, source: &[u8], class_name: &str, symbols: &mut FileSymbols) {
     for i in 0..node.child_count() {
         if let Some(child) = node.child(i) {
@@ -214,7 +199,7 @@ fn extract_cpp_base_classes(node: &Node, source: &[u8], class_name: &str, symbol
 
 fn handle_cpp_function_definition(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     if let Some(name) = extract_cpp_function_name(node, source) {
-        let parent_class = find_cpp_parent_class(node, source);
+        let parent_class = find_enclosing_type_name(node, &["class_specifier", "struct_specifier"], source);
         let full_name = match &parent_class {
             Some(cls) => format!("{}.{}", cls, name),
             None => name,
@@ -360,11 +345,11 @@ fn handle_cpp_call_expression(node: &Node, source: &[u8], symbols: &mut FileSymb
                 });
             }
             "field_expression" => {
-                let name = fn_node.child_by_field_name("field")
-                    .map(|n| node_text(&n, source).to_string())
+                let name = named_child_text(&fn_node, "field", source)
+                    .map(|s| s.to_string())
                     .unwrap_or_else(|| node_text(&fn_node, source).to_string());
-                let receiver = fn_node.child_by_field_name("argument")
-                    .map(|n| node_text(&n, source).to_string());
+                let receiver = named_child_text(&fn_node, "argument", source)
+                    .map(|s| s.to_string());
                 symbols.calls.push(Call {
                     name,
                     line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/csharp.rs b/crates/codegraph-core/src/extractors/csharp.rs
index 6118dfc0..53245371 100644
--- a/crates/codegraph-core/src/extractors/csharp.rs
+++ b/crates/codegraph-core/src/extractors/csharp.rs
@@ -221,8 +221,8 @@ fn handle_invocation_expr(node: &Node, source: &[u8], symbols: &mut FileSymbols)
         }
         "member_access_expression" => {
             if let Some(name) = fn_node.child_by_field_name("name") {
-                let receiver = fn_node.child_by_field_name("expression")
-                    .map(|expr| node_text(&expr, source).to_string());
+                let receiver = named_child_text(&fn_node, "expression", source)
+                    .map(|s| s.to_string());
                 symbols.calls.push(Call {
                     name: node_text(&name, source).to_string(),
                     line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/go.rs b/crates/codegraph-core/src/extractors/go.rs
index efd5d1bf..0d9d30b0 100644
--- a/crates/codegraph-core/src/extractors/go.rs
+++ b/crates/codegraph-core/src/extractors/go.rs
@@ -207,8 +207,8 @@ fn handle_call_expr(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         }
         "selector_expression" => {
             if let Some(field) = fn_node.child_by_field_name("field") {
-                let receiver = fn_node.child_by_field_name("operand")
-                    .map(|op| node_text(&op, source).to_string());
+                let receiver = named_child_text(&fn_node, "operand", source)
+                    .map(|s| s.to_string());
                 symbols.calls.push(Call {
                     name: node_text(&field, source).to_string(),
                     line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/helpers.rs b/crates/codegraph-core/src/extractors/helpers.rs
index 77ac8220..b0253189 100644
--- a/crates/codegraph-core/src/extractors/helpers.rs
+++ b/crates/codegraph-core/src/extractors/helpers.rs
@@ -75,9 +75,8 @@ pub fn find_enclosing_type_name(node: &Node, kinds: &[&str], source: &[u8]) -> O
     let mut current = node.parent();
     while let Some(parent) = current {
         if kinds.contains(&parent.kind()) {
-            return parent
-                .child_by_field_name("name")
-                .map(|n| node_text(&n, source).to_string());
+            return named_child_text(&parent, "name", source)
+                .map(|s| s.to_string());
         }
         current = parent.parent();
     }
@@ -541,8 +540,8 @@ fn walk_ast_nodes_with_config_depth(
 fn extract_constructor_name(node: &Node, source: &[u8]) -> String {
     // Try common field names for the constructed type
     for field in &["type", "class", "constructor"] {
-        if let Some(child) = node.child_by_field_name(field) {
-            return node_text(&child, source).to_string();
+        if let Some(text) = named_child_text(node, field, source) {
+            return text.to_string();
         }
     }
     for i in 0..node.child_count() {
@@ -599,8 +598,8 @@ fn extract_awaited_name(node: &Node, source: &[u8]) -> String {
 /// Extract function name from a call node.
 fn extract_call_name(node: &Node, source: &[u8]) -> String {
     for field in &["function", "method", "name"] {
-        if let Some(fn_node) = node.child_by_field_name(field) {
-            return node_text(&fn_node, source).to_string();
+        if let Some(text) = named_child_text(node, field, source) {
+            return text.to_string();
         }
     }
     let text = node_text(node, source);
diff --git a/crates/codegraph-core/src/extractors/java.rs b/crates/codegraph-core/src/extractors/java.rs
index 8739539a..0f7af903 100644
--- a/crates/codegraph-core/src/extractors/java.rs
+++ b/crates/codegraph-core/src/extractors/java.rs
@@ -264,8 +264,8 @@ fn handle_import_decl(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 
 fn handle_method_invocation(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     if let Some(name_node) = node.child_by_field_name("name") {
-        let receiver = node.child_by_field_name("object")
-            .map(|obj| node_text(&obj, source).to_string());
+        let receiver = named_child_text(node, "object", source)
+            .map(|s| s.to_string());
         symbols.calls.push(Call {
             name: node_text(&name_node, source).to_string(),
             line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/javascript.rs b/crates/codegraph-core/src/extractors/javascript.rs
index 724b52d7..45ae52df 100644
--- a/crates/codegraph-core/src/extractors/javascript.rs
+++ b/crates/codegraph-core/src/extractors/javascript.rs
@@ -46,7 +46,7 @@ fn extract_new_expr_type_name<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&
     match ctor.kind() {
         "identifier" => Some(node_text(&ctor, source)),
         "member_expression" => {
-            ctor.child_by_field_name("property").map(|p| node_text(&p, source))
+            named_child_text(&ctor, "property", source)
         }
         _ => None,
     }
@@ -905,8 +905,8 @@ fn extract_call_info(fn_node: &Node, call_node: &Node, source: &[u8]) -> Option<
             if prop.kind() == "string" || prop.kind() == "string_fragment" {
                 let method_name = node_text(&prop, source).replace(&['\'', '"'][..], "");
                 if !method_name.is_empty() {
-                    let receiver = fn_node.child_by_field_name("object")
-                        .map(|obj| node_text(&obj, source).to_string());
+                    let receiver = named_child_text(&fn_node, "object", source)
+                        .map(|s| s.to_string());
                     return Some(Call {
                         name: method_name,
                         line: start_line(call_node),
@@ -916,8 +916,8 @@ fn extract_call_info(fn_node: &Node, call_node: &Node, source: &[u8]) -> Option<
                 }
             }
 
-            let receiver = fn_node.child_by_field_name("object")
-                .map(|obj| node_text(&obj, source).to_string());
+            let receiver = named_child_text(&fn_node, "object", source)
+                .map(|s| s.to_string());
             Some(Call {
                 name: prop_text.to_string(),
                 line: start_line(call_node),
@@ -932,8 +932,8 @@ fn extract_call_info(fn_node: &Node, call_node: &Node, source: &[u8]) -> Option<
                     let method_name = node_text(&index, source)
                         .replace(&['\'', '"', '`'][..], "");
                     if !method_name.is_empty() && !method_name.contains('$') {
-                        let receiver = fn_node.child_by_field_name("object")
-                            .map(|obj| node_text(&obj, source).to_string());
+                        let receiver = named_child_text(&fn_node, "object", source)
+                            .map(|s| s.to_string());
                         return Some(Call {
                             name: method_name,
                             line: start_line(call_node),
diff --git a/crates/codegraph-core/src/extractors/php.rs b/crates/codegraph-core/src/extractors/php.rs
index 6e111107..00806987 100644
--- a/crates/codegraph-core/src/extractors/php.rs
+++ b/crates/codegraph-core/src/extractors/php.rs
@@ -255,8 +255,8 @@ fn handle_function_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 
 fn handle_member_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     if let Some(name) = node.child_by_field_name("name") {
-        let receiver = node.child_by_field_name("object")
-            .map(|obj| node_text(&obj, source).to_string());
+        let receiver = named_child_text(node, "object", source)
+            .map(|s| s.to_string());
         symbols.calls.push(Call {
             name: node_text(&name, source).to_string(),
             line: start_line(node),
@@ -268,8 +268,8 @@ fn handle_member_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 
 fn handle_scoped_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     if let Some(name) = node.child_by_field_name("name") {
-        let receiver = node.child_by_field_name("scope")
-            .map(|s| node_text(&s, source).to_string());
+        let receiver = named_child_text(node, "scope", source)
+            .map(|s| s.to_string());
         symbols.calls.push(Call {
             name: node_text(&name, source).to_string(),
             line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/python.rs b/crates/codegraph-core/src/extractors/python.rs
index b59a4a89..108fb099 100644
--- a/crates/codegraph-core/src/extractors/python.rs
+++ b/crates/codegraph-core/src/extractors/python.rs
@@ -116,11 +116,10 @@ fn handle_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     let (call_name, receiver) = match fn_node.kind() {
         "identifier" => (Some(node_text(&fn_node, source).to_string()), None),
         "attribute" => {
-            let name = fn_node
-                .child_by_field_name("attribute")
-                .map(|a| node_text(&a, source).to_string());
-            let recv = fn_node.child_by_field_name("object")
-                .map(|obj| node_text(&obj, source).to_string());
+            let name = named_child_text(&fn_node, "attribute", source)
+                .map(|s| s.to_string());
+            let recv = named_child_text(&fn_node, "object", source)
+                .map(|s| s.to_string());
             (name, recv)
         }
         _ => (None, None),
@@ -207,8 +206,8 @@ fn extract_python_parameters(node: &Node, source: &[u8], is_method: bool) -> Vec
                         Some(text.to_string())
                     }
                     "default_parameter" | "typed_default_parameter" => {
-                        child.child_by_field_name("name")
-                            .map(|n| node_text(&n, source).to_string())
+                        named_child_text(&child, "name", source)
+                            .map(|s| s.to_string())
                     }
                     "typed_parameter" => {
                         // typed_parameter: first child is the identifier
@@ -312,9 +311,7 @@ fn extract_python_type_name<'a>(type_node: &Node<'a>, source: &'a [u8]) -> Optio
         "identifier" | "attribute" => Some(node_text(type_node, source)),
         "subscript" => {
             // List[int] → List
-            type_node
-                .child_by_field_name("value")
-                .map(|n| node_text(&n, source))
+            named_child_text(type_node, "value", source)
         }
         _ => None,
     }
diff --git a/crates/codegraph-core/src/extractors/ruby.rs b/crates/codegraph-core/src/extractors/ruby.rs
index 6402a381..8f7506f7 100644
--- a/crates/codegraph-core/src/extractors/ruby.rs
+++ b/crates/codegraph-core/src/extractors/ruby.rs
@@ -119,8 +119,8 @@ fn handle_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     } else if method_text == "include" || method_text == "extend" || method_text == "prepend" {
         handle_mixin_call(node, source, symbols);
     } else {
-        let receiver = node.child_by_field_name("receiver")
-            .map(|r| node_text(&r, source).to_string());
+        let receiver = named_child_text(node, "receiver", source)
+            .map(|s| s.to_string());
         symbols.calls.push(Call {
             name: method_text.to_string(),
             line: start_line(node),
diff --git a/crates/codegraph-core/src/extractors/rust_lang.rs b/crates/codegraph-core/src/extractors/rust_lang.rs
index ff4d7324..a8397a4f 100644
--- a/crates/codegraph-core/src/extractors/rust_lang.rs
+++ b/crates/codegraph-core/src/extractors/rust_lang.rs
@@ -21,9 +21,8 @@ fn find_current_impl<'a>(node: &Node<'a>, source: &[u8]) -> Option<String> {
     let mut current = node.parent();
     while let Some(parent) = current {
         if parent.kind() == "impl_item" {
-            return parent
-                .child_by_field_name("type")
-                .map(|n| node_text(&n, source).to_string());
+            return named_child_text(&parent, "type", source)
+                .map(|s| s.to_string());
         }
         current = parent.parent();
     }
@@ -194,8 +193,8 @@ fn handle_call_expr(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         }
         "field_expression" => {
             if let Some(field) = fn_node.child_by_field_name("field") {
-                let receiver = fn_node.child_by_field_name("value")
-                    .map(|v| node_text(&v, source).to_string());
+                let receiver = named_child_text(&fn_node, "value", source)
+                    .map(|s| s.to_string());
                 symbols.calls.push(Call {
                     name: node_text(&field, source).to_string(),
                     line: start_line(node),
@@ -206,8 +205,8 @@ fn handle_call_expr(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         }
         "scoped_identifier" => {
             if let Some(name) = fn_node.child_by_field_name("name") {
-                let receiver = fn_node.child_by_field_name("path")
-                    .map(|p| node_text(&p, source).to_string());
+                let receiver = named_child_text(&fn_node, "path", source)
+                    .map(|s| s.to_string());
                 symbols.calls.push(Call {
                     name: node_text(&name, source).to_string(),
                     line: start_line(node),
@@ -323,8 +322,8 @@ fn extract_rust_use_path(node: &Node, source: &[u8]) -> Vec<(String, Vec<String>
             vec![(node_text(node, source).to_string(), name.into_iter().collect())]
         }
         "use_wildcard" => {
-            let src = node.child_by_field_name("path")
-                .map(|p| node_text(&p, source).to_string())
+            let src = named_child_text(&node, "path", source)
+                .map(|s| s.to_string())
                 .unwrap_or_else(|| "*".to_string());
             vec![(src, vec!["*".to_string()])]
         }
@@ -338,8 +337,8 @@ fn extract_rust_use_path(node: &Node, source: &[u8]) -> Vec<(String, Vec<String>
 }
 
 fn extract_scoped_use_list(node: &Node, source: &[u8]) -> Vec<(String, Vec<String>)> {
-    let prefix = node.child_by_field_name("path")
-        .map(|p| node_text(&p, source).to_string())
+    let prefix = named_child_text(&node, "path", source)
+        .map(|s| s.to_string())
         .unwrap_or_default();
     let Some(list_node) = node.child_by_field_name("list") else {
         return vec![(prefix, vec![])];
diff --git a/src/cli/commands/batch.ts b/src/cli/commands/batch.ts
index 3ba6e1ef..c77324a3 100644
--- a/src/cli/commands/batch.ts
+++ b/src/cli/commands/batch.ts
@@ -1,26 +1,11 @@
 import fs from 'node:fs';
 import { collectFile } from '../../db/query-builder.js';
 import { EVERY_SYMBOL_KIND } from '../../domain/queries.js';
-import { BATCH_COMMANDS, multiBatchData, splitTargets } from '../../features/batch.js';
-import { batch } from '../../presentation/batch.js';
+import { BATCH_COMMANDS, splitTargets } from '../../features/batch.js';
+import { batchQuery } from '../../presentation/batch.js';
 import { ConfigError, toErrorMessage } from '../../shared/errors.js';
 import type { CommandDefinition } from '../types.js';
 
-interface MultiBatchItem {
-  command: string;
-  target: string;
-  opts?: Record<string, unknown>;
-}
-
-function isMultiBatch(targets: unknown[]): targets is MultiBatchItem[] {
-  return (
-    targets.length > 0 &&
-    typeof targets[0] === 'object' &&
-    targets[0] !== null &&
-    'command' in targets[0]
-  );
-}
-
 export const command: CommandDefinition = {
   name: 'batch <command> [targets...]',
   description: `Run a query against multiple targets in one call. Output is always JSON.\nValid commands: ${Object.keys(BATCH_COMMANDS).join(', ')}`,
@@ -69,18 +54,12 @@ export const command: CommandDefinition = {
       );
     }
 
-    const batchOpts = {
+    batchQuery(targets as Array<string | { command: string; target: string }>, opts.db, {
+      command,
       depth: opts.depth ? parseInt(opts.depth as string, 10) : undefined,
       file: opts.file,
       kind: opts.kind,
       noTests: ctx.resolveNoTests(opts),
-    };
-
-    if (isMultiBatch(targets)) {
-      const data = multiBatchData(targets as MultiBatchItem[], opts.db, batchOpts);
-      console.log(JSON.stringify(data, null, 2));
-    } else {
-      batch(command!, targets as string[], opts.db, batchOpts);
-    }
+    });
   },
 };
diff --git a/src/cli/commands/structure.ts b/src/cli/commands/structure.ts
index 795ab70f..20676305 100644
--- a/src/cli/commands/structure.ts
+++ b/src/cli/commands/structure.ts
@@ -15,9 +15,29 @@ export const command: CommandDefinition = {
     ['--limit <number>', 'Max results to return'],
     ['--offset <number>', 'Skip N results (default: 0)'],
     ['--ndjson', 'Newline-delimited JSON output'],
+    ['--modules', 'Show module boundaries (directories with high cohesion)'],
+    ['--threshold <number>', 'Cohesion threshold for --modules (default: 0.3)'],
   ],
   async execute([dir], opts, ctx) {
-    const { structureData, formatStructure } = await import('../../presentation/structure.js');
+    const { structureData, formatStructure, moduleBoundariesData, formatModuleBoundaries } =
+      await import('../../presentation/structure.js');
+
+    if (opts.modules) {
+      const parsed = opts.threshold ? parseFloat(opts.threshold as string) : undefined;
+      if (parsed !== undefined && Number.isNaN(parsed)) {
+        console.error('Error: --threshold must be a number');
+        process.exitCode = 1;
+        return;
+      }
+      const data = moduleBoundariesData(opts.db, {
+        threshold: parsed,
+      });
+      if (!ctx.outputResult(data, 'modules', opts)) {
+        console.log(formatModuleBoundaries(data));
+      }
+      return;
+    }
+
     const qOpts = ctx.resolveQueryOpts(opts);
     const data = structureData(opts.db, {
       directory: dir,
diff --git a/src/domain/analysis/context.ts b/src/domain/analysis/context.ts
index 32969d3e..d5ef6b0c 100644
--- a/src/domain/analysis/context.ts
+++ b/src/domain/analysis/context.ts
@@ -27,7 +27,7 @@ import {
   readSourceRange,
 } from '../../shared/file-utils.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type {
   BetterSqlite3Database,
@@ -177,7 +177,7 @@ function buildImplementationInfo(db: BetterSqlite3Database, node: NodeRow, noTes
     let impls = findImplementors(db, node.id) as RelatedNodeRow[];
     if (noTests) impls = impls.filter((n) => !isTestFile(n.file));
     return {
-      implementors: impls.map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line })),
+      implementors: impls.map(toSymbolRef),
     };
   }
   // For classes/structs: show what they implement
@@ -186,7 +186,7 @@ function buildImplementationInfo(db: BetterSqlite3Database, node: NodeRow, noTes
     if (noTests) ifaces = ifaces.filter((n) => !isTestFile(n.file));
     if (ifaces.length > 0) {
       return {
-        implements: ifaces.map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line })),
+        implements: ifaces.map(toSymbolRef),
       };
     }
   }
@@ -359,21 +359,11 @@ function explainFunctionImpl(
     const summary = fileLines ? extractSummary(fileLines, node.line, displayOpts) : null;
     const signature = fileLines ? extractSignature(fileLines, node.line, displayOpts) : null;
 
-    const callees = (findCallees(db, node.id) as RelatedNodeRow[]).map((c) => ({
-      name: c.name,
-      kind: c.kind,
-      file: c.file,
-      line: c.line,
-    }));
+    const callees = (findCallees(db, node.id) as RelatedNodeRow[]).map(toSymbolRef);
 
     const allCallerRows = findCallers(db, node.id) as RelatedNodeRow[];
 
-    let callers = allCallerRows.map((c) => ({
-      name: c.name,
-      kind: c.kind,
-      file: c.file,
-      line: c.line,
-    }));
+    let callers = allCallerRows.map(toSymbolRef);
     if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
 
     const seenFiles = new Set<string>();
diff --git a/src/domain/analysis/dependencies.ts b/src/domain/analysis/dependencies.ts
index 730f5309..1a619c86 100644
--- a/src/domain/analysis/dependencies.ts
+++ b/src/domain/analysis/dependencies.ts
@@ -2,7 +2,7 @@ import { findFileNodes, type Repository } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type {
   BetterSqlite3Database,
@@ -143,12 +143,8 @@ function buildNodeDepsResult(
 
   return {
     ...normalizeSymbol(node, repo, hc),
-    callees: filteredCallees.map((c) => ({
-      name: c.name,
-      kind: c.kind,
-      file: c.file,
-      line: c.line,
-    })),
+    callees: filteredCallees.map(toSymbolRef),
+    // Not using toSymbolRef — callers include the extra viaHierarchy field
     callers: callers.map((c) => ({
       name: c.name,
       kind: c.kind,
@@ -245,20 +241,14 @@ function resolveEndpoints(
         to,
         found: false,
         error: `No symbol matching "${to}"`,
-        fromCandidates: fromNodes
-          .slice(0, 5)
-          .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line })),
+        fromCandidates: fromNodes.slice(0, 5).map(toSymbolRef),
         toCandidates: [],
       },
     };
   }
 
-  const fromCandidates = fromNodes
-    .slice(0, 5)
-    .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line }));
-  const toCandidates = toNodes
-    .slice(0, 5)
-    .map((n) => ({ name: n.name, kind: n.kind, file: n.file, line: n.line }));
+  const fromCandidates = fromNodes.slice(0, 5).map(toSymbolRef);
+  const toCandidates = toNodes.slice(0, 5).map(toSymbolRef);
 
   return {
     sourceNode: fromNodes[0],
diff --git a/src/domain/analysis/fn-impact.ts b/src/domain/analysis/fn-impact.ts
index 687be1ea..f33ab26f 100644
--- a/src/domain/analysis/fn-impact.ts
+++ b/src/domain/analysis/fn-impact.ts
@@ -1,6 +1,6 @@
 import { Repository, SqliteRepository } from '../../db/index.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
 import { resolveAnalysisOpts, withRepo } from './query-helpers.js';
@@ -125,7 +125,7 @@ export function bfsTransitiveCallers(
           visited.add(c.id);
           nextFrontier.push(c.id);
           if (!levels[d]) levels[d] = [];
-          levels[d]!.push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
+          levels[d]!.push(toSymbolRef(c));
           if (onVisit) onVisit(c, fid, d);
         }
         if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
diff --git a/src/domain/analysis/implementations.ts b/src/domain/analysis/implementations.ts
index 2c5dc9e4..ea670383 100644
--- a/src/domain/analysis/implementations.ts
+++ b/src/domain/analysis/implementations.ts
@@ -1,6 +1,6 @@
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { CORE_SYMBOL_KINDS } from '../../shared/kinds.js';
-import { normalizeSymbol } from '../../shared/normalize.js';
+import { normalizeSymbol, toSymbolRef } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { RelatedNodeRow } from '../../types.js';
 import { withRepo } from './query-helpers.js';
@@ -34,12 +34,7 @@ export function implementationsData(
 
       return {
         ...normalizeSymbol(node, repo, hc),
-        implementors: implementors.map((impl) => ({
-          name: impl.name,
-          kind: impl.kind,
-          file: impl.file,
-          line: impl.line,
-        })),
+        implementors: implementors.map(toSymbolRef),
       };
     });
 
@@ -76,12 +71,7 @@ export function interfacesData(
 
       return {
         ...normalizeSymbol(node, repo, hc),
-        interfaces: interfaces.map((iface) => ({
-          name: iface.name,
-          kind: iface.kind,
-          file: iface.file,
-          line: iface.line,
-        })),
+        interfaces: interfaces.map(toSymbolRef),
       };
     });
 
diff --git a/src/domain/graph/builder/stages/detect-changes.ts b/src/domain/graph/builder/stages/detect-changes.ts
index bcd40510..ff5c6d8a 100644
--- a/src/domain/graph/builder/stages/detect-changes.ts
+++ b/src/domain/graph/builder/stages/detect-changes.ts
@@ -277,14 +277,14 @@ async function runPendingAnalysis(ctx: PipelineContext): Promise<boolean> {
     rootDir,
     analysisOpts,
   );
-  if (needsCfg) {
-    const { buildCFGData } = await import('../../../../features/cfg.js');
-    await buildCFGData(db, analysisSymbols, rootDir, engineOpts);
-  }
-  if (needsDataflow) {
-    const { buildDataflowEdges } = await import('../../../../features/dataflow.js');
-    await buildDataflowEdges(db, analysisSymbols, rootDir, engineOpts);
-  }
+  const { runAnalyses } = await import('../../../../ast-analysis/engine.js');
+  await runAnalyses(
+    db,
+    analysisSymbols,
+    rootDir,
+    { ast: false, complexity: false, cfg: needsCfg, dataflow: needsDataflow },
+    engineOpts,
+  );
   return true;
 }
 
diff --git a/src/domain/parser.ts b/src/domain/parser.ts
index ea424ab3..97272262 100644
--- a/src/domain/parser.ts
+++ b/src/domain/parser.ts
@@ -5,7 +5,7 @@ import type { Tree } from 'web-tree-sitter';
 import { Language, Parser, Query } from 'web-tree-sitter';
 import { debug, warn } from '../infrastructure/logger.js';
 import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
-import { toErrorMessage } from '../shared/errors.js';
+import { ParseError, toErrorMessage } from '../shared/errors.js';
 import type {
   EngineMode,
   ExtractorOutput,
@@ -188,7 +188,11 @@ async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
       _queryCache.set(entry.id, new Query(lang, patterns.join('\n')));
     }
   } catch (e: unknown) {
-    if (entry.required) throw e;
+    if (entry.required)
+      throw new ParseError(`Required parser ${entry.id} failed to initialize`, {
+        file: entry.grammarFile,
+        cause: e as Error,
+      });
     warn(
       `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
     );
diff --git a/src/domain/queries.ts b/src/domain/queries.ts
index 7a4413e9..70c465b3 100644
--- a/src/domain/queries.ts
+++ b/src/domain/queries.ts
@@ -22,7 +22,7 @@ export {
   VALID_ROLES,
 } from '../shared/kinds.js';
 // ── Shared utilities ─────────────────────────────────────────────────────
-export { kindIcon, normalizeSymbol } from '../shared/normalize.js';
+export { kindIcon, normalizeSymbol, toSymbolRef } from '../shared/normalize.js';
 export { briefData } from './analysis/brief.js';
 export { contextData, explainData } from './analysis/context.js';
 export { fileDepsData, filePathData, fnDepsData, pathData } from './analysis/dependencies.js';
diff --git a/src/features/audit.ts b/src/features/audit.ts
index d0ccb78d..18ee8174 100644
--- a/src/features/audit.ts
+++ b/src/features/audit.ts
@@ -7,6 +7,7 @@ import { loadConfig } from '../infrastructure/config.js';
 import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { toErrorMessage } from '../shared/errors.js';
+import { toSymbolRef } from '../shared/normalize.js';
 import type { BetterSqlite3Database, CodegraphConfig } from '../types.js';
 import { RULE_DEFS } from './manifesto.js';
 
@@ -317,7 +318,7 @@ function enrichSymbol(
          WHERE e.source_id = ? AND e.kind = 'calls'`,
         )
         .all(nodeId) as SymbolRef[]
-    ).map((c) => ({ name: c.name, kind: c.kind, file: c.file, line: c.line }));
+    ).map(toSymbolRef);
 
     callers = (
       db
@@ -327,7 +328,7 @@ function enrichSymbol(
          WHERE e.target_id = ? AND e.kind = 'calls'`,
         )
         .all(nodeId) as SymbolRef[]
-    ).map((c) => ({ name: c.name, kind: c.kind, file: c.file, line: c.line }));
+    ).map(toSymbolRef);
     if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
 
     const testCallerRows = db
diff --git a/src/features/boundaries.ts b/src/features/boundaries.ts
index 2580b90d..c792a284 100644
--- a/src/features/boundaries.ts
+++ b/src/features/boundaries.ts
@@ -1,5 +1,5 @@
-import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { BoundaryError } from '../shared/errors.js';
 import type { BetterSqlite3Database } from '../types.js';
 
 // ─── Glob-to-Regex ───────────────────────────────────────────────────
@@ -269,8 +269,7 @@ export function evaluateBoundaries(
 
   const { valid, errors } = validateBoundaryConfig(boundaryConfig);
   if (!valid) {
-    debug(`boundary config validation failed: ${errors.join('; ')}`);
-    return { violations: [], violationCount: 0 };
+    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
   }
 
   const modules = resolveModules(boundaryConfig);
@@ -297,8 +296,7 @@ export function evaluateBoundaries(
       )
       .all() as Array<{ source: string; target: string }>;
   } catch (err) {
-    debug(`boundary edge query failed: ${(err as Error).message}`);
-    return { violations: [], violationCount: 0 };
+    throw new BoundaryError('Boundary evaluation failed', { cause: err as Error });
   }
 
   if (opts.noTests) {
diff --git a/src/features/branch-compare.ts b/src/features/branch-compare.ts
index d0ec80e9..086ed1f1 100644
--- a/src/features/branch-compare.ts
+++ b/src/features/branch-compare.ts
@@ -9,6 +9,7 @@ import { debug } from '../infrastructure/logger.js';
 import { getNative, isNativeAvailable } from '../infrastructure/native.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { toErrorMessage } from '../shared/errors.js';
+import { toSymbolRef } from '../shared/normalize.js';
 import type { EngineMode, NativeDatabase } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
@@ -255,9 +256,7 @@ function loadCallersFromDb(
             if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
               visited.add(c.id);
               nextFrontier.push(c.id);
-              allCallers.add(
-                JSON.stringify({ name: c.name, kind: c.kind, file: c.file, line: c.line }),
-              );
+              allCallers.add(JSON.stringify(toSymbolRef(c)));
             }
           }
         }
diff --git a/src/features/flow.ts b/src/features/flow.ts
index 0d2d6c26..18c52215 100644
--- a/src/features/flow.ts
+++ b/src/features/flow.ts
@@ -8,6 +8,7 @@
 import { openReadonlyOrFail } from '../db/index.js';
 import { CORE_SYMBOL_KINDS, findMatchingNodes } from '../domain/queries.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { toSymbolRef } from '../shared/normalize.js';
 import { paginateResult } from '../shared/paginate.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
@@ -175,7 +176,7 @@ function bfsCallees(
 
         visited.add(c.id);
         nextFrontier.push(c.id);
-        const nodeInfo: NodeInfo = { name: c.name, kind: c.kind, file: c.file, line: c.line };
+        const nodeInfo: NodeInfo = toSymbolRef(c);
         levelNodes.push(nodeInfo);
         nodeDepths.set(c.id, d);
         idToNode.set(c.id, nodeInfo);
diff --git a/src/features/manifesto.ts b/src/features/manifesto.ts
index edf22bc0..3a94bd2d 100644
--- a/src/features/manifesto.ts
+++ b/src/features/manifesto.ts
@@ -5,6 +5,7 @@ import { loadConfig } from '../infrastructure/config.js';
 import { debug } from '../infrastructure/logger.js';
 import { paginateResult } from '../shared/paginate.js';
 import type { BetterSqlite3Database, CodegraphConfig, ThresholdRule } from '../types.js';
+import type { BoundaryViolation } from './boundaries.js';
 import { evaluateBoundaries } from './boundaries.js';
 
 // ─── Rule Definitions ─────────────────────────────────────────────────
@@ -416,7 +417,20 @@ function evaluateBoundaryRules(
     return;
   }
 
-  const result = evaluateBoundaries(db, boundaryConfig, { noTests: opts.noTests || false });
+  let result: { violations: BoundaryViolation[]; violationCount: number };
+  try {
+    result = evaluateBoundaries(db, boundaryConfig, { noTests: opts.noTests || false });
+  } catch (e: unknown) {
+    debug(`boundary check failed: ${(e as Error).message}`);
+    ruleResults.push({
+      name: 'boundaries',
+      level: 'graph',
+      status: 'warn',
+      thresholds: effectiveThresholds,
+      violationCount: 0,
+    });
+    return;
+  }
   const hasBoundaryViolations = result.violationCount > 0;
 
   if (!hasBoundaryViolations) {
diff --git a/src/presentation/structure.ts b/src/presentation/structure.ts
index b5208d48..202f57dd 100644
--- a/src/presentation/structure.ts
+++ b/src/presentation/structure.ts
@@ -75,7 +75,7 @@ export function formatHotspots(data: HotspotsResult): string {
 
 interface ModuleBoundaryEntry {
   directory: string;
-  cohesion: number;
+  cohesion: number | null;
   fileCount: number;
   symbolCount: number;
   fanIn: number;
@@ -95,7 +95,7 @@ export function formatModuleBoundaries(data: ModuleBoundariesResult): string {
   const lines = [`\nModule boundaries (cohesion >= ${data.threshold}, ${data.count} modules):\n`];
   for (const m of data.modules) {
     lines.push(
-      `  ${m.directory}/  cohesion=${m.cohesion.toFixed(2)}  (${m.fileCount} files, ${m.symbolCount} symbols)`,
+      `  ${m.directory}/  cohesion=${m.cohesion !== null ? m.cohesion.toFixed(2) : 'n/a'}  (${m.fileCount} files, ${m.symbolCount} symbols)`,
     );
     lines.push(`    Incoming: ${m.fanIn} edges    Outgoing: ${m.fanOut} edges`);
     if (m.files.length > 0) {
diff --git a/src/shared/normalize.ts b/src/shared/normalize.ts
index 6650d8dc..ce69d10c 100644
--- a/src/shared/normalize.ts
+++ b/src/shared/normalize.ts
@@ -19,6 +19,16 @@ export function getFileHash(db: DbHandle, file: string): string | null {
   return row ? row.hash : null;
 }
 
+/** Pick the 4-field symbol reference from any row that carries at least {name, kind, file, line}. */
+export function toSymbolRef(row: { name: string; kind: string; file: string; line: number }): {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+} {
+  return { name: row.name, kind: row.kind, file: row.file, line: row.line };
+}
+
 export function kindIcon(kind: string): string {
   switch (kind) {
     case 'function':
diff --git a/tests/unit/boundaries.test.ts b/tests/unit/boundaries.test.ts
index d3f9b440..8684d8bc 100644
--- a/tests/unit/boundaries.test.ts
+++ b/tests/unit/boundaries.test.ts
@@ -383,11 +383,12 @@ describe('evaluateBoundaries', () => {
     }
   });
 
-  test('returns empty on invalid config', () => {
+  test('throws BoundaryError on invalid config', () => {
     const database = openDb();
     try {
-      const result = evaluateBoundaries(database, { modules: {} });
-      expect(result.violations).toHaveLength(0);
+      expect(() => evaluateBoundaries(database, { modules: {} })).toThrow(
+        /Invalid boundary configuration/,
+      );
     } finally {
       database.close();
     }