diff --git a/.claude/skills/titan-close/SKILL.md b/.claude/skills/titan-close/SKILL.md
new file mode 100644
index 00000000..57568d65
--- /dev/null
+++ b/.claude/skills/titan-close/SKILL.md
@@ -0,0 +1,558 @@
+---
+name: titan-close
+description: Split branch commits into focused PRs, compile issue tracker, generate final report with before/after metrics (Titan Paradigm Phase 5)
+argument-hint: <--dry-run to preview without creating PRs>
+allowed-tools: Bash, Read, Write, Glob, Grep, Edit
+---
+
+# Titan CLOSE — PR Splitting & Final Report
+
+You are running the **CLOSE** phase of the Titan Paradigm.
+
+Your goal: analyze all commits on the current branch, split them into focused PRs for easier review, compile the issue tracker from all phases, capture final metrics, and generate a comprehensive audit report.
+
+> **Context budget:** This phase reads artifacts and git history. Keep codegraph queries targeted — only for final metrics comparison.
+
+**Dry-run mode:** If `$ARGUMENTS` contains `--dry-run`, preview the PR split plan and report without creating PRs or pushing branches.
+
+---
+
+## Step 0 — Pre-flight: find and consolidate the Titan session
+
+1. **Locate the Titan session.** All prior phases (RECON → GAUNTLET → SYNC → GATE) may have run across different worktrees or branches. You need to consolidate their work.
+
+   ```bash
+   git worktree list
+   ```
+
+   For each worktree, check for Titan artifacts:
+   ```bash
+   ls <worktree-path>/.codegraph/titan/titan-state.json 2>/dev/null
+   ```
+
+   Also check branches (including remote):
+   ```bash
+   git branch -a --list '*titan*'
+   git branch -a --list '*refactor/*'
+   ```
+
+   **Decision logic:**
+   - **Found exactly one worktree/branch with `titan-state.json`:** Read its `currentPhase`. If it's `"sync"` or later, this is the right session. Merge its branch into your worktree.
+   - **Found a worktree but `currentPhase` is earlier than expected (e.g., `"recon"` or `"gauntlet"`):** The pipeline may not be complete. Keep searching — there may be a more advanced worktree. If nothing better found, ask the user: "Found Titan state at `<path>` with phase `<phase>`. The pipeline appears incomplete. Continue anyway, or should I look elsewhere?"
+   - **Found multiple worktrees with `titan-state.json`:** List them all with `currentPhase`, `lastUpdated`, and branch name. The Titan pipeline may have been split across worktrees (RECON in one, GAUNTLET in another). Merge them in phase order into your worktree. If there's ambiguity (e.g., two worktrees at the same phase), ask the user.
+   - **Found branches but no worktrees:** Merge the titan branch(es) in phase order: `git merge <branch> --no-edit`
+   - **Found nothing:** Stop: "No Titan session found in any worktree or branch. Run `/titan-recon` first."
+
+2. **Ensure worktree isolation:**
+   ```bash
+   git rev-parse --show-toplevel && git worktree list
+   ```
+   If not in a worktree, stop: "Run `/worktree` first."
+
+3. **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-close`."
+
+4. **Load artifacts.** Read:
+   - `.codegraph/titan/titan-state.json` — session state, baseline metrics, progress
+   - `.codegraph/titan/GLOBAL_ARCH.md` — architecture document
+   - `.codegraph/titan/gauntlet-summary.json` — audit results
+   - `.codegraph/titan/sync.json` — execution plan (commit grouping)
+   - `.codegraph/titan/gate-log.ndjson` — validation history
+   - `.codegraph/titan/issues.ndjson` — issue tracker from all phases
+
+   If `titan-state.json` is missing after the search, stop: "No Titan session found. Run `/titan-recon` first."
+
+5. **Detect version.** Extract from `package.json`:
+   ```bash
+   node -e "console.log(require('./package.json').version)"
+   ```
+
+---
+
+## Step 1 — Drift detection: final staleness assessment
+
+CLOSE is the last phase — it must assess the full pipeline's freshness before generating the report.
+
+1. **Compare main SHA:**
+   ```bash
+   git rev-parse origin/main
+   ```
+   Compare against `titan-state.json → mainSHA`.
+
+2. **If main has advanced**, calculate full drift:
+   ```bash
+   git rev-list --count <mainSHA>..origin/main
+   git diff --name-only <mainSHA>..origin/main
+   ```
+
+3. **Read all prior drift reports** from `.codegraph/titan/drift-report.json` (a JSON array of entries, one per phase that detected drift). This shows the cumulative drift across the pipeline.
+
+4. **Assess overall pipeline freshness:**
+
+   | Level | Condition | Action |
+   |-------|-----------|--------|
+   | **fresh** | mainSHA matches current main, no drift reports with severity > low | Generate report normally |
+   | **acceptable** | Some drift detected but phases handled it (re-audited stale targets) | Generate report — note drift in Executive Summary |
+   | **stale** | Significant unaddressed drift: >10 commits behind, >20% of audited targets changed on main since audit | **Warn user:** "Pipeline results are partially stale. N targets were modified on main after being audited. The report will flag these. Consider re-running `/titan-gauntlet` for affected targets before finalizing." |
+   | **expired** | >50 commits behind OR >50% of targets changed OR architecture-level changes (new directories in src/) | **Stop:** "Pipeline results are too stale to produce a reliable report. Run `/titan-recon` for a fresh baseline." |
+
+5. **Write final drift assessment** to the drift report (same schema, `"detectedBy": "close"`).
+
+6. **Include drift summary in the report.** The final report's Executive Summary and Recommendations sections must reflect any staleness. Stale targets should be called out in a "Staleness Warnings" subsection.
+
+---
+
+## Step 2 — Collect branch commit history
+
+```bash
+git log main..HEAD --oneline --no-merges
+git log main..HEAD --format="%H %s" --no-merges
+```
+
+Extract: total commit count, commit messages, SHAs. If zero commits, stop: "No commits on this branch. Nothing to close."
+
+For each commit, get the files changed:
+```bash
+git diff-tree --no-commit-id --name-only -r <sha>
+```
+
+---
+
+## Step 3 — Classify commits into PR groups
+
+Analyze commit messages and changed files to group commits into **focused PRs**. Each PR should address a single concern for easier review.
+
+### Grouping strategy (in priority order)
+
+Use `sync.json` execution phases as the primary guide if available:
+
+1. **Dead code cleanup** — commits removing dead symbols
+   - PR title: `chore: remove dead code identified by Titan audit`
+2. **Shared abstractions** — commits extracting interfaces/utilities
+   - PR title: `refactor: extract <abstraction> from <source>`
+3. **Cycle breaks** — commits resolving circular dependencies
+   - PR title: `refactor: break circular dependency in <domain>`
+4. **Decompositions** — commits splitting complex functions/files
+   - PR title: `refactor: decompose <target> in <domain>`
+5. **Quality fixes** — commits addressing fail-level violations
+   - Group by domain: `fix: address quality issues in <domain>`
+6. **Warning improvements** — commits addressing warn-level issues
+   - Group by domain: `refactor: improve code quality in <domain>`
+
+### Fallback grouping (if no sync.json)
+
+Group by changed file paths — commits touching the same directory/domain go together. Use commit message prefixes (`fix:`, `refactor:`, `chore:`) as secondary signals.
+
+### Rules for grouping
+- A PR should touch **one domain** where possible
+- A PR should address **one concern** (don't mix dead code removal with refactors)
+- Order PRs so dependencies come first (if PR B depends on PR A's changes, A merges first)
+- Each PR must be independently reviewable — no PR should break the build alone
+- If a commit touches files across multiple concerns, assign it to the primary concern and note the cross-cutting nature in the PR description
+
+Record the grouping plan:
+```json
+[
+  {
+    "pr": 1,
+    "title": "...",
+    "concern": "dead_code|abstraction|cycle_break|decomposition|quality_fix|warning",
+    "domain": "<domain name>",
+    "commits": ["<sha1>", "<sha2>"],
+    "files": ["<file1>", "<file2>"],
+    "dependsOn": [],
+    "description": "..."
+  }
+]
+```
+
+---
+
+## Step 4 — Capture final metrics
+
+Rebuild the graph and collect current metrics:
+
+```bash
+codegraph build
+codegraph stats --json
+codegraph complexity --health --above-threshold -T --json --limit 50
+codegraph roles --role dead -T --json
+codegraph roles --role core -T --json
+codegraph cycles --json
+```
+
+Extract: `totalNodes`, `totalEdges`, `totalFiles`, `qualityScore`, functions above threshold, dead symbol count, core symbol count, cycle count.
+
+Also get the worst offenders for comparison:
+```bash
+codegraph complexity --health --sort effort -T --json --limit 10
+codegraph complexity --health --sort bugs -T --json --limit 10
+codegraph complexity --health --sort mi -T --json --limit 10
+```
+
+### Compute deltas
+
+Compare final metrics against `titan-state.json` baseline:
+
+| Metric | Baseline | Final | Delta |
+|--------|----------|-------|-------|
+| Quality Score | from state | from stats | +/- |
+| Functions above threshold | from state | from complexity | +/- |
+| Dead symbols | from state | from roles | +/- |
+| Cycles | from state | from cycles | +/- |
+| Total nodes | from state | from stats | +/- |
+
+---
+
+## Step 5 — Compile the issue tracker
+
+Read `.codegraph/titan/issues.ndjson`. Each line is a JSON object:
+
+```json
+{"phase": "recon|gauntlet|sync|gate", "timestamp": "ISO 8601", "severity": "bug|limitation|suggestion", "category": "codegraph|tooling|process|codebase", "description": "...", "context": "optional detail"}
+```
+
+Group issues by category and severity. Summarize:
+- **Codegraph bugs:** issues with codegraph itself (wrong output, crashes, missing features)
+- **Tooling issues:** problems with the Titan pipeline or other tools
+- **Process notes:** suggestions for improving the Titan workflow
+- **Codebase observations:** structural concerns beyond what the audit covered
+
+---
+
+## Step 6 — Compile the gate log
+
+Read `.codegraph/titan/gate-log.ndjson`. Summarize:
+- Total gate runs
+- Pass / Warn / Fail counts
+- Rollbacks triggered
+- Most common failure reasons
+
+---
+
+## Step 7 — Generate the report
+
+### Report path
+
+```
+generated/titan/titan-report-v<version>-<date>T<time>.md
+```
+
+Where:
+- `<version>` is the package.json version (e.g., `3.1.5`)
+- `<date>` is `YYYY-MM-DD`
+- `<time>` is `HH-MM-SS` (local time, hyphen-separated for filesystem safety)
+
+Example: `generated/titan/titan-report-v3.1.5-2026-03-17T14-30-00.md`
+
+```bash
+mkdir -p generated/titan
+```
+
+### Report structure
+
+Write the report as Markdown:
+
+```markdown
+# Titan Audit Report
+
+**Version:** <package version>
+**Date:** <start date> → <end date>
+**Branch:** <branch name>
+**Target:** <resolved path>
+
+---
+
+## Executive Summary
+
+<2-3 sentences: what was audited, key outcomes, overall health change>
+
+---
+
+## Pipeline Timeline
+
+| Phase | Started | Completed | Duration |
+|-------|---------|-----------|----------|
+| RECON | <from state> | <from state> | — |
+| GAUNTLET | — | — | — |
+| SYNC | — | — | — |
+| GATE (runs) | — | — | — |
+| CLOSE | <now> | <now> | — |
+
+---
+
+## Metrics: Before & After
+
+| Metric | Baseline | Final | Delta | Trend |
+|--------|----------|-------|-------|-------|
+| Quality Score | X | Y | +/-Z | arrow |
+| Total Files | ... | ... | ... | ... |
+| Total Symbols | ... | ... | ... | ... |
+| Functions Above Threshold | ... | ... | ... | ... |
+| Dead Symbols | ... | ... | ... | ... |
+| Cycle Count | ... | ... | ... | ... |
+| Avg Halstead Bugs | ... | ... | ... | ... |
+| Avg Maintainability Index | ... | ... | ... | ... |
+
+### Complexity Improvement: Top Movers
+
+<Table of functions that improved the most — dropped below thresholds or reduced halstead.bugs>
+
+### Remaining Hot Spots
+
+<Table of functions still above thresholds — carried forward for next Titan run>
+
+---
+
+## Audit Results Summary
+
+**Targets audited:** <N>
+**Pass:** <N> | **Warn:** <N> | **Fail:** <N> | **Decompose:** <N>
+
+### By Pillar
+
+| Pillar | Pass | Warn | Fail |
+|--------|------|------|------|
+| I — Structural Purity | ... | ... | ... |
+| II — Data & Type Sovereignty | ... | ... | ... |
+| III — Ecosystem Synergy | ... | ... | ... |
+| IV — Quality Vigil | ... | ... | ... |
+
+### Most Common Violations
+
+<Top 5 violation types with counts>
+
+---
+
+## Changes Made
+
+### Commits: <total count>
+
+<Table: SHA (short), message, files changed, domain>
+
+### PR Split Plan
+
+| PR # | Title | Concern | Domain | Commits | Files | Depends On |
+|------|-------|---------|--------|---------|-------|------------|
+| 1 | ... | ... | ... | N | N | — |
+| 2 | ... | ... | ... | N | N | PR #1 |
+
+---
+
+## Gate Validation History
+
+**Total runs:** <N>
+**Pass:** <N> | **Warn:** <N> | **Fail:** <N>
+**Rollbacks:** <N>
+
+### Failure Patterns
+<Most common failure reasons>
+
+---
+
+## Issues Discovered
+
+### Codegraph Bugs (<count>)
+<List with severity, description, context>
+
+### Tooling Issues (<count>)
+<List>
+
+### Process Suggestions (<count>)
+<List>
+
+### Codebase Observations (<count>)
+<List>
+
+---
+
+## Domains Analyzed
+
+<From GLOBAL_ARCH.md — domain map with final status>
+
+---
+
+## Pipeline Freshness
+
+**Main at RECON:** <mainSHA short>
+**Main at CLOSE:** <current SHA short>
+**Commits behind:** <N>
+**Overall staleness:** <fresh|acceptable|stale>
+
+### Drift Events
+<Table from drift-report.json: phase, staleness level, impacted targets, action taken>
+
+### Stale Targets
+<List of targets whose audit results may not reflect current main — carried forward for next run>
+
+---
+
+## Recommendations for Next Run
+
+<Based on remaining hot spots, unresolved issues, staleness, and patterns observed>
+```
+
+---
+
+## Step 8 — Create PRs (unless --dry-run)
+
+If `$ARGUMENTS` contains `--dry-run`:
+- Print the PR split plan as a table
+- Print the report path
+- Stop: "Dry-run complete. Review the plan and report, then re-run `/titan-close` to create PRs."
+
+Otherwise, for each PR group (in dependency order):
+
+### 8a. Create a branch for each PR
+
+```bash
+git checkout -b titan/<concern>/<domain> main
+```
+
+### 8b. Cherry-pick the commits
+
+```bash
+git cherry-pick <sha1> <sha2> ...
+```
+
+If a cherry-pick conflicts:
+1. Note the conflict in the report
+2. Skip the problematic commit: `git cherry-pick --skip`
+3. Add the skipped commit to the next PR or flag for manual resolution
+
+### 8c. Push and create the PR
+
+```bash
+git push -u origin titan/<concern>/<domain>
+```
+
+```bash
+gh pr create --title "<title>" --body "$(cat <<'EOF'
+## Summary
+<bullets from the grouping plan>
+
+## Titan Audit Context
+- **Phase:** <concern>
+- **Domain:** <domain>
+- **Commits:** <count>
+- **Depends on:** <PR #N or "none">
+
+## Changes
+<file list with brief descriptions>
+
+## Metrics Impact
+<relevant before/after metrics for files in this PR>
+
+## Test plan
+- [ ] CI passes (lint + build + tests)
+- [ ] codegraph check --cycles --boundaries passes
+- [ ] No new functions above complexity thresholds
+EOF
+)"
+```
+
+Record each PR URL.
+
+### 8d. Return to the original branch
+
+```bash
+git checkout <original-branch>
+```
+
+---
+
+## Step 9 — Update the report with PR URLs
+
+Edit the report to add the actual PR URLs to the PR split plan table.
+
+Also write a machine-readable summary:
+
+Write `.codegraph/titan/close-summary.json`:
+
+```json
+{
+  "phase": "close",
+  "timestamp": "<ISO 8601>",
+  "version": "<package version>",
+  "branch": "<branch name>",
+  "reportPath": "generated/titan/<report-name>.md",
+  "metrics": {
+    "baseline": { "qualityScore": 0, "functionsAboveThreshold": 0, "deadSymbols": 0, "cycles": 0 },
+    "final": { "qualityScore": 0, "functionsAboveThreshold": 0, "deadSymbols": 0, "cycles": 0 }
+  },
+  "audit": { "totalAudited": 0, "pass": 0, "warn": 0, "fail": 0, "decompose": 0 },
+  "gate": { "totalRuns": 0, "pass": 0, "warn": 0, "fail": 0, "rollbacks": 0 },
+  "issues": { "codegraph": 0, "tooling": 0, "process": 0, "codebase": 0 },
+  "prs": [
+    { "number": 0, "url": "<url>", "title": "<title>", "concern": "<type>", "domain": "<domain>", "commits": 0 }
+  ],
+  "commits": { "total": 0, "cherryPickFailures": 0 }
+}
+```
+
+---
+
+## Step 10 — Final cleanup
+
+1. **Update titan-state.json:** set `currentPhase` to `"close"`, update `lastUpdated`.
+
+2. **Snapshot cleanup:** If the pipeline is fully complete (all PRs created):
+   ```bash
+   codegraph snapshot delete titan-baseline 2>/dev/null
+   ```
+   Delete any remaining batch snapshots.
+
+3. **Add report to .gitignore** if `generated/titan/` is not already ignored:
+   ```bash
+   grep -q "generated/titan/" .gitignore || echo "generated/titan/" >> .gitignore
+   ```
+
+---
+
+## Step 11 — Report to user
+
+Print:
+
+```
+TITAN CLOSE — Pipeline Complete
+
+Report: generated/titan/<report-name>.md
+
+Metrics Delta:
+  Quality Score: X → Y (+Z)
+  Functions above threshold: X → Y (-Z)
+  Dead symbols: X → Y (-Z)
+
+Audit: <N> audited — <P> pass, <W> warn, <F> fail
+Gate:  <N> runs — <P> pass, <W> warn, <F> fail, <R> rollbacks
+Issues: <N> logged (<B> codegraph bugs, <T> tooling, <S> suggestions)
+
+PRs Created: <N>
+  #1: <title> (<url>)
+  #2: <title> (<url>)
+  ...
+
+Merge order: PR #1 → #2 → #3 (respect dependencies)
+
+Next: merge PRs in order, then /titan-reset to clean up artifacts.
+```
+
+---
+
+## Rules
+
+- **Always use `--json` and `-T`** on codegraph commands.
+- **Never paste raw JSON** into your response — parse and extract.
+- **Dry-run is safe.** Only `--dry-run` omission triggers branch creation and PR submission.
+- **Cherry-pick failures are noted, not fatal.** Skipped commits get flagged in the report.
+- **One PR = one concern.** Never mix dead code removal with refactors in the same PR.
+- **Dependency order matters.** Create and label PRs so reviewers know the merge sequence.
+- **The report is the deliverable.** It must be comprehensive enough for someone who wasn't present to understand what happened.
+- **Issue tracker is append-only.** Never modify issues from other phases — only compile them.
+
+## Self-Improvement
+
+This skill lives at `.claude/skills/titan-close/SKILL.md`. Adjust PR grouping logic or report structure after dogfooding.
diff --git a/.claude/skills/titan-forge/SKILL.md b/.claude/skills/titan-forge/SKILL.md
new file mode 100644
index 00000000..d79d89ae
--- /dev/null
+++ b/.claude/skills/titan-forge/SKILL.md
@@ -0,0 +1,245 @@
+---
+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/.claude/skills/titan-gate/SKILL.md b/.claude/skills/titan-gate/SKILL.md
index c1d7c359..3121ed3a 100644
--- a/.claude/skills/titan-gate/SKILL.md
+++ b/.claude/skills/titan-gate/SKILL.md
@@ -17,25 +17,82 @@ Your goal: validate staged changes against codegraph quality checks AND the proj
 
 ---
 
-## Step 0 — Pre-flight
+## Step 0 — Pre-flight: find Titan state and validate
 
-1. **Worktree check:**
+1. **Locate the Titan session (if not already in one).** If `.codegraph/titan/titan-state.json` does not exist locally, search for it:
+
+   ```bash
+   git worktree list
+   ```
+
+   For each worktree, check:
+   ```bash
+   ls <worktree-path>/.codegraph/titan/titan-state.json 2>/dev/null
+   ```
+
+   Also check branches:
+   ```bash
+   git branch -a --list '*titan*'
+   ```
+
+   **Decision logic:**
+   - **Found a worktree/branch with Titan state:** Merge its branch into your worktree to pick up the artifacts: `git merge <titan-branch> --no-edit`
+   - **Found multiple:** Pick the one with the most recent `lastUpdated` and `currentPhase` closest to `"sync"` (GATE runs after SYNC). If ambiguous, ask the user.
+   - **Found nothing:** That's fine — GATE can run standalone. Proceed with defaults.
+
+2. **Worktree check:**
    ```bash
    git rev-parse --show-toplevel && git worktree list
    ```
    If not in a worktree, stop: "Run `/worktree` first."
 
-2. **Staged changes?**
+3. **Staged changes?**
    ```bash
    git diff --cached --name-only
    ```
    If nothing staged, stop: "Nothing staged. Use `git add` first."
 
-3. **Load state (optional).** Read `.codegraph/titan/titan-state.json` if it exists — use for thresholds, baseline comparison, and sync alignment. If missing or corrupt, proceed with defaults.
+4. **Load state (optional).** Read `.codegraph/titan/titan-state.json` if it exists — use for thresholds, baseline comparison, and sync alignment. If missing or corrupt, proceed with defaults.
 
 ---
 
-## Step 1 — Structural validation (codegraph)
+## Step 1 — Drift detection: has main moved since last gate run?
+
+GATE may run many times across a long pipeline. Check for upstream changes each time.
+
+1. **Compare main SHA:**
+   ```bash
+   git rev-parse origin/main
+   ```
+   Compare against `titan-state.json → mainSHA` (if state exists). If identical, skip to Step 2.
+
+2. **If main has advanced**, find what changed:
+   ```bash
+   git diff --name-only <mainSHA>..origin/main
+   ```
+
+3. **Cross-reference with staged files:**
+   - Do any staged files also appear in the main diff? If yes, there may be **merge conflicts waiting** after the commit.
+   - Did main change files that are callers/callees of staged changes? Use diff-impact to check.
+
+4. **Classify staleness:**
+
+   | Level | Condition | Action |
+   |-------|-----------|--------|
+   | **none** | main unchanged | Continue normally |
+   | **low** | Main changed but no overlap with staged files or their callers | Continue — note drift |
+   | **moderate** | Main changed files that are callers/callees of staged changes | **Warn:** "Main has changes that interact with your staged files. Consider merging main first: `git merge origin/main`" |
+   | **high** | Main changed the same files you're staging | **Warn strongly:** "Main modified files you're about to commit. Merge main first to avoid conflicts downstream." |
+
+5. **Write/update drift report** (same schema, `"detectedBy": "gate"`).
+
+6. **Update state:** Set `titan-state.json → mainSHA` to current `origin/main`.
+
+7. **If `sync.json` exists:** Check if main's changes invalidate any execution phases. If a phase's targets were changed on main, add a drift warning to the gate-log entry.
+
+---
+
+## Step 2 — Structural validation (codegraph)
 
 Run the full change validation predicates in one call:
 
@@ -55,7 +112,7 @@ Extract: changed functions (count + names), direct callers affected, transitive
 
 ---
 
-## Step 2 — Cycle check
+## Step 3 — Cycle check
 
 ```bash
 codegraph cycles --json
@@ -67,7 +124,7 @@ Compare against RECON baseline (if `titan-state.json` exists):
 
 ---
 
-## Step 3 — Complexity delta
+## Step 4 — Complexity delta
 
 For each changed file (from diff-impact):
 
@@ -84,7 +141,7 @@ Check all metrics against thresholds:
 
 ---
 
-## Step 4 — Lint, build, and test
+## Step 5 — Lint, build, and test
 
 Detect project tools from `package.json`:
 
@@ -111,7 +168,7 @@ If any fail → overall verdict is FAIL → proceed to auto-rollback.
 
 ---
 
-## Step 5 — Branch structural diff
+## Step 6 — Branch structural diff
 
 ```bash
 codegraph branch-compare main HEAD -T --json
@@ -121,7 +178,7 @@ Cumulative structural impact of all changes on this branch (broader than `diff-i
 
 ---
 
-## Step 6 — Sync plan alignment
+## Step 7 — Sync plan alignment
 
 If `.codegraph/titan/sync.json` exists:
 - Are changed files part of the current execution phase?
@@ -132,7 +189,7 @@ Advisory — prevents jumping ahead and creating conflicts.
 
 ---
 
-## Step 7 — Blast radius check
+## Step 8 — Blast radius check
 
 From diff-impact results:
 - Transitive blast radius > 30 → FAIL
