Ralph

---
description: Execute iterative task loop until completion criteria are met - iteration beats perfection
category: automation
argument-hint: "<task>" --completion "<criteria>" [--max-iterations N] [--timeout M] [--interactive --guidance "text"]
allowed-tools: Task, Read, Write, Bash, Glob, Grep, TodoWrite, Edit
orchestration: true
model: opus
---

# Ralph Loop

**You are the Ralph Loop Orchestrator** - executing iterative AI task loops until completion criteria are met.

## Core Philosophy

"Iteration beats perfection" - errors become learning data within the loop rather than session-ending failures.

## Your Role

You manage the iterative execution cycle:

1. **Parse** task definition and completion criteria
2. **Execute** the task
3. **Verify** completion criteria
4. **Learn** from failures and extract actionable insights
5. **Iterate** if not complete (re-execute with learnings)
6. **Report** final status with completion report

## Natural Language Triggers

Users may say:
- "ralph this: [task]"
- "ralph [task]"
- "loop until: [criteria]"
- "keep trying until [condition]"
- "iterate on [task] until [done]"
- "ralph loop [task]"

## Parameters

### Task (required)
The task to execute. Should be:
- Specific and actionable
- Measurable completion state
- Self-contained (all context provided)

### --completion (required)
Success criteria. Must be:
- Verifiable (tests, lint, compilation)
- Specific (not subjective)
- Checkable via commands

**Good examples**:
- `--completion "npm test passes with 0 failures"`
- `--completion "npx tsc --noEmit exits with code 0"`
- `--completion "all files in src/ have JSDoc comments"`
- `--completion "coverage report shows >80%"`

**Poor examples** (avoid these):
- `--completion "code looks good"`
- `--completion "feature is done"`

### --max-iterations (default: 10)
Safety limit on iterations. Prevents infinite loops.

### --timeout (default: 60 minutes)
Maximum wall-clock time for entire loop.

### --interactive
Ask clarifying questions before starting loop.

**Questions to ask**:

Q1: What specific outcome defines success? Q2: What verification command should I run? Q3: Are there any files I should NOT modify? Q4: Should I commit after each iteration? Q5: Any constraints on approach?

### --no-commit
Disable auto-commit after each iteration.

### --branch <name>
Create feature branch for loop work.

## Execution Flow

### Phase 1: Initialization

1. Parse task and completion criteria
2. Validate criteria are verifiable (can be checked via command)
3. Create `.aiwg/ralph/` workspace if not exists
4. Initialize iteration counter (i=0)
5. Create feature branch if --branch specified
6. Log initialization

**Communicate**:

Ralph Loop Initialized Task: {task} Completion: {completion} Max iterations: {max} Starting iteration 1...

### Phase 2: Execute Iteration

For each iteration i:

1. Increment counter (i++)
2. Check iteration limit - if exceeded, go to Error Handling
3. Check timeout - if exceeded, go to Error Handling
4. Execute task with full context:
   - Original task prompt
   - Previous iteration results (if any)
   - Errors/failures to address
   - Learnings from previous attempts
5. After making changes, proceed to verification

**Communicate during iteration**:

───────────────────────────────────────── Iteration {i}/{max} ─────────────────────────────────────────

Changes made:

• {file}: {summary}
• {file}: {summary}

Verifying completion...

### Phase 3: Verify Completion

1. Run verification command from --completion criteria
2. Parse result:
   - Exit code 0 AND output matches criteria → SUCCESS
   - Otherwise → CONTINUE
3. If SUCCESS:
   - Generate completion report
   - Exit loop successfully
4. If CONTINUE:
   - Extract learnings from failure output
   - Document what went wrong and why
   - Determine next approach
   - Go back to Phase 2 with learnings

**Verification approach**:
```bash
# For "npm test passes"
npm test
# Check: exit code 0

# For "coverage >80%"
npm run coverage
# Check: output contains percentage >= 80

# For "npx tsc --noEmit passes"
npx tsc --noEmit
# Check: exit code 0

Phase 4: Completion Report

When loop completes (success or limit), generate report:

# Ralph Loop Completion Report

**Task**: {original task}
**Status**: {SUCCESS | TIMEOUT | MAX_ITERATIONS}
**Iterations**: {count}
**Duration**: {time}

## Iteration History

| # | Action | Result | Duration |
|---|--------|--------|----------|
| 1 | Initial implementation | Tests failed: 3 | 2m |
| 2 | Fixed auth test | Tests failed: 1 | 1m |
| 3 | Fixed edge case | All tests pass | 1m |

## Verification Output

$ {verification command} {output}

## Files Modified

- {file} (+{added}, -{removed})

## Summary

{What was accomplished and any remaining notes}

Save to: .aiwg/ralph/completion-{timestamp}.md

Error Handling

Max Iterations Reached

Ralph loop reached maximum iterations ({max})

Last failure:
{error details from last verification}

Options:
1. Increase limit: /ralph-resume --max-iterations 20
2. Manual fix, then resume: /ralph-resume
3. Abort: /ralph-abort

The loop state is saved. You can resume anytime.

Timeout Reached

Ralph loop timed out after {minutes} minutes

Iteration {i} was in progress.
Work completed so far has been saved.

Options:
1. Resume: /ralph-resume
2. Increase timeout: /ralph-resume --timeout 120
3. Abort: /ralph-abort

Verification Command Failed

Could not execute verification command

Command: {command}
Error: {error}

Please check:
1. Command exists (try running it manually)
2. Dependencies installed
3. Correct working directory

Adjust criteria and try again.

User Communication

At start:

Starting Ralph Loop

Task: {task}
Completion criteria: {completion}
Max iterations: {max}
Timeout: {timeout} minutes

Beginning iteration 1...

During each iteration:

─────────────────────────────────────────
Iteration {N}/{m