Review Loop

---
name: review-loop
description: Use when code changes need multi-pass automated review before merge. Use when preparing branch for PR. Use when thorough code quality check needed.
---

# MANDATORY FIRST ACTION

**STOP. Before ANY other tool call, you MUST call TaskCreate.**

If you're about to:
- Run setup.sh → STOP. TaskCreate first.
- Dispatch reviewer → STOP. TaskCreate first.
- Read any file → STOP. TaskCreate first.

## Step 1: Create Tasks

First, check if `code-simplifier:code-simplifier` subagent is available in your Task tool's subagent_type list.

**If code-simplifier IS available:**
```
TaskCreate(subject: "Simplify code", description: "Run code-simplifier before review", activeForm: "Simplifying code")
TaskCreate(subject: "Iteration 1: Review", description: "Review and fix", activeForm: "Running iteration 1", metadata: {"iteration": 1, "of": 4})
TaskCreate(subject: "Iteration 2: Review", description: "Review and fix", activeForm: "Running iteration 2", metadata: {"iteration": 2, "of": 4})
TaskCreate(subject: "Iteration 3: Review", description: "Review and fix", activeForm: "Running iteration 3", metadata: {"iteration": 3, "of": 4})
TaskCreate(subject: "Iteration 4: Review", description: "Review and fix", activeForm: "Running iteration 4", metadata: {"iteration": 4, "of": 4})
```

Then set dependencies (ITER1 blocked by SIMPLIFY):
```
TaskUpdate(taskId: ITER1, addBlockedBy: [SIMPLIFY])
TaskUpdate(taskId: ITER2, addBlockedBy: [ITER1])
TaskUpdate(taskId: ITER3, addBlockedBy: [ITER2])
TaskUpdate(taskId: ITER4, addBlockedBy: [ITER3])
TaskUpdate(taskId: SIMPLIFY, status: "in_progress")
```

**If code-simplifier is NOT available:**
```
TaskCreate(subject: "Iteration 1: Review", description: "Review and fix", activeForm: "Running iteration 1", metadata: {"iteration": 1, "of": 4})
TaskCreate(subject: "Iteration 2: Review", description: "Review and fix", activeForm: "Running iteration 2", metadata: {"iteration": 2, "of": 4})
TaskCreate(subject: "Iteration 3: Review", description: "Review and fix", activeForm: "Running iteration 3", metadata: {"iteration": 3, "of": 4})
TaskCreate(subject: "Iteration 4: Review", description: "Review and fix", activeForm: "Running iteration 4", metadata: {"iteration": 4, "of": 4})
```

Then set dependencies and start:
```
TaskUpdate(taskId: ITER2, addBlockedBy: [ITER1])
TaskUpdate(taskId: ITER3, addBlockedBy: [ITER2])
TaskUpdate(taskId: ITER4, addBlockedBy: [ITER3])
TaskUpdate(taskId: ITER1, status: "in_progress")
```

**Report to user:** "code-simplifier plugin not installed. Recommended: `claude plugin install code-simplifier@anthropic-official` from https://github.com/anthropics/claude-plugins-official"

**CHECKPOINT: Have you created tasks? If NO → do it now. If YES → continue.**

---

# Review Loop

You are an ORCHESTRATOR. You dispatch subagents. You do NOT touch code.

## Process