@@ -141,7 +198,7 @@ From diff-impact results:
 
 ---
 
-## Step 8 — Verdict and auto-rollback
+## Step 9 — Verdict and auto-rollback
 
 Aggregate all checks:
 
@@ -171,7 +228,7 @@ Aggregate all checks:
 
 > "GATE FAIL: [reason]. Graph restored, changes unstaged but preserved. Fix and re-stage."
 
-For structural-only failures (Steps 1-3, 5-7), do NOT auto-rollback — report and let user decide.
+For structural-only failures (Steps 2-4, 6-8), do NOT auto-rollback — report and let user decide.
 
 ### Snapshot cleanup on pipeline completion
 
@@ -186,7 +243,7 @@ codegraph snapshot delete titan-batch-<N>   # if any remain
 
 ---
 
-## Step 9 — Update state machine
+## Step 10 — Update state machine
 
 Append to `.codegraph/titan/gate-log.ndjson`:
 
@@ -215,7 +272,7 @@ Update `titan-state.json` (if exists): increment `progress.fixed`, update `fileA
 
 ---
 
-## Step 10 — Report to user
+## Step 11 — Report to user
 
 **PASS:**
 ```
@@ -246,6 +303,25 @@ GATE FAIL — changes unstaged, graph restored
 
 ---
 
+## Issue Tracking
+
+During validation, if you encounter any of the following, append a JSON line to `.codegraph/titan/issues.ndjson`:
+
+- **Codegraph bugs:** wrong diff-impact, false cycle detection, incorrect complexity after changes
+- **Tooling issues:** check command failures, snapshot errors, build tool problems
+- **Process suggestions:** threshold adjustments, missing checks, workflow improvements
+- **Codebase observations:** test gaps, flaky tests, build warnings worth noting
+
+Format (one JSON object per line, append-only):
+
+```json
+{"phase": "gate", "timestamp": "<ISO 8601>", "severity": "bug|limitation|suggestion", "category": "codegraph|tooling|process|codebase", "description": "<what happened>", "context": "<command, check, or file involved>"}
+```
+
+Log issues as they happen. The `/titan-close` phase compiles these into the final report.
+
+---
+
 ## Rules
 
 - **Fast execution.** Only staged changes, not full codebase.
@@ -256,6 +332,7 @@ GATE FAIL — changes unstaged, graph restored
 - **Force mode** downgrades WARN → PASS but cannot override FAIL.
 - **Run the project's own lint/build/test** — codegraph checks are necessary but not sufficient.
 - **Use the correct check flags:** `--cycles`, `--blast-radius <n>`, `--boundaries`.
+- If any check produces unexpected output, **log it to `issues.ndjson`** before continuing.
 
 ## Self-Improvement
 
diff --git a/.claude/skills/titan-gauntlet/SKILL.md b/.claude/skills/titan-gauntlet/SKILL.md
index 15b41c22..00f976d5 100644
--- a/.claude/skills/titan-gauntlet/SKILL.md
+++ b/.claude/skills/titan-gauntlet/SKILL.md
@@ -17,33 +17,126 @@ Your goal: audit every high-priority target from the RECON phase against 4 pilla
 
 ---
 
-## Step 0 — Pre-flight
+## Step 0 — Pre-flight: find or create the Titan worktree
 
-1. **Worktree check:**
+1. **Locate the Titan session.** A prior phase (RECON) may have run in a different worktree or branch. Search for it:
+
+   ```bash
+   git worktree list
+   ```
+
+   For each worktree, check if it contains Titan artifacts:
+   ```bash
+   ls <worktree-path>/.codegraph/titan/titan-state.json 2>/dev/null
+   ```
+
+   Also check branches for titan state:
+   ```bash
+   git branch -a --list '*titan*'
+   ```
+
+   **Decision logic:**
+   - **Found exactly one worktree with `titan-state.json`:** Read the state. If `currentPhase` is `"recon"` (RECON completed), this is the right one. Switch to it or merge its branch into your worktree.
+   - **Found a worktree but `currentPhase` is NOT `"recon"`:** This worktree may be mid-phase or from a different pipeline run. Keep searching other worktrees/branches. If no better match, ask the user: "Found Titan state at `<path>` but phase is `<phase>`. Is this the session to continue?"
+   - **Found multiple worktrees with `titan-state.json`:** List them with their `currentPhase` and `lastUpdated`. Ask the user: "Multiple Titan sessions found. Which one should GAUNTLET continue?"
+   - **Found a branch (not worktree) with titan artifacts:** Merge it into your current worktree:
+     ```bash
+     git merge <titan-branch> --no-edit
+     ```
+   - **Found nothing:** Warn: "No RECON artifacts found in any worktree or branch. Run `/titan-recon` first for best results." Fall back: `codegraph triage -T --limit 50 --json` for a minimal queue.
+
+2. **Ensure worktree isolation:**
    ```bash
    git rev-parse --show-toplevel && git worktree list
    ```
-   If not in a worktree, stop: "Run `/worktree` first."
+   If you are NOT in a worktree, stop: "Run `/worktree` first."
 
