Name: prp-ralph
Author: fgarofalo56

Prompt file imported from fgarofalo56/Supercharge_Microsoft_Fabric (.github/prompts/prp-ralph.prompt.md). Fill in {{arguments}} before use. Copyright stays with the author.

User Input

{{arguments}}

Purpose

Combine Ralph Wiggum's iterative persistence with PRP Framework's structured plan execution for enhanced implementation reliability.

Integration Concept

┌─────────────────────────────────────────────────────────────────────┐
│                    RALPH + PRP                                      │
│                                                                     │
│    PRD ─────────────────────────────────────────────────────┐       │
│    │                                                         │       │
│    │  Problem Statement → Phases → Success Criteria         │       │
│    │                                                         │       │
│    └─────────────────────────────────────────────────────────┘       │
│                           │                                          │
│                           ▼                                          │
│    PLAN ────────────────────────────────────────────────────┐       │
│    │                                                         │       │
│    │  Tasks → Patterns → Validation → Acceptance            │       │
│    │                                                         │       │
│    └─────────────────────────────────────────────────────────┘       │
│                           │                                          │
│                           ▼                                          │
│    ┌──────────────────────────────────────────────────────────┐     │
│    │  RALPH LOOP                                               │     │
│    │                                                           │     │
│    │  For each task in plan:                                  │     │
│    │    1. Execute task following patterns                    │     │
│    │    2. Run validation commands                            │     │
│    │    3. Mark task complete in plan                         │     │
│    │    4. All tasks done? → COMPLETE                         │     │
│    │    5. Else → Continue iteration                          │     │
│    │                                                           │     │
│    └──────────────────────────────────────────────────────────┘     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Execution Flow

1. Locate Plan

# Get plan path from arguments
PLAN_PATH="{{arguments}}"

# If not provided, check for active plan
if [ -z "$PLAN_PATH" ]; then
    PLAN_PATH=$(ls -t PRPs/plans/*.plan.md | head -1)
fi

# Verify plan exists
cat "$PLAN_PATH"

2. Parse Plan

Extract from plan.md:

Summary and user story
Patterns to mirror
Files to change
Step-by-step tasks
Validation commands
Acceptance criteria

3. Turn the plan into a FORGE task graph

.ralph/config.json is dead. Nothing reads it — there was never a runner behind the Ralph loop, and the archon_project_id / archon_task_id it carried pointed at an MCP server that is not running. The execution state is .forge/tasks.json, and the only things that write it are atlas-forge plan and atlas-forge decompose. scripts/backlog_to_dag.py is not shipped in this repository. Verified command surface: ATLAS FORGE orchestration.

Parse the plan's tasks into a proposals document — either {"tasks": [...]} or a bare list of objects with id, title, estimate, needs, note, where needs carries the plan's phase ordering:

{"tasks": [
  {"id": "p1-t1", "title": "<task from the plan>", "estimate": 80,
   "needs": [], "note": "<acceptance criteria from the plan>"}
]}

Then assemble and gate it:

atlas-forge decompose --from proposals.json --json

decompose is a gate, not a report. If any task exceeds the diff-line budget it exits 1, names each offender and how many pieces it needs, and the oversized plan is not written to disk. Split those tasks in the PRP plan and re-run. Never raise --budget to make it pass.

Verified options: --repo, --from, --budget, --json.

4. Run it

atlas-forge dispatch --dry-run --json    # print the wave plan, run nothing
atlas-forge dispatch --wave 1 --json     # one wave; each task its own worktree + full gates
atlas-forge board --json                 # what settled, what failed, what is blocked

There is no max_iterations and no completion_promise. A task settles when its gates pass on its own branch; a task whose gates are red is red. Bound a run with the verified flags instead: --wave, --parallel, --max-usd, --task-usd, --task-minutes (default 90), --phase. Use --resume on any restart or the spend ceiling resets.

Merge finished branches in dependency order, as a separate step:

atlas-forge integrate --branch <new-branch-name> --json

integrate re-runs the budget over the real git diff --numstat, which is the half of the check that the planner's own estimate cannot talk past.

Before any of this: dispatch branches from HEAD and merges finished branches back, so do not point it at a dirty tree. This checkout holds hundreds of uncommitted files. Triage with the operator first, and never with git checkout --, git restore, git clean, or git stash.

5. Generate Plan-Aware Prompt

# Ralph Loop: PRP Plan Execution

## Plan
**Path**: [PLAN_PATH]
**Feature**: [FEATURE_NAME]

## Summary
[From plan]

## User Story
[From plan]

## Patterns to Mirror
[From plan - actual code patterns with file:line references]

## Tasks to Complete

[Task list from plan with checkboxes]

## Per-Iteration Protocol

### 1. Check Plan Status
Review which tasks are done, find next incomplete task.

### 2. Execute Task
Following PRP methodology:
- ACTION: What to do
- MIRROR: Code patterns to follow
- VALIDATE: Commands to run

### 3. Run Validation
```bash
[VALIDATION_COMMANDS]

4. Update Plan

If task passes:

Mark task checkbox as complete [x]
Add timestamp and notes

5. Completion Check

All plan tasks complete? → PLAN_COMPLETE
Tasks remaining? → Continue to next task

Validation Commands

[From plan]

Acceptance Criteria

[From plan - checkboxes]

Escape Hatch

If stuck on a task for 3 iterations:

Document blocker in plan
Mark task as [BLOCKED]
Move to next task or BLOCKED


### 5. Start Ralph Loop

```bash
& @ralph-loop --config .ralph/config.json

Plan Task Tracking

During Iteration

Ralph tracks progress in the plan file:

## Step-by-Step Tasks

### Task 1: Set up database schema ✅
- ACTION: Create migration file
- MIRROR: `src/db/migrations/001_users.sql:1-30`
- VALIDATE: `npm run migrate`
- **Status**: Complete (Iteration 2)
- **Commit**: abc123

### Task 2: Implement API endpoints ✅
- ACTION: Create CRUD handlers
- MIRROR: `src/api/users.ts:15-45`
- VALIDATE: `npm test -- --grep "API"`
- **Status**: Complete (Iteration 4)
- **Commit**: def456

### Task 3: Add input validation 🔄
- ACTION: Add Zod schemas
- MIRROR: `src/validators/user.ts:1-20`
- VALIDATE: `npm test -- --grep "validation"`
- **Status**: In Progress (Iteration 5)

### Task 4: Write integration tests ⏳
- ACTION: Create test suite
- MIRROR: `tests/integration/users.test.ts`
- VALIDATE: `npm run test:integration`
- **Status**: Pending

Commands

# Start Ralph with specific plan
/prp-ralph PRPs/plans/auth-feature.plan.md

# Auto-detect most recent plan
/prp-ralph

# With options
/prp-ralph --max-iterations 20 --mode background

# Check status
/prp-ralph --status

Report Generation

On completion, Ralph creates an implementation report:

# Implementation Report: [FEATURE_NAME]

## Summary
Successfully implemented [FEATURE] following PRP plan.

## Plan Reference
- Plan: PRPs/plans/auth-feature.plan.md
- PRD: PRPs/prds/auth-feature.prd.md (if exists)

## Execution Stats
| Metric | Value |
|--------|-------|
| Total Iterations | 8 |
| Duration | 45m |
| Tasks Completed | 5/5 |
| Files Changed | 12 |
| Tests Added | 15 |

## Tasks Completed
1. ✅ Set up database schema (Iteration 2)
2. ✅ Implement API endpoints (Iteration 4)
3. ✅ Add input validation (Iteration 6)
4. ✅ Write integration tests (Iteration 7)
5. ✅ Update documentation (Iteration 8)

## Validation Results
- Build: ✅ Pass
- Unit Tests: ✅ 45/45
- Integration: ✅ 12/12
- Lint: ✅ Clean

## Files Changed
| File | Action | Lines |
|------|--------|-------|
| src/api/auth.ts | Created | +120 |
| src/db/migrations/002_auth.sql | Created | +35 |
| tests/auth.test.ts | Created | +200 |
| ... | ... | ... |

## Acceptance Criteria
- [x] User can register with email
- [x] User can log in
- [x] Sessions are managed properly
- [x] Passwords are hashed securely

## Next Steps
- Create PR: `/pr-create`
- Review changes: `git diff main`

---
Generated: [TIMESTAMP]
Ralph Loop: [LOOP_ID]

Output

## 🔄 Ralph + PRP Integration Started

### Plan
- Path: PRPs/plans/auth-feature.plan.md
- Feature: User Authentication
- Tasks: 5

### Task Status
| # | Task | Status |
|---|------|--------|
| 1 | Database schema | ✅ Done |
| 2 | API endpoints | ✅ Done |
| 3 | Input validation | 🔄 Current |
| 4 | Integration tests | ⏳ Pending |
| 5 | Documentation | ⏳ Pending |

### Ralph Configuration
- Max Iterations: 10
- Mode: Background
- Completion: PLAN_COMPLETE

### Monitor
```bash
/ralph-status    # Loop progress
/prp-status      # Plan overview
cat PRPs/plans/auth-feature.plan.md

🚀 Ralph will iterate until all plan tasks are complete.


## Status View

```markdown
## 🔄 Ralph + PRP Status

### Plan Progress
- Feature: User Authentication
- Tasks: 3/5 complete (60%)

### Current Task
**Task 4: Write integration tests**
- Iteration: 7
- Status: In progress
- Pattern: tests/integration/users.test.ts

### Ralph Loop
- Iteration: 7/10
- Duration: 28m
- Mode: Running

### Validation
- Build: ✅ Pass
- Unit Tests: ✅ 45/45
- Integration: ⚠️ 8/12 (4 pending)

### Acceptance Criteria
- [x] User registration works
- [x] Login flow complete
- [~] Session management ◄── In progress
- [ ] Password reset flow

## User Input ```text {{arguments}} ``` ## Purpose Combine Ralph Wiggum's iterative persistence with PRP Framework's structured plan execution for enhanced implementation reliability. ## Integration Concept ``` ┌─────────────────────────────────────────────────────────────────────┐ │ RALPH + PRP │ │ │ │ PRD ─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Problem Statement → Phases → Success Criteria │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────┘ │ │ │ │ │ ▼ │ │ PLAN ────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Tasks → Patterns → Validation → Acceptance │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ RALPH LOOP │ │ │ │ │ │ │ │ For each task in plan: │ │ │ │ 1. Execute task following patterns │ │ │ │ 2. Run validation commands │ │ │ │ 3. Mark task complete in plan │ │ │ │ 4. All tasks done? → COMPLETE │ │ │ │ 5. Else → Continue iteration │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────┘ ``` ## Execution Flow ### 1. Locate Plan ```bash # Get plan path from arguments PLAN_PATH="{{arguments}}" # If not provided, check for active plan if [ -z "$PLAN_PATH" ]; then PLAN_PATH=$(ls -t PRPs/plans/*.plan.md | head -1) fi # Verify plan exists cat "$PLAN_PATH" ``` ### 2. Parse Plan Extract from plan.md: - Summary and user story - Patterns to mirror - Files to change - Step-by-step tasks - Validation commands - Acceptance criteria ### 3. Turn the plan into a FORGE task graph > **`.ralph/config.json` is dead.** Nothing reads it — there was never a runner > behind the Ralph loop, and the `archon_project_id` / `archon_task_id` it > carried pointed at an MCP server that is not running. The execution state is > `.forge/tasks.json`, and the only things that write it are `atlas-forge plan` > and `atlas-forge decompose`. **`scripts/backlog_to_dag.py` is not shipped in > this repository.** Verified command surface: > [ATLAS FORGE orchestration](../FORGE_ORCHESTRATION.md). Parse the plan's tasks into a proposals document — either `{"tasks": [...]}` or a bare list of objects with `id`, `title`, `estimate`, `needs`, `note`, where `needs` carries the plan's phase ordering: ```json {"tasks": [ {"id": "p1-t1", "title": "<task from the plan>", "estimate": 80, "needs": [], "note": "<acceptance criteria from the plan>"} ]} ``` Then assemble and gate it: ```bash atlas-forge decompose --from proposals.json --json ``` `decompose` is a **gate, not a report**. If any task exceeds the diff-line budget it exits 1, names each offender and how many pieces it needs, and the oversized plan is **not** written to disk. Split those tasks in the PRP plan and re-run. Never raise `--budget` to make it pass. Verified options: `--repo`, `--from`, `--budget`, `--json`. ### 4. Run it ```bash atlas-forge dispatch --dry-run --json # print the wave plan, run nothing atlas-forge dispatch --wave 1 --json # one wave; each task its own worktree + full gates atlas-forge board --json # what settled, what failed, what is blocked ``` There is no `max_iterations` and no `completion_promise`. A task settles when its **gates pass on its own branch**; a task whose gates are red is red. Bound a run with the verified flags instead: `--wave`, `--parallel`, `--max-usd`, `--task-usd`, `--task-minutes` (default 90), `--phase`. Use `--resume` on any restart or the spend ceiling resets. Merge finished branches in dependency order, as a separate step: ```bash atlas-forge integrate --branch <new-branch-name> --json ``` `integrate` re-runs the budget over the real `git diff --numstat`, which is the half of the check that the planner's own estimate cannot talk past. Before any of this: `dispatch` branches from `HEAD` and merges finished branches back, so **do not point it at a dirty tree**. This checkout holds hundreds of uncommitted files. Triage with the operator first, and never with `git checkout --`, `git restore`, `git clean`, or `git stash`. ### 5. Generate Plan-Aware Prompt ```markdown # Ralph Loop: PRP Plan Execution ## Plan **Path**: [PLAN_PATH] **Feature**: [FEATURE_NAME] ## Summary [From plan] ## User Story [From plan] ## Patterns to Mirror [From plan - actual code patterns with file:line references] ## Tasks to Complete [Task list from plan with checkboxes] ## Per-Iteration Protocol ### 1. Check Plan Status Review which tasks are done, find next incomplete task. ### 2. Execute Task Following PRP methodology: - ACTION: What to do - MIRROR: Code patterns to follow - VALIDATE: Commands to run ### 3. Run Validation ```bash [VALIDATION_COMMANDS] ``` ### 4. Update Plan If task passes: - Mark task checkbox as complete [x] - Add timestamp and notes ### 5. Completion Check - All plan tasks complete? → <promise>PLAN_COMPLETE</promise> - Tasks remaining? → Continue to next task ## Validation Commands ```bash [From plan] ``` ## Acceptance Criteria [From plan - checkboxes] ## Escape Hatch If stuck on a task for 3 iterations: 1. Document blocker in plan 2. Mark task as [BLOCKED] 3. Move to next task or <promise>BLOCKED</promise> ``` ### 5. Start Ralph Loop ```bash & @ralph-loop --config .ralph/config.json ``` ## Plan Task Tracking ### During Iteration Ralph tracks progress in the plan file: ```markdown ## Step-by-Step Tasks ### Task 1: Set up database schema ✅ - ACTION: Create migration file - MIRROR: `src/db/migrations/001_users.sql:1-30` - VALIDATE: `npm run migrate` - **Status**: Complete (Iteration 2) - **Commit**: abc123 ### Task 2: Implement API endpoints ✅ - ACTION: Create CRUD handlers - MIRROR: `src/api/users.ts:15-45` - VALIDATE: `npm test -- --grep "API"` - **Status**: Complete (Iteration 4) - **Commit**: def456 ### Task 3: Add input validation 🔄 - ACTION: Add Zod schemas - MIRROR: `src/validators/user.ts:1-20` - VALIDATE: `npm test -- --grep "validation"` - **Status**: In Progress (Iteration 5) ### Task 4: Write integration tests ⏳ - ACTION: Create test suite - MIRROR: `tests/integration/users.test.ts` - VALIDATE: `npm run test:integration` - **Status**: Pending ``` ## Commands ```bash # Start Ralph with specific plan /prp-ralph PRPs/plans/auth-feature.plan.md # Auto-detect most recent plan /prp-ralph # With options /prp-ralph --max-iterations 20 --mode background # Check status /prp-ralph --status ``` ## Report Generation On completion, Ralph creates an implementation report: ```markdown # Implementation Report: [FEATURE_NAME] ## Summary Successfully implemented [FEATURE] following PRP plan. ## Plan Reference - Plan: PRPs/plans/auth-feature.plan.md - PRD: PRPs/prds/auth-feature.prd.md (if exists) ## Execution Stats | Metric | Value | |--------|-------| | Total Iterations | 8 | | Duration | 45m | | Tasks Completed | 5/5 | | Files Changed | 12 | | Tests Added | 15 | ## Tasks Completed 1. ✅ Set up database schema (Iteration 2) 2. ✅ Implement API endpoints (Iteration 4) 3. ✅ Add input validation (Iteration 6) 4. ✅ Write integration tests (Iteration 7) 5. ✅ Update documentation (Iteration 8) ## Validation Results - Build: ✅ Pass - Unit Tests: ✅ 45/45 - Integration: ✅ 12/12 - Lint: ✅ Clean ## Files Changed | File | Action | Lines | |------|--------|-------| | src/api/auth.ts | Created | +120 | | src/db/migrations/002_auth.sql | Created | +35 | | tests/auth.test.ts | Created | +200 | | ... | ... | ... | ## Acceptance Criteria - [x] User can register with email - [x] User can log in - [x] Sessions are managed properly - [x] Passwords are hashed securely ## Next Steps - Create PR: `/pr-create` - Review changes: `git diff main` --- Generated: [TIMESTAMP] Ralph Loop: [LOOP_ID] ``` ## Output ```markdown ## 🔄 Ralph + PRP Integration Started ### Plan - Path: PRPs/plans/auth-feature.plan.md - Feature: User Authentication - Tasks: 5 ### Task Status | # | Task | Status | |---|------|--------| | 1 | Database schema | ✅ Done | | 2 | API endpoints | ✅ Done | | 3 | Input validation | 🔄 Current | | 4 | Integration tests | ⏳ Pending | | 5 | Documentation | ⏳ Pending | ### Ralph Configuration - Max Iterations: 10 - Mode: Background - Completion: PLAN_COMPLETE ### Monitor ```bash /ralph-status # Loop progress /prp-status # Plan overview cat PRPs/plans/auth-feature.plan.md ``` --- 🚀 Ralph will iterate until all plan tasks are complete. ``` ## Status View ```markdown ## 🔄 Ralph + PRP Status ### Plan Progress - Feature: User Authentication - Tasks: 3/5 complete (60%) ### Current Task **Task 4: Write integration tests** - Iteration: 7 - Status: In progress - Pattern: tests/integration/users.test.ts ### Ralph Loop - Iteration: 7/10 - Duration: 28m - Mode: Running ### Validation - Build: ✅ Pass - Unit Tests: ✅ 45/45 - Integration: ⚠️ 8/12 (4 pending) ### Acceptance Criteria - [x] User registration works - [x] Login flow complete - [~] Session management ◄── In progress - [ ] Password reset flow ```

{ "prompt": "## User Input\n\n```text\n{{arguments}}\n```\n\n## Purpose\n\nCombine Ralph Wiggum's iterative persistence with PRP Framework's structured plan execution for enhanced implementation reliability.\n\n## Integration Concept\n\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│ RALPH + PRP │\n│ │\n│ PRD ─────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Problem Statement → Phases → Success Criteria │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────┘ │\n│ │ │\n│ ▼ │\n│ PLAN ────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Tasks → Patterns → Validation → Acceptance │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────┘ │\n│ │ │\n│ ▼ │\n│ ┌──────────────────────────────────────────────────────────┐ │\n│ │ RALPH LOOP │ │\n│ │ │ │\n│ │ For each task in plan: │ │\n│ │ 1. Execute task following patterns │ │\n│ │ 2. Run validation commands │ │\n│ │ 3. Mark task complete in plan │ │\n│ │ 4. All tasks done? → COMPLETE │ │\n│ │ 5. Else → Continue iteration │ │\n│ │ │ │\n│ └──────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n## Execution Flow\n\n### 1. Locate Plan\n\n```bash\n# Get plan path from arguments\nPLAN_PATH=\"{{arguments}}\"\n\n# If not provided, check for active plan\nif [ -z \"$PLAN_PATH\" ]; then\n PLAN_PATH=$(ls -t PRPs/plans/*.plan.md | head -1)\nfi\n\n# Verify plan exists\ncat \"$PLAN_PATH\"\n```\n\n### 2. Parse Plan\n\nExtract from plan.md:\n- Summary and user story\n- Patterns to mirror\n- Files to change\n- Step-by-step tasks\n- Validation commands\n- Acceptance criteria\n\n### 3. Turn the plan into a FORGE task graph\n\n> **`.ralph/config.json` is dead.** Nothing reads it — there was never a runner\n> behind the Ralph loop, and the `archon_project_id` / `archon_task_id` it\n> carried pointed at an MCP server that is not running. The execution state is\n> `.forge/tasks.json`, and the only things that write it are `atlas-forge plan`\n> and `atlas-forge decompose`. **`scripts/backlog_to_dag.py` is not shipped in\n> this repository.** Verified command surface:\n> [ATLAS FORGE orchestration](../FORGE_ORCHESTRATION.md).\n\nParse the plan's tasks into a proposals document — either `{\"tasks\": [...]}` or\na bare list of objects with `id`, `title`, `estimate`, `needs`, `note`, where\n`needs` carries the plan's phase ordering:\n\n```json\n{\"tasks\": [\n {\"id\": \"p1-t1\", \"title\": \"<task from the plan>\", \"estimate\": 80,\n \"needs\": [], \"note\": \"<acceptance criteria from the plan>\"}\n]}\n```\n\nThen assemble and gate it:\n\n```bash\natlas-forge decompose --from proposals.json --json\n```\n\n`decompose` is a **gate, not a report**. If any task exceeds the diff-line\nbudget it exits 1, names each offender and how many pieces it needs, and the\noversized plan is **not** written to disk. Split those tasks in the PRP plan and\nre-run. Never raise `--budget` to make it pass.\n\nVerified options: `--repo`, `--from`, `--budget`, `--json`.\n\n### 4. Run it\n\n```bash\natlas-forge dispatch --dry-run --json # print the wave plan, run nothing\natlas-forge dispatch --wave 1 --json # one wave; each task its own worktree + full gates\natlas-forge board --json # what settled, what failed, what is blocked\n```\n\nThere is no `max_iterations` and no `completion_promise`. A task settles when\nits **gates pass on its own branch**; a task whose gates are red is red. Bound a\nrun with the verified flags instead: `--wave`, `--parallel`, `--max-usd`,\n`--task-usd`, `--task-minutes` (default 90), `--phase`. Use `--resume` on any\nrestart or the spend ceiling resets.\n\nMerge finished branches in dependency order, as a separate step:\n\n```bash\natlas-forge integrate --branch <new-branch-name> --json\n```\n\n`integrate` re-runs the budget over the real `git diff --numstat`, which is the\nhalf of the check that the planner's own estimate cannot talk past.\n\nBefore any of this: `dispatch` branches from `HEAD` and merges finished branches\nback, so **do not point it at a dirty tree**. This checkout holds hundreds of\nuncommitted files. Triage with the operator first, and never with\n`git checkout --`, `git restore`, `git clean`, or `git stash`.\n\n### 5. Generate Plan-Aware Prompt\n\n```markdown\n# Ralph Loop: PRP Plan Execution\n\n## Plan\n**Path**: [PLAN_PATH]\n**Feature**: [FEATURE_NAME]\n\n## Summary\n[From plan]\n\n## User Story\n[From plan]\n\n## Patterns to Mirror\n[From plan - actual code patterns with file:line references]\n\n## Tasks to Complete\n\n[Task list from plan with checkboxes]\n\n## Per-Iteration Protocol\n\n### 1. Check Plan Status\nReview which tasks are done, find next incomplete task.\n\n### 2. Execute Task\nFollowing PRP methodology:\n- ACTION: What to do\n- MIRROR: Code patterns to follow\n- VALIDATE: Commands to run\n\n### 3. Run Validation\n```bash\n[VALIDATION_COMMANDS]\n```\n\n### 4. Update Plan\nIf task passes:\n- Mark task checkbox as complete [x]\n- Add timestamp and notes\n\n### 5. Completion Check\n- All plan tasks complete? → <promise>PLAN_COMPLETE</promise>\n- Tasks remaining? → Continue to next task\n\n## Validation Commands\n```bash\n[From plan]\n```\n\n## Acceptance Criteria\n[From plan - checkboxes]\n\n## Escape Hatch\nIf stuck on a task for 3 iterations:\n1. Document blocker in plan\n2. Mark task as [BLOCKED]\n3. Move to next task or <promise>BLOCKED</promise>\n```\n\n### 5. Start Ralph Loop\n\n```bash\n& @ralph-loop --config .ralph/config.json\n```\n\n## Plan Task Tracking\n\n### During Iteration\n\nRalph tracks progress in the plan file:\n\n```markdown\n## Step-by-Step Tasks\n\n### Task 1: Set up database schema ✅\n- ACTION: Create migration file\n- MIRROR: `src/db/migrations/001_users.sql:1-30`\n- VALIDATE: `npm run migrate`\n- **Status**: Complete (Iteration 2)\n- **Commit**: abc123\n\n### Task 2: Implement API endpoints ✅\n- ACTION: Create CRUD handlers\n- MIRROR: `src/api/users.ts:15-45`\n- VALIDATE: `npm test -- --grep \"API\"`\n- **Status**: Complete (Iteration 4)\n- **Commit**: def456\n\n### Task 3: Add input validation 🔄\n- ACTION: Add Zod schemas\n- MIRROR: `src/validators/user.ts:1-20`\n- VALIDATE: `npm test -- --grep \"validation\"`\n- **Status**: In Progress (Iteration 5)\n\n### Task 4: Write integration tests ⏳\n- ACTION: Create test suite\n- MIRROR: `tests/integration/users.test.ts`\n- VALIDATE: `npm run test:integration`\n- **Status**: Pending\n```\n\n## Commands\n\n```bash\n# Start Ralph with specific plan\n/prp-ralph PRPs/plans/auth-feature.plan.md\n\n# Auto-detect most recent plan\n/prp-ralph\n\n# With options\n/prp-ralph --max-iterations 20 --mode background\n\n# Check status\n/prp-ralph --status\n```\n\n## Report Generation\n\nOn completion, Ralph creates an implementation report:\n\n```markdown\n# Implementation Report: [FEATURE_NAME]\n\n## Summary\nSuccessfully implemented [FEATURE] following PRP plan.\n\n## Plan Reference\n- Plan: PRPs/plans/auth-feature.plan.md\n- PRD: PRPs/prds/auth-feature.prd.md (if exists)\n\n## Execution Stats\n| Metric | Value |\n|--------|-------|\n| Total Iterations | 8 |\n| Duration | 45m |\n| Tasks Completed | 5/5 |\n| Files Changed | 12 |\n| Tests Added | 15 |\n\n## Tasks Completed\n1. ✅ Set up database schema (Iteration 2)\n2. ✅ Implement API endpoints (Iteration 4)\n3. ✅ Add input validation (Iteration 6)\n4. ✅ Write integration tests (Iteration 7)\n5. ✅ Update documentation (Iteration 8)\n\n## Validation Results\n- Build: ✅ Pass\n- Unit Tests: ✅ 45/45\n- Integration: ✅ 12/12\n- Lint: ✅ Clean\n\n## Files Changed\n| File | Action | Lines |\n|------|--------|-------|\n| src/api/auth.ts | Created | +120 |\n| src/db/migrations/002_auth.sql | Created | +35 |\n| tests/auth.test.ts | Created | +200 |\n| ... | ... | ... |\n\n## Acceptance Criteria\n- [x] User can register with email\n- [x] User can log in\n- [x] Sessions are managed properly\n- [x] Passwords are hashed securely\n\n## Next Steps\n- Create PR: `/pr-create`\n- Review changes: `git diff main`\n\n---\nGenerated: [TIMESTAMP]\nRalph Loop: [LOOP_ID]\n```\n\n## Output\n\n```markdown\n## 🔄 Ralph + PRP Integration Started\n\n### Plan\n- Path: PRPs/plans/auth-feature.plan.md\n- Feature: User Authentication\n- Tasks: 5\n\n### Task Status\n| # | Task | Status |\n|---|------|--------|\n| 1 | Database schema | ✅ Done |\n| 2 | API endpoints | ✅ Done |\n| 3 | Input validation | 🔄 Current |\n| 4 | Integration tests | ⏳ Pending |\n| 5 | Documentation | ⏳ Pending |\n\n### Ralph Configuration\n- Max Iterations: 10\n- Mode: Background\n- Completion: PLAN_COMPLETE\n\n### Monitor\n```bash\n/ralph-status # Loop progress\n/prp-status # Plan overview\ncat PRPs/plans/auth-feature.plan.md\n```\n\n---\n🚀 Ralph will iterate until all plan tasks are complete.\n```\n\n## Status View\n\n```markdown\n## 🔄 Ralph + PRP Status\n\n### Plan Progress\n- Feature: User Authentication\n- Tasks: 3/5 complete (60%)\n\n### Current Task\n**Task 4: Write integration tests**\n- Iteration: 7\n- Status: In progress\n- Pattern: tests/integration/users.test.ts\n\n### Ralph Loop\n- Iteration: 7/10\n- Duration: 28m\n- Mode: Running\n\n### Validation\n- Build: ✅ Pass\n- Unit Tests: ✅ 45/45\n- Integration: ⚠️ 8/12 (4 pending)\n\n### Acceptance Criteria\n- [x] User registration works\n- [x] Login flow complete\n- [~] Session management ◄── In progress\n- [ ] Password reset flow\n```", "variables": [ "arguments" ], "notes": "Turn a PRP plan into an atlas-forge task graph and run it wave by wave. Mode: agent. Tools: filesystem, terminal.", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/fgarofalo56/Supercharge_Microsoft_Fabric", "path": ".github/prompts/prp-ralph.prompt.md", "ref": "25b3c1ca0296274f8a779b35454ebc89f7012672", "url": "https://github.com/fgarofalo56/Supercharge_Microsoft_Fabric/blob/25b3c1ca0296274f8a779b35454ebc89f7012672/.github/prompts/prp-ralph.prompt.md", "key": "fgarofalo56/Supercharge_Microsoft_Fabric/.github/prompts/prp-ralph.prompt.md" } } }

prp-ralph

About