@atlashub/smartstack-cli 3.0.0 → 3.2.0

package/templates/skills/business-analyse/steps/step-06-extract.md

@@ -67,13 +67,27 @@ Lire le fichier passe en argument : {extract_path}
       "businessRules": [{ "id": "", "name": "", "category": "", "statement": "", "example": "" }],
       "entities": [{ "name": "", "description": "", "attributes": [{ "name": "", "description": "" }], "relationships": [] }],
       "permissions": [],
-      "notes": "",
-      "mockupNotes": ""
+      "notes": ""
     }
   },
   "consolidation": {
     "interactions": [],
-    "e2eFlows": [{ "name": "", "steps": [{ "module": "", "action": "" }], "actors": "" }]
+    "e2eFlows": [{ "name": "", "steps": [{ "module": "", "action": "" }], "actors": "", "diagram": "" }]
+  },
+  "artifacts": {
+    "wireframes": {
+      "{moduleCode}": [
+        { "screen": "", "section": "", "format": "ascii|svg", "content": "", "description": "",
+          "elements": [], "actions": [], "componentMapping": [], "layout": {}, "permissionsRequired": [] }
+      ]
+    },
+    "e2eFlows": [
+      { "name": "", "diagram": "", "steps": [], "actors": "", "modules": "" }
+    ],
+    "dependencyGraph": {
+      "nodes": [{ "id": "", "label": "", "type": "" }],
+      "edges": [{ "from": "", "to": "", "description": "" }]
+    }
   }
 }
 ```
@@ -407,6 +421,113 @@ ba-writer.enrichSection({
 ba-writer.updateStatus({feature_id}, "consolidated")
 ```
 
+### 6-bis. Extraire et reconstituer les artefacts visuels (NEW)
+
+> **NEW in v6.2:** Visual artifacts (wireframes, E2E diagrams, dependency graph) are now extracted from the exported JSON and reconstituted into feature.json.
+
+**IF** `artifacts` exists in exported JSON:
+
+#### Extract wireframes per module
+
+Pour chaque module dans `artifacts.wireframes`:
+
+```
+FOR EACH moduleCode IN artifacts.wireframes:
+  moduleWireframes = artifacts.wireframes[moduleCode]
+
+  // Locate the module feature.json
+  moduleFeature = ba-reader.findModuleFeature({feature_id}, moduleCode)
+
+  // Map wireframes to specification.uiWireframes[]
+  uiWireframes = moduleWireframes.map(wf => ({
+    "screen": wf.screen,
+    "section": wf.section,
+    "mockupFormat": wf.format,
+    "mockup": wf.content,
+    "description": wf.description || "",
+    "elements": wf.elements || [],
+    "actions": wf.actions || [],
+    "permissionsRequired": wf.permissionsRequired || [],
+    "componentMapping": wf.componentMapping || [],
+    "layout": wf.layout || null
+  }))
+
+  // Write to module feature.json (enriching specification section)
+  ba-writer.enrichSection({
+    featureId: moduleFeature.id,
+    section: "specification",
+    data: { uiWireframes: uiWireframes }
+  })
+```
+
+**Validation:** For each wireframe:
+- `screen` must be unique within module
+- `mockupFormat` must be "ascii" or "svg"
+- `mockup` content must not be empty
+- `componentMapping` array must have at least one entry
+- `layout` object must have `type` and `regions` if present
+
+#### Extract E2E flow diagrams
+
+IF `artifacts.e2eFlows` exists:
+
+```
+e2eFlows = artifacts.e2eFlows.map(flow => ({
+  "name": flow.name,
+  "modules": flow.modules.split(" → ").map(m => m.trim()),  // "OrderManagement → Invoicing" → ["OrderManagement", "Invoicing"]
+  "steps": flow.steps || [],
+  "diagram": flow.diagram,  // NEW: ASCII diagram preserved
+  "actors": flow.actors.split(", ").map(a => a.trim())
+}))
+
+// Merge with existing e2eFlows from consolidation.e2eFlows
+ba-writer.enrichSection({
+  featureId: {feature_id},
+  section: "consolidation",
+  data: { e2eFlows: e2eFlows }
+})
+```
+
+**Validation:** For each E2E flow:
+- `diagram` must not be empty if present
+- `modules` array must match modules defined in master feature.json
+- `steps` must have at least 2 entries (cross-module flow)
+
+#### Extract dependency graph (optional)
+
+IF `artifacts.dependencyGraph` exists:
+
+```
+dependencyGraph = {
+  "nodes": artifacts.dependencyGraph.nodes.map(n => ({
+    "id": n.id,
+    "label": n.label || n.id,
+    "type": n.type || "data-centric"
+  })),
+  "edges": artifacts.dependencyGraph.edges.map(e => ({
+    "from": e.from,
+    "to": e.to,
+    "description": e.description || ""
+  }))
+}
+
+// Write to master feature.json
+ba-writer.enrichSection({
+  featureId: {feature_id},
+  section: "decomposition",
+  data: { dependencyGraph: dependencyGraph }
+})
+```
+
+**Post-extraction summary:**
+
+```
+✓ Artefacts visuels extraits:
+  - Wireframes: {total_wireframe_count} across {module_count} modules
+  - E2E diagrams: {e2e_flow_count}
+  - Dependency graph: {node_count} nodes, {edge_count} edges
+```
+
 ### 7. Resume de l'extraction
 
 Afficher un resume comparatif :
@@ -432,11 +553,18 @@ Afficher un resume comparatif :
 | Regles metier          | {total}        | analysis.businessRules |
 | Entites                | {total}        | analysis.entities |
 | Parcours E2E           | {count}        | consolidation.e2eFlows |
+| Maquettes (wireframes) | {total}        | specification.uiWireframes[] |
+| Diagrammes E2E         | {count}        | consolidation.e2eFlows[].diagram |
 
 Fichiers generes :
   - docs/business/{app}/business-analyse/v1.0/feature.json (master)
   - docs/business/{app}/{module}/business-analyse/v1.0/feature.json (par module)
 
+Artefacts visuels preserves :
+  - Toutes les maquettes ASCII/SVG validees lors de la specification
+  - Tous les diagrammes E2E pour les flux cross-module
+  - Graphe de dependances entre modules
+
 ═══════════════════════════════════════════════════════════════
 ```
 

package/templates/skills/gitflow/steps/step-pr.md

@@ -38,13 +38,25 @@ fi
 
 ```bash
 CURRENT=$(git rev-parse --abbrev-ref HEAD)
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+
+# CRITICAL: Verify config was loaded
+if [ -z "$GF_MAIN_BRANCH" ] || [ -z "$GF_DEVELOP_BRANCH" ]; then
+  echo "❌ GitFlow config not loaded properly"
+  echo "→ Variables GF_MAIN_BRANCH and GF_DEVELOP_BRANCH are empty"
+  exit 1
+fi
 
-case "$CURRENT" in
-  ${GF_FEATURE_PREFIX}*) TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
-  ${GF_RELEASE_PREFIX}*) TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
-  ${GF_HOTFIX_PREFIX}*)  TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
-  *)                     TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
+# Determine target branch based on type (using config values)
+case "$BRANCH_TYPE" in
+  feature) TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
+  release) TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
+  hotfix)  TARGET_BRANCH="$GF_MAIN_BRANCH" ;;
+  *)       TARGET_BRANCH="$GF_DEVELOP_BRANCH" ;;
 esac
+
+echo "✓ Branch: $CURRENT (type: $BRANCH_TYPE)"
+echo "✓ Target: $TARGET_BRANCH"
 ```
 
 ### 3. Check Prerequisites

package/templates/skills/ralph-loop/SKILL.md

@@ -10,27 +10,38 @@ Execute the Ralph Weegund technique - an iterative development methodology where
 </objective>
 
 <quick_start>
-**Basic usage:**
-
-```bash
-/ralph-loop implement user authentication
-```
-
-**With completion promise:**
+**Three ways to start Ralph Loop:**
+
+1. **From Business Analysis (RECOMMENDED - NEW v6.1):**
+   ```bash
+   /business-analyse MyFeature
+   # At the end, choose "Ralph Loop" → automatic launch
+   # No arguments needed - prd.json already generated
+   ```
+
+2. **Manual start with existing prd.json:**
+   ```bash
+   /ralph-loop
+   # Ralph detects .ralph/prd.json and resumes automatically
+   # Works after BA handoff or previous Ralph session
+   ```
+
+3. **Direct task (no BA):**
+   ```bash
+   /ralph-loop implement user authentication
+   # Ralph creates prd.json on the fly
+   ```
+
+**With options:**
 
 ```bash
+# Completion promise
 /ralph-loop -c "COMPLETE" refactor the cache layer
-```
 
-**With max iterations:**
-
-```bash
+# Max iterations
 /ralph-loop -m 20 -c "TESTS PASS" add comprehensive tests
-```
 
-**Verbose mode:**
-
-```bash
+# Verbose mode
 /ralph-loop -v -c "DONE" fix all linting errors
 ```
 
@@ -39,6 +50,7 @@ Execute the Ralph Weegund technique - an iterative development methodology where
 - `-m N` (max): Maximum iterations before auto-stop
 - `-c TEXT` (complete): Completion promise text
 - `-v` (verbose): Detailed logging
+- `-r` (resume): Resume from previous state
 
 See `<parameters>` for complete flag list.
 </quick_start>
@@ -99,33 +111,144 @@ The same prompt is fed to Claude repeatedly. The "self-referential" aspect comes
 5. Claude sees previous work in the files
 6. Iteratively improves until completion promise is output
 
+**Iterative Development Cycle (per task):**
+```
+┌─────────────────────────────────────────────────────────────┐
+│                   RALPH LOOP - CYCLE                        │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  1. ANALYSE      → Load next task from prd.json            │
+│                    (UC, FR, BR, wireframes, acceptance)     │
+│                                                             │
+│  2. DÉVELOPPEMENT → Generate code for task                  │
+│     ├─ Backend:   Entity, Service, Repository, Controller  │
+│     ├─ Tests:     Unit tests (xUnit) + non-regression      │
+│     ├─ Frontend:  Page, Component, Hook (match wireframe)  │
+│     ├─ Tests:     Frontend tests (React Testing Library)   │
+│     ├─ SeedData:  CORE RBAC (5 entries) + business data    │
+│     └─ Docs:      Inline comments + tooltips + i18n keys   │
+│                                                             │
+│  3. VALIDATION   → Commit changes + MCP conventions check   │
+│                    (validate_conventions, check_migrations) │
+│                                                             │
+│  4. TEST         → Run tests (dotnet test + npm test)       │
+│                    ├─ Unit tests                            │
+│                    ├─ Integration tests                     │
+│                    ├─ Security tests (tenant isolation)     │
+│                    └─ E2E tests (critical flows)            │
+│                                                             │
+│  5. CORRECTION   → If tests fail:                           │
+│                    ├─ Analyze error logs                    │
+│                    ├─ Fix root cause                        │
+│                    ├─ Commit fix                            │
+│                    └─ Return to step 4                      │
+│                                                             │
+│  6. NEXT TASK    → Mark task as completed, loop to step 1   │
+│                                                             │
+│  🎯 Goal: 100% tests pass before moving to next task        │
+│  📊 Coverage: 95-100% (tests auto-generated)                │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
 **Completion signal:**
 ```
 <promise>{completion_promise}</promise>
 ```
 
 The loop only stops when this exact tag is output or max iterations reached.
+
+**What Ralph generates per task:**
+- **Backend code**: Entities (Domain), Services (Application), Repositories (Infrastructure), Controllers (API)
+- **Unit tests**: xUnit tests for domain logic, services, repositories
+- **Integration tests**: Controller tests with WebApplicationFactory
+- **Frontend code**: React pages, components, custom hooks (matching BA wireframes)
+- **Frontend tests**: React Testing Library for components and pages
+- **SeedData**: 5 CORE entries (Navigation, Permissions, Roles, Tenants, Users) + business reference data
+- **Documentation**: Inline code comments, user-facing tooltips, i18n translation keys
+- **Security tests**: Tenant isolation, permission checks, OWASP validations
+
+**prd.json structure (input from BA):**
+The prd.json is generated by `/business-analyse` via `ss derive-prd` command. It contains:
+- **feature**: Feature description (from BA)
+- **tasks[]**: Task breakdown by category (domain, application, infrastructure, api, frontend, i18n, test, validation)
+  - Each task has: id, description, category, dependencies, acceptance_criteria, linkedFRs, linkedUCs, linkedBRs
+  - Frontend tasks include: linkedWireframes (screen IDs from BA mockups), wireframeAcceptanceCriteria
+  - SeedData tasks specify: category (core|business), source (specification.seedDataCore or seedDataBusiness)
+- **source**: Traceability to feature.json path (source of truth)
+- **metadata**: Project context (branch, namespace, module order)
+- **config**: max_iterations, completion_promise, current_iteration
+
+Ralph reads prd.json to know WHAT to generate, then generates it, tests it, fixes it, and moves to the next task.
 </ralph_concept>
 
 <workflow>
 **Standard flow (single module):**
-1. Parse flags and task description
-2. Verify MCP servers are available (MANDATORY)
-3. Initialize .ralph/ structure and state files
-4. Load current task from prd.json (or create initial task breakdown with categories, dependencies, and acceptance criteria)
-5. Execute ONE task per iteration
-6. Commit changes, update progress
-7. Check completion criteria
-8. If complete: generate final report
-
-**Multi-module flow (from BA handoff):**
-1-3. Same as standard flow
+1. Parse flags and task description (step-00)
+2. Verify MCP servers are available (step-00, MANDATORY)
+3. Initialize .ralph/ structure and state files (step-00)
+4. Load current task from prd.json — create task breakdown if new (step-01, READ ONCE)
+5. Execute first task (step-02, READ ONCE)
+6. Commit changes, update progress (step-03, READ ONCE)
+7. Check completion → enter COMPACT LOOP (step-04)
+8. **COMPACT LOOP** (step-04 section 5, NO re-reading step files):
+   - Find eligible tasks → batch by category (max 5)
+   - Execute batch inline (generate code)
+   - Run tests (dotnet test + npm test)
+   - If tests fail: analyze → fix → re-test (loop until 100% pass)
+   - Commit batch (only when tests pass)
+   - Re-check completion → loop or finish
+9. When complete: generate final report (step-05)
+
+**Multi-module flow (from BA handoff - NEW v6.1: automatic launch):**
+1-3. Same as standard flow (or launched automatically from `/business-analyse`)
 4. Detect `prd-*.json` files → create `modules-queue.json`
 5. Copy current module's prd to `prd.json`
-6. Execute all tasks for current module (standard loop: steps 01→02→03→04)
-7. When module complete: advance to next module in queue
-8. Repeat steps 5-7 for each module
+6. Execute all tasks for current module via COMPACT LOOP:
+   - Process tasks by category (domain → seeddata → application → infrastructure → api → frontend → i18n → tests)
+   - For each task: generate → test → fix (if needed) → re-test → commit (when pass)
+   - Each task generates: backend code + tests + frontend code + tests + seeddata + docs
+   - Each frontend task respects wireframes from BA (specification.uiWireframes[])
+   - Continue until ALL tasks of module = completed
+7. When module complete: advance to next module in queue (step-04 section 3)
+8. Repeat steps 5-7 for each module (step-01 is re-read ONLY for module transitions)
 9. When all modules done: generate cross-module report
+
+**Note:** When launched from `/business-analyse` (v6.1+), Ralph Loop receives:
+- `.ralph/prd-{module}.json` for each module (generated by `ss derive-prd`)
+  - Each prd contains: tasks breakdown with UC/FR/BR/wireframes/acceptance criteria
+  - Task categories: domain, application, infrastructure, api, frontend, i18n, test, validation
+  - Each task linked to: functional requirements (FR), use cases (UC), business rules (BR)
+  - Frontend tasks include: linkedWireframes[] (screen IDs from BA mockups)
+  - SeedData tasks specify: category (core 5 entries MANDATORY + business data)
+- `.ralph/progress.txt` with comprehensive task tracker (hierarchical: module → layer → tasks)
+- Module order from BA's topological dependency graph (dependencies first)
+- No arguments needed - fully configured by BA handoff
+
+**Task execution cycle (per task):**
+```
+LOAD TASK → GENERATE CODE → COMMIT → RUN TESTS → [FAIL?] → ANALYZE ERROR → FIX → RE-TEST → [PASS!] → NEXT TASK
+                                                    ↑___________________________________________|
+                                                         (loop until 100% tests pass)
+```
+
+**What gets generated per module:**
+1. **Domain layer**: Entities, Value Objects, Enums, Domain Exceptions
+2. **SeedData layer**: 5 CORE entries (Navigation, Permissions, Roles, Tenants, Users) + business reference data
+3. **Application layer**: Services, DTOs, Validators, Query Handlers
+4. **Infrastructure layer**: Repositories, DbContext, Specifications
+5. **API layer**: Controllers, Error Handlers, Validation Responses
+6. **Frontend layer**: Pages (matching wireframes), Components, Custom Hooks, Forms
+7. **I18n layer**: Translation keys (fr, en, it, de) for UI labels
+8. **Tests layer**: Unit tests (Domain, Application), Integration tests (API), Security tests (tenant isolation), E2E tests (critical flows)
+
+**Acceptance criteria per task:**
+- Code compiles (dotnet build + npm build)
+- Tests pass (dotnet test + npm test)
+- MCP conventions validated (validate_conventions)
+- Wireframes respected (frontend pages match BA mockups from specification.uiWireframes[])
+- Business rules implemented (BR-to-code mapping from BA)
+- Security enforced (tenant isolation, RBAC permissions)
 </workflow>
 
 <state_variables>
@@ -279,12 +402,14 @@ Before ANY work, verify MCP servers:
 
 <execution_rules>
 
-- **Load one step at a time** - Only load the current step file
-- **VERIFY MCP FIRST** - Never skip MCP validation
-- **ONE TASK PER ITERATION** - Don't batch tasks
-- **COMMIT AFTER EACH TASK** - Atomic progress
+- **Load step files ONCE** - Step files are read only on FIRST iteration. After that, use the COMPACT LOOP in step-04 section 5.
+- **VERIFY MCP FIRST** - Never skip MCP validation at init
+- **BATCH same-category tasks** - Execute up to 5 tasks of the same category per iteration (reduces loop iterations from 30+ to ~8)
+- **COMMIT AFTER EACH BATCH** - One commit per batch, not per individual task
 - **UPDATE progress.txt** - Persist learnings
 - **NEVER fake completion** - Only output promise when truly done
+- **NEVER STOP THE LOOP** - The loop is AUTONOMOUS. DO NOT pause between iterations. DO NOT wait for user input. Only stop on: completion, max iterations, dead-end, or explicit user interruption. Stopping for any other reason wastes context and causes re-reads.
+- **COMPACT OUTPUT** - During loop iterations, use 1-2 lines per task. Save verbose output for the final report.
 </execution_rules>
 
 <success_criteria>

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

@@ -6,6 +6,36 @@ next_step: steps/step-02-execute.md
 
 # Step 1: Load Task
 
+> **MODULE TRANSITION CHECK (MANDATORY):**
+> Before applying the "Only Read Once" rule, check for module transition marker:
+
+```javascript
+const moduleChangedPath = '.ralph/module-changed.json';
+const moduleTransition = fileExists(moduleChangedPath);
+
+if (moduleTransition) {
+  const transitionData = readJSON(moduleChangedPath);
+  console.log(`🔄 Module transition detected: ${transitionData.fromModule} → ${transitionData.toModule}`);
+  console.log(`   Reloading step-01 to initialize new module...`);
+
+  // Delete flag (consume it)
+  deleteFile(moduleChangedPath);
+
+  // PROCEED with step-01 execution (skip "Only Read Once" rule below)
+  // This is the EXCEPTION case for multi-module workflows
+}
+```
+
+> **CONTEXT OPTIMIZATION:** This file is normally read ONCE per module (first iteration).
+> After the first full iteration (step-01 → step-02 → step-03 → step-04),
+> ALL subsequent iterations within the SAME module MUST use the COMPACT LOOP in step-04-check.md section 5.
+> **DO NOT re-read this file for iterations > 1 of the same module.**
+>
+> **EXCEPTION:** When transitioning between modules (multi-module workflows), step-01 MUST be re-read
+> to load the next module's PRD. This is signaled by `.ralph/module-changed.json` file (checked above).
+>
+> If you are re-reading this file on iteration > 1 AND no module transition detected, STOP and go to step-04 section 5 instead.
+
 ## YOUR TASK:
 
 Load the current task from prd.json or create initial task breakdown with categories, dependencies, and acceptance criteria.
@@ -18,7 +48,10 @@ Load the current task from prd.json or create initial task breakdown with catego
 
 ### 0. Multi-Module Queue Check
 
-**Before any other logic, check for modules-queue.json:**
+**✅ ALWAYS check for modules-queue.json, even on iteration > 1:**
+
+> **CRITICAL:** This section MUST execute even when step-01 is re-read for module transitions.
+> The module-changed.json flag (checked above) ensures this section runs when needed.
 
 ```javascript
 const queuePath = '.ralph/modules-queue.json';
@@ -28,22 +61,52 @@ if (hasQueue) {
   const queue = readJSON(queuePath);
   const currentModule = queue.modules[queue.currentIndex];
 
-  console.log(`Module ${queue.currentIndex + 1}/${queue.totalModules}: ${currentModule.code}`);
-
-  // Copy current module's prd file to prd.json (overwrite)
-  const modulePrd = readJSON(currentModule.prdFile);
-
-  // Transform PrdJson format to Ralph v2 if needed
-  if (modulePrd.project && modulePrd.requirements && !modulePrd.$version) {
-    // This is a PrdJson format from ss derive-prd → transform to Ralph v2
-    const transformedPrd = transformPrdJsonToRalphV2(modulePrd, currentModule.code);
-    writeJSON('.ralph/prd.json', transformedPrd);
+  console.log(`
+╔══════════════════════════════════════════════════════════════════╗
+║  Multi-Module Workflow Detected                                 ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Current Module: ${currentModule.code} (${queue.currentIndex + 1}/${queue.totalModules})                    ║
+║  Status: ${currentModule.status}                                ║
+║  PRD File: ${currentModule.prdFile}                             ║
+╚══════════════════════════════════════════════════════════════════╝
+  `);
+
+  // ✅ FIX #3: RESTORE multi-module state variables
+  // These variables persist across step files and are critical for multi-module coordination
+  {modules_queue} = queue;
+  {current_module} = currentModule.code;
+
+  // ✅ Load or verify current module's PRD is in .ralph/prd.json
+  // On module transition, step-04 already loaded it, but we verify here
+  const currentPrd = readJSON('.ralph/prd.json');
+
+  // Verify PRD matches current module (sanity check)
+  if (currentPrd.metadata && currentPrd.metadata.moduleCode !== currentModule.code) {
+    console.log(`⚠️  PRD mismatch detected. Loading correct PRD for module ${currentModule.code}...`);
+
+    // Load current module's PRD
+    const modulePrd = readJSON(currentModule.prdFile);
+
+    // Transform PrdJson format to Ralph v2 if needed
+    if (modulePrd.project && modulePrd.requirements && !modulePrd.$version) {
+      // This is a PrdJson format from ss derive-prd → transform to Ralph v2
+      const transformedPrd = transformPrdJsonToRalphV2(modulePrd, currentModule.code);
+      writeJSON('.ralph/prd.json', transformedPrd);
+      console.log(`✅ Transformed and loaded PRD for module: ${currentModule.code}`);
+    } else {
+      // Already Ralph v2 format
+      writeJSON('.ralph/prd.json', modulePrd);
+      console.log(`✅ Loaded PRD for module: ${currentModule.code}`);
+    }
   } else {
-    // Already Ralph v2 format
-    writeJSON('.ralph/prd.json', modulePrd);
+    console.log(`✅ PRD already loaded for module: ${currentModule.code}`);
   }
 
-  console.log(`Loaded PRD for module: ${currentModule.code}`);
+  console.log(`State restored: modules_queue and current_module set`);
+} else {
+  // Single-module workflow
+  {modules_queue} = null;
+  {current_module} = null;
 }
 ```
 
@@ -76,23 +139,37 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
   const filesToCreate = prdJson.implementation?.filesToCreate || {};
 
   // 1. Generate tasks from implementation.filesToCreate (primary source)
+  //    CRITICAL: Frontend and i18n tasks are CONSOLIDATED into ONE module-level task each.
+  //    These use MCP scaffolding tools, NOT manual file-by-file generation.
   const lastIdByCategory = {};
+  const frontendFiles = [];  // Collect frontend files for consolidated task
+  const i18nFiles = [];      // Collect i18n files for consolidated task
 
   for (const layer of layerOrder) {
     const files = filesToCreate[layer.key] || [];
+
+    // FRONTEND & I18N: Collect files, do NOT create individual tasks
+    if (layer.category === "frontend") {
+      frontendFiles.push(...files);
+      continue;  // Skip individual task creation
+    }
+
     for (const fileSpec of files) {
+      // Check if this is an i18n file (category "infrastructure" but path contains i18n)
+      if (fileSpec.path?.includes('i18n/') || fileSpec.path?.includes('/locales/')) {
+        i18nFiles.push(fileSpec);
+        continue;  // Skip individual task creation
+      }
+
       const depIds = [];
       // Depend on last task in same category (sequential within layer)
       if (lastIdByCategory[layer.category]) {
         depIds.push(lastIdByCategory[layer.category]);
       }
-      // Cross-layer: api depends on last application task, frontend depends on last api task
+      // Cross-layer: api depends on last application task
       if (layer.category === "api" && lastIdByCategory["application"]) {
         depIds.push(lastIdByCategory["application"]);
       }
-      if (layer.category === "frontend" && lastIdByCategory["api"]) {
-        depIds.push(lastIdByCategory["api"]);
-      }
       if (layer.category === "test" && lastIdByCategory["api"]) {
         depIds.push(lastIdByCategory["api"]);
       }
@@ -131,6 +208,71 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
     }
   }
 
+  // 1b. Create CONSOLIDATED frontend task (ONE task per module, uses MCP tools)
+  if (frontendFiles.length > 0) {
+    const apiDepId = lastIdByCategory["api"] || lastIdByCategory["application"];
+    const allLinkedUCs = [...new Set(frontendFiles.flatMap(f => f.linkedUCs || []))];
+    const allLinkedWireframes = [...new Set(frontendFiles.flatMap(f => f.linkedWireframes || []))];
+    const allPaths = frontendFiles.map(f => f.path);
+
+    tasks.push({
+      id: taskId,
+      description: `[frontend] Generate COMPLETE frontend for module ${moduleCode} via MCP scaffold tools (${frontendFiles.length} files: pages, components, hooks, API client)`,
+      status: "pending",
+      category: "frontend",
+      dependencies: apiDepId ? [apiDepId] : [],
+      acceptance_criteria: [
+        "MCP scaffold_api_client called → API client + types generated",
+        "MCP scaffold_routes called → routes.tsx updated with nested routes inside Layout wrapper",
+        "Pages match wireframes: " + allLinkedWireframes.join(", "),
+        "SmartTable for lists (NOT HTML tables), EntityCard for grids (NOT custom divs)",
+        "CSS variables ONLY (NO hardcoded Tailwind colors like bg-blue-600)",
+        "useNavigate + useParams for routing, NOT window.location",
+        "Loading/error/empty states on all pages",
+        "4-language i18n keys (fr, en, it, de)",
+        "npm run typecheck passes"
+      ].join("; "),
+      started_at: null,
+      completed_at: null,
+      iteration: null,
+      commit_hash: null,
+      files_changed: { created: allPaths, modified: [] },
+      validation: null,
+      error: null,
+      module: moduleCode,
+      _frontendMeta: {
+        wireframes: allLinkedWireframes,
+        linkedUCs: allLinkedUCs,
+        filesToCreate: frontendFiles
+      }
+    });
+
+    lastIdByCategory["frontend"] = taskId;
+    taskId++;
+  }
+
+  // 1c. Create CONSOLIDATED i18n task (ONE task per module)
+  if (i18nFiles.length > 0) {
+    tasks.push({
+      id: taskId,
+      description: `[i18n] Generate i18n translations for module ${moduleCode} (4 languages: fr, en, it, de)`,
+      status: "pending",
+      category: "i18n",
+      dependencies: lastIdByCategory["frontend"] ? [lastIdByCategory["frontend"]] : [],
+      acceptance_criteria: "4 JSON files (fr, en, it, de) with identical keys; all UI labels translated",
+      started_at: null,
+      completed_at: null,
+      iteration: null,
+      commit_hash: null,
+      files_changed: { created: i18nFiles.map(f => f.path), modified: [] },
+      validation: null,
+      error: null,
+      module: moduleCode
+    });
+    lastIdByCategory["i18n"] = taskId;
+    taskId++;
+  }
+
   // 2. Add IClientSeedDataProvider task for client projects (ExtensionsDbContext)
   // This is MANDATORY - without it, core seed data (navigation, permissions, roles) is dead code
   const hasClientSeedData = filesToCreate["seedData"]?.some(f =>