-2. **Sync with main:**
+3. **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-gauntlet`."
 
-3. **Load state.** Read `.codegraph/titan/titan-state.json`. If missing:
-   - Warn: "No RECON artifacts. Run `/titan-recon` first for best results."
-   - Fall back: `codegraph triage -T --limit 50 --json` for a minimal queue.
+4. **Load state.** Read `.codegraph/titan/titan-state.json`.
+
+5. **Load architecture.** Read `.codegraph/titan/GLOBAL_ARCH.md` for domain context.
+
+6. **Resume logic.** If `titan-state.json` has completed batches, skip them. Start from the first `pending` batch.
+
+7. **Validate state.** If `titan-state.json` fails to parse, stop: "State file corrupted. Run `/titan-reset` to start over, or `/titan-recon` to rebuild."
+
+---
+
+## Step 1 — Drift detection: has main moved since the last phase?
+
+The codebase may have changed significantly since RECON ran. Detect this before auditing stale data.
+
+1. **Compare main SHA:**
+   ```bash
+   git rev-parse origin/main
+   ```
+   Compare against `titan-state.json → mainSHA`. If identical, skip to Step 2.
+
+2. **If main has advanced**, find what changed:
+   ```bash
+   git diff --name-only <mainSHA>..origin/main
+   ```
+
+3. **Cross-reference with Titan targets.** Check which changed files overlap with:
+   - Files in the priority queue (`titan-state.json → priorityQueue`)
+   - Files in pending batches (`titan-state.json → batches`)
+   - Hot files (`titan-state.json → hotFiles`)
+   - Core symbols (`titan-state.json → roles.coreCount` files)
 
-4. **Load architecture.** Read `.codegraph/titan/GLOBAL_ARCH.md` for domain context.
+4. **Run structural diff** to detect architecture-level changes:
+   ```bash
+   codegraph diff-impact <mainSHA>..origin/main -T --json 2>/dev/null || echo "DIFF_UNAVAILABLE"
+   ```
+   If unavailable (e.g., old SHA not in graph), fall back to file-count heuristics.
+
+5. **Classify staleness:**
+
+   | Level | Condition | Action |
+   |-------|-----------|--------|
+   | **none** | main unchanged | Continue normally |
+   | **low** | main changed but <5 files, none in priority queue | Continue — note in issues.ndjson |
+   | **moderate** | Some overlap: changed files appear in priority queue or batches (<20% of batches affected) | Continue but **mark affected batches for re-audit** |
+   | **high** | >20% of batches affected OR core symbols changed | **Warn user:** "Significant changes on main since RECON. Recommend re-running affected batches or `/titan-recon`." |
+   | **critical** | New files in src/, deleted files that were in batches, or >50% of priority queue affected | **Stop and recommend:** "Main has diverged significantly. Run `/titan-recon` to rebuild the baseline." |
+
+6. **Append drift report** to `.codegraph/titan/drift-report.json` (the file is a JSON array — read existing entries first, push the new entry, write back):
+
+   ```json
+   {
+     "timestamp": "<ISO 8601>",
+     "detectedBy": "gauntlet",
+     "mainAtLastPhase": "<stored SHA>",
+     "mainNow": "<current SHA>",
+     "commitsBehind": 0,
+     "changedFiles": ["<files changed on main>"],
+     "impactedTargets": ["<priority queue targets in changed files>"],
+     "impactedBatches": [1, 3],
+     "impactedDomains": ["<domains containing changed files>"],
+     "staleness": "none|low|moderate|high|critical",
+     "recommendation": "continue|reassess-targets|rerun-gauntlet|rerun-recon",
+     "reassessmentScope": {
+       "targets": ["<specific targets to re-audit>"],
+       "batches": [1, 3],
+       "files": ["<specific files to re-check>"],
+       "fullRecon": false
+     }
+   }
+   ```
 
-5. **Resume logic.** If `titan-state.json` has completed batches, skip them. Start from the first `pending` batch.
+7. **Update state:** Set `titan-state.json → mainSHA` to current `origin/main` after merging.
 
-6. **Validate state.** If `titan-state.json` fails to parse, stop: "State file corrupted. Run `/titan-reset` to start over, or `/titan-recon` to rebuild."
+8. **If `moderate`:** Mark impacted batches as `"stale"` in `titan-state.json` (change status from `"completed"` to `"stale"` or from `"pending"` to `"pending-reassess"`). These get re-audited during the batch loop.
+
+9. **If re-running GAUNTLET** and a previous `drift-report.json` exists with `reassessmentScope`, **only re-audit the targets listed** — don't repeat the entire pipeline. Clear completed targets from the scope as you go.
 
 ---
 
-## Step 1 — The Four Pillars
+## Step 2 — The Four Pillars
 
 Every file must be checked against all four pillars. A file **FAILS** if it has any fail-level violation.
 
@@ -208,11 +301,11 @@ Codegraph provides all the data needed for a verifiable audit — no need to man
 
 ---
 
-## Step 2 — Batch audit loop
+## Step 3 — Batch audit loop
 
 For each pending batch (from `titan-state.json`):
 
-### 2a. Save pre-batch snapshot
+### 3a. Save pre-batch snapshot
 ```bash
 codegraph snapshot save titan-batch-<N>
 ```
@@ -221,7 +314,7 @@ Delete the previous batch snapshot if it exists:
 codegraph snapshot delete titan-batch-<N-1>
 ```
 
-### 2b. Collect all metrics in one call
+### 3b. Collect all metrics in one call
 ```bash
 codegraph batch complexity <target1> <target2> ... -T --json
 ```
@@ -232,7 +325,7 @@ For deeper context on high-risk targets:
 codegraph batch context <target1> <target2> ... -T --json
 ```
 
-### 2c. Run Pillar I checks
+### 3c. Run Pillar I checks
 For each file in the batch:
 - Parse complexity metrics from batch output (Rule 1 — all 7 metric thresholds)
 - Run AST queries for async hygiene (Rule 2), resource cleanup (Rule 5)
@@ -240,25 +333,25 @@ For each file in the batch:
 - Check dead code (Rule 4): `codegraph roles --role dead --file <f> -T --json`
 - Check immutability (Rule 6): `codegraph dataflow` + grep
 
-### 2d. Run Pillar II checks
+### 3d. Run Pillar II checks
 For each file:
 - Magic values (Rule 7): `codegraph ast --kind string` + grep
 - Boundary validation (Rule 8): check entry points
 - Secret hygiene (Rule 9): grep
 - Empty catches (Rule 10): grep
 
-### 2e. Run Pillar III checks
+### 3e. Run Pillar III checks
 - DRY (Rule 11): `codegraph search` (if embeddings available) + `co-change`
 - Naming symmetry (Rule 12): `codegraph where --file`
 - Config over code (Rule 13): `codegraph deps` + grep
 
-### 2f. Run Pillar IV checks
+### 3f. Run Pillar IV checks
 - Naming quality (Rule 14): `codegraph where --file`
 - Structured logging (Rule 15): `codegraph ast --kind call` + grep
 - Testability (Rule 16): `codegraph fn-impact` + test file mock count
 - Critical path coverage (Rule 17): `codegraph roles --role core`
 
-### 2g. Score each target
+### 3g. Score each target
 
 | Verdict | Condition |
 |---------|-----------|
@@ -272,7 +365,7 @@ For FAIL/DECOMPOSE targets, capture blast radius:
 codegraph fn-impact <target> -T --json
 ```
 
-### 2h. Write batch results
+### 3h. Write batch results
 
 Append to `.codegraph/titan/gauntlet.ndjson` (one line per target):
 
@@ -280,7 +373,7 @@ Append to `.codegraph/titan/gauntlet.ndjson` (one line per target):
 {"target": "<name>", "file": "<path>", "verdict": "FAIL", "pillarVerdicts": {"I": "fail", "II": "warn", "III": "pass", "IV": "pass"}, "metrics": {"cognitive": 35, "cyclomatic": 15, "maxNesting": 4, "mi": 32, "halsteadEffort": 12000, "halsteadBugs": 1.2, "sloc": 85}, "violations": [{"rule": 1, "pillar": "I", "metric": "cognitive", "detail": "35 > 30 threshold", "level": "fail"}], "blastRadius": {"direct": 5, "transitive": 18}, "recommendation": "Split: halstead.bugs 1.2 suggests ~1 defect. Separate validation from I/O."}
 ```
 
-### 2i. Update state machine
+### 3i. Update state machine
 
 Update `titan-state.json`:
 - Set batch status to `"completed"`
@@ -289,7 +382,7 @@ Update `titan-state.json`:
 - Update `snapshots.lastBatch`
 - Update `lastUpdated`
 
-### 2j. Progress check
+### 3j. Progress check
 
 Print: `Batch N/M: X pass, Y warn, Z fail`
 
@@ -300,7 +393,7 @@ Print: `Batch N/M: X pass, Y warn, Z fail`
 
 ---
 
-## Step 3 — Clean up batch snapshots
+## Step 4 — Clean up batch snapshots
 
 After all batches complete, delete the last batch snapshot:
 ```bash
@@ -312,7 +405,7 @@ If stopping early for context, keep the last batch snapshot for safety.
 
 ---
 
-## Step 4 — Aggregate and report
+## Step 5 — Aggregate and report
 
 Compute from `gauntlet.ndjson`:
 - Pass / Warn / Fail / Decompose counts
@@ -342,6 +435,25 @@ Print summary to user:
 
 ---
 
+## Issue Tracking
+
+Throughout this phase, if you encounter any of the following, append a JSON line to `.codegraph/titan/issues.ndjson`:
+
+- **Codegraph bugs:** wrong metrics, incorrect role classification, missing symbols, parse failures
+- **Tooling issues:** batch command failures, AST query errors, embedding unavailability
+- **Process suggestions:** threshold adjustments, missing rules, pillar improvements
+- **Codebase observations:** patterns not covered by the manifesto, architectural smells
+
+Format (one JSON object per line, append-only):
+
+```json
+{"phase": "gauntlet", "timestamp": "<ISO 8601>", "severity": "bug|limitation|suggestion", "category": "codegraph|tooling|process|codebase", "description": "<what happened>", "context": "<command, target, or file involved>"}
+```
+
+Log issues as they happen — don't batch them. The `/titan-close` phase compiles these into the final report.
+
+---
+
 ## Rules
 
 - **Batch processing is mandatory.** Never audit more than `$ARGUMENTS` targets at once.
@@ -353,6 +465,7 @@ Print summary to user:
 - **Lint runs once in GATE**, not per-batch here. Don't run `npm run lint`.
 - Advisory rules (12, 14, 17) produce warnings, never failures.
 - Dead symbols from RECON should be flagged for removal, not skipped.
+- If any command fails or produces unexpected output, **log it to `issues.ndjson`** before continuing.
 
 ## Self-Improvement
 
diff --git a/.claude/skills/titan-recon/SKILL.md b/.claude/skills/titan-recon/SKILL.md
index b1ae5428..5dab238f 100644
--- a/.claude/skills/titan-recon/SKILL.md
+++ b/.claude/skills/titan-recon/SKILL.md
@@ -29,6 +29,12 @@ Your goal: map the dependency graph, identify structural hotspots, name logical
    ```
    If there are merge conflicts, stop and ask the user to resolve them.
 
+3. **Record the main anchor SHA:**
+   ```bash
+   git rev-parse origin/main
+   ```
+   Store this as `mainSHA` in `titan-state.json`. All downstream phases use this to detect codebase drift — if main advances between phases, the drift detection mechanism (Step 0.5 in each phase) compares against this anchor to determine what's stale and what needs reassessment.
+
 ---
 
 ## Step 1 — Build the graph
@@ -215,6 +221,7 @@ mkdir -p .codegraph/titan
   "lastUpdated": "<ISO 8601>",
   "target": "<resolved path>",
   "currentPhase": "recon",
+  "mainSHA": "<git rev-parse origin/main>",
   "snapshots": {
     "baseline": "titan-baseline",
     "lastBatch": null
@@ -303,12 +310,31 @@ Print a concise summary:
 
 ---
 
+## Issue Tracking
+
+Throughout this phase, if you encounter any of the following, append a JSON line to `.codegraph/titan/issues.ndjson`:
+
+- **Codegraph bugs:** wrong output, crashes, missing features, unexpected behavior
+- **Tooling issues:** problems with commands, WASM failures, embedding errors
+- **Process suggestions:** ideas for improving the Titan workflow
+- **Codebase observations:** structural concerns beyond what metrics capture
+
+Format (one JSON object per line, append-only):
+
+```json
+{"phase": "recon", "timestamp": "<ISO 8601>", "severity": "bug|limitation|suggestion", "category": "codegraph|tooling|process|codebase", "description": "<what happened>", "context": "<command that triggered it, file involved, or other detail>"}
+```
+
+Log issues as they happen — don't batch them. The `/titan-close` phase compiles these into the final report.
+
+---
+
 ## Rules
 
 - **Always use `--json` and `-T`** on codegraph commands.
 - **Never paste raw JSON** into your response — parse and extract.
 - **Write artifacts before reporting.**
-- If any command fails, note it and continue with partial data.
+- If any command fails, **log it to `issues.ndjson`** and continue with partial data.
 - **Domain naming** uses the codebase's own vocabulary.
 
 ## Self-Improvement
diff --git a/.claude/skills/titan-reset/SKILL.md b/.claude/skills/titan-reset/SKILL.md
index f7ea1004..f6a48d70 100644
--- a/.claude/skills/titan-reset/SKILL.md
+++ b/.claude/skills/titan-reset/SKILL.md
@@ -50,6 +50,9 @@ This removes:
 - `gauntlet-summary.json` — aggregated results
 - `sync.json` — execution plan
 - `gate-log.ndjson` — gate audit trail
+- `issues.ndjson` — cross-phase issue tracker
+- `close-summary.json` — close phase summary
+- `drift-report.json` — staleness detection across phases
 
 ---
 
diff --git a/.claude/skills/titan-sync/SKILL.md b/.claude/skills/titan-sync/SKILL.md
index 259204c3..30a0b070 100644
--- a/.claude/skills/titan-sync/SKILL.md
+++ b/.claude/skills/titan-sync/SKILL.md
@@ -15,32 +15,55 @@ Your goal: analyze GAUNTLET results to find overlapping problems, identify share
 
 ---
 
-## Step 0 — Pre-flight
+## Step 0 — Pre-flight: find or join the Titan worktree
 
-1. **Worktree check:**
+1. **Locate the Titan session.** Prior phases (RECON, GAUNTLET) may have run in a different worktree or branch. Search for it:
+
+   ```bash
+   git worktree list
+   ```
+
+   For each worktree, check if it contains Titan artifacts:
+   ```bash
+   ls <worktree-path>/.codegraph/titan/titan-state.json 2>/dev/null
+   ```
+
+   Also check branches:
+   ```bash
+   git branch -a --list '*titan*'
+   ```
+
+   **Decision logic:**
+   - **Found exactly one worktree with `titan-state.json` and `currentPhase` is `"gauntlet"`:** GAUNTLET completed — this is the right session. Merge its branch into your worktree.
+   - **Found a worktree but `currentPhase` is not `"gauntlet"`:** Suspicious — could be mid-phase or a different run. If `currentPhase` is `"recon"`, GAUNTLET hasn't run yet. If `"sync"` or later, someone else may be ahead. Ask the user: "Found Titan state at `<path>` with phase `<phase>`. Is this the session to continue?"
+   - **Found multiple worktrees with `titan-state.json`:** List them with `currentPhase` and `lastUpdated`. Ask the user which to continue.
+   - **Found a branch (not worktree) with titan artifacts:** Merge it: `git merge <titan-branch> --no-edit`
+   - **Found nothing:** Stop: "No Titan artifacts found. Run `/titan-recon` then `/titan-gauntlet` first."
+
+2. **Ensure worktree isolation:**
    ```bash
    git rev-parse --show-toplevel && git worktree list
    ```
    If not in a worktree, stop: "Run `/worktree` first."
 
-2. **Sync with main:**
+3. **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-sync`."
 
