@atlashub/smartstack-cli 4.51.0 → 4.52.0

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/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 + ":");

package/templates/skills/business-analyse-html/steps/step-02-build-data.md

@@ -111,20 +111,34 @@ For EACH module, use the flat file data from `collected_data.modules[moduleCode]
 ```javascript
 const mod = collected_data.modules[moduleCode];
 
+// NORMALIZE: usecases.json may use "useCases" (camelCase) or "usecases" (lowercase)
+const rawUCs = mod.usecases?.useCases || mod.usecases?.usecases || [];
+// NORMALIZE: rules.json may use "rules" or "businessRules"
+const rawBRs = mod.rules?.rules || mod.rules?.businessRules || [];
+
 moduleSpecs[moduleCode] = {
-  useCases: (mod.usecases?.useCases || []).map(uc => ({
-    name: uc.name,
+  useCases: rawUCs.map(uc => ({
+    name: uc.name || uc.title || uc.id || "",
     sectionCode: uc.sectionCode || "",
-    actor: uc.primaryActor,
-    steps: (uc.mainScenario || []).join("\n"),
-    alternative: (uc.alternativeScenarios || []).map(a => a.name + ": " + (a.steps || []).join(", ")).join("\n")
+    actor: uc.primaryActor || uc.actor || "",
+    // SAFETY NET: steps may be strings[] (mainScenario) or objects[] ({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,
+  businessRules: rawBRs.map(br => ({
+    name: br.name || br.id || "",
     sectionCode: br.sectionCode || "",
-    category: br.category,
-    statement: br.statement,
-    example: (br.examples || []).map(e => e.input + " → " + e.expected).join("; ")
+    category: br.category || "",
+    statement: br.statement || br.description || "",
+    example: (br.examples || []).map(e =>
+      typeof e === 'string' ? e : ((e.input || "") + " → " + (e.expected || ""))
+    ).join("; ")
   })),
   // ENTITY SAFETY NET: map fields[] → attributes[] if agent deviated
   entities: (mod.entities?.entities || []).map(ent => ({
@@ -141,9 +155,45 @@ moduleSpecs[moduleCode] = {
 }
 
 // BUILD screens[] for HTML interactive mockups (SmartTable/SmartForm rendering)
+// NORMALIZE: screens.json may use "screens[]" (flat) or "sections[]" (nested) format
 const flatScr = mod.screens?.screens || [];
+const sectionScr = mod.screens?.sections || [];
 let screens = [];
+
+// Helper: normalize a column definition regardless of field naming convention
+function normalizeColumn(c) {
+  return {
+    field: c.code || c.name || c.id || c.field || c.fieldCode || "",
+    label: c.label || c.displayName || c.code || c.name || "",
+    type: c.renderAs === "badge" ? "badge" : (c.type || c.dataType || "text"),
+    sortable: !!c.sortable
+  };
+}
+
+// Helper: normalize a form field
+function normalizeField(f) {
+  return {
+    field: f.code || f.name || f.id || f.fieldCode || f.field || "",
+    label: f.label || f.displayName || f.code || f.name || "",
+    type: f.type || f.fieldType || f.dataType || "text",
+    required: !!f.required
+  };
+}
+
+// Helper: normalize a filter
+function normalizeFilter(f) {
+  if (typeof f === 'string') return f;
+  return f.label || f.displayName || f.filterLabel || f.name || f.code || f.filterCode || "";
+}
+
+// Helper: normalize an action
+function normalizeAction(a) {
+  if (typeof a === 'string') return a;
+  return a.code || a.id || a.label || a.actionCode || "";
+}
+
 if (flatScr.length > 0) {
+  // FORMAT A: flat screens[] array (ba-003 style)
   const bySec = {};
   flatScr.forEach(s => {
     const sec = s.section || "default";
@@ -156,28 +206,54 @@ if (flatScr.length > 0) {
       code: s.screen || s.name || "",
       label: s.sectionLabel || s.description || s.screen || "",
       type: s.componentType || "unknown",
-      columns: (s.columns || []).map(c => ({
-        field: c.code || c.field || "", label: c.label || c.code || "",
-        type: c.type || c.dataType || "text", sortable: !!c.sortable
-      })),
-      filters: (s.filters || []).map(f =>
-        typeof f === 'string' ? f : (f.label || f.filterLabel || f.code || f.filterCode || "")),
+      columns: (s.columns || []).map(normalizeColumn),
+      filters: (s.filters || []).map(normalizeFilter),
       fields: [],
       tabs: (s.tabs || []).map(t => ({
         label: t.label || t.tabLabel || t.code || "",
-        fields: (t.fields || []).map(f => ({
-          field: f.code || f.fieldCode || f.field || "",
-          label: f.label || f.code || "",
-          type: f.type || f.dataType || "text",
-          required: !!f.required
-        }))
+        fields: (t.fields || []).map(normalizeField)
       })),
-      actions: (s.actions || []).map(a =>
-        typeof a === 'string' ? a : (a.code || a.label || a.actionCode || "")),
-      kpis: s.kpis || [],
+      actions: (s.actions || []).map(normalizeAction),
+      kpis: (s.kpis || []).map(k => typeof k === 'object'
+        ? { label: k.label || k.displayName || "", value: k.value || k.metric || "0" }
+        : { label: String(k), value: "0" }),
       options: s.options || [],
       permission: s.permission || "",
-      notes: s.description || ""
+      notes: s.description || s.sectionDescription || ""
+    });
+  });
+  screens = Object.values(bySec);
+} else if (sectionScr.length > 0) {
+  // FORMAT B: sections[] array (ba-004 style — id/displayName/layout convention)
+  // Each section IS a screen resource (columns, tabs, filters are ON the section itself)
+  const bySec = {};
+  sectionScr.forEach(sec => {
+    const secId = sec.id || sec.code || sec.sectionCode || "";
+    const secLabel = sec.displayName || sec.label || sec.sectionLabel || secId;
+    const componentType = sec.layout || sec.componentType || "unknown";
+    if (!bySec[secId]) bySec[secId] = {
+      sectionCode: secId,
+      sectionLabel: secLabel,
+      resources: []
+    };
+    bySec[secId].resources.push({
+      code: secId,
+      label: secLabel,
+      type: componentType,
+      columns: (sec.columns || []).map(normalizeColumn),
+      filters: (sec.filters || []).map(normalizeFilter),
+      fields: [],
+      tabs: (sec.tabs || []).map(t => ({
+        label: t.displayName || t.label || t.code || t.id || "",
+        fields: (t.fields || []).map(normalizeField)
+      })),
+      actions: (sec.actions || []).map(normalizeAction),
+      kpis: (sec.kpis || []).map(k => typeof k === 'object'
+        ? { label: k.displayName || k.label || "", value: k.format === "percentage" ? "80%" : "1,234" }
+        : { label: String(k), value: "0" }),
+      options: sec.options || [],
+      permission: (typeof sec.permissions === 'object' ? sec.permissions?.view : sec.permission) || "",
+      notes: sec.description || ""
     });
   });
   screens = Object.values(bySec);
@@ -216,20 +292,36 @@ FEATURE_DATA.modules.forEach(m => {
   const source = collected_data.modules[m.code];
   if (!spec) { errors.push(`MISSING moduleSpecs[${m.code}]`); return; }
 
-  const srcUC = (source?.usecases?.useCases || []).length;
+  // Check useCases (handle both key conventions)
+  const srcUC = (source?.usecases?.useCases || source?.usecases?.usecases || []).length;
   const bltUC = (spec.useCases || []).length;
   if (srcUC > 0 && bltUC === 0)
     errors.push(`${m.code}: useCases EMPTY but source has ${srcUC}`);
 
-  const srcBR = (source?.rules?.rules || []).length;
+  // Check businessRules (handle both key conventions)
+  const srcBR = (source?.rules?.rules || source?.rules?.businessRules || []).length;
   const bltBR = (spec.businessRules || []).length;
   if (srcBR > 0 && bltBR === 0)
     errors.push(`${m.code}: businessRules EMPTY but source has ${srcBR}`);
 
+  // Check entities
   const srcEnt = (source?.entities?.entities || []).length;
   const bltEnt = (spec.entities || []).length;
   if (srcEnt > 0 && bltEnt === 0)
     errors.push(`${m.code}: entities EMPTY but source has ${srcEnt}`);
+
+  // Check screens (handle both formats: screens[] and sections[])
+  const srcScreens = (source?.screens?.screens || source?.screens?.sections || []).length;
+  const bltScreenResources = (spec.screens || []).reduce(
+    (acc, s) => acc + (s.resources || []).length, 0);
+  if (srcScreens > 0 && bltScreenResources === 0)
+    errors.push(`${m.code}: screens EMPTY (0 resources) but source has ${srcScreens} screens/sections`);
+
+  // Check serialization: [object Object] in useCases steps = BUG
+  (spec.useCases || []).forEach(uc => {
+    if (uc.steps && uc.steps.includes("[object Object]"))
+      errors.push(`${m.code}: UC "${uc.name}" has [object Object] in steps — steps[] contains objects not strings`);
+  });
 });
 
 if (errors.length > 0) {
@@ -310,39 +402,62 @@ rawWireframes.push(...flatScreens.filter(s => s.mockup || s.mockupFormat));
 // Source B: nested sections[].resources[].wireframe (design step output)
 const sections = mod.screens?.sections || [];
 for (const section of sections) {
+  // B1: wireframe directly on section (ba-004 style: sections[].wireframe)
+  if (section.wireframe) {
+    rawWireframes.push({
+      ...section.wireframe,
+      section: section.wireframe.section || section.id || section.code || section.sectionCode || "",
+      screen: section.wireframe.screen || section.id || section.code || section.sectionCode || ""
+    });
+  }
+  // B2: wireframe on resources (nested: sections[].resources[].wireframe)
   for (const resource of (section.resources || [])) {
     if (resource.wireframe) {
-      // Unwrap nested wireframe and add section context
       rawWireframes.push({
         ...resource.wireframe,
-        section: resource.wireframe.section || section.sectionCode || "",
-        screen: resource.wireframe.screen || `${section.sectionCode}-${resource.code}` || ""
+        section: resource.wireframe.section || section.sectionCode || section.id || "",
+        screen: resource.wireframe.screen || `${section.sectionCode || section.id}-${resource.code}` || ""
       });
     }
   }
 }
 
-// Source C: screens without mockup → auto-generate text description as wireframe fallback
+// Source C: screens/sections without mockup → auto-generate text description as wireframe fallback
+// C1: from flat screens[]
 const screensWithoutMockup = flatScreens.filter(s => !s.mockup && !s.mockupFormat);
-for (const screen of screensWithoutMockup) {
-  const type = screen.componentType || "";
+// C2: from sections[] (ba-004 style) — sections without wireframe property
+const sectionsWithoutWireframe = sections.filter(s => !s.wireframe);
+const allNoMockup = [
+  ...screensWithoutMockup.map(s => ({
+    type: s.componentType || "", columns: s.columns || [], tabs: s.tabs || [],
+    kpis: s.kpis || [], screen: s.screen || "", section: s.section || "",
+    description: s.sectionDescription || ""
+  })),
+  ...sectionsWithoutWireframe.map(s => ({
+    type: s.layout || s.componentType || "", columns: s.columns || [], tabs: s.tabs || [],
+    kpis: s.kpis || [], screen: s.id || s.code || "", section: s.id || s.code || "",
+    description: s.description || ""
+  }))
+];
+for (const screen of allNoMockup) {
+  const type = screen.type;
   let desc = "";
   if (type.includes("Table") || type.includes("Grid")) {
-    const cols = screen.columns || [];
-    desc = "Tableau avec " + cols.length + " colonnes : " + cols.map(c => c.label || c.code).join(", ");
+    const cols = screen.columns;
+    desc = "Tableau avec " + cols.length + " colonnes : " + cols.map(c => c.label || c.displayName || c.code || c.name).join(", ");
   } else if (type.includes("Form")) {
-    const tabs = screen.tabs || [];
+    const tabs = screen.tabs;
     desc = "Formulaire " + (tabs.length > 0 ? "avec " + tabs.length + " onglet(s)" : "");
   } else if (type.includes("Dashboard")) {
-    desc = "Tableau de bord avec KPIs";
+    desc = "Tableau de bord avec " + (screen.kpis.length || "") + " KPIs";
   } else if (type.includes("Kanban")) {
     desc = "Vue Kanban";
   }
   if (desc) {
     rawWireframes.push({
-      screen: screen.screen || "", section: screen.section || "",
+      screen: screen.screen, section: screen.section,
       mockupFormat: "text", mockup: desc,
-      description: screen.sectionDescription || "", elements: [], componentMapping: []
+      description: screen.description, elements: [], componentMapping: []
     });
   }
 }

package/templates/skills/business-analyse-html/steps/step-04-verify.md

@@ -8,7 +8,7 @@ model: opus
 
 ## YOUR TASK
 
-Run 6 blocking validations on the generated HTML file and display the completion summary.
+Run 9 blocking validations on the generated HTML file and display the completion summary.
 
 ---
 
@@ -57,19 +57,37 @@ FOR each module in FEATURE_DATA.modules:
 ```
 FOR each module in FEATURE_DATA.modules:
   Read source: docs/{app}/{module.code}/business-analyse/v{version}/usecases.json
-  sourceUCCount = count of useCases in source file
+  sourceUCCount = count of useCases OR usecases in source file
   htmlUCCount = count in FEATURE_DATA.moduleSpecs[module.code].useCases
   IF sourceUCCount > 0 AND htmlUCCount === 0:
     BLOCKING_ERROR("Module {module.code}: 0 useCases in HTML but {sourceUCCount} in source")
 
   Read source: docs/{app}/{module.code}/business-analyse/v{version}/rules.json
-  sourceBRCount = count of rules in source file
+  sourceBRCount = count of rules OR businessRules in source file
   htmlBRCount = count in FEATURE_DATA.moduleSpecs[module.code].businessRules
   IF sourceBRCount > 0 AND htmlBRCount === 0:
     BLOCKING_ERROR("Module {module.code}: 0 businessRules in HTML but {sourceBRCount} in source")
 ```
 
-**Check 7 — No runtime crash (CRITICAL — validates page won't be blank):**
+**Check 7 — Screens/mockups populated (prevents ASCII-only regression):**
+```
+FOR each module in FEATURE_DATA.modules:
+  Read source: docs/{app}/{module.code}/business-analyse/v{version}/screens.json
+  sourceScreenCount = count of "screens" array OR "sections" array in source file
+  htmlScreenResources = sum of resources[].length across moduleSpecs[module.code].screens[]
+  IF sourceScreenCount > 0 AND htmlScreenResources === 0:
+    BLOCKING_ERROR("Module {module.code}: 0 screen resources but source has {sourceScreenCount}")
+```
+
+**Check 8 — No serialization bugs ([object Object]):**
+```
+Search ba-interactive.html for the literal string "[object Object]"
+IF found:
+  BLOCKING_ERROR("Serialization bug: [object Object] found in HTML — steps[] or other arrays contain objects instead of strings")
+  Identify which module/field contains the bug and fix the mapping
+```
+
+**Check 9 — No runtime crash (CRITICAL — validates page won't be blank):**
 ```
 Open ba-interactive.html and search for the FEATURE_DATA JSON block.
 Verify these MANDATORY top-level fields exist: