@atlashub/smartstack-cli 4.74.0 → 4.76.0

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

@@ -14,7 +14,7 @@ next_step: none
 - ALWAYS validate permission coherence across modules
 - ALWAYS execute semantic validation checks
 - NEVER duplicate module content - work with summaries only
-- Single-module shortcut: auto-approve consolidation if only 1 module
+- ALWAYS ask for client approval, even for single-module projects (play devil's advocate)
 
 ## Context Recovery
 
@@ -50,98 +50,151 @@ IF status already "consolidated":
   STOP
 ```
 
-### 2. Cross-Module Interaction Analysis
-
-**2a. Load Module Index Files**
+### 1b. Analysis Quality Self-Assessment (MANDATORY)
 
-For each completed module, read `index.json` and discover granular files:
+> **Score the analysis quality BEFORE presenting to the client.**
+> This catches low-quality output before it reaches consolidation.
 
+#### 1b-i. Research Coverage
 ```javascript
-const moduleFiles = {
-  entities: "entities.json",
-  rules: "rules.json",
-  usecases: "usecases.json",
-  permissions: "permissions.json",
-  screens: "screens.json"
-};
-
-for (const module of completedModules) {
-  const index = ba-reader.readSection(module.code, "index");
-  module.files = index.files;
-  // Load only files needed for consolidation
-  module.entities = ba-reader.readSection(module.code, "entities");
-  module.permissions = ba-reader.readSection(module.code, "permissions");
+let researchScore = 0;
+if (domain_research?.source === "built-in-only") {
+  researchScore = 2;
+} else {
+  // +2 per application with Level 1 research
+  for (const app of applications) {
+    if (domain_research?.applications?.[app.code]) researchScore += 2;
+  }
+  // +1 per module with Level 2 research (cap at 4)
+  let moduleResearchCount = 0;
+  for (const module of completedModules) {
+    if (module.domainResearchSource !== "built-in-only") moduleResearchCount++;
+  }
+  researchScore += Math.min(moduleResearchCount, 4);
 }
+researchScore = Math.min(10, researchScore);
 ```
 
-**2b. Foreign Key References & Shared Entities**
-
-Build entity registry and validate cross-module references:
-
+#### 1b-ii. Module Completeness (per app)
 ```javascript
-const entityRegistry = {};
-for (const module of completedModules) {
-  entityRegistry[module.code] = {
-    entities: module.entities.map(e => ({
-      name: e.name,
-      attributes: e.attributes.map(a => a.name),
-      pk: e.attributes.find(a => a.name === "Id" || a.unique)?.name || "Id"
-    }))
-  };
+for (const app of applications) {
+  const archetype = loadArchetype(app.type); // from module-completeness-challenge.md
+  const corePresent = archetype.coreModules.filter(m => appHasModule(app, m)).length;
+  const coreTotal = archetype.coreModules.length;
+  app.completenessScore = (corePresent / coreTotal) * 10;
+  // Penalty if CORE excluded without justification
+  const unjustified = archetype.coreModules.filter(m =>
+    !appHasModule(app, m) && !isExplicitlyExcluded(app, m)
+  );
+  if (unjustified.length > 0) app.completenessScore -= 3;
 }
+const avgModuleScore = average(applications.map(a => a.completenessScore));
+```
 
-// Detect shared entities
-const sharedEntities = [];
+#### 1b-iii. Section Depth (per module)
+```javascript
 for (const module of completedModules) {
-  for (const entity of module.entities) {
-    for (const rel of entity.relationships || []) {
-      if (rel.target.includes(".")) {
-        const [targetModule, targetEntity] = rel.target.split(".");
-        if (!entityRegistry[targetModule]) {
-          BLOCKING_ERROR(`Module ${module.code}: references non-existent module "${targetModule}"`);
-        }
-        sharedEntities.push({
-          entity: targetEntity,
-          definedIn: targetModule,
-          referencedBy: module.code,
-          referenceType: rel.type
-        });
-      }
-    }
+  const sectionCount = module.anticipatedSections?.length || 0;
+  if (module.featureType === "workflow") {
+    if (sectionCount < 5) module.sectionScore = 4;
+    else if (sectionCount < 7) module.sectionScore = 7;
+    else module.sectionScore = 9;
+    // Bonus for contextual views
+    const hasContextual = module.anticipatedSections?.some(s =>
+      ["open-requests", "rejected", "history", "my-balance", "my-tasks", "overdue"].includes(s.code)
+    );
+    if (hasContextual) module.sectionScore = Math.min(10, module.sectionScore + 1);
+  } else {
+    module.sectionScore = sectionCount >= 3 ? 8 : sectionCount >= 2 ? 6 : 4;
   }
 }
+const avgSectionScore = average(completedModules.map(m => m.sectionScore));
 ```
 
-**2c. Detect Circular Dependencies**
-
+#### 1b-iv. Business Rule Depth (per module)
 ```javascript
-const cycles = detectCycles(dependencyGraph);
-if (cycles.length > 0) {
-  BLOCKING_ERROR("Circular dependencies detected:");
-  for (const cycle of cycles) {
-    ERROR(`  ${cycle.join(" → ")}`);
-  }
-  ACTIONS: Review dependencies, move shared entities to Core module, or use event-driven communication
-  STOP - DO NOT PROCEED
+for (const module of completedModules) {
+  const rules = module.rules || [];
+  const domainSpecific = rules.filter(r => r.domainSpecific === true || r.source === "domain-research").length;
+  const total = rules.length;
+  if (total === 0) { module.ruleScore = 0; continue; }
+  const genericRatio = (total - domainSpecific) / total;
+  if (genericRatio > 0.8) module.ruleScore = 3;       // >80% generic = poor
+  else if (genericRatio > 0.5) module.ruleScore = 6;   // 50-80% generic = acceptable
+  else module.ruleScore = 9;                           // <50% generic = excellent
 }
+const avgRuleScore = average(completedModules.map(m => m.ruleScore));
 ```
 
-**2d. Display Cross-Module Interaction Map**
+#### 1b-v. Global Quality Score
+```javascript
+const qualityScore = Math.round(
+  (researchScore + avgModuleScore + avgSectionScore + avgRuleScore) / 4
+);
+```
 
+Display:
 ```
-═══════════════════════════════════════════════════════════════
-  CROSS-MODULE INTERACTIONS VALIDATED
-═══════════════════════════════════════════════════════════════
+### Auto-evaluation qualite de l'analyse
 
-| Source Module | Target | Type | Status |
-|---------------|--------|------|--------|
-| Orders        | Customers.Customer | FK (N:1) | ✓ RESOLVED |
-| Invoices      | Customers.Customer | FK (N:1) | ✓ RESOLVED |
+| Dimension | Score | Detail |
+|-----------|-------|--------|
+| Recherche web | {researchScore}/10 | {N} apps recherchees, {M} modules recherches |
+| Completude modules | {avgModuleScore}/10 | {details per app} |
+| Profondeur sections | {avgSectionScore}/10 | {details per module} |
+| Profondeur regles metier | {avgRuleScore}/10 | {domainSpecific}/{total} regles specifiques domaine |
+| **GLOBAL** | **{qualityScore}/10** | |
+```
 
-Total: {count} cross-module references
-Shared entities: {count}
-═══════════════════════════════════════════════════════════════
 ```
+IF qualityScore < 7:
+  WARNING: "Score qualite inferieur a 7/10.
+    Recommandation : relancer les etapes deficientes avec WebSearch active."
+  Display: "Dimensions a ameliorer: {list dimensions < 7}"
+```
+
+Store in `validation.json` as `qualityAssessment`.
+
+### 1c. Business Process Coverage Validation (BLOCKING for multi-app)
+
+> **Verify that all identified business processes are covered by modules.**
+> A process step without a covering module = a GAP in the application.
+
+```javascript
+IF cadrage._preAnalysis?.businessProcesses?.length > 0:
+  const gaps = [];
+  for (const process of cadrage._preAnalysis.businessProcesses) {
+    for (const step of process.steps) {
+      if (!step.covered) {
+        gaps.push({ process: process.name, step: step.name, apps: process.apps });
+      }
+    }
+  }
+
+  Display:
+  ### Couverture des processus metier
+  | Processus | Etapes | Couvertes | Gaps |
+  |-----------|--------|-----------|------|
+  {for each process: name, steps.length, covered count, gap names}
+
+  IF gaps.length > 0:
+    WARNING: "{gaps.length} etapes de processus non couvertes."
+    // Not BLOCKING at consolidation (should have been caught in step-01/02)
+    // But display as warning for final visibility
+```
+
+Store in `validation.json` as `processCoverage`.
+
+### 2. Cross-Module Interaction Analysis
+
+→ **Load** `references/04-cross-module-validation.md` for FK validation rules, cycle detection, and interaction mapping.
+
+**Execution:**
+- Load module index files and granular JSON (entities, permissions)
+- Build entity registry and detect shared entities
+- Validate foreign key references across modules
+- Detect circular dependencies (blocking error if any found)
+- Display cross-module interaction map with validation status
 
 ### 3. Permission Coherence Check
 
@@ -184,43 +237,124 @@ const hierarchy = ["Admin", "Manager", "Contributor", "Viewer"];
 
 ### 4. Semantic Validation (MANDATORY)
 
-Execute 13 semantic checks per module:
+→ **Load** `references/04-semantic-validation-matrix.md` and execute ALL semantic validation checks.
+
+This includes:
+- 13 semantic checks per module (permission orphans, UC coverage, entity doubles, permission ghosts, etc.)
+- 5 contract verification checks (BR formulas, computed attributes, UC counts, permission counts, versioned attributes)
+- Blocking rule: 0 ERROR → PASS, ≥1 ERROR → BLOCK (user must fix before proceeding)
 
+**BR-EXAMPLES-COMPLETE check — qualité test-ready (NEW):**
 ```javascript
-const semanticChecks = [
-  { check: "permission-orpheline", severity: "WARNING" },
-  { check: "uc-sans-fr", severity: "WARNING" },
-  { check: "entity-sans-endpoint", severity: "WARNING" },
-  { check: "uc-sans-scenario", severity: "WARNING" },
-  { check: "role-sans-permissions", severity: "WARNING" },
-  { check: "navigation-sans-traduction", severity: "ERROR" },
-  { check: "lifecycle-terminal", severity: "WARNING" },
-  { check: "schema-conformity", severity: "ERROR" },
-  { check: "wireframe-coverage", severity: "ERROR" },
-  { check: "entity-doublon", severity: "ERROR" },
-  { check: "permission-fantome", severity: "ERROR" },
-  { check: "dashboard-coverage", severity: "WARNING" },
-  { check: "permission-uc-alignment", severity: "WARNING" }
-];
+for (const module of completedModules) {
+  const rules = module.rules || [];
+  if (rules.length === 0) continue;
+
+  // 1. Couverture : toutes les règles doivent avoir des exemples
+  const withExamples = rules.filter(r => r.examples?.length > 0);
+  const exampleRate = withExamples.length / rules.length;
+
+  if (exampleRate < 0.4) {
+    ERROR(`Module ${module.code}: ${withExamples.length}/${rules.length} BRs ont des exemples (${Math.round(exampleRate*100)}% < 40% minimum) — BLOQUANT`);
+  } else if (exampleRate < 0.7) {
+    WARNING(`Module ${module.code}: ${withExamples.length}/${rules.length} BRs ont des exemples (${Math.round(exampleRate*100)}% — cible: 100%)`);
+  }
+
+  // 2. Format test-ready : exemples avec given/when/then
+  const testReady = rules.filter(r =>
+    r.examples?.some(e => e.given && e.when && e.then)
+  );
+  const proseOnly = rules.filter(r =>
+    r.examples?.length > 0 && !r.examples.some(e => e.given && e.when && e.then)
+  );
 
+  if (testReady.length < 4 && module.featureType !== 'portal') {
+    WARNING(`Module ${module.code}: ${testReady.length}/4 BRs au format test-ready {given, when, then}`);
+  }
+  if (proseOnly.length > 0) {
+    WARNING(`Module ${module.code}: ${proseOnly.length} BRs avec exemples en prose — convertir en format test-ready pour génération de tests`);
+  }
+
+  // 3. BR-CALC : formule + exemple chiffré obligatoires
+  const calcRules = rules.filter(r => r.category === 'calculation');
+  const calcWithoutFormula = calcRules.filter(r => !r.formula);
+  const calcWithoutNumericExample = calcRules.filter(r =>
+    !r.examples?.some(e =>
+      (e.scenario === 'calculation') ||
+      (e.then && Object.values(e.then).some(v => typeof v === 'number'))
+    )
+  );
+
+  if (calcWithoutFormula.length > 0) {
+    ERROR(`Module ${module.code}: ${calcWithoutFormula.length} BR-CALC sans champ formula`);
+  }
+  if (calcWithoutNumericExample.length > 0) {
+    WARNING(`Module ${module.code}: ${calcWithoutNumericExample.length} BR-CALC sans exemple chiffré — les tests de calcul nécessitent des valeurs numériques`);
+  }
+
+  // 4. Couverture scénarios : chaque règle devrait avoir happy_path + error
+  const withBothScenarios = rules.filter(r =>
+    r.examples?.some(e => e.scenario === 'happy_path' || e.then?.result === 'success') &&
+    r.examples?.some(e => e.scenario === 'error' || e.then?.result === 'error')
+  );
+  if (withBothScenarios.length < rules.length * 0.5 && module.featureType !== 'portal') {
+    WARNING(`Module ${module.code}: ${withBothScenarios.length}/${rules.length} BRs couvrent happy_path + error — cible: 100%`);
+  }
+}
+```
+
+### 4b. Language Coherence Check (MANDATORY)
+
+Verify that ALL generated content respects `{language}` from config:
+
+```javascript
+const expectedLang = language; // from config.json
+
+// Heuristics for language detection
+const frIndicators = /\b(le|la|les|un|une|des|du|de|est|sont|doit|peut|dans|pour|avec|sur|par|cette|tout|qui)\b/i;
+const enIndicators = /\b(the|a|an|is|are|must|can|in|for|with|on|by|this|all|who|should|when|each)\b/i;
+
+function detectLang(text) {
+  if (!text || text.length < 10) return null;
+  const frScore = (text.match(frIndicators) || []).length;
+  const enScore = (text.match(enIndicators) || []).length;
+  if (frScore > enScore * 1.5) return 'fr';
+  if (enScore > frScore * 1.5) return 'en';
+  return null; // ambiguous
+}
+
+const langIssues = [];
 for (const module of completedModules) {
-  for (const check of semanticChecks) {
-    const result = executeSemanticCheck(module, check);
-    if (result.status === "ERROR") {
-      errors.push({module: module.code, check: check.check, details: result.details});
-    } else if (result.status === "WARNING") {
-      warnings.push({module: module.code, check: check.check, details: result.details});
+  // Sample entity descriptions
+  (module.entities || []).forEach(e => {
+    const detected = detectLang(e.description);
+    if (detected && detected !== expectedLang) {
+      langIssues.push({ module: module.code, type: 'entity', name: e.name, detected, text: e.description?.substring(0, 60) });
     }
-  }
+  });
+  // Sample BR statements
+  (module.rules || []).forEach(r => {
+    const detected = detectLang(r.statement);
+    if (detected && detected !== expectedLang) {
+      langIssues.push({ module: module.code, type: 'rule', name: r.id, detected, text: r.statement?.substring(0, 60) });
+    }
+  });
+  // Sample UC names
+  (module.useCases || module.usecases || []).forEach(u => {
+    const detected = detectLang(u.name);
+    if (detected && detected !== expectedLang) {
+      langIssues.push({ module: module.code, type: 'useCase', name: u.id || u.name, detected, text: u.name });
+    }
+  });
 }
 
-// Blocking rule: 0 ERROR → PASS, ≥1 ERROR → BLOCK (ask user for each)
-if (errors.length > 0) {
-  BLOCKING_ERROR("Semantic validation failed");
-  for (const error of errors) {
-    ERROR(`  [${error.module}] ${error.check}: ${error.details}`);
+if (langIssues.length > 0) {
+  WARNING(`${langIssues.length} content items detected in wrong language (expected: ${expectedLang})`);
+  Display(langIssues.slice(0, 10).map(i => `  - ${i.module}/${i.type} "${i.name}": detected ${i.detected}, text: "${i.text}"`).join('\n'));
+
+  if (langIssues.length > completedModules.length * 3) {
+    BLOCKING_ERROR(`Too many language violations (${langIssues.length}). Re-specify affected modules in ${expectedLang}.`);
   }
-  STOP - User must fix before proceeding
 }
 ```
 
@@ -259,6 +393,234 @@ Display("Global Entity Count: {count}")
 Display("Global Relationships: {count}")
 ```
 
+### 5a. Cross-Module Contracts (MANDATORY)
+
+> **Generate explicit contracts for every cross-module FK dependency.**
+> These contracts ensure both producer and consumer modules agree on the data shape.
+> They prevent the #1 cross-module integration failure: wrong field type/name/nullability.
+
+```javascript
+const crossModuleContracts = [];
+
+for (const rel of globalRelationships) {
+  // Only for cross-module relationships
+  if (rel.sourceModule !== rel.targetModule) {
+    // Resolve the FK field from the source entity's attributes
+    const sourceEntity = findEntity(rel.sourceModule, rel.sourceEntity);
+    const fkField = sourceEntity.attributes.find(a =>
+      a.name.toLowerCase() === (rel.targetEntity.toLowerCase() + 'id') ||
+      a.description?.includes('FK vers ' + rel.targetEntity)
+    );
+
+    crossModuleContracts.push({
+      consumer: `${rel.sourceModule}.${rel.sourceEntity}`,
+      provider: `${rel.targetModule}.${rel.targetEntity}`,
+      field: fkField?.name || `${rel.targetEntity.charAt(0).toLowerCase() + rel.targetEntity.slice(1)}Id`,
+      type: fkField?.type || "guid",
+      required: fkField?.required || false,
+      nullable: !fkField?.required,
+      resolvedVia: `FK → ${rel.targetEntity}.Id`,
+      cardinality: rel.cardinality,
+      cascadeDelete: rel.cascadeDelete,
+      description: `${rel.sourceEntity} references ${rel.targetEntity} from ${rel.targetModule}`
+    });
+  }
+}
+```
+
+Display:
+```
+### Contrats cross-module ({crossModuleContracts.length})
+
+| Consumer | Provider | FK Field | Type | Required | Cascade |
+|----------|----------|----------|------|----------|---------|
+{for each contract: | {consumer} | {provider} | {field} | {type} | {required} | {cascadeDelete} |}
+```
+
+Store in `consolidation.json` as `crossModuleContracts[]`.
+
+> These contracts are consumed by `/business-analyse-handoff` and `/business-analyse-develop`
+> to ensure correct FK generation, DTO mapping, and navigation property creation across modules.
+
+### 5b. Mermaid Diagram Generation (MANDATORY)
+
+> Generate 3 types of Mermaid diagrams as text, stored in consolidation.json.
+> These diagrams are rendered in the interactive HTML and exported with handoff.
+
+#### 5b-i. ERD (Entity-Relationship Diagram)
+
+From `globalEntities` and `globalRelationships` built in section 5, generate Mermaid ERD:
+
+```javascript
+let erd = "erDiagram\n";
+for (const entity of globalEntities) {
+  erd += `  ${entity.name} {\n`;
+  for (const attr of entity.topAttributes) { // top 5-8 attributes
+    erd += `    ${attr.type} ${attr.name}\n`;
+  }
+  erd += "  }\n";
+}
+for (const rel of globalRelationships) {
+  const card = rel.cardinality === "1:N" ? "||--o{" :
+               rel.cardinality === "N:1" ? "}o--||" :
+               rel.cardinality === "N:M" ? "}o--o{" : "||--||";
+  erd += `  ${rel.sourceEntity} ${card} ${rel.targetEntity} : "${rel.description}"\n`;
+}
+```
+
+Store as `consolidation.mermaidDiagrams.erd` (string).
+
+#### 5b-ii. State Machine Diagrams (per entity lifecycle)
+
+For EACH `lifeCycle` found in all modules' `usecases.json`:
+
+```javascript
+let sm = "stateDiagram-v2\n";
+sm += `  [*] --> ${lifecycle.initialState}\n`;
+for (const transition of lifecycle.transitions) {
+  sm += `  ${transition.from} --> ${transition.to} : ${transition.action}\n`;
+}
+for (const state of lifecycle.states.filter(s => s.isTerminal)) {
+  sm += `  ${state.id} --> [*]\n`;
+}
+```
+
+Store as `consolidation.mermaidDiagrams.stateMachines[{entity}]` (string).
+
+#### 5b-iii. Sequence Diagrams (per E2E flow)
+
+For EACH e2eFlow identified in section 6:
+
+```javascript
+let seq = "sequenceDiagram\n";
+for (const step of flow.steps) {
+  seq += `  ${step.actor || step.module}->>+${step.targetModule || "System"}: ${step.action}\n`;
+  if (step.result) {
+    seq += `  ${step.targetModule || "System"}-->>-${step.actor || step.module}: ${step.result}\n`;
+  }
+}
+```
+
+Store as `consolidation.mermaidDiagrams.sequences[{flowName}]` (string).
+
+#### 5b-iv. Use Case Diagrams (per module)
+
+For EACH module, generate a Mermaid use case diagram showing actors and their interactions:
+
+```javascript
+const useCaseDiagrams = {};
+
+for (const module of completedModules) {
+  const usecases = module.useCases || module.usecases || [];
+  if (usecases.length === 0) continue;
+
+  // Collect unique actors
+  const actors = [...new Set(usecases.map(uc => uc.primaryActor || uc.actor).filter(Boolean))];
+
+  // Build flowchart-based UC diagram (Mermaid does not have native usecase syntax)
+  let diagram = "flowchart LR\n";
+
+  // Add actors (left side)
+  actors.forEach((actor, i) => {
+    const actorId = 'actor_' + actor.replace(/[^a-zA-Z0-9]/g, '_');
+    diagram += `  ${actorId}[/"👤 ${actor}"\\]\n`;
+    diagram += `  style ${actorId} fill:#e1f5fe,stroke:#0288d1,color:#01579b\n`;
+  });
+
+  // Group UCs by section
+  const sections = [...new Set(usecases.map(uc => uc.sectionCode).filter(Boolean))];
+
+  sections.forEach(section => {
+    const sectionUCs = usecases.filter(uc => uc.sectionCode === section);
+    diagram += `  subgraph ${section}["${section}"]\n`;
+    sectionUCs.forEach(uc => {
+      const ucId = (uc.id || uc.name).replace(/[^a-zA-Z0-9]/g, '_');
+      diagram += `    ${ucId}(("${uc.name}"))\n`;
+    });
+    diagram += `  end\n`;
+  });
+
+  // UCs without section
+  const noSectionUCs = usecases.filter(uc => !uc.sectionCode);
+  noSectionUCs.forEach(uc => {
+    const ucId = (uc.id || uc.name).replace(/[^a-zA-Z0-9]/g, '_');
+    diagram += `  ${ucId}(("${uc.name}"))\n`;
+  });
+
+  // Connect actors to UCs
+  usecases.forEach(uc => {
+    const actor = uc.primaryActor || uc.actor;
+    if (!actor) return;
+    const actorId = 'actor_' + actor.replace(/[^a-zA-Z0-9]/g, '_');
+    const ucId = (uc.id || uc.name).replace(/[^a-zA-Z0-9]/g, '_');
+    diagram += `  ${actorId} --> ${ucId}\n`;
+  });
+
+  useCaseDiagrams[module.code] = diagram;
+}
+```
+
+Store as `consolidation.mermaidDiagrams.useCases` (object: moduleCode → diagram string).
+
+#### 5b-v. MCD (Modèle Conceptuel de Données)
+
+Generate a simplified conceptual data model showing ONLY entity names and named relationships with cardinalities. Unlike the ERD which shows all attributes, the MCD focuses on the conceptual structure.
+
+```javascript
+let mcd = "erDiagram\n";
+
+// Entities: name + PK only (no attributes)
+for (const ent of globalEntities) {
+  mcd += `  ${ent.name} {\n`;
+  mcd += `    ${ent.pk || 'guid'} Id PK\n`;
+  mcd += `  }\n`;
+}
+
+// Named relationships with cardinalities
+for (const rel of globalRelationships) {
+  const card = rel.cardinality === "1:N" ? "||--o{" :
+               rel.cardinality === "N:1" ? "}o--||" :
+               rel.cardinality === "N:M" ? "}o--o{" :
+               rel.cardinality === "1:1" ? "||--||" : "||--o{";
+
+  // Use description as relationship label, or derive from cardinality
+  const label = rel.description ||
+    (rel.cardinality === "1:N" ? "contient" :
+     rel.cardinality === "N:1" ? "appartient" : "associe");
+
+  mcd += `  ${rel.sourceEntity} ${card} ${rel.targetEntity} : "${label}"\n`;
+}
+```
+
+Store as `consolidation.mermaidDiagrams.mcd` (string).
+
+#### 5b-vi. Storage
+
+Write to `consolidation.json`:
+
+```json
+{
+  "mermaidDiagrams": {
+    "erd": "erDiagram\n  Employee {\n    guid id\n    string code\n    ...\n  }\n  ...",
+    "mcd": "erDiagram\n  Employee {\n    guid Id PK\n  }\n  Employee ||--o{ Contract : \"contient\"\n  ...",
+    "useCases": {
+      "Employees": "flowchart LR\n  actor_RH[/\"👤 RH Admin\"\\]\n  ...",
+      "Absences": "flowchart LR\n  ..."
+    },
+    "stateMachines": {
+      "Absence": "stateDiagram-v2\n  [*] --> Draft\n  Draft --> Submitted : submit\n  ...",
+      "Invoice": "stateDiagram-v2\n  [*] --> Draft\n  ..."
+    },
+    "sequences": {
+      "CycleCommercial": "sequenceDiagram\n  Commercial->>+CRM: Creer opportunite\n  ...",
+      "CycleFacturation": "sequenceDiagram\n  ..."
+    }
+  }
+}
+```
+
+Display diagrams as markdown Mermaid code blocks for the client to preview before approval (section 9).
+
 ### 6. E2E Flow Validation
 
 Identify business processes spanning multiple modules:
@@ -334,172 +696,15 @@ Les critères d'acceptation sont écrits dans `validation.json` au même niveau
 
 ### 7ter. Naming Audit (MANDATORY)
 
-> **Challenge all names before final approval.** Every code, label, and route generated
-> during the BA must be reviewed for coherence, convention compliance, and clarity.
+→ **Load** `references/04-naming-audit-checks.md` for all naming validation rules and user interaction flows.
 
-**7ter-a. Collect all names from the BA:**
-
-```javascript
-const namingRegistry = {
-  application: {
-    label: application_name,
-    code: applicationCode,              // PascalCase
-    route: toKebabCase(applicationCode)  // kebab-case
-  },
-  modules: completedModules.map(m => ({
-    label: m.name,
-    code: m.code,                        // PascalCase
-    route: toKebabCase(m.code)           // kebab-case
-  })),
-  entities: completedModules.flatMap(m =>
-    m.entities.map(e => ({
-      name: e.name,                      // PascalCase (C# class name)
-      module: m.code,
-      tableName: e.tableName || pluralize(e.name)  // Plural convention
-    }))
-  ),
-  permissionRoots: [...new Set(
-    permissionPaths.map(p => p.path.split('.').slice(0, 2).join('.'))
-  )]
-};
-```
-
-**7ter-b. Display naming recap table:**
-
-```
-═══════════════════════════════════════════════════════════════
-  NAMING AUDIT — {application_name}
-═══════════════════════════════════════════════════════════════
-
-APPLICATION
-| Label | Code (PascalCase) | Route (kebab-case) |
-|-------|-------------------|--------------------|
-| {application_name} | {applicationCode} | /{route} |
-
-MODULES
-| # | Label | Code (PascalCase) | Route (kebab-case) |
-|---|-------|-------------------|--------------------|
-{for each module: index | label | code | /app-route/module-route}
-
-ENTITIES
-| Entity (PascalCase) | Module | Table (plural) |
-|----------------------|--------|----------------|
-{for each entity: name | module | tableName}
-
-PERMISSION ROOTS
-{for each root: path}
-═══════════════════════════════════════════════════════════════
-```
-
-**7ter-c. Coherence checks:**
-
-```javascript
-const namingIssues = [];
-
-// 1. Duplicate entity names across modules
-const entityNames = namingRegistry.entities.map(e => e.name);
-const duplicates = entityNames.filter((n, i) => entityNames.indexOf(n) !== i);
-if (duplicates.length > 0) {
-  namingIssues.push({ severity: "ERROR", issue: `Duplicate entity names: ${[...new Set(duplicates)].join(', ')}` });
-}
-
-// 2. Module code vs label coherence (code should derive logically from label)
-for (const mod of namingRegistry.modules) {
-  if (!mod.code || mod.code.length < 2) {
-    namingIssues.push({ severity: "ERROR", issue: `Module "${mod.label}" has invalid code: "${mod.code}"` });
-  }
-}
-
-// 3. Permission root alignment with module codes
-for (const root of namingRegistry.permissionRoots) {
-  const [appSegment, moduleSegment] = root.split('.');
-  const matchingModule = namingRegistry.modules.find(m =>
-    m.code.toLowerCase() === moduleSegment.toLowerCase()
-  );
-  if (!matchingModule) {
-    namingIssues.push({ severity: "WARNING", issue: `Permission root "${root}" has no matching module code` });
-  }
-}
-
-// 4. Route collision detection
-const allRoutes = namingRegistry.modules.map(m =>
-  `/${namingRegistry.application.route}/${m.route}`
-);
-const routeDuplicates = allRoutes.filter((r, i) => allRoutes.indexOf(r) !== i);
-if (routeDuplicates.length > 0) {
-  namingIssues.push({ severity: "ERROR", issue: `Route collisions: ${routeDuplicates.join(', ')}` });
-}
-```
-
-**7ter-d. MCP validation:**
-
-```
-mcp__smartstack__validate_conventions({
-  checks: ["tables"],
-  context: {
-    applicationCode: applicationCode,
-    modules: namingRegistry.modules.map(m => m.code),
-    entities: namingRegistry.entities.map(e => e.name)
-  }
-})
-
-→ Merge MCP findings into namingIssues[]
-```
-
-**7ter-e. Present findings and confirm:**
-
-```
-IF namingIssues.length > 0:
-  Display issues table:
-  | # | Severity | Issue |
-  |---|----------|-------|
-  {for each issue}
-```
-
-Ask via AskUserQuestion:
-```
-question: "{language == 'fr'
-  ? 'Validez-vous les noms ci-dessus pour l\\'ensemble de l\\'application ?'
-  : 'Do you approve all the names above for the entire application?'}"
-header: "Naming Audit"
-options:
-  - label: "{language == 'fr' ? 'Approuvé' : 'Approved'}"
-    description: "{language == 'fr' ? 'Tous les noms sont corrects' : 'All names are correct'}"
-  - label: "{language == 'fr' ? 'Renommer certains éléments' : 'Rename some elements'}"
-    description: "{language == 'fr' ? 'Corriger des noms avant de finaliser' : 'Fix names before finalizing'}"
-```
-
-**IF "Renommer certains éléments":**
-
-Ask via AskUserQuestion (open-ended):
-```
-question: "{language == 'fr'
-  ? 'Quels éléments souhaitez-vous renommer ? (ex: \"Module Ventes → Commerce\", \"Entity Invoice → BillingDocument\")'
-  : 'Which elements do you want to rename? (e.g., \"Module Sales → Commerce\", \"Entity Invoice → BillingDocument\")'}"
-header: "Renaming"
-```
-
-Process user response:
-1. Parse rename instructions
-2. Update `applicationCode`, module codes, entity names, permission paths accordingly in JSON files via ba-writer
-3. Re-run 7ter-c and 7ter-d checks on updated names
-4. Re-display the naming recap table for final confirmation
-
-**IF "Approuvé":**
-→ Store naming audit result in `validation.json`:
-```javascript
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "namingAudit",
-  data: {
-    auditedAt: now(),
-    issues: namingIssues,
-    approved: true,
-    renames: []  // or list of applied renames
-  }
-});
-```
-→ Continue to section 8
+This includes:
+- Collect all application, module, entity, and permission names into a registry
+- Display naming recap table (application code, module routes, entity tables, permission roots)
+- Execute coherence checks (duplicate entities, route collisions, permission root alignment)
+- Run MCP `validate_conventions` on entity/module names
+- Present findings via AskUserQuestion with approval and rename options
+- Process rename instructions if needed, re-validate, and continue to section 8
 
 ### 8. Consolidation Summary Display
 
@@ -537,16 +742,10 @@ RISKS
 
 ### 9. Client Approval (BLOCKING)
 
-**Single-Module Mode:** Auto-approve (no cross-module concerns)
+**Toujours demander l'approbation** — meme pour un module unique, jouer l'avocat du diable :
+proposer au moins 1 cas non mentionne ou 1 question de completude avant validation.
 
-```
-IF completedModules.length === 1:
-  Display: "Module unique - consolidation automatique ✓"
-  approval = { approved: true, reason: "Single module", approvedAt: now() }
-  SKIP to section 10
-```
-
-**Multi-Module Mode:** Ask via AskUserQuestion:
+Ask via AskUserQuestion:
 
 ```
 question: "La consolidation est complète. Validez-vous l'ensemble ?"
@@ -568,6 +767,14 @@ IF "Modifier les interactions":
 
 ### 10. Write Consolidation Data
 
+→ **Load** `references/04-file-allocation.md` for strict data allocation rules.
+
+**MANDATORY:** Data must be written to correct files:
+- `consolidation.json`: crossModuleInteractions, sharedEntities, permissionCoherence, e2eFlows, decision
+- `validation.json`: semanticChecks, contractChecks, namingAudit, acceptanceCriteria, globalRiskAssessment
+
+Mixing contents across files = BLOCKING ERROR.
+
 ```javascript
 ba-writer.enrichSection({
   featureId: {feature_id},
@@ -594,10 +801,6 @@ ba-writer.enrichSection({
       warnings: []
     },
     e2eFlows: e2eFlows,
-    globalRiskAssessment: risks,
-    semanticChecks: [
-      { check: "permission-orpheline", status: "PASS|WARNING", details: "..." }
-    ],
     decision: {
       approved: approval.approved,
       reason: approval.reason,
@@ -607,6 +810,34 @@ ba-writer.enrichSection({
   }
 });
 
+// Write validation.json — quality/audit data for downstream skills (C1)
+ba-writer.enrichSection({
+  featureId: {feature_id},
+  section: "validation",
+  data: {
+    semanticChecks: semanticChecks.map(check => ({
+      check: check.check,
+      status: errors.some(e => e.check === check.check) ? "ERROR"
+            : warnings.some(w => w.check === check.check) ? "WARNING" : "PASS",
+      details: [...errors, ...warnings]
+        .filter(r => r.check === check.check)
+        .map(r => `[${r.module}] ${r.details}`)
+    })),
+    contractChecks: [...errors, ...warnings].filter(r =>
+      ["br-calc-sans-formula", "computed-sans-br-calc", "uc-count-critical",
+       "uc-count-low", "permission-count-low", "missing-versioned-attributes"].includes(r.check)
+    ),
+    namingAudit: {
+      auditedAt: now(),
+      issues: namingIssues,
+      approved: true,
+      renames: []
+    },
+    acceptanceCriteria: acceptanceCriteria,  // from section 7bis
+    globalRiskAssessment: risks              // from section 7
+  }
+});
+
 // Add changelog entry
 ba-writer.enrichSection({
   featureId: {feature_id},
@@ -681,7 +912,7 @@ BA workflow complete. Next steps:
 - ✓ Permission coherence validated
 - ✓ Semantic checks: 0 errors
 - ✓ Naming audit completed and approved
-- ✓ Client approval obtained (or auto-approved for single module)
+- ✓ Client approval obtained
 - ✓ Consolidation section written to validation.json
 - ✓ Status updated to "consolidated"
 - ✓ Workflow state saved for resume support