@atlashub/smartstack-cli 4.50.0 → 4.52.0

package/templates/skills/business-analyse-handoff/references/entity-canonicalization.md

@@ -0,0 +1,158 @@
+# Entity Name Canonicalization
+
+> **Used by:** step-01-transform (section 2: file mapping) and step-02-export (POST-CHECK)
+> **Purpose:** Convert BA entity names (potentially French, with spaces/apostrophes/accents) into valid C# identifiers for file paths.
+
+---
+
+## Why This Exists
+
+Business analysts write entity names in the user's language (e.g., French: "Type d'absence", "Employé", "Congé maladie"). These names are used as-is in `entities.json`. However, C# file paths and class names **MUST** be valid identifiers:
+- No spaces
+- No apostrophes
+- No accents (diacritics)
+- PascalCase convention
+
+Without canonicalization, the handoff generates paths like `src/Domain/Entities/Type d'absence.cs` → build failure (CS1001).
+
+---
+
+## Canonicalization Rules
+
+### Step 1: Map to English PascalCase (PREFERRED)
+
+If the BA provides an explicit `codeIdentifier` or `englishName` field on the entity, use it directly.
+
+### Step 2: Strip Diacritics
+
+Remove accents from characters:
+
+| Input | Output |
+|-------|--------|
+| é, è, ê, ë | e |
+| à, â, ä | a |
+| ù, û, ü | u |
+| ô, ö | o |
+| î, ï | i |
+| ç | c |
+
+Example: `Employé` → `Employe`, `Congé` → `Conge`
+
+### Step 3: Remove Apostrophes and Split on Spaces
+
+Split the name on spaces, apostrophes, hyphens, and underscores:
+
+| Input | Tokens |
+|-------|--------|
+| `Type d'absence` | `["Type", "d", "absence"]` |
+| `Congé maladie` | `["Conge", "maladie"]` |
+| `Mise à jour` | `["Mise", "a", "jour"]` |
+
+### Step 4: Remove Articles and Prepositions (1-2 letter tokens)
+
+Remove French articles and prepositions that don't contribute to the identifier:
+
+**Remove:** `d`, `de`, `du`, `l`, `la`, `le`, `les`, `un`, `une`, `des`, `a`, `au`, `aux`, `en`
+
+| Input Tokens | Filtered |
+|-------------|----------|
+| `["Type", "d", "absence"]` | `["Type", "absence"]` |
+| `["Mise", "a", "jour"]` | `["Mise", "jour"]` |
+
+### Step 5: PascalCase Assembly
+
+Capitalize first letter of each remaining token, join without separator:
+
+| Filtered Tokens | Result |
+|----------------|--------|
+| `["Type", "absence"]` | `TypeAbsence` |
+| `["Conge", "maladie"]` | `CongeMaladie` |
+| `["Mise", "jour"]` | `MiseJour` |
+| `["Employe"]` | `Employe` |
+
+---
+
+## Canonicalization Function (Pseudocode)
+
+```javascript
+function canonicalizeEntityName(baName) {
+  // Step 1: Use explicit code identifier if available
+  // (handled by caller — check entity.codeIdentifier || entity.englishName first)
+
+  // Step 2: Strip diacritics
+  let name = baName.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+  // Step 3: Split on non-alphanumeric
+  let tokens = name.split(/[\s'\-_]+/).filter(t => t.length > 0);
+
+  // Step 4: Remove French articles/prepositions
+  const stopWords = new Set(['d', 'de', 'du', 'l', 'la', 'le', 'les', 'un', 'une', 'des', 'a', 'au', 'aux', 'en']);
+  tokens = tokens.filter(t => !stopWords.has(t.toLowerCase()));
+
+  // Step 5: PascalCase
+  return tokens.map(t => t.charAt(0).toUpperCase() + t.slice(1).toLowerCase()).join('');
+}
+```
+
+---
+
+## Validation: Is Valid C# Identifier?
+
+After canonicalization, verify the result is a valid C# identifier:
+
+```javascript
+function isValidCSharpIdentifier(name) {
+  // Must start with letter or underscore
+  // Must contain only letters, digits, underscores
+  // Must not be a C# keyword
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)
+    && !CSHARP_KEYWORDS.has(name);
+}
+
+const CSHARP_KEYWORDS = new Set([
+  'abstract', 'as', 'base', 'bool', 'break', 'byte', 'case', 'catch',
+  'char', 'checked', 'class', 'const', 'continue', 'decimal', 'default',
+  'delegate', 'do', 'double', 'else', 'enum', 'event', 'explicit',
+  'extern', 'false', 'finally', 'fixed', 'float', 'for', 'foreach',
+  'goto', 'if', 'implicit', 'in', 'int', 'interface', 'internal',
+  'is', 'lock', 'long', 'namespace', 'new', 'null', 'object',
+  'operator', 'out', 'override', 'params', 'private', 'protected',
+  'public', 'readonly', 'ref', 'return', 'sbyte', 'sealed', 'short',
+  'sizeof', 'stackalloc', 'static', 'string', 'struct', 'switch',
+  'this', 'throw', 'true', 'try', 'typeof', 'uint', 'ulong',
+  'unchecked', 'unsafe', 'ushort', 'using', 'virtual', 'void',
+  'volatile', 'while'
+]);
+```
+
+---
+
+## Examples
+
+| BA Entity Name (French) | Canonicalized | File Path |
+|-------------------------|---------------|-----------|
+| `Type d'absence` | `TypeAbsence` | `src/Domain/Entities/App/Module/TypeAbsence.cs` |
+| `Employé` | `Employe` | `src/Domain/Entities/App/Module/Employe.cs` |
+| `Congé maladie` | `CongeMaladie` | `src/Domain/Entities/App/Module/CongeMaladie.cs` |
+| `Mise à jour` | `MiseJour` | `src/Domain/Entities/App/Module/MiseJour.cs` |
+| `Département` | `Departement` | `src/Domain/Entities/App/Module/Departement.cs` |
+| `Employee` | `Employee` | `src/Domain/Entities/App/Module/Employee.cs` (no change) |
+| `AbsenceType` | `AbsenceType` | `src/Domain/Entities/App/Module/AbsenceType.cs` (no change) |
+
+---
+
+## Integration Points
+
+1. **step-01-transform.md**: Apply `canonicalizeEntityName()` to ALL entity names BEFORE generating `filesToCreate` paths
+2. **step-02-export.md**: POST-CHECK validates all paths in `filesToCreate` are valid C# identifiers
+3. **entity-domain-mapping.md**: `{EntityName}` in path templates refers to the CANONICALIZED name
+4. **handoff-file-templates.md**: All `{EntityName}` placeholders use canonicalized names
+
+## Anti-Patterns
+
+| Anti-Pattern | Risk | Correct Approach |
+|-------------|------|-----------------|
+| Translate to English semantically | `MiseJour` → `Update`? No — loses domain meaning | Only strip illegal chars, keep semantics |
+| Remove all short words | `TypeAbsence` missing `Type`? | Only remove articles/prepositions, not nouns |
+| Lowercase everything | `typeabsence` is not PascalCase | PascalCase each token |
+| Skip validation | `Task` is a valid name but also a C# type | Warn on namespace conflicts, don't block |

