@atlashub/smartstack-cli 1.35.0 → 1.37.0

package/templates/skills/ralph-loop/steps/step-04-check.md

@@ -1,6 +1,6 @@
 ---
 name: step-04-check
-description: Check completion criteria and decide next action
+description: Check completion criteria with status-based logic
 next_step: steps/step-05-report.md OR steps/step-01-task.md
 ---
 
@@ -8,7 +8,7 @@ next_step: steps/step-05-report.md OR steps/step-01-task.md
 
 ## YOUR TASK:
 
-Check if all tasks are complete and decide whether to output completion promise or continue to next task.
+Check if all tasks are complete and decide whether to output completion promise or continue to next task. Uses v2 status-based checks instead of boolean `passes`.
 
 ---
 
@@ -20,50 +20,74 @@ Check if all tasks are complete and decide whether to output completion promise
 
 ```javascript
 const prd = readJSON('.ralph/prd.json');
-const tasksCompleted = prd.tasks.filter(t => t.passes).length;
-const tasksTotal = prd.tasks.length;
-const allComplete = tasksCompleted === tasksTotal;
+
+const tasksCompleted = prd.tasks.filter(t => t.status === 'completed').length;
+const tasksSkipped   = prd.tasks.filter(t => t.status === 'skipped').length;
+const tasksFailed    = prd.tasks.filter(t => t.status === 'failed').length;
+const tasksBlocked   = prd.tasks.filter(t => t.status === 'blocked').length;
+const tasksPending   = prd.tasks.filter(t => t.status === 'pending').length;
+const tasksTotal     = prd.tasks.length;
+
+const allDone      = (tasksCompleted + tasksSkipped) === tasksTotal;
+const hasFailures  = tasksFailed > 0;
+const hasBlocked   = tasksBlocked > 0;
+const hasPending   = tasksPending > 0;
 ```
 
 ### 2. Check Iteration Limit
 
-**If {current_iteration} >= {max_iterations}:**
+**If `prd.config.current_iteration` > `prd.config.max_iterations`:**
 
 ```
 ╔══════════════════════════════════════════════════════════════════╗
-║  ⚠️ MAX ITERATIONS REACHED                                        ║
+║  ⚠️ MAX ITERATIONS REACHED                                     ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Iterations: {current_iteration} / {max_iterations}               ║
-║  Tasks: {tasksCompleted} / {tasksTotal} complete                  ║
+║  Iterations: {current_iteration} / {max_iterations}             ║
+║  Tasks: {tasksCompleted} / {tasksTotal} complete                ║
+║  Failed: {tasksFailed}  |  Blocked: {tasksBlocked}             ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Ralph loop stopped due to iteration limit.                       ║
-║  Remaining tasks:                                                  ║
-║  {list of tasks with passes: false}                               ║
+║  Ralph loop stopped due to iteration limit.                     ║
+║  Remaining tasks:                                                ║
+║  {list of tasks with status != completed and != skipped}        ║
 ╚══════════════════════════════════════════════════════════════════╝
 
 -> Generating partial report...
 ```
 
+**Update prd.json:**
+```javascript
+prd.status = 'partial';
+prd.updated_at = new Date().toISOString();
+writeJSON('.ralph/prd.json', prd);
+```
+
 **Proceed to step-05-report.md**
 
 ### 3. Check All Tasks Complete
 
-**If allComplete = true:**
+**If allDone = true:**
 
 ```
 ╔══════════════════════════════════════════════════════════════════╗
-║  ✅ ALL TASKS COMPLETE                                            ║
+║  ✅ ALL TASKS COMPLETE                                          ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Iterations: {current_iteration}                                  ║
-║  Tasks: {tasksTotal} / {tasksTotal} complete                      ║
+║  Iterations: {current_iteration - 1}                            ║
+║  Tasks: {tasksCompleted} completed, {tasksSkipped} skipped      ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Output completion promise:                                        ║
-║  <promise>{completion_promise}</promise>                          ║
+║  Output completion promise:                                      ║
+║  <promise>{completion_promise}</promise>                         ║
 ╚══════════════════════════════════════════════════════════════════╝
 
 <promise>{completion_promise}</promise>
 ```
 
+**Update prd.json:**
+```javascript
+prd.status = 'completed';
+prd.updated_at = new Date().toISOString();
+writeJSON('.ralph/prd.json', prd);
+```
+
 **CRITICAL: Output the promise tag exactly as shown:**
 ```
 <promise>{completion_promise}</promise>
@@ -71,15 +95,48 @@ const allComplete = tasksCompleted === tasksTotal;
 
 **Proceed to step-05-report.md**
 
-### 4. More Tasks Remaining
+### 4. Check for Dead-End (all remaining are blocked/failed)
+
+**If !hasPending AND !allDone:**
+
+All remaining tasks are blocked or failed. No progress is possible.
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  ⚠️ DEAD-END DETECTED                                          ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Tasks: {tasksCompleted} completed, {tasksFailed} failed,       ║
+║         {tasksBlocked} blocked                                   ║
+╠══════════════════════════════════════════════════════════════════╣
+║  No more tasks can be executed.                                  ║
+║  Failed tasks:                                                   ║
+║  {list of failed tasks with error messages}                     ║
+║                                                                  ║
+║  Blocked tasks (downstream):                                     ║
+║  {list of blocked tasks with dependency info}                   ║
+╚══════════════════════════════════════════════════════════════════╝
+
+-> Generating partial report...
+```
+
+**Update prd.json:**
+```javascript
+prd.status = 'failed';
+prd.updated_at = new Date().toISOString();
+writeJSON('.ralph/prd.json', prd);
+```
+
+**Proceed to step-05-report.md**
+
+### 5. More Tasks Remaining
 
-**If allComplete = false AND iteration < max_iterations:**
+**If hasPending AND iteration < max_iterations:**
 
 ```
 Progress: {tasksCompleted} / {tasksTotal} tasks
+Failed: {tasksFailed}  |  Blocked: {tasksBlocked}  |  Pending: {tasksPending}
 
-Next task:
-[{next_task_id}] {next_task_description}
+Next eligible task will be determined by dependency resolution.
 
 Continuing to next iteration...
 ```
@@ -95,20 +152,25 @@ Continuing to next iteration...
                     │  Check Completion   │
                     └──────────┬──────────┘
                                │
-              ┌────────────────┼────────────────┐
-              │                │                │
-              ▼                ▼                ▼
-      ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
-      │ Max Iters    │ │ All Tasks    │ │ Tasks        │
-      │ Reached      │ │ Complete     │ │ Remaining    │
-      └──────┬───────┘ └──────┬───────┘ └──────┬───────┘
-             │                │                │
-             ▼                ▼                ▼
-      ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
-      │ Partial      │ │ Output       │ │ Loop to      │
-      │ Report       │ │ Promise      │ │ step-01      │
-      │ step-05      │ │ step-05      │ │              │
-      └──────────────┘ └──────────────┘ └──────────────┘
+          ┌────────────────────┼────────────────────┐
+          │                    │                    │
+          ▼                    ▼                    ▼
+   ┌──────────────┐   ┌──────────────┐   ┌──────────────┐
+   │ Max Iters    │   │ All Tasks    │   │ Tasks        │
+   │ Reached      │   │ Done         │   │ Remaining    │
+   └──────┬───────┘   └──────┬───────┘   └──────┬───────┘
+          │                  │                   │
+          │                  │          ┌────────┴────────┐
+          │                  │          │                 │
+          ▼                  ▼          ▼                 ▼
+   ┌──────────────┐   ┌──────────────┐ ┌─────────────┐ ┌─────────────┐
+   │ Partial      │   │ Output       │ │ Dead-End    │ │ Loop to     │
+   │ Report       │   │ Promise      │ │ (all blocked│ │ step-01     │
+   │ step-05      │   │ step-05      │ │ or failed)  │ │             │
+   │ status:      │   │ status:      │ │ step-05     │ │             │
+   │ "partial"    │   │ "completed"  │ │ status:     │ │             │
+   └──────────────┘   └──────────────┘ │ "failed"    │ └─────────────┘
+                                       └─────────────┘
 ```
 
 ---
@@ -122,9 +184,11 @@ Completion Check:
 | Field | Value |
 |-------|-------|
 | Iteration | {current_iteration} / {max_iterations} |
-| Tasks | {tasksCompleted} / {tasksTotal} |
+| Completed | {tasksCompleted} / {tasksTotal} |
+| Failed | {tasksFailed} |
+| Blocked | {tasksBlocked} |
+| Pending | {tasksPending} |
 | Status | Continuing |
-| Next | [{next_task_id}] {next_task_description} |
 
 -> Loading next task...
 ```
@@ -135,8 +199,9 @@ Completion Check:
 
 | Field | Value |
 |-------|-------|
