@atlashub/smartstack-cli 4.23.0 → 4.24.0

package/templates/skills/derive-prd/references/readiness-scoring.md

@@ -1,41 +1,35 @@
 # Readiness Scoring Algorithm
 
 > **Used by:** step-00-validate (section 4: Calculate Readiness Score)
-> **Purpose:** Evaluate module readiness for handoff based on acceptance criteria from validation-checklist.md.
+> **Purpose:** Evaluate module readiness for handoff based on input acceptance criteria.
 
 ---
 
 ## Algorithm
 
-For each module, evaluate all acceptance criteria (AC-01 to AC-17) from `references/acceptance-criteria.md`.
+For each module, evaluate **input** acceptance criteria (AC-01 to AC-07) from `references/acceptance-criteria.md`.
+
+Output ACs (AC-08 to AC-11) are checked **after** step-01 transform, not here.
 
 ### Score Calculation
 
 ```javascript
-const blockingACs = ['AC-01', 'AC-02', 'AC-03', 'AC-04', 'AC-05', 'AC-06', 'AC-07',
-                     'AC-08', 'AC-09', 'AC-10', 'AC-11', 'AC-12', 'AC-13',
-                     'AC-15', 'AC-16', 'AC-17'];  // 16 blocking
-const nonBlockingACs = ['AC-14'];  // 1 non-blocking (warning only)
+const inputACs = ['AC-01', 'AC-02', 'AC-03', 'AC-04', 'AC-05', 'AC-06', 'AC-07'];
 
 // Count passes
-const blockingPassed = blockingACs.filter(ac => results[ac] === 'PASS').length;
-const blockingTotal = blockingACs.length;
-const nonBlockingPassed = nonBlockingACs.filter(ac => results[ac] === 'PASS').length;
-const nonBlockingTotal = nonBlockingACs.length;
-
-// Scores
-const blockingScore = (blockingPassed / blockingTotal) * 100;  // Must be 100%
-const nonBlockingScore = (nonBlockingPassed / nonBlockingTotal) * 100;  // Warn if < 80%
+const passed = inputACs.filter(ac => results[ac] === 'PASS').length;
+const total = inputACs.length;
+
+// Score
+const score = (passed / total) * 100;  // Must be 100%
 ```
 
 ### Gate Rules
 
 | Condition | Action |
 |-----------|--------|
-| Blocking score = 100% | PASS — module ready for handoff |
-| Blocking score < 100% | BLOCKING — list failed ACs, require fix |
-| Non-blocking score >= 80% | OK — proceed normally |
-| Non-blocking score < 80% | WARNING — suggest fixes but don't block |
+| Score = 100% | PASS — module ready for transform |
+| Score < 100% | BLOCKING — list failed ACs, require fix |
 
 ---
 
@@ -46,39 +40,43 @@ const nonBlockingScore = (nonBlockingPassed / nonBlockingTotal) * 100;  // Warn
 ```javascript
 {
   moduleCode: "Employees",
-  blockingScore: 100,        // percentage
-  blockingPassed: 16,
-  blockingTotal: 16,
-  nonBlockingScore: 100,
-  nonBlockingPassed: 1,
-  nonBlockingTotal: 1,
+  score: 100,
+  passed: 7,
+  total: 7,
   ready: true,
-  failedACs: [],             // empty if ready
-  warnings: []               // non-blocking failures
+  failedACs: [],
+  details: {
+    entities: 2,
+    useCases: 6,
+    rules: 8,
+    screens: 4,
+    permissions: 5,
+    status: "specified"
+  }
 }
 ```
 
 ### Readiness Table
 
 ```
-┌──────────────┬──────────┬────────────┬──────────────┬────────┐
-│ Module       │ Status   │ Blocking   │ Non-blocking │ Ready  │
-├──────────────┼──────────┼────────────┼──────────────┼────────┤
-│ Employees    │ consol.  │ 16/16 100% │ 1/1 100%     │ YES    │
-│ Absences     │ consol.  │ 14/16  88% │ 1/1 100%     │ NO     │
-└──────────────┴──────────┴────────────┴──────────────┴────────┘
++--------------+----------+-----------+-------+
+| Module       | Status   | Score     | Ready |
++--------------+----------+-----------+-------+
+| Employees    | specif.  | 7/7 100%  | YES   |
+| Absences     | specif.  | 5/7  71%  | NO    |
++--------------+----------+-----------+-------+
 ```
 
 ### Failure Detail (when blocked)
 
 ```
-Module "Absences" — 2 blocking ACs FAILED:
+Module "Absences" -- 2 input ACs FAILED:
 
-  FAIL AC-05: wireframes >= 1 = 0 (min: 1)
-    Recovery: Re-run /business-analyse step-03 wireframe generation
+  FAIL AC-05: screens = 0 (min: 1)
+    Recovery: Re-run /business-analyse screen specification
 
-  FAIL AC-09: seedDataCore 9 arrays = 7 (min: 9)
-    Recovery: Re-run /business-analyse step-03 seedDataCore transform
+  FAIL AC-06: permissions = 0 (min: 1)
+    Recovery: Re-run /business-analyse permission specification
 ```
 
 ---
