@atlashub/smartstack-cli 3.7.0 → 3.9.0

package/templates/skills/ralph-loop/SKILL.md

@@ -2,447 +2,165 @@
 name: ralph-loop
 description: Iterative AI development loop with MCP validation, progress tracking, and completion promises.
 argument-hint: "[-m N] [-c TEXT] [-v] <task description>"
-disable-model-invocation: true
 ---
 
 <objective>
-Execute the Ralph Weegund technique - an iterative development methodology where the same prompt is fed repeatedly until completion. Uses progressive step loading with MCP validation and progress persistence.
+Execute the Ralph Weegund technique — iterative development where the same prompt is fed repeatedly until completion. Uses progressive step loading with MCP validation, progress persistence, and Agent Teams for multi-module parallelization.
 </objective>
 
 <quick_start>
-**Three ways to start Ralph Loop:**
-
-1. **From Business Analysis (RECOMMENDED):**
-   ```bash
-   /business-analyse MyFeature
-   # At the end, BA offers to launch ralph-loop automatically
-   # If PRD files are missing, ralph-loop auto-recovers via ss derive-prd
-   ```
-
-2. **Manual start with existing prd.json:**
-   ```bash
-   /ralph-loop
-   # Ralph detects .ralph/prd.json and resumes automatically
-   # Works after BA handoff or previous Ralph session
-   ```
-
-3. **Direct task (no BA):**
-   ```bash
-   /ralph-loop implement user authentication
-   # Ralph creates prd.json on the fly
-   ```
-
-**With options:**
 
+**From Business Analysis (RECOMMENDED):**
 ```bash
-# Completion promise
-/ralph-loop -c "COMPLETE" refactor the cache layer
-
-# Max iterations
-/ralph-loop -m 20 -c "TESTS PASS" add comprehensive tests
-
-# Verbose mode
-/ralph-loop -v -c "DONE" fix all linting errors
+/business-analyse MyFeature
+# Then: /ralph-loop -r
 ```
 
-**Flags:**
+**Manual start:**
+```bash
+/ralph-loop implement user authentication
+/ralph-loop -c "COMPLETE" -m 20 refactor cache layer
+/ralph-loop -r  # Resume previous
+```
 
-- `-m N` (max): Maximum iterations before auto-stop
-- `-c TEXT` (complete): Completion promise text
-- `-v` (verbose): Detailed logging
-- `-r` (resume): Resume from previous state
+**Flags:** `-m N` (max iterations), `-c TEXT` (completion promise), `-v` (verbose), `-r` (resume)
 
-See `<parameters>` for complete flag list.
 </quick_start>
 
 <parameters>
-
-<flags>
-**Flags:**
 | Short | Long | Description |
 |-------|------|-------------|
-| `-m N` | `--max-iterations N` | Maximum iterations (default: 50) |
-| `-c TEXT` | `--completion-promise TEXT` | Text that signals completion |
-| `-v` | `--verbose` | Enable detailed logging |
+| `-m N` | `--max-iterations N` | Max iterations (default: 50) |
+| `-c TEXT` | `--completion-promise TEXT` | Completion signal text |
+| `-v` | `--verbose` | Detailed logging |
 | `-r` | `--resume` | Resume from previous state |
-</flags>
-
-<examples>
-```bash
-# Basic loop
-/ralph-loop implement feature X
-
-# With completion signal
-/ralph-loop -c "ALL TESTS PASS" fix failing tests
-
-# Limited iterations with completion
-/ralph-loop -m 10 -c "REFACTOR COMPLETE" clean up auth module
-
-# Resume previous loop
-/ralph-loop -r
-
-# Verbose mode
-/ralph-loop -v -m 25 -c "DONE" implement CRUD for products
-```
-</examples>
-
-<parsing_rules>
-**Argument parsing:**
-
-1. `-m N` or `--max-iterations N` -> `{max_iterations}` = N
-2. `-c TEXT` or `--completion-promise TEXT` -> `{completion_promise}` = TEXT
-3. `-v` or `--verbose` -> `{verbose_mode}` = true
-4. `-r` or `--resume` -> `{resume_mode}` = true
-5. Remainder -> `{task_description}`
-</parsing_rules>
-
 </parameters>
 
-<ralph_concept>
-**Core concept:**
-
-The same prompt is fed to Claude repeatedly. The "self-referential" aspect comes from Claude seeing its own previous work in files and git history.
-
-**Each iteration:**
-1. Claude receives the SAME prompt
-2. Works on the task, modifying files
-3. Checks completion criteria
-4. If not complete: saves progress, iteration count increments
-5. Claude sees previous work in the files
-6. Iteratively improves until completion promise is output
-
-**Iterative Development Cycle (per task):**
-```
-┌─────────────────────────────────────────────────────────────┐
-│                   RALPH LOOP - CYCLE                        │
-├─────────────────────────────────────────────────────────────┤
-│                                                             │
-│  1. ANALYSE      → Load next task from prd.json            │
-│                    (UC, FR, BR, wireframes, acceptance)     │
-│                                                             │
-│  2. DÉVELOPPEMENT → Generate code for task                  │
-│     ├─ Backend:   Entity, Service, Repository, Controller  │
-│     ├─ Tests:     Unit tests (xUnit) + non-regression      │
-│     ├─ Frontend:  Page, Component, Hook (match wireframe)  │
-│     ├─ Tests:     Frontend tests (React Testing Library)   │
-│     ├─ SeedData:  CORE RBAC (5 entries) + business data    │
-│     └─ Docs:      Inline comments + tooltips + i18n keys   │
-│                                                             │
-│  3. VALIDATION   → Commit changes + MCP conventions check   │
-│                    (validate_conventions, check_migrations) │
-│                                                             │
-│  4. TEST         → Run tests (dotnet test + npm test)       │
-│                    ├─ Unit tests                            │
-│                    ├─ Integration tests                     │
-│                    ├─ Security tests (tenant isolation)     │
-│                    └─ E2E tests (critical flows)            │
-│                                                             │
-│  5. CORRECTION   → If tests fail:                           │
-│                    ├─ Analyze error logs                    │
-│                    ├─ Fix root cause                        │
-│                    ├─ Commit fix                            │
-│                    └─ Return to step 4                      │
-│                                                             │
-│  6. NEXT TASK    → Mark task as completed, loop to step 1   │
-│                                                             │
-│  🎯 Goal: 100% tests pass before moving to next task        │
-│  📊 Coverage: 95-100% (tests auto-generated)                │
-│                                                             │
-└─────────────────────────────────────────────────────────────┘
-```
-
-**Completion signal:**
-```
-<promise>{completion_promise}</promise>
-```
-
-The loop only stops when this exact tag is output or max iterations reached.
-
-**What Ralph generates per task:**
-- **Backend code**: Entities (Domain), Services (Application), Repositories (Infrastructure), Controllers (API)
-- **Unit tests**: xUnit tests for domain logic, services, repositories
-- **Integration tests**: Controller tests with WebApplicationFactory
-- **Frontend code**: React pages, components, custom hooks (matching BA wireframes)
-- **Frontend tests**: React Testing Library for components and pages
-- **SeedData**: 5 CORE entries (Navigation, Permissions, Roles, Tenants, Users) + business reference data
-- **Documentation**: Inline code comments, user-facing tooltips, i18n translation keys
-- **Security tests**: Tenant isolation, permission checks, OWASP validations
-
-**prd.json structure (input from BA):**
-The prd.json is generated by `/business-analyse` via `ss derive-prd` command. It contains:
-- **feature**: Feature description (from BA)
-- **tasks[]**: Task breakdown by category (domain, application, infrastructure, api, frontend, i18n, test, validation)
-  - Each task has: id, description, category, dependencies, acceptance_criteria, linkedFRs, linkedUCs, linkedBRs
-  - Frontend tasks include: linkedWireframes (screen IDs from BA mockups), wireframeAcceptanceCriteria
-  - SeedData tasks specify: category (core|business), source (specification.seedDataCore or seedDataBusiness)
-- **source**: Traceability to feature.json path (source of truth)
-- **metadata**: Project context (branch, namespace, module order)
-- **config**: max_iterations, completion_promise, current_iteration
-
-Ralph reads prd.json to know WHAT to generate, then generates it, tests it, fixes it, and moves to the next task.
-</ralph_concept>
-
 <workflow>
-**Standard flow (single module):**
-1. Parse flags and task description (step-00)
-2. Verify MCP servers are available (step-00, MANDATORY)
-3. Initialize .ralph/ structure and state files (step-00)
-4. Load current task from prd.json — create task breakdown if new (step-01, READ ONCE)
-5. Execute first task (step-02, READ ONCE)
-6. Commit changes, update progress (step-03, READ ONCE)
-7. Check completion → enter COMPACT LOOP (step-04)
-8. **COMPACT LOOP** (step-04 section 5, NO re-reading step files):
-   - Find eligible tasks → batch by category (max 5)
-   - Execute batch inline (generate code)
-   - Run tests (dotnet test + npm test)
-   - If tests fail: analyze → fix → re-test (loop until 100% pass)
-   - Commit batch (only when tests pass)
-   - Re-check completion → loop or finish
-9. When complete: generate final report (step-05)
-
-**Multi-module flow (from BA handoff - NEW v6.1: automatic launch):**
-1-3. Same as standard flow (or launched automatically from `/business-analyse`)
-4. Detect `prd-*.json` files → create `modules-queue.json`
-5. Copy current module's prd to `prd.json`
-6. Execute all tasks for current module via COMPACT LOOP:
-   - Process tasks by category (domain → seeddata → application → infrastructure → api → frontend → i18n → tests)
-   - For each task: generate → test → fix (if needed) → re-test → commit (when pass)
-   - Each task generates: backend code + tests + frontend code + tests + seeddata + docs
-   - Each frontend task respects wireframes from BA (specification.uiWireframes[])
-   - Continue until ALL tasks of module = completed
-7. When module complete: advance to next module in queue (step-04 section 3)
-8. Repeat steps 5-7 for each module (step-01 is re-read ONLY for module transitions)
-9. When all modules done: generate cross-module report
 
-**Note:** When launched from `/business-analyse` (v6.1+), Ralph Loop receives:
-- `.ralph/prd-{module}.json` for each module (generated by `ss derive-prd`)
-  - Each prd contains: tasks breakdown with UC/FR/BR/wireframes/acceptance criteria
-  - Task categories: domain, application, infrastructure, api, frontend, i18n, test, validation
-  - Each task linked to: functional requirements (FR), use cases (UC), business rules (BR)
-  - Frontend tasks include: linkedWireframes[] (screen IDs from BA mockups)
-  - SeedData tasks specify: category (core 5 entries MANDATORY + business data)
-- `.ralph/progress.txt` with comprehensive task tracker (hierarchical: module → layer → tasks)
-- Module order from BA's topological dependency graph (dependencies first)
-- No arguments needed - fully configured by BA handoff
+**Single module:**
+1. Init: parse flags, verify MCP, setup .ralph/ (step-00)
+2. Load tasks from prd.json — unified v3 has pre-computed tasks (step-01, READ ONCE)
+3. Execute first task (step-02, READ ONCE)
+4. Commit + update progress (step-03, READ ONCE)
+5. Check completion → enter COMPACT LOOP (step-04)
+6. **COMPACT LOOP** (step-04 → references/compact-loop.md):
+   - Find eligible → batch by category (max 5) → execute → test → commit → loop
+7. Report (step-05)
+
+**Multi-module (2+ modules, from BA handoff):**
+1. Init: detect prd-*.json, read dependency layers (step-00)
+2. **IF dependency graph available:** Agent Teams (parallel)
+   ```
+   Team Lead → TeamCreate("ralph-{app}")
+     Layer 0: Spawn "mod-employees" (foundation) → wait LAYER_READY
+     Layer 1: Spawn "mod-timetracking" + "mod-leavemanagement" (parallel)
+     Layer 2: Spawn "mod-reporting"
+     → Cross-module verify → Report → TeamDelete
+   ```
+3. **IF no dependency graph:** Sequential (compact loop per module)
+4. Report with per-module aggregation (step-05)
 
-**Task execution cycle (per task):**
+**Task execution cycle:**
 ```
-LOAD TASK → GENERATE CODE → COMMIT → RUN TESTS → [FAIL?] → ANALYZE ERROR → FIX → RE-TEST → [PASS!] → NEXT TASK
-                                                    ↑___________________________________________|
-                                                         (loop until 100% tests pass)
+LOAD → GENERATE → COMPILE → TEST → [FAIL?] → FIX → RE-TEST → [PASS!] → COMMIT → NEXT
+                                       ↑___________________________|
 ```
 
-**What gets generated per module:**
-1. **Domain layer**: Entities, Value Objects, Enums, Domain Exceptions
-2. **SeedData layer**: 5 CORE entries (Navigation, Permissions, Roles, Tenants, Users) + business reference data
-3. **Application layer**: Services, DTOs, Validators, Query Handlers
-4. **Infrastructure layer**: Repositories, DbContext, Specifications
-5. **API layer**: Controllers, Error Handlers, Validation Responses
-6. **Frontend layer**: Pages (matching wireframes), Components, Custom Hooks, Forms
-7. **I18n layer**: Translation keys (fr, en, it, de) for UI labels
-8. **Tests layer**: Unit tests (Domain, Application), Integration tests (API), Security tests (tenant isolation), E2E tests (critical flows)
-
-**Acceptance criteria per task:**
-- Code compiles (dotnet build + npm build)
-- Tests pass (dotnet test + npm test)
-- MCP conventions validated (validate_conventions)
-- Wireframes respected (frontend pages match BA mockups from specification.uiWireframes[])
-- Business rules implemented (BR-to-code mapping from BA)
-- Security enforced (tenant isolation, RBAC permissions)
 </workflow>
 
 <state_variables>
-**Persist throughout all steps:**
-
 | Variable | Type | Description |
 |----------|------|-------------|
-| `{task_description}` | string | The prompt/task to execute |
-| `{max_iterations}` | number | Maximum iterations allowed |
-| `{completion_promise}` | string | Text that signals completion |
-| `{verbose_mode}` | boolean | Enable detailed logging |
-| `{resume_mode}` | boolean | Resume from previous state |
-| `{current_iteration}` | number | Current iteration count |
-| `{tasks_completed}` | number | Number of tasks completed |
-| `{tasks_total}` | number | Total tasks in prd.json |
-| `{task_status}` | string | Current task status (pending/in_progress/completed/failed/skipped/blocked) |
-| `{task_category}` | string | Task category (domain/application/infrastructure/api/frontend/i18n/test/validation) |
-| `{files_created}` | string[] | Files created during current task |
-| `{files_modified}` | string[] | Files modified during current task |
-| `{current_module}` | string\|null | Current module code (multi-module only) |
-| `{modules_queue}` | object\|null | Module queue state (multi-module only) |
-
+| `{task_description}` | string | The task to execute |
+| `{max_iterations}` | number | Max iterations |
+| `{completion_promise}` | string | Completion signal |
+| `{current_iteration}` | number | Current iteration |
+| `{current_module}` | string\|null | Current module (multi-module) |
+| `{modules_queue}` | object\|null | Module queue (multi-module) |
 </state_variables>
 
 <mcp_requirements>
-**MANDATORY MCP Validation:**
-
-Before ANY work, verify MCP servers:
-
-1. **SmartStack MCP** - `mcp__smartstack__validate_conventions`
-2. **Context7 MCP** - `mcp__plugin_context7_context7__resolve-library-id`
-
-**If ANY MCP unavailable:**
-- DO NOT proceed
-- Log failure to `.ralph/logs/`
-- Output error message
-- Suggest: `smartstack check-mcp`
-
-**Throughout work, use:**
-- `mcp__smartstack__validate_conventions` - Before commits
-- `mcp__smartstack__check_migrations` - Before EF Core changes
-- `mcp__smartstack__scaffold_extension` - For code generation
+**MANDATORY before any work:**
+1. `mcp__smartstack__validate_conventions` — verify connectivity
+2. `mcp__context7__resolve-library-id` — verify connectivity
+
+**During work:**
+- `validate_conventions` — before commits
+- `check_migrations` — before EF Core changes
+- `suggest_migration` — migration naming
+- `generate_permissions` — RBAC seed data
+- `scaffold_api_client` — frontend API client
+- `scaffold_routes` — frontend routing
+- `scaffold_tests` — test generation
 </mcp_requirements>
 
 <entry_point>
-
 **FIRST ACTION:** Load `steps/step-00-init.md`
-
 </entry_point>
 
 <step_files>
-**Progressive loading - only load current step:**
-
-| Step | File | Purpose |
-|------|------|---------|
-| 00 | `steps/step-00-init.md` | Parse args, verify MCP, initialize state |
-| 01 | `steps/step-01-task.md` | Load current task from prd.json |
-| 02 | `steps/step-02-execute.md` | Execute ONE task |
-| 03 | `steps/step-03-commit.md` | Commit, update prd.json/progress.txt |
-| 04 | `steps/step-04-check.md` | Check completion, decide next action |
-| 05 | `steps/step-05-report.md` | Generate final report |
+| Step | File | Purpose | Target Lines |
+|------|------|---------|-------------|
+| 00 | `steps/step-00-init.md` | Parse args, verify MCP, init state, team setup | ~150 |
+| 01 | `steps/step-01-task.md` | Load/create tasks from prd.json | ~365 |
+| 02 | `steps/step-02-execute.md` | Execute ONE task (first iteration) | ~140 |
+| 03 | `steps/step-03-commit.md` | Commit, update prd.json/progress.txt | ~135 |
+| 04 | `steps/step-04-check.md` | Check completion, compact loop entry | ~185 |
+| 05 | `steps/step-05-report.md` | Generate final report | ~150 |
 
 **Reference files (loaded conditionally):**
-
-| Ref | File | Loaded when |
-|-----|------|-------------|
-| - | `references/core-seed-data.md` | Infrastructure task involves seed data or IClientSeedDataProvider |
-
+| File | Loaded when |
+|------|-------------|
+| `references/category-rules.md` | Step-02 and compact loop (execution rules per category) |
+| `references/compact-loop.md` | Step-04 section 5 (inline execution after first iteration) |
+| `references/core-seed-data.md` | Infrastructure task with seed data keywords |
+| `references/team-orchestration.md` | Step-00 when multi-module detected (2+ PRDs) |
 </step_files>
 
 <file_structure>
-**Ralph creates these files:**
-
 ```
 .ralph/
-├── prd.json              # Task list with status (current module or single)
-├── progress.txt          # Persistent memory between iterations
-├── modules-queue.json    # Multi-module tracking (only if multiple prd-*.json exist)
-├── prd-{module1}.json    # Per-module PRD from BA handoff (source, not modified)
-├── prd-{module2}.json    # Per-module PRD from BA handoff (source, not modified)
+├── prd.json              # Active task list (unified v3: reference data + pre-computed tasks)
+├── progress.txt          # Persistent memory
+├── modules-queue.json    # Multi-module tracking (if applicable)
+├── prd-{module}.json     # Per-module PRDs (from ss derive-prd, unified v3 format)
 ├── logs/
-│   └── {timestamp}.log
 └── reports/
-    └── {feature-name}.md
+    └── {feature}.md
 ```
-
-**modules-queue.json structure (multi-module only):**
-```json
-{
-  "modules": [
-    {
-      "code": "module-code",
-      "prdFile": ".ralph/prd-module-code.json",
-      "status": "pending|in-progress|completed|failed|partial"
-    }
-  ],
-  "currentIndex": 0,
-  "totalModules": 3,
-  "completedModules": 0
-}
-```
-
-**prd.json structure:**
-```json
-{
-  "$version": "2.0.0",
-  "feature": "{task_description}",
-  "status": "in_progress",
-  "created": "2026-01-30T15:00:00.000Z",
-  "updated_at": "2026-01-30T16:30:00.000Z",
-  "metadata": {
-    "cli_version": "1.36.0",
-    "branch": "feature/user-auth",
-    "project_path": "/path/to/project",
-    "mcp_servers": { "smartstack": true, "context7": true }
-  },
-  "config": {
-    "max_iterations": 50,
-    "completion_promise": "COMPLETE",
-    "current_iteration": 1
-  },
-  "source": {
-    "type": "ba-handoff",
-    "handoff_path": "path/to/4-development-handoff.md",
-    "feature_json_path": null
-  },
-  "tasks": [
-    {
-      "id": 1,
-      "description": "Create User entity in Domain layer",
-      "status": "pending",
-      "category": "domain",
-      "dependencies": [],
-      "acceptance_criteria": "Entity compiles, properties match handoff spec",
-      "started_at": null,
-      "completed_at": null,
-      "iteration": null,
-      "commit_hash": null,
-      "files_changed": { "created": [], "modified": [] },
-      "validation": null,
-      "error": null
-    }
-  ],
-  "history": []
-}
-```
-
-> **Schema v2 notes:**
-> - `$version`: Schema version for forward migration
-> - `status` (top-level): `pending` | `in_progress` | `completed` | `failed` | `partial`
-> - `source.type`: `ba-handoff` | `direct` | `feature-full` — `null` when tasks are created directly by Ralph Loop
-> - `task.status`: `pending` | `in_progress` | `completed` | `failed` | `skipped` | `blocked`
-> - `task.category`: `domain` | `application` | `infrastructure` | `api` | `frontend` | `i18n` | `test` | `validation` | `other`
-> - `task.dependencies`: Array of task IDs that must be `completed` before this task can start
-> - `history`: Structured iteration journal (replaces unstructured progress.txt for traceability)
 </file_structure>
 
 <execution_rules>
 
-- **NEVER DELEGATE THE LOOP** - The Ralph loop MUST execute in the MAIN agent context. NEVER use the Task tool to spawn a sub-agent for loop execution. Sub-agents lose ALL skill context (step files, COMPACT LOOP logic, MCP requirements, SmartStack conventions) and WILL stop prematurely. This is FORBIDDEN. The only acceptable use of Task is for isolated read-only research (e.g., looking up documentation via Context7).
-- **Load step files ONCE** - Step files are read only on FIRST iteration. After that, use the COMPACT LOOP in step-04 section 5.
-- **VERIFY MCP FIRST** - Never skip MCP validation at init
-- **BATCH same-category tasks** - Execute up to 5 tasks of the same category per iteration (reduces loop iterations from 30+ to ~8)
-- **COMMIT AFTER EACH BATCH** - One commit per batch, not per individual task
-- **UPDATE progress.txt** - Persist learnings
-- **NEVER fake completion** - Only output promise when truly done
-- **NEVER STOP THE LOOP** - The loop is AUTONOMOUS. Stopping is a BUG. Specifically FORBIDDEN:
-  - DO NOT pause between iterations
-  - DO NOT wait for user input
-  - DO NOT output a summary and stop ("I'll continue later")
-  - DO NOT decide to stop because "quality over quantity" or "this is enough for now"
-  - DO NOT stop after completing one module when others remain in the queue
-  - DO NOT reduce scope autonomously ("I'll skip frontend/tests to save time")
-  - The ONLY valid stop reasons: ALL tasks complete, max iterations reached, dead-end (all remaining blocked/failed), or explicit user interruption via Ctrl+C
-- **CONTEXT BUDGET** - Keep ALL output COMPACT during loop iterations. Verbose reasoning wastes context tokens and causes premature termination. Use 1-2 lines per task during the loop. Save detailed output for the final report ONLY. During init, skip verbose MCP output and keep summaries minimal.
-- **MODULE COMPLETENESS** - A module is NOT complete unless ALL expected layers have completed tasks: domain, infrastructure, application, api, frontend, i18n, test. If any layer is missing, inject guardrail tasks before advancing to the next module.
+- **Single module:** Main agent runs compact loop (NEVER delegate to sub-agent)
+- **Multi-module (2+):** Team lead + module workers via TeamCreate (see references/team-orchestration.md)
+- **Load step files ONCE** — after first iteration, use compact-loop.md
+- **VERIFY MCP FIRST** — never skip
+- **BATCH** same-category tasks (max 5 per iteration)
+- **COMMIT** after each batch (not per task)
+- **NEVER fake completion** — only output promise when truly done
+- **NEVER stop the loop** — autonomous until complete, max iterations, or dead-end
+- **CONTEXT BUDGET** — compact output during loop (1-2 lines per task)
+- **MODULE COMPLETENESS** — all layers (domain, infra, app, api, frontend, test) before advancing
+- **MIGRATION MANDATORY** — after EF configs, before tests (no DB = no tests)
+- **TESTS BLOCKING** — 100% pass before proceeding to next task
+
 </execution_rules>
 
 <success_criteria>
-
-- All tasks in prd.json have `status: "completed"` (or `"skipped"`)
-- No tasks with `status: "blocked"` remain
+- All tasks completed (or skipped) in prd.json
 - MCP validations pass
-- Git commits atomic per task with `commit_hash` tracked
-- `history[]` contains entry for every completed task
-- Completion promise output when genuinely complete
-- Final report generated in `.ralph/reports/`
-- `prd.json` top-level `status` set to `"completed"` or `"partial"`
-- **Multi-module:** All modules in `modules-queue.json` processed sequentially
-- **Multi-module:** Cross-module aggregation in final report
+- Git commits atomic with commit_hash tracked
+- Tests pass (dotnet test + npm test)
+- Migrations created and applied
+- Seed data complete (navigation, permissions, roles via MCP)
+- Frontend in correct hierarchy (Context/App/Module)
+- Report generated in .ralph/reports/
+- Multi-module: all modules processed, cross-module report
 </success_criteria>
 
 <available_commands>
-**Related commands:**
-- `/ralph-loop:cancel-ralph` - Cancel active loop
-- `/ralph-loop:help` - Show documentation
+- `/ralph-loop:cancel-ralph` — Cancel active loop
+- `/ralph-loop:help` — Show documentation
 </available_commands>