feat: /titan-run orchestrator with diff review, semantic assertions, arch snapshots

.claude/skills/titan-forge/SKILL.md

@@ -18,7 +18,6 @@ Your goal: read `sync.json`, find the next incomplete execution phase, make the
 - `--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
 
 ---
 
@@ -135,26 +134,78 @@ For each target in the current phase:
 
 7. **Apply the change** based on phase strategy (Step 1) + gauntlet recommendation.
 
-8. **Run tests:**
+8. **Stage changed files:**
    ```bash
-   npm test 2>&1
+   git add <specific changed files>
    ```
-   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).
+9. **Diff review (intent verification):**
+   Before running gate or tests, verify the diff matches the intent. This catches cases where the code change is structurally valid but doesn't match what was planned.
 
-10. **On success:**
+   Collect the context:
+   ```bash
+   git diff --cached --stat
+   git diff --cached
+   ```
+
+   Load the gauntlet entry for this target (from `gauntlet.ndjson`) and the sync plan entry (from `sync.json → executionOrder[currentPhase]`).
+
+   **Check all of the following:**
+
+   **D1. Scope — only planned files touched:**
+   Compare staged file paths against `sync.json → executionOrder[currentPhase].targets` and their known file paths (from gauntlet entries). Flag any file NOT associated with the current target or phase.
+   - File in a completely different domain → **DIFF FAIL**
+   - File is a direct dependency of the target (consumer or import) → **OK** (expected ripple)
+   - Test file for the target → **OK**
+
+   **D2. Intent match — diff aligns with gauntlet recommendation:**
+   Read the gauntlet entry's `recommendation` field and `violations` list. Verify the diff addresses them:
+   - If recommendation says "split" → diff should show new functions extracted, original simplified
+   - If recommendation says "remove dead code" → diff should show deletions, not additions
+   - If violation was "complexity > threshold" → diff should reduce complexity, not just move code around
+   - If the diff does something **entirely different** from the recommendation → **DIFF FAIL**
+
+   **D3. Commit message accuracy:**
+   Compare the planned commit message from `sync.json` against what the diff actually does.
+   - Message says "remove dead code" but diff adds new functions → **DIFF WARN**
+   - Message says "extract X from Y" but diff only modifies Y without creating X → **DIFF FAIL**
+
+   **D4. Deletion audit:**
+   If the diff deletes code (lines removed > 10):
+   ```bash
+   codegraph fn-impact <deleted-symbol> -T --json 2>/dev/null
+   ```
+   If the deleted symbol has active callers not updated in this diff → **DIFF FAIL**: "Deleted <symbol> still has <N> callers not updated in this commit."
+
+   **D5. Leftover check:**
+   If the gauntlet recommendation mentioned specific symbols to remove/refactor, verify they were actually addressed:
+   - Dead symbols listed for removal → should be deleted in the diff
+   - Functions marked for decomposition → original should be simplified or removed
+
+   **On DIFF FAIL:** Unstage and revert changes, add to `execution.failedTargets` with reason starting with `"diff-review: "`. Continue to next target.
+   **On DIFF WARN:** Log the warning but proceed to gate. Include the warning in the gate-log entry.
+
+10. **Run tests** (detect the project's test command from package.json scripts — `npm test`, `yarn test`, `pnpm test`, etc.):
+    ```bash
+    <detected-test-command> 2>&1
+    ```
+    If tests fail → go to rollback (step 13).
+
+11. **Run /titan-gate:**
+    Use the Skill tool to invoke `titan-gate`. If FAIL → go to rollback (step 13).
+
+12. **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`
+    - Record any diff-review warnings in `execution.diffWarnings` (if any)
     - Update `titan-state.json`
 
-11. **On failure (test or gate):**
+13. **On failure (test, gate, or diff-review):**
     ```bash
+    git reset HEAD <changed files>
     git checkout -- <changed files>
     ```
     - Add to `execution.failedTargets` with reason: `{ "target": "<name>", "reason": "<why>", "phase": N }`