package/templates/skills/business-analyse-handoff/steps/step-01-transform.md

@@ -19,6 +19,7 @@ next_step: steps/step-02-export.md
 - **NEVER** invent entities/BRs not in module JSON files
 - **NEVER** load all module data in the main conversation (causes context overflow on 5+ modules)
 - **ALWAYS** generate API endpoints from use cases + entities (BA does not produce apiEndpoints)
+- **ALWAYS** canonicalize entity names before generating file paths — see `references/entity-canonicalization.md`
 
 ## YOUR TASK
 
@@ -96,6 +97,19 @@ Then build the handoff data following these rules:
 ### Section UC/BR Enrichment
 Using sectionCode from usecases.json and rules.json, link each UC and BR to its section.
 
+### Entity Name Canonicalization (MANDATORY)
+Before generating any file paths, canonicalize ALL entity names from `entities.json`:
+1. Read `references/entity-canonicalization.md` for complete rules
+2. For each entity in `entities.json > entities[]`:
+   - If entity has `codeIdentifier` or `englishName` → use it directly
+   - Otherwise → apply canonicalization: strip diacritics, remove apostrophes/spaces, remove French articles (d, de, du, l, la, le, les, un, une, des, a, au, aux, en), PascalCase
+3. Use the CANONICALIZED name in ALL file path templates (`{EntityName}`, `{ServiceName}`, `{DtoName}`, etc.)
+4. Store the mapping `{ originalName: "Type d'absence", canonicalName: "TypeAbsence" }` in handoff metadata for traceability
+
+**Example:** Entity `"Type d'absence"` → canonicalized to `"TypeAbsence"` → path `src/Domain/Entities/App/Module/TypeAbsence.cs`
+
+**BLOCKING:** If ANY entity name after canonicalization is not a valid C# identifier (`/^[A-Za-z_][A-Za-z0-9_]*$/`), STOP and report the error.
+
 ### File Mapping (8 Categories)
 Read `references/handoff-file-templates.md` for complete JSON templates.
 All backend paths MUST include {ApplicationName}/ hierarchy.