@@ -89,16 +87,9 @@ Each failed AC has a specific recovery action (from `references/acceptance-crite
 
 | AC | Recovery |
 |----|----------|
-| AC-01/02 | Re-run step-03 entity specification |
-| AC-03/04 | Re-run step-03 use case / functional requirements |
-| AC-05/06/07 | Re-run step-03 wireframe generation |
-| AC-08 | Re-run step-03 section definition |
-| AC-09 | Re-run step-03 seedDataCore transform |
-| AC-10 | Auto-fix: wrap in array |
-| AC-11 | Re-run step-03 API endpoints |
-| AC-12 | Re-run step-03 messages |
-| AC-13 | Re-run step-03 validations |
-| AC-14 | Auto-fix: rename fields (non-blocking) |
-| AC-15 | Auto-fix: wrap string in array |
-| AC-16 | Auto-fix: copy description to message |
-| AC-17 | Re-run step-03 gherkin |
+| AC-01/02 | Re-run /business-analyse entity specification |
+| AC-03 | Re-run /business-analyse use case specification |
+| AC-04 | Re-run /business-analyse business rules |
+| AC-05 | Re-run /business-analyse screen specification |
+| AC-06 | Re-run /business-analyse permission specification |
+| AC-07 | Run /business-analyse step-04 consolidation |

package/templates/skills/derive-prd/schemas/handoff-schema.json

@@ -27,7 +27,7 @@
         "type": "object",
         "required": ["ruleId", "implementationPoints"],
         "properties": {
-          "ruleId": { "type": "string", "description": "BR-XXX identifier from analysis.businessRules" },
+          "ruleId": { "type": "string", "description": "BR-XXX identifier from rules.json > rules[]" },
           "title": { "type": "string" },
           "implementationPoints": {
             "type": "array",
@@ -47,7 +47,7 @@
     },
     "apiEndpointSummary": {
       "type": "array",
-      "description": "Subset of specification.apiEndpoints enriched with linkedUC. MUST use EXACT same routes as specification.",
+      "description": "API endpoints generated from usecases.json + entities.json during step-01 transform.",
       "items": {
         "type": "object",
         "properties": {

package/templates/skills/derive-prd/steps/step-00-validate.md

@@ -1,6 +1,6 @@
 ---
 name: step-00-validate
-description: Detect input, validate BA readiness, acceptance criteria gate
+description: Detect input, validate BA readiness with flat-file support, AC gate
 model: sonnet
 next_step: steps/step-01-transform.md
 ---
@@ -11,14 +11,16 @@ next_step: steps/step-01-transform.md
 
 ## MANDATORY EXECUTION RULES
 
-- **ALWAYS** verify status = "consolidated" for all modules before proceeding
-- **ALWAYS** validate acceptance criteria (AC-01 to AC-17) per module
-- **BLOCKING** if any module has readiness score < 100% on blocking ACs
+- **ALWAYS** verify status = "consolidated" or "specified" for all modules before proceeding
+- **ALWAYS** validate **input** acceptance criteria (AC-01 to AC-07) per module
+- **ALWAYS** load flat files (entities.json, usecases.json, etc.) from module directories
+- **BLOCKING** if any module has readiness score < 100% on input ACs
 - **NEVER** proceed to transform if any module fails readiness gate
+- **NEVER** check output ACs (AC-08+) here — those are checked after step-01 transform
 
 ## YOUR TASK
 
-Detect the BA feature input, verify all modules are consolidated, validate acceptance criteria as a pre-gate, calculate readiness scores, and display the readiness table.
+Detect the BA feature input, verify all modules are consolidated/specified, validate input acceptance criteria as a pre-gate, calculate readiness scores, and display the readiness table.
 
 ---
 
@@ -42,85 +44,104 @@ ELSE:
     STOP
 ```
 
-### 2. Load Feature & Verify Consolidation
+### 2. Load Feature & Resolve Module Paths
 
 ```
-// Determine workflow mode
-IF project-level index.json exists:
-  projectFeature = ba-reader.findProjectFeature()
-  FOR each app in projectFeature.applications:
-    appFeature = ba-reader.findFeature(app.featureJsonPath)
-    IF appFeature.status !== "consolidated":
-      BLOCKING ERROR: "Application {app.code} not consolidated (status: {appFeature.status})"
-      → Run /business-analyse step-04 first
-  feature = projectFeature
-  modules = projectFeature.applications.flatMap(app => app.modules)
-ELSE:
-  feature = ba-reader.findFeature(featurePath)
-  IF feature.status !== "consolidated":
-    BLOCKING ERROR: "Feature status: {feature.status}, expected consolidated"
-    → Run /business-analyse step-04 first
-  modules = feature.modules
+// Read application-level index.json
+appIndex = READ(featurePath/index.json)
+
+// Resolve module directories
+// Modules are stored in: docs/{AppCode}/{ModuleCode}/business-analyse/v{X.Y}/
+FOR each module in appIndex.modules:
+  moduleDir = docs/{appIndex.metadata.applicationCode}/{module.code}/business-analyse/v{version}/
+  IF moduleDir/index.json exists:
+    module.baDir = moduleDir
+  ELSE:
+    BLOCKING ERROR: "Module {module.code} directory not found at {moduleDir}"
+```
+
+### 3. Verify Module Status
+
+```
+FOR each module:
+  moduleIndex = READ(module.baDir/index.json)
+  IF moduleIndex.metadata.status NOT IN ["consolidated", "specified"]:
+    BLOCKING ERROR: "Module {module.code} status: {status}, expected consolidated or specified"
+    -> Run /business-analyse to complete specification first
 ```
 
-### 3. Validate Acceptance Criteria Per Module
+### 4. Load Flat Files Per Module
 
-For **EACH module**, run the acceptance criteria bash script from `references/acceptance-criteria.md`:
+For each module, load the separate JSON files referenced in `index.json > files`:
+
+```javascript
+// Module index.json contains file references:
+// { "files": { "entities": { "path": "entities.json" }, "usecases": { "path": "usecases.json" }, ... } }
+
+const moduleData = {
+  index: READ(moduleDir + '/index.json'),
+  entities: READ(moduleDir + '/entities.json').entities || [],
+  useCases: READ(moduleDir + '/usecases.json').useCases || [],
+  rules: READ(moduleDir + '/rules.json').rules || [],
+  permissions: READ(moduleDir + '/permissions.json'),
+  screens: READ(moduleDir + '/screens.json').screens || []
+};
+```
+
+### 5. Validate Input Acceptance Criteria Per Module
+
+For **EACH module**, run the **input** AC bash script from `references/acceptance-criteria.md`:
 
 ```bash
-MODULE_JSON="{module_feature_json_path}"
+MODULE_DIR="{module_ba_dir}"
 node -e "
 const fs = require('fs');
-const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf-8'));
-// ... (full AC-01 to AC-17 script from references/acceptance-criteria.md)
-" "$MODULE_JSON"
+const path = require('path');
+const dir = process.argv[1];
+// ... (full input AC script from references/acceptance-criteria.md)
+" "$MODULE_DIR"
 ```
 
-Collect results per module: PASS count, FAIL count, WARNING count.
+Collect results per module: PASS count, FAIL count.
 
-### 4. Calculate Readiness Score
+### 6. Calculate Readiness Score
 
 > **Reference:** Read `references/readiness-scoring.md` for the full algorithm.
 
 For each module:
-- Count blocking ACs passed vs total blocking ACs
-- Score = (blocking passed / blocking total) x 100
-- Non-blocking score = (non-blocking passed / non-blocking total) x 100
+- Count input ACs passed vs total (7 input ACs)
+- Score = (passed / 7) x 100
 
-### 5. Apply Readiness Gate
+### 7. Apply Readiness Gate
 
 ```
 FOR each module:
   IF readiness_score < 100%:
-    BLOCKING ERROR: "Module {moduleCode} readiness: {score}% — {failed_count} blocking ACs failed"
+    BLOCKING ERROR: "Module {moduleCode} readiness: {score}% -- {failed_count} input ACs failed"
     Display failed ACs with recovery actions
-    → Run /business-analyse to fix, then retry /derive-prd
+    -> Run /business-analyse to fix, then retry /derive-prd
     STOP
-
-  IF non_blocking_score < 80%:
-    WARNING: "Module {moduleCode} non-blocking score: {score}% — consider fixing before handoff"
 ```
 
-### 6. Display Readiness Table
+### 8. Display Readiness Table
 
 ```
-══════════════════════════════════════════════════════════════
-  DERIVE-PRD — BA READINESS VALIDATION
-══════════════════════════════════════════════════════════════
+================================================================
+  DERIVE-PRD -- BA READINESS VALIDATION
+================================================================
 
 Feature: {feature_name}
-Applications: {app_count} (project mode only)
 Modules: {module_count}
 
-┌──────────────┬──────────┬────────────┬──────────────┬────────┐
-│ Module       │ Status   │ Blocking   │ Non-blocking │ Ready  │
-├──────────────┼──────────┼────────────┼──────────────┼────────┤
-│ {module1}    │ consol.  │ 16/16 100% │ 1/1 100%     │ YES    │
-│ {module2}    │ consol.  │ 16/16 100% │ 1/1 100%     │ YES    │
-└──────────────┴──────────┴────────────┴──────────────┴────────┘
++--------------+----------+-----------+-------+---------+
+| Module       | Status   | Score     | Ready | Details |
++--------------+----------+-----------+-------+---------+
+| {module1}    | specif.  | 7/7 100%  | YES   | E:2 UC:6 BR:8 S:4 P:5 |
+| {module2}    | specif.  | 7/7 100%  | YES   | E:3 UC:8 BR:10 S:6 P:6 |
++--------------+----------+-----------+-------+---------+
 
-→ All modules READY — proceeding to transform...
-══════════════════════════════════════════════════════════════
+-> All modules READY -- proceeding to transform...
+================================================================
 ```
 
 ---

package/templates/skills/derive-prd/steps/step-01-transform.md

@@ -1,6 +1,6 @@
 ---
 name: step-01-transform
-description: Build handoff data per module - 8 categories with all gap fixes
+description: Build handoff data per module - 8 categories from flat BA files
 model: sonnet
 next_step: steps/step-02-export.md
 ---
@@ -12,17 +12,45 @@ next_step: steps/step-02-export.md
 ## MANDATORY EXECUTION RULES
 
 - **ALWAYS** process modules in topological order (dependencies first)
+- **ALWAYS** load data from **flat files** (entities.json, usecases.json, rules.json, screens.json, permissions.json)
 - **ALWAYS** map to 8 categories (including "documentation")
-- **ALWAYS** propagate personRoleConfig verbatim from analysis.entities[]
+- **ALWAYS** propagate personRoleConfig verbatim from entities
 - **ALWAYS** separate seedData into core/business categories
 - **ALWAYS** map entity to domain file path (1:1)
 - **ALWAYS** include dependencies[] per file entry
-- **NEVER** invent entities/FRs/BRs not in module JSON files
-- **ALL** API routes from specification.apiEndpoints (exact copy)
+- **NEVER** invent entities/BRs not in module JSON files
+- **ALWAYS** generate API endpoints from use cases + entities (BA does not produce apiEndpoints)
 
 ## YOUR TASK
 
-For each module in topological order, build the complete handoff data with 8 file categories, BR-to-code mapping, API endpoint summary, and write to feature.json via ba-writer.
+For each module in topological order, load flat BA files, build the complete handoff data with 8 file categories, BR-to-code mapping, API endpoint summary, and write to feature.json via ba-writer.
+
+---
+
+## DATA LOADING (Flat-File Architecture)
+
+For each module, load data from separate files:
+
+```javascript
+// Module BA directory: docs/{AppCode}/{ModuleCode}/business-analyse/v{X.Y}/
+const moduleDir = module.baDir;  // resolved in step-00
+
+const entities    = READ(moduleDir + '/entities.json').entities || [];
+const useCases    = READ(moduleDir + '/usecases.json').useCases || [];
+const rules       = READ(moduleDir + '/rules.json').rules || [];
+const permissions = READ(moduleDir + '/permissions.json');
+const screens     = READ(moduleDir + '/screens.json').screens || [];
+```
+
+**Source mapping (flat files -> handoff categories):**
+
+| Handoff needs | Source file | Root key |
+|---------------|------------|----------|
+| Entities, ValueObjects, Enums | `entities.json` | `entities[]` |
+| Use cases | `usecases.json` | `useCases[]` |
+| Business rules | `rules.json` | `rules[]` |
+| Roles, permissions | `permissions.json` | `roles[]`, `matrix[]`, `permissionPaths[]` |
+| Screens, sections, wireframes | `screens.json` | `screens[]` |
 
 ---
 
@@ -52,25 +80,40 @@ For **EACH module** in topological order:
 
 **Global complexity** = highest across all modules.
 
-### 2. Map Specification to Files (8 Categories)
+### 2. Generate API Endpoints from Use Cases
+
+Since `/business-analyse` does not produce `apiEndpoints`, generate them from use cases + entities:
+
+```javascript
+// For each use case, derive the API endpoint:
+// UC "Create Employee" -> POST /api/{app}/{module}
+// UC "List Employees"  -> GET  /api/{app}/{module}
+// UC "Update Employee" -> PUT  /api/{app}/{module}/{id}
+// UC "Delete Employee" -> DELETE /api/{app}/{module}/{id}
+// UC "Get Employee"    -> GET  /api/{app}/{module}/{id}
+
+// Use permission paths from permissions.json to determine operations
+// Map CRUD operations to HTTP methods
+```
+
+### 3. Map Specification to Files (8 Categories)
 
 > **Reference:** Read `references/handoff-file-templates.md` for complete JSON templates.
 > All backend paths MUST include `{ApplicationName}/` hierarchy.
 
 | Category | Source | Key rules |
 |----------|--------|-----------|
-| **Domain** | `analysis.entities[]` | Entities, ValueObjects, Enums |
-| **Application** | `analysis.useCases[]` | Services, DTOs, Validators |
-| **Infrastructure** | `analysis.entities[]` | EF Configurations, DbSet |
-| **API** | `specification.apiEndpoints[]` | Controllers (exact copy) |
-| **Frontend** | `specification.uiWireframes[]` | Pages, Components, Hooks; split by file (NOT monolithic) |
-| **SeedData** | `specification.seedDataCore` | CORE (2 app-level + per-module) + business |
+| **Domain** | `entities.json > entities[]` | Entities, ValueObjects, Enums |
+| **Application** | `usecases.json > useCases[]` | Services, DTOs, Validators |
+| **Infrastructure** | `entities.json > entities[]` | EF Configurations, DbSet |
+| **API** | Generated from useCases + entities | Controllers |
+| **Frontend** | `screens.json > screens[]` | Pages, Components, Hooks; split by file (NOT monolithic) |
+| **SeedData** | Generated from entities + permissions | CORE (2 app-level + per-module) + business |
 | **Tests** | All layers | Unit, Integration, Security tests |
 | **Documentation** | All layers | Technical docs, user guides, API specs (can be empty `[]`) |
 
 **Frontend Task Splitting (MANDATORY):**
 - Each page as separate entry (not bundled mega-task)
-- Include `linkedWireframes[]` + `wireframeAcceptanceCriteria`
 - FK fields: `"fkFields": ["EmployeeId->Employee", "DepartmentId->Department"]`
 - ALL pages use `/ui-components` skill
 - Route wiring: separate entry in `filesToCreate.frontend`
@@ -81,27 +124,25 @@ For **EACH module** in topological order:
 
 **Documentation Category:**
 - Include `doc-data.ts` for documentation data export
-- Include API specification files if applicable
 - Can be empty `[]` if no documentation is planned at this stage
-- Will be populated later by `/documentation` skill after `/ralph-loop`
 
-### 3. Map Business Rules to Code
+### 4. Map Business Rules to Code
 
-> **Reference:** Read `references/handoff-mappings.md` — Section "Business Rules to Code Mapping"
+> **Reference:** Read `references/handoff-mappings.md` -- Section "Business Rules to Code Mapping"
 
-For each BR in `analysis.businessRules[]` of EACH module:
-- ruleId, title, module, severity (critical/high/medium/low)
+For each rule in `rules.json > rules[]` of EACH module:
+- ruleId, title, module, severity (from `rule.severity`)
 - implementationPoints: Array of {layer, component, method, implementation} across all layers
 
-### 4. Propagate personRoleConfig (GAP #2 Fix)
+### 5. Propagate personRoleConfig (GAP #2 Fix)
 
-For each entity in `analysis.entities[]`:
+For each entity in `entities.json > entities[]`:
 - IF entity has `personRoleConfig` property:
   - Copy verbatim into handoff entity data
-  - Ensures `/apex` and `/ralph-loop` receive person extension configuration
-  - See `references/handoff-mappings.md` — Section "Person Extension Mapping"
 
-### 5. Separate SeedData Core/Business (GAP #3 Fix)
+### 6. Generate SeedData Core/Business (GAP #3 Fix)
+
+Generate seed data from entities and permissions:
 
 Each seedData entry MUST include a `category` field:
 
@@ -114,12 +155,12 @@ Each seedData entry MUST include a `category` field:
 }
 ```
 
-- `category: "core"` — Navigation, Permissions, Roles (mandatory infrastructure)
-- `category: "business"` — Domain-specific reference/lookup data
+- `category: "core"` -- Navigation, Permissions, Roles (mandatory infrastructure)
+- `category: "business"` -- Domain-specific reference/lookup data
 
 > **Reference:** Read `references/handoff-seeddata-generation.md` for complete core seed generation.
 
-### 6. Map Entity to Domain File (GAP #4 Fix)
+### 7. Map Entity to Domain File (GAP #4 Fix)
 
 > **Reference:** Read `references/entity-domain-mapping.md` for complete mapping rules.
 
@@ -131,7 +172,7 @@ Each seedData entry MUST include a `category` field:
 | ValueObject | `src/Domain/{Module}/ValueObjects/{VOName}.cs` |
 | Enum | `src/Domain/{Module}/Enums/{EnumName}.cs` |
 
-### 7. Add Dependencies per File Entry (GAP #7 Fix)
+### 8. Add Dependencies per File Entry (GAP #7 Fix)
 
 Each file entry includes `dependencies[]` ordered by layer:
 
@@ -146,33 +187,35 @@ Each file entry includes `dependencies[]` ordered by layer:
 | tests | `["domain", "application", "infrastructure", "api"]` |
 | documentation | `[]` |
 
-### 8. API Endpoint Summary
-
-> **ABSOLUTE RULE:** Copy **EXACTLY** from `specification.apiEndpoints[]`. **NEVER** reinvent routes.
-
-For each endpoint: operation, method, route, linkedUC, linkedFR, permissions, requestSchema, responseSchema, errorCodes, module.
-
 ### 9. Write Handoff to Feature.json
 
 ```
 FOR i = 0 to modules.length-1:
   1. moduleCode = modules[i].code
-  2. moduleFeature = ba-reader.findFeature(modules[i].featureJsonPath)
-  3. Build handoff payload:
+  2. Build handoff payload:
      - complexity (from step 1)
      - filesToCreate (full 8-category structure, filtered for this module)
-     - brToCodeMapping (from step 3)
-     - apiEndpointSummary (from step 8)
+     - brToCodeMapping (from step 4)
+     - apiEndpointSummary (from step 2)
      - prdFile: ".ralph/prd-{moduleCode}.json"
      - totalFiles: count from filesToCreate
      - totalTasks: estimated from complexity
      - handedOffAt: ISO timestamp
-  4. Write via ba-writer.enrichModuleHandoff({ moduleFeatureId, handoffData })
-  5. Display: "handoff {i+1}/{N}: {moduleCode} ({fileCount} files)"
+  3. Write via ba-writer.enrichModuleHandoff({ moduleFeatureId, handoffData })
+  4. Display: "handoff {i+1}/{N}: {moduleCode} ({fileCount} files)"
 ```
 
 ### 10. POST-CHECK Per Module (BLOCKING)
 
+Run the **output** AC script from `references/acceptance-criteria.md`:
+
+```bash
+MODULE_JSON="{module_index_json_path}"
+node -e "
+// ... (output AC script from references/acceptance-criteria.md)
+" "$MODULE_JSON"
+```
+
 For each module, verify:
 
 ```javascript
@@ -183,20 +226,20 @@ if (!handoff || Object.keys(handoff).length === 0) {
   BLOCKING_ERROR("Module {moduleCode}: handoff is empty");
 }
 
-// 2. All 8 categories present
+// 2. All 8 categories present (AC-08)
 const categories = ['domain', 'application', 'infrastructure', 'api', 'frontend', 'seedData', 'tests', 'documentation'];
 const missing = categories.filter(cat => !handoff.filesToCreate[cat]);
 if (missing.length > 0) {
   BLOCKING_ERROR("Module {moduleCode}: missing categories: " + missing.join(', '));
 }
 
-// 3. BR-to-code mapping non-empty
+// 3. BR-to-code mapping non-empty (AC-09)
 if (!handoff.brToCodeMapping || handoff.brToCodeMapping.length === 0) {
   BLOCKING_ERROR("Module {moduleCode}: brToCodeMapping is empty");
 }
 
 // 4. Display pass
-console.log("POST-CHECK PASS: {moduleCode} — 8 categories, {brCount} BRs mapped");
+console.log("POST-CHECK PASS: {moduleCode} -- 8 categories, {brCount} BRs mapped");
 ```
 
 ---

package/templates/skills/ba-generate-html/html/src/partials/cadrage-risks.html

@@ -1,48 +0,0 @@
-                <!-- SECTION: Risques et hypotheses -->
-                <div class="section" id="cadrage-risks" style="display:none;" data-vibe-hide>
-                    <h2 class="section-title">Risques et hypotheses</h2>
-                    <p class="section-subtitle">Ce qui pourrait mal tourner et les certitudes non verifiees.</p>
-
-                    <h3 style="color: var(--text-bright); font-size: 1rem; margin-bottom: 0.75rem;">Risques identifies</h3>
-                    <div id="risksList"></div>
-                    <button class="add-btn" onclick="toggleForm('addRiskForm')">+ Ajouter un risque</button>
-
-                    <div class="inline-form" id="addRiskForm">
-                        <div class="inline-form-title">Nouveau risque</div>
-                        <div class="form-group">
-                            <label class="form-label">Description du risque</label>
-                            <input type="text" class="form-input" id="risk-desc" placeholder="Qu'est-ce qui pourrait mal tourner ?">
-                        </div>
-                        <div class="form-row">
-                            <div class="form-group">
-                                <label class="form-label">Probabilite</label>
-                                <select class="form-select" id="risk-probability">
-                                    <option value="high">Forte</option>
-                                    <option value="medium">Moyenne</option>
-                                    <option value="low">Faible</option>
-                                </select>
-                            </div>
-                            <div class="form-group">
-                                <label class="form-label">Impact</label>
-                                <select class="form-select" id="risk-impact">
-                                    <option value="high">Grave</option>
-                                    <option value="medium">Moyen</option>
-                                    <option value="low">Faible</option>
-                                </select>
-                            </div>
-                        </div>
-                        <div class="form-group">
-                            <label class="form-label">Mesure de prevention ou de reduction</label>
-                            <textarea class="form-textarea" id="risk-mitigation" placeholder="Comment prevenir ou reduire ce risque ?"></textarea>
-                        </div>
-                        <div class="form-actions">
-                            <button class="btn" onclick="toggleForm('addRiskForm')">Annuler</button>
-                            <button class="btn btn-primary" onclick="addRisk()">Ajouter ce risque</button>
-                        </div>
-                    </div>
-
-                    <h3 style="color: var(--text-bright); font-size: 1rem; margin: 2rem 0 0.75rem;">Hypotheses a verifier</h3>
-                    <div class="card">
-                        <div class="editable" contenteditable="true" data-field="risks.assumptions" data-placeholder="Quelles hypotheses faites-vous sur ce projet sans les avoir verifiees ? (une par ligne)"></div>
-                    </div>
-                </div>