@atlashub/smartstack-cli 3.5.0 → 3.7.0

package/templates/skills/ralph-loop/steps/step-02-execute.md

@@ -435,15 +435,30 @@ A validation task is ONLY complete when:
 
 When executing `infrastructure` category tasks, follow these rules strictly:
 
-1. **Seed data files** MUST go under `Infrastructure/Persistence/Seeding/Data/{Module}/`
+1. **Core seed data (navigation, permissions, roles) — CONDITIONAL REFERENCE LOADING:**
+
+   > **IF** the current task description contains "seed data", "SeedData",
+   > "NavigationModule", "PermissionsSeedData", "RolesSeedData", or "IClientSeedDataProvider":
+   > **THEN read `references/core-seed-data.md`** for COMPLETE execution guidance including:
+   > - Parameter extraction from PRD seedDataCore / task `_seedDataMeta`
+   > - MCP `generate_permissions` call sequence (primary) with fallback templates
+   > - `NavigationModuleSeedData.cs` template (deterministic GUIDs, 4 languages)
+   > - `PermissionsSeedData.cs` template (wraps MCP output)
+   > - `RolesSeedData.cs` template (context-based role mapping)
+   > - `IClientSeedDataProvider` complete implementation template
+   > - DI registration pattern
+   > - Verification checklist (BLOCKING)
+   >
+   > **This reference is MANDATORY for seed data tasks. Do NOT improvise.**
+
+   **Directory convention:** All seed data files MUST go under `Infrastructure/Persistence/Seeding/Data/{Module}/`
    - NEVER use `Infrastructure/Data/SeedData/` or `Data/SeedData/`
-   - Each module gets 5 core files: NavigationModuleSeedData.cs, PermissionsSeedData.cs, RolesSeedData.cs, TenantSeedData.cs, UserSeedData.cs
 
 2. **IClientSeedDataProvider** (client projects with `extensions` DbContext):
    - Generate at `Infrastructure/Persistence/Seeding/{AppPascalName}SeedDataProvider.cs`
    - Register in DI: `services.AddScoped<IClientSeedDataProvider, {AppPascalName}SeedDataProvider>()`
    - Must implement: SeedNavigationAsync, SeedPermissionsAsync, SeedRolePermissionsAsync
-   - See `/application` skill step-03b-provider for the full pattern
+   - **Complete template and rules in `references/core-seed-data.md`**
 
 3. **DevDataSeeder** for domain entity seed data:
    - Located at `Infrastructure/Persistence/Seeding/DevDataSeeder.cs`
@@ -514,15 +529,29 @@ Only fr/en translations                      → MUST have 4 languages (fr, en,
 | `business.*` | `BusinessLayout` | `/business` |
 | `personal.*` | `UserLayout` | `/personal/myspace` |
 
-**API/Controller task guidance (MANDATORY folder hierarchy):**
+**Backend folder hierarchy (MANDATORY for ALL layers):**
 
-When executing `api` category tasks, follow these rules strictly:
+> **CRITICAL:** ALL backend files MUST be organized by `{ContextPascal}/{ApplicationName}/{ModuleName}/` hierarchy.
+> Derive from PRD `project.application` and feature.json `metadata.context`.
+> The file paths in prd.json already include this hierarchy — follow them exactly.
 
-1. **Controllers MUST be organized by context and application folders:**
-   - Path: `Api/Controllers/{ContextShort}/{Application}/{EntityName}Controller.cs`
-   - If no application sub-level: `Api/Controllers/{ContextShort}/{EntityName}Controller.cs`
+When executing `domain`, `application`, `infrastructure`, `api`, or `test` category tasks:
 
-2. **Context-to-folder mapping (from navRoute):**
+1. **ALL layers use context/application/module folder hierarchy:**
+
+   | Layer | Path Pattern |
+   |-------|-------------|
+   | Domain | `Domain/Entities/{ContextPascal}/{App}/{Module}/{Entity}.cs` |
+   | Domain Enums | `Domain/Enums/{ContextPascal}/{App}/{Module}/{Enum}.cs` |
+   | Domain Exceptions | `Domain/Exceptions/{ContextPascal}/{App}/{Module}/{Exception}.cs` |
+   | Application Services | `Application/Services/{ContextPascal}/{App}/{Module}/{Service}.cs` |
+   | Application DTOs | `Application/DTOs/{ContextPascal}/{App}/{Module}/{Dto}.cs` |
+   | Application Validators | `Application/Validators/{ContextPascal}/{App}/{Module}/{Validator}.cs` |
+   | Infrastructure Configs | `Infrastructure/Persistence/Configurations/{ContextPascal}/{App}/{Module}/{Config}.cs` |
+   | API Controllers | `Api/Controllers/{ContextShort}/{App}/{Entity}Controller.cs` |
+   | Tests | `Tests/Unit/Domain/{ContextPascal}/{App}/{Module}/{Tests}.cs` |
+
+2. **Controller context-to-folder mapping (`{ContextShort}`):**
 
    | NavRoute Prefix | Controller Folder |
    |-----------------|-------------------|
@@ -531,12 +560,7 @@ When executing `api` category tasks, follow these rules strictly:
    | `business.*` | `Business` |
    | `personal.*` | `User` |
 
-3. **Sub-folders for applications/modules with multiple controllers:**
-   - `Admin/Tenants/` for tenant-related controllers
-   - `Admin/AI/` for AI-related controllers
-   - `Admin/Communications/` for communication controllers
-
-4. **Reference:** SmartStack.app `Api/Controllers/` for the canonical structure
+3. **Reference:** SmartStack.app `Api/Controllers/` for the canonical structure
 
 ### 4. Explore Context (if needed)
 

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

@@ -168,7 +168,64 @@ if (hasQueue) {
   const queue = readJSON(queuePath);
   const currentModule = queue.modules[queue.currentIndex];
 
-  // Mark current module as completed
+  // ✅ FIX #4: MODULE COMPLETENESS CHECK (MANDATORY before advancing)
+  // A module is NOT complete unless all expected layers have at least one completed task.
+  // This prevents marking a module as "done" when only backend was implemented.
+  const completedCategories = new Set(
+    prd.tasks.filter(t => t.status === 'completed').map(t => t.category)
+  );
+  const expectedCategories = ['domain', 'infrastructure', 'application', 'api', 'frontend', 'test'];
+  const missingCategories = expectedCategories.filter(c => !completedCategories.has(c));
+
+  if (missingCategories.length > 0) {
+    console.log(`
+╔══════════════════════════════════════════════════════════════════╗
+║  ⚠️ MODULE INCOMPLETE: Missing layers                           ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Module: ${currentModule.code}                                   ║
+║  Missing: ${missingCategories.join(', ')}                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Injecting guardrail tasks for missing layers...                 ║
+╚══════════════════════════════════════════════════════════════════╝
+    `);
+
+    // Inject guardrail tasks for each missing category
+    let maxId = Math.max(...prd.tasks.map(t => t.id));
+    const lastCompletedByCategory = {};
+    for (const task of prd.tasks) {
+      if (task.status === 'completed') lastCompletedByCategory[task.category] = task.id;
+    }
+
+    for (const cat of missingCategories) {
+      maxId++;
+      const depId = cat === 'frontend'
+        ? (lastCompletedByCategory['api'] || lastCompletedByCategory['application'])
+        : cat === 'test'
+        ? (lastCompletedByCategory['api'] || lastCompletedByCategory['frontend'])
+        : (lastCompletedByCategory['domain'] || lastCompletedByCategory['infrastructure']);
+
+      prd.tasks.push({
+        id: maxId,
+        description: `[${cat}] GUARDRAIL: Generate missing ${cat} layer for module ${currentModule.code}`,
+        status: 'pending',
+        category: cat,
+        dependencies: depId ? [depId] : [],
+        acceptance_criteria: `${cat} layer fully implemented for module ${currentModule.code}`,
+        started_at: null, completed_at: null, iteration: null, commit_hash: null,
+        files_changed: { created: [], modified: [] },
+        validation: null, error: null, module: currentModule.code
+      });
+      console.log(`  → Injected task ${maxId}: [${cat}] guardrail for ${currentModule.code}`);
+    }
+
+    prd.updated_at = new Date().toISOString();
+    writeJSON('.ralph/prd.json', prd);
+
+    // DO NOT mark module as complete — continue the COMPACT LOOP with new tasks
+    // Fall through to section 5 (COMPACT LOOP)
+  } else {
+
+  // Mark current module as completed (only when ALL layers verified)
   currentModule.status = 'completed';
   queue.completedModules++;
 
@@ -231,6 +288,7 @@ if (hasQueue) {
 ║  ${queue.modules.map(m => m.code + ": " + m.status).join("\n║  ")} ║
 ╚══════════════════════════════════════════════════════════════════╝
   `);
+  } // end else (module completeness check passed)
 }
 ```
 
@@ -430,9 +488,19 @@ Batch: {tasksToExecute.length} task(s) [{firstCategory}]
   8. Generate 4-language i18n (fr, en, it, de)
   9. `npm run typecheck` MUST pass
 
-**IF category = "infrastructure":** Seed data in `Infrastructure/Persistence/Seeding/Data/{Module}/`
+**IF category = "domain":** Entities in `Domain/Entities/{ContextPascal}/{App}/{Module}/`, Enums in `Domain/Enums/{ContextPascal}/{App}/{Module}/`
 
-**IF category = "api":** Controllers in `Api/Controllers/{Context}/{App}/{Entity}Controller.cs`
+**IF category = "application":** Services in `Application/Services/{ContextPascal}/{App}/{Module}/`, DTOs in `Application/DTOs/{ContextPascal}/{App}/{Module}/`
+
+**IF category = "infrastructure":**
+  - EF configs in `Infrastructure/Persistence/Configurations/{ContextPascal}/{App}/{Module}/`
+  - Seed data in `Infrastructure/Persistence/Seeding/Data/{Module}/`
+  - **IF task description contains "seed data", "SeedData", or "IClientSeedDataProvider":**
+    Read `references/core-seed-data.md` for COMPLETE execution guidance (parameter extraction,
+    MCP `generate_permissions` call, code templates, IClientSeedDataProvider, verification checklist).
+    **Do NOT improvise core seed data generation.**
+
+**IF category = "api":** Controllers in `Api/Controllers/{ContextShort}/{App}/{Entity}Controller.cs`
 
 After ALL tasks in batch executed:
 - Run `mcp__smartstack__validate_conventions` ONCE for the whole batch
@@ -581,17 +649,32 @@ Completion Check:
 1. ALL tasks have `status: "completed"` or `status: "skipped"`
 2. Zero tasks with `status: "blocked"` or `status: "failed"`
 3. The statement is genuinely true
+4. **Multi-module:** ALL modules in `modules-queue.json` have `status: "completed"`
 
 **False promises to escape the loop are FORBIDDEN.**
 
 **Always update `prd.status` and `prd.updated_at` before proceeding.**
 
+**NEVER DELEGATE THE LOOP:**
+- NEVER use the Task tool to spawn a sub-agent for Ralph loop execution.
+- Sub-agents lose ALL skill context and WILL stop prematurely.
+- The ONLY acceptable Task usage: isolated read-only research (e.g., Context7 docs lookup).
+
+**MODULE COMPLETENESS (multi-module):**
+- Before advancing to the next module, verify ALL expected layers have completed tasks.
+- Expected layers: domain, infrastructure, application, api, frontend, test.
+- If any layer is missing, inject guardrail tasks and continue the COMPACT LOOP.
+- A module with only backend tasks is NOT complete.
+
 **LOOP CONTINUATION IS MANDATORY:**
 - After the first full iteration (step-01→02→03→04), ALL subsequent iterations use the COMPACT LOOP in section 5.
 - DO NOT re-read step-01, step-02, step-03 files. You already know the instructions.
 - DO NOT stop and wait for user input between iterations.
 - DO NOT output a summary and pause. The loop is AUTONOMOUS.
-- The ONLY reasons to stop: completion, max iterations, dead-end, or user interruption.
+- DO NOT decide to stop because "quality over quantity" or "this is enough for now".
+- DO NOT stop after completing one module when others remain in the queue.
+- DO NOT reduce scope autonomously ("I'll skip frontend/tests to save time").
+- The ONLY reasons to stop: ALL tasks complete (all modules), max iterations, dead-end, or user Ctrl+C.
 - Stopping for any other reason is a **BUG** that wastes user time and context.
 - **BATCH tasks of the same category** to reduce iterations (max 5 per batch).
 - Prefer compact output (1-2 lines per task) over verbose output during the loop.