diff --git a/.claude/skills/titan-close/SKILL.md b/.claude/skills/titan-close/SKILL.md
index 4fa1eff7..a8b70181 100644
--- a/.claude/skills/titan-close/SKILL.md
+++ b/.claude/skills/titan-close/SKILL.md
@@ -65,6 +65,7 @@ Your goal: analyze all commits on the current branch, split them into focused PR
    - `.codegraph/titan/issues.ndjson` — issue tracker from all phases
    - `.codegraph/titan/arch-snapshot.json` — pre-forge architectural snapshot (communities, structure, drift). Use for before/after comparison in the Metrics section. May not exist if capture failed.
    - `.codegraph/titan/drift-report.json` — cumulative drift reports from all phases. May not exist if no drift was detected.
+   - `.codegraph/titan/grind-targets.ndjson` — grind phase adoption targets and outcomes. Each line: `{target, file, phase, classification, reason, consumers, pattern, timestamp}`. May not exist if grind wasn't run.
 
    If `titan-state.json` is missing after the search, stop: "No Titan session found. Run `/titan-recon` first."
 
@@ -146,6 +147,9 @@ Use `sync.json` execution phases as the primary guide if available:
    - 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>`
+7. **Helper adoption** — commits from grind phase adopting dead helpers into callsites
+   - PR title: `refactor: adopt dead helpers in <domain>`
+   - Look for `grind(...)` commit prefixes or commits touching files listed in `grind-targets.ndjson`
 
 ### Fallback grouping (if no sync.json)
 
@@ -164,7 +168,7 @@ Record the grouping plan:
   {
     "pr": 1,
     "title": "...",
-    "concern": "dead_code|abstraction|cycle_break|decomposition|quality_fix|warning",
+    "concern": "dead_code|abstraction|cycle_break|decomposition|quality_fix|warning|adoption",
     "domain": "<domain name>",
     "commits": ["<sha1>", "<sha2>"],
     "files": ["<file1>", "<file2>"],
@@ -202,6 +206,17 @@ codegraph complexity --health --sort mi -T --json --limit 10
 
 If `.codegraph/titan/arch-snapshot.json` was captured before forge, compare its `structure` data against current `codegraph structure --depth 2 --json` output. Report cohesion changes per directory (improved / degraded / unchanged). Include in the "Metrics: Before & After" section of the report.
 
+### Grind metrics (if grind-targets.ndjson exists)
+
+If `.codegraph/titan/grind-targets.ndjson` exists, parse it and cross-reference with `titan-state.json → grind`:
+- **Targets processed:** count entries in `grind.processedTargets` (from titan-state.json)
+- **Targets failed:** count entries in `grind.failedTargets` (from titan-state.json)
+- **False positives identified:** count entries with `classification: "false-positive"` in grind-targets.ndjson (or from `grind.falsePositives` in titan-state.json)
+- **Adopted:** count entries with `classification: "adopt"` in grind-targets.ndjson
+- **Dead symbol delta:** from `grind.deadSymbolDelta` in titan-state.json (or compute from baseline vs final dead symbol counts)
+
+Include these in the Metrics: Before & After section and the Grind Results report section.
+
 ### Compute deltas
 
 Compare final metrics against `titan-state.json` baseline:
@@ -342,7 +357,8 @@ Read `titan-state.json → phaseTimestamps` for real wall-clock data. If `phaseT
 | GAUNTLET | <computed from phaseTimestamps.gauntlet> | <iterations count if resuming> |
 | SYNC | <computed from phaseTimestamps.sync> | — |
 | FORGE | <computed from phaseTimestamps.forge> | <commit count>, first at <time>, last at <time> |
-| GATE | across forge | <total runs> inline with forge commits |
+| GRIND | <computed from phaseTimestamps.grind> | <targets processed>, <adoptions made> |
+| GATE | across forge/grind | <total runs> inline with forge/grind commits |
 | CLOSE | <computed from phaseTimestamps.close> | — |
 | **Total** | <sum of all phases> | — |
 
