@atlashub/smartstack-cli 3.1.0 → 3.3.0

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

@@ -181,13 +181,25 @@ if (hasQueue) {
     queue.modules[nextIndex].status = 'in-progress';
     writeJSON(queuePath, queue);
 
+    // ✅ FIX #1: Create module transition marker
+    // This signals to step-01 that it MUST reload even on iteration > 1
+    writeJSON('.ralph/module-changed.json', {
+      fromModule: currentModule.code,
+      toModule: queue.modules[nextIndex].code,
+      timestamp: new Date().toISOString()
+    });
+
     // Mark current prd.json as completed
     prd.status = 'completed';
     prd.updated_at = new Date().toISOString();
     writeJSON('.ralph/prd.json', prd);
 
-    // Reset iteration counter for next module
-    // (preserve max_iterations from config)
+    // ✅ FIX #2: Load next module's PRD NOW and reset iteration counter
+    const nextModulePrd = readJSON(queue.modules[nextIndex].prdFile);
+    nextModulePrd.config.current_iteration = 1;
+    nextModulePrd.config.max_iterations = prd.config.max_iterations; // Preserve
+    nextModulePrd.updated_at = new Date().toISOString();
+    writeJSON('.ralph/prd.json', nextModulePrd);
 
     console.log(`
 ╔══════════════════════════════════════════════════════════════════╗
@@ -197,10 +209,13 @@ if (hasQueue) {
 ║  Modules: ${queue.completedModules} / ${queue.totalModules}     ║
 ╠══════════════════════════════════════════════════════════════════╣
 ║  ADVANCING TO NEXT MODULE: ${queue.modules[nextIndex].code}     ║
+║  Next module PRD loaded: ${queue.modules[nextIndex].prdFile}    ║
+║  Iteration counter reset: 1                                      ║
 ╚══════════════════════════════════════════════════════════════════╝
     `);
 
-    // Loop back to step-01 which will load next module's prd
+    // Loop back to step-01 which will detect module-changed.json
+    // and skip the "Only Read Once" rule for this transition
     // -> Proceed to step-01-task.md
     return;
   }
@@ -347,8 +362,60 @@ Batch: {tasksToExecute.length} task(s) [{firstCategory}]
 1. Mark `task.status = 'in_progress'`, `task.started_at = now`
 2. ULTRA THINK: implement the task following SmartStack conventions
    - Track files_created and files_modified per task
-3. Verify acceptance criteria
-4. If failed: set `task.status = 'failed'`, `task.error = reason`, continue to next task in batch
+3. **MANDATORY TEST-DRIVEN CYCLE (per task):**
+   ```
+   ┌─────────────────────────────────────────────────────────┐
+   │  TASK EXECUTION CYCLE (100% tests pass required)       │
+   ├─────────────────────────────────────────────────────────┤
+   │                                                         │
+   │  1. GENERATE CODE                                       │
+   │     ├─ Backend:  Entity, Service, Repository, Controller│
+   │     ├─ Frontend: Page, Component, Hook                 │
+   │     ├─ Tests:    Unit tests + Integration tests        │
+   │     └─ Docs:     Inline comments + tooltips + i18n     │
+   │                                                         │
+   │  2. COMPILE CODE                                        │
+   │     ├─ Backend:  dotnet build --no-restore             │
+   │     └─ Frontend: npm run typecheck                     │
+   │                                                         │
+   │  3. RUN TESTS (MANDATORY)                               │
+   │     ├─ Backend:  dotnet test {TestProject}             │
+   │     ├─ Frontend: npm test (if applicable)              │
+   │     └─ Security: tenant isolation + RBAC checks        │
+   │                                                         │
+   │  4. CHECK RESULT                                        │
+   │     ├─ IF 100% PASS → Mark task completed, next task   │
+   │     └─ IF ANY FAIL  → Go to step 5                     │
+   │                                                         │
+   │  5. FIX ERRORS (loop until pass)                        │
+   │     ├─ Parse test output → identify failing tests      │
+   │     ├─ Analyze root cause (stack trace, logs)          │
+   │     ├─ Fix code (NOT test - fix implementation)        │
+   │     ├─ Re-compile (step 2)                             │
+   │     └─ Re-run tests (step 3) → loop until 100% pass    │
+   │                                                         │
+   │  🎯 Goal: ZERO test failures before next task           │
+   │  📊 Coverage: 95-100% (tests auto-generated per task)   │
+   │                                                         │
+   └─────────────────────────────────────────────────────────┘
+   ```
+
+   **Implementation per task:**
+   a. Generate code + tests
+   b. Compile: `dotnet build` or `npm run typecheck`
+   c. Run tests: `dotnet test {TestProject}` or `npm test`
+   d. Parse test output → count passed/failed/skipped
+   e. IF failed > 0:
+      - Log failure details to progress.txt
+      - Analyze error (stack trace, assertion message)
+      - Fix code (modify implementation, NOT test)
+      - Re-compile
+      - Re-run tests
+      - Repeat until passed = total (100%)
+   f. IF passed = total → task.status = 'completed'
+
+4. Verify acceptance criteria
+5. If task execution failed (not tests, but code generation): set `task.status = 'failed'`, `task.error = reason`, continue to next task in batch
 
 **CATEGORY-SPECIFIC EXECUTION RULES:**