@atlashub/smartstack-cli 3.8.0 → 3.10.0

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

@@ -126,6 +126,280 @@ ba-writer.enrichSection({
 })
 ```
 
+#### 9f. Module Specification Checklist (BLOCKING)
+
+> **CRITICAL:** This checklist MUST be FULLY COMPLETED before marking module status = "specified".
+> **Rationale:** Prevents incomplete modules from reaching handoff, reduces ralph-loop failures.
+
+**Execute BEFORE updating module status to "specified":**
+
+```javascript
+const checklist = {
+  // SECTION 1: DATA MODEL (BLOCKING)
+  entities: {
+    minimum: 2,
+    actual: specification.entities.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "At least 2 entities required for a meaningful module"
+  },
+
+  entityAttributes: {
+    check: "All entities have ≥3 attributes",
+    status: validateAllEntities(e => e.attributes.length >= 3) ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Entities with <3 attributes are likely incomplete"
+  },
+
+  entityRelationships: {
+    check: "All entities have relationships defined (or explicitly marked as standalone)",
+    status: validateEntityRelationships() ? "PASS" : "FAIL",
+    blocking: false,  // WARNING only
+    details: "Standalone entities should be rare in business modules"
+  },
+
+  // SECTION 2: BUSINESS RULES (BLOCKING)
+  businessRules: {
+    minimum: 4,
+    actual: analysis.businessRules.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Minimum 4 BRs (mix of VAL/CALC/WF/SEC/DATA)"
+  },
+
+  businessRuleCategories: {
+    check: "BRs cover ≥2 categories (VAL, CALC, WF, SEC, DATA)",
+    status: countUniqueCategories(analysis.businessRules) >= 2 ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Single-category modules are likely incomplete"
+  },
+
+  businessRulePrefixes: {
+    check: "All BR IDs use module prefix (e.g., BR-VAL-{PREFIX}-NNN)",
+    status: validateBRPrefixes() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Missing prefixes cause ID collisions in multi-module apps"
+  },
+
+  // SECTION 3: USE CASES & REQUIREMENTS (BLOCKING)
+  useCases: {
+    minimum: 6,
+    actual: specification.useCases.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Minimum 6 UCs (CRUD + 2 business-specific)"
+  },
+
+  useCasePrefixes: {
+    check: "All UC IDs use module prefix (UC-{PREFIX}-NNN)",
+    status: validateUCPrefixes() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Missing prefixes cause ID collisions"
+  },
+
+  functionalRequirements: {
+    minimum: 4,
+    actual: specification.functionalRequirements.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "FRs must cover key functionality"
+  },
+
+  ucFrLinkage: {
+    check: "Every UC has ≥1 linked FR",
+    status: validateUCtoFRLinkage() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Orphan UCs indicate incomplete requirements"
+  },
+
+  frBrLinkage: {
+    check: "Every FR has ≥1 linked BR",
+    status: validateFRtoBRLinkage() ? "PASS" : "FAIL",
+    blocking: false,  // WARNING only
+    details: "FRs without BRs may lack validation/calculation logic"
+  },
+
+  // SECTION 4: PERMISSIONS (BLOCKING)
+  permissions: {
+    minimum: 5,
+    actual: specification.permissionMatrix.permissions.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Minimum 5 permissions (CRUD + 1 business action)"
+  },
+
+  permissionFormat: {
+    check: "All permissions use full format: business.{app}.{module}.{resource}.{action}",
+    status: validatePermissionFormat() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Wrong format breaks RBAC system"
+  },
+
+  rolePermissions: {
+    check: "All application roles have ≥1 permission assigned",
+    status: validateRoleAssignments() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Roles without permissions are useless"
+  },
+
+  // SECTION 5: UI & NAVIGATION (BLOCKING)
+  sections: {
+    minimum: 2,
+    actual: specification.sections.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Modules need ≥2 sections (list + form minimum)"
+  },
+
+  wireframes: {
+    minimum: specification.sections.length,  // 1 wireframe PER section
+    actual: specification.uiWireframes.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "EVERY section MUST have a wireframe (ASCII/SVG)"
+  },
+
+  navigation: {
+    check: "Module has ≥1 navigation entry",
+    status: specification.navigation.entries.length >= 1 ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Module must be accessible in menu"
+  },
+
+  // SECTION 6: I18N & MESSAGES (BLOCKING)
+  i18nKeys: {
+    minimum: 42,  // Realistic minimum for a module
+    actual: specification.i18nKeys.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Keys needed: entities (×2), fields, messages, validation, navigation"
+  },
+
+  i18nLanguages: {
+    check: "All i18n keys have 4 languages (fr, en, nl, de)",
+    status: validateI18nCompleteness() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Missing translations break multi-language support"
+  },
+
+  messages: {
+    minimum: 4,
+    actual: specification.messages.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Minimum: 1 success, 1 error, 1 warning, 1 info"
+  },
+
+  // SECTION 7: SEED DATA (BLOCKING)
+  seedDataCore: {
+    check: "All 5 CORE seed data sections present",
+    requiredSections: [
+      "navigationModules",
+      "navigationTranslations",
+      "permissions",
+      "rolePermissions",
+      "permissionConstants"
+    ],
+    status: validateSeedDataCore() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Missing CORE seed data breaks module deployment"
+  },
+
+  seedDataBusiness: {
+    check: "Business seed data template defined (even if empty)",
+    status: specification.seedDataBusiness !== undefined ? "PASS" : "FAIL",
+    blocking: false,  // WARNING only
+    details: "Business seed data helps with testing"
+  },
+
+  // SECTION 8: API ENDPOINTS (BLOCKING)
+  apiEndpoints: {
+    minimum: 5,
+    actual: specification.apiEndpoints.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Minimum 5 endpoints (CRUD + 1 business action)"
+  },
+
+  apiPermissions: {
+    check: "Every API endpoint has permission defined",
+    status: validateAPIPermissions() ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Endpoints without permissions are security holes"
+  },
+
+  // SECTION 9: VALIDATIONS (BLOCKING)
+  validations: {
+    minimum: 1,
+    actual: specification.validations.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: true,
+    details: "Modules need field validation rules"
+  },
+
+  // SECTION 10: GHERKIN SCENARIOS (WARNING)
+  gherkinScenarios: {
+    minimum: 2,
+    actual: specification.gherkinScenarios.scenarios.length,
+    status: actual >= minimum ? "PASS" : "FAIL",
+    blocking: false,  // WARNING only
+    details: "Gherkin scenarios enable automated testing"
+  }
+};
+
+// BLOCKING CHECK: Count failures in BLOCKING items
+const blockingFailures = Object.entries(checklist)
+  .filter(([key, check]) => check.blocking === true && check.status === "FAIL")
+  .map(([key, check]) => ({ section: key, ...check }));
+
+IF blockingFailures.length > 0:
+  **BLOCKING ERROR:** Module specification incomplete
+
+  Display table:
+  | Section | Required | Actual | Status | Details |
+  |---------|----------|--------|--------|---------|
+  {for each blocking failure}
+
+  ACTIONS REQUIRED:
+  1. Fix ALL blocking failures listed above
+  2. Re-run step-03d validation
+  3. DO NOT mark module as "specified" until ALL blocking checks pass
+
+  STOP - DO NOT PROCEED TO UPDATE STATUS
+ELSE:
+  All blocking checks passed ✓
+  {count} warnings (non-blocking)
+  Proceed to mark module as "specified"
+```
+
+**Display Checklist Summary:**
+
+```
+═══════════════════════════════════════════════════════════════
+  MODULE SPECIFICATION CHECKLIST - {currentModule}
+═══════════════════════════════════════════════════════════════
+
+| Category | Checks | Passed | Failed | Warnings |
+|----------|--------|--------|--------|----------|
+| Data Model | 3 | {n} | {n} | {n} |
+| Business Rules | 3 | {n} | {n} | {n} |
+| Use Cases & FRs | 4 | {n} | {n} | {n} |
+| Permissions | 3 | {n} | {n} | {n} |
+| UI & Navigation | 3 | {n} | {n} | {n} |
+| I18N & Messages | 3 | {n} | {n} | {n} |
+| Seed Data | 2 | {n} | {n} | {n} |
+| API Endpoints | 2 | {n} | {n} | {n} |
+| Validations | 1 | {n} | {n} | {n} |
+| Gherkin | 1 | {n} | {n} | {n} |
+
+TOTAL: {total_checks} checks | {passed} ✓ | {failed} ✗ | {warnings} ⚠
+
+STATUS: {failed === 0 ? "READY FOR SPECIFIED" : "INCOMPLETE - FIX REQUIRED"}
+═══════════════════════════════════════════════════════════════
+```
+
+**IF ALL BLOCKING CHECKS PASS → Proceed to update module status to "specified"**
+
 ---
 
 ### 10. Module Summary with Roles & Permissions
@@ -228,56 +502,11 @@ ba-writer.updateModuleStatus({feature_id}, {currentModule.code}, "specified")
 ### 11-bis. Deploy Incremental Interactive HTML (MANDATORY)
 
 > **After each module is specified, deploy/update the interactive HTML document with all available data.**
-> This allows the client to review completed modules while the next module is being specified.
-> The HTML is incrementally enriched: after module 1, only module 1 specs appear; after module 2, both appear; etc.
-
-**Source:** `html/ba-interactive.html` (relative to skill root = `~/.claude/skills/business-analyse/html/`)
+> The client can review completed modules while the next module is being specified.
 
-**Destination:** `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`
-
-**Steps:**
-
-1. **Read sources:**
-   - Read the HTML template from skill directory
-   - Read the master feature.json (application level — now updated with current module status)
-   - Read EACH completed module's feature.json (including the one just specified)
-
-2. **Build FEATURE_DATA object:**
-
-   > **Use the EXACT SAME mapping defined in step-05b-deploy.md and references/html-data-mapping.md.**
-   > The mapping is identical — the only difference is that `moduleSpecs` only includes completed modules.
-   > Modules not yet specified will NOT appear in `moduleSpecs` (their entry in `modules[]` will show `status: "pending"`).
-
-   Follow step-05 section 9d "Step 2: Build FEATURE_DATA object" for the complete mapping pseudocode:
-   - `metadata`, `cadrage`, `modules[]`, `dependencies[]` → from master feature.json
-   - `moduleSpecs[moduleCode]` → only for modules with status "specified" (completed so far)
-   - `consolidation` → empty `{ interactions: [], e2eFlows: [] }` (not yet consolidated)
-   - `handoff` → empty `{}` (not yet handed off)
-
-3. **Replace placeholders in template:**
-   - Serialize the FEATURE_DATA object as JSON (2-space indentation)
-   - Replace `{{FEATURE_DATA}}` with the serialized JSON
-   - Replace `{{APPLICATION_NAME}}` → `{application_name}`
-   - Replace `{{APPLICATION_ID}}` → `{feature_id}`
-   - Replace `{{VERSION}}` → `{version}`
-   - Replace `{{CREATED_AT}}` → `{ISO timestamp}`
-
-4. **Write and confirm:**
-
-```
-✓ Interactive HTML updated (incremental):
-  Path: docs/business/{app}/business-analyse/v{version}/ba-interactive.html
-  Modules included: {completedModules.length}/{totalModules} specified
-    - {completedModule1}: {uc_count} UCs, {br_count} BRs, {entity_count} entities
-    - {completedModule2}: ...
-  Remaining: {pendingModules.join(', ')} (will be added after specification)
-  → Client can open in browser to review completed modules now.
-```
+See [references/validate-incremental-html.md](../references/validate-incremental-html.md) for the complete deployment process (read sources, build FEATURE_DATA, replace placeholders, write HTML).
 
-> **WHY incremental?** The client doesn't have to wait until handoff to start reviewing.
-> While module 2 is being specified, the client can already give feedback on module 1.
-> Each incremental deployment OVERWRITES the previous HTML (latest state always).
-> The FINAL deployment at step-05 (handoff) will include consolidation and handoff data.
+Uses the **same mapping** as step-05b-deploy.md — only difference is `moduleSpecs` only includes completed modules.
 
 ---
 

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

@@ -113,6 +113,172 @@ Identify shared lookup/reference tables:
 }
 ```
 
+**2e. Cross-Module Reference Validation (ENHANCED)**
+
+> **CRITICAL:** Verify ALL cross-module entity references are resolvable.
+> **Purpose:** Prevent broken FK references and runtime errors in ralph-loop.
+
+**Process:**
+
+1. **Build Entity Registry:**
+   ```javascript
+   const entityRegistry = {};
+   for (const module of completedModules) {
+     entityRegistry[module.code] = {
+       entities: module.analysis.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"
+       }))
+     };
+   }
+   ```
+
+2. **Extract Cross-Module References:**
+
+   For EACH module, scan all entity relationships:
+   ```javascript
+   for (const entity of module.analysis.entities) {
+     for (const rel of entity.relationships) {
+       // Detect cross-module reference
+       if (rel.target.includes(".")) {
+         // Format: "ModuleName.EntityName.FieldName" or "ModuleName.EntityName"
+         const [targetModule, targetEntity, targetField] = rel.target.split(".");
+
+         // Validate: target module exists
+         if (!entityRegistry[targetModule]) {
+           BLOCKING_ERROR(`Module ${module.code}: Entity ${entity.name} references non-existent module "${targetModule}"`);
+         }
+
+         // Validate: target entity exists in target module
+         const targetModuleEntities = entityRegistry[targetModule].entities;
+         const resolvedEntity = targetModuleEntities.find(e => e.name === targetEntity);
+         if (!resolvedEntity) {
+           BLOCKING_ERROR(`Module ${module.code}: Entity ${entity.name} references non-existent entity "${targetEntity}" in module "${targetModule}"`);
+         }
+
+         // Validate: target field exists (if specified)
+         if (targetField && !resolvedEntity.attributes.includes(targetField)) {
+           BLOCKING_ERROR(`Module ${module.code}: Entity ${entity.name} references non-existent field "${targetField}" on "${targetModule}.${targetEntity}"`);
+         }
+
+         // Record valid reference
+         crossModuleReferences.push({
+           sourceModule: module.code,
+           sourceEntity: entity.name,
+           sourceField: rel.sourceField || `${targetEntity}Id`,
+           targetModule,
+           targetEntity,
+           targetField: targetField || resolvedEntity.pk,
+           type: rel.type,
+           cardinality: rel.cardinality || "N:1",
+           status: "RESOLVED"
+         });
+       }
+     }
+   }
+   ```
+
+3. **Validate Dependency Graph Alignment:**
+
+   ```javascript
+   // For each cross-module reference, verify dependency edge exists
+   for (const ref of crossModuleReferences) {
+     const dependencyExists = dependencyGraph.edges.find(edge =>
+       edge.from === ref.sourceModule && edge.to === ref.targetModule
+     );
+
+     if (!dependencyExists) {
+       WARNING(`Dependency missing: ${ref.sourceModule} → ${ref.targetModule}`);
+       WARNING(`Reason: ${ref.sourceEntity}.${ref.sourceField} references ${ref.targetModule}.${ref.targetEntity}`);
+
+       // Auto-fix: add missing dependency edge
+       dependencyGraph.edges.push({
+         from: ref.sourceModule,
+         to: ref.targetModule,
+         type: "FK",
+         reason: `${ref.sourceEntity}.${ref.sourceField} → ${ref.targetEntity}`
+       });
+
+       // Recalculate topological order
+       topologicalOrder = calculateTopologicalOrder(dependencyGraph);
+     }
+   }
+   ```
+
+4. **Display Cross-Module Reference Map:**
+
+   ```
+   ═══════════════════════════════════════════════════════════════
+     CROSS-MODULE REFERENCES VALIDATED
+   ═══════════════════════════════════════════════════════════════
+
+   | Source Module | Source Entity | Target | Type | Status |
+   |---------------|---------------|--------|------|--------|
+   | TimeTracking | TimeEntry | Projects.Project.Id | FK (N:1) | ✓ RESOLVED |
+   | LeaveManagement | LeaveRequest | Projects.Employee.Id | FK (N:1) | ✓ RESOLVED |
+   | AbsenceManagement | Absence | Projects.Employee.Id | FK (N:1) | ✓ RESOLVED |
+   | Reporting | ProjectReport | Projects.Project.Id | FK (N:1) | ✓ RESOLVED |
+
+   Total: {count} cross-module references
+   All references RESOLVED ✓
+   ═══════════════════════════════════════════════════════════════
+   ```
+
+5. **Detect Circular Dependencies:**
+
+   ```javascript
+   const cycles = detectCycles(dependencyGraph);
+
+   if (cycles.length > 0) {
+     BLOCKING_ERROR("Circular dependencies detected:");
+     for (const cycle of cycles) {
+       ERROR(`  ${cycle.join(" → ")}`);
+     }
+
+     ACTIONS:
+     1. Review module dependencies
+     2. Break cycles by:
+        - Moving shared entities to a separate "Core" module
+        - Using event-driven communication instead of FK
+        - Removing unnecessary dependencies
+     3. Re-run step-02 decomposition with fixed dependencies
+
+     STOP - DO NOT PROCEED TO HANDOFF
+   }
+   ```
+
+6. **Store Cross-Module Interaction Data:**
+
+   ```javascript
+   ba-writer.enrichSection({
+     featureId: {feature_id},
+     section: "consolidation",
+     data: {
+       crossModuleInteractions: crossModuleReferences.map(ref => ({
+         fromModule: ref.sourceModule,
+         toModule: ref.targetModule,
+         interactionType: "FK_REFERENCE",
+         description: `${ref.sourceEntity}.${ref.sourceField} → ${ref.targetModule}.${ref.targetEntity}.${ref.targetField}`,
+         entities: [ref.sourceEntity, ref.targetEntity],
+         cardinality: ref.cardinality,
+         status: ref.status
+       }))
+     }
+   });
+   ```
+
+**Success Criteria:**
+- ✓ All cross-module references resolved
+- ✓ Dependency graph aligned with actual references
+- ✓ No circular dependencies
+- ✓ Topological order valid
+
+**Failure Handling:**
+- BLOCKING errors for unresolved references
+- Auto-fix missing dependency edges (with warning)
+- Manual intervention required for circular dependencies
+
 ### 3. Permission Coherence
 
 > **All modules MUST use the same application-level roles.**
@@ -212,112 +378,17 @@ Store results in consolidation.semanticChecks[]:
 
 ### 4-bis. Structural Schema Conformity Check (MANDATORY)
 
-> **Post-generation validation.** After semantic checks, verify that ALL module feature.json files conform to the JSON schema structure. This catches field name mismatches, missing sections, and wrong nesting.
-
-For EACH module feature.json, run these structural checks:
-
-**A. Required Sections Presence**
-
-| Section | Required | Check |
-|---------|----------|-------|
-| `metadata` | YES | Must have: app, module, language, featureDescription, featureType |
-| `discovery` | YES | Must exist (even if minimal) |
-| `analysis.entities[]` | YES | Must have ≥1 entity |
-| `analysis.businessRules[]` | YES | Must have ≥1 BR |
-| `analysis.objectives[]` | YES | Must have ≥1 objective |
-| `analysis.processFlow` | YES | Must have entryPoints, mainFlow, decisionPoints |
-| `analysis.dataLifecycle` | YES | Must have retention, archival, deletion, gdprRelevant |
-| `specification.useCases[]` | YES | Must have ≥1 UC |
-| `specification.functionalRequirements[]` | YES | Must have ≥1 FR |
-| `specification.permissionMatrix` | YES | Must be `{permissions[], roleAssignments[]}` (NOT flat array) |
-| `specification.sections[]` | YES | Must have ≥1 section with resources |
-| `specification.uiWireframes[]` | YES | Must have ≥1 wireframe with `layout` object |
-| `specification.lifeCycles[]` | IF entities have status | States must be objects (NOT strings) |
-| `specification.seedDataCore` | YES | Must have 5 arrays: navigationModules, navigationTranslations, permissions, rolePermissions, permissionConstants |
-| `specification.gherkinScenarios` | YES | Must be `{feature, scenarios[]}` (NOT flat array) |
-| `specification.navigation` | YES | Must have entries[] |
-| `specification.i18nKeys[]` | YES | Must have ≥1 key with fr, en, nl, de |
-| `validation` | YES | Must have completenessChecks, consistencyChecks, semanticChecks, decision |
-| `handoff` | Written by step-05 | Checked post-handoff |
-
-**B. Field Name Conformity**
-
-For each section, verify NO FORBIDDEN field names are used:
-
-| Section | FORBIDDEN fields | Correct fields |
-|---------|-----------------|----------------|
-| `entities[].attributes[]` | `type`, `values`, `rules` | `description`, `unique`, `validation` |
-| `businessRules[]` | `rule`, `condition` (singular), `action` | `name`, `statement`, `conditions[]` |
-| `useCases[]` | `actor`, `linkedBRs`, `linkedFRs` | `primaryActor`, `linkedRules` |
-| `functionalRequirements[]` | `name`, `description`, `linkedUCs`, `linkedBRs` | `statement`, `linkedUseCases`, `linkedRules` |
-| `permissionMatrix` | flat array with `resource`/`roles` | `{permissions[], roleAssignments[]}` |
-| `lifeCycles[].states[]` | string values like `"Active"` | objects with `{id, displayName, color, isTerminal}` |
-| `seedDataCore` | flat object, string values | 5 typed arrays |
-| `gherkinScenarios` | flat scenario array | `{feature, scenarios[]}` nested |
-
-**C. ID Pattern Conformity**
-
-| ID Type | Pattern | Example |
-|---------|---------|---------|
-| BR | `BR-(VAL\|CALC\|WF\|SEC\|DATA)-{PREFIX}-\d{3}` | BR-VAL-RM-001 |
-| UC | `UC-{PREFIX}-\d{3}` | UC-RM-001 |
-| FR | `FR-{PREFIX}-\d{3}` | FR-RM-001 |
-| Permissions | `business.{app}.{module}.{resource}.{action}` | business.freebike.repairs.create |
-
-Verify all IDs use the correct module prefix (2-4 uppercase letters).
-
-**D. Cross-Module ID Uniqueness**
-
-Verify no ID collision across modules:
-```
-SET all_ids = {}
-FOR each module:
-  FOR each BR, UC, FR id:
-    IF id IN all_ids → ERROR: "Duplicate {id} in {module1} and {module2}"
-    ADD id to all_ids
-```
-
-**E. Wireframe Layout Completeness**
-
-For each `uiWireframes[]`:
-```
-IF missing componentMapping[] → ERROR
-IF missing layout object → ERROR
-IF missing layout.regions[] → ERROR
-FOR each region in layout.regions[]:
-  IF missing position → ERROR
-  IF missing components[] → ERROR
-```
-
-**F. SeedDataCore Translation Coverage**
+> **Post-generation validation.** After semantic checks, verify ALL module feature.json files conform to JSON schema.
 
-```
-FOR each navigationModules[].code:
-  FOR each language in [fr, en, nl, de]:
-    IF NOT EXISTS navigationTranslations[] with moduleCode AND language → ERROR
-```
+See [references/consolidation-structural-checks.md](../references/consolidation-structural-checks.md) for the full 6-category structural check:
+- **A.** Required Sections Presence (18 sections)
+- **B.** Field Name Conformity (forbidden vs correct fields)
+- **C.** ID Pattern Conformity (BR, UC, FR, Permissions)
+- **D.** Cross-Module ID Uniqueness
+- **E.** Wireframe Layout Completeness
+- **F.** SeedDataCore Translation Coverage
 
-**Result aggregation:**
-```json
-{
-  "structuralChecks": [
-    { "check": "required-sections", "module": "...", "status": "PASS|ERROR", "details": "Missing: analysis.objectives" },
-    { "check": "field-names", "module": "...", "status": "PASS|ERROR", "details": "businessRules[0] uses 'rule' instead of 'name'+'statement'" },
-    { "check": "id-patterns", "module": "...", "status": "PASS|ERROR", "details": "BR-001 missing category segment" },
-    { "check": "id-uniqueness", "module": "...", "status": "PASS|ERROR", "details": "UC-RM-003 duplicated in Vehicles and Repairs" },
-    { "check": "wireframe-layout", "module": "...", "status": "PASS|ERROR", "details": "Wireframe repairs-list missing layout object" },
-    { "check": "seeddata-translations", "module": "...", "status": "PASS|ERROR", "details": "Missing nl translation for NavigationModuleRepairs" }
-  ]
-}
-```
-
-**Blocking rule:**
-- 0 ERROR → PASS (merge structuralChecks into consolidation.semanticChecks[])
-- ≥1 ERROR → BLOCK. For each ERROR:
-  1. Attempt AUTO-FIX (rename fields, restructure)
-  2. Re-write the module feature.json with fixes
-  3. Re-check
-  4. If still ERROR → ask user
+**Blocking rule:** 0 ERROR → PASS. ≥1 ERROR → BLOCK (attempt auto-fix, re-write, re-check).
 
 ### 5. End-to-End Flows