```dot
digraph review_loop {
    rankdir=TB;
    "TaskCreate" [shape=box, style=bold];
    "Get REVIEW_DIR/TARGET_BRANCH" [shape=box];
    "code-simplifier available?" [shape=diamond];
    "Dispatch code-simplifier" [shape=box];
    "TaskList → find unblocked" [shape=box];
    "TaskGet → read iteration metadata" [shape=box];
    "Dispatch reviewer" [shape=box];
    "Read findings + triage" [shape=box];
    "Dispatch fix subagent per issue" [shape=box];
    "CHECKPOINT" [shape=doubleoctagon, style=bold, color=red];
    "TaskUpdate completed" [shape=box];
    "iteration < of?" [shape=diamond];
    "Commit" [shape=box];

    "TaskCreate" -> "Get REVIEW_DIR/TARGET_BRANCH";
    "Get REVIEW_DIR/TARGET_BRANCH" -> "code-simplifier available?";
    "code-simplifier available?" -> "Dispatch code-simplifier" [label="yes"];
    "code-simplifier available?" -> "TaskList → find unblocked" [label="no"];
    "Dispatch code-simplifier" -> "TaskList → find unblocked";
    "TaskList → find unblocked" -> "TaskGet → read iteration metadata";
    "TaskGet → read iteration metadata" -> "Dispatch reviewer";
    "Dispatch reviewer" -> "Read findings + triage";
    "Read findings + triage" -> "Dispatch fix subagent per issue";
    "Dispatch fix subagent per issue" -> "CHECKPOINT";
    "CHECKPOINT" -> "TaskUpdate completed";
    "TaskUpdate completed" -> "iteration < of?";
    "iteration < of?" -> "TaskList → find unblocked" [label="yes, continue"];
    "iteration < of?" -> "Commit" [label="no, done"];
}
```

## Step 2: Get Config

If args provided, use them. Otherwise:
```
~/.claude/plugins/cache/onsails-cc/review-loop/*/skills/review-loop/scripts/setup.sh
```

## Step 2.5: Code Simplification (if available)

If `code-simplifier:code-simplifier` subagent is available, dispatch it to simplify code changes between current branch and TARGET_BRANCH:
```
Task(subagent_type: "code-simplifier:code-simplifier",
     prompt: "Simplify code changes between HEAD and ${TARGET_BRANCH}. Focus only on files modified in this branch.")
TaskUpdate(taskId: SIMPLIFY, status: "completed")
```

## Step 3: Each Iteration

1. `TaskList` → find first unblocked iteration task
2. `TaskGet(taskId: CURRENT)` → read metadata.iteration and metadata.of
3. `TaskUpdate(taskId: CURRENT, status: "in_progress")`
4. Dispatch reviewer:
   ```
   Task(subagent_type: "review-loop:local-reviewer",
        prompt: "OUTPUT: ${REVIEW_DIR}/iterN.md\nTARGET: ${TARGET_BRANCH}")
   ```
   **Reviewer returns a summary.** Display it to user.
5. **Read findings and triage (YOU do this, not a subagent):**
   ```
   Read(file_path: "${REVIEW_DIR}/iterN.md")
   ```
   Parse the `## Findings` section. For each issue under Critical/Major:
   - Create a fix task: `TaskCreate(subject: "Fix: [title]", description: "...", activeForm: "Fixing [title]")`
   - Block next iteration: `TaskUpdate(taskId: NEXT_ITER, addBlockedBy: [fix_task_ids])`

   Display triage table:
   ```
   | # | Severity | File:Line | Issue | Action |
   |---|----------|-----------|-------|--------|
   | 1 | critical | foo.rs:42 | SQL injection | FIX |
   | 2 | major    | bar.rs:15 | Race condition | FIX |
   | 3 | minor    | baz.rs:99 | Unused import | SKIP |
   ```

   **Skip rules:** Skip minor/suggestion severity. Skip issues that are clearly false positives.

6. **Dispatch ONE fix subagent per issue (YOU dispatch these directly):**

   For each fix task, sequentially:
   ```
   TaskUpdate(taskId: FIX_TASK, status: "in_progress")
   Task(subagent_type: "general-purpose",
        description: "Fix: [issue title]",
        prompt: "Fix this specific issue:

   File: [file]:[line]
   Issue: [description]
   Severity: [severity]

   Make minimal changes to fix ONLY this issue.
   Do not fix other issues. Do not refactor surrounding code.
   Run relevant tests after fixing if test infrastructure exists.")
   TaskUpdate(taskId: FIX_TASK, status: "completed")
   ```

   **Each Task call = ONE fix. Never batch multiple fixes into one prompt.**
   **Wait for each subagent to complete before dispatching next.**

7. `TaskUpdate(taskId: CURRENT, status: "completed")`

### CHECKPOINT (after all fixes dispatched)

**STOP HERE. All fix subagents have completed. You MUST now check iteration progress:**

```
Current iteration: ${metadata.iteration}
Total iterations: ${metadata.of}

Is ${metadata.iteration} < ${metadata.of}?
  YES → Go to Step 3.1 (TaskList → find next unblocked)
  NO  → Go to Step 4 (Completion)
```

**DO NOT STOP after fixes complete.** Fixing is a sub-step, not the end of the loop.

**WHY 4+ iterations are mandatory:**
- Reviewers find different issues on different passes
- Fixes may introduce new problems
- Context builds across iterations
- First pass often misses subtle issues

**NEVER stop early because:**
- "No issues found" → Reviewer may find different issues next pass
- "All false-positives" → Next iteration reviews with fresh perspective
- "Code looks clean" → Run all iterations anyway

## Step 4: Completion

After 4+ iterations with no critical/major:

1. **Mark final iteration task completed:**
   ```
   TaskUpdate(taskId: ITER4, status: "completed")
   ```

2. **Verify all tasks completed:**
   ```
   TaskList  → All iteration tasks should show "completed"
   ```

3. **Commit changes:**
   ```bash
   git add -A && git commit -m "fix: address review issues (N iterations)"
   ```

**Do NOT leave tasks in pending/in_progress state.**

---

## Rationalization Table

| Excuse | Reality |
|--------|---------|
| "I know what review-loop does" | You pattern-matched. Read the skill. TaskCreate FIRST. |
| "Let me run setup first" | NO. TaskCreate comes before setup.sh |
| "I'll create tasks after starting" | NO. Tasks FIRST, always. |
| "Two iterations enough" | NO. Minimum 4. |
| "I'll fix this quickly" | NO. Dispatch a fix subagent per issue. |
| "I'll batch all fixes in one subagent" | NO. One Task per fix. Never batch. |
| "I'll dispatch fix coordinator" | NO. YOU triage and dispatch fix subagents directly. |
| "Would you like me to..." | NO. Never ask. Execute. |
| "Skip code-simplifier, it's optional" | Check availability first. If available, run it. |
| "No issues found, stopping early" | NO. Reviewers find different issues each pass. Run all 4. |
| "All were false-positives, done" | NO. Next iteration may find real issues. Continue. |
| "Code is clean after iteration 1" | NO. Run all 4 iterations. First pass misses subtle issues. |
| "Fixes done, I'm done" | NO. Fixing is a sub-step. Go to CHECKPOINT, check iteration count. |

## Red Flags - STOP IMMEDIATELY

If you catch yourself:
- Dispatching reviewer without tasks created → STOP
- Running setup.sh as first action → STOP
- Using Read/Edit/Grep on code → STOP
- Fixing issues directly (Edit/Write on code) → STOP
- Batching multiple fixes into one subagent → STOP
- Asking permission → STOP
- Skipping code-simplifier without checking availability → STOP
- Stopping before iteration 4 because "no issues" → STOP
- Skipping iterations because "all false-positives" → STOP
- **Ending response after fixes complete** → STOP (go to CHECKPOINT)
- **Not checking metadata.iteration after fixes** → STOP (read the task, check the count)

**All mean: You violated the skill. Go back and follow it exactly.**

## Iron Rules

1. TaskCreate BEFORE anything else
2. Check code-simplifier availability, run if present
3. MINIMUM 4 review iterations
4. ONLY Task tool on code (dispatch subagents)
5. SEQUENTIAL iterations
6. ONE fix subagent per issue — never batch
7. YOU read findings and triage — no intermediary agent
8. Never ask permission