-| Iteration | {current_iteration} |
-| Tasks | {tasksTotal} / {tasksTotal} |
+| Iterations Used | {current_iteration - 1} |
+| Completed | {tasksCompleted} / {tasksTotal} |
+| Skipped | {tasksSkipped} |
 | Status | COMPLETE |
 
 <promise>{completion_promise}</promise>
@@ -144,19 +209,38 @@ Completion Check:
 -> Generating report...
 ```
 
+**If partial/failed:**
+```
+Completion Check:
+
+| Field | Value |
+|-------|-------|
+| Iterations Used | {current_iteration - 1} |
+| Completed | {tasksCompleted} / {tasksTotal} |
+| Failed | {tasksFailed} |
+| Blocked | {tasksBlocked} |
+| Status | {PARTIAL or FAILED} |
+| Reason | {max iterations / dead-end} |
+
+-> Generating report...
+```
+
 ---
 
-## CRITICAL RULE:
+## CRITICAL RULES:
 
 **NEVER output the completion promise unless:**
-1. ALL tasks have `passes: true`
-2. The statement is genuinely true
+1. ALL tasks have `status: "completed"` or `status: "skipped"`
+2. Zero tasks with `status: "blocked"` or `status: "failed"`
+3. The statement is genuinely true
 
 **False promises to escape the loop are FORBIDDEN.**
 
+**Always update `prd.status` and `prd.updated_at` before proceeding.**
+
 ---
 
 ## NEXT STEP:
 
-- If complete or max iterations: `./step-05-report.md`
+- If complete or max iterations or dead-end: `./step-05-report.md`
 - If tasks remaining: `./step-01-task.md`

package/templates/skills/ralph-loop/steps/step-05-report.md

@@ -1,6 +1,6 @@
 ---
 name: step-05-report
-description: Generate final feature report
+description: Generate final report from prd.json v2 structured data
 next_step: null
 ---
 
@@ -8,57 +8,79 @@ next_step: null
 
 ## YOUR TASK:
 
-Generate a comprehensive feature report documenting what was accomplished.
+Generate a comprehensive feature report using structured data from prd.json v2 (history, task metadata, file tracking).
 
 ---
 
 ## EXECUTION SEQUENCE:
 
-### 1. Gather Statistics
+### 1. Load Structured Data from prd.json
 
-**Collect data from prd.json and progress.txt:**
+**Read all data from the single source of truth:**
 
 ```javascript
 const prd = readJSON('.ralph/prd.json');
+
 const stats = {
   feature: prd.feature,
+  status: prd.status,
+  schema: prd.$version,
   started: prd.created,
   completed: new Date().toISOString(),
-  iterations: prd.current_iteration,
-  maxIterations: prd.max_iterations,
-  tasksCompleted: prd.tasks.filter(t => t.passes).length,
-  tasksTotal: prd.tasks.length,
-  status: allComplete ? "COMPLETE" : "PARTIAL"
+  iterations_used: prd.config.current_iteration - 1,
+  max_iterations: prd.config.max_iterations,
+  tasks: {
+    total: prd.tasks.length,
+    completed: prd.tasks.filter(t => t.status === 'completed').length,
+    failed: prd.tasks.filter(t => t.status === 'failed').length,
+    blocked: prd.tasks.filter(t => t.status === 'blocked').length,
+    skipped: prd.tasks.filter(t => t.status === 'skipped').length,
+    pending: prd.tasks.filter(t => t.status === 'pending').length
+  },
+  source: prd.source ? prd.source.type : 'direct',
+  branch: prd.metadata.branch
 };
+
+// Aggregate files from all tasks
+const allFilesCreated = [];
+const allFilesModified = [];
+for (const task of prd.tasks) {
+  if (task.files_changed) {
+    allFilesCreated.push(...task.files_changed.created);
+    allFilesModified.push(...task.files_changed.modified);
+  }
+}
+
+// Deduplicate
+const filesCreated = [...new Set(allFilesCreated)];
+const filesModified = [...new Set(allFilesModified)];
+
+// Calculate total duration from history
+const totalDuration = prd.history.reduce((sum, h) => sum + (h.duration_seconds || 0), 0);
 ```
 
-### 2. Collect File Changes
+### 2. Collect MCP Usage (from logs if available)
 
-**Get files from git log:**
+**Parse from verbose logs:**
 
 ```bash