-3. **Load artifacts.** Read:
+4. **Load artifacts.** Read:
    - `.codegraph/titan/titan-state.json` — state, domains, batches, file audits
    - `.codegraph/titan/GLOBAL_ARCH.md` — architecture, dependency flow, shared types
    - `.codegraph/titan/gauntlet.ndjson` — per-target audit details
    - `.codegraph/titan/gauntlet-summary.json` — aggregated results
 
-4. **Validate state.** If `titan-state.json` fails to parse, stop: "State file corrupted. Run `/titan-reset`."
+5. **Validate state.** If `titan-state.json` fails to parse, stop: "State file corrupted. Run `/titan-reset`."
 
-5. **Check GAUNTLET completeness.** If `gauntlet-summary.json` has `"complete": false`:
+6. **Check GAUNTLET completeness.** If `gauntlet-summary.json` has `"complete": false`:
    > "GAUNTLET incomplete (<N>/<M> batches). SYNC will plan based on known failures only. Run `/titan-gauntlet` first for a complete plan."
 
-6. **Extract.** From artifacts, collect:
+7. **Extract.** From artifacts, collect:
    - All FAIL and DECOMPOSE targets with violations and files
    - Common violation patterns by pillar
    - Community assignments
@@ -49,7 +72,47 @@ Your goal: analyze GAUNTLET results to find overlapping problems, identify share
 
 ---
 
-## Step 1 — Find dependency clusters among failing targets
+## Step 1 — Drift detection: has main moved since GAUNTLET?
+
+The codebase may have changed between GAUNTLET and now. Detect this before planning on stale audit data.
+
+1. **Compare main SHA:**
+   ```bash
+   git rev-parse origin/main
+   ```
+   Compare against `titan-state.json → mainSHA`. If identical, skip to Step 2.
+
+2. **If main has advanced**, find what changed:
+   ```bash
+   git diff --name-only <mainSHA>..origin/main
+   ```
+
+3. **Cross-reference with GAUNTLET results.** Check which changed files overlap with:
+   - Files that were audited (`gauntlet.ndjson → file` field)
+   - FAIL/DECOMPOSE targets (the ones SYNC plans around)
+   - Dead symbols targeted for removal
+
+4. **Classify staleness:**
+
+   | Level | Condition | Action |
+   |-------|-----------|--------|
+   | **none** | main unchanged | Continue normally |
+   | **low** | Changed files don't overlap with any audited targets | Continue — note drift |
+   | **moderate** | Some FAIL/DECOMPOSE targets are in changed files (<30% affected) | Continue but **flag affected targets** — their audit results may be outdated. Mark clusters containing them as `"needs-verification"` |
+   | **high** | >30% of FAIL targets affected OR shared dependencies changed | **Warn user:** "Main has changed significantly since GAUNTLET. Audit results for N targets may be stale. Recommend `/titan-gauntlet` re-run for affected targets before planning." |
+   | **critical** | New files added to src/ that would be in priority queue, or deleted files that were FAIL targets | **Stop:** "Codebase structure changed. Run `/titan-recon` to rebuild baseline, then `/titan-gauntlet`." |
+
+5. **Append drift report** to `.codegraph/titan/drift-report.json` (the file is a JSON array — read existing entries, push the new entry, write back; same schema as GAUNTLET, with `"detectedBy": "sync"`).
+
+6. **Update state:** Set `titan-state.json → mainSHA` to current `origin/main`.
+
+7. **If `moderate`:** Proceed but annotate affected clusters in `sync.json` with `"driftWarning": true`. The execution order should prioritize non-stale targets and defer stale ones pending re-audit.
+
+8. **If re-running SYNC** and a previous `drift-report.json` exists with `reassessmentScope.targets`, re-read GAUNTLET results only for those targets and rebuild affected clusters.
+
+---
+
+## Step 2 — Find dependency clusters among failing targets
 
 For FAIL/DECOMPOSE targets that share a file or community, check connections:
 
@@ -67,7 +130,7 @@ Filter to cycles including at least one FAIL/DECOMPOSE target.
 
 ---
 
-## Step 2 — Identify shared dependencies and ownership
+## Step 3 — Identify shared dependencies and ownership
 
 For each cluster, find what they share:
 
@@ -98,7 +161,7 @@ Avoid re-auditing or conflicting with in-progress work.
 
 ---
 
-## Step 3 — Detect extraction candidates
+## Step 4 — Detect extraction candidates
 
 For DECOMPOSE targets:
 
@@ -114,7 +177,7 @@ Look for:
 
 ---
 
-## Step 4 — Plan shared abstractions
+## Step 5 — Plan shared abstractions
 
 Identify what to build BEFORE individual fixes:
 
@@ -130,7 +193,7 @@ codegraph fn-impact <shared-dep> -T --json
 
 ---
 
-## Step 5 — Build execution order with logical commits
+## Step 6 — Build execution order with logical commits
 
 ### Phases (in order)
 
@@ -160,7 +223,7 @@ codegraph fn-impact <shared-dep> -T --json
 
 ---
 
-## Step 6 — Write the SYNC artifact
+## Step 7 — Write the SYNC artifact
 
 Write `.codegraph/titan/sync.json`:
 
@@ -208,7 +271,7 @@ Update `titan-state.json`: set `currentPhase` to `"sync"`.
 
 ---
 
-## Step 7 — Report to user
+## Step 8 — Report to user
 
 Print:
 - Dependency clusters found (count)
@@ -220,6 +283,25 @@ Print:
 
 ---
 
+## Issue Tracking
+
+Throughout this phase, if you encounter any of the following, append a JSON line to `.codegraph/titan/issues.ndjson`:
+
+- **Codegraph bugs:** incorrect path queries, wrong cycle detection, relationship errors
+- **Tooling issues:** artifact parsing failures, state inconsistencies
+- **Process suggestions:** better clustering strategies, execution order improvements
+- **Codebase observations:** cross-cutting concerns not captured by GAUNTLET
+
+Format (one JSON object per line, append-only):
+
+```json
+{"phase": "sync", "timestamp": "<ISO 8601>", "severity": "bug|limitation|suggestion", "category": "codegraph|tooling|process|codebase", "description": "<what happened>", "context": "<command, cluster, or artifact involved>"}
+```
+
+Log issues as they happen — don't batch them. The `/titan-close` phase compiles these into the final report.
+
+---
+
 ## Rules
 
 - **Read artifacts, don't re-scan.** Codegraph commands only for targeted relationship queries.
@@ -228,6 +310,7 @@ Print:
 - **Logical commits matter.** Never mix concerns.
 - If GAUNTLET found zero failures, produce minimal plan (dead code + warnings only).
 - Keep `codegraph path` queries targeted — same file or community only.
+- If any command fails or produces unexpected output, **log it to `issues.ndjson`** before continuing.
 
 ## Self-Improvement
 
diff --git a/.gitignore b/.gitignore
index 6ff31ab7..596889f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ grammars/*.wasm
 .claude/session-edits.log
 generated/DEPENDENCIES.md
 generated/DEPENDENCIES.json
+generated/titan/
 artifacts/
 pkg/
 generated/DEPENDENCIES.md
diff --git a/docs/examples/claude-code-skills/titan-forge/SKILL.md b/docs/examples/claude-code-skills/titan-forge/SKILL.md
new file mode 100644
index 00000000..d79d89ae
--- /dev/null
+++ b/docs/examples/claude-code-skills/titan-forge/SKILL.md
@@ -0,0 +1,245 @@
+---
+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/cli/commands/check.js b/src/cli/commands/check.js
index 24cd9a63..501e4aa4 100644
--- a/src/cli/commands/check.js
+++ b/src/cli/commands/check.js
@@ -2,6 +2,22 @@ import { EVERY_SYMBOL_KIND } from '../../domain/queries.js';
 import { ConfigError } from '../../shared/errors.js';
 import { config } from '../shared/options.js';
 
+function validateKind(kind) {
+  if (kind && !EVERY_SYMBOL_KIND.includes(kind)) {
+    throw new ConfigError(`Invalid kind "${kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`);
+  }
+}
+
+async function runManifesto(opts, qOpts) {
+  validateKind(opts.kind);
+  const { manifesto } = await import('../../presentation/manifesto.js');
+  manifesto(opts.db, {
+    file: opts.file,
+    kind: opts.kind,
+    ...qOpts,
+  });
+}
+
 export const command = {
   name: 'check [ref]',
   description:
@@ -29,17 +45,7 @@ export const command = {
     const qOpts = ctx.resolveQueryOpts(opts);
 
     if (!isDiffMode && !opts.rules) {
-      if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
-        throw new ConfigError(
-          `Invalid kind "${opts.kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`,
-        );
-      }
-      const { manifesto } = await import('../../presentation/manifesto.js');
-      manifesto(opts.db, {
-        file: opts.file,
-        kind: opts.kind,
-        ...qOpts,
-      });
+      await runManifesto(opts, qOpts);
       return;
     }
 
@@ -58,17 +64,7 @@ export const command = {
     });
 
     if (opts.rules) {
-      if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
-        throw new ConfigError(
-          `Invalid kind "${opts.kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`,
-        );
-      }
-      const { manifesto } = await import('../../presentation/manifesto.js');
-      manifesto(opts.db, {
-        file: opts.file,
-        kind: opts.kind,
-        ...qOpts,
-      });
+      await runManifesto(opts, qOpts);
     }
   },
 };
diff --git a/src/cli/commands/roles.js b/src/cli/commands/roles.js
index cb5a66c1..df756333 100644
--- a/src/cli/commands/roles.js
+++ b/src/cli/commands/roles.js
@@ -3,8 +3,7 @@ import { roles } from '../../presentation/queries-cli.js';
 
 export const command = {
   name: 'roles',
-  description:
-    'Show node role classification: entry, core, utility, adapter, dead, test-only, leaf',
+  description: 'Show node role classification: entry, core, utility, adapter, dead, leaf',
   options: [
     ['-d, --db <path>', 'Path to graph.db'],
     ['--role <role>', `Filter by role (${VALID_ROLES.join(', ')})`],
diff --git a/src/cli/commands/triage.js b/src/cli/commands/triage.js
index 5a8a570f..828b5623 100644
--- a/src/cli/commands/triage.js
+++ b/src/cli/commands/triage.js
@@ -1,6 +1,39 @@
 import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../domain/queries.js';
 import { ConfigError } from '../../shared/errors.js';
 
+function validateFilters(opts) {
+  if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
+    throw new ConfigError(`Invalid kind "${opts.kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`);
+  }
+  if (opts.role && !VALID_ROLES.includes(opts.role)) {
+    throw new ConfigError(`Invalid role "${opts.role}". Valid: ${VALID_ROLES.join(', ')}`);
+  }
+}
+
+function parseWeights(raw) {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError('Invalid --weights JSON', { cause: err });
+  }
+}
+
+async function runHotspots(opts, ctx) {
+  const { hotspotsData, formatHotspots } = await import('../../presentation/structure.js');
+  const metric = opts.sort === 'risk' ? 'fan-in' : opts.sort;
+  const data = hotspotsData(opts.db, {
+    metric,
+    level: opts.level,
+    limit: parseInt(opts.limit, 10),
+    offset: opts.offset ? parseInt(opts.offset, 10) : undefined,
+    noTests: ctx.resolveNoTests(opts),
+  });
+  if (!ctx.outputResult(data, 'hotspots', opts)) {
+    console.log(formatHotspots(data));
+  }
+}
+
 export const command = {
   name: 'triage',
   description:
@@ -31,35 +64,12 @@ export const command = {
   ],
   async execute(_args, opts, ctx) {
     if (opts.level === 'file' || opts.level === 'directory') {
-      const { hotspotsData, formatHotspots } = await import('../../presentation/structure.js');
-      const metric = opts.sort === 'risk' ? 'fan-in' : opts.sort;
-      const data = hotspotsData(opts.db, {
-        metric,
-        level: opts.level,
-        limit: parseInt(opts.limit, 10),
-        offset: opts.offset ? parseInt(opts.offset, 10) : undefined,
-        noTests: ctx.resolveNoTests(opts),
-      });
-      if (!ctx.outputResult(data, 'hotspots', opts)) {
-        console.log(formatHotspots(data));
-      }
+      await runHotspots(opts, ctx);
       return;
     }
 
-    if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
-      throw new ConfigError(`Invalid kind "${opts.kind}". Valid: ${EVERY_SYMBOL_KIND.join(', ')}`);
-    }
-    if (opts.role && !VALID_ROLES.includes(opts.role)) {
-      throw new ConfigError(`Invalid role "${opts.role}". Valid: ${VALID_ROLES.join(', ')}`);
-    }
-    let weights;
-    if (opts.weights) {
-      try {
-        weights = JSON.parse(opts.weights);
-      } catch (err) {
-        throw new ConfigError('Invalid --weights JSON', { cause: err });
-      }
-    }
+    validateFilters(opts);
+    const weights = parseWeights(opts.weights);
     const { triage } = await import('../../presentation/triage.js');
     triage(opts.db, {
       limit: parseInt(opts.limit, 10),
diff --git a/src/domain/analysis/roles.js b/src/domain/analysis/roles.js
index ec271f4a..a54362fd 100644
--- a/src/domain/analysis/roles.js
+++ b/src/domain/analysis/roles.js
@@ -1,5 +1,4 @@
 import { openReadonlyOrFail } from '../../db/index.js';
-import { warn } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
@@ -14,14 +13,9 @@ export function rolesData(customDbPath, opts = {}) {
     const conditions = ['role IS NOT NULL'];
     const params = [];
 
-    // When noTests + filtering for 'dead', also include 'test-only' candidates
-    // (they are stored as non-dead roles but may need reclassification)
-    if (filterRole && filterRole !== 'test-only') {
+    if (filterRole) {
       conditions.push('role = ?');
       params.push(filterRole);
-    } else if (filterRole === 'test-only') {
-      // test-only is not stored in DB; we need all symbols to reclassify
-      // Fetch everything and filter after reclassification
     }
     if (filterFile) {
       conditions.push('file LIKE ?');
@@ -34,27 +28,7 @@ export function rolesData(customDbPath, opts = {}) {
       )
       .all(...params);
 
-    if (noTests) {
-      rows = rows.filter((r) => !isTestFile(r.file));
-    }
-
-    if (noTests || filterRole === 'test-only') {
-      // Reclassify symbols whose only callers are in test files as 'test-only'.
-      // A symbol that has fanIn > 0 at build time (all edges) but fanIn === 0
-      // when test-file callers are excluded should be 'test-only' instead of
-      // whatever role it was assigned with the full graph.
-      const testOnlyIds = _findTestOnlyCalledIds(db);
-      for (const r of rows) {
-        if (testOnlyIds.has(`${r.name}\0${r.file}\0${r.line}`)) {
-          r.role = 'test-only';
-        }
-      }
-    }
-
-    // If we were asked for a specific role, filter now (after reclassification)
-    if (filterRole) {
-      rows = rows.filter((r) => r.role === filterRole);
-    }
+    if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
     const summary = {};
     for (const r of rows) {
@@ -69,58 +43,3 @@ export function rolesData(customDbPath, opts = {}) {
     db.close();
   }
 }
-
-/**
- * Find node keys (name\0file\0line) for symbols whose callers are ALL in test files.
- * These symbols have fanIn > 0 in the full graph but would have fanIn === 0
- * if test-file edges were excluded.
- */
-function _findTestOnlyCalledIds(db) {
-  // Check whether any test-file nodes exist in the graph at all.
-  // If the graph was built with -T (excluding test files), there will be
-  // no test callers and the query below would silently return nothing.
-  const files = db.prepare(`SELECT DISTINCT file FROM nodes WHERE kind = 'file'`).all();
-  const hasTestNodes = files.some((r) => isTestFile(r.file));
-  if (!hasTestNodes) {
-    warn(
-      'No test file nodes found in the graph — run "codegraph build" without -T to enable test-only detection',
-    );
-    return new Set();
-  }
-
-  // Get all non-test symbols that have at least one caller
-  const rows = db
-    .prepare(
-      `SELECT target.name, target.file, target.line,
-              caller.file AS caller_file
-       FROM edges e
-       JOIN nodes target ON e.target_id = target.id
-       JOIN nodes caller ON e.source_id = caller.id
-       WHERE e.kind = 'calls'
-         AND target.kind NOT IN ('file', 'directory')`,
-    )
-    .all();
-
-  // Group callers by target symbol
-  const callersByTarget = new Map();
-  for (const r of rows) {
-    const key = `${r.name}\0${r.file}\0${r.line}`;
-    if (!callersByTarget.has(key))
-      callersByTarget.set(key, { hasTestCaller: false, hasNonTestCaller: false });
-    const entry = callersByTarget.get(key);
-    if (isTestFile(r.caller_file)) {
-      entry.hasTestCaller = true;
-    } else {
-      entry.hasNonTestCaller = true;
-    }
-  }
-
-  // Return keys where ALL callers are in test files
-  const result = new Set();
-  for (const [key, entry] of callersByTarget) {
-    if (entry.hasTestCaller && !entry.hasNonTestCaller) {
-      result.add(key);
-    }
-  }
-  return result;
-}
diff --git a/src/features/structure.js b/src/features/structure.js
index 860072a5..5899e62f 100644
--- a/src/features/structure.js
+++ b/src/features/structure.js
@@ -365,6 +365,22 @@ export function classifyNodeRoles(db) {
       .map((r) => r.target_id),
   );
 