@@ -393,6 +409,22 @@ Read `titan-state.json → phaseTimestamps` for real wall-clock data. If `phaseT
 
 ---
 
+## Grind Results (if grind ran)
+
+**Targets processed:** <N> | **Adopted:** <N> | **Failed:** <N> | **False positives:** <N>
+
+### Adoption Summary
+
+<Table: target name, dead symbols before, dead symbols after, delta, files modified>
+
+### False Positives Logged
+
+<Table: target name, reason (dynamic import / re-export / closure-local / type noise), logged to issues.ndjson>
+
+> Omit this section entirely if `grind-targets.ndjson` does not exist.
+
+---
+
 ## Changes Made
 
 ### Commits: <total count>
@@ -551,6 +583,7 @@ Write `.codegraph/titan/close-summary.json`:
   },
   "audit": { "totalAudited": 0, "pass": 0, "warn": 0, "fail": 0, "decompose": 0 },
   "gate": { "totalRuns": 0, "pass": 0, "warn": 0, "fail": 0, "rollbacks": 0 },
+  "grind": { "targetsProcessed": 0, "adopted": 0, "failed": 0, "falsePositives": 0, "deadSymbolDelta": 0 },
   "issues": { "codegraph": 0, "tooling": 0, "process": 0, "codebase": 0 },
   "prs": [
     { "number": 0, "url": "<url>", "title": "<title>", "concern": "<type>", "domain": "<domain>", "commits": 0 }
diff --git a/.claude/skills/titan-grind/SKILL.md b/.claude/skills/titan-grind/SKILL.md
index 77481238..eab05227 100644
--- a/.claude/skills/titan-grind/SKILL.md
+++ b/.claude/skills/titan-grind/SKILL.md
@@ -13,13 +13,13 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
 
 > **Why this phase exists:** Forge decomposes god-functions into smaller helpers, but those helpers are only called within their own file. The dead symbol count inflates with every forge phase because the adoption loop is never closed. Grind closes it.
 
-> **Context budget:** One forge phase per invocation. Process all targets from one forge phase's commits, then stop. User re-runs for the next phase.
+> **Context budget:** One forge phase per invocation. Process all targets from one forge phase's commits, then stop. If context reaches ~80% capacity mid-phase, write all state to disk, print a progress message, and stop — user re-runs for remainder.
 
 **Arguments** (from `$ARGUMENTS`):
 - No args → process the next unground forge phase
 - `--phase N` → process a specific forge phase
 - `--target <name>` → run single target only (for retrying failures)
-- `--dry-run` → analyze and report without making changes
+- `--dry-run` → analyze and classify without making code changes (classifications ARE persisted to `grind-targets.ndjson`)
 - `--yes` → skip confirmation prompt (typically passed by `/titan-run` orchestrator)
 
 ---
@@ -32,24 +32,46 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
    ```
    If not in a worktree, stop: "Run `/worktree` first."
 
-2. **Sync with main:**
+2. **Session discovery.** Check all worktrees for titan artifacts:
+   ```bash
+   git worktree list
+   ```
+   For each worktree, check:
+   ```bash
+   ls <worktree-path>/.codegraph/titan/titan-state.json 2>/dev/null
+   ```
+   - **Found artifacts in a different worktree:** Read its `titan-state.json → currentPhase` and `execution` block. If forge completed there but grind hasn't run, merge its branch: `git merge <branch> --no-edit`
+   - **Found artifacts in current worktree:** Proceed normally.
+   - **Found nothing:** Stop: "No Titan session found. Run `/titan-forge` first."
+
+3. **Sync with main:**
    ```bash
    git fetch origin main && git merge origin/main --no-edit
    ```
    If merge conflicts → stop: "Merge conflict detected. Resolve and re-run `/titan-grind`."
 
-3. **Load artifacts.** Read:
+4. **Validate state file integrity:**
+   ```bash
+   node -e "try { JSON.parse(require('fs').readFileSync('.codegraph/titan/titan-state.json','utf8')); console.log('OK'); } catch(e) { console.log('CORRUPT: '+e.message); process.exit(1); }"
+   ```
+   If CORRUPT → check `.codegraph/titan/titan-state.json.bak`:
+   - Backup valid → restore: `cp .codegraph/titan/titan-state.json.bak .codegraph/titan/titan-state.json`
+   - Backup also corrupt or missing → stop: "State file corrupted with no valid backup. Run `/titan-reset` and start over."
+
+5. **Load artifacts.** Read:
    - `.codegraph/titan/titan-state.json` — current state (required)
    - `.codegraph/titan/sync.json` — execution plan (required)
    - `.codegraph/titan/gate-log.ndjson` — gate verdicts (optional)
    - `.codegraph/titan/grind-targets.ndjson` — persisted grind analysis (optional, exists on resume)
