@atlashub/smartstack-cli 3.17.0 → 3.19.0

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

@@ -71,6 +71,68 @@ if [ -f "web/package.json" ] || [ -f "package.json" ]; then
 fi
 ```
 
+### 1.7. Category Completeness Check (RUNS EVERY ITERATION)
+
+> **CRITICAL:** This check runs REGARDLESS of allDone status.
+> In test-v4-005, allDone was never true (PRD status not updated), so the
+> module completeness check in section 3b never triggered, and missing
+> frontend/test categories were never detected.
+
+```javascript
+const presentCategories = new Set(prd.tasks.map(t => t.category));
+const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', 'frontend', 'test'];
+const missingFromPrd = REQUIRED_CATEGORIES.filter(c => !presentCategories.has(c));
+
+if (missingFromPrd.length > 0) {
+  console.warn(`⚠ PRD MISSING CATEGORIES: ${missingFromPrd.join(', ')}`);
+
+  // Inject guardrail tasks for missing categories
+  let maxIdNum = Math.max(...prd.tasks.map(t => parseInt(t.id.replace(/[^0-9]/g, ''), 10) || 0));
+  const prefix = prd.tasks[0]?.id?.replace(/[0-9]+$/, '') || 'GUARD-';
+  const lastApiTask = prd.tasks.filter(t => t.category === 'api').pop()?.id;
+
+  for (const cat of missingFromPrd) {
+    maxIdNum++;
+    const taskId = `${prefix}${String(maxIdNum).padStart(3, '0')}`;
+    prd.tasks.push({
+      id: taskId,
+      description: `[GUARDRAIL] Generate missing ${cat} layer for ${prd.project?.module || 'module'}`,
+      status: 'pending', category: cat,
+      dependencies: lastApiTask ? [lastApiTask] : [],
+      acceptance_criteria: [
+        cat === 'frontend' ? 'React pages + routes wired to App.tsx (standard + tenant blocks)' :
+        cat === 'test' ? 'Unit + integration test projects with passing dotnet test' :
+        `${cat} layer complete`
+      ],
+      started_at: null, completed_at: null, iteration: null,
+      commit_hash: null, files_changed: [], validation: null, error: null
+    });
+    console.log(`  → Injected [${taskId}] ${cat} guardrail`);
+  }
+  writeJSON('.ralph/prd.json', prd);
+
+  // Re-count after injection
+  const newPending = prd.tasks.filter(t => t.status === 'pending').length;
+  console.log(`PRD updated: +${missingFromPrd.length} guardrails, ${newPending} pending tasks`);
+}
+
+// Also check: artifact existence for categories with completed tasks
+const completedCats = new Set(prd.tasks.filter(t => t.status === 'completed').map(t => t.category));
+const artifactChecks = {
+  'frontend': () => glob.sync('**/src/pages/**/*.tsx').length > 0,
+  'test': () => glob.sync('tests/**/*Tests.cs').length > 0,
+  'api': () => glob.sync('src/*/Controllers/**/*Controller.cs').length > 0
+};
+for (const [cat, check] of Object.entries(artifactChecks)) {
+  if (completedCats.has(cat) && !check()) {
+    console.warn(`ARTIFACT MISSING: ${cat} tasks marked completed but no files found — resetting`);
+    prd.tasks.filter(t => t.category === cat && t.status === 'completed')
+      .forEach(t => { t.status = 'pending'; t.error = 'Artifacts missing — re-execute'; t.completed_at = null; });
+    writeJSON('.ralph/prd.json', prd);
+  }
+}
+```
+
 ## 2. Check Iteration Limit
 
 If `current_iteration > max_iterations`:
@@ -82,6 +144,13 @@ Set `prd.status = 'partial'` → step-05.
 
 ## 3. Check All Tasks Complete
 
+**Re-read state after section 1.7 (categories may have been injected):**
+```javascript
+const tasksCompletedNow = prd.tasks.filter(t => t.status === 'completed').length;
+const tasksTotalNow = prd.tasks.length;
+const allDone = (tasksCompletedNow + prd.tasks.filter(t => t.status === 'skipped').length) === tasksTotalNow;
+```
+
 If `allDone`:
 
 ### 3a. Team Mode (multi-module with Agent Teams)
@@ -107,42 +176,15 @@ if (fileExists(queuePath)) {
   const queue = readJSON(queuePath);
   const currentModule = queue.modules[queue.currentIndex];
 
-  // MODULE COMPLETENESS CHECK: verify all expected layers AND their artifacts
+  // MODULE COMPLETENESS CHECK (lightweight — heavy check already done in section 1.7)
+  // Verify all expected layers have completed tasks
   const completedCats = new Set(prd.tasks.filter(t => t.status === 'completed').map(t => t.category));
   const expected = ['domain', 'infrastructure', 'application', 'api', 'frontend', 'test'];
   const missing = expected.filter(c => !completedCats.has(c));
 
-  // ARTIFACT EXISTENCE CHECK: categories with completed tasks must have real files
-  const artifactChecks = {
-    'infrastructure': () => fs.existsSync('src/*/Persistence/Migrations') && fs.readdirSync('src/*/Persistence/Migrations').length > 0,
-    'test': () => fs.existsSync(`tests/${projectName}.Tests.Unit`) && glob.sync('tests/**/*Tests.cs').length > 0,
-    'api': () => glob.sync('src/*/Controllers/**/*Controller.cs').length > 0,
-    'frontend': () => glob.sync('**/src/pages/**/*.tsx').length > 0
-  };
-  for (const [cat, check] of Object.entries(artifactChecks)) {
-    if (completedCats.has(cat) && !check()) {
-      // Tasks marked completed but artifacts missing — reset to pending
-      prd.tasks.filter(t => t.category === cat && t.status === 'completed')
-        .forEach(t => { t.status = 'pending'; t.error = 'Artifacts missing — re-execute'; t.completed_at = null; });
-      missing.push(cat);
-      console.log(`ARTIFACT RESET: ${cat} tasks reset to pending (no files found)`);
-    }
-  }
-
   if (missing.length > 0) {
-    // Inject guardrail tasks for missing layers
-    let maxId = Math.max(...prd.tasks.map(t => t.id));
-    for (const cat of missing) {
-      maxId++;
-      prd.tasks.push({
-        id: maxId, description: `[${cat}] GUARDRAIL: Generate missing ${cat} for ${currentModule.code}`,
-        status: 'pending', category: cat, dependencies: [],
-        acceptance_criteria: `${cat} layer fully implemented`, started_at: null, completed_at: null,
-        iteration: null, commit_hash: null, files_changed: { created: [], modified: [] },
-        validation: null, error: null, module: currentModule.code
-      });
-    }
-    writeJSON('.ralph/prd.json', prd);
+    // Section 1.7 should have injected guardrails already — fall through to compact loop
+    console.log(`Module ${currentModule.code}: missing categories ${missing.join(', ')} — continuing loop`);
     // Fall through to section 5 (compact loop)
   } else {
     // Module complete — advance
@@ -198,28 +240,33 @@ DEAD-END: {completed} done, {failed} failed, {blocked} blocked
 ```
 Set `prd.status = 'failed'` → step-05.
 
-## 5. Compact Loop (CRITICAL)
+## 5. Compact Loop (MANDATORY — EXECUTE IMMEDIATELY)
 
-> **MANDATORY:** After first full iteration, ALL subsequent iterations use this inline loop.
-> DO NOT stop. DO NOT wait for user. DO NOT re-read step files.
-> **Read `references/compact-loop.md` and execute inline.**
+> **THIS IS NOT OPTIONAL.** If there are pending tasks, you MUST enter the compact loop NOW.
+> DO NOT stop. DO NOT wait for user. DO NOT ask for confirmation. DO NOT re-read step files.
+> **Read `references/compact-loop.md` and execute ALL sections inline.**
+> **Stopping here is a VIOLATION of the execution guarantee.**
 
 If `hasPending && iteration < max`:
 
 1. Read `references/compact-loop.md`
-2. Execute sections A → B → C → D inline
-3. Return to section 1 of THIS step
+2. Execute sections A → B → C → D inline (find tasks → execute batch → commit → loop back)
+3. **IMMEDIATELY** return to section 1 of THIS step (do NOT pause)
+4. Repeat until ALL tasks are complete, max iterations reached, or dead-end
 
 ---
 
-## CRITICAL RULES:
+## CRITICAL RULES — EXECUTION GUARANTEE:
 
 - **NEVER** output completion promise unless ALL tasks done (all modules if multi)
 - **NEVER** delegate the loop to sub-agents (except team mode for multi-module)
-- **NEVER** stop between iterations
+- **NEVER** stop between iterations — this is the CORE PROMISE of ralph-loop
+- **NEVER** ask the user "should I continue?" or "is this OK?" — JUST CONTINUE
+- **NEVER** pause to show intermediate results and wait for feedback
 - **BATCH** same-category tasks (max 5)
 - **MODULE COMPLETENESS:** All layers must have completed tasks before advancing
-- Only valid stop: all complete, max iterations, dead-end, or user Ctrl+C
+- **Only valid stop conditions:** all complete, max iterations, dead-end, or user Ctrl+C
+- **If you stop for any other reason, you have VIOLATED the execution guarantee.**
 
 ---