@atlashub/smartstack-cli 4.43.0 → 4.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "4.43.0",
+  "version": "4.45.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",

package/templates/agents/ba-writer.md

@@ -471,11 +471,11 @@ Perform these structural checks before every write:
 - relationships[]: REQUIRED `target`, `type`, `description`
 - FORBIDDEN: `values` (use `validation`), `rules` (use `validation`)
 
-**analysis.businessRules** in rules.json — REQUIRED: `id`, `name`, `category`, `statement`, `priority`
+**analysis.rules** in rules.json — Root key: `rules[]` — REQUIRED: `id`, `name`, `category`, `statement`, `priority`
 - OPTIONAL: `conditions[]`, `examples[]`, `testability`
 - category values: `validation`, `calculation`, `workflow`, `security`, `data` (lowercase only)
-- FORBIDDEN: `rule` (use `name`+`statement`), `condition` singular (use `conditions[]`)
-- AUTO-MAP: `rule` → split into `name` (short) + `statement` (IF/THEN)
+- FORBIDDEN: `rule` (use `name`+`statement`), `condition` singular (use `conditions[]`), `businessRules` as root key (use `rules`)
+- AUTO-MAP: `rule` → split into `name` (short) + `statement` (IF/THEN), `businessRules` → rename to `rules`
 
 **specification.useCases** in usecases.json — REQUIRED: `id`, `name`, `primaryActor`, `permission`, `preconditions[]`, `postconditions[]`, `mainScenario[]`
 - OPTIONAL: `alternativeScenarios[]`, `errorScenarios[]`, `linkedRules[]`
@@ -489,14 +489,18 @@ Perform these structural checks before every write:
 - FORBIDDEN: `name` (use `statement`), `linkedUCs` (use `linkedUseCases`), `linkedBRs` (use `linkedRules`)
 - AUTO-MAP: `name` → `statement`, `linkedUCs` → `linkedUseCases`, `linkedBRs` → `linkedRules`
 
-**specification.permissionMatrix** in permissions.json — REQUIRED shape: `{permissions[], roleAssignments[]}`
-- permissions[]: `{path, action, description}`
-- roleAssignments[]: `{role, permissions[]}`
-- FORBIDDEN: flat array format, top-level `roles` key
+**specification.permissionMatrix** in permissions.json — Root keys: `permissionPaths[]`, `roles[]`, `matrix[]`
+- permissionPaths[]: array of permission path strings (e.g., `"crm.contacts.read"`)
+- roles[]: array of role definitions `{role, level}`
+- matrix[]: array of `{role, permissions[]}` assignments
+- FORBIDDEN: flat array format, `permissionSet` as wrapper, `actions` as root key
+- AUTO-MAP: `permissionSet.permissions[]` → extract `.code`/`.path` into `permissionPaths[]`, `permissions[{code}]` → extract into `permissionPaths[]`
 
-**specification.uiWireframes** in screens.json — REQUIRED: `screen`, `section`, `mockup`, `componentMapping[]`, `layout`
+**specification.uiWireframes** in screens.json — Root key: `screens[]` — each screen REQUIRED: `screen`, `section`, `mockup`, `componentMapping[]`, `layout`
 - componentMapping[]: `{wireframeElement, reactComponent}`
 - layout: `{type, regions[]}` where regions[]: `{id, position, span?, components[]}`
+- FORBIDDEN: `sections[].resources[]` as root structure (use `screens[]`)
+- AUTO-MAP: `sections[].resources[]` → flatten into `screens[]`
 
 **handoff** in handoff.json — REQUIRED: `complexity`, `filesToCreate`, `brToCodeMapping[]`, `apiEndpointSummary[]`, `prdFile`, `totalFiles`, `totalTasks`, `handedOffAt`
 - filesToCreate: REQUIRED 8 categories: `domain[]`, `application[]`, `infrastructure[]`, `api[]`, `frontend[]`, `seedData[]`, `tests[]`, `documentation[]`
@@ -598,21 +602,21 @@ Versions are stored as separate directories. Each directory contains index.json
 Before EVERY enrichSection() call for specification or handoff sections, validate referential integrity.
 
 ### After enrichSection("specification" or "usecases")
-1. Build SET_BR from rules.json businessRules[].id
+1. Build SET_BR from rules.json rules[].id
 2. For each useCases[].linkedRules[] → verify ∈ SET_BR
 3. For each functionalRequirements[].linkedRules[] → verify ∈ SET_BR
 4. Build SET_UC from usecases[].useCases[].id
 5. For each functionalRequirements[].linkedUseCases[] → verify ∈ SET_UC
-6. Build SET_PERM from permissions.json permissionMatrix.permissions[].path
-7. For each roleAssignments[].permissions[] → verify ∈ SET_PERM
-8. Build SET_SCREEN from screens.json uiWireframes[].screen
+6. Build SET_PERM from permissions.json permissionPaths[]
+7. For each matrix[].permissions[] → verify ∈ SET_PERM
+8. Build SET_SCREEN from screens.json screens[].screen
 9. For each sections[].wireframe → verify ∈ SET_SCREEN
 
 ### After enrichSection("handoff")
 1. Build SET_FR from specification functionalRequirements[].id
 2. Build SET_UC from specification useCases[].id
-3. Build SET_SCREEN from specification uiWireframes[].screen
-4. Build SET_BR from analysis businessRules[].id
+3. Build SET_SCREEN from specification screens[].screen
+4. Build SET_BR from analysis rules[].id
 5. For each filesToCreate.*[].linkedFRs[] → verify ∈ SET_FR
 6. For each filesToCreate.*[].linkedUCs[] → verify ∈ SET_UC
 7. For each filesToCreate.*[].linkedWireframes[] → verify ∈ SET_SCREEN

package/templates/skills/business-analyse/steps/step-00-init.md

@@ -1,7 +1,6 @@
 ---
 name: step-00-init
 description: Initialize Business Analysis - Auto-detect new/update, create index.json structure
-model: sonnet
 next_step: steps/step-01-cadrage.md
 ---
 

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

@@ -1,7 +1,6 @@
 ---
 name: business-analyse-handoff
 description: "Transform consolidated business analysis into handoff data (8 categories) and PRD files for /business-analyse-develop consumption."
-model: sonnet
 user_invocable: true
 ---
 

package/templates/skills/business-analyse-handoff/references/acceptance-criteria.md

@@ -10,14 +10,14 @@
 
 `/business-analyse` generates **separate JSON files** per module:
 
-| File | Content | Root key |
-|------|---------|----------|
-| `index.json` | Metadata, file references, summary | `metadata`, `files`, `summary` |
-| `entities.json` | Entity definitions | `entities[]` |
-| `rules.json` | Business rules | `rules[]` |
-| `usecases.json` | Use cases | `useCases[]` |
-| `permissions.json` | Roles and permission matrix | `roles[]`, `permissionPaths[]`, `matrix[]` |
-| `screens.json` | UI screen specifications | `screens[]` |
+| File | Content | Root key (canonical) | Accepted variants |
+|------|---------|----------------------|-------------------|
+| `index.json` | Metadata, file references, summary | `metadata`, `files`, `summary` | — |
+| `entities.json` | Entity definitions | `entities[]` | — |
+| `rules.json` | Business rules | `rules[]` | `businessRules[]` |
+| `usecases.json` | Use cases | `useCases[]` | `usecases[]` (lowercase) |
+| `permissions.json` | Roles and permission matrix | `permissionPaths[]` | `permissionSet.permissions[]`, `permissions[]`, `actions[]` |
+| `screens.json` | UI screen specifications | `screens[]` | `sections[].resources[]` |
 
 The validation script **assembles** these files before checking.
 
@@ -33,7 +33,7 @@ These verify data that `/business-analyse` produces:
 
 | # | Criterion | Minimum | Source File | Blocking |
 |---|-----------|---------|-------------|----------|
-| AC-01 | Entities present | 2 | `entities.json > entities[]` | YES |
+| AC-01 | Entities present | 1 (or referencedEntities) | `entities.json > entities[]` | YES |
 | AC-02 | Entity attributes have `type` field | ALL | `entities.json > entities[].attributes[].type` | YES |
 | AC-03 | Use cases present | 2 | `usecases.json > useCases[]` | YES |
 | AC-04 | Business rules present | 2 | `rules.json > rules[]` | YES |
@@ -85,19 +85,32 @@ const rulesData = loadFile('rules') || {};
 const permissionsData = loadFile('permissions') || {};
 const screensData = loadFile('screens') || {};
 
+// NORMALISATION: tolerate ba-writer + LLM field name variants
 const entities = entitiesData.entities || [];
-const useCases = usecasesData.useCases || [];
-const rules = rulesData.rules || [];
-const permissions = permissionsData.permissionPaths || permissionsData.permissions || [];
+const hasReferencedEntities = (entitiesData.referencedEntities || []).length > 0;
+const useCases = usecasesData.useCases || usecasesData.usecases || [];
+const rules = rulesData.rules || rulesData.businessRules || [];
+
+// Permissions: canonical permissionPaths[] OR extract from nested structures
+const permissions = permissionsData.permissionPaths
+  || (permissionsData.permissionSet && permissionsData.permissionSet.permissions || []).map(function(p) { return p.code || p.path || ''; })
+  || (permissionsData.permissions || []).map(function(p) { return typeof p === 'string' ? p : (p.code || p.path || ''); })
+  || (permissionsData.actions || []).map(function(a) { return a.code || ''; })
+  || [];
+
+// Screens: canonical screens[] OR flatten sections[].resources[]
 const screens = screensData.screens || [];
+const sectionsAsScreens = (screensData.sections || []).reduce(function(acc, s) { return acc.concat(s.resources || []); }, []);
+const allScreens = screens.length > 0 ? screens : sectionsAsScreens;
+
 const status = index.metadata?.status || 'unknown';
 
 const fails = [];
 
-// AC-01: Entities >= 2
-if (entities.length < 2) {
-  fails.push('AC-01: entities = ' + entities.length + ' (min: 2)');
-  console.error('FAIL: AC-01: entities >= 2 = ' + entities.length + ' (min: 2)');
+// AC-01: Entities >= 1 (exempt modules with referencedEntities - vue perso pattern)
+if (entities.length < 1 && !hasReferencedEntities) {
+  fails.push('AC-01: entities = ' + entities.length + ' (min: 1)');
+  console.error('FAIL: AC-01: entities >= 1 = ' + entities.length + ' (min: 1, no referencedEntities)');
 }
 
 // AC-02: Entity attributes have type
@@ -122,9 +135,9 @@ if (rules.length < 2) {
 }
 
 // AC-05: Screens >= 1
-if (screens.length < 1) {
-  fails.push('AC-05: screens = ' + screens.length + ' (min: 1)');
-  console.error('FAIL: AC-05: screens >= 1 = ' + screens.length + ' (min: 1)');
+if (allScreens.length < 1) {
+  fails.push('AC-05: screens = ' + allScreens.length + ' (min: 1)');
+  console.error('FAIL: AC-05: screens >= 1 = ' + allScreens.length + ' (min: 1)');
 }
 
 // AC-06: Permissions >= 1
@@ -145,7 +158,7 @@ if (fails.length > 0) {
   process.exit(1);
 }
 console.log('PASS: All input acceptance criteria met (AC-01 to AC-07)');
-console.log('  entities: ' + entities.length + ', useCases: ' + useCases.length + ', rules: ' + rules.length + ', screens: ' + screens.length + ', permissions: ' + permissions.length);
+console.log('  entities: ' + entities.length + (hasReferencedEntities ? ' (+ referencedEntities)' : '') + ', useCases: ' + useCases.length + ', rules: ' + rules.length + ', screens: ' + allScreens.length + ', permissions: ' + permissions.length);
 " "$MODULE_DIR"
 ```
 

package/templates/skills/business-analyse-handoff/steps/step-00-validate.md

@@ -1,7 +1,6 @@
 ---
 name: step-00-validate
 description: Detect input, validate BA readiness with flat-file support, AC gate
-model: sonnet
 next_step: steps/step-01-transform.md
 ---
 
@@ -78,13 +77,26 @@ For each module, load the separate JSON files referenced in `index.json > files`
 // Module index.json contains file references:
 // { "files": { "entities": { "path": "entities.json" }, "usecases": { "path": "usecases.json" }, ... } }
 
+const entitiesData = READ(moduleDir + '/entities.json');
+const usecasesData = READ(moduleDir + '/usecases.json');
+const rulesData = READ(moduleDir + '/rules.json');
+const permissionsData = READ(moduleDir + '/permissions.json');
+const screensData = READ(moduleDir + '/screens.json');
+
+// NORMALISATION: tolerate ba-writer + LLM field name variants
 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 || []
+  entities: entitiesData.entities || [],
+  hasReferencedEntities: (entitiesData.referencedEntities || []).length > 0,
+  useCases: usecasesData.useCases || usecasesData.usecases || [],
+  rules: rulesData.rules || rulesData.businessRules || [],
+  permissions: permissionsData.permissionPaths
+    || (permissionsData.permissionSet?.permissions || []).map(p => p.code || p.path)
+    || (permissionsData.permissions || []).map(p => typeof p === 'string' ? p : (p.code || p.path))
+    || [],
+  screens: (screensData.screens || []).length > 0
+    ? screensData.screens
+    : (screensData.sections || []).flatMap(s => s.resources || [])
 };
 ```
 

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

@@ -1,17 +1,15 @@
 ---
 name: step-01-transform
 description: Build handoff data per module - 8 categories from flat BA files
-model: sonnet
 next_step: steps/step-02-export.md
 ---
 
-> **Context files:** `references/handoff-file-templates.md` | `references/handoff-mappings.md` | `references/handoff-seeddata-generation.md` | `references/entity-domain-mapping.md`
-
 # Step 01: Transform (Handoff Data Generation)
 
 ## MANDATORY EXECUTION RULES
 
 - **ALWAYS** process modules in topological order (dependencies first)
+- **ALWAYS** delegate each module to an **isolated Agent** (context isolation — CRITICAL for large projects)
 - **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 entities
@@ -19,270 +17,167 @@ next_step: steps/step-02-export.md
 - **ALWAYS** map entity to domain file path (1:1)
 - **ALWAYS** include dependencies[] per file entry
 - **NEVER** invent entities/BRs not in module JSON files
+- **NEVER** load all module data in the main conversation (causes context overflow on 5+ modules)
 - **ALWAYS** generate API endpoints from use cases + entities (BA does not produce apiEndpoints)
 
 ## YOUR TASK
 
-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.
+Orchestrate the transform: determine module order, then delegate each module's transform to an Agent with isolated context. This prevents context accumulation across modules.
 
 ---
 
-## 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
+## CONTEXT ISOLATION ARCHITECTURE
 
-// Read with explicit error detection (do NOT silently swallow parse failures)
-const entitiesFile = READ(moduleDir + '/entities.json');
-const usecasesFile = READ(moduleDir + '/usecases.json');
-const rulesFile    = READ(moduleDir + '/rules.json');
-const permissions  = READ(moduleDir + '/permissions.json');
-const screensFile  = READ(moduleDir + '/screens.json');
-
-// Log missing files explicitly before falling back
-if (!entitiesFile) console.warn("⚠ " + moduleDir + "/entities.json not found — using empty");
-if (!usecasesFile) console.warn("⚠ " + moduleDir + "/usecases.json not found — using empty");
-if (!rulesFile)    console.warn("⚠ " + moduleDir + "/rules.json not found — using empty");
-
-const entities = (entitiesFile?.entities) || [];
-const useCases = (usecasesFile?.useCases) || [];
-const rules    = (rulesFile?.rules) || [];
-const screens  = (screensFile?.screens) || [];
+```
+Main conversation (orchestrator):
+  ├─ Determine topological order
+  ├─ FOR each module:
+  │   └─ Agent(ba-writer) ──► reads 5 files, builds handoff, writes result
+  │                           (isolated context: ~500-1000 lines per module)
+  └─ Collect results, display summary
 ```
 
-**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[]` |
+**WHY:** A 10-module project has ~10K lines of JSON data. Loading all at once exceeds Sonnet's effective context. Processing one module per Agent keeps each invocation under ~2K lines.
 
 ---
 
 ## EXECUTION SEQUENCE
 
-For **EACH module** in topological order:
+### 1. Determine Module Processing Order
 
-### 1. Calculate Complexity
+From step-00 data, extract the topological order of modules. Display:
 
-```json
-{
-  "complexity": "simple|medium|complex",
-  "complexityDetails": {
-    "entities": {count},
-    "useCases": {count},
-    "businessRules": {count},
-    "calculated": "{level} (entities<=X, UCs<=Y, BRs<=Z)"
-  }
-}
 ```
+Module processing order:
+  1. {module1} (0 dependencies)
+  2. {module2} (depends on: module1)
+  ...
+```
+
+### 2. Process Each Module via Agent
 
+For **EACH module** in topological order, use the **Agent tool** (subagent_type: `ba-writer`) with the following prompt structure:
+
+```
+Transform module "{moduleCode}" for handoff.
+
+## Input
+- Module BA directory: {moduleDir}
+- Application code: {appCode}
+- Application name: {appName}
+- Feature description: {featureDescription}
+- Module index: {moduleDir}/index.json
+
+## Instructions
+Read the following 5 files from {moduleDir}:
+  1. entities.json → entities[]
+  2. usecases.json → useCases[]
+  3. rules.json → rules[]
+  4. permissions.json → roles[], matrix[], permissionPaths[]
+  5. screens.json → screens[]
+
+Then build the handoff data following these rules:
+
+### Complexity
 | Criteria | Simple | Medium | Complex |
 |----------|--------|--------|---------|
 | Entities | <=3 | <=6 | >6 |
 | Use Cases | <=5 | <=12 | >12 |
 | Business Rules | <=10 | <=20 | >20 |
 
-**Global complexity** = highest across all modules.
-
-### 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
-```
-
-### 2b. Enrich Sections with UC/BR Links
-
-Using `sectionCode` from usecases.json and rules.json, link each UC and BR to its section:
-
-```javascript
-// Build section-level UC/BR mapping
-const sectionMap = {};
-for (const section of screens) {
-  sectionMap[section.sectionCode || section.code] = {
-    useCases: useCases.filter(uc => uc.sectionCode === (section.sectionCode || section.code)).map(uc => uc.id),
-    businessRules: rules.filter(br => br.sectionCode === (section.sectionCode || section.code)).map(br => br.id)
-  };
-}
-// Attach to sections for PRD consumption
-```
-
-> This mapping enables business-analyse-develop's section-splitting to know which UCs/BRs belong to which section.
+### API Endpoints (generate from use cases)
+- UC "Create X" → POST /api/{app}/{module}
+- UC "List X"   → GET  /api/{app}/{module}
+- UC "Update X" → PUT  /api/{app}/{module}/{id}
+- UC "Delete X" → DELETE /api/{app}/{module}/{id}
+- UC "Get X"    → GET  /api/{app}/{module}/{id}
+- Use permission paths from permissions.json
 
-### 3. Map Specification to Files (8 Categories)
+### Section UC/BR Enrichment
+Using sectionCode from usecases.json and rules.json, link each UC and BR to its section.
 
-> **Reference:** See loaded context `handoff-file-templates.md` for complete JSON templates.
-> All backend paths MUST include `{ApplicationName}/` hierarchy.
+### File Mapping (8 Categories)
+Read `references/handoff-file-templates.md` for complete JSON templates.
+All backend paths MUST include {ApplicationName}/ hierarchy.
 
 | Category | Source | Key rules |
 |----------|--------|-----------|
-| **Domain** | `entities.json > entities[]` | Entities, ValueObjects, Enums |
-| **Application** | `usecases.json > useCases[]` | Services, DTOs, Validators |
-| **Infrastructure** | `entities.json > entities[]` | EF Configurations, DbSet |
+| **Domain** | entities[] | Entities, ValueObjects, Enums |
+| **Application** | useCases[] | Services, DTOs, Validators |
+| **Infrastructure** | 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** | screens[] | Pages, Components, Hooks; split by file (NOT monolithic) |
+| **SeedData** | entities + permissions | CORE + business (include category field) |
+| **Tests** | All layers | Unit, Integration, Security |
+| **Documentation** | All layers | Technical docs (can be empty []) |
 
-**Frontend Task Splitting (MANDATORY):**
-- Each page as separate entry (not bundled mega-task)
-- FK fields: `"fkFields": ["EmployeeId->Employee", "DepartmentId->Department"]`
-- ALL pages use `/ui-components` skill
-- Route wiring: separate entry in `filesToCreate.frontend`
+Frontend: each page as separate entry, FK fields, ALL pages use /ui-components.
+Routes: PascalCase module codes → kebab-case (NEVER include /business/ prefix).
 
-**Route Convention (CRITICAL):**
-- Transform PascalCase module codes to kebab-case in NavigationModule/Section routes
-- Example: `"HumanResources"` -> `"/human-resources"` (NEVER include `/business/` prefix)
+### BR-to-Code Mapping
+Read `references/handoff-mappings.md` for mapping rules.
+For each rule: ruleId, title, module, severity, implementationPoints[].
 
-**Documentation Category:**
-- Include `doc-data.ts` for documentation data export
-- Can be empty `[]` if no documentation is planned at this stage
+### personRoleConfig
+If entity has personRoleConfig, copy verbatim into handoff.
 
-### 4. Map Business Rules to Code
+### SeedData
+Read `references/handoff-seeddata-generation.md` for core seed generation.
+- category: "core" → Navigation, Permissions, Roles
+- category: "business" → Domain-specific data
 
-> **Reference:** See loaded context `handoff-mappings.md` -- Section "Business Rules to Code Mapping"
-
-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
-
-### 5. Propagate personRoleConfig (GAP #2 Fix)
-
-For each entity in `entities.json > entities[]`:
-- IF entity has `personRoleConfig` property:
-  - Copy verbatim into handoff entity data
-
-### 6. Generate SeedData Core/Business (GAP #3 Fix)
-
-Generate seed data from entities and permissions:
-
-Each seedData entry MUST include a `category` field:
-
-```json
-{
-  "path": "src/Infrastructure/Persistence/Seeding/Data/NavigationApplicationSeedData.cs",
-  "type": "SeedData",
-  "category": "core",
-  "module": "shared"
-}
-```
-
-- `category: "core"` -- Navigation, Permissions, Roles (mandatory infrastructure)
-- `category: "business"` -- Domain-specific reference/lookup data
-
-> **Reference:** See loaded context `handoff-seeddata-generation.md` for complete core seed generation.
-
-### 7. Map Entity to Domain File (GAP #4 Fix)
-
-> **Reference:** See loaded context `entity-domain-mapping.md` for complete mapping rules.
-
-1:1 mapping from BA entity to Domain file:
-
-| BA Element | Domain File Path |
-|------------|-----------------|
-| Entity | `src/Domain/Entities/{App}/{Module}/{EntityName}.cs` |
-| ValueObject | `src/Domain/{Module}/ValueObjects/{VOName}.cs` |
-| Enum | `src/Domain/{Module}/Enums/{EnumName}.cs` |
-
-### 8. Add Dependencies per File Entry (GAP #7 Fix)
-
-Each file entry includes `dependencies[]` ordered by layer:
+### Entity Domain Mapping
+Read `references/entity-domain-mapping.md` for mapping rules.
+- Entity → src/Domain/Entities/{App}/{Module}/{EntityName}.cs
+- ValueObject → src/Domain/{Module}/ValueObjects/{VOName}.cs
+- Enum → src/Domain/{Module}/Enums/{EnumName}.cs
 
+### Dependencies per File Entry
 | Layer | Dependencies |
 |-------|-------------|
-| domain | `[]` (no dependencies) |
-| infrastructure | `["domain"]` |
-| application | `["domain"]` |
-| api | `["application"]` |
-| seedData | `["domain", "infrastructure"]` |
-| frontend | `["api"]` |
-| tests | `["domain", "application", "infrastructure", "api"]` |
-| documentation | `[]` |
+| domain | [] |
+| infrastructure | ["domain"] |
+| application | ["domain"] |
+| api | ["application"] |
+| seedData | ["domain", "infrastructure"] |
+| frontend | ["api"] |
+| tests | ["domain", "application", "infrastructure", "api"] |
+| documentation | [] |
+
+### Write Result
+Write via ba-writer.enrichModuleHandoff with the complete handoff payload:
+- complexity, filesToCreate (8 categories), brToCodeMapping, apiEndpointSummary
+- prdFile: ".ralph/prd-{moduleCode}.json"
+- totalFiles, totalTasks, handedOffAt (ISO timestamp)
+- featureDescription: {featureDescription}
+
+### POST-CHECK (BLOCKING)
+After writing, verify:
+1. Handoff not empty
+2. All 8 categories present
+3. brToCodeMapping non-empty
+4. Section resources have entity field
+Display: "POST-CHECK PASS: {moduleCode} -- 8 categories, {brCount} BRs mapped"
+```
+
+### 3. Display Progress
 
-### 9. Write Handoff to Feature.json
+After each Agent completes, display:
 
 ```
-FOR i = 0 to modules.length-1:
-  1. moduleCode = modules[i].code
-  2. Build handoff payload:
-     - complexity (from step 1)
-     - filesToCreate (full 8-category structure, filtered for this module)
-     - brToCodeMapping (from step 4)
-     - apiEndpointSummary (from step 2)
-     - prdFile: ".ralph/prd-{moduleCode}.json"
-     - totalFiles: count from filesToCreate
-     - totalTasks: estimated from complexity
-     - handedOffAt: ISO timestamp
-  3. Propagate featureDescription from app-level index.json:
-     ```javascript
-     handoffPayload.featureDescription = appIndex.metadata.featureDescription || null;
-     ```
-  4. Write via ba-writer.enrichModuleHandoff({ moduleFeatureId, handoffData })
-  5. Display: "handoff {i+1}/{N}: {moduleCode} ({fileCount} files)"
+handoff {i+1}/{N}: {moduleCode} ({fileCount} files) ✓
 ```
 
-### 10. POST-CHECK Per Module (BLOCKING)
+### 4. Display Summary
 
-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
-const handoff = moduleFeature.handoff;
-
-// 1. Handoff not empty
-if (!handoff || Object.keys(handoff).length === 0) {
-  BLOCKING_ERROR("Module {moduleCode}: handoff is empty");
-}
-
-// 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 (AC-09)
-if (!handoff.brToCodeMapping || handoff.brToCodeMapping.length === 0) {
-  BLOCKING_ERROR("Module {moduleCode}: brToCodeMapping is empty");
-}
-
-// 4. Validate section resources have entity field (enables section-splitting)
-const sections = screens || [];
-for (const section of sections) {
-  for (const resource of (section.resources || [])) {
-    if (!resource.entity) {
-      BLOCKING_ERROR("Module {moduleCode}, section {section.code}: resource {resource.code} missing 'entity' field");
-    }
-  }
-}
-
-// 5. Display pass
-console.log("POST-CHECK PASS: {moduleCode} -- 8 categories, {brCount} BRs mapped, {sections.length} sections validated");
+================================================================
+  TRANSFORM COMPLETE
+================================================================
+Modules processed: {N}/{N}
+Total files mapped: {totalFiles}
+Global complexity: {highest_complexity}
+================================================================
 ```
 
 ---

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

@@ -1,7 +1,6 @@
 ---
 name: step-02-export
 description: Generate PRD files, verify integrity, output progress tracker and manifest
-model: sonnet
 ---
 
 > **Context files:** `references/prd-generation.md` | `templates/tpl-progress.md`

package/templates/skills/business-analyse-review/steps/step-00-init.md

@@ -1,7 +1,6 @@
 ---
 name: step-00-init
 description: Initialize review workflow — locate ba-review.json, detect feature, set variables
-model: sonnet
 next_step: steps/step-01-apply.md
 ---
 

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

@@ -1,7 +1,6 @@
 ---
 name: business-analyse-status
 description: Display the current state of business analysis cycle, show progress per module, and recommend next steps.
-model: sonnet
 user-invocable: true
 ---