package/templates/skills/business-analyse-handoff/steps/step-02-export.md

@@ -111,6 +111,20 @@ for (const key of specKeys) {
     BLOCKING_ERROR(`Companion file empty or too small: ${companionPath} (${companionSize} bytes)`);
   }
 }
+
+// Check 6: File paths must be valid C# identifiers (no spaces, apostrophes, accents)
+// Reference: references/entity-canonicalization.md
+for (const [cat, files] of Object.entries(ftc)) {
+  for (const file of (files || [])) {
+    const filePath = file.path || file;
+    // Extract filename without extension
+    const fileName = filePath.split('/').pop().replace(/\.(cs|tsx|ts|json)$/, '');
+    // Check for illegal characters in C# file names
+    if (/[\s'àâäéèêëïîôùûüçÀÂÄÉÈÊËÏÎÔÙÛÜÇ]/.test(fileName)) {
+      BLOCKING_ERROR(`${cat}: File path contains illegal characters for C# identifier: "${filePath}" — entity name must be canonicalized (see references/entity-canonicalization.md)`);
+    }
+  }
+}
 ```
 
 Display verification table showing all 8 categories match between module JSON files and prd.json.

package/templates/skills/business-analyse-html/SKILL.md

@@ -42,9 +42,13 @@ Generate the interactive HTML document of the business analysis from the JSON an
 
 - **NEVER** deploy an empty template — FEATURE_DATA must be injected
 - **moduleSpecs** MUST have ONE entry per module (empty = BROKEN)
+- **moduleSpecs[].screens[]** MUST have populated resources when source screens.json has data (empty resources = NO HTML mockups)
 - **Scope keys** MUST be converted: `inScope` → `inscope`, `outOfScope` → `outofscope`
 - **Wireframe fields** MUST be renamed: `mockupFormat` → `format`, `mockup` → `content`
+- **Input normalization** MUST handle both JSON schemas: Format A (`screens[]`, `useCases`, `mainScenario`) and Format B (`sections[]`, `usecases`, `steps[]` as objects)
+- **NEVER** call `.join()` on arrays without checking element types — object elements produce `[object Object]`
 - **Final file** MUST be > 100KB
+- **Final file** MUST NOT contain the string `[object Object]`
 
 ## References
 

package/templates/skills/business-analyse-html/html/ba-interactive.html

@@ -2394,6 +2394,13 @@ let data = {{FEATURE_DATA}};
 const ORIGINAL_DATA = JSON.parse(JSON.stringify(data));
 const EMBEDDED_ARTIFACTS = {{EMBEDDED_ARTIFACTS}};
 
+// CRITICAL: Initialize top-level structures FIRST to prevent TypeError crashes
+data.cadrage = data.cadrage || {};
+data.modules = data.modules || [];
+data.dependencies = data.dependencies || [];
+data.handoff = data.handoff || {};
+data.cadrage.stakeholders = data.cadrage.stakeholders || [];
+
 // Initialize applications array (multi-app support)
 data.applications = data.applications || [];
 

package/templates/skills/business-analyse-html/html/src/scripts/01-data-init.js

@@ -6,6 +6,13 @@ let data = {{FEATURE_DATA}};
 const ORIGINAL_DATA = JSON.parse(JSON.stringify(data));
 const EMBEDDED_ARTIFACTS = {{EMBEDDED_ARTIFACTS}};
 
+// CRITICAL: Initialize top-level structures FIRST to prevent TypeError crashes
+data.cadrage = data.cadrage || {};
+data.modules = data.modules || [];
+data.dependencies = data.dependencies || [];
+data.handoff = data.handoff || {};
+data.cadrage.stakeholders = data.cadrage.stakeholders || [];
+
 // Initialize applications array (multi-app support)
 data.applications = data.applications || [];
 

package/templates/skills/business-analyse-html/references/data-build.md

@@ -64,8 +64,14 @@ const FEATURE_DATA = {
     // FLAT-FILE: Data comes from collected_data.modules[moduleCode] (flat files), NOT module index.json
     "{moduleCode}": {
       // const mod = collected_data.modules[moduleCode];
-      useCases: mod.usecases?.useCases || [],
-      businessRules: mod.rules?.rules || [],
+      // NORMALIZE: handle both key conventions (useCases/usecases, rules/businessRules)
+      useCases: (mod.usecases?.useCases || mod.usecases?.usecases || []).map(uc => ({
+        // Handle both "name"/"title"/"id" and "primaryActor"/"actor" conventions
+        // Handle steps as strings (mainScenario) or objects ({step, action})
+      })),
+      businessRules: (mod.rules?.rules || mod.rules?.businessRules || []).map(br => ({
+        // Handle both "name"/"id" and "statement"/"description" conventions
+      })),
       // ENTITY SAFETY NET: map fields[] → attributes[] if agent deviated from canonical format
       entities: (mod.entities?.entities || []).map(ent => ({
         name: ent.name,
@@ -124,26 +130,27 @@ const FEATURE_DATA = {
 const EMBEDDED_ARTIFACTS = {
   wireframes: {
     // PER-MODULE keyed object (NOT a flat array)
-    // FLAT-FILE: Read from screens.json in each module directory (collected in step-01)
+    // TWO SOURCE FORMATS: screens.json may use screens[] (Format A) or sections[] (Format B)
     // const mod = collected_data.modules[moduleCode];
-    // const screens = mod.screens?.screens || [];
-    [moduleCode]: screens
-      .filter(s => s.wireframe || s.mockup || s.mockupFormat)
-      .map(wf => ({
-      screen: wf.screen || wf.name || wf.title || wf.id || "",  // SAFETY NET: fallback name/title/id → screen
-      section: wf.section || "",                      // e.g. "list"
-      format: wf.mockupFormat || "ascii",             // RENAME: mockupFormat → format
-      content: wf.mockup || wf.ascii || wf.content || "",  // SAFETY NET: mockup/ascii/content → content
-      svgContent: null,                              // Populated by SVG generation step (see wireframe-svg-style-guide.md)
+    // Collect from ALL sources:
+    //   Source A: mod.screens.screens[] with mockup/mockupFormat (flat format)
+    //   Source B1: mod.screens.sections[].wireframe (section-level wireframe)
+    //   Source B2: mod.screens.sections[].resources[].wireframe (resource-level wireframe)
+    //   Source C: auto-generated text for screens/sections without wireframe
+    [moduleCode]: rawWireframes.map(wf => ({
+      screen: wf.screen || wf.name || wf.title || wf.id || "",
+      section: wf.section || "",
+      format: wf.mockupFormat || wf.format || "ascii",    // RENAME: mockupFormat → format
+      content: wf.mockup || wf.ascii || wf.content || "", // SAFETY NET: mockup/ascii/content → content
+      svgContent: null,                              // Populated by SVG generation step
       description: wf.description || "",
-      elements: wf.elements || [],                    // [{ id, type, label }] or ["DataGrid", ...]
-      actions: wf.actions || [],                      // [{ trigger, action }] or ["filter", ...]
-      // SAFETY NET: convert object → array format if agent used { "Header": "PageHeader" } instead of [{ wireframeElement, reactComponent }]
+      elements: wf.elements || [],
+      actions: wf.actions || [],
       componentMapping: Array.isArray(wf.componentMapping) ? wf.componentMapping
         : typeof wf.componentMapping === 'object' && wf.componentMapping !== null
           ? Object.entries(wf.componentMapping).map(([k, v]) => ({ wireframeElement: k, reactComponent: v }))
           : [],
-      layout: typeof wf.layout === 'object' ? wf.layout : null,  // SAFETY NET: ignore string layout ("grid")
+      layout: typeof wf.layout === 'object' ? wf.layout : null,
       permissionsRequired: wf.permissionsRequired || []
     }))
   },
@@ -167,7 +174,7 @@ const EMBEDDED_ARTIFACTS = {
 
 ### Artifact Gathering
 
-1. For EACH module: read `screens.json` flat file from `collected_data.modules[moduleCode].screens`, filter screens with wireframe data, **rename fields** (`mockupFormat`→`format`, `mockup`/`ascii`/`content`→`content`, `screen`/`name`/`title`→`screen`), store under `wireframes[moduleCode]`
+1. For EACH module: read `screens.json` from `collected_data.modules[moduleCode].screens`. **Detect format:** if `screens[]` exists → Format A (flat). If `sections[]` exists → Format B (nested). Collect wireframes from all sources (A: screen.mockup, B1: section.wireframe, B2: section.resources[].wireframe, C: auto-text). **Rename fields** (`mockupFormat`→`format`, `mockup`/`ascii`/`content`→`content`). Store under `wireframes[moduleCode]`
 2. Read master's `consolidation.e2eFlows[]` and build e2eFlows array with diagram generation
 3. Read master's `dependencyGraph` and build nodes/edges
 4. Serialize as JSON with 2-space indentation

package/templates/skills/business-analyse-html/references/data-mapping.md

@@ -99,36 +99,52 @@ For EACH module in `master.modules[]`:
 2. Data sources: `entities.json`, `rules.json`, `usecases.json`, `permissions.json`, `screens.json`
 3. Do NOT read from `moduleIndex.specification` or `moduleIndex.analysis` — these don't exist in flat-file format
 
+> **TWO INPUT FORMATS:** The `/business-analyse` skill may produce JSON in two schema conventions.
+> You MUST normalize both to the same output format. The mapping below shows both variants.
+
 ```javascript
 const mod = collected_data.modules[moduleCode];
 
+// NORMALIZE: usecases.json key may be "useCases" (camelCase) or "usecases" (lowercase)
+const rawUCs = mod.usecases?.useCases || mod.usecases?.usecases || [];
+// NORMALIZE: rules.json key may be "rules" or "businessRules"
+const rawBRs = mod.rules?.rules || mod.rules?.businessRules || [];
+
 moduleSpecs[moduleCode] = {
-  useCases: (mod.usecases?.useCases || []).map(uc => ({
-    name: uc.name,
-    sectionCode: uc.sectionCode || "",                  // links UC to anticipatedSections[].code
-    actor: uc.primaryActor,
-    steps: (uc.mainScenario || []).join("\n"),           // array → newline-separated string
-    alternative: (uc.alternativeScenarios || [])
-      .map(a => a.name + ": " + (a.steps || []).join(", ")).join("\n")
+  useCases: rawUCs.map(uc => ({
+    name: uc.name || uc.title || uc.id || "",            // Format A: "name", Format B: "title" or "id"
+    sectionCode: uc.sectionCode || "",
+    actor: uc.primaryActor || uc.actor || "",             // Format A: "primaryActor", Format B: "actor"
+    // SAFETY NET: steps may be string[] or object[] ({step, action})
+    steps: (uc.mainScenario || uc.steps || []).map(s =>
+      typeof s === 'string' ? s : (s.action || s.description || "")
+    ).join("\n"),
+    alternative: (uc.alternativeScenarios || uc.alternativeFlows || []).map(a =>
+      (a.name || a.trigger || "") + ": " + (a.steps || a.actions || []).map(s =>
+        typeof s === 'string' ? s : (s.action || s.description || "")
+      ).join(", ")
+    ).join("\n")
   })),
-  businessRules: (mod.rules?.rules || []).map(br => ({
-    name: br.name,
-    sectionCode: br.sectionCode || "",                  // links BR to anticipatedSections[].code
-    category: br.category,                              // "validation"|"calculation"|"workflow"|"security"|"data"
-    statement: br.statement,
-    example: (br.examples || []).map(e => e.input + " → " + e.expected).join("; ")
+  businessRules: rawBRs.map(br => ({
+    name: br.name || br.id || "",
+    sectionCode: br.sectionCode || "",
+    category: br.category || "",
+    statement: br.statement || br.description || "",
+    example: (br.examples || []).map(e =>
+      typeof e === 'string' ? e : ((e.input || "") + " → " + (e.expected || ""))
+    ).join("; ")
   })),
   entities: (mod.entities?.entities || []).map(ent => ({
     name: ent.name,
     description: ent.description || "",
-    attributes: (ent.attributes || []).map(a => ({
+    attributes: (ent.attributes || ent.fields || []).map(a => ({
       name: a.name,
-      type: a.type || "string",                            // string, int, decimal, date, datetime, bool, enum, guid, text
+      type: a.type || "string",
       required: a.required || false,
       description: a.description || ""
     })),
     relationships: (ent.relationships || []).map(r =>
-      r.target + " (" + r.type + ") - " + (r.description || "")
+      typeof r === 'string' ? r : (r.target || r.to || "") + " (" + (r.type || r.cardinality || "") + ") - " + (r.description || "")
     )
   })),
   permissions: buildPermissionKeys(mod.permissions),    // see below
@@ -215,31 +231,59 @@ Build a JSON object containing ALL visual artifacts from module JSON files (inde
 
 ### Wireframes Mapping (FLAT-FILE: from screens.json)
 
+> **TWO SOURCE FORMATS:** screens.json may use `screens[]` (Format A) or `sections[]` (Format B).
+> Wireframes may be at top level (Format A: `screen.mockup`) or nested (Format B: `section.wireframe`).
+
 For EACH module in `master.modules[]`:
 
 ```javascript
-// Use flat file data from collected_data (loaded in step-01)
 const mod = collected_data.modules[moduleCode];
-const screens = mod.screens?.screens || [];
-
-// Extract wireframes from screens that have mockup/wireframe data
-const wireframes = screens
-  .filter(s => s.wireframe || s.mockup || s.mockupFormat)
-  .map(wf => ({
-    screen: wf.screen || wf.name || wf.id || "",        // e.g. "UM-list", "UM-form"
-    section: wf.section || "",                            // e.g. "list", "form"
-    format: wf.mockupFormat || "ascii",                   // "ascii" | "svg"
-    content: wf.mockup || wf.ascii || wf.content || "",   // ASCII art or SVG markup
+let rawWireframes = [];
+
+// Source A: flat screens[] with mockup/mockupFormat at screen level
+const flatScreens = mod.screens?.screens || [];
+rawWireframes.push(...flatScreens.filter(s => s.mockup || s.mockupFormat));
+
+// Source B: sections[] with wireframe at section or resource level
+const sections = mod.screens?.sections || [];
+for (const section of sections) {
+  // B1: wireframe directly on section (section.wireframe)
+  if (section.wireframe) {
+    rawWireframes.push({
+      ...section.wireframe,
+      section: section.wireframe.section || section.id || section.code || "",
+      screen: section.wireframe.screen || section.id || section.code || ""
+    });
+  }
+  // B2: wireframe nested in section.resources[]
+  for (const resource of (section.resources || [])) {
+    if (resource.wireframe) {
+      rawWireframes.push({
+        ...resource.wireframe,
+        section: resource.wireframe.section || section.id || section.code || "",
+        screen: resource.wireframe.screen || `${section.id || section.code}-${resource.code}`
+      });
+    }
+  }
+}
+
+// Map to HTML format (RENAME: mockupFormat → format, mockup → content)
+EMBEDDED_ARTIFACTS.wireframes[moduleCode] = rawWireframes.map(wf => ({
+    screen: wf.screen || wf.name || wf.id || "",
+    section: wf.section || "",
+    format: wf.mockupFormat || wf.format || "ascii",      // RENAME: mockupFormat → format
+    content: wf.mockup || wf.ascii || wf.content || "",    // RENAME: mockup → content
+    svgContent: null,
     description: wf.description || "",
-    elements: wf.elements || [],                          // ["DataGrid", "FilterBar", ...]
-    actions: wf.actions || [],                            // ["filter", "sort", "create", ...]
-    componentMapping: wf.componentMapping || [],          // [{ wireframeElement, reactComponent }]
-    layout: wf.layout || null,                            // { type, regions: [...] }
+    elements: wf.elements || [],
+    actions: wf.actions || [],
+    componentMapping: Array.isArray(wf.componentMapping) ? wf.componentMapping
+      : typeof wf.componentMapping === 'object' && wf.componentMapping !== null
+        ? Object.entries(wf.componentMapping).map(([k, v]) => ({ wireframeElement: k, reactComponent: v }))
+        : [],
+    layout: typeof wf.layout === 'object' ? wf.layout : null,
     permissionsRequired: wf.permissionsRequired || []
-  }));
-
-// Store in artifacts object
-EMBEDDED_ARTIFACTS.wireframes[moduleCode] = wireframes;
+}));
 ```
 
 ### E2E Flows Mapping

package/templates/skills/business-analyse-html/references/output-modes.md

@@ -112,7 +112,8 @@ Full handoff across multiple applications within a project:
 | ba-interactive.html is too small (< 100KB) | FEATURE_DATA not serialized correctly. Verify JSON structure. Re-run FEATURE_DATA build. |
 | moduleSpecs missing from HTML | FEATURE_DATA.moduleSpecs is empty or not included in JSON. Verify each module is iterated and populated. |
 | Scope keys still show "inScope" instead of "inscope" | Conversion from JSON keys to HTML keys failed. Check cadrage.scope conversion logic. |
-| Wireframes array is empty | Verify each module has specification.uiWireframes. If missing, add wireframe stubs. |
+| Wireframes array is empty | Verify each module has screens.json with wireframe data (Format A: screens[].mockup, Format B: sections[].wireframe). If missing, step-02 will auto-generate text descriptions from columns/tabs. |
+| Mockups show ASCII instead of HTML tables | screens[] in moduleSpecs has empty resources. Verify screens.json format was normalized correctly (Format A: screens[] or Format B: sections[]) by step-02. |
 | dependencyGraph missing | Verify master index.json has consolidation.dependencyGraph. If missing, create empty nodes/edges arrays. |
 | HTML opens but data blank (localStorage issue) | Clear browser localStorage. HTML will load pre-populated FEATURE_DATA on first load. |
 | Export/re-import fails | Verify exported JSON matches original schema. Validate with `/business-analyse -x --validate`. |

package/templates/skills/business-analyse-html/steps/step-01-collect.md

@@ -87,10 +87,15 @@ FOR each module in master.index.modules[]:
   if (["specified", "consolidated", "designed", "reviewed", "handed-off"].includes(moduleStatus)) {
     if ((moduleData.entities.entities || []).length === 0)
       warnings.push("entities.json is EMPTY for specified module " + module.code);
-    if ((moduleData.usecases.useCases || []).length === 0)
+    // Check both key conventions: useCases (camelCase) and usecases (lowercase)
+    if ((moduleData.usecases.useCases || moduleData.usecases.usecases || []).length === 0)
       warnings.push("usecases.json is EMPTY for specified module " + module.code);
-    if ((moduleData.rules.rules || []).length === 0)
+    // Check both key conventions: rules and businessRules
+    if ((moduleData.rules.rules || moduleData.rules.businessRules || []).length === 0)
       warnings.push("rules.json is EMPTY for specified module " + module.code);
+    // Check screens: both screens[] (Format A) and sections[] (Format B)
+    if ((moduleData.screens.screens || moduleData.screens.sections || []).length === 0)
+      warnings.push("screens.json is EMPTY for specified module " + module.code);
   }
   if (warnings.length > 0) {
     Display("⚠ WARNING — Missing data for module " + module.code + ":");