-git log --name-status --pretty=format:"%H" HEAD~{iterations}..HEAD
+# Count MCP calls from log files
+MCP_CALLS=$(grep -c "\[MCP\]" .ralph/logs/*.log 2>/dev/null || echo "0")
+SMARTSTACK_CALLS=$(grep -c "mcp__smartstack" .ralph/logs/*.log 2>/dev/null || echo "0")
+CONTEXT7_CALLS=$(grep -c "mcp__context7" .ralph/logs/*.log 2>/dev/null || echo "0")
 ```
 
-**Categorize:**
-- Files created (A)
-- Files modified (M)
-- Files deleted (D)
-
-### 3. Collect MCP Usage
-
-**From verbose logs (if available):**
+**Or extract from task validations:**
 
 ```javascript
-const mcpStats = {
-  validate_conventions: X,
-  check_migrations: Y,
-  scaffold_extension: Z,
-  context7_queries: W
+const validationStats = {
+  passed: prd.tasks.filter(t => t.validation === 'passed').length,
+  failed: prd.tasks.filter(t => t.validation && t.validation.startsWith('failed')).length,
+  skipped: prd.tasks.filter(t => t.validation === null).length
 };
 ```
 
-### 4. Generate Report File
+### 3. Generate Report File
 
 **Write to `.ralph/reports/{feature-slug}.md`:**
 
@@ -66,87 +88,148 @@ const mcpStats = {
 # Feature Report: {feature}
 
 ## Summary
-- **Started**: {started}
-- **Completed**: {completed}
-- **Duration**: {iterations} iterations
-- **Status**: {status}
-
-## Task Progress
-
-| # | Task | Status |
-|---|------|--------|
-| 1 | {task_1_description} | ✅ |
-| 2 | {task_2_description} | ✅ |
-| 3 | {task_3_description} | ❌ (if incomplete) |
-
-## MCP Usage Statistics
-
-| Tool | Calls | Success | Failures |
-|------|-------|---------|----------|
-| validate_conventions | X | X | 0 |
-| check_migrations | Y | Y | 0 |
-| scaffold_extension | Z | Z | 0 |
-| context7 query-docs | W | W | 0 |
-
-## Files Created
 
-```
-{list of created files}
-```
+| Field | Value |
+|-------|-------|
+| **Status** | {status} |
+| **Started** | {started} |
+| **Completed** | {completed} |
+| **Iterations** | {iterations_used} / {max_iterations} |
+| **Branch** | {branch} |
+| **Source** | {source} |
+| **Schema** | {schema} |
 
-## Files Modified
+## Task Progress
 
-```
-{list of modified files}
-```
+| # | Task | Category | Status | Iteration | Duration | Commit |
+|---|------|----------|--------|-----------|----------|--------|
+{for each task in prd.tasks:}
+| {id} | {description} | {category} | {status_emoji} | {iteration || '-'} | {duration}s | {commit_hash || '-'} |
+{end for}
+
+**Summary: {completed}/{total} completed, {failed} failed, {blocked} blocked, {skipped} skipped**
+
+{status_emoji mapping: completed=✅, failed=❌, blocked=🚫, skipped=⏭️, pending=⏳}
+
+## Failed Tasks
+
+{if any failed tasks:}
+| # | Task | Error |
+|---|------|-------|
+{for each failed task:}
+| {id} | {description} | {error} |
+{end for}
+{else:}
+No failed tasks.
+{end if}
+
+## Blocked Tasks
+
+{if any blocked tasks:}
+| # | Task | Blocked By | Error |
+|---|------|------------|-------|
+{for each blocked task:}
+| {id} | {description} | Tasks {dependencies} | {error} |
+{end for}
+{else:}
+No blocked tasks.
+{end if}
+
+## Iteration History
+
+{for each entry in prd.history:}
+### Iteration {iteration} — Task [{task_id}]
+- **Action**: {action}
+- **Timestamp**: {timestamp}
+- **Commit**: {commit_hash}
+- **Duration**: {duration_seconds}s
+- **Notes**: {notes}
+
+{end for}
+
+## MCP Validation Results
+
+| Task | Category | Validation |
+|------|----------|------------|
+{for each task:}
+| [{id}] {description} | {category} | {validation || 'N/A'} |
+{end for}
+
+## Files Created ({filesCreated.length})
+
+{if filesCreated.length > 0:}
+{for each file:}
+- `{file}`
+{end for}
+{else:}
+- (none)
+{end if}
+
+## Files Modified ({filesModified.length})
+
+{if filesModified.length > 0:}
+{for each file:}
+- `{file}`
+{end for}
+{else:}
+- (none)
+{end if}
 
 ## Git Commits
 
-```
-{commit_hash_1} feat(ralph): {message_1}
-{commit_hash_2} feat(ralph): {message_2}
-```
+{for each unique commit_hash in tasks:}
+`{commit_hash}` {commit message from task description}
+{end for}
 
-## Validations Performed
+## Metadata
 
-- [x] SmartStack conventions validated
-- [x] EF Core migrations checked (if applicable)
-- [x] No conflicts detected
-- [x] Build passes
-- [x] Tests pass (if applicable)
+| Field | Value |
+|-------|-------|
+| CLI Version | {prd.metadata.cli_version} |
+| Branch | {prd.metadata.branch} |
+| Project | {prd.metadata.project_path} |
+| MCP SmartStack | {prd.metadata.mcp_servers.smartstack ? '✅' : '❌'} |
+| MCP Context7 | {prd.metadata.mcp_servers.context7 ? '✅' : '❌'} |
+| Total Duration | {totalDuration}s ({Math.round(totalDuration/60)} min) |
 
-## Key Learnings
+---
+*Auto-generated by Ralph Loop v2 — SmartStack CLI*
+```
 
-{Extracted from progress.txt - key insights from each iteration}
+### 4. Finalize prd.json
 
-## Notes
+**Set final status (if not already set by step-04):**
 
-{Any additional observations about the implementation}
+```javascript
+prd.updated_at = new Date().toISOString();
+writeJSON('.ralph/prd.json', prd);
 ```
 
 ### 5. Display Final Summary
 
 ```
 ╔══════════════════════════════════════════════════════════════════╗
-║                    RALPH LOOP COMPLETE                            ║
+║                    RALPH LOOP COMPLETE                           ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Feature: {feature}                                               ║
-║  Status:  {status}                                                ║
-║  Iterations: {iterations}                                         ║
-║  Tasks: {tasksCompleted} / {tasksTotal}                          ║
+║  Feature:    {feature}                                           ║
+║  Status:     {status}                                            ║
+║  Iterations: {iterations_used}                                   ║
+║  Tasks:      {completed}/{total} completed                       ║
+║              {failed} failed, {blocked} blocked                  ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Files Created:  {created_count}                                  ║
-║  Files Modified: {modified_count}                                 ║
-║  Commits:        {commit_count}                                   ║
+║  Files Created:  {filesCreated.length}                           ║
+║  Files Modified: {filesModified.length}                          ║
+║  Commits:        {unique_commits.length}                         ║
+║  Duration:       {totalDuration}s ({minutes} min)                ║
 ╠══════════════════════════════════════════════════════════════════╣
-║  Report saved to:                                                 ║
-║  .ralph/reports/{feature-slug}.md                                 ║
+║  Report saved to:                                                ║
+║  .ralph/reports/{feature-slug}.md                                ║
 ╚══════════════════════════════════════════════════════════════════╝
 ```
 
 ### 6. Output Completion (if applicable)
 
-**If all tasks complete and not already output:**
+**If prd.status === 'completed' and not already output:**
 
 ```
 <promise>{completion_promise}</promise>
@@ -154,7 +237,7 @@ const mcpStats = {
 
 ---
 
-## CLEANUP OPTIONS:
+## CLEANUP SUGGESTIONS:
 
 **Suggest to user:**
 
@@ -162,19 +245,23 @@ const mcpStats = {
 Next steps:
 1. Review report: .ralph/reports/{feature-slug}.md
 2. Run full test suite: dotnet test
-3. Create PR: /gitflow:7-pull-request
-4. Clean up Ralph files: rm -rf .ralph/
+3. Create PR: /gitflow pr
+4. Clean up Ralph files: rm -rf .ralph/ (optional)
 ```
 
 ---
 
 ## SUCCESS CRITERIA:
 
-- Report generated in `.ralph/reports/`
-- All statistics accurate
-- File lists complete
-- Learnings documented
+- Report generated in `.ralph/reports/` with ALL structured data from prd.json
+- Task progress table with categories, status, iterations, and commits
+- Failed/blocked tasks documented with error messages
+- Iteration history from `history[]` included
+- File lists from task-level tracking (not git log)
+- Metadata section with execution context
+- Duration calculated from history entries
 - Final summary displayed
+- prd.json `status` and `updated_at` finalized
 
 ## COMPLETION: