@atlashub/smartstack-cli 3.16.0 → 3.18.0

package/templates/skills/ralph-loop/references/compact-loop.md

@@ -1,8 +1,15 @@
 # Compact Loop — Inline Execution
 
 > **Loaded by:** step-04 section 5 (after first full iteration)
-> **Purpose:** Execute all subsequent iterations inline without re-reading step files.
-> **Rule:** NEVER stop the loop. NEVER wait for user input. NEVER re-read step files.
+> **Purpose:** Execute ALL remaining tasks autonomously without stopping.
+> **EXECUTION GUARANTEE:** This loop runs until ALL tasks are done, max iterations, or dead-end.
+> **ABSOLUTE RULES:**
+> - NEVER stop the loop
+> - NEVER wait for user input
+> - NEVER ask for confirmation
+> - NEVER re-read step files
+> - NEVER pause between iterations
+> - Execute A → B → C → D → back to step-04 section 1 → repeat
 
 ---
 
@@ -208,10 +215,49 @@ Batch: {batch.length} [{firstCategory}] → {batch.map(t => `[${t.id}] ${t.descr
 
 ## C. Commit Batch
 
+### C1. Update PRD Status (MANDATORY — BEFORE git commit)
+
+> **CRITICAL:** PRD status MUST be updated BEFORE committing.
+> In test-v4-005, the compact loop executed 44 tasks but NEVER updated prd.json status.
+> This broke ALL downstream guardrails (module completeness check never triggered).
+
+```javascript
+const now = new Date().toISOString();
+const COMMIT_HASH_PENDING = 'pending-commit'; // Updated after git commit
+
+for (const task of batch) {
+  if (task.status !== 'failed') task.status = 'completed';
+  task.completed_at = now;
+  task.iteration = prd.config.current_iteration;
+  task.commit_hash = COMMIT_HASH_PENDING;
+}
+prd.config.current_iteration++;
+prd.updated_at = now;
+writeJSON('.ralph/prd.json', prd);
+```
+
+### C2. Update Progress File (MANDATORY)
+
+```javascript
+const completed = prd.tasks.filter(t => t.status === 'completed').length;
+const total = prd.tasks.length;
+const moduleName = prd.project?.module || 'unknown';
+
+// Append to progress.txt (NOT overwrite)
+appendFile('.ralph/progress.txt',
+  `Iteration ${prd.config.current_iteration - 1}: ${batch.map(t => t.id).join('/')} COMPLETED — ` +
+  `${batch[0].category} (${batch.length} tasks). ${completed}/${total} done.\n` +
+  `  Files: ${batch.reduce((acc, t) => acc + (t.files_changed?.created?.length || 0), 0)} created\n`
+);
+```
+
+### C3. Git Commit
+
 ```bash
 # Stage all changed files from batch
 git add {all_files_from_batch}
-git add .ralph/prd.json
+git add .ralph/prd.json .ralph/progress.txt
+[ -f .ralph/modules-queue.json ] && git add .ralph/modules-queue.json
 
 git commit -m "$(cat <<'EOF'
 feat({scope}): [{category}] {batch.length} tasks — {short summary}
@@ -227,44 +273,59 @@ EOF
 COMMIT_HASH=$(git rev-parse --short HEAD)
 ```
 
-**Finalize tasks in prd.json:**
+### C4. Finalize PRD with Commit Hash
+
 ```javascript
-const now = new Date().toISOString();
+// Update commit hash now that we have the real one
 for (const task of batch) {
-  if (task.status !== 'failed') task.status = 'completed';
-  task.completed_at = now;
-  task.iteration = prd.config.current_iteration;
-  task.commit_hash = COMMIT_HASH;
+  if (task.commit_hash === 'pending-commit') task.commit_hash = COMMIT_HASH;
 }
 prd.history.push({
-  iteration: prd.config.current_iteration,
+  iteration: prd.config.current_iteration - 1,
   task_ids: batch.map(t => t.id),
   action: 'batch-completed',
   timestamp: now,
   commit_hash: COMMIT_HASH,
   notes: "{summary}"
 });
-prd.config.current_iteration++;
-prd.updated_at = now;
 writeJSON('.ralph/prd.json', prd);
 ```
 
-**Commit progress:**
-```bash
-git add .ralph/prd.json .ralph/progress.txt
-[ -f .ralph/modules-queue.json ] && git add .ralph/modules-queue.json
-git commit -m "chore(ralph): progress — iteration {iteration}"
+### C5. PRD Sync Verification (HARD CHECK)
+
+> **MANDATORY:** Verify prd.json reflects reality before looping back.
+
+```javascript
+const prdCheck = readJSON('.ralph/prd.json');
+const batchIds = batch.map(t => t.id);
+const actuallyCompleted = prdCheck.tasks.filter(t => batchIds.includes(t.id) && t.status === 'completed');
+
+if (actuallyCompleted.length !== batch.filter(t => t.status !== 'failed').length) {
+  console.error('PRD SYNC ERROR: Tasks executed but not marked completed in prd.json');
+  console.error(`Expected: ${batch.filter(t => t.status !== 'failed').length} completed, Got: ${actuallyCompleted.length}`);
+  // Force re-write
+  for (const task of batch) {
+    const prdTask = prdCheck.tasks.find(t => t.id === task.id);
+    if (prdTask && task.status === 'completed') prdTask.status = 'completed';
+    if (prdTask) prdTask.commit_hash = COMMIT_HASH;
+  }
+  writeJSON('.ralph/prd.json', prdCheck);
+  console.log('PRD SYNC REPAIRED');
+}
 ```
 
 ---
 
-## D. Loop Back
+## D. Loop Back (MANDATORY — NO PAUSE)
 
 **IMMEDIATELY return to step-04 section 1 (Read Current State).**
-DO NOT stop. DO NOT wait for user. DO NOT re-read step files.
 
-The only exit conditions:
-- ALL tasks complete (all modules if multi-module)
-- Max iterations reached
-- Dead-end (all remaining blocked/failed)
-- User Ctrl+C
+DO NOT stop. DO NOT wait for user. DO NOT ask "should I continue?". DO NOT re-read step files.
+DO NOT display a summary and pause. DO NOT output partial results and wait.
+**Go directly to step-04 section 1. NOW.**
+
+The ONLY exit conditions (enforced by step-04 sections 2-4):
+- ALL tasks complete (all modules if multi-module) → step-05
+- Max iterations reached → step-05
+- Dead-end (all remaining blocked/failed) → step-05
+- User Ctrl+C (external interrupt)

package/templates/skills/ralph-loop/references/core-seed-data.md

@@ -385,6 +385,52 @@ public class NavigationResourceSeedEntry
 
 ## 3. PermissionsSeedData.cs — MCP-First
 
+### CRITICAL: PermissionAction Safety Rules
+
+> **NEVER use `Enum.Parse<PermissionAction>("...")` — this causes runtime crashes if the string is invalid.**
+> The error only manifests at application startup, not at compile time.
+
+**Valid PermissionAction values (from SmartStack.Domain.Authorization):**
+
+| Enum Value | Int | Description |
+|------------|-----|-------------|
+| `PermissionAction.Access` | 0 | Wildcard permissions only (IsWildcard = true) |
+| `PermissionAction.Read` | 1 | GET/HEAD — View data |
+| `PermissionAction.Create` | 2 | POST — Create new records |
+| `PermissionAction.Update` | 3 | PUT/PATCH — Modify existing records |
+| `PermissionAction.Delete` | 4 | DELETE — Remove records |
+| `PermissionAction.Export` | 5 | Export data (CSV, Excel, etc.) |
+| `PermissionAction.Import` | 6 | Import data |
+| `PermissionAction.Approve` | 7 | Approve workflow items |
+| `PermissionAction.Reject` | 8 | Reject workflow items |
+| `PermissionAction.Assign` | 9 | Assign items to users |
+| `PermissionAction.Execute` | 10 | Execute actions (sync, run, etc.) |
+
+**Anti-patterns (FORBIDDEN):**
+
+```csharp
+// FORBIDDEN — Runtime crash if string is not a valid enum value
+Enum.Parse<PermissionAction>("Validate");          // ArgumentException at startup
+(PermissionAction)Enum.Parse(typeof(PermissionAction), "Validate"); // Same crash
+
+// FORBIDDEN — String-based action in anonymous objects
+new { Action = "read" };  // Not type-safe, silent mismatch possible
+```
+
+**Correct patterns (MANDATORY):**
+
+```csharp
+// ALWAYS use the typed enum directly — compile-time safe
+Action = PermissionAction.Read      // Compile-time checked
+Action = PermissionAction.Create    // Compile-time checked
+Action = PermissionAction.Approve   // Compile-time checked
+
+// For custom actions beyond standard CRUD, pick from the enum:
+// Export, Import, Approve, Reject, Assign, Execute
+```
+
+**MCP validation:** `validate_conventions` with `checks: ["permissions"]` will detect and flag these anti-patterns.
+
 ### Step A: Call MCP (PRIMARY)
 
 ```
@@ -932,6 +978,8 @@ Before marking the task as completed, verify ALL:
 - [ ] NavigationResources seeded (if `seedDataCore.navigationResources` present in feature.json)
 - [ ] Section/Resource translations created (4 languages each, EntityType = Section/Resource)
 - [ ] `dotnet build` passes after generation
+- [ ] NO `Enum.Parse<PermissionAction>` usage anywhere in seeding code (use typed enum directly)
+- [ ] ALL PermissionAction values are from the valid enum: Access, Read, Create, Update, Delete, Export, Import, Approve, Reject, Assign, Execute
 
 **If ANY check fails, the task status = 'failed'.**
 

package/templates/skills/ralph-loop/steps/step-00-init.md

@@ -8,9 +8,12 @@ next_step: steps/step-01-task.md
 
 ## MANDATORY RULES:
 
+- **FULLY AUTONOMOUS** — execute ALL tasks without stopping or asking the user
 - NEVER skip MCP verification
 - ALWAYS parse ALL flags before any action
 - ONLY check resume if -r flag is set
+- **NEVER ask the user** to choose a mode, confirm execution, or select options
+- **NEVER set max_iterations = 1** — unless the user explicitly passed `-m 1`
 - CONTEXT BUDGET: Keep output COMPACT
 - **NEVER DELEGATE** the main Ralph loop to a sub-agent (single module)
 - **Multi-module (2+ modules):** Use Agent Teams for parallel execution
@@ -48,69 +51,36 @@ mcp__context7__resolve-library-id: libraryName: "test"  → {mcp_context7} = tru
 
 If ANY fails: show error, suggest `smartstack check-mcp`, STOP.
 
-## 3. Human-in-the-Loop Checkpoint (RECOMMENDED)
+## 3. Execution Mode (FULLY AUTONOMOUS)
 
-> **Best Practice:** Commencer en mode supervisé avant le mode autonome complet.
+> **CRITICAL:** Ralph-loop is FULLY AUTONOMOUS by default.
+> It executes ALL tasks from start to finish WITHOUT stopping.
+> The user launched `/ralph-loop` — this IS the instruction to execute everything.
 
-### Why HITL First?
+**DO NOT** ask the user to confirm, choose a mode, or approve execution.
+**DO NOT** set `max_iterations = 1` or any reduced value.
+**DO NOT** stop after the first task to "check quality".
 
-Ralph-loop est puissant mais peut diverger si :
-- Les requirements sont ambigus
-- Les tests sont lents (>30s)
-- Le code généré ne compile pas immédiatement
-
-**Stratégie recommandée :**
-
-1. **Première itération supervisée** - Lancer manuellement la première tâche pour vérifier :
-   - La qualité du code généré
-   - Le temps d'exécution des tests
-   - La clarté des messages d'erreur
-
-2. **Mode autonome limité** - Si première itération OK, relancer avec `--max-iterations 5-10`
-
-3. **Mode autonome complet** - Une fois confiant, augmenter à `--max-iterations 50`
-
-### Checkpoint Prompt (Optional)
-
-Si vous détectez que c'est la première utilisation de ralph-loop sur ce projet (pas de `.ralph/logs/`), proposer :
+The loop runs autonomously until:
+- ALL tasks are completed (success)
+- `max_iterations` is reached (user explicitly set via `-m N`)
+- Dead-end detected (all remaining tasks blocked/failed)
+- User Ctrl+C (external interrupt)
 
 ```javascript
-if (!dirExists('.ralph/logs') && !resume_mode) {
-  AskUserQuestion({
-    questions: [{
-      question: "Premier usage de ralph-loop détecté. Démarrer en mode supervisé ou autonome ?",
-      header: "Mode",
-      multiSelect: false,
-      options: [
-        { label: "Supervisé (recommandé)", description: "Exécuter 1 tâche, puis demander confirmation" },
-        { label: "Autonome limité", description: "Max 10 itérations automatiques" },
-        { label: "Autonome complet", description: "Jusqu'à 50 itérations (mode AFK)" }
-      ]
-    }]
-  });
-
-  if (answer === "Supervisé") {
-    max_iterations = 1;
-    console.log("Mode supervisé : 1 tâche sera exécutée. Relancez avec -r pour continuer.");
-  } else if (answer === "Autonome limité") {
-    max_iterations = Math.min(max_iterations, 10);
-  }
-}
+// NO user prompt. NO mode selection. JUST EXECUTE.
+// max_iterations is already set from flags (default: 50).
+// If user wants fewer iterations, they use -m N explicitly.
+console.log(`Mode: AUTONOMOUS | Max iterations: ${max_iterations}`);
 ```
 
-### Feedback Speed Warning
-
-⚠️ **IMPORTANT :** Si vos tests prennent >30 secondes, ralph-loop peut devenir inefficace.
+### Speed Warning (informational only — does NOT block)
 
+If tests are slow (>30s detected in previous logs), display a one-line warning but **continue execution**:
 ```
-Temps test recommandés :
-  - Unitaires : <5s
-  - Intégration : <15s
-  - E2E : <30s (à exécuter en dehors du loop)
+⚠ Slow tests detected. Consider disabling E2E during ralph-loop.
 ```
 
-Si tests lents détectés (via logs), avertir l'utilisateur et suggérer de désactiver tests E2E pendant le loop.
-
 ## 4. Resume Mode
 
 If `{resume_mode} = true`:
@@ -213,9 +183,15 @@ if (PRD_COUNT > 1) {
 }
 ```
 
-## 5. Completion Promise
+## 5. Completion Promise (auto-set)
 
-If `{completion_promise}` is null: ask user to choose (COMPLETE, ALL TESTS PASS, DONE, or custom).
+```javascript
+// Auto-set if not provided — NEVER ask the user
+if (!completion_promise) {
+  completion_promise = "COMPLETE";
+}
+// The promise is output ONLY when ALL tasks are done. No user interaction needed.
+```
 
 ## 6. Collect Metadata
 

package/templates/skills/ralph-loop/steps/step-01-task.md

@@ -94,11 +94,62 @@ If `.ralph/prd.json` exists:
 2. **v3 FAST PATH:** If `$version === "3.0.0"` AND `tasks[]` exists:
    - Inject runtime fields if missing (status, config, feature, created, updated_at, history)
    - Write back to `.ralph/prd.json`
+   - **Run CATEGORY COMPLETENESS CHECK (section 4b) before proceeding**
    - Skip directly to section 5 (find next task)
 3. **v2 legacy:** If `$version === "2.0.0"` → find next eligible task (section 5), skip to section 5
 4. **FORMAT A (deprecated):** If `.project && .requirements && !.$version` → run `transformPrdJsonToRalphV2()` → section 5
 
-If `.ralph/prd.json` does not exist: continue to section 2.
+If `.ralph/prd.json` does not exist: continue to section 1b.
+
+### 1b. BA Handoff Quality Gate (BLOCKING)
+
+> **CRITICAL:** Before generating ANY tasks, verify the BA handoff is complete.
+> A missing handoff means no frontend files, no test plan, no BR-to-code mapping.
+> Generating tasks without handoff produces an INCOMPLETE PRD (backend-only).
+
+```javascript
+// Find the source feature.json for the current module
+const sourceFeatureJson = prd?.metadata?.sourceFeatureJson
+  || findFile('docs/business/**/business-analyse/**/feature.json');
+
+if (sourceFeatureJson) {
+  const feature = readJSON(sourceFeatureJson);
+  const handoff = feature.handoff || {};
+
+  // CHECK 1: Handoff status must be "handed-off"
+  if (handoff.status !== 'handed-off') {
+    console.error(`
+╔══════════════════════════════════════════════════════════════╗
+║  BLOCKING: BA HANDOFF INCOMPLETE                            ║
+║                                                              ║
+║  feature.json handoff.status = "${handoff.status || 'missing'}"
+║  Expected: "handed-off"                                      ║
+║                                                              ║
+║  The /business-analyse did not complete steps 04a→05c.       ║
+║  Without handoff, the PRD will be MISSING:                   ║
+║    - Frontend tasks (pages, components, routes)              ║
+║    - Test tasks (unit, integration, security)                ║
+║    - BR-to-code mappings                                     ║
+║    - API endpoint summary                                    ║
+║                                                              ║
+║  ACTION: Run /business-analyse to complete the handoff,      ║
+║  then re-run /ralph-loop.                                    ║
+╚══════════════════════════════════════════════════════════════╝`);
+    STOP;
+  }
+
+  // CHECK 2: filesToCreate must have all 7 categories
+  const filesToCreate = handoff.filesToCreate || {};
+  const requiredCategories = ['domain', 'application', 'infrastructure', 'api', 'frontend', 'seedData', 'tests'];
+  const missingInHandoff = requiredCategories.filter(c => !filesToCreate[c] || filesToCreate[c].length === 0);
+
+  if (missingInHandoff.length > 0) {
+    console.warn(`⚠ Handoff has empty categories: ${missingInHandoff.join(', ')}`);
+    console.warn('PRD generation may produce incomplete tasks. Consider re-running /business-analyse step-05a.');
+    // WARNING only — allow proceeding if handoff.status is correct
+  }
+}
+```
 
 ## 2. Analyze Task Description
 
@@ -128,6 +179,56 @@ Initialize `.ralph/progress.txt`:
 - Dependency references are valid (exist, no forward/circular)
 - Task count 3-30
 
+### 4b. Category Completeness Check (BLOCKING)
+
+> **CRITICAL:** The PRD MUST contain tasks for ALL required categories.
+> A PRD with only backend categories (domain, infrastructure, application, api) is INCOMPLETE.
+> This check prevents the "no frontend generated" failure mode.
+
+```javascript
+const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', 'frontend', 'test'];
+const presentCategories = new Set(prd.tasks.map(t => t.category));
+const missingCategories = REQUIRED_CATEGORIES.filter(c => !presentCategories.has(c));
+
+if (missingCategories.length > 0) {
+  console.warn(`⚠ PRD MISSING CATEGORIES: ${missingCategories.join(', ')}`);
+
+  // AUTO-INJECT guardrail tasks for missing categories
+  let maxIdNum = Math.max(...prd.tasks.map(t => {
+    const num = parseInt(t.id.replace(/[^0-9]/g, ''), 10);
+    return isNaN(num) ? 0 : num;
+  }));
+  const prefix = prd.tasks[0]?.id?.replace(/[0-9]+$/, '') || 'GUARD-';
+  const lastBackendTask = prd.tasks.filter(t => t.category === 'api').pop()?.id || prd.tasks[prd.tasks.length - 1]?.id;
+
+  for (const cat of missingCategories) {
+    maxIdNum++;
+    const taskId = `${prefix}${String(maxIdNum).padStart(3, '0')}`;
+    const guardrailTask = {
+      id: taskId,
+      description: `[GUARDRAIL] Generate ${cat} layer for ${prd.project?.module || 'module'}`,
+      status: 'pending',
+      category: cat,
+      dependencies: cat === 'test' ? [lastBackendTask] : (cat === 'frontend' ? [lastBackendTask] : []),
+      acceptance_criteria: [
+        cat === 'frontend' ? 'React pages created via MCP scaffold_api_client + scaffold_routes, wired to App.tsx' :
+        cat === 'test' ? 'Unit + Integration test projects created, scaffold_tests MCP called, dotnet test passes' :
+        `${cat} layer fully implemented per category-rules.md`
+      ],
+      started_at: null, completed_at: null, iteration: null,
+      commit_hash: null, files_changed: [], validation: null, error: null
+    };
+    prd.tasks.push(guardrailTask);
+    console.log(`  → Injected guardrail: [${taskId}] ${cat}`);
+  }
+
+  writeJSON('.ralph/prd.json', prd);
+  console.log(`PRD updated: ${prd.tasks.length} tasks (${missingCategories.length} guardrails added)`);
+}
+```
+
+**Why this matters:** In test-v4-005, the PRD was generated with only backend categories (domain, infrastructure, application, api, seedData, validation). The frontend and test categories were entirely absent, resulting in 0 frontend pages and 0 tests generated across 3 modules.
+
 ## 5. Find Current Task
 
 ```javascript

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.**
 
 ---