@atlashub/smartstack-cli 3.20.0 → 3.22.0

package/templates/skills/business-analyse/steps/step-03d-validate.md

@@ -34,21 +34,50 @@ Validate the module specification for completeness and consistency, write to fea
 
 #### 9a. Completeness Checks
 
-| Section | Minimum | Status |
-|---------|---------|--------|
-| actors | 2 | PASS/FAIL |
-| useCases | 2 | PASS/FAIL |
-| functionalRequirements | 4 | PASS/FAIL |
-| permissionMatrix | 1 resource × 2 roles | PASS/FAIL |
-| entities | 1 | PASS/FAIL |
-| entitySchemaFormat | attributes[] not fields[] (BLOCKING) | PASS/FAIL |
-| wireframes | 1 per section (BLOCKING) | PASS/FAIL |
-| wireframeSchema | All required fields present (BLOCKING) | PASS/FAIL |
-| gherkinScenarios | 2 per UC | PASS/FAIL |
-| validations | 1 | PASS/FAIL |
-| messages | 4 | PASS/FAIL |
-| lifeCycles | 1 (if entity has status) | PASS/FAIL |
-| seedDataCore | 7 sections present | PASS/FAIL (BLOCKING) |
+> **CRITICAL:** Checks MUST count ACTUAL elements in arrays, NOT declarative values.
+> A check that reports PASS when the array is empty is a LIE and BLOCKS downstream quality.
+
+| Section | Minimum | How to verify | Status |
+|---------|---------|---------------|--------|
+| actors | 2 | `specification.actors.length >= 2` | PASS/FAIL |
+| useCases | 2 | `specification.useCases.length >= 2` | PASS/FAIL |
+| functionalRequirements | 4 | `specification.functionalRequirements.length >= 4` | PASS/FAIL |
+| permissionMatrix | 1 resource × 2 roles | `specification.permissionMatrix.permissions.length >= 1 && specification.permissionMatrix.roleAssignments.length >= 2` | PASS/FAIL |
+| entities | 1 | `analysis.entities.length >= 1` | PASS/FAIL |
+| entitySchemaFormat | attributes[] not fields[] (BLOCKING) | `analysis.entities.every(e => e.attributes?.length > 0)` | PASS/FAIL |
+| entityAttributeTypes | ALL attributes have `type` field (BLOCKING) | `analysis.entities.every(e => e.attributes.every(a => a.type))` | PASS/FAIL |
+| wireframes | 1 per section (BLOCKING) | `(specification.uiWireframes \|\| specification.wireframes \|\| []).length >= (specification.sections \|\| []).length` (count REAL elements, check BOTH key names) | PASS/FAIL |
+| wireframeSchema | All required fields present (BLOCKING) | `(specification.uiWireframes \|\| specification.wireframes \|\| []).every(w => (w.screen \|\| w.title) && w.section && (w.mockup \|\| w.ascii \|\| w.content))` | PASS/FAIL |
+| sections | 1 (BLOCKING) | `specification.sections.length >= 1` (EVERY module needs at least 1 section) | PASS/FAIL |
+| gherkinScenarios | 1 array entry | `Array.isArray(specification.gherkinScenarios) && specification.gherkinScenarios.length >= 1` | PASS/FAIL |
+| gherkinFormat | Array not object (BLOCKING) | `Array.isArray(specification.gherkinScenarios)` (NOT a single object) | PASS/FAIL |
+| validations | 1 | `specification.validations.length >= 1` | PASS/FAIL |
+| validationFormat | rules[] array (BLOCKING) | `specification.validations.every(v => Array.isArray(v.rules))` (NOT singular `rule`) | PASS/FAIL |
+| messages | 4 | `specification.messages.length >= 4` | PASS/FAIL |
+| messageFormat | `message` field present (BLOCKING) | `specification.messages.every(m => m.message)` | PASS/FAIL |
+| lifeCycles | 1 (if entity has status) | `specification.lifeCycles.length >= 1` (if any entity has status/state field) | PASS/FAIL |
+| seedDataCore | 7 arrays present with content | See detailed check below | PASS/FAIL (BLOCKING) |
+| apiEndpoints | 1 | `specification.apiEndpoints.length >= 1` | PASS/FAIL |
+| i18nKeys | present | `specification.i18nKeys !== undefined && specification.i18nKeys !== null` | PASS/FAIL |
+| navigationIcons | non-null | `specification.seedDataCore.navigationModules.every(m => m.icon !== null)` | PASS/FAIL |
+
+**seedDataCore detailed check (BLOCKING):**
+```javascript
+const sdc = specification.seedDataCore;
+const checks = [
+  { key: "navigationModules",      actual: sdc.navigationModules?.length || 0,      min: 1 },
+  { key: "navigationSections",     actual: sdc.navigationSections?.length || 0,     min: 1 },  // EVERY module needs ≥1 section
+  { key: "navigationResources",    actual: sdc.navigationResources?.length || 0,    min: 1 },
+  { key: "navigationTranslations", actual: sdc.navigationTranslations?.length || 0, min: 2 },  // min fr+en
+  { key: "permissions",            actual: sdc.permissions?.length || 0,            min: 1 },
+  { key: "rolePermissions",        actual: sdc.rolePermissions?.length || 0,        min: 1 },
+  { key: "permissionConstants",    actual: sdc.permissionConstants?.length || 0,    min: 1 }
+];
+const failures = checks.filter(c => c.actual < c.min);
+IF failures.length > 0:
+  BLOCKING ERROR: "seedDataCore incomplete — empty arrays: {failures.map(f => f.key).join(', ')}"
+  → Fix: Ensure specification.sections[] has ≥1 entry, then re-run 8f-bis transform
+```
 
 #### 9b. Consistency Checks
 
@@ -68,9 +97,74 @@ Validate the module specification for completeness and consistency, write to fea
 - Entity names PascalCase
 - Field names camelCase
 - Entity attribute format: `attributes[]` with {name, description}, NOT `fields[]` with {name, type} — entities must NOT have tableName or primaryKey
-- Wireframe structure: `screen` (not `name`), `componentMapping` is array of {wireframeElement, reactComponent} (not plain key-value object), `layout` is object with regions (not string)
+- Wireframe structure: `screen` (not `name`/`title`), `mockup` (not `ascii`/`content`), `componentMapping` is array of {wireframeElement, reactComponent} (not plain key-value object), `layout` is object with regions (not string)
+- Wireframe field naming: uses `screen` (not `title`), `mockup` (not `ascii`) — auto-fix if wrong (see 9c-fix below)
 - Permission paths dot-separated lowercase
 
+#### 9c-fix. Auto-Fix Wireframe Field Names (MANDATORY before writing)
+
+> **CRITICAL:** The agent may use non-canonical field names (`title`, `ascii`, `name`, `content`).
+> These MUST be normalized to canonical names before writing to feature.json.
+
+```javascript
+// AUTO-FIX: Normalize wireframe field names before writing
+const wireframes = specification.uiWireframes || specification.wireframes || [];
+for (const wf of wireframes) {
+  if (wf.title && !wf.screen) { wf.screen = wf.title; delete wf.title; }
+  if (wf.ascii && !wf.mockup) { wf.mockup = wf.ascii; delete wf.ascii; }
+  if (wf.content && !wf.mockup) { wf.mockup = wf.content; delete wf.content; }
+  if (wf.name && !wf.screen) { wf.screen = wf.name; delete wf.name; }
+}
+// Store normalized wireframes back under canonical key
+specification.uiWireframes = wireframes;
+```
+
+#### 9c-fix-entities. Auto-Fix Entity Attribute Types (MANDATORY before writing)
+
+> **DEFENSE-IN-DEPTH:** step-03c POST-CHECK should catch attributes without `type`,
+> but if any slip through to step-03d, auto-fix them here before writing to feature.json.
+> Uses the same type inference algorithm as step-03c POST-CHECK.
+
+```javascript
+// AUTO-FIX: Ensure all entity attributes have structured type
+const entities = analysis.entities || [];
+let entityAutoFixCount = 0;
+for (const entity of entities) {
+  for (const attr of entity.attributes || []) {
+    if (!attr.type) {
+      // Infer type from attribute name pattern
+      if (attr.validation?.match(/max\s*\d+/i) || attr.name.match(/name|title|code|description|label|email|phone|address/i)) {
+        attr.type = "string";
+        const maxMatch = attr.validation?.match(/max\s*(\d+)/i);
+        if (maxMatch) attr.maxLength = parseInt(maxMatch[1]);
+      } else if (attr.name.match(/id$/i)) {
+        attr.type = "Guid";
+      } else if (attr.name.match(/date|At$/i)) {
+        attr.type = "DateTime";
+      } else if (attr.name.match(/is[A-Z]|has[A-Z]|active|enabled/)) {
+        attr.type = "bool";
+      } else if (attr.name.match(/amount|salary|rate|price|total/i)) {
+        attr.type = "decimal";
+      } else if (attr.name.match(/count|number|order|sort|index/i)) {
+        attr.type = "int";
+      } else {
+        attr.type = "string"; // safe default
+      }
+      // Normalize free-text maxLength
+      if (typeof attr.validation === 'string' && !attr.maxLength) {
+        const m = attr.validation.match(/max\s*(\d+)/i);
+        if (m) attr.maxLength = parseInt(m[1]);
+      }
+      if (attr.required === undefined) attr.required = true;
+      entityAutoFixCount++;
+    }
+  }
+}
+if (entityAutoFixCount > 0) {
+  console.warn(`DEFENSE-IN-DEPTH: auto-fixed ${entityAutoFixCount} attributes without type in step-03d`);
+}
+```
+
 #### 9d. Decision
 
 IF validation PASS:
@@ -136,10 +230,10 @@ ba-writer.enrichSection({
 
 **Execute the comprehensive validation checklist:**
 
-Run the 27-check validation process across 10 categories:
+Run the 29-check validation process across 10 categories:
 - Data Model (4 checks) | Business Rules (3 checks) | Use Cases & FRs (4 checks)
 - Permissions (3 checks) | UI & Navigation (4 checks) | I18N & Messages (3 checks)
-- Seed Data (2 checks) | API Endpoints (2 checks) | Validations (1 check) | Gherkin (1 check)
+- Seed Data (2 checks) | API Endpoints (2 checks) | Validations (1 check) | Gherkin (3 checks)
 
 ```javascript
 const blockingFailures = checks.filter(c => c.blocking && c.status === "FAIL");
@@ -214,18 +308,13 @@ Display comprehensive summary:
 
 → Validation: {PASS/FAIL}
 ═══════════════════════════════════════════════════════════
-```
 
-Ask via AskUserQuestion:
+{IF validation PASS}:
+  → Module validé automatiquement
+  → Passage automatique au module suivant (section 12)
 
-```
-question: "Le module {currentModule} est-il correctement spécifié ?"
-header: "Module"
-options:
-  - label: "Validé"
-    description: "Passer au module suivant"
-  - label: "Réviser"
-    description: "Modifier des éléments du module"
+{IF validation FAIL}:
+  → Afficher les erreurs et offrir les options de correction (section 9d)
 ```
 
 ---
@@ -278,6 +367,106 @@ ba-writer.updateStatus({module_feature_id}, "specified")
 ba-writer.updateModuleStatus({feature_id}, {currentModule.code}, "specified")
 ```
 
+#### 11-POST-CHECK: Verify Written Data (BLOCKING)
+
+> **CRITICAL — Data loss prevention.** After writing, READ BACK the module feature.json and verify the following arrays are **non-empty**:
+
+```javascript
+// READ BACK the written feature.json
+const written = ba-reader.read({module_feature_id});
+
+// BLOCKING checks — if ANY fails, the write was incomplete
+const checks = [
+  { key: "specification.actors",          actual: written.specification?.actors?.length,          min: 2 },
+  { key: "specification.useCases",        actual: written.specification?.useCases?.length,        min: 2 },
+  { key: "specification.wireframes",      actual: (written.specification?.uiWireframes?.length || written.specification?.wireframes?.length || 0), min: 1 },
+  { key: "specification.sections",        actual: written.specification?.sections?.length,        min: 1 },
+  { key: "specification.seedDataCore",    actual: Object.keys(written.specification?.seedDataCore || {}).length, min: 7 },
+  { key: "specification.lifeCycles",      actual: written.specification?.lifeCycles?.length,      min: 0 },
+  { key: "specification.gherkinScenarios",actual: written.specification?.gherkinScenarios?.length,min: 1 },
+  { key: "specification.apiEndpoints",    actual: written.specification?.apiEndpoints?.length,    min: 1 }
+];
+
+const failures = checks.filter(c => (c.actual || 0) < c.min);
+
+IF failures.length > 0:
+  BLOCKING ERROR: "Feature.json write INCOMPLETE — missing data in: {failures.map(f => f.key).join(', ')}"
+  → Re-execute section 11 write with ALL specification data
+  → DO NOT proceed to next module until ALL checks pass
+
+// SPECIAL CHECK: wireframes content verification (check BOTH key names)
+const wireframes = written.specification?.uiWireframes || written.specification?.wireframes || [];
+IF wireframes.length > 0:
+  const emptyMockups = wireframes.filter(wf => !wf.mockup && !wf.ascii && !wf.content);
+  IF emptyMockups.length > 0:
+    WARNING: "{emptyMockups.length} wireframes have empty mockup content — verify step-03b data"
+
+// SPECIAL CHECK: wireframes >= sections
+const sectionCount = written.specification?.sections?.length || 0;
+IF wireframes.length < sectionCount:
+  BLOCKING ERROR: "{wireframes.length} wireframes < {sectionCount} sections — wireframes MISSING for some sections"
+  → Re-read wireframes from conversation context and re-write to feature.json
+```
+
+#### 11-POST-CHECK-BASH: Acceptance Criteria Verification (BLOCKING)
+
+> **CRITICAL:** The pseudocode checks above are interpreted by the model — they can be "passed" incorrectly.
+> This bash check reads the REAL file on disk and provides an objective verification.
+> See [references/acceptance-criteria.md](../references/acceptance-criteria.md) for the full acceptance criteria definition.
+
+```bash
+MODULE_JSON="{module_feature_json_path}"
+node -e "
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf-8'));
+const spec = data.specification || {};
+const analysis = data.analysis || {};
+const wf = spec.uiWireframes || spec.wireframes || [];
+const sections = spec.sections || [];
+const checks = [
+  ['entities >= 1',          (analysis.entities||[]).length,          1],
+  ['useCases >= 2',          (spec.useCases||[]).length,              2],
+  ['FRs >= 4',               (spec.functionalRequirements||[]).length,4],
+  ['wireframes >= 1',        wf.length,                               1],
+  ['wireframes >= sections', wf.length,                               sections.length],
+  ['sections >= 1',          sections.length,                          1],
+  ['seedDataCore 7 arrays',  Object.keys(spec.seedDataCore||{}).filter(k=>(spec.seedDataCore||{})[k]&&(spec.seedDataCore||{})[k].length>0).length, 7],
+  ['gherkin is array',       Array.isArray(spec.gherkinScenarios)?1:0, 1],
+  ['apiEndpoints >= 1',      (spec.apiEndpoints||[]).length,           1],
+  ['messages >= 4',          (spec.messages||[]).length,               4],
+  ['validations >= 1',       (spec.validations||[]).length,            1]
+];
+const fails = checks.filter(c => c[1] < c[2]);
+fails.forEach(f => console.error('FAIL: ' + f[0] + ' = ' + f[1] + ' (min: ' + f[2] + ')'));
+// Check wireframe content
+const emptyWf = wf.filter(w => !w.mockup && !w.ascii && !w.content);
+if (emptyWf.length > 0) { fails.push(['wireframe content', 0, 1]); console.error('FAIL: ' + emptyWf.length + ' wireframes have EMPTY content'); }
+// Check entity attribute types
+const badAttrs = (analysis.entities||[]).flatMap(e => (e.attributes||[]).filter(a => !a.type).map(a => e.name+'.'+a.name));
+if (badAttrs.length > 0) { fails.push(['attr.type', 0, 1]); console.error('FAIL: attributes without type: ' + badAttrs.join(', ')); }
+// AC-15: Validation rules format
+const badRules = (spec.validations||[]).filter(v => v.rules && !Array.isArray(v.rules));
+if (badRules.length > 0) { fails.push(['AC-15: rules not array', badRules.length, 0]); console.error('FAIL: AC-15: ' + badRules.length + ' validations have rules as string'); }
+// AC-16: Messages must have message field
+const noMsg = (spec.messages||[]).filter(m => !m.message);
+if (noMsg.length > 0) { fails.push(['AC-16: message missing', noMsg.length, 0]); console.error('FAIL: AC-16: ' + noMsg.length + ' messages missing message field'); }
+// AC-17: Gherkin content structure
+if (Array.isArray(spec.gherkinScenarios)) { const badG = spec.gherkinScenarios.filter(g => !g.feature || !Array.isArray(g.scenarios)); if (badG.length > 0) { fails.push(['AC-17: gherkin content', badG.length, 0]); console.error('FAIL: AC-17: ' + badG.length + ' gherkin entries invalid'); } }
+if (fails.length > 0) { console.error('BLOCKING: ' + fails.length + ' acceptance criteria failed'); process.exit(1); }
+console.log('PASS: All acceptance criteria met');
+" "$MODULE_JSON"
+```
+
+IF this check FAILS:
+- Identify which criteria failed from the output
+- Fix the corresponding data (re-read from conversation context, re-generate, or re-run the step that produces it)
+- Re-write to feature.json
+- Re-run the POST-CHECK until PASS
+
+> **WHY:** Step-03b now writes wireframes intermediately (since fix), but step-03d section 11 does the FULL write.
+> This bash POST-CHECK is the ultimate safety net — it reads the REAL file and verifies ALL acceptance criteria.
+> The pseudocode checks (section 9a) catch issues early; this bash check catches anything the model missed.
+
 ---
 
 ### 11-bis. Deploy Incremental Interactive HTML (MANDATORY)

package/templates/skills/business-analyse/steps/step-05a-handoff.md

@@ -194,16 +194,66 @@ See [references/handoff-file-templates.md](../references/handoff-file-templates.
 |----------|--------|-----------|
 | **4.1 Domain** | `analysis.entities[]` | Entities, ValueObjects, Enums, Exceptions |
 | **4.2 Application** | `analysis.useCases[]` | Services, DTOs, Validators |
-| **4.3 Infrastructure** | `analysis.entities[]` | EF Configurations, DbSet, DI |
+| **4.3 Infrastructure** | `analysis.entities[]` | EF Configurations, DbSet, DI. **DEPENDENCY:** Each EF config task MUST `dependsOn` its corresponding domain entity task. |
 | **4.4 API** | `specification.apiEndpoints[]` | Controllers with `{ContextShort}` mapping |
 | **4.5 Frontend** | `specification.uiWireframes[]` | Pages, Components, Hooks + wireframe traceability |
 | **4.6 SeedData** | `specification.seedDataCore` | 5 CORE + business + IClientSeedDataProvider |
 | **4.7 Tests** | All layers | Unit, Integration, Security tests |
 
+#### Route Convention (CRITICAL)
+
+> **MANDATORY:** All NavigationModule/Section routes MUST use kebab-case transformation.
+> See [references/naming-conventions.md](../references/naming-conventions.md) for complete guide.
+
+**Problem:**
+- Module codes in feature.json are **PascalCase** (e.g., `"HumanResources"`)
+- Routes in seed data MUST be **kebab-case** (e.g., `"/business/human-resources"`)
+- Failing to transform causes 404 when clicking menu items
+
+**Solution:**
+
+When generating `seedDataCore` for handoff, transform PascalCase codes to kebab-case routes:
+
+```javascript
+// Transform module codes to kebab-case routes
+function toKebabCase(code) {
+  return code
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase();
+}
+
+// Example usage in seedDataCore generation
+const moduleCode = "TimeManagement";     // PascalCase (C#)
+const appCode = "HumanResources";       // PascalCase (C#)
+const contextCode = "business";         // lowercase
+
+const route = `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+// Result: "/business/human-resources/time-management"
+```
+
+**Include in task instructions:**
+
+For NavigationSeedData tasks in `handoff.filesToCreate`, add:
+
+```json
+{
+  "path": "Infrastructure/Persistence/Seeding/Data/{Module}/NavigationSeedData.cs",
+  "type": "SeedData",
+  "category": "core",
+  "instructions": "Generate NavigationModule seed data. CRITICAL: Use ToKebabCase() helper for Route property. Example: Route = ToKebabCase($\"/{context}/{app}/{module}\"). See core-seed-data.md template."
+}
+```
+
+**Validation:**
+- ralph-loop POST-CHECK validates routes after generation (see step-02-execute.md)
+- MCP `validate_frontend_routes` detects case mismatches
+- Convention documented in naming-conventions.md
+
 **Critical rules:**
 - All backend paths include `{ContextPascal}/{ApplicationName}/` hierarchy
 - Frontend pages MUST have `linkedWireframes[]` + `wireframeAcceptanceCriteria`
 - SeedData: 5 CORE entries ALWAYS + IClientSeedDataProvider for client projects
+- **Acceptance Criteria Mapping:** Each task's `acceptanceCriteria` MUST be derived from its own `linkedFRs[]` entries (lookup FR → `acceptanceCriteria`). NEVER map by sequential FR index — use the task's explicit linkedFRs to resolve the correct criteria.
 - Path convention: `Persistence/Seeding/Data/` (NEVER `Data/SeedData/`)
 
 ---
@@ -228,6 +278,52 @@ For each endpoint: operation, method, route, linkedUC, linkedFR, permissions, re
 
 Total endpoints = count of specification.apiEndpoints[] across all modules.
 
+### 6b. Frontend Task Splitting (MANDATORY)
+
+> **CRITICAL:** Frontend MUST be split into discrete tasks, NOT bundled as a single mega-task.
+> A single mega-task covering 5-8 files prevents granular error recovery in ralph-loop.
+
+For each module, generate these SEPARATE frontend file entries (not one monolithic entry):
+
+```json
+"frontend": [
+  { "path": "src/pages/{Mod}/{ListPage}Page.tsx", "type": "Page", "linkedWireframes": ["{module}-list"], "module": "{moduleCode}" },
+  { "path": "src/pages/{Mod}/{DetailPage}Page.tsx", "type": "Page", "linkedWireframes": ["{module}-detail"], "module": "{moduleCode}" },
+  { "path": "src/hooks/use{Module}.ts", "type": "Hook", "module": "{moduleCode}" },
+  { "path": "src/i18n/{module}.json", "type": "I18n", "module": "{moduleCode}" }
+]
+```
+
+Additional per-section pages (dashboard, import, etc.) are separate entries.
+
+**Route wiring task (MANDATORY — separate entry):**
+```json
+{ "path": "src/App.tsx", "type": "RouteWiring", "module": "{moduleCode}", "description": "Wire {module} routes into App.tsx (detect pattern: contextRoutes array OR JSX Route wrappers). BLOCKING: pages without route wiring = blank pages." }
+```
+
+### 6c. Cross-Module PRD (MANDATORY for multi-module features)
+
+> **CRITICAL:** Cross-module integration tasks MUST exist in a dedicated PRD file.
+> Without this, ralph-loop will NOT execute E2E tests or FK validation.
+
+Generate `.ralph/prd-CrossModule.json` with:
+```json
+{
+  "$version": "3.0.0",
+  "implementation": {
+    "filesToCreate": {
+      "tests": [
+        { "path": "src/Tests/Integration/CrossModule/ForeignKeyValidationTests.cs", "type": "IntegrationTests", "module": "CrossModule" },
+        { "path": "src/Tests/Integration/CrossModule/PermissionMatrixTests.cs", "type": "SecurityTests", "module": "CrossModule" },
+        { "path": "src/Tests/Integration/CrossModule/E2EFlowTests.cs", "type": "E2ETests", "module": "CrossModule" }
+      ]
+    }
+  }
+}
+```
+
+Add to progress.txt after all module tasks.
+
 ---
 
 ### 7. Write Handoff to Feature.json
@@ -312,12 +408,48 @@ Total endpoints = count of specification.apiEndpoints[] across all modules.
 ```
 // Derive seedDataCore from modules[], applicationRoles[], and coverageMatrix[]
 
+// Helper: PascalCase → "Human Readable" (e.g., "HumanResources" → "Human Resources")
+function toHumanReadable(pascalCase) {
+  return pascalCase
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+}
+
+const contextCode = master.metadata.context || "business";
+const appCode = master.metadata.application;
+const appLabel = toHumanReadable(appCode);
+const appDesc = master.cadrage?.problem?.split('.')[0] || `Gestion ${appLabel}`;
+const lang = master.metadata.language || "fr";
+
 const seedDataCore = {
+  // Application-level navigation (MANDATORY — one entry per application)
+  navigationApplications: [{
+    code: appCode.toLowerCase(),
+    name: appCode,
+    labels: {
+      fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+      en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+      it: appLabel,
+      de: appLabel
+    },
+    description: {
+      fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
+      en: lang === "en" ? appDesc : `${appLabel} management`,
+      it: `Gestione ${appLabel}`,
+      de: `${appLabel} Verwaltung`
+    },
+    icon: inferIconFromApplication(master) || "layout-grid",
+    iconType: "lucide",
+    context: contextCode,
+    route: `/${contextCode}/${toKebabCase(appCode)}`,
+    displayOrder: 1
+  }],
+
   navigationModules: master.modules.map((m, i) => ({
     code: m.code,
     label: m.name || m.code,
     description: m.description,
-    icon: null,  // set by ralph-loop
+    icon: inferIconFromModule(m) || "folder",  // MUST be non-null — use sensible default
     iconType: "lucide",
     route: `/business/${master.metadata.application.toLowerCase()}/${m.code.toLowerCase()}`,
     displayOrder: (i + 1) * 10
@@ -386,6 +518,49 @@ const seedDataCore = {
   )
 };
 
+// Icon inference for APPLICATION level (NEVER leave as null)
+function inferIconFromApplication(master) {
+  const appLC = (master.metadata.application || '').toLowerCase();
+  const iconMap = {
+    'humanresource': 'users', 'rh': 'users', 'hr': 'users', 'personnel': 'users',
+    'sales': 'shopping-cart', 'vente': 'shopping-cart', 'commerce': 'shopping-cart',
+    'finance': 'wallet', 'comptabilite': 'calculator', 'accounting': 'calculator',
+    'inventory': 'warehouse', 'stock': 'package', 'logistic': 'truck',
+    'crm': 'building-2', 'customer': 'building', 'client': 'building-2',
+    'project': 'folder-kanban', 'task': 'check-square', 'gestion': 'layout-grid',
+    'admin': 'shield', 'support': 'headphones', 'maintenance': 'wrench',
+    'production': 'factory', 'quality': 'badge-check', 'document': 'file-text',
+    'fleet': 'car', 'vehicle': 'car', 'transport': 'truck',
+    'education': 'graduation-cap', 'formation': 'graduation-cap', 'training': 'graduation-cap'
+  };
+  for (const [keyword, icon] of Object.entries(iconMap)) {
+    if (appLC.includes(keyword)) return icon;
+  }
+  return "layout-grid";  // fallback — NEVER null
+}
+
+// Icon inference from module context (NEVER leave as null)
+function inferIconFromModule(module) {
+  const codeLC = module.code.toLowerCase();
+  const iconMap = {
+    'employee': 'users', 'staff': 'users', 'personnel': 'users', 'user': 'users',
+    'project': 'folder-kanban', 'task': 'check-square', 'work': 'briefcase',
+    'time': 'clock', 'schedule': 'calendar', 'planning': 'calendar-days',
+    'absence': 'calendar-off', 'leave': 'calendar-off', 'vacation': 'palm-tree',
+    'finance': 'wallet', 'billing': 'receipt', 'invoice': 'file-text',
+    'inventory': 'warehouse', 'stock': 'package', 'product': 'shopping-bag',
+    'customer': 'building', 'client': 'building-2', 'contact': 'contact',
+    'report': 'bar-chart', 'dashboard': 'layout-dashboard', 'analytics': 'trending-up',
+    'document': 'file-text', 'notification': 'bell', 'setting': 'settings',
+    'order': 'shopping-cart', 'vehicle': 'car', 'maintenance': 'wrench',
+    'audit': 'shield-check', 'workflow': 'git-branch', 'approval': 'check-circle'
+  };
+  for (const [keyword, icon] of Object.entries(iconMap)) {
+    if (codeLC.includes(keyword)) return icon;
+  }
+  return "folder";  // fallback — NEVER null
+}
+
 ba-writer.enrichSection({
   featureId: {feature_id},
   section: "seedDataCore",
@@ -393,12 +568,23 @@ ba-writer.enrichSection({
 })
 ```
 
-**POST-CHECK (non-blocking):**
+**POST-CHECK (BLOCKING for icons/application, warning for counts):**
 ```
+IF !seedDataCore.navigationApplications || seedDataCore.navigationApplications.length === 0:
+  BLOCKING ERROR: "navigationApplications is empty — Application navigation will NOT be seeded. Menu will show Context → (nothing) → Modules."
+IF seedDataCore.navigationApplications[0].icon === null || seedDataCore.navigationApplications[0].icon === undefined:
+  BLOCKING ERROR: "Application icon is null — ralph-loop will render empty navigation"
+IF !seedDataCore.navigationApplications[0].labels?.fr || !seedDataCore.navigationApplications[0].labels?.en:
+  BLOCKING ERROR: "Application labels missing fr/en — translations will fail"
 IF seedDataCore.navigationModules.length !== master.modules.length:
   WARNING: seedDataCore has ${seedDataCore.navigationModules.length} nav modules but ${master.modules.length} modules exist
 IF seedDataCore.permissions.length === 0:
   WARNING: seedDataCore has 0 permissions — applicationRoles may be missing
+IF seedDataCore.navigationModules.some(m => !m.icon || m.icon === null):
+  BLOCKING ERROR: "Navigation modules with null icons detected — ralph-loop will render empty navigation"
+  → Fix: Re-run inferIconFromModule() for modules with null icons
+IF seedDataCore.navigationSections.length === 0:
+  WARNING: "0 navigation sections — every module should have at least 1 section (e.g., 'list')"
 ```
 
 #### 7c. Master Handoff (after ALL modules written + seedDataCore generated)

package/templates/skills/business-analyse/steps/step-05b-deploy.md

@@ -238,6 +238,34 @@ See [references/deploy-data-build.md](../references/deploy-data-build.md) for:
 
 ---
 
+### 7-bis. Generate SVG Wireframes (Parallel Enrichment)
+
+> **After EMBEDDED_ARTIFACTS is built (sections 5-7) but BEFORE writing the HTML (section 8).**
+> This step enriches each ASCII wireframe with a professional SVG version for dual-view rendering.
+
+See [references/wireframe-svg-style-guide.md](../references/wireframe-svg-style-guide.md) for the complete SVG style specification, prompt template, and orchestration process.
+
+**Process summary:**
+
+1. **Read** `references/wireframe-svg-style-guide.md` to get the prompt template
+2. **Collect** all wireframes across ALL modules in `EMBEDDED_ARTIFACTS.wireframes` where `content` exists and `svgContent` is null
+3. **Spawn parallel Task(sonnet) agents** — ONE per wireframe, ALL in a single message
+4. **Collect and validate** results: strip markdown fences if present, verify SVG starts with `<svg` and contains `</svg>`
+5. **Inject** valid SVGs into `EMBEDDED_ARTIFACTS.wireframes[moduleCode][index].svgContent`
+6. **Display summary:**
+   ```
+   SVG wireframe generation:
+     Total wireframes: {total}
+     SVG generated: {successCount}/{total}
+     Fallback (ASCII only): {failCount}/{total}
+   ```
+
+> **CRITICAL:** This step is NEVER blocking. If all SVG generations fail, deployment
+> continues with ASCII-only wireframes. The HTML renderer checks for `svgContent` before
+> showing the SVG view. SVG is an enhancement, not a requirement.
+
+---
+
 ### 8. Write and Verify
 
 1. Write the populated HTML to the output directory: `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`
@@ -357,6 +385,33 @@ After writing the HTML file, verify:
      BLOCKING_ERROR("Module mismatch: expected [${expectedModules}] but wireframes has [${wireframeModules}]")
    ```
 
+9. **MODULE DATA COMPLETENESS** — every module in FEATURE_DATA.modules[] must carry ALL fields from feature.json
+   ```
+   FOR each htmlModule in FEATURE_DATA.modules[]:
+     masterModule = master.modules.find(m => m.code === htmlModule.code)
+
+     // name MUST be display name, NOT code
+     IF htmlModule.name === htmlModule.code AND masterModule.name !== masterModule.code:
+       BLOCKING_ERROR("Module '${htmlModule.code}' has name === code. Expected: '${masterModule.name}'")
+
+     // anticipatedSections MUST be present (drives Structure tab + navigation tree)
+     IF masterModule.anticipatedSections?.length > 0 AND (!htmlModule.anticipatedSections OR htmlModule.anticipatedSections.length === 0):
+       BLOCKING_ERROR("Module '${htmlModule.code}' lost anticipatedSections: master has ${masterModule.anticipatedSections.length}, HTML has 0")
+       → FIX: Copy anticipatedSections from master.modules[].anticipatedSections
+
+     // dependencies/dependents MUST be present (drives dependency graph)
+     IF masterModule.dependencies?.length > 0 AND (!htmlModule.dependencies OR htmlModule.dependencies.length === 0):
+       BLOCKING_ERROR("Module '${htmlModule.code}' lost dependencies array")
+   ```
+
+   Display verification table:
+   ```
+   POST-CHECK: Module data completeness
+   | Module         | name    | sections | deps | wireframes | specs | Match |
+   |----------------|---------|----------|------|------------|-------|-------|
+   | {code}         | {name}  | {n}      | {n}  | {n}        | OK    | OK/FAIL |
+   ```
+
 **IF ANY CHECK FAILS → DO NOT PROCEED. Fix the data mapping and regenerate.**
 
 ---

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

@@ -304,7 +304,9 @@ fi
 **Execution sequence (IN ORDER):**
 1. `mcp__smartstack__scaffold_api_client` → API client + types + React Query hook
 2. `mcp__smartstack__scaffold_routes` (with `outputFormat: "clientRoutes"`) → route registry + route fragments
-3. **Wire routes to App.tsx** → insert `<Route>` entries inside correct Layout wrapper (BOTH standard AND tenant-prefixed `/t/:slug/...` blocks)
+3. **Wire routes to App.tsx (detect pattern: `contextRoutes` array OR JSX `<Route>`):**
+   - **Pattern A** (`contextRoutes: ContextRouteExtensions` in App.tsx): add to `contextRoutes.{context}[]` with RELATIVE paths → auto-injected into both standard + tenant trees
+   - **Pattern B** (JSX `<Route>` in App.tsx): insert `<Route>` entries inside correct Layout wrapper (BOTH standard AND tenant-prefixed `/t/:slug/...` blocks)
 4. Create pages using SmartStack components
 5. Create preferences hook: `use{Module}Preferences.ts`
 6. Generate i18n (4 languages: fr, en, it, de)
@@ -348,7 +350,8 @@ import axios from 'axios'                    → use @/services/api/apiClient
 Only fr/en translations                      → MUST have 4 languages
 src/pages/{Module}/                          → MUST be src/pages/{Context}/{App}/{Module}/
 Routes generated but NOT added to App.tsx    → MUST wire routes to App.tsx after scaffold_routes
-Routes in standard block only               → MUST also add to /t/:slug/ tenant block
+Routes in standard block only               → MUST also add to /t/:slug/ tenant block (Pattern B only; Pattern A auto-handles)
+Adding routes to clientRoutes[] instead of contextRoutes.{context}[] → MUST use contextRoutes for business/platform/personal routes
 '00000000-0000-0000-0000-000000000000'       → use dynamic ID from auth context or route params
 const api = axios.create(...)                → use @/services/api/apiClient (single instance)
 useXxx with raw axios inside hooks           → hooks MUST use the shared apiClient from @/services/api