+   - `.codegraph/titan/arch-snapshot.json` — pre-forge architectural snapshot (optional — if missing, gate's A1/A3/A4 checks will be skipped; print: "NOTE: No arch-snapshot.json found. Gate architectural comparisons will be skipped.")
+   - `.codegraph/titan/issues.ndjson` — cross-phase issue tracker (optional, for appending)
 
-4. **Validate state.** Grind runs after forge. Check:
+6. **Validate state.** Grind runs after forge. Check:
    - `titan-state.json → execution` block exists
    - `execution.completedPhases` has at least one entry
    - If no `execution` block → stop: "No forge execution found. Run `/titan-forge` first."
 
-5. **Initialize grind state** (if `grind` block doesn't exist in `titan-state.json`). Merge into `titan-state.json`:
+7. **Initialize grind state** (if `grind` block doesn't exist in `titan-state.json`). Merge into `titan-state.json`:
    ```json
    {
      "grind": {
@@ -61,33 +83,62 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
        "adoptions": [],
        "removals": [],
        "falsePositives": [],
+       "diffWarnings": [],
        "deadSymbolBaseline": null,
        "deadSymbolCurrent": null
      }
    }
    ```
 
-6. **Ensure graph is current.** Rebuild if stale:
-   ```bash
-   codegraph build
-   ```
+8. **Update top-level state.** Set `currentPhase` to `"grind"` in `titan-state.json`. Write immediately.
 
-7. **Capture dead-symbol baseline** (only if `grind.deadSymbolBaseline` is null):
+9. **Back up state:**
    ```bash
-   codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const items=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:items.length,byRole:items.reduce((a,i)=>{a[i.role]=(a[i.role]||0)+1;return a},{})}));})"
+   cp .codegraph/titan/titan-state.json .codegraph/titan/titan-state.json.bak
    ```
-   Store the total in `grind.deadSymbolBaseline`. Write `titan-state.json` immediately.
 
-8. **Determine next phase.** Use `--phase N` if provided, otherwise find the lowest forge phase number not in `grind.completedPhases`.
+10. **Ensure graph is current.** Rebuild if stale:
+    ```bash
+    codegraph build
+    ```
+
+11. **Take a graph snapshot** before making changes:
+    ```bash
+    codegraph snapshot save titan-grind-baseline 2>/dev/null || true
+    ```
+
+12. **Capture dead-symbol baseline** (only if `grind.deadSymbolBaseline` is null):
+    ```bash
+    codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const items=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:items.length,byRole:items.reduce((a,i)=>{a[i.role]=(a[i.role]||0)+1;return a},{})}));})"
+    ```
+    Store the total in `grind.deadSymbolBaseline`. Write `titan-state.json` immediately.
 
-9. **Update state.** Set `grind.currentPhase` to the target phase number. Write `titan-state.json`.
+13. **Drift detection.** Compare `titan-state.json → mainSHA` against current origin/main:
+    ```bash
+    git rev-list --count <mainSHA>..origin/main
+    ```
+    If main has advanced, check if any forge-touched files were modified:
+    ```bash
+    git diff --name-only <mainSHA>..origin/main
+    ```
+    Cross-reference against files from forge's `execution.commits`. If >20% of grind candidate files changed on main → **WARN**: "Main has advanced <N> commits since forge. <M> grind candidate files were modified. Some helpers may already be adopted or removed on main. Consider re-running `/titan-recon`." Continue unless >50% affected, then stop.
+
+14. **Determine next phase.** Use `--phase N` if provided, otherwise find the lowest forge phase number not in `grind.completedPhases`.
 
-10. **Print plan and ask for confirmation** (unless `--yes`):
+15. **Update state.** Set `grind.currentPhase` to the target phase number. Write `titan-state.json`.
+
+16. **Record phase timestamp** (only if not already set — may exist from a prior crashed run):
+    ```bash
+    node -e "const fs=require('fs');const s=JSON.parse(fs.readFileSync('.codegraph/titan/titan-state.json','utf8'));s.phaseTimestamps=s.phaseTimestamps||{};s.phaseTimestamps['grind']=s.phaseTimestamps['grind']||{};if(!s.phaseTimestamps['grind'].startedAt){s.phaseTimestamps['grind'].startedAt=new Date().toISOString();fs.writeFileSync('.codegraph/titan/titan-state.json',JSON.stringify(s,null,2));}"
+    ```
+
+17. **Print plan and ask for confirmation** (unless `--yes`):
     ```
     GRIND — Phase N: <label>
     Forge made N commits for this phase.
     Dead symbol baseline: <N>
     Previously processed: <N> targets (<N> adopted, <N> failed)
+    Drift: <fresh|N commits behind>
     
     Will: identify new dead symbols, find adoption opportunities, wire helpers into consumers.
     Proceed? [y/n]
@@ -97,7 +148,22 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
 
 ## Step 1 — Identify forge's new symbols
 
-**Skip if:** `.codegraph/titan/grind-targets.ndjson` already has entries for this phase (resume case). Load existing entries and skip to Step 3.
+**Skip if:** `.codegraph/titan/grind-targets.ndjson` already has entries for this phase (resume case). Validate NDJSON integrity first:
+
+```bash
+node -e "
+const fs = require('fs');
+const path = '.codegraph/titan/grind-targets.ndjson';
+if (!fs.existsSync(path)) { console.log(JSON.stringify({ valid: 0, corrupt: 0, total: 0, missing: true })); process.exit(0); }
+const lines = fs.readFileSync(path,'utf8').trim().split('\n');
+let valid = 0, corrupt = 0;
+for (const line of lines) { try { JSON.parse(line); valid++; } catch { corrupt++; } }
+console.log(JSON.stringify({ valid, corrupt, total: lines.length, missing: false }));
+"
+```
+
+- If `corrupt > 0`: Print "WARNING: <corrupt> corrupt lines in grind-targets.ndjson (likely from a crashed write). These targets will be re-classified."
+- If existing valid entries cover this phase → load them and skip to Step 3.
 
 For the target forge phase, get the commits from `titan-state.json → execution.commits` that belong to this phase (cross-reference with `sync.json → executionOrder[phase].targets`).
 
@@ -153,7 +219,10 @@ Check for:
 - **Closure-local usage** — the symbol is assigned to a variable and called within the same function
 - **Template literal usage** — the symbol is referenced inside a string template (e.g., HTML renderer)
 
-If any of these apply → classify as **false-positive**.
+If any of these apply → classify as **false-positive**. Append to `.codegraph/titan/issues.ndjson`:
+```json
+{"phase":"grind","timestamp":"<ISO 8601>","severity":"bug","category":"codegraph","description":"False positive dead-code detection: <symbol> in <file> — <reason>","context":"<detection method that failed>"}
+```
 
 ### 2c. Duplicate-logic scan
 
@@ -213,14 +282,14 @@ For each grind target, assign one of:
 | **intentionally-private** | Helper is file-local and only used within its file. Remove export or leave as-is. |
 | **remove** | Helper is genuinely unused and has no adoption opportunity. Delete it. |
 
-**Persist each classification immediately** to `.codegraph/titan/grind-targets.ndjson` (one JSON object per line):
+**Persist each classification immediately** to `.codegraph/titan/grind-targets.ndjson` (one JSON object per line, append-only):
 ```json
 {"target":"<name>","file":"<file>","phase":N,"classification":"adopt|re-export|promote|false-positive|intentionally-private|remove","reason":"<why>","consumers":["file1.ts"],"pattern":"<what to search for>","timestamp":"<ISO 8601>"}
 ```
 
 This ensures resume works — if interrupted, re-running loads existing entries and skips already-classified targets.
 
-If zero actionable grind targets (only false-positives and intentionally-private) → print "Phase N: no dead helpers to adopt. Forge wired everything correctly (or all dead symbols are false positives)." Mark phase complete, stop.
+If zero actionable grind targets (only false-positives and intentionally-private) → print "Phase N: no dead helpers to adopt. Forge wired everything correctly (or all dead symbols are false positives)." Mark phase complete, skip to Step 5.
 
 ---
 
@@ -230,7 +299,10 @@ For each grind target classified as **adopt**, **re-export**, **promote**, or **
 
 1. **Skip if done.** Check if target is already in `grind.processedTargets`. If so, skip.
 
-2. **Update state.** Set `grind.currentTarget` in `titan-state.json`. Write immediately.
+2. **Update state.** Set `grind.currentTarget` in `titan-state.json`. Write immediately. Back up:
+   ```bash
+   cp .codegraph/titan/titan-state.json .codegraph/titan/titan-state.json.bak
+   ```
 
 3. **Reload grind-targets.ndjson** entry for this target to get classification, consumers, and pattern.
 
@@ -246,11 +318,11 @@ For each grind target classified as **adopt**, **re-export**, **promote**, or **
    codegraph where --file <consumer-file> -T --json
    ```
 
-5. **Check if still dead.** The target may have been adopted by a previous grind commit in this phase:
+5. **Check if still dead.** The target may have been adopted by a previous grind commit or by changes merged from main:
    ```bash
    codegraph roles --role dead -T --file <target-file> --json
    ```
-   If the target is no longer dead → skip with note: "Target already adopted by a prior grind commit."
+   If the target is no longer dead → skip with note: "Target already adopted (by prior grind commit or main merge)."
 
 6. **Read source file(s).** Read the helper source and each consumer site. Understand the code before editing.
 
@@ -267,18 +339,71 @@ For each grind target classified as **adopt**, **re-export**, **promote**, or **
    ```
    Never `git add .` or `git add -A`.
 
-9. **Verify impact before committing:**
+9. **Diff review (intent verification):**
+
+   Collect the context:
+   ```bash
+   git diff --cached --stat
+   git diff --cached
+   ```
+
+   **DR1. Scope — only expected files touched:**
+   Compare staged file paths against the consumer list from `grind-targets.ndjson`. Flag any file NOT associated with the current target or its known consumers.
+   - File in a completely different domain → **DIFF FAIL**
+   - File is a direct dependency of the target (import chain) → **OK** (expected ripple)
+   - Test file for the target → **OK**
+
+   **DR2. Intent match — diff aligns with classification:**
+   - `adopt` → diff should show new import statements and replaced inline patterns, not new logic
+   - `re-export` → diff should only touch the barrel file
+   - `promote` → diff should add export + barrel entry + consumer imports
+   - `remove` → diff should show only deletions (no new functions added)
+   If the diff does something **entirely different** from the classification → **DIFF FAIL**
+
+   **DR3. Deletion audit (for remove targets):**
+   If lines removed > 10, verify deleted symbols have no active callers not updated in this diff:
+   ```bash
+   codegraph fn-impact <deleted-symbol> -T --json 2>/dev/null
+   ```
+   If deleted symbol has callers not in the staged diff → **DIFF FAIL**: "Deleted <symbol> still has <N> callers not updated."
+
+   **On DIFF FAIL:**
    ```bash
-   codegraph diff-impact --staged -T --json
+   git restore --staged $(git diff --cached --name-only)
+   git checkout -- $(git diff --name-only)
    ```
-   Review the blast radius. If transitive callers > 30 for a simple adoption, something is wrong — review the change carefully.
+   Add to `grind.failedTargets` with reason `"diff-review: <detail>"`. Continue to next target.
+
+   **On DIFF WARN:** Log to `grind.diffWarnings`:
+   ```json
+   { "target": "<name>", "check": "<DR1|DR2|DR3>", "message": "<warning text>", "phase": N }
+   ```
+   Proceed to tests.
+
+10. **Verify impact:**
+    ```bash
+    codegraph diff-impact --staged -T --json
+    ```
+    Review the blast radius. If transitive callers > 30 for a simple adoption, something is wrong — review the change carefully.
+
+11. **Run tests (fast-fail before gate):**
+    ```bash
+    testCmd=$(node -e "const p=require('./package.json');const s=p.scripts||{};const script=s.test?'test':s['test:ci']?'test:ci':null;if(!script){console.log('NO_TEST_SCRIPT');process.exit(0);}const fs=require('fs');const runner=fs.existsSync('yarn.lock')?'yarn':fs.existsSync('pnpm-lock.yaml')?'pnpm':fs.existsSync('bun.lockb')?'bun':'npm';console.log(runner+(script==='test'?' test':' run '+script));")
+    ```
+    - If `testCmd == "NO_TEST_SCRIPT"` → skip pre-gate test run.
+    - Otherwise run: `$testCmd 2>&1`. If tests fail → go to rollback (step 15).
 
-10. **Run /titan-gate:**
+12. **Run /titan-gate:**
     Use the Skill tool to invoke `titan-gate`.
-    - If FAIL on **cycle/test/lint/build** → go to rollback (step 13).
-    - If FAIL on **other checks** → unstage with `git restore --staged $(git diff --cached --name-only)`, add to `grind.failedTargets` with reason, continue to next target.
+    - If FAIL on **cycle/test/lint/build** (gate auto-rolls back staged changes) → go to rollback (step 15) to also revert working tree.
+    - If FAIL on **other checks** (complexity, semantic, structural/arch) — gate does NOT auto-rollback → unstage AND revert:
+      ```bash
+      git restore --staged $(git diff --cached --name-only) 2>/dev/null
+      git checkout -- $(git diff --name-only) 2>/dev/null
+      ```
+      Add to `grind.failedTargets` with reason, continue to next target. Do NOT go to step 15.
 
-11. **Commit on success:**
+13. **Commit on success:**
     ```bash
     git commit -m "grind(<scope>): adopt <helper> across <N> consumers"
     ```
@@ -286,8 +411,12 @@ For each grind target classified as **adopt**, **re-export**, **promote**, or **
     ```bash
     git commit -m "grind(<scope>): remove unused <helper>"
     ```
+    For re-exports:
+    ```bash
+    git commit -m "grind(<scope>): re-export <helper> from barrel"
+    ```
 
-12. **Update state on success.** Write `titan-state.json` immediately after each commit:
+14. **Update state on success.** Write `titan-state.json` immediately after each commit:
     - Add target to `grind.processedTargets`
     - Record in `grind.adoptions` (or `grind.removals`):
       ```json
@@ -300,25 +429,39 @@ For each grind target classified as **adopt**, **re-export**, **promote**, or **
       }
       ```
     - Clear `grind.currentTarget`
+    - Back up state:
+      ```bash
+      cp .codegraph/titan/titan-state.json .codegraph/titan/titan-state.json.bak
+      ```
 
-13. **On failure (test or gate rollback):**
+15. **On failure (test or gate cycle/test/lint/build rollback):**
     ```bash
-    # Discover dirty files at rollback time
+    # Restore graph snapshot
+    codegraph snapshot restore titan-grind-baseline 2>/dev/null || true
+    # Revert working tree
     git restore --staged $(git diff --cached --name-only) 2>/dev/null
     git checkout -- $(git diff --name-only) 2>/dev/null
+    # Rebuild graph from clean state
+    codegraph build
     ```
     - Add to `grind.failedTargets`: `{ "target": "<name>", "reason": "<why>", "phase": N }`
     - Add target to `grind.processedTargets` (so it's not retried on resume)
     - Clear `grind.currentTarget`
     - Write `titan-state.json`
+    - Back up state
     - **Continue to next target** — don't block the whole phase
 
-14. **Rebuild graph** after changes to keep it current for the next target:
+16. **Rebuild graph** after successful changes to keep it current for the next target:
     ```bash
     codegraph build
     ```
 
-For **false-positive** and **intentionally-private** targets: add to `grind.processedTargets` and `grind.falsePositives`, write state, but make no code changes. These inform future improvements to codegraph's dead-code detection.
+17. **Take a fresh snapshot** for the next target's rollback safety:
+    ```bash
+    codegraph snapshot save titan-grind-baseline 2>/dev/null || true
+    ```
+
+For **false-positive** and **intentionally-private** targets: add to `grind.processedTargets` and `grind.falsePositives`, write state and backup, but make no code changes.
 
 ---
 
@@ -353,6 +496,20 @@ On FAIL: print the new dead symbols that were not addressed and their files. Do
 3. Clear `grind.currentPhase`
 4. Clear `grind.currentTarget`
 5. Write updated `titan-state.json`
+6. Back up state:
+   ```bash
+   cp .codegraph/titan/titan-state.json .codegraph/titan/titan-state.json.bak
+   ```
+
+When ALL forge phases are ground (all entries in `execution.completedPhases` are in `grind.completedPhases`):
+7. Record `phaseTimestamps.grind.completedAt`:
+   ```bash
+   node -e "const fs=require('fs');const s=JSON.parse(fs.readFileSync('.codegraph/titan/titan-state.json','utf8'));s.phaseTimestamps=s.phaseTimestamps||{};s.phaseTimestamps['grind']=s.phaseTimestamps['grind']||{};s.phaseTimestamps['grind'].completedAt=new Date().toISOString();fs.writeFileSync('.codegraph/titan/titan-state.json',JSON.stringify(s,null,2));"
+   ```
+8. Clean up grind snapshot:
+   ```bash
+   codegraph snapshot delete titan-grind-baseline 2>/dev/null || true
+   ```
 
 ---
 
@@ -367,7 +524,7 @@ Dead symbols: <baseline> → <current> (delta: <+/-N>)
 Targets: <processed>/<total> processed, <failed> failed
 Adoptions: <N> helpers wired into <M> consumers
 Removals: <N> unused helpers deleted
-False positives: <N> (codegraph resolution bugs)
+False positives: <N> (codegraph resolution bugs → logged to issues.ndjson)
 Intentionally private: <N>
 
 ### Adoptions:
@@ -381,7 +538,10 @@ Intentionally private: <N>
 ### Failed targets (if any):
 - <target>: <reason>
 
-### False positives (codegraph bugs to investigate):
+### Diff review warnings (if any):
+- <target>: <check> — <message>
+
+### False positives (codegraph bugs — issues filed):
 - <symbol>: <reason> (dynamic import / re-export chain / closure)
 
 ### Next: Phase M — <label>
@@ -406,15 +566,20 @@ Run /titan-close to finalize.
 
 ## Edge Cases
 
-- **Interrupted mid-target:** On re-run, `grind.currentTarget` is set. Check if target has uncommitted changes (`git status`). If dirty → rollback dirty files, then re-process the target. If clean → the commit succeeded but state wasn't updated; check `git log -1` to see if the last commit matches, and update state accordingly.
-- **Interrupted mid-classification (Step 2):** On re-run, `grind-targets.ndjson` has partial entries. Load existing entries, skip already-classified targets, continue from the next unclassified candidate.
+- **Interrupted mid-target:** On re-run, `grind.currentTarget` is set. Check if target has uncommitted changes (`git status`). If dirty → restore graph snapshot, rollback dirty files, then re-process the target. If clean → the commit succeeded but state wasn't updated; check `git log -1` to see if the last commit matches, and update state accordingly.
+- **Interrupted mid-classification (Step 2):** On re-run, validate `grind-targets.ndjson` integrity. Load valid entries, skip already-classified targets, continue from the next unclassified candidate. Corrupt lines are re-classified.
+- **State file corrupt on resume:** G4-style recovery from `.bak` file (Step 0.4).
 - **No dead helpers in a phase:** Skip with note. Some forge phases may have wired everything correctly.
-- **Helper is used via dynamic import:** Classify as false-positive. Note for codegraph bug tracking.
+- **Helper is used via dynamic import:** Classify as false-positive. Log to `issues.ndjson` as a codegraph bug.
 - **Helper is in Rust, consumers are TypeScript (or vice versa):** Cross-language helpers cannot be adopted across the FFI boundary. Classify as intentionally-private if used within their language, or false-positive if the dead flag is from FFI resolution limits.
-- **Gate fails on adoption:** Rollback, record failure, continue. A failed adoption may indicate the helper's semantics don't match the inline pattern exactly.
+- **Gate fails on adoption:** Restore snapshot, rollback, record failure, continue. A failed adoption may indicate the helper's semantics don't match the inline pattern exactly.
 - **Helper was adopted by a previous target in this phase:** Check `codegraph roles --role dead` before applying — if no longer dead, skip.
+- **Helper was adopted on main since forge ran:** Drift detection (Step 0.13) warns about this. Per-target dead check (Step 3.5) catches it.
+- **Merge conflict with main:** Stop with conflicting files listed. User resolves and re-runs.
 - **`--target <name>`:** Run single target only. Useful for retrying entries in `grind.failedTargets`.
-- **`--dry-run`:** Walk through all targets, classify them, persist to `grind-targets.ndjson`, print the adoption plan, but make no code changes or commits.
+- **`--dry-run`:** Walk through all targets, classify them, persist to `grind-targets.ndjson`, print the adoption plan. No code changes, no commits, no graph mutations. Note: dry-run DOES write to `grind-targets.ndjson` (classifications are useful even without code changes).
+- **Context budget exhausted:** If context reaches ~80% capacity mid-phase, write all state to disk (including partially processed targets), print progress, and stop. User re-runs to continue.
+- **Sync plan alignment:** Before modifying a file, check if it's scheduled for a later forge phase in `sync.json`. If so, **WARN**: "File <file> is scheduled for forge phase <N> — grind modifications may conflict." Proceed but log the warning.
 
 ---
 
@@ -423,14 +588,17 @@ Run /titan-close to finalize.
 - **One forge phase per invocation.** Stop after the phase completes. User re-runs for next.
 - **Resumable.** State is written after every target. If interrupted, re-running picks up from `grind.currentTarget` and `grind.processedTargets`. Already-committed adoptions are skipped.
 - **Always use `--json` and `-T`** for codegraph commands.
-- **Use codegraph to understand before editing.** Run `codegraph context`, `codegraph audit --quick`, `codegraph fn-impact`, and `codegraph where` before touching any code. Run `codegraph diff-impact --staged` before committing.
+- **Use codegraph to understand before editing.** Run `codegraph context`, `codegraph audit --quick`, `codegraph fn-impact`, `codegraph where`, and `codegraph query` before touching any code. Run `codegraph diff-impact --staged` before committing.
+- **Diff review before gate.** Every change goes through DR1-DR3 checks. DIFF FAIL = rollback without running gate.
+- **Test before gate.** Run the project's test suite as fast-fail before invoking `/titan-gate`.
 - **Gate before commit.** Every commit must pass `/titan-gate`. No exceptions.
 - **Stage only specific files.** Never `git add .` or `git add -A`.
 - **Never change control flow.** Adoptions must be semantically identical to the code they replace. If the helper does something slightly different from the inline pattern, skip it.
-- **Rollback on failure is gentle** — `git restore --staged` to unstage, `git checkout --` to revert working tree. Never `git reset --hard`.
-- **Persist state after every target.** Write `titan-state.json` after each commit, failure, or classification. The `.ndjson` file is append-only — never rewrite it.
+- **Rollback restores graph snapshot** — `codegraph snapshot restore`, then `git restore --staged` + `git checkout --`, then `codegraph build`. Never `git reset --hard`.
+- **Persist state after every target.** Write `titan-state.json` after each commit, failure, or classification. Back up after every write. The `.ndjson` files are append-only — never rewrite them.
+- **Log false positives to issues.ndjson.** These are codegraph bugs. Close phase compiles them into the report and opens GitHub issues.
 - **Dead-symbol delta is advisory, not blocking.** Some increase from type-level symbols is expected. The gate catches real problems.
-- **Log false positives.** These are codegraph bugs. The report feeds back into improving dead-code detection.
+- **Update top-level currentPhase.** Set to `"grind"` at start. Close phase reads this to know grind ran.
 
 ## Relationship to Other Skills
 
@@ -438,9 +606,12 @@ Run /titan-close to finalize.
 |-------|-------------|
 | `/titan-forge` | Grind runs after forge — processes forge's output |
 | `/titan-gate` | Called per-commit for validation (same as forge) |
-| `/titan-close` | Runs after grind — includes grind metrics in final report |
-| `/titan-sync` | Grind reads sync.json to map commits to phases |
+| `/titan-close` | Runs after grind — reads `grind` state block, `grind-targets.ndjson`, and grind entries in `issues.ndjson` for the final report |
+| `/titan-sync` | Grind reads sync.json to map commits to phases and check alignment |
 | `/titan-recon` | Grind reads titan-state.json produced by recon |
+| `/titan-run` | Orchestrator that dispatches grind as Step 4.5 between forge and close |
+| `/titan-reset` | Cleans grind artifacts (`grind-targets.ndjson`, `titan-grind-baseline` snapshot) |
+| `/titan-gauntlet` | Gauntlet recommendations inform what forge extracted, which is what grind processes |
 
 ## Self-Improvement
 
diff --git a/.claude/skills/titan-reset/SKILL.md b/.claude/skills/titan-reset/SKILL.md
index f6a48d70..81771932 100644
--- a/.claude/skills/titan-reset/SKILL.md
+++ b/.claude/skills/titan-reset/SKILL.md
@@ -27,6 +27,12 @@ This restores the graph database to its pre-GAUNTLET state.
 codegraph snapshot delete titan-baseline 2>/dev/null
 ```
 
+Delete the grind baseline snapshot (if it exists):
+
+```bash
+codegraph snapshot delete titan-grind-baseline 2>/dev/null
+```
+
 Also delete any batch snapshots dynamically:
 
 ```bash
@@ -53,6 +59,8 @@ This removes:
 - `issues.ndjson` — cross-phase issue tracker
 - `close-summary.json` — close phase summary
 - `drift-report.json` — staleness detection across phases
+- `grind-targets.ndjson` — grind phase adoption targets and outcomes
+- `arch-snapshot.json` — pre-forge architectural snapshot
 
 ---
 
@@ -75,6 +83,7 @@ If `$ARGUMENTS` contains `--keep-graph`, skip this step.
 ```
 Titan pipeline reset complete.
   - Baseline snapshot: restored and deleted
+  - Grind snapshot: deleted
   - Batch snapshots: deleted
   - Artifacts: removed (.codegraph/titan/)
   - Graph: rebuilt (clean state)
diff --git a/.claude/skills/titan-run/SKILL.md b/.claude/skills/titan-run/SKILL.md
index 7cce5b2f..781f2561 100644
--- a/.claude/skills/titan-run/SKILL.md
+++ b/.claude/skills/titan-run/SKILL.md
@@ -143,6 +143,7 @@ For each phase BEFORE `startPhase`, run the corresponding V-checks:
 | `gauntlet` | V5 (coverage ≥ 50%), V6 (entry completeness sample), V7 (summary consistency); also run NDJSON integrity check (2c) |
 | `sync` | V8 (sync.json structure), V9 (targets trace to gauntlet), V10 (dependency order) |
 | `forge` | V14 (final state consistency), V15 (gate log consistency); execution block must exist in titan-state.json |
+| `grind` | V14, V15; `execution.completedPhases` must be non-empty in titan-state.json (forge must have run at least one phase) |
 
 If ANY required artifact is **missing** → stop: "Cannot start from `<phase>` — `<artifact>` is missing. Run the full pipeline or start from an earlier phase."
 
diff --git a/src/presentation/batch.ts b/src/presentation/batch.ts
index cfa71425..461bd2e3 100644
--- a/src/presentation/batch.ts
+++ b/src/presentation/batch.ts
@@ -36,6 +36,7 @@ export function batchQuery(
   const { command: defaultCommand = 'where', ...rest } = opts;
   const isMulti =
     targets.length > 0 &&
+    targets[0] !== null &&
     typeof targets[0] === 'object' &&
     !!(targets[0] as MultiBatchTarget).command;