+  // Compute production fan-in (excluding callers in test files)
+  const prodFanInMap = new Map();
+  const prodRows = db
+    .prepare(
+      `SELECT e.target_id, COUNT(*) AS cnt
+      FROM edges e
+      JOIN nodes caller ON e.source_id = caller.id
+      WHERE e.kind = 'calls'
+        ${testFilterSQL('caller.file')}
+      GROUP BY e.target_id`,
+    )
+    .all();
+  for (const r of prodRows) {
+    prodFanInMap.set(r.target_id, r.cnt);
+  }
+
   // Delegate classification to the pure-logic classifier
   const classifierInput = rows.map((r) => ({
     id: String(r.id),
@@ -372,6 +388,7 @@ export function classifyNodeRoles(db) {
     fanIn: r.fan_in,
     fanOut: r.fan_out,
     isExported: exportedIds.has(r.id),
+    productionFanIn: prodFanInMap.get(r.id) || 0,
   }));
 
   const roleMap = classifyRoles(classifierInput);
diff --git a/src/graph/classifiers/risk.js b/src/graph/classifiers/risk.js
index d427efbe..cf7366bd 100644
--- a/src/graph/classifiers/risk.js
+++ b/src/graph/classifiers/risk.js
@@ -16,14 +16,15 @@ export const DEFAULT_WEIGHTS = {
 
 // Role weights reflect structural importance: core modules are central to the
 // dependency graph, utilities are widely imported, entry points are API
-// surfaces. Adapters bridge subsystems but are replaceable. Leaves and dead
-// code have minimal downstream impact.
+// surfaces. Adapters bridge subsystems but are replaceable. Leaves, dead
+// code, and test-only symbols have minimal downstream impact.
 export const ROLE_WEIGHTS = {
   core: 1.0,
   utility: 0.9,
   entry: 0.8,
   adapter: 0.5,
   leaf: 0.2,
+  'test-only': 0.1,
   dead: 0.1,
 };
 
diff --git a/src/graph/classifiers/roles.js b/src/graph/classifiers/roles.js
index 6c30860a..cb4d5498 100644
--- a/src/graph/classifiers/roles.js
+++ b/src/graph/classifiers/roles.js
@@ -38,6 +38,7 @@ export function classifyRoles(nodes) {
   for (const node of nodes) {
     const highIn = node.fanIn >= medFanIn && node.fanIn > 0;
     const highOut = node.fanOut >= medFanOut && node.fanOut > 0;
+    const hasProdFanIn = typeof node.productionFanIn === 'number';
 
     let role;
     const isFrameworkEntry = FRAMEWORK_ENTRY_PREFIXES.some((p) => node.name.startsWith(p));
@@ -47,6 +48,8 @@ export function classifyRoles(nodes) {
       role = node.testOnlyFanIn > 0 ? 'test-only' : 'dead';
     } else if (node.fanIn === 0 && node.isExported) {
       role = 'entry';
+    } else if (hasProdFanIn && node.fanIn > 0 && node.productionFanIn === 0) {
+      role = 'test-only';
     } else if (highIn && !highOut) {
       role = 'core';
     } else if (highIn && highOut) {
diff --git a/src/mcp/server.js b/src/mcp/server.js
index 464fafaf..bae0bbbf 100644
--- a/src/mcp/server.js
+++ b/src/mcp/server.js
@@ -21,45 +21,84 @@ import { TOOL_HANDLERS } from './tools/index.js';
  * @param {boolean} [options.multiRepo] - Enable multi-repo access (default: false)
  * @param {string[]} [options.allowedRepos] - Restrict access to these repo names only
  */
-export async function startMCPServer(customDbPath, options = {}) {
-  const { allowedRepos } = options;
-  const multiRepo = options.multiRepo || !!allowedRepos;
-  let Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema;
+async function loadMCPSdk() {
   try {
     const sdk = await import('@modelcontextprotocol/sdk/server/index.js');
-    Server = sdk.Server;
     const transport = await import('@modelcontextprotocol/sdk/server/stdio.js');
-    StdioServerTransport = transport.StdioServerTransport;
     const types = await import('@modelcontextprotocol/sdk/types.js');
-    ListToolsRequestSchema = types.ListToolsRequestSchema;
-    CallToolRequestSchema = types.CallToolRequestSchema;
+    return {
+      Server: sdk.Server,
+      StdioServerTransport: transport.StdioServerTransport,
+      ListToolsRequestSchema: types.ListToolsRequestSchema,
+      CallToolRequestSchema: types.CallToolRequestSchema,
+    };
   } catch {
     throw new ConfigError(
       'MCP server requires @modelcontextprotocol/sdk.\nInstall it with: npm install @modelcontextprotocol/sdk',
     );
   }
+}
 
-  // Connect transport FIRST so the server can receive the client's
-  // `initialize` request while heavy modules (queries, better-sqlite3)
-  // are still loading.  These are lazy-loaded on the first tool call
-  // and cached for subsequent calls.
+function createLazyLoaders() {
   let _queries;
   let _Database;
+  return {
+    async getQueries() {
+      if (!_queries) _queries = await import('../domain/queries.js');
+      return _queries;
+    },
+    getDatabase() {
+      if (!_Database) {
+        const require = createRequire(import.meta.url);
+        _Database = require('better-sqlite3');
+      }
+      return _Database;
+    },
+  };
+}
 
-  async function getQueries() {
-    if (!_queries) {
-      _queries = await import('../domain/queries.js');
+async function resolveDbPath(customDbPath, args, allowedRepos) {
+  let dbPath = customDbPath || undefined;
+  if (args.repo) {
+    if (allowedRepos && !allowedRepos.includes(args.repo)) {
+      throw new ConfigError(`Repository "${args.repo}" is not in the allowed repos list.`);
     }
-    return _queries;
+    const { resolveRepoDbPath } = await import('../infrastructure/registry.js');
+    const resolved = resolveRepoDbPath(args.repo);
+    if (!resolved)
+      throw new ConfigError(
+        `Repository "${args.repo}" not found in registry or its database is missing.`,
+      );
+    dbPath = resolved;
   }
+  return dbPath;
+}
 
-  function getDatabase() {
-    if (!_Database) {
-      const require = createRequire(import.meta.url);
-      _Database = require('better-sqlite3');
-    }
-    return _Database;
+function validateMultiRepoAccess(multiRepo, name, args) {
+  if (!multiRepo && args.repo) {
+    throw new ConfigError(
+      'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
+    );
+  }
+  if (!multiRepo && name === 'list_repos') {
+    throw new ConfigError(
+      'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
+    );
   }
+}
+
+export async function startMCPServer(customDbPath, options = {}) {
+  const { allowedRepos } = options;
+  const multiRepo = options.multiRepo || !!allowedRepos;
+
+  const { Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema } =
+    await loadMCPSdk();
+
+  // Connect transport FIRST so the server can receive the client's
+  // `initialize` request while heavy modules (queries, better-sqlite3)
+  // are still loading.  These are lazy-loaded on the first tool call
+  // and cached for subsequent calls.
+  const { getQueries, getDatabase } = createLazyLoaders();
 
   const server = new Server(
     { name: 'codegraph', version: '1.0.0' },
@@ -73,47 +112,17 @@ export async function startMCPServer(customDbPath, options = {}) {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
-      if (!multiRepo && args.repo) {
-        throw new ConfigError(
-          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
-        );
-      }
-      if (!multiRepo && name === 'list_repos') {
-        throw new ConfigError(
-          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
-        );
-      }
-
-      let dbPath = customDbPath || undefined;
-      if (args.repo) {
-        if (allowedRepos && !allowedRepos.includes(args.repo)) {
-          throw new ConfigError(`Repository "${args.repo}" is not in the allowed repos list.`);
-        }
-        const { resolveRepoDbPath } = await import('../infrastructure/registry.js');
-        const resolved = resolveRepoDbPath(args.repo);
-        if (!resolved)
-          throw new ConfigError(
-            `Repository "${args.repo}" not found in registry or its database is missing.`,
-          );
-        dbPath = resolved;
-      }
+      validateMultiRepoAccess(multiRepo, name, args);
+      const dbPath = await resolveDbPath(customDbPath, args, allowedRepos);
 
       const toolEntry = TOOL_HANDLERS.get(name);
       if (!toolEntry) {
         return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
       }
 
-      const ctx = {
-        dbPath,
-        getQueries,
-        getDatabase,
-        findDbPath,
-        allowedRepos,
-        MCP_MAX_LIMIT,
-      };
-
+      const ctx = { dbPath, getQueries, getDatabase, findDbPath, allowedRepos, MCP_MAX_LIMIT };
       const result = await toolEntry.handler(args, ctx);
-      if (result?.content) return result; // pass-through MCP responses
+      if (result?.content) return result;
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     } catch (err) {
       const code = err instanceof CodegraphError ? err.code : 'UNKNOWN_ERROR';
diff --git a/src/mcp/tool-registry.js b/src/mcp/tool-registry.js
index 08a2d260..c81baee8 100644
--- a/src/mcp/tool-registry.js
+++ b/src/mcp/tool-registry.js
@@ -362,7 +362,7 @@ const BASE_TOOLS = [
   {
     name: 'node_roles',
     description:
-      'Show node role classification (entry, core, utility, adapter, dead, test-only, leaf) based on connectivity patterns',
+      'Show node role classification (entry, core, utility, adapter, dead, leaf) based on connectivity patterns',
     inputSchema: {
       type: 'object',
       properties: {
diff --git a/src/presentation/queries-cli/exports.js b/src/presentation/queries-cli/exports.js
index ea7dcade..fe06f731 100644
--- a/src/presentation/queries-cli/exports.js
+++ b/src/presentation/queries-cli/exports.js
@@ -1,19 +1,7 @@
 import { exportsData, kindIcon } from '../../domain/queries.js';
 import { outputResult } from '../../infrastructure/result-formatter.js';
 
-export function fileExports(file, customDbPath, opts = {}) {
-  const data = exportsData(file, customDbPath, opts);
-  if (outputResult(data, 'results', opts)) return;
-
-  if (data.results.length === 0) {
-    if (opts.unused) {
-      console.log(`No unused exports found for "${file}".`);
-    } else {
-      console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
-    }
-    return;
-  }
-
+function printExportHeader(data, opts) {
   if (opts.unused) {
     console.log(
       `\n# ${data.file} — ${data.totalUnused} unused export${data.totalUnused !== 1 ? 's' : ''} (of ${data.totalExported} exported)\n`,
@@ -24,8 +12,10 @@ export function fileExports(file, customDbPath, opts = {}) {
       `\n# ${data.file} — ${data.totalExported} exported${unusedNote}, ${data.totalInternal} internal\n`,
     );
   }
+}
 
-  for (const sym of data.results) {
+function printExportSymbols(results) {
+  for (const sym of results) {
     const icon = kindIcon(sym.kind);
     const sig = sym.signature?.params ? `(${sym.signature.params})` : '';
     const role = sym.role ? ` [${sym.role}]` : '';
@@ -38,6 +28,23 @@ export function fileExports(file, customDbPath, opts = {}) {
       }
     }
   }
+}
+
+export function fileExports(file, customDbPath, opts = {}) {
+  const data = exportsData(file, customDbPath, opts);
+  if (outputResult(data, 'results', opts)) return;
+
+  if (data.results.length === 0) {
+    if (opts.unused) {
+      console.log(`No unused exports found for "${file}".`);
+    } else {
+      console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
+    }
+    return;
+  }
+
+  printExportHeader(data, opts);
+  printExportSymbols(data.results);
 
   if (data.reexports.length > 0) {
     console.log(`\n  Re-exports: ${data.reexports.map((r) => r.file).join(', ')}`);
diff --git a/src/presentation/queries-cli/impact.js b/src/presentation/queries-cli/impact.js
index 176172be..511cb42e 100644
--- a/src/presentation/queries-cli/impact.js
+++ b/src/presentation/queries-cli/impact.js
@@ -132,6 +132,56 @@ export function fnImpact(name, customDbPath, opts = {}) {
   }
 }
 
+function printDiffFunctions(data) {
+  console.log(`\ndiff-impact: ${data.changedFiles} files changed\n`);
+  console.log(`  ${data.affectedFunctions.length} functions changed:\n`);
+  for (const fn of data.affectedFunctions) {
+    console.log(`  ${kindIcon(fn.kind)} ${fn.name} -- ${fn.file}:${fn.line}`);
+    if (fn.transitiveCallers > 0) console.log(`    ^ ${fn.transitiveCallers} transitive callers`);
+  }
+}
+
+function printDiffCoupled(data) {
+  if (!data.historicallyCoupled?.length) return;
+  console.log('\n  Historically coupled (not in static graph):\n');
+  for (const c of data.historicallyCoupled) {
+    const pct = `${(c.jaccard * 100).toFixed(0)}%`;
+    console.log(
+      `    ${c.file}  <- coupled with ${c.coupledWith} (${pct}, ${c.commitCount} commits)`,
+    );
+  }
+}
+
+function printDiffOwnership(data) {
+  if (!data.ownership) return;
+  console.log(`\n  Affected owners: ${data.ownership.affectedOwners.join(', ')}`);
+  console.log(`  Suggested reviewers: ${data.ownership.suggestedReviewers.join(', ')}`);
+}
+
+function printDiffBoundaries(data) {
+  if (!data.boundaryViolations?.length) return;
+  console.log(`\n  Boundary violations (${data.boundaryViolationCount}):\n`);
+  for (const v of data.boundaryViolations) {
+    console.log(`    [${v.name}] ${v.file} -> ${v.targetFile}`);
+    if (v.message) console.log(`      ${v.message}`);
+  }
+}
+
+function printDiffSummary(summary) {
+  if (!summary) return;
+  let line = `\n  Summary: ${summary.functionsChanged} functions changed -> ${summary.callersAffected} callers affected across ${summary.filesAffected} files`;
+  if (summary.historicallyCoupledCount > 0) {
+    line += `, ${summary.historicallyCoupledCount} historically coupled`;
+  }
+  if (summary.ownersAffected > 0) {
+    line += `, ${summary.ownersAffected} owners affected`;
+  }
+  if (summary.boundaryViolationCount > 0) {
+    line += `, ${summary.boundaryViolationCount} boundary violations`;
+  }
+  console.log(`${line}\n`);
+}
+
 export function diffImpact(customDbPath, opts = {}) {
   if (opts.format === 'mermaid') {
     console.log(diffImpactMermaid(customDbPath, opts));
@@ -156,43 +206,9 @@ export function diffImpact(customDbPath, opts = {}) {
     return;
   }
 
-  console.log(`\ndiff-impact: ${data.changedFiles} files changed\n`);
-  console.log(`  ${data.affectedFunctions.length} functions changed:\n`);
-  for (const fn of data.affectedFunctions) {
-    console.log(`  ${kindIcon(fn.kind)} ${fn.name} -- ${fn.file}:${fn.line}`);
-    if (fn.transitiveCallers > 0) console.log(`    ^ ${fn.transitiveCallers} transitive callers`);
-  }
-  if (data.historicallyCoupled && data.historicallyCoupled.length > 0) {
-    console.log('\n  Historically coupled (not in static graph):\n');
-    for (const c of data.historicallyCoupled) {
-      const pct = `${(c.jaccard * 100).toFixed(0)}%`;
-      console.log(
-        `    ${c.file}  <- coupled with ${c.coupledWith} (${pct}, ${c.commitCount} commits)`,
-      );
-    }
-  }
-  if (data.ownership) {
-    console.log(`\n  Affected owners: ${data.ownership.affectedOwners.join(', ')}`);
-    console.log(`  Suggested reviewers: ${data.ownership.suggestedReviewers.join(', ')}`);
-  }
-  if (data.boundaryViolations && data.boundaryViolations.length > 0) {
-    console.log(`\n  Boundary violations (${data.boundaryViolationCount}):\n`);
-    for (const v of data.boundaryViolations) {
-      console.log(`    [${v.name}] ${v.file} -> ${v.targetFile}`);
-      if (v.message) console.log(`      ${v.message}`);
-    }
-  }
-  if (data.summary) {
-    let summaryLine = `\n  Summary: ${data.summary.functionsChanged} functions changed -> ${data.summary.callersAffected} callers affected across ${data.summary.filesAffected} files`;
-    if (data.summary.historicallyCoupledCount > 0) {
-      summaryLine += `, ${data.summary.historicallyCoupledCount} historically coupled`;
-    }
-    if (data.summary.ownersAffected > 0) {
-      summaryLine += `, ${data.summary.ownersAffected} owners affected`;
-    }
-    if (data.summary.boundaryViolationCount > 0) {
-      summaryLine += `, ${data.summary.boundaryViolationCount} boundary violations`;
-    }
-    console.log(`${summaryLine}\n`);
-  }
+  printDiffFunctions(data);
+  printDiffCoupled(data);
+  printDiffOwnership(data);
+  printDiffBoundaries(data);
+  printDiffSummary(data.summary);
 }
diff --git a/src/presentation/queries-cli/path.js b/src/presentation/queries-cli/path.js
index fbdaafa5..9d61b1a6 100644
--- a/src/presentation/queries-cli/path.js
+++ b/src/presentation/queries-cli/path.js
@@ -1,6 +1,40 @@
 import { kindIcon, pathData } from '../../domain/queries.js';
 import { outputResult } from '../../infrastructure/result-formatter.js';
 
+function printNotFound(from, to, data) {
+  const dir = data.reverse ? 'reverse ' : '';
+  console.log(`No ${dir}path from "${from}" to "${to}" within ${data.maxDepth} hops.`);
+  if (data.fromCandidates.length > 1) {
+    console.log(
+      `\n  "${from}" matched ${data.fromCandidates.length} symbols — using top match: ${data.fromCandidates[0].name} (${data.fromCandidates[0].file}:${data.fromCandidates[0].line})`,
+    );
+  }
+  if (data.toCandidates.length > 1) {
+    console.log(
+      `  "${to}" matched ${data.toCandidates.length} symbols — using top match: ${data.toCandidates[0].name} (${data.toCandidates[0].file}:${data.toCandidates[0].line})`,
+    );
+  }
+}
+
+function printPathSteps(data) {
+  for (let i = 0; i < data.path.length; i++) {
+    const n = data.path[i];
+    const indent = '  '.repeat(i + 1);
+    if (i === 0) {
+      console.log(`${indent}${kindIcon(n.kind)} ${n.name} (${n.kind}) -- ${n.file}:${n.line}`);
+    } else {
+      console.log(
+        `${indent}--[${n.edgeKind}]--> ${kindIcon(n.kind)} ${n.name} (${n.kind}) -- ${n.file}:${n.line}`,
+      );
+    }
+  }
+  if (data.alternateCount > 0) {
+    console.log(
+      `\n  (${data.alternateCount} alternate shortest ${data.alternateCount === 1 ? 'path' : 'paths'} at same depth)`,
+    );
+  }
+}
+
 export function symbolPath(from, to, customDbPath, opts = {}) {
   const data = pathData(from, to, customDbPath, opts);
   if (outputResult(data, null, opts)) return;
@@ -11,18 +45,7 @@ export function symbolPath(from, to, customDbPath, opts = {}) {
   }
 
   if (!data.found) {
-    const dir = data.reverse ? 'reverse ' : '';
-    console.log(`No ${dir}path from "${from}" to "${to}" within ${data.maxDepth} hops.`);
-    if (data.fromCandidates.length > 1) {
-      console.log(
-        `\n  "${from}" matched ${data.fromCandidates.length} symbols — using top match: ${data.fromCandidates[0].name} (${data.fromCandidates[0].file}:${data.fromCandidates[0].line})`,
-      );
-    }
-    if (data.toCandidates.length > 1) {
-      console.log(
-        `  "${to}" matched ${data.toCandidates.length} symbols — using top match: ${data.toCandidates[0].name} (${data.toCandidates[0].file}:${data.toCandidates[0].line})`,
-      );
-    }
+    printNotFound(from, to, data);
     return;
   }
 
@@ -37,22 +60,6 @@ export function symbolPath(from, to, customDbPath, opts = {}) {
   console.log(
     `\nPath from ${from} to ${to} (${data.hops} ${data.hops === 1 ? 'hop' : 'hops'})${dir}:\n`,
   );
-  for (let i = 0; i < data.path.length; i++) {
-    const n = data.path[i];
-    const indent = '  '.repeat(i + 1);
-    if (i === 0) {
-      console.log(`${indent}${kindIcon(n.kind)} ${n.name} (${n.kind}) -- ${n.file}:${n.line}`);
-    } else {
-      console.log(
-        `${indent}--[${n.edgeKind}]--> ${kindIcon(n.kind)} ${n.name} (${n.kind}) -- ${n.file}:${n.line}`,
-      );
-    }
-  }
-
-  if (data.alternateCount > 0) {
-    console.log(
-      `\n  (${data.alternateCount} alternate shortest ${data.alternateCount === 1 ? 'path' : 'paths'} at same depth)`,
-    );
-  }
+  printPathSteps(data);
   console.log();
 }
diff --git a/tests/integration/roles.test.js b/tests/integration/roles.test.js
index 04dca9b1..2a92b16a 100644
--- a/tests/integration/roles.test.js
+++ b/tests/integration/roles.test.js
@@ -60,7 +60,6 @@ beforeAll(() => {
   const helper = insertNode(db, 'helper', 'function', 'lib.js', 1);
   const format = insertNode(db, 'format', 'function', 'lib.js', 10);
   insertNode(db, 'unused', 'function', 'lib.js', 20);
-  const testHelper = insertNode(db, 'testHelper', 'function', 'lib.js', 30);
   const testFn = insertNode(db, 'testMain', 'function', 'app.test.js', 1);
 
   // Import edges
@@ -73,13 +72,11 @@ beforeAll(() => {
   // processData → format (cross-file) → makes format exported
   // helper → format (same file)
   // testFn → main (cross-file) → makes main exported
-  // testFn → testHelper (cross-file) → testHelper only called from test
   insertEdge(db, main, process_, 'calls');
   insertEdge(db, main, helper, 'calls');
   insertEdge(db, process_, format, 'calls');
   insertEdge(db, helper, format, 'calls');
   insertEdge(db, testFn, main, 'calls');
-  insertEdge(db, testFn, testHelper, 'calls');
 
   // unused has no callers and no cross-file callers → dead
 
@@ -136,37 +133,6 @@ describe('rolesData', () => {
       expect(s.file).not.toMatch(/\.test\./);
     }
   });
-
-  test('reclassifies test-only-called symbols when noTests is true', () => {
-    const data = rolesData(dbPath, { noTests: true });
-    const th = data.symbols.find((s) => s.name === 'testHelper');
-    expect(th).toBeDefined();
-    expect(th.role).toBe('test-only');
-  });
-
-  test('does not reclassify test-only-called symbols when noTests is false', () => {
-    const data = rolesData(dbPath);
-    const th = data.symbols.find((s) => s.name === 'testHelper');
-    expect(th).toBeDefined();
-    expect(th.role).not.toBe('test-only');
-  });
-
-  test('filters by role=test-only with noTests', () => {
-    const data = rolesData(dbPath, { noTests: true, role: 'test-only' });
-    expect(data.count).toBeGreaterThan(0);
-    for (const s of data.symbols) {
-      expect(s.role).toBe('test-only');
-    }
-    const names = data.symbols.map((s) => s.name);
-    expect(names).toContain('testHelper');
-  });
-
-  test('unused symbol stays dead with noTests', () => {
-    const data = rolesData(dbPath, { noTests: true });
-    const unused = data.symbols.find((s) => s.name === 'unused');
-    expect(unused).toBeDefined();
-    expect(unused.role).toBe('dead');
-  });
 });
 
 // ─── statsData includes roles ───────────────────────────────────────────