@atlashub/smartstack-cli 3.17.0 → 3.19.0

package/templates/skills/ralph-loop/references/category-rules.md

@@ -141,13 +141,86 @@ Rules:
 - DTOs separate from domain entities
 - Service interfaces in Application, implementations in Infrastructure
 
-**Tenant isolation (BLOCKING):**
+**Tenant isolation (BLOCKING — SECURITY CRITICAL):**
+
+> **ROOT CAUSE (test-v4-005):** Services were generated WITHOUT TenantId filtering,
+> creating cross-tenant data leakage on ALL 70+ CRUD endpoints.
+> This is an OWASP A01 (Broken Access Control) vulnerability.
+
 - ALL queries on tenant entities MUST include `.Where(x => x.TenantId == _currentUser.TenantId)`
 - ALL entity creation MUST pass `_currentUser.TenantId` as first parameter to `Entity.Create(tenantId, ...)`
 - NEVER use `new Entity { }` without `TenantId =` — always prefer factory method `Entity.Create()`
 - NEVER use `Guid.Empty` as a placeholder for userId, tenantId, or any business identifier
 - Service constructor MUST inject `ICurrentUserService _currentUser` to access TenantId
 
+**MANDATORY Service Template (use as skeleton for ALL services):**
+
+```csharp
+public class {Entity}Service : I{Entity}Service
+{
+    private readonly IExtensionsDbContext _db;
+    private readonly ICurrentUserService _currentUser;
+
+    public {Entity}Service(IExtensionsDbContext db, ICurrentUserService currentUser)
+    {
+        _db = db;
+        _currentUser = currentUser;
+    }
+
+    public async Task<PagedResult<{Entity}Response>> GetAllAsync(/* filters */, CancellationToken ct)
+    {
+        var tenantId = _currentUser.TenantId;
+        var query = _db.{Entities}
+            .Where(x => x.TenantId == tenantId)  // ← MANDATORY tenant filter
+            .AsQueryable();
+        // ... apply filters, pagination, projection to Response DTO
+    }
+
+    public async Task<{Entity}Response?> GetByIdAsync(Guid id, CancellationToken ct)
+    {
+        var tenantId = _currentUser.TenantId;
+        var entity = await _db.{Entities}
+            .Where(x => x.TenantId == tenantId)  // ← MANDATORY tenant filter
+            .FirstOrDefaultAsync(x => x.Id == id, ct);
+        // ...
+    }
+
+    public async Task<{Entity}Response> CreateAsync(Create{Entity}Dto dto, CancellationToken ct)
+    {
+        var entity = {Entity}.Create(_currentUser.TenantId, /* dto fields */);
+        // ← TenantId as FIRST parameter
+        _db.{Entities}.Add(entity);
+        await _db.SaveChangesAsync(ct);
+        return MapToResponse(entity);
+    }
+
+    public async Task<{Entity}Response> UpdateAsync(Guid id, Update{Entity}Dto dto, CancellationToken ct)
+    {
+        var entity = await _db.{Entities}
+            .Where(x => x.TenantId == _currentUser.TenantId)  // ← MANDATORY
+            .FirstOrDefaultAsync(x => x.Id == id, ct)
+            ?? throw new NotFoundException(nameof({Entity}), id);
+        // ... update fields
+    }
+
+    public async Task DeleteAsync(Guid id, CancellationToken ct)
+    {
+        var entity = await _db.{Entities}
+            .Where(x => x.TenantId == _currentUser.TenantId)  // ← MANDATORY
+            .FirstOrDefaultAsync(x => x.Id == id, ct)
+            ?? throw new NotFoundException(nameof({Entity}), id);
+        // ...
+    }
+
+    private static {Entity}Response MapToResponse({Entity} entity) => new()
+    {
+        // Map entity fields to response DTO
+    };
+}
+```
+
+**POST-CHECK after writing ANY service:** Grep the file for `TenantId`. If 0 occurrences → FAIL, rewrite with tenant filtering.
+
 **Lifecycle-aware services:**
 - Services operating on entities with a `lifeCycle` (status field) MUST validate entity state before mutations
 - Example: `if (entity.Status == EmployeeStatus.Terminated) throw new BusinessException("Cannot update terminated employee")`
@@ -161,6 +234,22 @@ Rules:
 - DependencyInjection.cs MUST NOT be empty or contain only TODO comments
 - After writing validators, VERIFY DI registration exists — if missing, add it immediately
 
+**POST-CHECK after writing validators:**
+```bash
+# Count Create validators vs Update validators
+CREATE_COUNT=$(find . -path "*/Validators/*" -name "Create*Validator.cs" | wc -l)
+UPDATE_COUNT=$(find . -path "*/Validators/*" -name "Update*Validator.cs" | wc -l)
+if [ "$CREATE_COUNT" -ne "$UPDATE_COUNT" ]; then
+  echo "VALIDATOR MISMATCH: $CREATE_COUNT Create vs $UPDATE_COUNT Update → MUST be equal"
+  # List missing UpdateValidators and CREATE them
+fi
+```
+
+**Mapper pattern (DRY):**
+- Each service MUST include a `private static {Entity}Response MapToResponse({Entity} entity)` method
+- For complex mappings with related entities, use an extension method in `Application/Mappings/{Module}Mappings.cs`
+- NEVER duplicate mapping logic between GetAll, GetById, Create, Update — always call MapToResponse
+
 **FORBIDDEN:**
 - Empty DependencyInjection.cs with `// TODO` placeholder
 - CreateValidator without matching UpdateValidator
@@ -169,6 +258,7 @@ Rules:
 - `new Entity { }` without TenantId assignment
 - `Guid.Empty` as a business value in services or controllers
 - Entity.Create() without tenantId as first parameter
+- Duplicated mapping logic (entity→response) in multiple methods
 
 ---
 
@@ -280,9 +370,13 @@ useXxx with raw axios inside hooks           → hooks MUST use the shared apiCl
 
 **MCP:** `scaffold_tests`, `analyze_test_coverage`
 
+> **CRITICAL:** Test generation is a MANDATORY category. If the PRD has no test tasks,
+> the category completeness check (step-01 section 4b) will inject a guardrail task.
+> Test projects MUST be created as the FIRST action in this category — before generating any test files.
+
 **Execution sequence:**
 
-1. **Ensure test projects exist:**
+1. **Ensure test projects exist (FIRST — before any test generation):**
    ```bash
    # Unit test project
    UNIT_TEST_PROJECT="tests/${PROJECT_NAME}.Tests.Unit"

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/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